Bug Fixes (BREAKING)
-
share received packs and shallow metadata
A straight-forward wiring of thecore.sharedRepositoryflag.Fetching into a shared repository must make received packs, pack indices, and
shallow boundaries accessible according tocore.sharedRepository.Pass the repository policy through pack-writing and protocol-fetch options.
Create immutable pack and index files with appropriate initial permissions,
share new destination directories, and keep.keepmarkers private. Preserve
pre-existing markers and their ownership so the receiver does not remove another
operation's marker. A tempfile constructor accepts creation permissions without
bypassing the process umask. -
apply sharing to loose object writes
A very straight-forward wiring of shared repository permissions down to loose
object writes.Shared refs are insufficient when loose objects remain private. Propagate the
resolved repository policy through object-store initialization and each handle's
loose-object writes, applying it before publishing objects and to newly created
fanout directories.Keep objects read-only. Runtime configuration changes and reloads affect the
next write through the current handle without changing other handles, including
cloned and thread-safe round trips. Cover both object hash formats and update
the existing repository-size guard for the measured Windows layout. -
preserve configuration permissions during branch deletion and clone
Straightforward, it leverages the newconfig_file_mut()to change the configuration,
which automatically feeds the lock file with the shared permissions settings.Deleting branch configuration and adopting a cloned remote's object format
must preserve an existing configuration file's explicit permissions, even when
core.sharedRepositoryis enabled.Use the existing
FileTransactionfor both updates. This preserves the
configuration mode and follows the transaction's symlink and locking behavior
while retaining branch deletion's partial-success error reporting. Regression
coverage checks that an explicit0600config stays private, matching Git. -
apply sharing to reference, index, and worktree writes
This change is mostly tests, and theshared_repository_permissionswired through
togix-index,gix-mergeandgix-ref.
Tests mostly rubber-stamped, but made it use test scripts more.Reference, index, and linked-worktree metadata writes must apply the effective
core.sharedRepositorypolicy after the process umask so other users can access
shared repository data.Cache the parsed policy in
gix, refresh it after configuration changes, and
pass it through loose and packed references, reflogs, clone checkout, status
index updates, and the CLI and Tix index writers. Avoid redundant permission
changes on already-shared reflogs owned by another user. Standalone index
writers retain process-umask behavior by passing0.Apply the same policy when preparing linked-worktree directories and linking
files, writingHEADand the index, and copying worktree configuration. Keep
the private Git directory and checked-out contents at ordinary filesystem
permissions. Include Git-baseline coverage and the deliberate extension of
sharing to worktree linking files. -
reject symlinks in configured submodule paths
- Some API modifications to capture optionality of worktree directories with type system
- mostly rubber-stamped tests, based on their titles
Submodule inspection must validate the configured worktree path before
using it to locate a repository. This addresses GHSA-2rx9-36wh-cm54.
The earlier trust fix in392336fb114already recomputes trust when
opening a submodule, but ownership checks cannot validate the selected
repository's relationship to the superproject.Check each configured path component before
looking for its.gitentry. Reject symlinks before normalizing away
parent components, permit missing paths for uninitialized submodules,
and preserve symlinks in the superproject's own path. The shared lookup
coversgit_dir_try_old_form(),state(),open(), andstatus(),
includingIgnore::All.The regression failed before this change. Its read-only fixture covers
13 path variants, also checked locally against Git's submodule helper.
Existing tests preserve uninitialized submodules, linked worktrees, and
independent trust determination.Git reference:
validate_submodule_path()insubmodule.cat
6de20f6092dcf9bdb1c8efe03db4b70c82b423dd(v2.56.0-116-g6de20f6092),
introduced ine8d0608944486019ea0e1ed2ed29776811a565c2.
At the same baseline,repo_worktree_path_append()inpath.cand
repo_submodule_init()inrepository.calso avoid worktree lookup and
use the modules-directory fallback without a worktree for bare parents.
The fixture comparison ran with Git 2.54.0 (Apple Git-157).
New Features (BREAKING)
-
configure extra monitor invalidations and selected worktrees
Definitely rubber-stamped tests, but otherwise looked at the new API and deemed it
fit. Added these capablities to the CLI as well for good measure.Downstream applications need to observe their own state files alongside Git
metadata, and some consume only a subset of a repository's linked checkouts.
Maintaining a separate watcher for application state adds adapter code; filtering
all-worktree outcomes still pays for excluded native coverage and filesystem
processing.Add
notify::InvalidationPathandOptions::additional_pathsto map application
files and recursively observed directories to caller-selectedChanges. Resolve
native paths at construction, advance coverage as missing parents appear, detect
atomic replacement, and preserve the configured invalidations through startup,
rescan, loss and recovery. Use the existing metadata subscription and debounce;
themetadata = falsesuppression contract still applies. Additional-only
coverage can run without opening a repository.Add
Options::worktree_filteras an optional allowlist of private Git directories
forall_worktrees. Excluded checkouts receive neither private metadata watches
nor checkout monitors. The primary repository and shared membership watches
remain covered. Child monitors do not inherit application invalidation paths. -
expose topological walks through
Repository- Simplified the
gix logcommand. - Removed unnecessary
rev_walk_topo(), as TopoOrder is a sorting mode.
Only read the test-case names, but took my time to peruse the tests and
fixtures. - Algorithmic changes were explained and make sense, but implementation is
rubber-stamped, knowing that regression-protection exists for performance. - Rubber-stamp for tests after reading their names, validating they are read-only.
Repository callers had to use the plumbing
Topobuilder to obtain Git's
topological or date ordering, duplicating traversal setup and bypassing
repository handling of replacements and shallow boundaries.Expose topological and date ordering through
Repository::rev_walk(tips)
withSorting::TopoOrderandSorting::DateOrder, sharing the builder
controls, iterator, errors, and attachedInfoacross sorting modes.gix logis a repository-backed revision walker with Git-style positional
revision expressions, exclusions, and ranges, plus---separated pathspecs.
Its--sortoption selectsbreadth-first,newest-first,oldest-first,
topo-order, ordate-order(the default).--first-parent,--tip, and
--hideremain available. Path-filtered history is not implemented yet and
reports an explicit error.Align
Topopredicates withSimple: reject a commit before looking it up
and prune that path, while allowing shared ancestors through other accepted
paths. Cache decisions in existing traversal flags across hidden-frontier
preparation and the walk. Hidden painting still follows all parents and
ignores the visible predicate. Read parent IDs for metadata without fetching
rejected parents, and limit first-parent metadata to one parent.Treat shallow commits as roots through a shared object finder, including
during hidden painting; attached object access retains the stored parents.
Disable optional commit graphs for shallow boundaries and replacements,
and honor disabled graph settings even when a graph was explicitly supplied.This adds variants to the exhaustive public
Sortingenum and changes the
plumbing predicate from output filtering to path pruning. First-parent and
shallow metadata now describe traversable parents. Callers wanting only
output filtering can filter the resulting iterator instead. - Simplified the
Changed (BREAKING)
-
change
gix_ref::ReferencetoReference<'repo>andattached.repoto.repo()
This commit is a bit rusehd, but needed to be a bit more consistent.
HeadOwned really needs more work, and so doesHead, but let's leave
it at this breaking change for now and safe the others for later.The auto-review also disliked the inconcistency possible with nested attached types, so repo
is read-only now.Symbolic
HEADand parsed revision specs now retaingix::Reference
values. Callers can use the same reference API as lookup and iteration,
andHeadcan peel its symbolic referent in place.Expose the owning repository through read-only
repo()accessors on
attached values and platforms. A fixed binding keeps object IDs,
reference edits, and reflog reads in the same repository, and keeps
reusable buffers tied to their original freelist.Use
Head::detach_repo()to keep an ownedHeadOwnedsnapshot across
repository lifetimes.HeadOwned::attach()binds the snapshot and its
symbolic referent together. The snapshot'sid()prefers a cached peeled
ID, including the commit ID for a packed annotated tag.Reference equality, ordering, and hashing use the underlying snapshot.
Attached and plumbing references can be compared directly, and name
comparisons still use only the reference name. Adaptgitoxide-core
and Tix callers to use the reference accessors and owned HEAD snapshots. -
gate the
gix::fsre-export behindunstable
Here was more to fix asunstablereally needs to be enabled within
the workspace, so tests and gitoxide-core + gitoxide can just use
the unstable version, forever.gixenablesgix-fs/unstablefor internal use. Re-exporting the
whole crate gives downstream users access to those experimental APIs
throughgix, even when they disable its default features.Make
unstablea default-enabledgixfeature for compatibility and
use it to gate only thegix::fsre-export.
Downstream crates in the workspace now enableunstable. -
reuse reference name storage during iteration
Turns an ownedReferenceinto a connected one, which allows buffer-reuse
during iteration. The re-use is limited to avoid it to pile up, and individual
reference are generally not linked to the freelist (i.e. won't return their allocation
for the name).Reference iteration reuses buffers from the repository freelist for ref
names and validated symbolic target names. Dropping a reference returns
the borrowed buffers. Newly allocated names are cached only while the
freelist holds fewer than two buffers, limiting retention when a
collection is dropped.The underlying
gix_ref::Referencenow lives behindinner()and
inner_mut(). Usedetach()to take ownership and
gix::prelude::ReferenceExt::attach()to attach a standalone reference.
Drop or consume the reference before mutably borrowing its repository.Peeling an individual reference reuses a repository buffer for object
lookups. A peeled iterator holds one scratch buffer and its packed-refs
snapshot across the scan.The freelist tests cover reference scans, object reads and writes, tree
lookup, and tag peeling. On macOS with SHA-1 and SHA-256 fixtures, the
packed and symbolic scans count zero allocations after the first item.
The direct loose scan across sibling directories counts 1,818 and fails
the zero-allocation assertion. -
replace discovery trust maps with callbacks
A long overdue cleanup on how discovery works in relation to trust,
which is both more powerful and easier to understand.Let callers choose how to open a repository once its initial trust has
been determined. Replacegix::sec::trust::Mappingwith a callback in
the two configurableThreadSafeRepositorydiscovery entry points
and inThreadSafeRepository::open_with_environment_overrides().
Apply the computed trust to the returned options. Adapt the CLI to
configure only the options for the selected level.Honor explicit opening trust in
gix::discover_opts()and in the new
gix::discover_with_environment_overrides_opts()function. Upward
discovery uses its own trust policy, while the environment-aware
function opens the repository selected byGIT_DIRdirectly when set. -
return
Repositoryfromopen::Options::open()Align direct opens through
open::Optionswithgix::open_opts()so
callers can use the repository APIs immediately. Callers that need a
ThreadSafeRepositorycan callRepository::into_sync()on the result. -
upgrade dependencies and require Rust 1.95
Complete the workspace dependency audit requested alongside the Jiff 1.0
migration. Upgradeparking_lotto 0.13.0,faster-hexto 1.0.0,sysinfo
to 0.40.3, andserial_testto 4.0.1.The runtime upgrades require Rust 1.95. Raise all 48 consuming workspace
packages, following normal and build dependencies including optional
features; preserve the existing MSRVs of the other 24 packages. Regenerate
the badge and remove feature documentation that now states lower minima.
Synchronization types exposed throughgix-parallelnow useparking_lot
0.13 andlock_api0.5, which is a public type compatibility change.Keep hash validation messages while adapting to
faster-hex's new errors,
update the packet-line diagnostic snapshot to include the offending byte
and its index, and use the current const-capable mutex constructor.
Propagatesysinfo's new CPU errors with runner context and keep hostname
lookup optional, so unavailable host details still become SQLNULL.
Use the larger duration units now required by Clippy at this MSRV. -
make repository option reuse explicit
Lot's of refactoring happened here, removing a footgun, and
the renaming of a builder that had it coming:with().The submodule-opening work exposed that
open::Optionsmixes reusable
configuration with state captured for one repository. Copying everything
can carry trust or a stale working directory into another repository.
Reopening the same repository needs to preserve that state deliberately.Use
Repository::reload()for plain reopens and add
Repository::reload_with()for changing options through a builder callback.
Both retain the repository's trust and path anchoring by default. Modified
options are retained for later reloads only after opening succeeds; failures
leave the existing handle unchanged. Adapt CLI configuration, object-store
refreshes, and clone object-format changes to these APIs.Remove
Clonefromopen::Options. Keepclone_with_trust()crate-private
for internal handle copies, and makeclone_without_trust()clear trust,
the captured CWD, and one-shot path and checkout policies. Permissions and
configuration overrides remain reusable. Supply the captured CWD explicitly
when opening submodules through the resolved-path initializer.Rename
Options::with()towith_trust()and accept
impl Into<Option<gix_sec::Trust>>, allowing aTrustvalue directly or
Noneto restore ownership checks. Document when to reload rather than copy
options, and cover successful and failed reloads, trust preservation, fresh
opening state, and path anchoring after a CWD change.
New Features
-
let callers configure related repository opens
Being able to control with which options sub-repositories are opened
closes a gap in how openeing worked before.Library callers can configure the initial repository open, but need a
way to apply their own trust and configuration policy when Gitoxide
opens a submodule or another worktree on their behalf.Pass the relationship, resolved paths, and trust information to an
optional callback before configuration loads. Allow it to modify the
target options, skip an optional open, or stop with an error. Keep
skips distinct from missing repositories so merge does not retry a
skipped submodule and worktree checks cannot silently omit a checkout. -
add discovery methods to
open::OptionsLet callers use the same configured
open::Optionsfor a direct open
or for repository discovery with the default search settings. Add
discover()for an upward search and
discover_with_environment_overrides()for Git environment-aware
selection. Exercise both methods through the trust and environment
integration tests. -
let callers enforce trust on direct opens
I think havingwith_enforced_trust()is good for the documentation alone,
as it explains what can happen if full trust is granted to an untrusted directory.Add
open::Options::with_enforced_trust()so callers can supply the final
trust decision for a known repository.with_trust()still supplies an
initial level thatsafe.directorycan promote and ownership of the
configured checkout can demote.Keep the enforced level on reload and let callers clear it with
None.
Strict opens reject enforcedReducedtrust. Discovery, submodules,
and other worktrees determine their trust independently of the override. -
add opt-in async filesystem notifications and monitoring
gix-notify
Mostly rubber-stamped the implementation, mild changes to internal API.
There aren't too many async related tests, but then again, I think it's enough
with the downstream tests piling on top of them. In the end, this is just an
adapter which for now has a certain expense to it, particularly when comparing
with bare blocking watchers. Probably worth it for the convenience when
integrating into a mostly async app.Applications maintaining repository views or serving Git's filesystem monitor
from async event loops need notification readiness, complete delivery fences,
and owned startup and shutdown without waiting for native work on executor
threads. Carry that support fromgix-notifythroughgix-fsmonitortogix,
while retaining the existing blocking APIs and their runtime-free builds.Use the existing native watchers and bounded queues behind a runtime-independent
gix-notify::asynchronous::Watcher. Synchronous initiation returns operations
supporting both futures and blocking waits; draining and lightweight callbacks
remain synchronous. A bounded control owner performs registration, native
synchronization, and teardown. Release its control slot before delivering a
completion so callers can immediately initiate the next operation.Share filesystem monitor event interpretation, coverage generations, journal
invalidation, token handling, fence consumption, cookie observation, and response
construction. Reusegix-macrosfor common orchestration and packet/hook logic,
with separate blocking and Tokio event loops and transports. Async clients use
bounded framing and exchange deadlines on Unix and Windows; server waits remain
driven by clients, notifications, shutdown, recovery, and idle deadlines.Treat cancellation as abandonment of a reply rather than cancellation of native
work. Retain undelivered registration diagnostics and native resource ownership.
Bound filesystem housekeeping with permits held through actual completion and
cookie cleanup; ingest batches before cancellable root checks and retain
conservative recovery state when those checks are interrupted. Completed but
unclaimed repository service results also release their watchers on workers.
Explicit async shutdown observes native teardown and endpoint cleanup.
Validate filesystem eligibility, including remote-worktree policy, on the
startup worker before acquiring an endpoint or native watches.Expose
async-notify,async-fsmonitor, andasync-fsmonitor-serveringix.
Repository notification service returns the owned monitor and complete outcome;
readiness waits use real publication and recovery deadlines. Repository server
startup captures detached context and can be spawned without retaining a
repository. Document feature/runtime requirements and end-to-end examples.
Async integration coexists with blocking execution and is excluded from normal
CLI and daemon feature bundles; both binaries continue using blocking APIs. -
start an application-owned filesystem monitor server
Split server context into its own method and made sure the endpoint selection
matches the one that clients expect.Rubber-stamp for tests.
Applications holding a repository can serve external Git clients without
reconstructing its private Git directory, shared directory, and filesystem
capabilities. AddRepository::fsmonitor_server()behind the opt-in
fsmonitor-serverfeature and re-export the supportinggix-fsmonitorAPI.Register native watches before returning the owned handle, forward idle
shutdown options, reject bare repositories, and retain no repository handle
after startup. Linked worktrees use their private administrative IPC endpoint.
Repository configuration remains under the caller's control; filesystem
monitor acceleration ingixstatus operations is a separate concern.Exercise the direct server alongside the repository daemon context and
command helpers, including endpoint selection, repository-handle lifetime,
idle shutdown, and bare-repository rejection. Include the daemon feature in
the independent native test configuration. -
monitor repository and linked-worktree changes
Removed a lot of API, and added an exmple program to try the watching in
real repositories. This led to various improvements to the implementation.
Also added a mode to watch all worktrees, and a way to selectively watch
only non-ignored directories while taking advantage of native recursion
capabilities of the watcher.
All tests are rubber-stamped, not even looked at actually, it's 2k SLOC of
production code/comments.Tix needs to keep history and worktree views current without retaining a
repository while idle. Make this reusable throughRepository::monitor()and
replace Tix's direct watcher management withgix::notify::RepositoryMonitor.The opt-in
notifyfeature provides detached monitoring with independently
selected metadata and worktree coverage.service()returns bounded cache
invalidations and diagnostics, reopening repositories only for maintenance;
next_timeout()supplies event-loop deadlines. Ignore-aware coverage follows
index and exclude rules, stops at nested repositories, and keeps index paths
in one compact buffer. Complete coverage uses recursive native watches without
index parsing. All-worktree monitoring shares metadata subscriptions while
reporting each checkout's inventory, lifecycle, and invalidations separately.Track local configuration, includes, ignore and attribute dependencies,
including missing candidates and symlink replacement, within the worktrees
and their private and shared Git directories. Refresh registrations after
relevant changes or coverage loss. Metadata uses bounded debouncing, failures
retry, andrescan()requests explicit recovery; no timer forces full scans.
Raw native events remain available throughgix::notify::plumbing. -
add exact ahead/behind commit counts
A lot of (now) read-only tests that validate is-ancestor and ahead-behind functionality,
withgix -tt status --ahead-behindto measure performance more easily in the real world.An ancestor check tells whether one history contains another, but branch
status also needs to quantify their divergence. Exact counting can walk
substantially more history, so make it a separate operation and keep its
cost opt-in for status.Expose
Repository::ahead_behind_counts()and its reusable-graph variant,
backed bygix_revision::ahead_behind_counts()andAheadBehindCounts.
Keep counts explicit in the API names so a future operation returning the
commits themselves remains distinct. Reuse cached commits and prune shared
history only when commit-graph generations make that safe; otherwise let
reachability settle before counting each exclusive commit once.Make repository ancestry and counting queries honor shallow boundaries
and active object replacements, even when given a graph populated from
unmodified history. Avoid incompatible commit-graph caches, treat shallow
commits as roots on demand, and stop counting at missing parents while
still validating both input commits and propagating lookup failures.Add
gix status --ahead-behindto report counts against the locally
available fetch upstream without fetching or doing this traversal during
ordinary status. Handle local upstreams and missing upstream references.Compare ancestry and counts with Git-generated baselines across divergent,
unrelated, shallow, and replacement histories, with fresh and reused
graphs. Cover uncached tips, unreliable generations, missing parents,
invalid inputs, unrelated malformed shallow boundaries, and opt-in CLI
tracing. -
add
Repository::is_ancestor()andRepository::is_ancestor_with_graph()
They answer whether one commit is reachable from another, likegit merge-base --is-ancestor,
without computing merge-bases and comparing them (see #2914). Like the merge-base methods,
the_with_graph()variant reuses a revision graph across calls to speed up repeated queries.is_ancestor()carries agit2alias forgraph_descendant_of(), which takes the descendant
first and doesn't consider a commit its own descendant. -
honor
init.defaultObjectFormatwhen initializing
Likegit init, new repositories now useinit.defaultObjectFormat
orGIT_DEFAULT_HASHif set.An explicitly requested object format still takes precedence.
The value is read from the configuration available before the
repository exists, so it is created in the right format directly.Clones ignore it, as they adopt the remote's object format. Otherwise
a SHA-256 default would make every clone fail in SHA-1-only builds. -
add
init.defaultObjectFormatconfig key
Like in Git,GIT_DEFAULT_HASHoverrides it.
Values are parsed like those ofextensions.objectFormat.Unlike Git, invalid configuration values are an error instead of a
warning followed by a fallback to SHA-1. As a library,gixhas no
channel to show such a warning, so the fallback would silently create a
repository in an object format the user didn't ask for.Invalid
GIT_DEFAULT_HASHvalues are an error in Git as well.
Bug Fixes
-
reselect the checkout after repository trust drops
I think this cleans up the worktree search logic, despite its complexity,
and almost definitely handles the trust checks around it correctly.Tests seem fine, even though admittedly sometimes assertions can flip-flop
and we are clearly in unchartered territorry here as Git does not have this
concept. I should probably put more time into it, but for now this is hopefully
better than before as it doesn't lead to undue trusted directories.A checkout ownership check can lower repository trust and make the
section that suppliedcore.worktreeineligible. Keeping the selected
path still directs worktree operations to that checkout.Repeat checkout selection with the reduced section trust and the
original inferred path. Cover the inferred fallback on demotion and
keep coverage for missing paths supplied by an eligible section. -
use the platform default for symlinks without a probe result
Ifcore.symlinkshas no usable value, use the platform default when the
worktree probe is skipped or cannot inspect or remove its temporary link.
This follows Git’s platform-dependent default instead of assuming symlink
support on Windows.An explicit configuration value or a completed probe still takes precedence,
including when the worktree cannot create the temporary symlink. -
honor section trust in checkout and submodule settings
Don't trust submodule settings that affect what is fetched and where from.
Also removed some archives that didn't need to be there.Repository-local values could change symlink checkout behavior, affect
submodule activation and configured state, or conceal submodule changes
in status even when the section filter rejects their source.Apply the repository's section filter to these reads and to the
fetch.recurseSubmodulesfallback. Use the same eligible submodule
sections when building the activation pathspec and checking each module. -
apply final repository trust to configuration
Rubber-stamped tests, but looked carefully at everything else and
fixed a shortcoming of 'overfit' code.
Let's see if this now cuts it better, and if not, it's one test
closer each time.A late checkout ownership check could leave repository-local settings
eligible for trust-filtered reads after lowering repository trust.
Protectedsafe.directoryapproval also came too late to enable
core.worktreeor the cached reference namespace.Approve known repository paths before selecting the checkout, and
synchronize local and worktree sections after checking the selected
path. Initialize cached values only after that final check. -
honor sharing during repository initialization
Scrubbed through this quickly, as it's completely internal and seems to follow the
typical playbook of wiring the shared config settings up.
Tests are barely looked at .Initialization must resolve
core.sharedRepositorybefore it creates repository
metadata; adjusting later writes leaves the Git directory, configuration, and
template files inaccessible under a restrictive umask.Load the permitted configuration scopes first, apply the sharing policy to the
Git root and its metadata, and persist active sharing as Git does. Destination
ancestors and the configuration-independent creation entry point retain their
ordinary umask behavior.Add a reusable subprocess helper for umask-sensitive tests, avoiding
process-wide umask changes in concurrent tests. Compare initialized repositories
and cloned metadata with Git under restrictive and ordinary umasks. -
honor configuration trust for security-sensitive settings
Took a close look and now requiring the author/committer information to be
trusted as well.
Took a look at the titles of the tests, and it appears each trusted key
now has a read-only test as well. Fair enough.The
gpg.minTrustLevelingix0.90.0 is read without
the repository's section filter, although verifier programs and SSH trust
files are filtered. A later reduced-trust value can lower a trusted
verification threshold and makeOutcome::is_valid()accept a signature
that the caller's policy rejects.Apply the existing section filter to verification and signing policy,
including the identity used to choose a default signing key. Extend the
audit to branch remote/upstream/push selection, reference namespaces,
pathspec defaults and their subprocess environment, conversion safety
checks, and index checksum reads/writes. Preserve ordinary identity
resolution and the behavior of eligible configuration.Regression tests first demonstrated each bypass. They cover a real SSH
signature, earlier trusted versus later untrusted settings, custom section
filters, invalid rejected values, irreversible CRLF conversion, and
corrupted or refreshed index checksums. Fixtures remain isolated; read-only
operations use read-only fixtures and configuration changes stay in memory.Git reference:
6de20f6092dc(v2.56.0-116-g6de20f6092),
gpg-interface.c,Documentation/config/gpg.adoc, and
t/t7510-signed-commit.sh. Git defines the same trust-level ordering but
normally rejects untrusted repositories through its ownership checks.
This change enforcesgix's documented policy for safely opening them. -
honor directory hints in
AttributeStack::at_entry()The reproduction in #3189 queries an absent
absent/target/under a
target/ignore rule.AttributeStack::at_entry(path, None)reports it
as included even though its documentation andgit check-ignore --no-index
identify the trailing slash as a directory hint. The wrapper forwards the
unknown mode toat_path(), which assumes a file.Use
ToNormalPathComponents::ends_with_separator()to inferMode::DIR
before passing the path to the underlying stack, only when the caller
supplies no mode. This also recognizes native Windows backslashes while
retaining all supported input types. Explicit modes take precedence, and
at_path()keeps its existing behavior.Git reference: the local Git checkout identifies itself as
2.55.0.782.g1630431f32.dirty;builtin/check-ignore.ccalls
last_matching_pattern()indir.c, whose directory-only rules require
DT_DIR. The executable baseline is Apple Git2.54.0, which ignores
absent/target/and leavesabsent/targetincluded in the fixture. -
accept Git's whitespace in
core.checkRoundtripEncodingThe encoding migration exposed that this list only recognized literal spaces
and commas. Git also treats tabs, carriage returns, and line feeds as list
separators, so valid configurations could fail before a filter was created.
Reusegix_utils::git_is_space()to retain Git's exclusion of form feed and
vertical tab as well. -
give public API types nameable paths
A downstream caller reported that the interrupt flag accepted by
Repository::dirwalk_iter()could only be constructed through inference.
Clippy'sdefault_trait_accesssuggestion could not compile because
OwnedOrStaticAtomicBoollived in the privateutilmodule.Re-export it from
gix::interruptand make the existing directory-walk
integration test name it explicitly. That test failed to compile before
the re-export and now passes in serial and parallel configurations.
Keep the flag's variants and conversions unchanged.The requested scan for similar cases found configuration validators and
public return or associated types hidden behind private modules. Give
those types public paths ingix,gix-fs,gix-hash,gix-imara-diff,
gix-index,gix-pack,gix-packetline,gix-parallel, andgix-protocol.
Keep thegix-fswrappers behind its existingunstablefeature, with
an introduction date from Git history. Add documentation for the newly
nameable APIs without changing their behavior.Enable
unnameable_typesfor the workspace to catch future omissions.
Document intentional exceptions for sealed supertraits ingixand
gix-ref. Restrict CLI conversion types and protocol test helpers to
crate visibility, since they have no public API role; remove an unused
public test-helper re-export. -
keep the refspecs of configured remotes in their configured order
-
resolve rename modes and limits independently
Removed the elaborate tests for this trivial change, as I don't expect it
to regress. And before that has a chance to happen, tests can always be regenerated.While investigating status configuration for #3133, edited staged renames
showed that correcting the section names was insufficient: a standalone
status.renameLimitwas still ignored. A status-specific mode also
prevented falling back todiff.renameLimit. The shared resolver had the
same problem for diff and merge limits, silently ignoring their limits
unless a correspondingrenameskey was also set.Resolve rename mode and limit independently in the existing shared helper.
Unset status/merge keys each fall back to the corresponding diff key.
A configured limit uses the default rename mode when no mode is set.
Retain explicit disabling, strict/lenient validation, copy settings, and
the public helper's empty-configuration signal. Remove redundant whole-
configuration fallback from the status and merge callers.Git 2.54.0 is the executed baseline. Git's
builtin/commit.c::git_status_config()resolves status mode and limit
separately, andmerge-ort.c::merge_options_init()readsdiff.renamelimit
followed bymerge.renamelimitindependently of rename mode. -
read status rename keys from the status section
Removed the test as this is a trivial change. While it's now defintely
untested, I found it overkill.Consumers of
Repository::status()reported thatstatus.renames=false
still paired staged renames, while unrelatedmerge.renamessettings
changed status results. They had to resolve configuration themselves and
pass explicit rename options as a workaround.Both
Status::RENAMESandStatus::RENAME_LIMITwere accidentally attached
to themergesection. Attach them tostatus, preserving the existing
fallback todiff.renameswhen status rename tracking is unset. -
recompute trust when staging embedded repositories
The caller audit after GHSA-2rx9-36wh-cm54 found another repository open
that copied the parent's determined trust. AlthoughSubmodule::open()
already clearsgit_dir_trust,Pipeline::worktree_file_to_object()
cloned its options unchanged when turning directories into gitlinks.
This bypasses independent ownership-based trust determination and also
affectsgix-tixstaging.Clear cached trust and repository-local environment overrides before
opening the embedded repository, matchingSubmodule::open(). Keep
Options::Cloneunchanged and preserve intentional API configuration.
Path validation and trust determination protect different boundaries.The public regression observes trust through a configuration-section
filter while opening a fixture submodule. It failed with inherited
Reducedtrust, despite the child being owned by the current user, and
now sees independently determinedFulltrust. Existing opening-path
and reload regressions continue to pass. -
validate gitlinks before worktree removal safety probes
Improved performance by reducing IO and avoided in-Rust fixture creation,
let's just stick to the current patterns.The submodule caller audit traced Git's removal checks and exposed an
analogous unchecked lookup in linked-worktree removal. When no private
modulesdirectory exists,has_populated_submodule()probes each index
gitlink's.gitentry. A symlink could select an unrelated repository.Validate each gitlink's checkout path before probing it. Existing
conservative handling of stored submodule state and unpopulated gitlinks
remains intact.The regression failed before the fix with a populated-submodule conflict
after following the link. It now expects a validation error and verifies
that the checkout, registration, and unrelated repository are preserved. -
reject symlinked ancestors during file-to-object conversion
The submodule path audit found
Pipeline::worktree_file_to_object()
opening embedded repositories without validating their worktree paths.
This API is also used bygix-tixwhen staging changes. A directory link
could redirect both repository lookup and ordinary file reads.Validate the parent before metadata or reads, retaining trackable leaf
symlinks. Validate the entire directory path before opening an embedded
repository. Reject paths without a file name and paths escaping the root;
keep the original spelling so trailing separators cannot bypass checks.The regression failed before the fix by turning the repository behind a
directory symlink into a gitlink. It covers repository, file, and leaf-link
lookups through ancestors, trailing separators, dot/parent aliases, and
invalid root-only paths; existing valid leaf-link behavior still passes.
Run the writable fixture directly because its FIFO cannot be copied. -
validate unconfigured gitlink paths during status
- implementation is trivial, but was improved by refactor as it wasn't handling
all worktree cases correctly. - test is quite simple and seems fine, but it's mostly a rubber-stamp as well.
- This really expanded and probably fixed a lot of open-related inconsistencies
The Git caller audit for GHSA-2rx9-36wh-cm54 exposed unvalidated paths in
BuiltinSubmoduleStatus's unconfigured-gitlink fallback. Public-provider
validation must not depend on cached traversal.Share path validation, gitfile resolution, and opening with configured
submodules. Open the known Git directory and worktree checkout directly, preserving
core.worktreeprecedence and relative/symlink-sensitive paths. Recompute
trust from the original.gitentry, resolved Git directory, and common
directory; check the effective checkout after configuration, including
retained bare-submodule checkouts.Normalize paths only for configuration matching so gitfile targets containing
..honorcore.worktree. Preserve the parent worktree, includingNone, in
serial/parallel status. Suppress only top-level not-found errors, not invalid
configuration.Regressions cover symlinks, gitfile/worktree overrides, missing and bare
checkouts, and relative/detached paths, with Git comparisons where applicable. - implementation is trivial, but was improved by refactor as it wasn't handling
-
accept booleans for
status.showUntrackedFilesIssue #3128 reported that
gix statusstill listed an untracked file
afterstatus.showUntrackedFiles=falsewas configured. Match Git's
documented configuration behavior so users can hide untracked files
with the same boolean settings in both tools.Reuse
gix_config::Booleanto map false values toNoneand true
values toCollapsed, retainingnormalandallas explicit modes.
Read implicit configuration values separately so a key without=
selects the defaultCollapsedmode, even after an earlier setting,
while an explicitly empty value selectsNone.Extend the existing configuration-key test with boolean spellings,
case variations, empty values, and zero/nonzero numbers. The extended
test failed on boolean input before the fix. Keep error metadata
coverage using the invalid modeNORMAL.Git reference: local checkout version
2.55.0.782.g1630431f32,
builtin/commit.c::parse_untracked_setting_name(),
Documentation/config/status.adoc, and the boolean loops in
t/t7508-status.sh. A disposable repository comparison against
Apple Git2.54.0confirmed matching CLI output for 17 settings,
including an implicit key overriding an earlier explicit value. -
report status for gitlinks missing from
.gitmodulesStatus skipped indexed gitlinks unless
.gitmodulescontained their path,
so commits and dirty files in an embedded repository were invisible.For an unlisted gitlink, open its nested repository directly and compare
HEAD with the indexed commit. Reuse the submodule status collector so
tracked changes, untracked files and ignore policies behave consistently.
Nested opens retain repository options without inheriting repository
location overrides from the process environment.Preserve the original open options when the nonparallel implementation
reopens the parent repository. Review found that dropping those options
ignored API configuration overrides. ExplicitIgnore::Allreturns
before reopening the parent for each gitlink.The permanent Git porcelain baseline covers absent, unrelated and matching
.gitmodulesentries; clean, changed-commit, modified, staged and untracked
states; gitfiles and uninitialized repositories; and all ignore modes.
The API-override regression compares against Git's ignore-all baseline.
Git's diff and submodule dirty checks are the behavior reference. -
resolve indirect unborn HEAD references
Made the tests truly read-only.HEADcan point through multiple symbolic branches before reaching an unborn
branch. Following only its first target made an empty repository fail status
and exposed an intermediate branch name instead of Git's final referent.Reuse
follow_to_object()to resolve the entire chain while retaining tag
objects and existing cycle/depth checks. A missing final target is unborn.
The permanent Git fixture records symbolic names, trees and porcelain status
for empty, staged, committed and packed indirect HEADs, plus a cycle control.
Git's symbolic-ref and revision resolution are the behavior reference. -
describe commits with nested annotated tags
Default name selection discarded tags targeting another tag object.
Peel to a commit recursively while retaining the outer tag's date, so
newer nested tags win just as ingit describe.The existing describe fixture now records Git results with both tags
present and with only the packed outer tag left. Validated all six
describe tests, the SHA-256 regression and strict Clippy. -
preserve literal tree paths in revision specifications
Filesystem path components discard empty components, dots and trailing
slashes. Revision tree lookup therefore accepted paths Git rejects,
includingHEAD:file/andHEAD:dir//f.Use byte components for tree lookup and require a tree for a trailing
slash. Keep the existing normalization of CWD-relative syntax.
Git baselines cover blobs, symlinks, gitlinks, trees and malformed paths. -
reject unresolved commit-search anchors
An unborn or dangling symbolic anchor left no starting object for
HEAD^{/text}. That state fell into the unanchored search and could return
a commit from an unrelated ref. Reject unresolved reference anchors before
entering the all-refs search, retaining the original lookup diagnostics.The existing dangling-reference Git baseline now records bounded searches
through unborn HEAD, dangling and cyclic refs, with both text and empty
patterns. An unanchored:/wipremains a successful control. The reported
unborn-HEAD case failed against Git before the fix.Git's
object-name.c::peel_onion()resolves and peels the anchor before
searching, inspected atv2.56.0-116-g6de20f6092; Apple Git 2.54.0 generated
the local baseline. All 60 revision-spec tests, the new baseline with
SHA-256 and regex support, strictgixClippy, and formatting passed. -
honor push tracking defaults and upstream remotes
Looked at everything, but ultimately it's mostly a rubber-stamp.
Now some upstream-related functionality is also tested more through
revspec resolution, which probably isn't the worst thing in the world
particularly as it has a Git baseline.Without per-branch remote configuration,
@{push}failed instead of using
origin(or the only configured remote). In a triangular setup,
push.default=upstreammapped the upstream branch through the push remote
and selected the wrong tracking ref.Reuse the default remote selection when the branch has no explicit remote
name. Map upstream pushes through the fetch remote, and require matching
push and upstream tracking destinations forsimple. Explicit push
refspecs retain precedence. Clarify the documented no-branch-config case.The new Git baseline records object and symbolic results for both setups
withcurrent,matching,upstream,simple, and explicit push refspecs.
Both reported cases failed before the fix. Git's
remote.c::remotes_pushremote_for_branch()andbranch_get_push_1()were
inspected atv2.56.0-116-g6de20f6092; local baseline generation used Apple
Git 2.54.0. Git rejects triangular@{push}withsimplewhen the two
tracking destinations differ, which is covered as well. -
preserve annotated tags in prior checkouts
A previous checkout name can resolve to an annotated tag after its branch
is deleted.@{-1}must return that tag like the plain name does, leaving
peeling to an explicit^{}. Following symbolic references is sufficient;
peeling the object eagerly instead returned the tagged commit.The existing revision baseline now creates this history and records Git's
results for the prior checkout, its name, and both explicit peel forms.
The regression failed before the fix. Git'sobject-name.c::get_oid_basic()
usesrepo_dwim_ref()after expanding the checkout name, inspected at
v2.56.0-116-g6de20f6092; local baselines use Apple Git 2.54.0. -
match Git when resolving reflog boundary values
Mostly rubber-stamp, but also... it's very good at doing the tests with
read-only fixtures now.Reflog lookups rejected the oldest prior value after expiration, returned
null IDs at deletion entries, used stale symbolic-ref logs for the current
value, and accepted logs belonging to refs that no longer resolve.Resolve the current ref before consulting its log and retain it when the
log is stale or has a deletion discontinuity. Indexed lookups at the entry
count accept the oldest non-null previous ID. Date lookups retain the
oldest available value and preserve exact timestamp semantics.make_reflog_edge_cases.shkeeps all four Git reproductions, including
remote symbolic refs, indexed and date queries, unborn HEADs and null-only
logs. The reference is Git'srefs.c::read_ref_at()andrepo_dwim_log(),
and thenth == co_cntcase inobject-name.c::get_oid_basic(), inspected
atv2.56.0-116-g6de20f6092. Local baselines were generated by Apple Git 2.54.0. -
skip dangling symbolic refs during revision lookup
A dangling or cyclic early DWIM candidate can hide a live later reference
or a unique object prefix. A deleted prior branch could also resolve to its
old reflog ID when a dangling remote HEAD matched the branch name.Add
gix-ref::file::Store::find_resolved()using the existing candidate
lookup order while keeping raw lookup available. Revision names, hex prefix
collisions and prior checkouts use the resolving lookup. When all candidates
fail, retain deferred reference diagnostics; prior checkouts no longer ignore
peeling failures.make_dangling_revspecs.shpreserves Git reproductions for dangling tags,
cycles, remote HEADs, hex prefixes and deleted prior branches. Git's
refs.c::expand_ref()usesRESOLVE_REF_READINGto skip unresolved
candidates; inspected Git atv2.56.0-116-g6de20f6092. -
apply
gitoxide.core.defaultPackCacheMemoryLimitto the default pack cache.- The key caps the memory of the default pack delta cache (64 slots, 96MiB if unset).
- It was never applied: the code read
gitoxide.core.deltaBaseCacheLimit, a key that is not defined.
Since #851 the limit was fed bycore.deltaBaseCacheLimit, which selects another cache and wins. - Read the documented key.
gitoxide.core.deltaBaseCacheLimitworked by accident and is no longer read.
-
attribute object-format validation errors to the supplied config key
init.defaultObjectFormatreused a validator that attached
extensions.objectFormatmetadata, so generic key validation reported the
wrong setting. Share key-neutral parsing and attach the caller's key and
environment override only at the public conversion boundary. -
honor init object-format defaults, context, and section filtering
This is a typical review with quite a bunch of agent-enabled changes to
avoid super-specific tests in favor of adjusting existing tests to capture
what's now also interesting.Additionally, make it more Git-conform as Git picks up intial values from the
global configuration.Keep
create::Options::default().object_hashunspecified in every build;
apply the build fallback only in repository creation. This lets configured
and environment defaults be validated even in SHA-256-only builds while
preserving explicit hash requests and clone behavior.Read
init.defaultObjectFormatwithout a future Git directory, honor the
opening options' section filter, and distinguish a valueless selected entry
from an absent setting before creating anything.Regression tests reproduce all four init findings. They cover both repository
kinds, available and unsupported environment requests, excluded API settings,
and Git comparisons for conditional includes and valueless settings.
Focused checks pass with SHA-1, SHA-256, and both hashes; the fullgix-init
integration target passes with default features plus SHA-256. Existing init,
clone-default, and build-fallback checks also pass.
Commit Statistics
- 109 commits contributed to the release.
- 31 days passed between releases.
- 53 commits were understood as conventional.
- 13 unique issues were worked on: #3089, #3090, #3095, #3096, #3100, #3102, #3103, #3112, #3114, #3128, #3133, #3167, #3189
Commit Details
view details
- #3089
- Match Git when resolving reflog boundary values (65cfa83)
- #3090
- Skip dangling symbolic refs during revision lookup (370328b)
- #3095
- Preserve annotated tags in prior checkouts (c25f4d5)
- #3096
- Honor push tracking defaults and upstream remotes (6c45816)
- #3100
- Reject unresolved commit-search anchors (1cd4b31)
- #3102
- Preserve literal tree paths in revision specifications (aed3cf3)
- #3103
- Describe commits with nested annotated tags (eaf91c8)
- #3112
- Resolve indirect unborn HEAD references (00e8f77)
- #3114
- Report status for gitlinks missing from
.gitmodules(8a09473)
- Report status for gitlinks missing from
- #3128
- Accept booleans for
status.showUntrackedFiles(399ad55)
- Accept booleans for
- #3133
- #3167
- Give public API types nameable paths (17a3a55)
- #3189
- Honor directory hints in
AttributeStack::at_entry()(9bb7d88)
- Honor directory hints in
- Uncategorized
- Release gix-error v0.5.3, gix-macros v0.2.2, gix-date v0.19.0, gix-actor v0.45.0, gix-trace v0.3.2, gix-validate v0.13.2, gix-path v0.14.2, gix-utils v0.5.3, gix-quote v0.10.2, gix-command v0.12.2, gix-hash v0.29.0, gix-hashtable v0.19.0, gix-parallel v0.50.2, gix-fs v1.0.0, gix-tempfile v27.0.0, gix-object v0.67.0, gix-glob v0.30.0, gix-attributes v0.38.0, gix-zlib v0.4.1, gix-encoding v0.1.0, gix-packetline v0.24.2, gix-filter v0.37.0, gix-chunk v0.10.2, gix-commitgraph v0.43.0, gix-revwalk v0.39.0, gix-traverse v0.65.0, gix-worktree-stream v0.40.0, gix-archive v0.40.0, gix-bitmap v0.6.2, gix-lock v27.0.0, gix-index v0.59.0, gix-config-value v0.21.2, gix-pathspec v0.23.0, gix-ignore v0.25.0, gix-worktree v0.60.0, gix-imara-diff v0.3.4, gix-diff v0.71.0, gix-blame v0.21.0, gix-ref v0.70.0, gix-sec v0.17.0, gix-config v0.63.0, gix-prompt v0.19.2, gix-url v0.41.0, gix-credentials v0.43.0, gix-discover v0.58.0, gix-dir v0.33.0, gix-fsck v0.28.0, gix-notify v0.1.0, gix-fsmonitor v0.1.0, gix-mailmap v0.36.2, gix-revision v0.53.0, gix-merge v0.24.0, gix-negotiate v0.39.0, gix-note v0.4.0, gix-pack v0.78.0, gix-odb v0.88.0, gix-refspec v0.48.0, gix-shallow v0.16.0, gix-transport v0.63.0, gix-protocol v0.69.0, gix-status v0.38.0, gix-submodule v0.37.0, gix-worktree-state v0.38.0, gix v0.91.0, gitoxide-core v0.65.0, gix-tix v0.7.0, gitoxide v0.62.0, safety bump 44 crates (df27410)
- Drop orphaned release metadata from
gix(aab2dcc) - Change
gix_ref::ReferencetoReference<'repo>andattached.repoto.repo()(3af2f76) - Re-export
gix-fsckasgix::fsck(1238c01) - Gate the
gix::fsre-export behindunstable(fcee32f) - Merge pull request #3230 from GitoxideLabs/allocation-free-ref-iteration (732cc15)
- Reuse reference name storage during iteration (92a7a69)
- Merge pull request #3220 from GitoxideLabs/trust-in-CLI (689a724)
- Let callers configure related repository opens (1907f59)
- Add discovery methods to
open::Options(0998577) - Replace discovery trust maps with callbacks (b91fe7b)
- Return
Repositoryfromopen::Options::open()(1ba6f8e) - Merge pull request #3218 from GitoxideLabs/fix-issues (3599c4e)
- Let callers enforce trust on direct opens (8354d34)
- Reselect the checkout after repository trust drops (59568e6)
- Use the platform default for symlinks without a probe result (2571b8c)
- Honor section trust in checkout and submodule settings (5c607f4)
- Apply final repository trust to configuration (fb4e1a9)
- Merge pull request #3028 from GitoxideLabs/repo-sharing-permissions (a77e8d4)
- Share received packs and shallow metadata (6ca509d)
- Apply sharing to loose object writes (ba1557a)
- Honor sharing during repository initialization (9e41eb6)
- Preserve configuration permissions during branch deletion and clone (4895bae)
- Apply sharing to reference, index, and worktree writes (80530c6)
- Merge pull request #3207 from GitoxideLabs/fix/gix-merge-0.23-correctness (3e89f3b)
- Merge pull request #3191 from GitoxideLabs/notify-and-more (ab7c5dc)
- Configure extra monitor invalidations and selected worktrees (be69a0f)
- Add opt-in async filesystem notifications and monitoring (0bf6ab4)
- Start an application-owned filesystem monitor server (3dbd035)
- Monitor repository and linked-worktree changes (2d7396d)
- Merge pull request #3211 from GitoxideLabs/jiff-upgrade (12eff45)
- Upgrade dependencies and require Rust 1.95 (945b52a)
- Merge pull request #3205 from GitoxideLabs/fix-tree-mode (706d070)
- Merge pull request #3203 from GitoxideLabs/fix-config-parsing (154ffbc)
- Merge pull request #3198 from GitoxideLabs/fix-long-paths (c2c487c)
- Keep Windows QA free of platform-specific warnings (9f331f0)
- Merge pull request #3192 from GitoxideLabs/fix-config-access (5e0af63)
- Honor configuration trust for security-sensitive settings (2145f39)
- Merge pull request #3190 from GitoxideLabs/fix-attribute-query (d1e064e)
- Merge pull request #3187 from trevorlasn/status-macos-thread-cap (8118e5e)
- Review (6f51b5c)
- Merge pull request #3036 from ameyypawar/merge-base-is-ancestor (e2743fe)
- Add exact ahead/behind commit counts (274fe03)
- Add
Repository::is_ancestor()andRepository::is_ancestor_with_graph()(a583aef) - Merge pull request #3162 from GitoxideLabs/nullid-is-option-id (8050181)
- Merge pull request #3178 from GitoxideLabs/fix-status-race (576bfd2)
- Merge pull request #3174 from GitoxideLabs/windows-system-prefix-without-git (3347b23)
- Merge pull request #3165 from GitoxideLabs/encoding (1b025f7)
- Accept Git's whitespace in
core.checkRoundtripEncoding(8552c13) - Merge pull request #3168 from GitoxideLabs/fix-ident-filter (f06f106)
- Merge pull request #3160 from laj52/fix-remote-refspec-order (526c1c7)
- Review (43f0311)
- Keep the refspecs of configured remotes in their configured order (8c71752)
- Merge pull request #3145 from GitoxideLabs/supersede-3086 (54248f1)
- Merge pull request #3152 from GitoxideLabs/even-faster-qa (2baa819)
- Import the shared remote fixture's multi-round history in one Git process (19ff6a6)
- Merge pull request #3146 from GitoxideLabs/publish-gix-macros (9dd78c8)
- Release gix-macros v0.2.1 (16940c7)
- Merge pull request #3143 from GitoxideLabs/fast-ci (c4a28f8)
- Check major
gixconsumers in advisory CI jobs (b6eda5b) - Build
gixfetch worktrees only for the test that uses them (012fd68) - Discover QA work from manifests and share it between local runs and CI (8bf25a2)
- Merge pull request #3061 from GitoxideLabs/stable-gix (5c88568)
- Leave a note in the manifest for
gix1.0 (39f7a9c) - Merge pull request #3140 from GitoxideLabs/gix-status-fix (9519478)
- Merge pull request #3138 from GitoxideLabs/fix-submodule-issue (e0be1ed)
- Make repository option reuse explicit (5647da5)
- Recompute trust when staging embedded repositories (1e9051b)
- Validate gitlinks before worktree removal safety probes (4bc3346)
- Reject symlinked ancestors during file-to-object conversion (ef37e22)
- Validate unconfigured gitlink paths during status (d65a1b0)
- Reject symlinks in configured submodule paths (a9f1f1e)
- Merge pull request #3127 from srijs/gix-zlib-sirocco-deflate (8644bf3)
- Add a
gix-zlibcompression and decompression benchmark (9730753) - Merge pull request #3131 from stephenprater/gix-odb-grow-index-slots (44c5008)
- Merge pull request #3125 from wleeaf/config-legacy-subsection-lower-case (8d90449)
- Avoid a Git Bash subshell in the submodule URL fixture (0632c3b)
- Merge pull request #3129 from GitoxideLabs/show-untracked-files-bool (e6a1d27)
- Merge pull request #3092 from GitoxideLabs/brace-brace (15b71a3)
- Expose topological walks through
Repository(3a05954) - Merge pull request #3119 from castrog/fix/pack-cache-memory-limit-key (d4db00d)
- Review (a31201a)
- Apply
gitoxide.core.defaultPackCacheMemoryLimitto the default pack cache. (cd79375) - Merge pull request #3117 from GitoxideLabs/release-testtools (8929480)
- Release gix-utils v0.5.2, gix-parallel v0.50.1, gix-hashtable v0.18.1, gix-sec v0.16.1, gix-config v0.62.2, gix-ignore v0.24.1, gix-imara-diff v0.3.3, gix-testtools v0.22.0 (584a602)
- Merge pull request #3087 from 10ne1/sha256-init-default-format (4dd8f2b)
- Attribute object-format validation errors to the supplied config key (e34fb56)
- Honor init object-format defaults, context, and section filtering (47a3651)
- Honor
init.defaultObjectFormatwhen initializing (5fb8bf9) - Add
init.defaultObjectFormatconfig key (a62739f) - Test SHA-256 repository initialization (fabb119)
- Merge pull request #3116 from EliahKagan/claude/run-ci/fix-windows-long-checkout-fixture-paths (4dc73c3)
- Drop the submodule's own worktree from the linked-superproject fixture (e1d6835)
- Shorten directory names in the linked-superproject submodule fixture (e917129)
- Merge pull request #3083 from GitoxideLabs/report-october (e87b6ee)