github GitoxideLabs/gitoxide gix/v0.91.0
gix v0.91.0

latest release: v0.62.0
one hour ago

Bug Fixes (BREAKING)

  • share received packs and shallow metadata
    A straight-forward wiring of the core.sharedRepository flag.

    Fetching into a shared repository must make received packs, pack indices, and
    shallow boundaries accessible according to core.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 .keep markers 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 new config_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.sharedRepository is enabled.

    Use the existing FileTransaction for 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 explicit 0600 config stays private, matching Git.

  • apply sharing to reference, index, and worktree writes
    This change is mostly tests, and the shared_repository_permissions wired through
    to gix-index, gix-merge and gix-ref.
    Tests mostly rubber-stamped, but made it use test scripts more.

    Reference, index, and linked-worktree metadata writes must apply the effective
    core.sharedRepository policy 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 passing 0.

    Apply the same policy when preparing linked-worktree directories and linking
    files, writing HEAD and 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 in 392336fb114 already 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 .git entry. 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
    covers git_dir_try_old_form(), state(), open(), and status(),
    including Ignore::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() in submodule.c at
    6de20f6092dcf9bdb1c8efe03db4b70c82b423dd (v2.56.0-116-g6de20f6092),
    introduced in e8d0608944486019ea0e1ed2ed29776811a565c2.
    At the same baseline, repo_worktree_path_append() in path.c and
    repo_submodule_init() in repository.c also 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::InvalidationPath and Options::additional_paths to map application
    files and recursively observed directories to caller-selected Changes. 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;
    the metadata = false suppression contract still applies. Additional-only
    coverage can run without opening a repository.

    Add Options::worktree_filter as an optional allowlist of private Git directories
    for all_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 log command.
    • 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 Topo builder 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)
    with Sorting::TopoOrder and Sorting::DateOrder, sharing the builder
    controls, iterator, errors, and attached Info across sorting modes.

    gix log is a repository-backed revision walker with Git-style positional
    revision expressions, exclusions, and ranges, plus ---separated pathspecs.
    Its --sort option selects breadth-first, newest-first, oldest-first,
    topo-order, or date-order (the default). --first-parent, --tip, and
    --hide remain available. Path-filtered history is not implemented yet and
    reports an explicit error.

    Align Topo predicates with Simple: 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 Sorting enum 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.

Changed (BREAKING)

  • change gix_ref::Reference to Reference<'repo> and attached.repo to .repo()
    This commit is a bit rusehd, but needed to be a bit more consistent.
    HeadOwned really needs more work, and so does Head, 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 HEAD and parsed revision specs now retain gix::Reference
    values. Callers can use the same reference API as lookup and iteration,
    and Head can 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 owned HeadOwned snapshot across
    repository lifetimes. HeadOwned::attach() binds the snapshot and its
    symbolic referent together. The snapshot's id() 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. Adapt gitoxide-core
    and Tix callers to use the reference accessors and owned HEAD snapshots.

  • gate the gix::fs re-export behind unstable
    Here was more to fix as unstable really needs to be enabled within
    the workspace, so tests and gitoxide-core + gitoxide can just use
    the unstable version, forever.

    gix enables gix-fs/unstable for internal use. Re-exporting the
    whole crate gives downstream users access to those experimental APIs
    through gix, even when they disable its default features.

    Make unstable a default-enabled gix feature for compatibility and
    use it to gate only the gix::fs re-export.
    Downstream crates in the workspace now enable unstable.

  • reuse reference name storage during iteration
    Turns an owned Reference into 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::Reference now lives behind inner() and
    inner_mut(). Use detach() 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. Replace gix::sec::trust::Mapping with a callback in
    the two configurable ThreadSafeRepository discovery entry points
    and in ThreadSafeRepository::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 by GIT_DIR directly when set.

  • return Repository from open::Options::open()

    Align direct opens through open::Options with gix::open_opts() so
    callers can use the repository APIs immediately. Callers that need a
    ThreadSafeRepository can call Repository::into_sync() on the result.

  • upgrade dependencies and require Rust 1.95

    Complete the workspace dependency audit requested alongside the Jiff 1.0
    migration. Upgrade parking_lot to 0.13.0, faster-hex to 1.0.0, sysinfo
    to 0.40.3, and serial_test to 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 through gix-parallel now use parking_lot
    0.13 and lock_api 0.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.
    Propagate sysinfo's new CPU errors with runner context and keep hostname
    lookup optional, so unavailable host details still become SQL NULL.
    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::Options mixes 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 Clone from open::Options. Keep clone_with_trust() crate-private
    for internal handle copies, and make clone_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() to with_trust() and accept
    impl Into<Option<gix_sec::Trust>>, allowing a Trust value directly or
    None to 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::Options

    Let callers use the same configured open::Options for 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 having with_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 that safe.directory can 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 enforced Reduced trust. 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 from gix-notify through gix-fsmonitor to gix,
    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. Reuse gix-macros for 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, and async-fsmonitor-server in gix.
    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. Add Repository::fsmonitor_server() behind the opt-in
    fsmonitor-server feature and re-export the supporting gix-fsmonitor API.

    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 in gix status 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 through Repository::monitor() and
    replace Tix's direct watcher management with gix::notify::RepositoryMonitor.

    The opt-in notify feature 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, and rescan() requests explicit recovery; no timer forces full scans.
    Raw native events remain available through gix::notify::plumbing.

  • add exact ahead/behind commit counts
    A lot of (now) read-only tests that validate is-ancestor and ahead-behind functionality,
    with gix -tt status --ahead-behind to 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 by gix_revision::ahead_behind_counts() and AheadBehindCounts.
    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-behind to 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() and Repository::is_ancestor_with_graph()
    They answer whether one commit is reachable from another, like git 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 a git2 alias for graph_descendant_of(), which takes the descendant
    first and doesn't consider a commit its own descendant.

  • honor init.defaultObjectFormat when initializing
    Like git init, new repositories now use init.defaultObjectFormat
    or GIT_DEFAULT_HASH if 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.defaultObjectFormat config key
    Like in Git, GIT_DEFAULT_HASH overrides it.
    Values are parsed like those of extensions.objectFormat.

    Unlike Git, invalid configuration values are an error instead of a
    warning followed by a fallback to SHA-1. As a library, gix has 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_HASH values 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 supplied core.worktree ineligible. 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
    If core.symlinks has 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.recurseSubmodules fallback. 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.
    Protected safe.directory approval also came too late to enable
    core.worktree or 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.sharedRepository before 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.minTrustLevel in gix 0.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 make Outcome::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 enforces gix'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 and git check-ignore --no-index
    identify the trailing slash as a directory hint. The wrapper forwards the
    unknown mode to at_path(), which assumes a file.

    Use ToNormalPathComponents::ends_with_separator() to infer Mode::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.c calls
    last_matching_pattern() in dir.c, whose directory-only rules require
    DT_DIR. The executable baseline is Apple Git 2.54.0, which ignores
    absent/target/ and leaves absent/target included in the fixture.

  • accept Git's whitespace in core.checkRoundtripEncoding

    The 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.
    Reuse gix_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's default_trait_access suggestion could not compile because
    OwnedOrStaticAtomicBool lived in the private util module.

    Re-export it from gix::interrupt and 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 in gix, gix-fs, gix-hash, gix-imara-diff,
    gix-index, gix-pack, gix-packetline, gix-parallel, and gix-protocol.
    Keep the gix-fs wrappers behind its existing unstable feature, with
    an introduction date from Git history. Add documentation for the newly
    nameable APIs without changing their behavior.

    Enable unnameable_types for the workspace to catch future omissions.
    Document intentional exceptions for sealed supertraits in gix and
    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.renameLimit was still ignored. A status-specific mode also
    prevented falling back to diff.renameLimit. The shared resolver had the
    same problem for diff and merge limits, silently ignoring their limits
    unless a corresponding renames key 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, and merge-ort.c::merge_options_init() reads diff.renamelimit
    followed by merge.renamelimit independently 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 that status.renames=false
    still paired staged renames, while unrelated merge.renames settings
    changed status results. They had to resolve configuration themselves and
    pass explicit rename options as a workaround.

    Both Status::RENAMES and Status::RENAME_LIMIT were accidentally attached
    to the merge section. Attach them to status, preserving the existing
    fallback to diff.renames when 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. Although Submodule::open()
    already clears git_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
    affects gix-tix staging.

    Clear cached trust and repository-local environment overrides before
    opening the embedded repository, matching Submodule::open(). Keep
    Options::Clone unchanged 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
    Reduced trust, despite the child being owned by the current user, and
    now sees independently determined Full trust. 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
    modules directory exists, has_populated_submodule() probes each index
    gitlink's .git entry. 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 by gix-tix when 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.worktree precedence and relative/symlink-sensitive paths. Recompute
    trust from the original .git entry, 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
    .. honor core.worktree. Preserve the parent worktree, including None, 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.

  • accept booleans for status.showUntrackedFiles

    Issue #3128 reported that gix status still listed an untracked file
    after status.showUntrackedFiles=false was configured. Match Git's
    documented configuration behavior so users can hide untracked files
    with the same boolean settings in both tools.

    Reuse gix_config::Boolean to map false values to None and true
    values to Collapsed, retaining normal and all as explicit modes.
    Read implicit configuration values separately so a key without =
    selects the default Collapsed mode, even after an earlier setting,
    while an explicitly empty value selects None.

    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 mode NORMAL.

    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 Git 2.54.0 confirmed matching CLI output for 17 settings,
    including an implicit key overriding an earlier explicit value.

  • report status for gitlinks missing from .gitmodules

    Status skipped indexed gitlinks unless .gitmodules contained 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. Explicit Ignore::All returns
    before reopening the parent for each gitlink.

    The permanent Git porcelain baseline covers absent, unrelated and matching
    .gitmodules entries; 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.

    HEAD can 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 in git 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,
    including HEAD:file/ and HEAD: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 :/wip remains 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 at v2.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, strict gix Clippy, 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=upstream mapped 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 for simple. Explicit push
    refspecs retain precedence. Clarify the documented no-branch-config case.

    The new Git baseline records object and symbolic results for both setups
    with current, matching, upstream, simple, and explicit push refspecs.
    Both reported cases failed before the fix. Git's
    remote.c::remotes_pushremote_for_branch() and branch_get_push_1() were
    inspected at v2.56.0-116-g6de20f6092; local baseline generation used Apple
    Git 2.54.0. Git rejects triangular @{push} with simple when 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's object-name.c::get_oid_basic()
    uses repo_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.sh keeps all four Git reproductions, including
    remote symbolic refs, indexed and date queries, unborn HEADs and null-only
    logs. The reference is Git's refs.c::read_ref_at() and repo_dwim_log(),
    and the nth == co_cnt case in object-name.c::get_oid_basic(), inspected
    at v2.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.sh preserves Git reproductions for dangling tags,
    cycles, remote HEADs, hex prefixes and deleted prior branches. Git's
    refs.c::expand_ref() uses RESOLVE_REF_READING to skip unresolved
    candidates; inspected Git at v2.56.0-116-g6de20f6092.

  • apply gitoxide.core.defaultPackCacheMemoryLimit to 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 by core.deltaBaseCacheLimit, which selects another cache and wins.
    • Read the documented key.
    • gitoxide.core.deltaBaseCacheLimit worked by accident and is no longer read.
  • attribute object-format validation errors to the supplied config key

    init.defaultObjectFormat reused a validator that attached
    extensions.objectFormat metadata, 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_hash unspecified 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.defaultObjectFormat without 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 full gix-init
    integration target passes with default features plus SHA-256. Existing init,
    clone-default, and build-fallback checks also pass.

Commit Statistics

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)
  • #3128
    • Accept booleans for status.showUntrackedFiles (399ad55)
  • #3133
    • Resolve rename modes and limits independently (251322d)
    • Read status rename keys from the status section (7e48cb0)
  • #3167
    • Give public API types nameable paths (17a3a55)
  • #3189
    • Honor directory hints in AttributeStack::at_entry() (9bb7d88)
  • 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::Reference to Reference<'repo> and attached.repo to .repo() (3af2f76)
    • Re-export gix-fsck as gix::fsck (1238c01)
    • Gate the gix::fs re-export behind unstable (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 Repository from open::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() and Repository::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 gix consumers in advisory CI jobs (b6eda5b)
    • Build gix fetch 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 gix 1.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-zlib compression 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.defaultPackCacheMemoryLimit to 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.defaultObjectFormat when initializing (5fb8bf9)
    • Add init.defaultObjectFormat config 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)

Don't miss a new gitoxide release

NewReleases is sending notifications on new releases.