100 issue fixes · 31 other changes
v0.5.25 is mostly a performance and correctness release: large speedups in rebase, merge, checkout, reset, log, fetch and ref handling, plus many Git-compatibility fixes.
Auto-staged commits now hold the repository index lock before staging and give hooks a temporary index containing the staged view. The real index is persisted only after the ref update, so failed pre-commit or commit-msg hooks no longer destroy a curated staged/unstaged split or stage untracked files.
Tree and commit-pair stats now count the compacted line operations already used by structured patches, instead of taking a separate LF-only shortcut. This removes phantom or missing lines in stat/numstat/shortstat while retaining the existing shared patch and pickaxe alignment.
Rebase now distinguishes the branch's first-parent line from commits that enter through a merge. Side branches retain their own ancestry, and resolving a stopped merge replay keeps all merge parents, preventing merged files and topology from being silently lost.
Binary patch-text emission now retains the inflated blob or worktree bytes needed to encode real `GIT binary patch` literal sections. Ordinary line/status diff paths still discard binary payloads and retain the existing big-file memory optimization.
Single-branch clones now follow only tags reachable from the selected branch instead of requesting every advertised tag and its history. Bare clones also stop creating synthetic `refs/remotes/<name>/*` refs, matching Git’s ref layout.
When grit exposes a stopped rebase to Git, the Git-visible todo now contains only commits belonging to the branch actually being rebased. Grit retains its complete internal replay plan, so resuming with grit still updates stacked branches while resuming with Git finishes only the primary branch.
Already-based rebases with `--exec` now run commands over the selected commit range without changing commit IDs when commands are no-ops. If a command amends history, the checked-out branch and scoped stacked branches are remapped together; human, Markdown, and JSON output report executed commands instead of claiming nothing happened.
Reftable repositories no longer fail integrity checks solely because of the Git-compatible HEAD and refs/heads sentinel files. Fsck now validates the actual shared and worktree-local reftable stacks, and the round-3 commit brings the public API snapshot in sync with the added store traversal method.
Files-backed ref transactions now own their lock and snapshot state per prepared transaction, so independent branches update concurrently instead of contending on one repository-wide writer slot. Commit-time directory/file ref-name races remain safe and typed, and round three restores unrelated MSRV and Unix interruption coverage that regeneration had accidentally displaced.
Newly installed kept packs and their index/reverse-index sidecars are finalized read-only while honoring the process umask and core.sharedRepository. Receive-pack now writes Git-compatible readable modes for shared repositories and emits a valid .rev by default; the round-two follow-up also restores two unrelated regression-test gates that had been weakened.
Wide merges now apply sparse merge results to the index in one sorted compaction/merge pass instead of shifting a large entry vector once per touched path. Matching stage-0 rows survive harmless in-memory fsmonitor flag differences, and remaining stat rows are overwritten in place.
Prevents add and commit auto-staging from silently changing indexed path case on case-folding filesystems. It preserves indexed directory/leaf spellings for aliases and makes filesystem case detection collision-safe, while retaining tracked-path respelling on case-sensitive filesystems.
Merge comparison now preserves CRLF-vs-LF differences by default, including a lone CR on an incomplete final line. It still supports explicit ignore_cr_at_eol behavior and produces Git-compatible conflict blobs/stages for the reported histories.
Ref transactions now reject malformed symbolic-ref targets before locking or writing, with a typed error. Repository-backed stores also validate every nonzero object ID that a reflog-only update will record—including the previously missed `log_only + new_value: None` representation—while preserving object-blind raw backends and explicit verification opt-outs.
Absorb no longer treats a second local branch name at HEAD as a history boundary. When another local tip genuinely excludes an introducing commit, plans and CLI output identify that ref, while commits excluded independently by the ten-commit cap or fork-point remain ordinary no_candidate results.
Makes reset output accurately distinguish a preview from a reset that has already moved the branch. Successful resets identify the previous tip and give a concrete recovery command, while Markdown gains the same recovery guidance and JSON remains stable.
Successful remote ref deletions now render as deletion actions instead of ordinary pushes. JSON gains an optional per-result `deleted: true`, while normal pushes and existing rejection/exit behavior remain unchanged.
Blame now preserves exact bytes for individual non-UTF-8 lines while retaining the existing lossy display string. Structured CLI output marks only affected lines, including a parallel per-line flag array for grouped JSON.
A normal `grit commit` can now correctly finish a conflicted pick or revert instead of leaving stale operation state. Pick completion preserves the picked commit's author identity and date, while replay continue/abort/skip understand a step that was committed through the normal commit command.
This change prevents the Windows files ref backend from creating loose refs or reflogs under Win32-reserved path components, while leaving Unix and reftable behavior intact. Initial imports that are guaranteed to write only packed-refs remain accepted, including reserved names such as `aux`.
Adds an atomic git-dir file replacement path that retries transient Windows sharing failures and closes index lock handles before publication. It preserves fatal ACL errors, reports exhausted index/ref contention as retryable file-in-use errors, normalizes ref lock paths, and documents the CLI guidance.
Large-pack object lookups now use the slot encoded in each v2 index row to read the corresponding 64-bit offset directly. This removes a scan from row zero on every lookup while preserving corruption checks at the appropriate lazy- and strict-open boundaries.
Tree listings now derive each entry's displayed type solely from its mode, without opening the referenced object. `grit cat` parses a tree once and builds only the representation needed for the selected output mode; `grit show REV:path` reuses its first parse and preformatted human bytes.
This adds a per-plan replay merge session that analyzes the fork-to-onto delta once, then splices simple disjoint commit changes directly into the new parent tree. Collisions and complex cases retain the existing three-way merge fallback, while partial tree writing now prunes empty subtrees correctly.
This change makes bulk object-id abbreviation use mmap-backed pack-index neighbor checks and cached loose-object state, then uses that batch API to render plain human/Markdown `log --oneline` directly from revwalk-retained commit bytes. The round-3 fix preserves uniqueness when a collision lives in an alternate object store by forcing bounded full-ODB disambiguation whenever secondary read layers are configured.
Merges with multiple equally good ancestors now first combine those ancestors into a virtual merge base. Prediction, merge-tree writing, and real branch integration share the same implementation, including Git-compatible nested conflict blobs and outer-only ours/theirs favoring.
Makes pack sidecar permission finalization compile across Unix platforms whose mode_t widths differ. It also fixes the existing permission regression test so its 022 and 077 expectations are exercised under the intended process umask.
Hard reset now reconciles the loaded index with the target tree in place, probes worktree state by index position, and rebuilds valid target cache-tree metadata instead of retaining several full-tree/index copies. The round-five addition specifically restores the target cache-tree after different-commit resets using lockstep subtree reuse with a tree-derived fallback.
This protects both index entries when two directory spellings collapse onto one worktree directory on a case-folding filesystem. Status and auto-stage now recognize that the shared file already contains a sibling entry’s blob, but a genuinely new edit still updates the actual dentry spelling.
Repository-backed injected ref stores now honor core.filesRefLockTimeout when retrying a busy writer slot. This fixes high-contention MemoryRefStore and database-style backends without changing raw prepare semantics or uncontended writes.
Activates the already-implemented Win32 loose-ref path guard in the files ref store. Ordinary transactions now reject reserved path components before creating ref locks or loose files, while the initial packed-only optimization remains allowed because it creates no Win32-inaccessible path.
When a stopped rebase completes through continue or skip, Grit now rewrites `history-last` after HEAD is reattached. The record names the original branch and its true pre-/post-rebase tips, allowing history undo and redo to work like an uninterrupted rebase.
Content-producing tree diffs now gather their distinct old/new blob IDs and prefetch all missing promised blobs before parallel workers read content. Name-only diffs still avoid blob fetches, and the existing per-object lazy-fetch path remains available for unbatched callers.
This change divides directory-sorted tracked entries into balanced worker slices, allowing one very large directory to use multiple stat workers. It keeps slices ordered, checks symlink ancestors before each slice, and leaves Windows on one worker per directory to avoid duplicate listings.
Short local branch names passed to the merge porcelain API are canonicalized to `refs/heads/...` before any merge state or ref update. Missing short branches now return `BranchNotFound` without writing `ORIG_HEAD`, while full refs retain the existing compare-and-swap behavior; docs and system-Git-backed regression coverage describe both forms and merge-message behavior.
Ref transaction preparation no longer copies every stored ref and reflog. It probes the ordered ref map for D/F conflicts, simulates ordered writes in a small overlay, and commits MemoryRefStore transactions in place with touched-state rollback.
Strict receive-pack verification no longer reloads ordinary blob payloads after the unpack path has already streamed and stored them. It still parses all object kinds that can contain references and preserves the separate `.gitmodules`/`.gitattributes` validation path.
Ref-store transactions now invoke geometric reftable compaction after publishing a successful table update, keeping repeated updates bounded instead of accumulating one table per transaction. The round-2 fix explicitly carries the repository Environment into write-option discovery, preserving the hygiene contract without hidden process reads.
RefTransaction now maintains a private set of queued ref names, so adding each update no longer scans every prior update. Immediate duplicate rejection and all existing transaction behavior remain unchanged, with focused tests covering constructor synchronization and scaling.
Optimizes Myers line diffing for large repetitive text by materializing contiguous interned record IDs and reusing per-thread scratch buffers. It also gives no-index shortstat a hunk-free line-count path while preserving the existing three-argument public diff_paths API.
This change teaches protocol-v0/v1 upload-pack negotiation to tell multi_ack_detailed clients when their acknowledged history fully covers the requested commits. It also corrects the round-state edge case from review round 1, ensuring any absent have suppresses a later flush-time ready response while preserving the immediate absent-oid ready response when coverage was already established.
Repository-aware ref operations now consistently use the Repository’s selected RefStore, so an injected backend cannot silently diverge from stray HEAD or refs files. Bare git-dir helpers remain supported and are explicitly documented as opening a fresh on-disk backend.
Local and file-backed fetches now expose enumeration, copying, indexing, and delta-resolution progress instead of staying silent through most of the operation. The round-2 correction makes whole-store local clone totals and updates count Git objects, not pack sidecar files or wanted refs.
Caches the fork-to-onto diff, file renames, directory rename roots, and similarity scores once per replay session. Overlapping commits then reuse that analysis in a sparse three-way transplant, while conflicts are returned directly and unsupported cases retain the full-merge fallback.
Upload-pack now writes the PACK header, entries, and trailer directly to the caller instead of retaining a complete pack or large object in anonymous memory. Packed whole objects are copied from mmap-backed ranges in 64 KiB chunks, while large loose objects are inflated and re-deflated through bounded streams.
Extends the in-process serve API so receive hooks can inspect push options before refs move, uploads return typed transfer statistics, and upload/receive operations can be cancelled. The round-two fix preserves upload statistics across normal stateful protocol-v2 command sequences instead of discarding them at EOF.
This change makes sparse:oid enumeration cache sparse path decisions and fully enumerated subtrees without skipping unchanged parent subtrees across commit history. It also supplies pack name hashes and adds system-Git compatibility regressions for nested, aliased, and deep-history tree shapes.
Fetch and push can now use a custom writable object-store primary instead of requiring the files backend. Clone can populate an already-open repository while preserving injected object and ref stores, including correct default-branch creation and worktree checkout.
Bounds wide-tree checkout memory by processing write jobs and outcomes in chunks, reducing per-file checkout metadata, and releasing hard-reset planning data before applying changes. It also corrects bulk checkout attribute handling per path and adds reliable Git-compatibility and peak-RSS regressions tied to the exact release binary under test.
Status can now be explicitly read-only and honors captured GIT_OPTIONAL_LOCKS, avoiding opportunistic index writes and rewrite recovery when optional locks are disabled. The CLI exposes the same behavior globally, compatibility tests cover index/journal preservation, and the round-2 repair keeps unrelated hard-reset coverage in the default gate.
Reflog read-modify-write operations are serialized by each built-in ref backend, preventing concurrent ref updates from being overwritten. Delete, expire, and stash-drop paths now perform their decisions against locked current state or use snapshot validation and retry.
Large full objects can now be copied from v1-index packs without first inflating the entire payload into anonymous memory. The same bounded CRC path is reused for v2 bitmap selection, large body writes are chunked, and the regression fixtures now use genuinely incompressible data.
Grit now recognizes a common Git habit when users pass `-n` to add, rm, mv, clean, or push and points them to the supported long-form `--dry-run`. The existing misleading Clap suggestion to treat `-n` as a path is suppressed, including for clean's `-fn` and `-nf` clusters.
An environment supplied while initializing a repository now remains attached to the returned handle across normal, bare, separate-git-dir, and bare-with-worktree layouts. Commit creation also validates author/committer identity before storing the tree, preventing failed first commits from leaving dangling trees.
Filtered and path-limited log walks now honor a committer-date `--since` frontier even when callers omit an explicit `-n`. This fixes the default-page case that previously traversed all history when fewer matches existed than a page could fill.
This changes rename and copy similarity from whole-line hashes to the 64-byte/newline span hashes used by Git 2.43. It preserves raw blob sizes in the denominator, handles CRLF the same way as Git, and routes the corrected score through JSON diff and stable patch-id generation.
Paused rebase state is now detected before commands interpret its detached HEAD or conflict markers as unrelated errors. Pull, merge, rebase, pick, revert, and branch rename render a consistent refusal with actionable continue/abort commands, while foreign Git-owned rebases retain Git-specific ownership messaging.
Reset orphan warnings now tell users to recover with the same reset mode that caused the branch move. Following a hard-reset hint restores deleted tracked files, while soft and keep recovery retain their non-destructive mode semantics; mixed remains the unflagged default.
Patch-ID hashing now decodes invalid UTF-8 with the same borrow-or-lossy rule used by structured diffs, instead of treating an entire blob side as empty. This restores hunk alignment for invalid bytes in distant unchanged text and fixes the reported insertion mismatch across all three patch-ID text-hunk paths.
GC now respects the maintenance settings users carry from Git: commit-graph and ref packing can be disabled, `notbare` behaves correctly, and either bitmap spelling participates in load-order precedence. Ref cleanup also keeps stable namespace directories such as `refs/heads` while still pruning empty descendants.
This change removes duplicate cwd resolution for log/revs pathspecs and completes the pathspec engine behavior needed for excludes and long glob magic from subdirectories. It adds CLI and library Git-oracle regressions for ordinary relative paths, top magic, excludes, globs, and pathspec files.
Bare repository HEAD now remains a ref pointer rather than being mistaken for a checkout. This enables the standard bare-repo-plus-linked-worktrees layout while retaining branch exclusivity once a real linked worktree checks out the branch, and list output identifies the bare row clearly.
A conflict-resolution commit made during a grit-owned rebase stop now counts as the rewritten pick, so `rebase --continue` safely replays the remaining commits instead of reporting nothing to commit. Round 3 closes the legacy-state escape hatch by validating any inferred stop against the saved replay base before applying the first-parent safety check.
Global `:/<text>` resolution now searches commits reachable from all refs and HEAD in descending committer-date order, rather than returning the first ref-order match. The round-2 revision removes the many-ref slowdown by sourcing linkage from the commit-graph when available and caching each fallback commit parse/message.
This change makes machine-readable revision failures consistent across the affected commands while retaining each command's existing human error text. It also gives branch-create failures their documented start-point kind and names missing filesystem paths in bundle/init errors.
Path-limited revision walks now descend through wildcard and case-folded directory components instead of incorrectly pruning matching subtrees. The round-3 correction makes the new case-insensitive prefix test safe for unrelated non-ASCII directory names, preventing the reported panic.
AuthStore now gives SQLite a Windows extended-length path only when an absolute database path exceeds the traditional 259-UTF-16-unit limit. The caller-visible path remains unchanged, and regression coverage verifies drive paths, UNC paths, slash normalization, repeatable setup, persistence, and already-prefixed reopen behavior.
Large non-atomic receive-pack batches now attempt one ref transaction instead of committing every accepted command separately. Plain direct creates are published by one locked packed-refs rewrite; mixed batches use the regular transaction path, and a failed non-atomic batch retries per ref so valid commands can still land.
This change makes reftable readers reload the stack when concurrent compaction removes or briefly exposes an unusable table, and changes writers to publish fsynced temporary table files. It adds concurrent reader/writer coverage and Git fsck/ref verification.
This replaces repeated full reftable scans and per-ref lookups with indexed range iteration and merged stack traversal. It also safely short-circuits small, name-sorted single-namespace queries while preserving global ordering for multi-namespace callers.
Non-atomic receive-pack now batches ref work into at most two store transactions: deletions first, then creates/updates, while preserving per-ref rejection reporting. The round-3 fix ensures allowing-failures preparation still executes rename-only transactions instead of silently treating them as empty.
Detached checkouts can now perform real, predictive, fast-forward, conflict, continuation, abort, squash, and no-commit merge flows without moving a branch ref. The round-2 correction ensures a completed conflicted merge reports that HEAD moved rather than falsely claiming the current branch moved.
Conflict merges now retain one checkout rollback journal until the single in-memory index has been spliced with conflict stages and safely written. Merge abort also reuses the one-index hard-reset path, reducing peak memory while preserving conflict files, unmerged index stages, cancellation rollback, and Git interoperability.
Hard reset now uses the parallel checkout writer for tree transitions, batches staged index realignment for reset-to-HEAD, and parallelizes the unchanged-path stat scan. Merge abort replaces a full worktree-stat index rebuild with an index/tree diff and the same fast checkout machinery.
Reftable table publication now atomically refuses to overwrite a final `.ref` path created by a concurrent writer. Failed staged writes are cleaned up, and a deterministic race test verifies preservation plus retry behavior.
Status now observes cancellation during the expensive tracked-file stat and racy-content-check phases instead of waiting for the complete scan. Round 3 keeps ProgressSink polling on the owner thread while removing the crate-private poll type from the public diff options API.
Interrupts during commit, stash, merge, pick, and revert now become cooperative cancellation instead of immediately terminating the process. That lets existing checkout rollback and lock guards restore repository state and delete `index.lock` before the CLI reports `operation cancelled`.
Status now remembers the exact on-disk index identity it loaded and checks that identity again only after acquiring index.lock. If a concurrent commit replaced the index, status drops its optional refresh instead of writing stale entries over the commit’s index.
Replay bookkeeping now records both the paths changed by a topic commit and the corresponding post-/pre-rename paths from the cached upstream delta. That prevents cache validation from mistaking a replayed edit at the moved destination for external drift and rebuilding rename analysis for every commit.
Dry-run commit previews now notice mode changes even when blob content is unchanged. A chmod-only preview succeeds and reports the path as modified, while mixed mode/content previews list the same files as the real commit.
Header-only commit and annotated-tag objects are now readable when EOF terminates the headers without a blank message separator. Grit treats the absent body as an empty message, allowing history walks and object-moving operations to proceed, while writers continue emitting canonical blank-line separators.
This change prevents a wide checkout from repeating whole-index finalization for every 2,048-path slice. It precomputes worktree rules once, uses existing bounded bulk writers for eligible diffs, and finalizes cache-tree/index state once for general chunked diffs.
Library callers can now pass a repository-relative blame path without results changing with the host process cwd. The CLI still behaves like Git from subdirectories by resolving its file operand once before both range parsing and blame, and it displays that same resolved path.
Canonicalizes historical non-standard regular-file modes whenever trees are compared with an index/worktree or used to populate an index. This removes phantom status/diff changes and prevents checkout and hard reset from writing index modes that system Git rejects.
Makes typed tree creation validate every referenced object’s existence and mode-implied kind before writing, while preserving an explicit `allow_missing` escape hatch for partial clones and bottom-up assembly. It also refuses symlinks using Git-reserved metadata spellings, including the NTFS `foo\\.gitmodules` case fixed in round 2.
Adds a bounded streaming date-order walk for logs constrained by first-parent and/or merge-parent-count filters. It stops after the requested matching page while retaining correct parent counts under first-parent traversal and preserving count results.
Local fetch now reports source pack-index scanning as enumeration work, without claiming that examined objects have already been copied. Copy progress and received-object counts begin only after hard-linked packs, loose objects, or generated remainder packs are installed.
Default fetch now ignores a remote tag move when that tag name already exists locally, so routine fetches remain successful and leave the local tag untouched. Explicit tag fetches retain rejection safety, and `--force` provides a documented way to accept tag or non-fast-forward updates; pull uses the same option and stops on fetch rejection.
Switch now reports case-colliding tracked paths through the public library outcome and all CLI output modes. Checkout smudges misleading collision stat records, while diff/status hashes collision members and commit reports remaining drift instead of falsely declaring a clean tree.
This change makes merge-preserving rebase replay integration branches whose first-parent history consists only of no-ff merges, instead of incorrectly declaring them up to date. It also preserves the documented staged conflict-resolution workflow after side branches are replayed before the mainline.
Inexact rename detection now gathers unresolved old/new blob IDs and performs one promisor batch fetch before probing sizes or loading content. Two large partial-clone regressions lock in single-request/single-pack behavior beyond the previous cliff.
This change removes two sources of repeated work during delete-heavy switches. Wholesale safety scans now use precomputed directory prefixes, while checkout builds the prospective index and destination attribute rules once with bulk index updates instead of rebuilding them path-by-path for every chunk.
Preserves split-index metadata while a commit writes the temporary unified index exposed to hooks. The later primary-index write can therefore reuse the existing shared base for small changes instead of emitting a full new sharedindex on every commit.
Adds a typed grit-lib workspace snapshot API that preserves HEAD, selected refs, raw index stages, worktree contents, and in-progress operation files, then restores them through one repository handle. It also makes stash apply optionally tolerate byte-identical untracked collisions, improves structured error serialization, and adds a required-identity constructor for stash pushes.
This replaces merge abort's full hard-reset-style rebuild/stat scan with an index-to-ORIG_HEAD alignment checkout using the parallel checkout writer. It retains trustworthy index stats for unchanged rows, lets rewritten rows receive fresh checkout stats, refreshes only remaining unset rows, and explicitly restores/deletes conflict-only paths.
This change makes object freshening robust when pack or loose-object files are read-only, while preserving the exact timestamp used on disk for pack-cache signatures. It centralizes the permission-clear/retry/restore behavior and adds scale plus compatibility regression coverage.
This change keeps wholesale directory removal for truly deleted trees while excluding any top-level directory reused by the target tree. That prevents newly written files and index rows from being erased during switch/checkout, including across bounded checkout chunks.
This change makes grit-lib cleaner for embedders: internal commit/fetch driver state is no longer exposed, common commit-only revision walks can stream lazily, and platform-specific code builds without the reported Windows warnings. It also makes symlink restoration validate and create links safely without deleting an existing path before an unsupported operation fails.
Keeps Git-written cone sparse indexes compact across status, diff, and clean add operations, and teaches staged diff to compare sparse-directory placeholders without expanding the whole index. The round-3 correction handles an out-of-cone staged subtree that does not exist in HEAD by reporting its leaf files as additions rather than returning a directory row.
Parallelizes cancellation rollback for wide checkouts, including file removal and restoration, so cancelling no longer serially rewrites every completed path. The follow-up also makes rollback correct for truly delayed process filters by restarting stale filters and completing or retrying delayed smudges before returning.
Qualifies one intra-doc link in the diff API with its crate-level public path. This removes the only broken-link error that made strict workspace rustdoc fail, without changing compiled behavior or API shape.
No branch-specific change exists. The branch records that main already contains the one-line fully-qualified rustdoc link fix at 6565b24e2, and the originally failing documentation build is green.
Removes one private rebase helper that was introduced but never called. This restores the clippy gate without changing runtime behavior or any supported API.
This review branch is a no-op against current main. The dead-code helper that broke clippy had already been removed by commit 99dedcac7 before the branch tip, so no additional source change is present or needed.
Qualifies the replay-abort rustdoc links so strict documentation builds resolve them, and refreshes the committed grit-lib API snapshot with the pinned generator. This is documentation and generated-snapshot maintenance only; runtime behavior is unchanged.
There is no branch-specific change to integrate: the review branch is byte-for-byte the same commit as current origin/main. The original rustdoc-link and public-API snapshot repair had already landed on main before this branch was prepared.
This consolidates staged, unstaged, and working-tree diff collection/content loading behind a repository-scoped grit-lib API. grit-cli now filters and renders library results instead of manipulating the index, worktree rules, object sides, and gitlink text itself.
This replaces roughly twenty hand-written “read object, check commit kind, parse commit” paths with the existing `Odb::read_commit` and `Odb::commit_tree` APIs. Six private commit-tree helpers disappear, CLI loaders become thinner, typed wrong-kind errors become consistent, and focused tests pin the intentionally preserved exceptions.
This removes avoidable work from clean status: tracked files are discarded while reading directories, sorted indexes are searched directly instead of copied into a hash set, per-directory ignore files load only when needed, and worktree refresh checks allocate only when hashing is required. The CLI remains unchanged and all behavior stays in grit-lib.
Regenerates the committed grit-lib public API snapshot so the seven `ref_lock_wait` entries appear in cargo-public-api's emitted order. This is a generated-data-only correction; it does not alter the Rust API or runtime behavior.
Adds one cache-backed ODB API for locating a byte path inside a tree and routes ten private walkers through it. The change removes duplicated tree parsing across diff, history, blame, stash, merge enrichment, and snapshot checkout while retaining each caller's leaf filtering and error mapping.
This review branch contains no code or snapshot changes. It confirms that main already contains the generated public-API snapshot ordering correction and that the submitted head is green.
This removes repeated fixed work from repository opening and log walks: one shared config snapshot, one ODB pack context/reader per page, and reuse of mapped pack indexes. Human and Markdown log rendering also avoids constructing JSON-only commit models, while preserving JSON, decorated, diff, graph, and stat paths.
This change makes partial line staging operate on a path-restricted unstaged diff, then applies the selected patch without eagerly copying every line or the full index. It also removes unnecessary per-line allocations from structured hunk construction while preserving rendered text and hunk identities.
This applies rustfmt's canonical layout to the `parent_trees_slice` filter condition in rev-list traversal. It is a formatting-only change with no altered expression, API, output, object format, or wire behavior.
History absorb, fixup, squash, drop, and subject now share commit-reading helpers and preserve underlying repository errors instead of flattening them into planning strings. Change-id generation failures receive their own typed HistoryError variant, with public API snapshot and regression tests updated.
Stash stat generation now belongs to the library: RepositoryStash::diff_stat computes line statistics directly without constructing structured hunks and hunk IDs. The CLI only maps options and renders the returned DiffStat; stash diff entries also gain deterministic path ordering.
Enables nextest setup scripts and moves the checkout RSS setup hook into nextest's supported profile script tables. This makes the CI test command parse its repository configuration again instead of exiting before any tests run.
Shallow and deepen fetches over protocol v2 now advertise the objects the client already has, including the tip being deepened, so the server sends only missing history. Upload-pack also falls back to a graft-aware object walk when either side is shallow, avoiding bitmap closures that incorrectly cross the client's shallow boundary.
Refreshes the committed grit-lib public API manifest so its ordering matches the output of the repository’s pinned cargo-public-api tool. The diff only repositions existing declarations; it neither adds nor removes an API.
Removes an unused diff dependency and a set of public/library helpers that had no production callers, mostly remnants of the removed compatibility CLI and unsupported octopus/legacy diff behavior. It also clears test-build dead-code warnings and restores a status test that had accidentally stopped running.
Refreshes the committed grit-lib API inventory so it matches the deterministic output of the repository's pinned nightly and cargo-public-api version. The only differences reorder existing enum entries and ref-store methods; no API item, behavior, test, format, or protocol changes.
This changes CLI startup so clap copies root output/thread flags only into the top-level subcommand actually named by argv, instead of cloning them into all 55 commands. Unknown commands, bare invocation, help, and version retain the stock clap tree; tests compare every command and alias against stock parsing and error rendering.
Corrects the public rustdoc link for revision walking and removes a link to a private diff helper. The exact CI rustdoc command now completes successfully.
This change removes avoidable allocations and character decoding from config parsing, then makes repeated Repository::config() validation re-stat the already-known cascade instead of rebuilding environment-derived state. It adds focused Criterion coverage, exhaustive scanner-equivalence and session-invalidation tests, plus recorded benchmark evidence.
Refreshes grit-lib's generated public API baseline so it records the ref-transaction partial-failure interfaces already present in the library. This is a snapshot-only CI repair with no runtime behavior change.
There is no submitted code change to integrate. The review workspace is byte-for-byte current origin/main at 1d054b51c; the public API snapshot repair had already landed as 9ff05a6c8.
Builds the partial-clone benchmark source with one pack per commit batch regardless of newer Git repack consolidation behavior. It also keeps the fixture pack-only and invalidates cached fixtures whose pack or loose-object layout is stale.
This change disables Git's automatic maintenance in the synthetic partial-clone benchmark source repository. That preserves one pack per generated commit batch on Git 2.56 and restores the fixture's required four-pack layout.
The partial-clone many-pack fixture now disables Git's automatic garbage collection in addition to automatic maintenance. This keeps the synthetic repository's intended one-pack-per-batch shape stable when newer Git versions decide to consolidate small packs.
Refreshes the committed `grit-lib` public API snapshot so it exactly matches clean output from the pinned cargo-public-api generator. The patch only reorders one existing `SwitchOutcome::path_collisions` line; it does not change Rust code or the exported API itself.