85 issue fixes · 23 other changes
v0.5.24 is mostly Git-compatibility and performance fixes, especially on Windows, plus new hook support, safer Ctrl-C/signal rollback, and rebase and history reliability.
History fixup and absorb now retain consumed index/worktree edits in an internal sidecar so undo restores the user's exact pre-command state and a second undo redoes the rewrite. The round-two fix extends that safety to staged submodule pointers while never reading their commits as blobs or touching the submodule checkout.
Adds range expansion to patch-id and a cherry-marked symmetric revision walk that identifies patch-equivalent commits across rewritten branches, including one-to-one counterpart and message-change metadata. The round-two fix ensures `-n 0` cannot bypass the required `A...B` validation for cherry-mark or left/right modes.
Adds a host-agnostic, non-interactive way to save HTTP(S) credentials with `grit auth --username --token`, distinguishes rejected credentials from missing credentials, and classifies non-grit hosts cleanly. The round-three fix prevents credential helpers or transports that close stdin early from killing remote-capable CLI commands with SIGPIPE.
Index-only restore now refuses conflicted paths before dropping stages, and auto-staging refuses marker-bearing files whose stages were previously collapsed by another tool. Round 3 narrows the intentional-marker exemption so every complete worktree conflict block must exist byte-for-byte in HEAD with the same multiplicity; a committed example can no longer hide a new stash-pop block.
This change prevents detached Windows auto-gc from keeping the command caller's stdin/stdout/stderr pipes alive. It clears inheritance on grit's original three standard handles immediately before spawning the NUL-redirected background child, while leaving Linux/macOS and repository data behavior unchanged.
This change removes unnecessary case-insensitive filesystem path probes from the worktree scan used by status, diff, and commit. It resolves indexed paths lazily only after direct directory metadata cannot establish a match, while preserving case-folded fallback behavior and adding Git-compatibility regressions.
This change prevents upload-pack from combining individually valid deltas from separate packs into an unresolvable cycle. It also refuses to stream a non-thin pack when a planned delta reaches the writer before its base, converting latent corruption into a typed error.
Windows console interrupts now reach the existing cancellation/rollback path used by switch and clone instead of immediately killing the process. The change adds platform handling, shared first/duplicate/later interrupt semantics, an end-to-end switch rollback regression, and concise command documentation.
Tracked paths that change between a file and directory now stage as a deletion of the old index path plus additions for the replacement, without panicking or surfacing ENOTDIR. Deferred removals are compacted in one pass, and CLI guidance only suggests closing programs when the OS actually reports an in-use file.
Patch-ID computation now hashes the exact text hunks produced by Grit's Git-compatible default diff engine, including Git's placement of ambiguous insertions and deletions. The verbatim synthesis uses that same Myers/indent path, and whitespace hashing is batched by non-whitespace runs for speed.
Slash-free ignore rules now test only the queried path's basename instead of every path component. Parent-directory inheritance remains centralized in the existing ancestor walk, so a later `!dir/` genuinely re-includes that directory and its otherwise-unmatched children.
Local-path pushes now create refs with a compare-and-swap that requires the ref to remain absent. If another pusher wins first, the loser exits nonzero with a typed already-exists result instead of overwriting a successful push.
Windows console interrupts now become cooperative cancellation, allowing clone and switch rollback to finish instead of letting the OS terminate midway. Failed-clone cleanup first drops pack/index mappings held by the calling thread, so Windows can remove the destination and an immediate retry can reuse the path.
Status and index-to-worktree diff now trust a worktree size mismatch only when the path's clean conversion is guaranteed to be byte-preserving. Conversion-sensitive paths are hashed, matching cleaned blobs refresh their index stat, and already-computed hashes are reused so real edits are not read twice.
Rebase exec now adopts commits created by amend/extra-commit commands and continues replaying later commits on the resulting HEAD. Recovery is resumable across dirty/conflict stops, preserves the original rewrite policy, executes pending commands after conflict skip, and rolls back cleanly if conflict-state persistence fails.
Local-path and file:// pushes now execute the destination repository's pre-receive, update, post-receive, and post-update scripts instead of bypassing server policy. New objects remain quarantined through pre-receive, hook refusals become structured rejected results with relayed output, and advertised push options reach the appropriate hooks.
Checkout deletion rollback now stores each removed file under a short, process-and-sequence-based spool name instead of flattening the full repository-relative path into one filename component. The CLI also limits its close-the-file hint to actual sharing/lock failures, while regression coverage exercises switch and hard reset across a roughly 380-character tracked path.
Bulk staging now hashes and stores untracked files in 4,096-path chunks, retaining only compact index entries until one final merge. A transient per-entry bit replaces the second path-keyed verification map for freshly hashed entries, and root commits derive their reported file list from the index instead of constructing a full empty-tree diff.
This makes a clean first status after checkout stat-only on Windows by using NTFS nanosecond timestamps consistently for both stat matching and racy-entry detection. It also handles NTFS’s 100 ns tick and the last tick of a second safely, while preserving whole-second behavior under core.checkstat=minimal and when core.usenanosec=false.
Adds a full-only `grit-lib` regression suite that prevents clean-tree staging under `core.ignorecase=true` from returning to quadratic behavior. It also checks no-op index compatibility with Git, one-file edit staging, repeated runs, and case-only spelling updates on case-folding filesystems; production code is unchanged.
First-parent revision ranges now walk the commits to display through first parents only while hiding every commit reachable from excluded tips through any parent. The implementation computes a hidden frontier, stops the displayed walk there, and keeps the existing explicit first-parent-only exclusion mode unchanged.
History rewrites now leave any secondary local branch at the current HEAD commit pointing to the old history. The checked-out branch and true stacked branches on intermediate or descendant commits still move, including fast-forward rebases.
Changes the library’s default rename similarity threshold from 40% to 50%, making default diff/show/log behavior agree with the existing docs and system Git. Adds regression coverage for empty/true/copies config and a 44%-similar Git fixture, while preserving explicit lower thresholds.
History undo now restores converted files with trustworthy index stat data instead of leaving a phantom unstaged modification. It preserves real unstaged edits by retaining an unset stat cache when clean-converted worktree content does not match the restored blob.
Blame can now attribute a working-tree file or caller-supplied buffer without writing a synthetic object, preserving committed attribution while marking new lines with the null object id. The CLI defaults to working-tree blame unless a revision is explicit, adds --contents, and reports typed not-committed state in human and structured output. Round two additionally makes unfinished-merge overlays honor --first-parent.
Custom object stores can now build, persist, attach, and use verified commit-graphs without trusting the files backend's graph. History hot paths use backend-provided buffered reads, while malformed octopus graphs missing their EDGE chunk are rejected consistently with Git.
Adds `Odb::read_store()` so embedders can expose everything an ODB can already read as one composable `Arc<dyn ObjectStore>`. It also makes Arc, Box, and references transparently forward read/write store traits, while retaining the narrower existing meanings of `sources()` and `primary()`.
Push cancellation now reaches the expensive object walk, delta planning/writing, destination indexing, streamed smart-HTTP body, and smart-HTTP report wait. Local pushes stream directly into a quarantined temporary pack and avoid a redundant post-index pack verification, substantially reducing runtime and peak memory without changing pack or ref semantics.
Three-way merges now infer directory moves from file renames and correctly relocate files added by the opposite side. A typed policy supports off, apply, and conflict behavior; conflict metadata, index stages, worktree materialization, status output, and merge abort all preserve the resulting state safely.
Ref updates issued through a Repository now reject missing object IDs, and branch/HEAD updates reject stored non-commit objects. Round 2 extends that policy to files-backend commit fast paths before any lock or reflog/ref write, including detached HEAD, replay, and the path-based branch writer.
This keeps the mandatory `.git/refs` directory when pack-refs removes the last loose references, including the common stash-triggered case. Empty directories below that root are still pruned, and the CLI remains a thin caller of the corrected library path.
Staging now detects when a worktree blob is already stored in a local pack, promisor pack, or alternate and freshens that copy instead of writing a duplicate loose object. Cruft-only objects and genuinely new content still become loose, so repository safety and partial-clone behavior are preserved.
Ordinary reflog expiry now performs a commit-only, seen-set reachability walk instead of recursively validating every commit tree for every old entry. Full object completeness checking remains available for stale-fix, but is iterative and memoized across refs, eliminating repeated merge-diamond traversal and stack-depth risk.
This removes the quadratic same-batch ref-name check, makes initial clone refs a single packed-refs transaction, and eliminates duplicate ownership and filesystem work during ordinary fetch. The round-2 amendment preserves the public batch API's all-or-nothing behavior when a lock path is obstructed or otherwise errors.
Empty-prefix ref enumeration now has one backend-independent meaning: enumerate only names under `refs/`, while non-empty prefixes can still select root refs such as `HEAD` and `ORIG_HEAD`. The change updates memory and reftable implementations, the public contract, custom-backend guidance, and shared conformance coverage.
Worktree diffs now record a null worktree OID for actual content changes instead of reusing the index blob through a status-only shortcut. That lets existing human and Markdown renderers identify size-changing binary edits, while retaining the status fast path and keeping mode-only binary changes silent. Large index-to-worktree scans also use the existing parallel hashing path for every content-comparison caller.
A stopped `rebase --exec` now detects external ref movement before continue/skip can replay anything, and abort can safely restore a moved branch to its recorded pre-rebase tip. The CLI reports the overwritten tip in human, Markdown, and JSON output while preserving the previous output for ordinary aborts.
This makes `includeIf "hasconfig:remote.*.url:…"` evaluate against every remote URL in the current config load, so a global identity include can see remotes defined later in `.git/config`. Matching includes still merge at their original position, preserving later local overrides.
Reflog expiry now interns every commit read during one expiry pass into a dense index and reuses its parent linkage across all refs. Each ref still has its own reachability bitmap, so the speedup does not leak reachability between branches.
Adds one bounded retry boundary around ref-store prepare operations so pluggable stores with a single writer slot serialize concurrent writes instead of failing most commits. It also shortens the shared-lock critical section for linked worktrees and makes LockHeld consistently identify the caller’s ref.
Ref directory/file collisions now surface as structured name conflicts that identify both the requested ref and the blocking descendant. Reflog-path collisions are detected during transaction preparation, so branch/switch errors are useful and fetch can continue applying unrelated updates while rejecting the conflicting tracking ref with prune guidance.
This makes diff compaction distinguish a line ending in LF from an otherwise identical final line without LF, preventing ambiguous change groups from sliding across EOF. It also narrows patch-ID whitespace stripping to Git’s actual four-byte set, restoring compatible IDs for control-character changes.
Maps a refused fast-forward pull directly to the typed `RefusedNotFf` status, producing exit 128 in human, JSON, and markdown modes. Conflict and dry-run/check behavior remains at exit 1, and generated skill/docs now state the same contract.
This change makes ODB-computed patch IDs omit invented unified-diff body lines for empty-file additions/deletions and reproduces Git's stable digest boundaries for header-only entries. It adds a system-Git regression covering nine empty, mode-only, rename, ordering, and truncation shapes across stable, unstable, and verbatim modes.
This corrects index handling when switch or fast-forward merge moves a submodule gitlink while the submodule checkout has drifted. The index now records the target gitlink without moving or deleting an existing submodule directory, including an uninitialized directory containing local files.
Unix grit commands now treat SIGTERM and SIGHUP like Ctrl-C while a cancellable operation is active: the first signal requests cancellation so clone or switch can roll back, while a deliberate later signal restores default termination. Clone retry behavior and switch atomicity are covered end-to-end, and user docs now explain the cleanup guarantees.
History rewrite failures now identify the exact replay commit and any sibling branch that made planning fail. Users get a direct `--update-refs head` escape hatch in human and structured output, while successful planning and the default branch-moving behavior are unchanged.
Gitlink entries now contribute `Subproject commit <oid>\n` to patch IDs instead of being looked up as objects in the parent repository. The same side loader is used by stable, unstable, rename, binary-probe, and verbatim paths; type changes are represented as deletion plus addition to match Git's emitted patch.
Clean worktree paths involved in rewrite checkout are now represented by path and kind in one journal manifest instead of one full-byte file per changed path. If apply is interrupted, recovery rematerializes those paths from the pre-apply tree; paths carrying preserved local edits still retain exact byte snapshots.
Corrects non-cone sparse filtering so nested blobs under an included directory are no longer omitted when `!/*/` is present, and unanchored patterns follow Git basename matching. It also avoids reparsing sparse patterns for every blob and adds cancellation polling to filtered object enumeration when callers provide a signal.
This change completes commit, merge, pull, and rebase hook handling in grit-lib and exposes only the required --no-verify controls in the CLI. It also preserves merge state and autostashed edits when a merge-commit hook refuses, allowing a safe continue or abort.
Status callers can now distinguish an un-hashed modified worktree file from the staged blob: the worktree side is represented by the null OID instead of incorrectly repeating the index OID. The optimization remains intact and still avoids reading file content when an identity-conversion size mismatch proves modification.
Grit now records the process ID beside every grit-owned index lock unless explicitly disabled. After a process is killed during rewrite checkout, status or abort can identify that dead holder, safely remove the stale lock pair, reacquire the index lock, and finish or roll back recovery without manual file deletion.
Pickaxe history search now limits the tree diff to the requested paths, pairs adds/deletes as renames, and only then applies -S/-G. The same change reuses commit/blob data and enables bounded path walks to stop after enough matches, removing the reported false positives and most of the 3–4x pathspec gap.
Loose receive-pack ingestion now stores only compact object metadata for the life of the pack, resolves available deltas during the forward scan, and retains base bytes in a 96 MiB LRU. Strict graph and dot-special validation re-read stored objects as needed, preserving compatibility while removing payload retention proportional to object count.
This change makes ORIG_HEAD a repository-ref-store-backed recovery point across reset, merge, pull, and rebase. Round two closes the remaining documented rebase gaps by moving `--exec` orchestration into grit-lib and routing `-X ours|theirs` through the resumable rebase session, including continuation with the saved merge favor.
Rebase planning now extends the replay order with all commits on scoped branch tips that descend from the rewritten range, not just a single eligible tip or a first-parent chain. Multi-commit stacked branches and stacked merges are replayed after the checked-out range, so every affected local branch moves together.
Include-tag decisions now happen after pack enumeration by probing the objects actually selected for transmission. Annotated tag chains are appended only when their final commit, tree, or blob is in that set, on both normal walk and bitmap-reuse paths, without walking client history.
Rebase conflicts now identify the replayed commit in incoming markers instead of repeating the file path. A shared internal label helper keeps pick and history replay aligned, including linear replay, merge replay, and the post-`--exec` re-merge path.
Authenticated HTTP retries now erase a credential only when the server answers 401 again. Repository-not-found, permission, rate-limit, and server errors remain typed HTTP failures while leaving both the provider entry and in-process authorization state intact.
Linked worktree creation now runs `post-checkout` after checkout and after rollback guards are committed. The hook executes from the new worktree with `<null oid> <new HEAD> 1`; no-checkout and orphan creation continue to skip it, and hook failures remain advisory.
Merge checkout refusals now expose a structured reason and every affected path instead of forcing library callers to parse English. The same typed error is used for untracked checkout collisions, and history replay consumes it directly.
Case-colliding tracked paths now retain their original index entries when only the shared case-folded worktree file exists. Path-scoped commit, auto-stage commit, and status all consistently treat the collision loser as a checkout artifact rather than a deletion or modification.
Uninitialized submodule directories now remain clean even when stray files are placed inside them, matching system Git and eliminating the status/commit disagreement. Clone results also report gitlink paths, while human and Markdown modes explain that grit does not fetch submodules and JSON exposes a stable `submodule_paths` field.
This change makes reference updates invoke the repository's reference-transaction hook once per transaction, with prepared followed by committed or aborted and Git-compatible old/new/ref input. A denying prepared hook now prevents writes, including central ref-store updates and files-backend commit/delete bypass paths; round three restores a missing test import and repairs the nested-lock test's stdin handling.
Clone and fetch outcomes now expose whether a requested object filter was sent after capability negotiation. `grit clone --blobs` warns and suppresses partial-clone claims when the server lacks filter support, while retaining the existing Git-compatible promisor configuration.
Declares Rust 1.95 as the minimum consumer toolchain for all four publishable Grit crates, so older Cargo versions fail immediately with a useful requirement instead of reaching an experimental-language-feature compiler error. It separately documents that contributors use the repository's Rust 1.99 pin and adds a manifest regression test.
Reset and path restore now honor Ctrl-C through the library cancellation path, release index locks, and roll back worktree changes instead of leaving an index/HEAD/worktree split. The round-2 fix extends the checkout journal to preserve a whole existing directory—including untracked files—when a restore temporarily replaces that directory with a tracked file.
Bundle ingestion now trusts the validation already completed by the index-building pass instead of serially inflating every object a second time. It preserves all installed pack/index formats and leaves explicit verify-pack/fsck behavior unchanged.
Reflog date selectors now use the same relaxed date grammar as other date-aware library operations, so forms such as `yesterday`, `last week`, and `noon yesterday` resolve correctly. Invalid date text survives the object-inspection API as a typed error, and dates older than the reflog resolve to the oldest state while emitting a structured warning.
Filtered and path-limited default-order revision walks now stop at the `--since` date frontier instead of traversing all reachable history, including filtered count mode. Round 3 adds an immediate zero result for `--count -n 0`, preventing the bounded filter walk from counting its first match.
This makes `rebase --exec` write durable recovery state before detaching HEAD and keep its command cursor current while subprocesses run. An interrupted process is now visible in `grit status`, can be aborted back to the original branch/index/worktree, or continued from the recorded replay tip.
This change recognizes a small set of common Git spellings that map cleanly to existing Grit behavior and replaces misleading clap suggestions with Grit-specific migration hints. The round-two fixes preserve reset hint formatting and make message-less annotated-tag requests fail consistently as structured usage errors.
Mtime/ctime-only changes now refresh tracked index stat metadata without being reported as staged content. The index refresh is persisted for both `grit add` and auto-staging commit flows, while actual content and mode changes retain their existing staged behavior.
Normalizes the worktree component of grit’s UNTR cache identity and emits Git’s `Windows` system name on Windows. This lets system Git accept grit-written untracked-cache extensions instead of warning and discarding them on every status.
This change makes repeated `grit blame -C` levels trace moved and copied chunks back to their source files, including groups of individually short lines. The round-2 follow-up restores performance by comparing candidate blob content first and recursively blaming only the selected source.
GC and full repack now treat alternate object stores as reachability boundaries, so shared clones pack only objects physically owned by the clone. The round-2 correction makes prune-packed distinguish alternate pack membership from alternate loose membership, preserving local loose duplicates in the latter case to match Git.
This change sizes Windows loose-object reads to the compressed file bytes remaining, avoiding oversized 64 KiB reads that trigger severe cold-file overhead. It also makes fsck validate and retain each loose object only until its ordered result is consumed, eliminating both the duplicate read and the prior unbounded inflated-payload retention.
Conflicted submodule paths now stage the checked-out submodule commit as a mode-160000 gitlink instead of an empty executable blob. Status no longer mislabels conflicted submodules as untracked, restore can check out either conflict side, and round 3 keeps ordinary `grit add .` on its original fast matcher path.
This change makes ignored directory excludes opaque to the untracked walker when Git would report the directory as one unit, then carries that proof into clean so it can avoid redundant preservation walks. It also uses directory-entry type data during required rescans and avoids unnecessary ignore-file metadata probes while preserving symlink handling.
Large diff sides now use object headers or worktree metadata to classify files over `core.bigFileThreshold` without materializing their contents. The follow-up preserves Git-compatible forced-text behavior when a path selects a diff driver configured with `binary=false`.
This change routes stat/numstat and `log -G` through the same xdiff-derived line alignment used by patches, with regression coverage against system Git. Round 3 replaces whole-file changed-mask expansion with direct middle-mask counting and special-cases uniform unchanged affixes, improving the previous revision but leaving a measured 30.7% hot-path regression versus origin/main.
This aligns stat/numstat and `log -G` line selection with Grit’s own compacted patch alignment, while retaining a specialized LF-only count path for large files with small edits. The round-2 follow-up is mechanical: it removes one unnecessary mutable closure binding and replaces four manual membership scans with slice `contains`, allowing the enforced lint gate to pass.
Partial stash pushes now resolve hunk or line selections once inside grit-lib and return the resolved hunk IDs/line labels in both preview and push outcomes. The CLI no longer performs a duplicate unstaged diff, and the include-untracked conflict is enforced consistently for library callers.
Centralizes integration-test system-git execution, revision parsing, and localhost port selection in grit-test-support. Forty-nine test modules now import shared fixtures instead of maintaining local copies, reducing the change set by 1,023 net lines while preserving every test declaration.
Commit walks now inflate fallback commit objects into one reusable buffer instead of allocating and retaining session-cache copies per commit. JSON log output separately avoids constructing human-only summary rows and defers diff config loading until a diff format actually needs it.
Deletes the unused Git-style diffstat layout engine and its two public wrapper functions from grit-lib. It also removes the now-unneeded unicode-width workspace dependency and cleans up tests, coverage metadata, and the public API snapshot; grit-cli output is unchanged because it uses its own renderer.
Tree-to-tree diffs now merge-walk borrowed entries directly from raw tree payloads, avoiding per-entry name allocations while retaining parsed trees for callers that need owned entries. The same change makes the ODB session tree cache hold either raw or parsed trees under one byte budget, fixes custom-target `dist` profile reporting, and documents the daily benchmark profile and startup-cost conclusion.
Hunk selection now retains the underlying `grit_lib::Error` instead of flattening it to text, and exposes typed side, gitlink, path, and mode failures. The CLI only extends its exhaustive exit-code mapping, while new library tests prove callers can branch on the typed failures.
Replaces one shared mutex/hash-map ancestor-symlink cache with per-scan-worker prefix caches and, on 64-bit Linux, confirms clean deep directory chains with one openat2 walk. It retains component-by-component fallback for symlinks, missing paths, unsupported kernels, case folding, and Unicode resolution, and adds correctness plus probe-count guards.
The change avoids constructing full commit JSON and ref decorations when `grit revs` is rendering human or Markdown output, defers filter subprocess environment construction until a filter actually runs, and removes allocation from ObjectId display. It also records the benchmark evidence in the documentation and baseline bundle.
Adds a reusable grit-lib diffstat model containing per-file metadata, line counts, aggregate totals, maximum-change scaling, and typed bar widths. Diff, show, log/shortlog, and stash-show CLI paths retain their output contracts but delegate counting and scaling to the library.
Hard reset now updates an absent out-of-cone sparse-directory index entry directly to the destination tree instead of materializing, diffing, probing, and collapsing all descendants. A crate-private diff mode avoids reading either excluded subtree, while switch retains its stricter expansion behavior.
This replaces per-directory whole-index deletion and sorted insertion during sparse-index collapse with a deepest-first decision pass over a virtual collapsed view, followed by one rebuild of the entry vector. It also caches prefix-tree resolution, uses the ODB tree-walk cache, and adds unit plus system-Git round-trip coverage and benchmark documentation.
Removes seven unreferenced grit-lib functions and narrows one internal pack-index writer, reducing the library by 124 net lines. It also instruments actual MIDX metadata probes in test-only counters and reuses the shared HTTP media-type parser for non-Git-server detection.
This change accelerates reachability paints seeded by hundreds of refs by reading only packed commit header blocks in parallel and caching their parent/date linkage. It also short-circuits the common reset-backward ancestry check along the first-parent chain, while retaining full-read and full-walk fallbacks.
Reorders two adjacent PackBitmapWriteOptions field entries in the committed grit-lib API snapshot so it matches deterministic cargo-public-api output. No Rust source, behavior, public API shape, on-disk format, wire protocol, test, or documentation content changes.
This change makes worktree hunk restoration hold and load one index snapshot, then avoids rewriting `.git/index` when the restored file still differs from its index entry. It also removes redundant large-file diff copies/scans and shortens xdiff temporary lifetimes, reducing the target runtime substantially without changing public API or on-disk formats.
This removes stale pieces left behind when receive-pack migration moved to guard objects and repack concurrency moved to an inventory snapshot plus `gc_test_hooks`. It also corrects three private helper return paths to match their existing `Result<()>` signatures, restoring compilation without changing successful runtime behavior.
There is no integration delta: the submitted branch already matches origin/main exactly at 22ec3d073. That main commit removed incomplete maintenance hooks and corrected receive-quarantine helper return values, restoring compilation and CI, but none of that work remains unique to this branch.
Updates the committed grit-lib API snapshot so CloneOutcome.repo appears before CloneOutcome.submodule_paths, matching the struct declaration and generated cargo-public-api output. This is a snapshot-only correction with no runtime behavior change.
There is no change left to integrate: the reviewed workspace and origin/main both point to 5cabe3d7e. The stale public API snapshot was already corrected on main by c81d42371, which only reordered the CloneOutcome::repo and CloneOutcome::submodule_paths entries in the generated API snapshot.
Refreshes the committed grit-lib API inventory so its StageTrackedSummary fields appear in the order emitted by the pinned cargo-public-api tool. This is snapshot-only and has no runtime or API behavior change.
Updates one generated grit-lib API snapshot entry so `StageTrackedSummary` fields appear in the order emitted by the pinned cargo-public-api tool. There is no Rust source or behavior change.
Qualifies the `line_change_counts` intra-doc link from `diff/core.rs` through the public `crate::diff` re-export. This removes the only broken rustdoc link reported by the failing main CI job without changing compiled behavior.
This changes one rustdoc link in the diff line-count API to name its crate-qualified target explicitly. It has no runtime, public API, storage-format, protocol, or CLI behavior impact.