@scolladon/tsgit 2.0.1 → 3.1.0

package/dist/types/chunks/index-Dfh8cvEs.d.cts

@@ -0,0 +1,2468 @@
+import { O as ObjectId, R as RefName, F as FilePath, c as Context, o as PromisorRemote } from './context-CF1YF2S8.cjs';
+import { p as FileMode, aO as IndexEntry, $ as StatData, G as GitIndex, q as FlatTree, a8 as TreeDiff, L as LineKey, a as AuthorIdentity, C as CatFileBatchEntry, aP as ConfigKey, aN as ConfigScope, X as RenameDetectOptions, a3 as StatTreeDiff, a4 as SubmoduleEntry, V as ReadObjectOptions, aQ as ReflogEntry, e as CommitData, a6 as TagData } from './reflog-entry-Dy-O27Dd.cjs';
+
+type BundleVersion = 2 | 3;
+type BundleHashAlgorithm = 'sha1';
+interface BundleRef {
+    readonly oid: ObjectId;
+    readonly name: RefName;
+}
+interface BundlePrerequisite {
+    readonly oid: ObjectId;
+    readonly comment: string;
+}
+
+type ConflictType = 'content' | 'add-add' | 'distinct-types' | 'modify-delete' | 'type-change' | 'rename-rename' | 'gitlink' | 'binary';
+interface MergeConflict {
+    readonly type: ConflictType;
+    readonly path: FilePath;
+    readonly baseId?: ObjectId;
+    readonly ourId?: ObjectId;
+    readonly theirId?: ObjectId;
+    readonly baseMode?: FileMode;
+    readonly ourMode?: FileMode;
+    readonly theirMode?: FileMode;
+    readonly conflictContent?: Uint8Array;
+    readonly contentVerdict?: 'clean' | 'content' | 'binary';
+    /**
+     * Three-way-merged mode for `content` conflicts (theirs' mode when only
+     * theirs diverged from the base, ours' otherwise). The working tree is
+     * materialised with this mode; the per-side stage entries keep their own.
+     */
+    readonly mergedMode?: FileMode;
+    /** Recorded path for our side; populated only on `distinct-types` conflicts. */
+    readonly ourPath?: FilePath;
+    /** Recorded path for their side; populated only on `distinct-types` conflicts. */
+    readonly theirPath?: FilePath;
+    /** Recorded path of the base's stage-1 entry; populated only on `distinct-types` conflicts that have a base. */
+    readonly basePath?: FilePath;
+}
+
+interface UnmergedEntryGroup {
+    readonly stage1?: IndexEntry;
+    readonly stage2?: IndexEntry;
+    readonly stage3?: IndexEntry;
+}
+interface GroupedIndex {
+    readonly staged: ReadonlyArray<IndexEntry>;
+    readonly unmerged: ReadonlyMap<FilePath, UnmergedEntryGroup>;
+}
+declare function diffIndexAgainstTree(index: GitIndex, tree: FlatTree | undefined): TreeDiff;
+declare function groupUnmergedEntries(index: GitIndex): GroupedIndex;
+declare function recordedPaths(conflict: MergeConflict): ReadonlyArray<FilePath>;
+declare function sortedRecordedPaths(conflicts: ReadonlyArray<MergeConflict>): ReadonlyArray<FilePath>;
+declare function conflictsToIndexEntries(conflicts: ReadonlyArray<MergeConflict>, statFactory: (mode: FileMode) => StatData): ReadonlyArray<IndexEntry>;
+
+/**
+ * The seven git conflict states, each a function of which merge stages
+ * (1 = base, 2 = ours, 3 = theirs) an unmerged path carries. They map to git's
+ * porcelain unmerged `XY` codes: `both-modified` → `UU`, `both-added` → `AA`,
+ * `both-deleted` → `DD`, `added-by-us` → `AU`, `added-by-them` → `UA`,
+ * `deleted-by-us` → `DU`, `deleted-by-them` → `UD`.
+ */
+type ConflictKind = 'both-modified' | 'both-added' | 'both-deleted' | 'added-by-us' | 'added-by-them' | 'deleted-by-us' | 'deleted-by-them';
+/**
+ * Classify an unmerged path by the presence of its base/ours/theirs stages. The
+ * seven non-empty subsets of `{1,2,3}` map one-to-one onto {@link ConflictKind};
+ * the fall-through final arm is the lone stage-3 case, total over a non-empty
+ * group (every group built from a real index carries at least one stage).
+ */
+declare const classifyUnmerged: (group: UnmergedEntryGroup) => ConflictKind;
+
+interface LineHunk {
+    readonly kind: 'common' | 'ours-only' | 'theirs-only';
+    readonly oursStart: number;
+    readonly oursEnd: number;
+    readonly theirsStart: number;
+    readonly theirsEnd: number;
+}
+interface LineDiffOptions {
+    readonly lineKey?: LineKey;
+}
+interface LineDiff {
+    readonly hunks: ReadonlyArray<LineHunk>;
+    readonly oursLines: ReadonlyArray<Uint8Array>;
+    readonly theirsLines: ReadonlyArray<Uint8Array>;
+    readonly degraded: boolean;
+}
+declare const BINARY_DETECTION_BYTES = 8000;
+declare const MAX_LINE_BYTES = 65536;
+declare const MAX_LINES = 100000;
+declare const MAX_DIFF_EDIT_DISTANCE = 10000;
+declare const MAX_DIFF_ITERATION_FACTOR = 1000;
+declare const MAX_DIFF_LINES = 50000;
+declare function splitLines(bytes: Uint8Array): ReadonlyArray<Uint8Array>;
+declare function isBinary(bytes: Uint8Array): boolean;
+declare function diffLines(ours: Uint8Array, theirs: Uint8Array, options?: LineDiffOptions): LineDiff;
+
+interface MergeAbortResult {
+    /** The commit `ORIG_HEAD` recorded; HEAD now points at this id. */
+    readonly origHead: ObjectId;
+    /** The branch HEAD is on (always defined — detached merges are rejected upstream). */
+    readonly branch: RefName;
+}
+/**
+ * Abort a conflicting merge. Restores the working tree, index, and branch
+ * ref to `ORIG_HEAD`, then clears `MERGE_HEAD` and `MERGE_MSG`. `ORIG_HEAD`
+ * is preserved on disk as a cross-operation recovery aid (ADR-173).
+ *
+ * Refuses when no merge is in progress (`MERGE_HEAD` absent) or when the
+ * merge state is incomplete (`ORIG_HEAD` absent — corrupt half-state).
+ *
+ * The hard-reset machinery is inlined rather than delegated to `reset` so
+ * the call can bypass `assertNoPendingOperation` (which would itself
+ * fire on the very `MERGE_HEAD` we're about to clear). See ADR-170.
+ */
+declare const mergeAbort: (ctx: Context) => Promise<MergeAbortResult>;
+
+interface AddOptions {
+    readonly force?: boolean;
+    readonly all?: boolean;
+}
+interface AddResult {
+    readonly added: ReadonlyArray<FilePath>;
+    readonly modified: ReadonlyArray<FilePath>;
+    readonly removed: ReadonlyArray<FilePath>;
+}
+/**
+ * Stage paths in the index. Two modes:
+ *
+ * - **Literal-path mode** (`paths` non-empty, `all` falsy): every path is
+ *  validated, read, hashed, and staged. Missing paths reject the whole call.
+ * - **Bulk mode** (`paths` empty, `all === true`): walk the working tree,
+ *  stage every modified/new tracked file plus every untracked, non-ignored
+ *  file. Files missing from disk but present in the prior index land in
+ *  `removed`. `.git` and embedded repositories are skipped.
+ *
+ * Both modes acquire `.git/index.lock` once, read the existing index under
+ * the lock, and commit a single replacement — no partial writes.
+ */
+declare const add: (ctx: Context, paths: ReadonlyArray<string>, opts?: AddOptions) => Promise<AddResult>;
+
+/** One entry in an archive export — path, raw git mode, object id, and optional content. */
+interface ArchiveEntry {
+    /** Repo-relative path of this entry (slash-joined, pre-order). */
+    readonly path: FilePath;
+    /** Raw git mode exactly as stored in the tree object. */
+    readonly mode: FileMode;
+    /** Object id of this entry (blob, tree, or gitlink commit oid). */
+    readonly oid: ObjectId;
+    /**
+     * Raw blob bytes. Present only for regular, exec, and symlink entries
+     * (symlink: the link-target bytes). Absent for directory and gitlink
+     * entries — serializer-side framing decides how those are encoded.
+     */
+    readonly content?: Uint8Array;
+}
+/** Structured result of `archive` — resolved tree metadata + lazy entry stream. */
+interface ArchiveResult {
+    /** The resolved tree object id that was exported. */
+    readonly tree: ObjectId;
+    /**
+     * Peeled commit oid. Present when the treeish resolved through a commit
+     * (direct or via an annotated tag). Absent for a bare tree treeish.
+     */
+    readonly commit?: ObjectId;
+    /**
+     * Committer epoch seconds. Present when `commit` is present. Used by
+     * serializers as the default mtime for archive entries.
+     */
+    readonly commitTime?: number;
+    /** Lazy entry stream — blob bytes are hydrated per-entry, not upfront. */
+    readonly entries: AsyncIterable<ArchiveEntry>;
+}
+
+/** Options for the `archive` command. */
+interface ArchiveOptions {
+    /**
+     * Tree-ish to export (branch name, tag, commit oid, tree oid …).
+     * Required — `git archive` refuses with no argument.
+     */
+    readonly treeish: string;
+}
+/**
+ * Resolve a tree-ish and return a structured entry stream — the data equivalent
+ * of `git archive`. No tar/zip bytes are produced here; serializers are separate
+ * pure functions that consume an `ArchiveResult`.
+ *
+ * Refusal conditions (thrown, never mid-stream):
+ * - `NOT_A_REPOSITORY`: `ctx` does not point at a git repository.
+ * - Unborn HEAD or unresolvable expression: propagated from `revParse`.
+ * - `UNEXPECTED_OBJECT_TYPE`: treeish resolves to a blob, not a tree/commit/tag.
+ */
+declare function archive(ctx: Context, opts: ArchiveOptions): Promise<ArchiveResult>;
+
+interface BlameOptions {
+    /** Commit-ish to blame as-of (default: HEAD). Mutually exclusive with `worktree`. */
+    readonly rev?: string;
+    /**
+     * Blame the working-tree content instead of a committed revision (git's bare
+     * `git blame <file>`): lines matching the committed history blame to their real
+     * commits, uncommitted lines to the "Not Committed Yet" pseudo-commit
+     * (`committed: false`). Mutually exclusive with `rev`; requires a working tree.
+     */
+    readonly worktree?: boolean;
+    /**
+     * Restrict the reported lines to a 1-based inclusive `[start, end]` window over
+     * the final file (git's `-L`). `end` past the last line is clamped; a start
+     * below 1, a start past the last line, or an inverted/non-integer range refuse.
+     */
+    readonly range?: {
+        readonly start: number;
+        readonly end: number;
+    };
+}
+/** Fields shared by every blamed line, committed or not. */
+interface BlameLineBase {
+    /** 1-based line number in the queried file. */
+    readonly finalLine: number;
+    /** 1-based line number in the originating blob (the queried-file position for an uncommitted line). */
+    readonly sourceLine: number;
+    /** Path the file had in the originating version — rename-aware. */
+    readonly sourcePath: FilePath;
+    /** Where the committed base lives; absent for a staged-new file (not in HEAD). */
+    readonly previous?: {
+        readonly commit: ObjectId;
+        readonly path: FilePath;
+    };
+    /** The line's bytes (newline-terminated except a final line without a trailing LF). */
+    readonly content: Uint8Array;
+}
+/** A line blamed to a real commit. */
+interface CommittedBlameLine extends BlameLineBase {
+    readonly committed: true;
+    /** Commit this line is blamed to. */
+    readonly commit: ObjectId;
+    readonly author: AuthorIdentity;
+    readonly committer: AuthorIdentity;
+    /** Commit subject (first message line). */
+    readonly summary: string;
+    /** Blamed commit is a root (no parents). */
+    readonly boundary: boolean;
+}
+/**
+ * A line not yet committed — git's zero-oid "Not Committed Yet" pseudo-commit.
+ * The library emits none of git's fabricated oid / identity / timestamp / summary
+ * (those are the caller's to render); `committed: false` losslessly signals it.
+ */
+interface UncommittedBlameLine extends BlameLineBase {
+    readonly committed: false;
+}
+type BlameLine = CommittedBlameLine | UncommittedBlameLine;
+interface BlameResult {
+    /** The queried path (final name). */
+    readonly path: FilePath;
+    readonly lines: ReadonlyArray<BlameLine>;
+}
+declare const blame: (ctx: Context, path: string, opts?: BlameOptions) => Promise<BlameResult>;
+
+interface BranchInfo {
+    readonly name: RefName;
+    readonly id: ObjectId;
+    readonly current: boolean;
+}
+interface BranchListResult {
+    readonly branches: ReadonlyArray<BranchInfo>;
+}
+interface BranchCreateInput {
+    readonly name: string;
+    readonly startPoint?: string;
+    readonly force?: boolean;
+}
+interface BranchCreateResult {
+    readonly name: RefName;
+    readonly id: ObjectId;
+}
+interface BranchDeleteInput {
+    readonly name: string;
+    readonly force?: boolean;
+}
+interface BranchDeleteResult {
+    readonly name: RefName;
+}
+interface BranchRenameInput {
+    readonly from: string;
+    readonly to: string;
+    readonly force?: boolean;
+}
+interface BranchRenameResult {
+    readonly from: RefName;
+    readonly to: RefName;
+}
+declare const branchList: (ctx: Context) => Promise<BranchListResult>;
+declare const branchCreate: (ctx: Context, input: BranchCreateInput) => Promise<BranchCreateResult>;
+declare const branchDelete: (ctx: Context, input: BranchDeleteInput) => Promise<BranchDeleteResult>;
+declare const branchRename: (ctx: Context, input: BranchRenameInput) => Promise<BranchRenameResult>;
+
+type BundleRevArg = {
+    readonly tip: string;
+} | {
+    readonly exclude: string;
+} | {
+    readonly range: readonly [string, string];
+} | {
+    readonly symmetricRange: readonly [string, string];
+};
+interface BundleCreateOptions {
+    readonly revs?: ReadonlyArray<BundleRevArg>;
+    readonly all?: boolean;
+    readonly branches?: boolean;
+    readonly tags?: boolean;
+}
+interface BundleCreateResult {
+    readonly version: BundleVersion;
+    readonly bytes: Uint8Array;
+    readonly refs: ReadonlyArray<BundleRef>;
+    readonly prerequisites: ReadonlyArray<BundlePrerequisite>;
+    readonly objectCount: number;
+    readonly packSha: string;
+}
+/**
+ * Produces a v2 git bundle — the full object closure for the given rev
+ * selection plus the structured header metadata.
+ *
+ * Returns `bytes` (header ++ packfile) for the caller to write, alongside
+ * the structured metadata so the caller can inspect the result without
+ * re-parsing. Throws `BUNDLE_EMPTY` if the selection yields no ref lines
+ * (`reason: 'no-refs'`) or an empty object closure (`reason: 'no-objects'`).
+ */
+declare const bundleCreate: (ctx: Context, opts: BundleCreateOptions) => Promise<BundleCreateResult>;
+
+interface BundleListHeadsInput {
+    readonly path: string;
+    readonly names?: ReadonlyArray<RefName>;
+}
+interface BundleListHeadsResult {
+    readonly version: BundleVersion;
+    readonly refs: ReadonlyArray<BundleRef>;
+}
+declare const bundleListHeads: (ctx: Context, input: BundleListHeadsInput) => Promise<BundleListHeadsResult>;
+
+interface BundleVerifyInput {
+    readonly path: string;
+}
+interface BundleVerifyResult {
+    readonly version: BundleVersion;
+    readonly hashAlgorithm: BundleHashAlgorithm;
+    readonly refs: ReadonlyArray<BundleRef>;
+    readonly prerequisites: ReadonlyArray<BundlePrerequisite>;
+    readonly missingPrerequisites: ReadonlyArray<ObjectId>;
+    readonly prerequisitesPresent: boolean;
+    readonly recordsCompleteHistory: boolean;
+}
+declare const bundleVerify: (ctx: Context, input: BundleVerifyInput) => Promise<BundleVerifyResult>;
+
+/**
+ * Tier-1 `catFile` command — wraps the streaming `catFileBatch` primitive in
+ * a request/response shape matching the other v2 commands (`submodules`,
+ * `log`, `reflog`). String ids are coerced at the boundary via
+ * `ObjectId.from`, which throws `INVALID_OBJECT_ID` on malformed input
+ * before any read happens.
+ *
+ * For streaming use cases, callers reach for `repo.primitives.catFileBatch`
+ * directly — see `docs/design/cat-file-batch.md` §2.
+ */
+
+interface CatFileInput {
+    readonly ids: ReadonlyArray<ObjectId | string>;
+    /** Per-object byte cap; forwarded to the underlying `readObject` call. */
+    readonly maxBytes?: number;
+}
+interface CatFileResult {
+    readonly kind: 'batch';
+    readonly entries: ReadonlyArray<CatFileBatchEntry>;
+}
+declare const catFile: (ctx: Context, opts: CatFileInput) => Promise<CatFileResult>;
+
+interface CheckoutSwitchOptions {
+    readonly rev: string;
+    readonly detach?: boolean;
+    readonly force?: boolean;
+}
+interface CheckoutPathsOptions {
+    readonly paths: ReadonlyArray<string>;
+    readonly source?: 'index' | 'HEAD' | ObjectId;
+}
+type CheckoutOptions = CheckoutSwitchOptions | CheckoutPathsOptions;
+interface CheckoutResult {
+    readonly branch: RefName | undefined;
+    readonly id: ObjectId;
+    readonly detached: boolean;
+    readonly changedPaths: number;
+}
+declare const checkout: (ctx: Context, opts: CheckoutOptions) => Promise<CheckoutResult>;
+
+interface CherryPickRunInput {
+    /** Revisions to pick, in argument order — a commit-ish or an `A..B` range each. */
+    readonly commits: ReadonlyArray<string>;
+    /** -x: append `(cherry picked from commit <oid>)` to each commit message. */
+    readonly recordOrigin?: boolean;
+    /** --allow-empty: a redundant pick creates an empty commit instead of stopping. */
+    readonly allowEmpty?: boolean;
+    /** -n / --no-commit: apply each pick to the index + working tree only; never
+     *  commit, never persist CHERRY_PICK_HEAD / sequencer state. */
+    readonly noCommit?: boolean;
+}
+interface CherryPickedCommit {
+    readonly source: ObjectId;
+    readonly created: ObjectId;
+}
+interface CherryPickConflict {
+    readonly path: FilePath;
+    readonly type: ConflictType;
+}
+type CherryPickResult = {
+    readonly kind: 'picked';
+    readonly commits: ReadonlyArray<CherryPickedCommit>;
+} | {
+    readonly kind: 'no-commit';
+    readonly sources: ReadonlyArray<ObjectId>;
+} | {
+    readonly kind: 'conflict';
+    readonly commit: ObjectId;
+    readonly conflicts: ReadonlyArray<CherryPickConflict>;
+    readonly remaining: number;
+} | {
+    readonly kind: 'empty';
+    readonly commit: ObjectId;
+    readonly remaining: number;
+};
+declare const cherryPickRun: (ctx: Context, input: CherryPickRunInput) => Promise<CherryPickResult>;
+interface CherryPickContinueInput {
+    /** --allow-empty: finalise a resolution that yields no change as an empty commit. */
+    readonly allowEmpty?: boolean;
+}
+/**
+ * Finalise the in-progress conflicted pick as a single-parent commit from the
+ * resolved index, then resume any remaining sequencer picks. Refuses when nothing
+ * is in progress or the index is unmerged. A no-change resolution re-stops empty.
+ */
+declare const cherryPickContinue: (ctx: Context, input?: CherryPickContinueInput) => Promise<CherryPickResult>;
+interface CherryPickAbortResult {
+    readonly head: ObjectId;
+    readonly branch: RefName;
+}
+/**
+ * Drop the in-progress pick: hard-reset to HEAD (discarding its half-applied
+ * state), then resume the remaining sequencer picks (if any).
+ */
+declare const cherryPickSkip: (ctx: Context, input?: CherryPickContinueInput) => Promise<CherryPickResult>;
+/**
+ * Abort the cherry-pick: hard-reset the working tree, index, and branch to the
+ * pre-sequence HEAD (sequencer `head`, or the current HEAD for a lone pick), and
+ * clear all state. The branch update records git's faithful
+ * `reset: moving to <oid>` reflog. Refuses when nothing is in progress.
+ */
+declare const cherryPickAbort: (ctx: Context) => Promise<CherryPickAbortResult>;
+
+interface CloneOptions {
+    readonly url: string;
+    readonly bare?: boolean;
+    readonly initialBranch?: string;
+    /**
+     * Shallow clone depth. When set, sends `deepen N` and persists the
+     * resulting shallow boundaries to `.git/shallow`.
+     */
+    readonly depth?: number;
+    /**
+     * Partial-clone object filter (`blob:none`, `blob:limit=<n>`, `tree:<n>`).
+     * When set, the server omits the filtered objects, a promisor remote is
+     * recorded in `.git/config`, and omitted objects are lazy-fetched on read.
+     */
+    readonly filter?: string;
+}
+interface CloneResult {
+    readonly path: FilePath;
+    readonly head: RefName | undefined;
+    readonly fetchedRefs: ReadonlyArray<{
+        readonly name: RefName;
+        readonly id: ObjectId;
+    }>;
+}
+declare const clone: (ctx: Context, opts: CloneOptions) => Promise<CloneResult>;
+
+interface CommitOptions {
+    readonly message: string;
+    readonly author?: AuthorIdentity;
+    readonly committer?: AuthorIdentity;
+    readonly allowEmpty?: boolean;
+    readonly allowEmptyMessage?: boolean;
+    /** Skip the `pre-commit` and `commit-msg` hooks (git's `--no-verify`). */
+    readonly noVerify?: boolean;
+    /**
+     * Sign the commit (git's `-S`). Tri-state against `commit.gpgsign`: an
+     * explicit `true`/`false` here always wins; leaving it `undefined` falls
+     * back to `commit.gpgsign` from config.
+     */
+    readonly sign?: boolean;
+    /** Signing key/identity override (git's `-S<keyid>`); falls back to `user.signingKey`. */
+    readonly signKey?: string;
+}
+interface CommitResult {
+    readonly id: ObjectId;
+    readonly tree: ObjectId;
+    readonly branch: RefName | undefined;
+    readonly parents: ReadonlyArray<ObjectId>;
+}
+/**
+ * Create a new commit from the current index. Resolves author/committer from
+ * options or `.git/config` `[user]`, writes a tree from the index, builds the
+ * commit object, and updates HEAD's target ref (or detached HEAD itself).
+ *
+ * Throws `NOTHING_TO_COMMIT` when the new tree matches the parent's tree and
+ * `allowEmpty` is not set; `EMPTY_COMMIT_MESSAGE` when the message is blank
+ * and `allowEmptyMessage` is not set.
+ */
+declare const commit: (ctx: Context, opts: CommitOptions) => Promise<CommitResult>;
+
+/**
+ * `repo.config.*` porcelain — nested-namespace shape per ADR-181. The methods
+ * exported here are the Context-aware functions the namespace dispatcher in
+ * `repository.ts` binds; `repo.config.get(input)` is roughly
+ * `configGet(repo.ctx, input)`.
+ *
+ * Each command:
+ *   1. asserts the context targets a repository,
+ *   2. parses + validates inputs at the command boundary,
+ *   3. composes the slice-7 readers / slice-8/9 writers,
+ *   4. returns a typed result envelope (per-action shape, no discriminator).
+ */
+
+interface ConfigGetInput {
+    readonly key: string;
+    readonly scope?: ConfigScope;
+}
+type ConfigGetResult = {
+    readonly key: ConfigKey;
+    readonly value: string | null;
+    readonly scope: ConfigScope;
+} | {
+    readonly key: ConfigKey;
+    readonly value: undefined;
+};
+declare const configGet: (ctx: Context, input: ConfigGetInput) => Promise<ConfigGetResult>;
+interface ConfigGetAllInput {
+    readonly key: string;
+    readonly scope?: ConfigScope;
+}
+interface ConfigGetAllResult {
+    readonly key: ConfigKey;
+    readonly values: ReadonlyArray<{
+        readonly value: string | null;
+        readonly scope: ConfigScope;
+    }>;
+}
+declare const configGetAll: (ctx: Context, input: ConfigGetAllInput) => Promise<ConfigGetAllResult>;
+interface ConfigGetRegexpInput {
+    readonly keyPattern: RegExp;
+    readonly valuePattern?: RegExp;
+    readonly scope?: ConfigScope;
+}
+interface ConfigEntryView {
+    readonly key: ConfigKey;
+    /** `null` means the entry is present with no `=` (git's internal NULL). */
+    readonly value: string | null;
+    readonly scope: ConfigScope;
+}
+interface ConfigGetRegexpResult {
+    readonly entries: ReadonlyArray<ConfigEntryView>;
+}
+declare const configGetRegexp: (ctx: Context, input: ConfigGetRegexpInput) => Promise<ConfigGetRegexpResult>;
+interface ConfigListInput {
+    readonly scope?: ConfigScope;
+}
+interface ConfigListResult {
+    readonly entries: ReadonlyArray<ConfigEntryView>;
+}
+declare const configList: (ctx: Context, input?: ConfigListInput) => Promise<ConfigListResult>;
+interface ConfigSetInput {
+    readonly key: string;
+    readonly value: string;
+    readonly scope?: ConfigScope;
+}
+interface ConfigSetResult {
+    readonly key: ConfigKey;
+    readonly value: string;
+    readonly scope: ConfigScope;
+}
+declare const configSet: (ctx: Context, input: ConfigSetInput) => Promise<ConfigSetResult>;
+interface ConfigUnsetInput {
+    readonly key: string;
+    readonly scope?: ConfigScope;
+}
+type ConfigUnsetResult = {
+    readonly key: ConfigKey;
+    readonly scope: ConfigScope;
+    readonly removed: true;
+    /** The value that was removed. `null` when the entry had no `=`. */
+    readonly previousValue: string | null;
+} | {
+    readonly key: ConfigKey;
+    readonly scope: ConfigScope;
+    readonly removed: false;
+};
+declare const configUnset: (ctx: Context, input: ConfigUnsetInput) => Promise<ConfigUnsetResult>;
+interface ConfigUnsetAllInput {
+    readonly key: string;
+    readonly scope?: ConfigScope;
+}
+interface ConfigUnsetAllResult {
+    readonly key: ConfigKey;
+    readonly scope: ConfigScope;
+    readonly removed: number;
+}
+declare const configUnsetAll: (ctx: Context, input: ConfigUnsetAllInput) => Promise<ConfigUnsetAllResult>;
+interface ConfigRenameSectionInput {
+    readonly oldName: string;
+    readonly newName: string;
+    readonly scope?: ConfigScope;
+}
+interface ConfigRenameSectionResult {
+    readonly oldName: string;
+    readonly newName: string;
+    readonly scope: ConfigScope;
+}
+declare const configRenameSection: (ctx: Context, input: ConfigRenameSectionInput) => Promise<ConfigRenameSectionResult>;
+interface ConfigRemoveSectionInput {
+    readonly name: string;
+    readonly scope?: ConfigScope;
+}
+interface ConfigRemoveSectionResult {
+    readonly name: string;
+    readonly scope: ConfigScope;
+}
+declare const configRemoveSection: (ctx: Context, input: ConfigRemoveSectionInput) => Promise<ConfigRemoveSectionResult>;
+
+interface MergeContinueInput {
+    /** Override `MERGE_MSG`. Empty/undefined falls back to the draft. */
+    readonly message?: string;
+    /** Forwarded to commit. */
+    readonly author?: AuthorIdentity;
+    readonly committer?: AuthorIdentity;
+    /** Skip the `pre-commit` and `commit-msg` hooks (git's `--no-verify`). */
+    readonly noVerify?: boolean;
+}
+type MergeContinueResult = CommitResult;
+/**
+ * Finalise a conflicting merge as a merge commit. Asserts a merge is in
+ * progress, then delegates to `commit` — which already reads
+ * `MERGE_HEAD` for the second parent, falls back to `MERGE_MSG` when the
+ * message is empty, runs hooks, and clears merge state on success
+ * (ADR-174).
+ *
+ * Refuses when no merge is in progress (`MERGE_HEAD` absent). Refuses
+ * (via `commit`) when the index still has stage-1/2/3 entries.
+ */
+declare const mergeContinue: (ctx: Context, opts?: MergeContinueInput) => Promise<MergeContinueResult>;
+
+/**
+ * Pure value types for `name-rev`'s reverse-reachability naming. No I/O, no
+ * rendering. A commit's name is the chosen ref plus an ordered path down to it
+ * via git's `~` (first-parent) / `^` (n-th parent) notation.
+ */
+
+/** One segment of a name-rev path: `~count` (first-parent run) or `^number` (n-th parent). */
+type NameRevStep = {
+    readonly kind: 'ancestor';
+    readonly count: number;
+} | {
+    readonly kind: 'parent';
+    readonly number: number;
+};
+
+/**
+ * Tier-1 `name-rev` command — git's `git name-rev`: name a commit by the nearest
+ * ref that **contains** it (a descendant-or-self ref), via a reverse-reachability
+ * flood down from every qualifying ref (ADRs 283–285). Returns structured data
+ * only: the chosen ref (full name), whether it is an annotated tag (the `^0`
+ * peel), and the ordered `~`/`^` navigation steps. The library renders no name
+ * string and abbreviates no ref — assembling `tags/v2.0~3^2~1` is the caller's.
+ */
+
+interface NameRevOptions {
+    /** Restrict the naming sources to tags (`refs/tags/*`). */
+    readonly tags?: boolean;
+    /** Full-refname globs a ref must match to be a naming source (`*`/`?` cross `/`). */
+    readonly refs?: string | ReadonlyArray<string>;
+    /** Full-refname globs that drop a ref from the naming sources. */
+    readonly exclude?: string | ReadonlyArray<string>;
+}
+interface NameRevResult {
+    /** Full 40-hex oid of the named commit. */
+    readonly oid: ObjectId;
+    /** Naming ref (full name, e.g. `refs/tags/v1.0`); `undefined` when unnameable. */
+    readonly ref: RefName | undefined;
+    /** `true` when the ref is an annotated tag (the caller renders `^0` at the tip). */
+    readonly tagDeref: boolean;
+    /** Navigation from the ref's commit down to `oid` (`~count` / `^number`). */
+    readonly steps: ReadonlyArray<NameRevStep>;
+}
+declare const nameRev: (ctx: Context, rev?: string, opts?: NameRevOptions) => Promise<NameRevResult>;
+
+interface DescribeOptions {
+    /** Include lightweight tags (priority ≥ 1), not just annotated ones. */
+    readonly tags?: boolean;
+    /** Consider every ref (branches, remotes; priority 0), not only tags. */
+    readonly all?: boolean;
+    /** Always emit a result even when no tag matches, falling back to the oid. */
+    readonly always?: boolean;
+    /** Only an exact tag on the target counts (≡ `candidates: 0`). */
+    readonly exactMatch?: boolean;
+    /** Maximum tags considered during the search. Default 10. */
+    readonly candidates?: number;
+    /** Follow only first parents through merges. */
+    readonly firstParent?: boolean;
+    /** Short-name globs a tag must match to be considered. */
+    readonly match?: string | ReadonlyArray<string>;
+    /** Short-name globs that drop a tag from consideration. */
+    readonly exclude?: string | ReadonlyArray<string>;
+    /** Report whether HEAD's working tree has tracked changes (HEAD only). */
+    readonly dirty?: boolean;
+    /** Tolerate a working tree whose state can't be read, reporting it dirty. */
+    readonly broken?: boolean;
+    /** Name the nearest ref that *contains* the commit (delegates to `name-rev`). */
+    readonly contains?: boolean;
+}
+interface DescribeResult {
+    /** Chosen ref (a tag, or any ref under `all`); `undefined` on the `always` fallback. */
+    readonly tag: RefName | undefined;
+    /** Describe short-name (`v2.0`, `heads/main`); `''` on the `always` fallback. */
+    readonly name: string;
+    /** Commits between the chosen ref and the target (`0` when exact). */
+    readonly distance: number;
+    /** Full 40-hex oid of the described commit; the caller abbreviates it. */
+    readonly oid: ObjectId;
+    /** `true` when the target itself carries the chosen tag. */
+    readonly exact: boolean;
+    /** `true` when HEAD's working tree had tracked changes (`dirty`/`broken`). */
+    readonly dirty: boolean;
+}
+declare function describe(ctx: Context, rev: string | undefined, opts: DescribeOptions & {
+    contains: true;
+}): Promise<NameRevResult>;
+declare function describe(ctx: Context, rev?: string, opts?: DescribeOptions): Promise<DescribeResult>;
+
+interface DiffOptions {
+    /** Resolve to a tree. Accepts any revision (ref, oid, `HEAD`, `~`/`^` grammar). */
+    readonly from?: string;
+    readonly to?: string;
+    readonly detectRenames?: boolean;
+    /** Fine-tune rename detection (limit, threshold). Only used when `detectRenames` is true. */
+    readonly renameOptions?: RenameDetectOptions;
+    /**
+     * Recurse into sub-directories (`git diff-tree -r`), surfacing nested blobs as
+     * full-path changes instead of one change per top-level sub-tree. Default `false`.
+     */
+    readonly recursive?: boolean;
+    /**
+     * Attach per-file line counts (`added` / `deleted` / `binary`) to each change —
+     * the data half of git's `--numstat`. Off by default (tree-level, no blob reads).
+     */
+    readonly withStat?: boolean;
+    /**
+     * Whitespace-normalization mode for line equality (data mode, not a rendering
+     * knob). `'all'` ignores all space/tab; `'change'` ignores amount-only changes;
+     * `'at-eol'` ignores trailing whitespace only.
+     */
+    readonly ignoreWhitespace?: 'all' | 'change' | 'at-eol';
+    /**
+     * When `true`, a trailing CR (`\r`) immediately before the line terminator is
+     * treated as insignificant (data mode — `git diff --ignore-cr-at-eol`).
+     */
+    readonly ignoreCrAtEol?: boolean;
+    /**
+     * When `true`, change groups consisting solely of blank lines are excluded from
+     * added/deleted counts and the drop-pass predicate (data mode —
+     * `git diff --ignore-blank-lines`).
+     */
+    readonly ignoreBlankLines?: boolean;
+}
+/**
+ * Diff two tree-like targets, returning the structured `TreeDiff`. Pass
+ * `withStat: true` to attach per-file line counts (a `StatTreeDiff`). Rendering
+ * the diff as a unified patch is the caller's concern.
+ */
+declare function diff(ctx: Context, opts: DiffOptions & {
+    withStat: true;
+}): Promise<StatTreeDiff>;
+declare function diff(ctx: Context, opts?: DiffOptions): Promise<TreeDiff>;
+
+interface FetchOptions {
+    /**
+     * Remote to fetch from. Default: `branch.<current>.remote` ?? the sole
+     * configured remote ?? `'origin'`; detached HEAD skips the branch step.
+     */
+    readonly remote?: string;
+    readonly refspecs?: ReadonlyArray<string>;
+    readonly prune?: boolean;
+    /** Shallow clone depth. Delegates to fetchPack's deepen path. */
+    readonly depth?: number;
+}
+interface FetchUpdate {
+    readonly name: RefName;
+    readonly oldId: ObjectId | undefined;
+    readonly newId: ObjectId;
+}
+interface FetchResult {
+    readonly remote: string;
+    readonly url: string;
+    readonly updatedRefs: ReadonlyArray<FetchUpdate>;
+    /** Refs deleted because the server no longer advertises them (prune semantics). */
+    readonly prunedRefs: ReadonlyArray<RefName>;
+    /** New shallow boundaries written to `.git/shallow` during this fetch. */
+    readonly shallow: ReadonlyArray<ObjectId>;
+    /** Commits that crossed the shallow → non-shallow boundary during this fetch. */
+    readonly unshallow: ReadonlyArray<ObjectId>;
+}
+declare const fetch: (ctx: Context, opts?: FetchOptions) => Promise<FetchResult>;
+
+interface FetchMissingOptions {
+    /** Object ids to fetch. Ones already present locally are skipped. */
+    readonly oids: ReadonlyArray<ObjectId>;
+}
+interface FetchMissingResult {
+    /** The promisor remote the objects were fetched from. */
+    readonly remote: string;
+    /** Objects the caller asked for. */
+    readonly requested: number;
+    /** Objects that were missing locally and got fetched. */
+    readonly fetched: number;
+}
+/**
+ * Fetch the named objects from the repository's promisor remote. Throws
+ * `NO_PROMISOR_REMOTE` when the repository is not a partial clone.
+ */
+declare const fetchMissing: (ctx: Context, opts: FetchMissingOptions) => Promise<FetchMissingResult>;
+/**
+ * `PromisorRemote` port implementation — the seam `readObject` calls on a
+ * miss. A non-partial repository yields `attempted: false` (rather than
+ * throwing) so `readObject` falls through to its normal `OBJECT_NOT_FOUND`.
+ */
+declare const createPromisorRemote: (ctx: Context) => PromisorRemote;
+
+/** Object kinds the fsck validator operates on. */
+type FsckObjectType = 'commit' | 'blob' | 'tree' | 'tag';
+/**
+ * Severity of a catalogue finding.
+ * Mirrors git's WARN/ERROR/INFO classes that appear in
+ * `warning in …` / `error in …` / `warning in …` (INFO) output.
+ */
+type FsckSeverity = 'error' | 'warning' | 'info';
+
+type FsckFinding = {
+    readonly type: 'dangling';
+    readonly id: ObjectId;
+    readonly objectType: FsckObjectType;
+} | {
+    readonly type: 'unreachable';
+    readonly id: ObjectId;
+    readonly objectType: FsckObjectType;
+} | {
+    readonly type: 'missing';
+    readonly id: ObjectId;
+    readonly objectType: FsckObjectType | 'unknown';
+} | {
+    readonly type: 'broken-link';
+    readonly fromId: ObjectId;
+    readonly fromType: FsckObjectType;
+    readonly toId: ObjectId;
+    readonly toType: FsckObjectType | 'unknown';
+} | {
+    readonly type: 'bad-object';
+    readonly id: ObjectId;
+    /** 'unknown' when the object is undecodable and the type cannot be determined. */
+    readonly objectType: FsckObjectType | 'unknown';
+    readonly msgId: string;
+    readonly severity: FsckSeverity;
+} | {
+    readonly type: 'hash-mismatch';
+    readonly id: ObjectId;
+    readonly actual: ObjectId;
+} | {
+    readonly type: 'bad-ref';
+    readonly ref: RefName;
+    readonly msgId: string;
+    readonly severity: FsckSeverity;
+    readonly target?: ObjectId;
+} | {
+    readonly type: 'root';
+    readonly id: ObjectId;
+} | {
+    readonly type: 'tagged';
+    readonly id: ObjectId;
+    readonly objectType: FsckObjectType;
+    readonly tagName: string;
+    readonly tag: ObjectId;
+};
+interface FsckOptions {
+    /** Skip object-content validation, check links only. */
+    readonly connectivityOnly?: boolean;
+    /** Default true — reflog oids are roots; false to exclude. */
+    readonly reflogRoots?: boolean;
+    /** Default true — index oids are roots. */
+    readonly indexRoot?: boolean;
+    /** Default true — include packs. */
+    readonly full?: boolean;
+    /** WARN-class msg-ids upgraded to ERROR (+exit bit). */
+    readonly strict?: boolean;
+    /** Default true — run refs-verify pass. */
+    readonly checkReferences?: boolean;
+}
+interface FsckResult {
+    readonly findings: ReadonlyArray<FsckFinding>;
+    /** Composite exit bitmask: 0=clean, 2=missing/broken-link. */
+    readonly exitCode: number;
+}
+
+declare function fsck(ctx: Context, opts?: FsckOptions): Promise<FsckResult>;
+
+interface MatchSpan {
+    readonly start: number;
+    readonly end: number;
+}
+interface GrepFixedPattern {
+    readonly fixed: string;
+}
+type GrepPattern = RegExp | GrepFixedPattern;
+interface LineVerdict {
+    readonly returned: boolean;
+    readonly spans: ReadonlyArray<MatchSpan>;
+}
+interface GrepMatcherOptions {
+    readonly wholeWord?: boolean;
+    readonly invert?: boolean;
+}
+interface GrepMatcher {
+    matchLine(line: Uint8Array): LineVerdict;
+}
+declare function buildGrepMatcher(patterns: ReadonlyArray<GrepPattern>, options?: GrepMatcherOptions): GrepMatcher;
+
+interface GrepLineHit {
+    /** 1-based line number (git's `-n`). */
+    readonly lineNumber: number;
+    /** Raw returned-line bytes (LF kept by splitLines). */
+    readonly line: Uint8Array;
+    /** Match byte-offset spans; EMPTY under `invert` (a returned line is a non-match). */
+    readonly spans: ReadonlyArray<MatchSpan>;
+}
+interface GrepPathResult {
+    readonly path: FilePath;
+    readonly hits: ReadonlyArray<GrepLineHit>;
+    /**
+     * Blob is binary AND contained a match. `hits` stays empty — line scan is
+     * skipped for binary blobs (git's default). The caller reconstructs
+     * "Binary file X matches" from this datum.
+     */
+    readonly binaryMatch: boolean;
+}
+interface GrepResult {
+    /** Only paths with ≥1 hit or binaryMatch:true. */
+    readonly paths: ReadonlyArray<GrepPathResult>;
+}
+interface GrepOptions {
+    /** Patterns to search. ≥1 required; multiple OR-combine. */
+    readonly patterns: ReadonlyArray<GrepPattern>;
+    /** Whole-word gating (`-w`). */
+    readonly wholeWord?: boolean;
+    /** Invert: return lines that do NOT match (`-v`). */
+    readonly invert?: boolean;
+    /**
+     * Target. Absent ⇒ working tree; `'index'` ⇒ `--cached`;
+     * `{ treeish }` ⇒ committed tree.
+     */
+    readonly target?: 'index' | {
+        readonly treeish: string;
+    };
+    /** Pathspec limiter (`-- <path>...`). */
+    readonly paths?: ReadonlyArray<string>;
+}
+declare function grep(ctx: Context, opts: GrepOptions): Promise<GrepResult>;
+
+interface InitOptions {
+    readonly initialBranch?: string;
+    readonly bare?: boolean;
+}
+interface InitResult {
+    readonly path: FilePath;
+    readonly initialBranch: RefName;
+    readonly bare: boolean;
+}
+/**
+ * Initialize a fresh repository at `ctx.layout.gitDir`. Throws
+ * `ALREADY_INITIALIZED` when the target gitDir already exists; otherwise
+ * delegates to `bootstrapRepository` for the standard layout.
+ *
+ * For non-bare repos, the gitDir is `<workDir>/.git`. For bare, gitDir IS the
+ * working dir — callers must construct a Context with `bare: true` for that
+ * shape.
+ */
+declare const init: (ctx: Context, opts?: InitOptions) => Promise<InitResult>;
+
+/**
+ * The nested-namespace surface for `repo.branch.*`. Each method runs the
+ * caller-supplied `guard()` first (so a disposed repository throws before any
+ * work) and then forwards to the corresponding context-aware command in
+ * `commands/branch.ts`.
+ */
+interface BranchNamespace {
+    readonly list: () => Promise<BranchListResult>;
+    readonly create: (input: BranchCreateInput) => Promise<BranchCreateResult>;
+    readonly delete: (input: BranchDeleteInput) => Promise<BranchDeleteResult>;
+    readonly rename: (input: BranchRenameInput) => Promise<BranchRenameResult>;
+}
+/**
+ * Bind the `repo.branch.*` nested-namespace dispatcher. `guard()` is the
+ * lifecycle gate (typically the disposed/closed check from `openRepository`);
+ * it is invoked before every method forwards to its underlying command.
+ *
+ * The returned object is frozen — callers cannot monkey-patch methods onto
+ * the namespace at runtime.
+ */
+declare const bindBranchNamespace: (ctx: Context, guard: () => void) => BranchNamespace;
+
+/**
+ * Nested-namespace surface for `repo.bundle.{create,verify,listHeads}`. Each
+ * method runs the caller-supplied `guard()` first (so a disposed repository
+ * throws before any work) and then forwards to the context-aware command.
+ * Frozen.
+ */
+interface BundleNamespace {
+    readonly create: (opts: BundleCreateOptions) => Promise<BundleCreateResult>;
+    readonly verify: (input: BundleVerifyInput) => Promise<BundleVerifyResult>;
+    readonly listHeads: (input: BundleListHeadsInput) => Promise<BundleListHeadsResult>;
+}
+/**
+ * Bind the `repo.bundle.*` nested-namespace dispatcher. `guard()` is the
+ * lifecycle gate (typically the disposed/closed check from `openRepository`);
+ * it is invoked before every method forwards to its underlying command.
+ *
+ * The returned object is frozen — callers cannot monkey-patch methods onto
+ * the namespace at runtime.
+ */
+declare const bindBundleNamespace: (ctx: Context, guard: () => void) => BundleNamespace;
+
+/**
+ * The nested-namespace surface for `repo.cherryPick.*` (ADR-181/192/210). Each
+ * method runs the caller-supplied `guard()` first (so a disposed repository
+ * throws before any work) and forwards to the Context-aware command. Frozen.
+ */
+interface CherryPickNamespace {
+    readonly run: (input: CherryPickRunInput) => Promise<CherryPickResult>;
+    readonly continue: (input?: CherryPickContinueInput) => Promise<CherryPickResult>;
+    readonly skip: (input?: CherryPickContinueInput) => Promise<CherryPickResult>;
+    readonly abort: () => Promise<CherryPickAbortResult>;
+}
+declare const bindCherryPickNamespace: (ctx: Context, guard: () => void) => CherryPickNamespace;
+
+/**
+ * The nested-namespace surface for `repo.config.*` (ADR-181). Each method
+ * runs the caller-supplied `guard()` first (so a disposed repository throws
+ * before any work) and then forwards to the corresponding context-aware
+ * command in `commands/config.ts`.
+ */
+interface ConfigNamespace {
+    readonly get: (input: ConfigGetInput) => Promise<ConfigGetResult>;
+    readonly getAll: (input: ConfigGetAllInput) => Promise<ConfigGetAllResult>;
+    readonly getRegexp: (input: ConfigGetRegexpInput) => Promise<ConfigGetRegexpResult>;
+    readonly list: (input?: ConfigListInput) => Promise<ConfigListResult>;
+    readonly set: (input: ConfigSetInput) => Promise<ConfigSetResult>;
+    readonly unset: (input: ConfigUnsetInput) => Promise<ConfigUnsetResult>;
+    readonly unsetAll: (input: ConfigUnsetAllInput) => Promise<ConfigUnsetAllResult>;
+    readonly renameSection: (input: ConfigRenameSectionInput) => Promise<ConfigRenameSectionResult>;
+    readonly removeSection: (input: ConfigRemoveSectionInput) => Promise<ConfigRemoveSectionResult>;
+}
+/**
+ * Bind the `repo.config.*` nested-namespace dispatcher. `guard()` is the
+ * lifecycle gate (typically the disposed/closed check from `openRepository`);
+ * it is invoked before every method forwards to its underlying command.
+ *
+ * The returned object is frozen — callers cannot monkey-patch methods onto
+ * the namespace at runtime.
+ */
+declare const bindConfigNamespace: (ctx: Context, guard: () => void) => ConfigNamespace;
+
+interface MergeRunInput {
+    readonly rev: string;
+    readonly message?: string;
+    /**
+     * Fast-forward policy (git `--ff` / `--ff-only` / `--no-ff`):
+     * - `'allow'` (default) — fast-forward when possible, else a true merge.
+     * - `'only'` — refuse with `NON_FAST_FORWARD` when a true merge is required.
+     * - `'never'` — always create a merge commit, even when a fast-forward is possible.
+     */
+    readonly fastForward?: 'only' | 'never' | 'allow';
+    readonly author?: AuthorIdentity;
+    readonly committer?: AuthorIdentity;
+}
+/**
+ * Internal-only knobs for `merge`, set by composing porcelain (e.g. `pull`),
+ * never by end users. Deliberately **not** re-exported from the commands barrel,
+ * so it stays off the public API surface.
+ */
+interface MergeInternalOptions {
+    /**
+     * Reflog action prefix, mirroring git's GIT_REFLOG_ACTION. Replaces the
+     * default `merge <rev>` prefix in the fast-forward and merge-commit reflog
+     * messages (e.g. `pull` → `pull: Fast-forward`). Defaults to `merge <rev>`.
+     */
+    readonly reflogAction?: string;
+}
+interface MergeConflictDescriptor {
+    readonly path: FilePath;
+    readonly type: ConflictType;
+}
+type MergeResult = {
+    readonly kind: 'up-to-date';
+    readonly id: ObjectId;
+} | {
+    readonly kind: 'fast-forward';
+    readonly id: ObjectId;
+    readonly branch: RefName;
+} | {
+    readonly kind: 'merge';
+    readonly id: ObjectId;
+    readonly branch: RefName;
+    readonly parents: ReadonlyArray<ObjectId>;
+} | {
+    readonly kind: 'conflict';
+    readonly conflicts: ReadonlyArray<MergeConflictDescriptor>;
+    readonly mergeHead: ObjectId;
+    readonly origHead: ObjectId;
+};
+declare const mergeRun: (ctx: Context, opts: MergeRunInput, internal?: MergeInternalOptions) => Promise<MergeResult>;
+
+/**
+ * The nested-namespace surface for `repo.merge.*` (ADR-181/192/263). Each method
+ * runs the caller-supplied `guard()` first (so a disposed repository throws
+ * before any work) and forwards to the Context-aware command. Frozen.
+ *
+ * There is no `skip` verb — a merge applies a single integration, so the verbs
+ * are `run` / `continue` / `abort` (git `merge` / `merge --continue` /
+ * `merge --abort`). `run` never exposes `merge`'s internal reflog-action channel.
+ */
+interface MergeNamespace {
+    readonly run: (input: MergeRunInput) => Promise<MergeResult>;
+    readonly continue: (input?: MergeContinueInput) => Promise<MergeContinueResult>;
+    readonly abort: () => Promise<MergeAbortResult>;
+}
+declare const bindMergeNamespace: (ctx: Context, guard: () => void) => MergeNamespace;
+
+interface NotesAddInput {
+    /** Commit-ish or full oid to annotate. */
+    readonly object: string;
+    /** Note bytes stored verbatim — no normalisation applied by the library. */
+    readonly content: Uint8Array;
+    /** Overwrite an existing note; without this, an existing note refuses. */
+    readonly force?: boolean;
+    /** Notes-ref override; selection rule: explicit → GIT_NOTES_REF → core.notesRef → default. */
+    readonly ref?: string;
+}
+interface NotesAddResult {
+    readonly notesCommit: ObjectId;
+    readonly note: ObjectId;
+}
+interface NotesReadInput {
+    readonly object: string;
+    readonly ref?: string;
+}
+type NotesReadResult = {
+    readonly object: ObjectId;
+    readonly note: ObjectId;
+    readonly content: Uint8Array;
+} | null;
+interface NotesListInput {
+    readonly ref?: string;
+}
+type NotesListResult = ReadonlyArray<{
+    readonly object: ObjectId;
+    readonly note: ObjectId;
+}>;
+interface NotesRemoveInput {
+    readonly object: string;
+    readonly ref?: string;
+}
+interface NotesRemoveResult {
+    readonly notesCommit: ObjectId;
+}
+/**
+ * Writes (or, with `force`, overwrites) a note for an object. Commits the new
+ * notes tree and moves the notes ref, creating it if absent.
+ */
+declare const notesAdd: (ctx: Context, input: NotesAddInput) => Promise<NotesAddResult>;
+/**
+ * Returns the note recorded for an object, or `null` when the note or ref is
+ * absent. Never throws for absence — callers distinguish "no note" from errors.
+ */
+declare const notesRead: (ctx: Context, input: NotesReadInput) => Promise<NotesReadResult>;
+/**
+ * Enumerates every `(annotated-object, note-blob)` pair in the notes ref by
+ * walking the real notes tree, recursing through every fanout level. Returns an
+ * empty array when the ref is absent. Skips non-note entries (directories and
+ * any leaf whose de-slashed path is not a full-hex oid). Sorted by
+ * annotated-object oid ascending (git tree order).
+ */
+declare const notesList: (ctx: Context, input?: NotesListInput) => Promise<NotesListResult>;
+/**
+ * Removes the note for an object. Commits the smaller (or empty) tree and
+ * moves the notes ref. The ref is never deleted, even when the last note is
+ * removed — an empty tree commit is stored instead.
+ */
+declare const notesRemove: (ctx: Context, input: NotesRemoveInput) => Promise<NotesRemoveResult>;
+
+/**
+ * The nested-namespace surface for `repo.notes.*`. Each method runs the
+ * caller-supplied `guard()` first (so a disposed repository throws before any
+ * work) and then forwards to the corresponding context-aware command in
+ * `commands/notes.ts`.
+ */
+interface NotesNamespace {
+    readonly add: (input: NotesAddInput) => Promise<NotesAddResult>;
+    readonly read: (input: NotesReadInput) => Promise<NotesReadResult>;
+    readonly list: (input?: NotesListInput) => Promise<NotesListResult>;
+    readonly remove: (input: NotesRemoveInput) => Promise<NotesRemoveResult>;
+}
+/**
+ * Bind the `repo.notes.*` nested-namespace dispatcher. `guard()` is the
+ * lifecycle gate (typically the disposed/closed check from `openRepository`);
+ * it is invoked before every method forwards to its underlying command.
+ *
+ * The returned object is frozen — callers cannot monkey-patch methods onto
+ * the namespace at runtime.
+ */
+declare const bindNotesNamespace: (ctx: Context, guard: () => void) => NotesNamespace;
+
+type RebaseTodoAction = 'pick' | 'reword' | 'edit' | 'squash' | 'fixup' | 'drop';
+
+/** The interactive instruction verbs (`git rebase -i`). */
+type RebaseInteractiveAction = RebaseTodoAction;
+/** One post-`$EDITOR` interactive instruction — the edited-todo line as data. */
+interface RebaseInstruction {
+    readonly action: RebaseInteractiveAction;
+    /** A commit-ish in the `onto..HEAD` range. */
+    readonly oid: string;
+    /** reword: the new message (required). squash: the combined message
+     *  (optional — defaults to git's combination template). Ignored otherwise. */
+    readonly message?: string;
+}
+interface RebaseRunInput {
+    /** The fork-point side — a commit-ish (`git rebase <upstream>`). */
+    readonly upstream: string;
+    /** `--onto <newbase>`: replay onto this base instead of `upstream`. */
+    readonly onto?: string;
+    /** Present → interactive: the post-`$EDITOR` instruction list (`git rebase -i`). */
+    readonly interactive?: ReadonlyArray<RebaseInstruction>;
+}
+interface RebasedCommit {
+    readonly source: ObjectId;
+    readonly created: ObjectId;
+}
+interface RebaseConflict {
+    readonly path: FilePath;
+    readonly type: ConflictType;
+}
+type RebaseResult = {
+    readonly kind: 'rebased';
+    readonly commits: ReadonlyArray<RebasedCommit>;
+} | {
+    readonly kind: 'up-to-date';
+} | {
+    readonly kind: 'conflict';
+    readonly commit: ObjectId;
+    readonly conflicts: ReadonlyArray<RebaseConflict>;
+    readonly remaining: number;
+} | {
+    readonly kind: 'stopped';
+    readonly commit: ObjectId;
+    readonly remaining: number;
+};
+declare const rebaseRun: (ctx: Context, input: RebaseRunInput) => Promise<RebaseResult>;
+interface RebaseAbortResult {
+    readonly head: ObjectId;
+    readonly headName: string;
+}
+/**
+ * Resume the rebase after the conflicted commit was resolved: commit the resolved
+ * index as the stopped commit (preserved author from `author-script`, current
+ * committer, `rebase (continue)` reflog), then replay the remaining todo.
+ */
+declare const rebaseContinue: (ctx: Context) => Promise<RebaseResult>;
+/** Drop the conflicted commit (hard-reset to the last good pick) and replay the rest. */
+declare const rebaseSkip: (ctx: Context) => Promise<RebaseResult>;
+/**
+ * Abort the rebase: hard-reset the working tree + index to the pre-rebase tip,
+ * reattach `head-name`, record git's `rebase (abort): returning to <name>` reflog
+ * (the branch never moved during the replay, so it gets no entry), clear state.
+ */
+declare const rebaseAbort: (ctx: Context) => Promise<RebaseAbortResult>;
+
+/**
+ * The nested-namespace surface for `repo.rebase.*` (ADR-181/192/230). Each method
+ * runs the caller-supplied `guard()` first (so a disposed repository throws before
+ * any work) and forwards to the Context-aware command. Frozen.
+ */
+interface RebaseNamespace {
+    readonly run: (input: RebaseRunInput) => Promise<RebaseResult>;
+    readonly continue: () => Promise<RebaseResult>;
+    readonly skip: () => Promise<RebaseResult>;
+    readonly abort: () => Promise<RebaseAbortResult>;
+}
+declare const bindRebaseNamespace: (ctx: Context, guard: () => void) => RebaseNamespace;
+
+/** Compact view of a remote pulled from `.git/config`. */
+interface RemoteInfo {
+    readonly name: string;
+    readonly url: string;
+    readonly pushUrl: string | undefined;
+    readonly fetchRefspecs: ReadonlyArray<string>;
+}
+/** Local-only `show` payload: config view + tracking refs + tracking branches. */
+interface RemoteShow extends RemoteInfo {
+    readonly trackingRefs: ReadonlyMap<RefName, ObjectId>;
+    readonly trackedBy: ReadonlyArray<{
+        readonly branch: RefName;
+        readonly merge: string | undefined;
+    }>;
+}
+interface RemoteListResult {
+    readonly remotes: ReadonlyArray<RemoteInfo>;
+}
+interface RemoteAddInput {
+    readonly name: string;
+    readonly url: string;
+    readonly fetch?: string;
+}
+interface RemoteAddResult {
+    readonly remote: RemoteInfo;
+}
+interface RemoteRemoveInput {
+    readonly name: string;
+}
+interface RemoteRemoveResult {
+    readonly name: string;
+    readonly removedTrackingRefs: ReadonlyArray<RefName>;
+    readonly clearedBranches: ReadonlyArray<RefName>;
+}
+interface RemoteRenameInput {
+    readonly from: string;
+    readonly to: string;
+}
+interface RemoteRenameResult {
+    readonly from: string;
+    readonly to: string;
+    readonly movedTrackingRefs: ReadonlyArray<RefName>;
+    readonly rewrittenBranches: ReadonlyArray<RefName>;
+}
+interface RemoteSetUrlInput {
+    readonly name: string;
+    readonly url: string;
+    readonly push?: boolean;
+}
+interface RemoteSetUrlResult {
+    readonly remote: RemoteInfo;
+}
+interface RemoteShowInput {
+    readonly name: string;
+}
+interface RemoteShowResult {
+    readonly remote: RemoteShow;
+}
+declare const remoteList: (ctx: Context) => Promise<RemoteListResult>;
+declare const remoteAdd: (ctx: Context, input: RemoteAddInput) => Promise<RemoteAddResult>;
+declare const remoteRemove: (ctx: Context, input: RemoteRemoveInput) => Promise<RemoteRemoveResult>;
+declare const remoteRename: (ctx: Context, input: RemoteRenameInput) => Promise<RemoteRenameResult>;
+declare const remoteSetUrl: (ctx: Context, input: RemoteSetUrlInput) => Promise<RemoteSetUrlResult>;
+declare const remoteShow: (ctx: Context, input: RemoteShowInput) => Promise<RemoteShowResult>;
+
+/**
+ * The nested-namespace surface for `repo.remote.*`. Each method runs the
+ * caller-supplied `guard()` first (so a disposed repository throws before any
+ * work) and then forwards to the corresponding context-aware command in
+ * `commands/remote.ts`.
+ */
+interface RemoteNamespace {
+    readonly list: () => Promise<RemoteListResult>;
+    readonly add: (input: RemoteAddInput) => Promise<RemoteAddResult>;
+    readonly remove: (input: RemoteRemoveInput) => Promise<RemoteRemoveResult>;
+    readonly rename: (input: RemoteRenameInput) => Promise<RemoteRenameResult>;
+    readonly setUrl: (input: RemoteSetUrlInput) => Promise<RemoteSetUrlResult>;
+    readonly show: (input: RemoteShowInput) => Promise<RemoteShowResult>;
+}
+/**
+ * Bind the `repo.remote.*` nested-namespace dispatcher. `guard()` is the
+ * lifecycle gate (typically the disposed/closed check from `openRepository`);
+ * it is invoked before every method forwards to its underlying command.
+ *
+ * The returned object is frozen — callers cannot monkey-patch methods onto
+ * the namespace at runtime.
+ */
+declare const bindRemoteNamespace: (ctx: Context, guard: () => void) => RemoteNamespace;
+
+interface RevertRunInput {
+    /** Revisions to revert, in argument order — a commit-ish each. */
+    readonly commits: ReadonlyArray<string>;
+    /** -n / --no-commit: apply each reverse change to the index + working tree
+     *  only; never commit, never persist REVERT_HEAD / sequencer state. */
+    readonly noCommit?: boolean;
+}
+interface RevertedCommit {
+    readonly source: ObjectId;
+    readonly created: ObjectId;
+}
+interface RevertConflict {
+    readonly path: FilePath;
+    readonly type: ConflictType;
+}
+type RevertResult = {
+    readonly kind: 'reverted';
+    readonly commits: ReadonlyArray<RevertedCommit>;
+} | {
+    readonly kind: 'no-commit';
+    readonly sources: ReadonlyArray<ObjectId>;
+} | {
+    readonly kind: 'conflict';
+    readonly commit: ObjectId;
+    readonly conflicts: ReadonlyArray<RevertConflict>;
+    readonly remaining: number;
+} | {
+    readonly kind: 'empty';
+    readonly commit: ObjectId;
+    readonly remaining: number;
+};
+declare const revertRun: (ctx: Context, input: RevertRunInput) => Promise<RevertResult>;
+/**
+ * Finalise the in-progress conflicted revert (if any) as a single-parent commit,
+ * then resume the remaining sequencer reverts. Refuses when nothing is in progress
+ * or the index is unmerged; a resolution that yields no change re-stops empty.
+ */
+declare const revertContinue: (ctx: Context) => Promise<RevertResult>;
+interface RevertAbortResult {
+    readonly head: ObjectId;
+    readonly branch: RefName;
+}
+/**
+ * Drop the in-progress revert: hard-reset to HEAD (discarding its half-applied
+ * state), then resume the remaining sequencer reverts (if any).
+ */
+declare const revertSkip: (ctx: Context) => Promise<RevertResult>;
+/**
+ * Abort the revert: hard-reset the working tree, index, and branch to the
+ * pre-sequence HEAD (sequencer `head`, or the current HEAD for a lone revert),
+ * and clear all state. The branch update records git's faithful
+ * `reset: moving to <oid>` reflog. Refuses when nothing is in progress.
+ */
+declare const revertAbort: (ctx: Context) => Promise<RevertAbortResult>;
+
+/**
+ * The nested-namespace surface for `repo.revert.*` (ADR-181/192/210/217 lineage).
+ * Each method runs the caller-supplied `guard()` first (so a disposed repository
+ * throws before any work) and forwards to the Context-aware command. Frozen.
+ * `continue` / `skip` take no arguments — revert has no resume-time options.
+ */
+interface RevertNamespace {
+    readonly run: (input: RevertRunInput) => Promise<RevertResult>;
+    readonly continue: () => Promise<RevertResult>;
+    readonly skip: () => Promise<RevertResult>;
+    readonly abort: () => Promise<RevertAbortResult>;
+}
+declare const bindRevertNamespace: (ctx: Context, guard: () => void) => RevertNamespace;
+
+interface SparseCheckoutListResult {
+    readonly cone: boolean;
+    readonly patterns: ReadonlyArray<string>;
+}
+interface SparseCheckoutAppliedResult {
+    readonly cone: boolean;
+    readonly materialized: number;
+    readonly removed: number;
+    readonly retained: ReadonlyArray<FilePath>;
+}
+interface SparseCheckoutSetInput {
+    readonly patterns: ReadonlyArray<string>;
+    readonly cone?: boolean;
+    readonly force?: boolean;
+}
+interface SparseCheckoutAddInput {
+    readonly patterns: ReadonlyArray<string>;
+    readonly force?: boolean;
+}
+interface SparseCheckoutReapplyInput {
+    readonly force?: boolean;
+}
+interface SparseCheckoutDisableInput {
+    readonly force?: boolean;
+}
+declare const sparseCheckoutList: (ctx: Context) => Promise<SparseCheckoutListResult>;
+declare const sparseCheckoutSet: (ctx: Context, input: SparseCheckoutSetInput) => Promise<SparseCheckoutAppliedResult>;
+declare const sparseCheckoutAdd: (ctx: Context, input: SparseCheckoutAddInput) => Promise<SparseCheckoutAppliedResult>;
+declare const sparseCheckoutReapply: (ctx: Context, input?: SparseCheckoutReapplyInput) => Promise<SparseCheckoutAppliedResult>;
+declare const sparseCheckoutDisable: (ctx: Context, input?: SparseCheckoutDisableInput) => Promise<SparseCheckoutAppliedResult>;
+
+/**
+ * The nested-namespace surface for `repo.sparseCheckout.*`. Each method runs
+ * the caller-supplied `guard()` first (so a disposed repository throws before
+ * any work) and then forwards to the corresponding context-aware command in
+ * `commands/sparse-checkout.ts`.
+ */
+interface SparseCheckoutNamespace {
+    readonly list: () => Promise<SparseCheckoutListResult>;
+    readonly set: (input: SparseCheckoutSetInput) => Promise<SparseCheckoutAppliedResult>;
+    readonly add: (input: SparseCheckoutAddInput) => Promise<SparseCheckoutAppliedResult>;
+    readonly reapply: (input?: SparseCheckoutReapplyInput) => Promise<SparseCheckoutAppliedResult>;
+    readonly disable: (input?: SparseCheckoutDisableInput) => Promise<SparseCheckoutAppliedResult>;
+}
+/**
+ * Bind the `repo.sparseCheckout.*` nested-namespace dispatcher. `guard()` is
+ * the lifecycle gate (typically the disposed/closed check from
+ * `openRepository`); it is invoked before every method forwards to its
+ * underlying command.
+ *
+ * The returned object is frozen — callers cannot monkey-patch methods onto
+ * the namespace at runtime.
+ */
+declare const bindSparseCheckoutNamespace: (ctx: Context, guard: () => void) => SparseCheckoutNamespace;
+
+/** One entry of the stash stack, newest-first (`stash@{0}` = index 0). */
+interface StashStackEntry {
+    readonly index: number;
+    readonly selector: string;
+    readonly stash: ObjectId;
+    readonly message: string;
+}
+interface StashDropResult {
+    readonly dropped: ObjectId;
+    readonly remaining: number;
+}
+
+interface StashPushInput {
+    readonly message?: string;
+    readonly includeUntracked?: boolean;
+    readonly keepIndex?: boolean;
+}
+type StashPushResult = {
+    readonly kind: 'saved';
+    readonly stash: ObjectId;
+    readonly message: string;
+} | {
+    readonly kind: 'no-local-changes';
+};
+declare const stashPush: (ctx: Context, opts?: StashPushInput) => Promise<StashPushResult>;
+
+type StashListEntry = StashStackEntry;
+interface StashListResult {
+    readonly entries: ReadonlyArray<StashListEntry>;
+}
+/** List the stash stack, newest-first (`stash@{0}` first). */
+declare const stashList: (ctx: Context) => Promise<StashListResult>;
+interface StashDropInput {
+    readonly index?: number;
+}
+/** Drop `stash@{index}` (default newest) from the stack. */
+declare const stashDrop: (ctx: Context, input?: StashDropInput) => Promise<StashDropResult>;
+interface StashApplyInput {
+    readonly index?: number;
+    readonly restoreIndex?: boolean;
+}
+interface StashConflict {
+    readonly path: FilePath;
+    readonly type: ConflictType;
+}
+type StashApplyResult = {
+    readonly kind: 'applied';
+    readonly stash: ObjectId;
+} | {
+    readonly kind: 'conflict';
+    readonly conflicts: ReadonlyArray<StashConflict>;
+};
+/** Apply `stash@{index}` (default newest) onto the working tree via a 3-way merge. */
+declare const stashApply: (ctx: Context, input?: StashApplyInput) => Promise<StashApplyResult>;
+type StashPopResult = {
+    readonly kind: 'applied';
+    readonly stash: ObjectId;
+    readonly dropped: ObjectId;
+} | {
+    readonly kind: 'conflict';
+    readonly conflicts: ReadonlyArray<StashConflict>;
+};
+/** Apply `stash@{index}` then drop it; on conflict the stash is retained. */
+declare const stashPop: (ctx: Context, input?: StashApplyInput) => Promise<StashPopResult>;
+
+/**
+ * The nested-namespace surface for `repo.stash.*` (ADR-181 / ADR-192). Each
+ * method runs the caller-supplied `guard()` first (so a disposed repository
+ * throws before any work) and then forwards to the corresponding Context-aware
+ * command in `commands/stash.ts`. The returned object is frozen.
+ */
+interface StashNamespace {
+    readonly push: (input?: StashPushInput) => Promise<StashPushResult>;
+    readonly list: () => Promise<StashListResult>;
+    readonly apply: (input?: StashApplyInput) => Promise<StashApplyResult>;
+    readonly pop: (input?: StashApplyInput) => Promise<StashPopResult>;
+    readonly drop: (input?: StashDropInput) => Promise<StashDropResult>;
+}
+declare const bindStashNamespace: (ctx: Context, guard: () => void) => StashNamespace;
+
+/**
+ * The recognised `submodule.<name>.update` modes git copies from `.gitmodules`
+ * into `.git/config` during `init`. A `!command` form or any other token is
+ * refused (git: `fatal: invalid value for 'submodule.<name>.update'`) — only
+ * these four are valid.
+ */
+type SubmoduleUpdateMode = 'checkout' | 'rebase' | 'merge' | 'none';
+
+interface SubmoduleInitOptions {
+    /** Submodule paths to register. Default: every submodule in `.gitmodules`. */
+    readonly paths?: ReadonlyArray<string>;
+}
+interface SubmoduleInitEntry {
+    readonly name: string;
+    readonly path: FilePath;
+    /** Resolved URL now in `.git/config` (newly written, or the preserved existing value). */
+    readonly url: string;
+    /** True when this call wrote the registration; false when it was already registered. */
+    readonly registered: boolean;
+    readonly update?: SubmoduleUpdateMode;
+}
+interface SubmoduleInitResult {
+    readonly entries: ReadonlyArray<SubmoduleInitEntry>;
+}
+/**
+ * Register submodules into `.git/config` (`git submodule init`). For each
+ * un-registered submodule (no `submodule.<name>.url` in config) writes
+ * `active = true`, the resolved `url`, and (when declared) a validated
+ * `update` mode, in git's key order. An already-registered submodule keeps its
+ * url untouched (`registered: false`). Relative `.gitmodules` URLs resolve
+ * against the superproject's default-remote URL.
+ */
+declare const submoduleInit: (ctx: Context, opts?: SubmoduleInitOptions) => Promise<SubmoduleInitResult>;
+interface SubmoduleSyncOptions {
+    /** Submodule paths to sync. Default: every initialised submodule. */
+    readonly paths?: ReadonlyArray<string>;
+    /** `--recursive`: descend into checked-out submodules and sync their nested ones. */
+    readonly recursive?: boolean;
+}
+interface SubmoduleSyncEntry {
+    readonly name: string;
+    readonly path: FilePath;
+    /** Resolved URL written to `submodule.<name>.url`. */
+    readonly url: string;
+    /** True when the checked-out submodule's own `remote.origin.url` was updated too. */
+    readonly syncedRemote: boolean;
+}
+interface SubmoduleSyncResult {
+    readonly entries: ReadonlyArray<SubmoduleSyncEntry>;
+}
+/**
+ * Re-point configured submodule URLs from `.gitmodules` (`git submodule sync`).
+ * Operates only on **initialised** submodules (those already carrying
+ * `submodule.<name>.url` in config); a fresh clone with nothing initialised is a
+ * no-op. Overwrites `submodule.<name>.url` with the freshly resolved URL and,
+ * when the submodule is checked out, its own `remote.origin.url`. With
+ * `recursive`, descends into each checked-out submodule and syncs its nested ones.
+ */
+declare const submoduleSync: (ctx: Context, opts?: SubmoduleSyncOptions) => Promise<SubmoduleSyncResult>;
+interface SubmoduleDeinitOptions {
+    /** Submodule paths to deinitialise. Required unless `all` is set. */
+    readonly paths?: ReadonlyArray<string>;
+    /** Deinitialise every submodule. Required when `paths` is empty/omitted. */
+    readonly all?: boolean;
+    /** Discard a submodule working tree that has local modifications. */
+    readonly force?: boolean;
+}
+interface SubmoduleDeinitEntry {
+    readonly name: string;
+    readonly path: FilePath;
+    /** The raw `.gitmodules` URL (git's unregister message reports this form). */
+    readonly url: string;
+    /** True when a populated working tree was cleared. */
+    readonly cleared: boolean;
+}
+interface SubmoduleDeinitResult {
+    readonly entries: ReadonlyArray<SubmoduleDeinitEntry>;
+}
+/**
+ * Unregister submodules and clear their working trees (`git submodule deinit`).
+ * Requires `paths` or `all`. Removes each submodule's `.git/config` section and
+ * clears its working-tree contents (the empty directory, `.gitmodules`, the
+ * index gitlink, and `.git/modules/<name>` are all left intact). Refuses a
+ * submodule with local modifications unless `force`.
+ */
+declare const submoduleDeinit: (ctx: Context, opts?: SubmoduleDeinitOptions) => Promise<SubmoduleDeinitResult>;
+interface SubmoduleListOptions {
+    /** Tree-ish to walk. Default: `'HEAD'`. */
+    readonly ref?: string;
+    /** Descend into nested submodules' own `.gitmodules`. Default: `false`. */
+    readonly recursive?: boolean;
+    /**
+     * Cap on recursion depth. Default: `MAX_SUBMODULE_DEPTH`. Entries at exactly
+     * this depth are yielded but not recursed into.
+     */
+    readonly maxDepth?: number;
+}
+interface SubmoduleListResult {
+    readonly entries: ReadonlyArray<SubmoduleEntry>;
+}
+declare const submoduleList: (ctx: Context, opts?: SubmoduleListOptions) => Promise<SubmoduleListResult>;
+interface SubmoduleAddOptions {
+    /** Submodule URL — stored verbatim in `.gitmodules`, resolved for `.git/config`. */
+    readonly url: string;
+    /** Worktree-relative checkout path. */
+    readonly path: string;
+    /** `.gitmodules` subsection name. Default: `path` (git's `--name` default). */
+    readonly name?: string;
+    /** `-b`: track this branch instead of the remote default HEAD. */
+    readonly branch?: string;
+}
+interface SubmoduleAddEntry {
+    readonly name: string;
+    readonly path: FilePath;
+    /** Resolved URL written to `.git/config` + the module's `remote.origin.url`. */
+    readonly url: string;
+    /** Submodule HEAD oid staged as the gitlink. */
+    readonly id: ObjectId;
+    /** Checked-out branch (remote default HEAD branch, or `branch`). */
+    readonly branch: string;
+}
+type SubmoduleAddResult = SubmoduleAddEntry;
+/**
+ * Clone a new submodule into the worktree + `.git/modules/<name>` and register
+ * it (`git submodule add`). Clones the remote into the absorbed gitdir, writes
+ * `core.worktree` + the `.git` gitfile, materialises the working tree on the
+ * remote default branch, writes `.gitmodules`, stages the gitlink +
+ * `.gitmodules` blob, and records `submodule.<name>.{url,active}` in
+ * `.git/config`. Refuses an unsafe/empty name/path/url or an already-tracked path.
+ */
+declare const submoduleAdd: (ctx: Context, opts: SubmoduleAddOptions) => Promise<SubmoduleAddResult>;
+interface SubmoduleUpdateOptions {
+    /** Submodule paths to update. Default: every registered submodule. */
+    readonly paths?: ReadonlyArray<string>;
+    /** `--init`: register an unregistered submodule before updating it. */
+    readonly init?: boolean;
+    /** `--checkout`/`--rebase`/`--merge`: override the configured update mode. */
+    readonly mode?: SubmoduleUpdateMode;
+}
+interface SubmoduleUpdateEntry {
+    readonly name: string;
+    readonly path: FilePath;
+    /** Pinned gitlink oid the submodule was reconciled to. */
+    readonly id: ObjectId;
+    /** Mode actually applied. */
+    readonly mode: SubmoduleUpdateMode;
+    /** True when this call cloned the module gitdir. */
+    readonly cloned: boolean;
+    /** True when the submodule HEAD/branch moved (false ⇒ already in sync / none). */
+    readonly changed: boolean;
+}
+interface SubmoduleUpdateResult {
+    readonly entries: ReadonlyArray<SubmoduleUpdateEntry>;
+}
+/**
+ * Clone-if-missing + reconcile each registered, selected submodule to its pinned
+ * commit (`git submodule update`). The pinned oid is read from the superproject
+ * index gitlink; the module is cloned into `.git/modules/<name>` when absent,
+ * then brought to the pin per its `update` mode (`checkout`/`rebase`/`merge`/
+ * `none`; `opts.mode` overrides). An unregistered submodule is skipped unless
+ * `init`. Refuses `OBJECT_NOT_FOUND` when the pin is absent after cloning (the
+ * remote-advanced case — tsgit has no incremental fetch).
+ */
+declare const submoduleUpdate: (ctx: Context, opts?: SubmoduleUpdateOptions) => Promise<SubmoduleUpdateResult>;
+
+/**
+ * The nested-namespace surface for `repo.submodule.*`. Each method runs the
+ * caller-supplied `guard()` first (so a disposed repository throws before any
+ * work) and then forwards to the corresponding context-aware command in
+ * `commands/submodule.ts`.
+ */
+interface SubmoduleNamespace {
+    readonly list: (opts?: SubmoduleListOptions) => Promise<SubmoduleListResult>;
+    readonly add: (opts: SubmoduleAddOptions) => Promise<SubmoduleAddResult>;
+    readonly init: (opts?: SubmoduleInitOptions) => Promise<SubmoduleInitResult>;
+    readonly update: (opts?: SubmoduleUpdateOptions) => Promise<SubmoduleUpdateResult>;
+    readonly sync: (opts?: SubmoduleSyncOptions) => Promise<SubmoduleSyncResult>;
+    readonly deinit: (opts?: SubmoduleDeinitOptions) => Promise<SubmoduleDeinitResult>;
+}
+/**
+ * Bind the `repo.submodule.*` nested-namespace dispatcher. `guard()` is the
+ * lifecycle gate (typically the disposed/closed check from `openRepository`);
+ * it is invoked before every method forwards to its underlying command. The
+ * returned object is frozen — callers cannot monkey-patch the namespace.
+ */
+declare const bindSubmoduleNamespace: (ctx: Context, guard: () => void) => SubmoduleNamespace;
+
+interface TagInfo {
+    readonly name: RefName;
+    readonly id: ObjectId;
+}
+interface TagListResult {
+    readonly tags: ReadonlyArray<TagInfo>;
+}
+interface TagCreateInput {
+    readonly name: string;
+    readonly target?: string;
+    readonly force?: boolean;
+    /** Create an annotated tag object (git's `-a`). Implied by `message` and `sign`. */
+    readonly annotate?: boolean;
+    /** Annotated tag message (git's `-m`). Setting this implies `annotate`. */
+    readonly message?: string;
+    /** GPG-sign the annotated tag (git's `-s`). Implies `annotate`; falls back to `tag.gpgSign` when unset. */
+    readonly sign?: boolean;
+    /** Signer key override (git's `-u <keyid>` / `--local-user`). */
+    readonly signKey?: string;
+}
+interface TagCreateResult {
+    readonly name: RefName;
+    readonly id: ObjectId;
+}
+interface TagDeleteInput {
+    readonly name: string;
+}
+interface TagDeleteResult {
+    readonly name: RefName;
+}
+declare const tagList: (ctx: Context) => Promise<TagListResult>;
+declare const tagCreate: (ctx: Context, input: TagCreateInput) => Promise<TagCreateResult>;
+declare const tagDelete: (ctx: Context, input: TagDeleteInput) => Promise<TagDeleteResult>;
+
+/**
+ * The nested-namespace surface for `repo.tag.*`. Each method runs the
+ * caller-supplied `guard()` first (so a disposed repository throws before any
+ * work) and then forwards to the corresponding context-aware command in
+ * `commands/tag.ts`.
+ */
+interface TagNamespace {
+    readonly list: () => Promise<TagListResult>;
+    readonly create: (input: TagCreateInput) => Promise<TagCreateResult>;
+    readonly delete: (input: TagDeleteInput) => Promise<TagDeleteResult>;
+}
+/**
+ * Bind the `repo.tag.*` nested-namespace dispatcher. `guard()` is the
+ * lifecycle gate (typically the disposed/closed check from `openRepository`);
+ * it is invoked before every method forwards to its underlying command.
+ *
+ * The returned object is frozen — callers cannot monkey-patch methods onto
+ * the namespace at runtime.
+ */
+declare const bindTagNamespace: (ctx: Context, guard: () => void) => TagNamespace;
+
+/**
+ * Enumerate the repository's worktrees — the main worktree first, then each
+ * linked worktree registered under `<commonDir>/worktrees/<id>/`, sorted by
+ * path. A pure read over the admin pointer files; the shared branch refs resolve
+ * through the common-dir ref store.
+ */
+
+interface WorktreeEntry {
+    /** Admin-directory id (`<commonDir>/worktrees/<id>`); absent for the main worktree. */
+    readonly id?: string;
+    /** Absolute worktree path. */
+    readonly path: FilePath;
+    /** HEAD commit oid; absent for an unborn branch or a bare main worktree. */
+    readonly head?: ObjectId;
+    /** Full branch refname HEAD points at; absent when detached or bare. */
+    readonly branch?: RefName;
+    readonly detached: boolean;
+    readonly bare: boolean;
+    /** Present ⇒ locked; `reason` is the recorded reason (`''` when none). */
+    readonly locked?: {
+        readonly reason: string;
+    };
+    /** Present ⇒ the admin entry's worktree is gone (prunable). */
+    readonly prunable?: {
+        readonly reason: string;
+    };
+    /** True for the primary worktree. */
+    readonly main: boolean;
+}
+
+/**
+ * `worktree` porcelain — the `repo.worktree.*` nested namespace. Manages linked
+ * working trees over one object store: `list` / `add` / `move` / `remove`.
+ *
+ * Per ADR-249 the results are structured data — `list` returns the per-worktree
+ * fields (path, head oid, branch, detached, bare, locked, prunable), never a
+ * rendered table. The namespace binder lives in
+ * `internal/worktree-namespace.ts`.
+ */
+
+interface WorktreeListResult {
+    readonly entries: ReadonlyArray<WorktreeEntry>;
+}
+/**
+ * List the repository's worktrees (`git worktree list`) — the main worktree
+ * first, then each linked worktree sorted by path.
+ */
+declare const worktreeList: (ctx: Context) => Promise<WorktreeListResult>;
+interface WorktreeAddOptions {
+    /** Worktree-relative or absolute target directory for the new worktree. */
+    readonly path: string;
+    /** Start point (commit-ish); default `HEAD`. */
+    readonly commitish?: string;
+    /** `-b`: create this new branch at the start point. */
+    readonly branch?: string;
+    /** `--detach`: detached HEAD at the start point instead of a branch. */
+    readonly detach?: boolean;
+    /** Override the existing-branch / checked-out refusals. */
+    readonly force?: boolean;
+}
+interface WorktreeAddResult {
+    readonly path: FilePath;
+    readonly id: string;
+    readonly head: ObjectId;
+    /** Created/checked-out branch; absent when detached. */
+    readonly branch?: RefName;
+    readonly detached: boolean;
+}
+/**
+ * Create a linked worktree (`git worktree add`). Resolves the start point,
+ * decides the mode (new branch from `-b`/the path basename, checkout of an
+ * existing branch, or detached), creates the branch when needed, lays down the
+ * admin pointer files + the `.git` gitfile, and materialises the working tree +
+ * per-worktree index. Refuses a non-empty target, an existing branch (without
+ * force), or a branch already used by another worktree (without force).
+ */
+declare const worktreeAdd: (ctx: Context, opts: WorktreeAddOptions) => Promise<WorktreeAddResult>;
+interface WorktreeMoveOptions {
+    /** Move even when the worktree is locked. */
+    readonly force?: boolean;
+}
+interface WorktreeMoveResult {
+    readonly from: FilePath;
+    readonly to: FilePath;
+    readonly id: string;
+}
+/**
+ * Relocate a linked worktree (`git worktree move`). Renames the worktree
+ * directory and re-points the admin `gitdir` file at the new `.git` location;
+ * the `.git` gitfile itself moves with the directory and still points at the
+ * (unchanged) admin dir. Refuses a locked worktree (without force), a non-empty
+ * destination, the main worktree, or a non-worktree source.
+ */
+declare const worktreeMove: (ctx: Context, from: string, to: string, opts?: WorktreeMoveOptions) => Promise<WorktreeMoveResult>;
+interface WorktreeRemoveOptions {
+    /** Remove even when the worktree is dirty or locked. */
+    readonly force?: boolean;
+}
+interface WorktreeRemoveResult {
+    readonly path: FilePath;
+    readonly id: string;
+}
+/**
+ * Remove a linked worktree (`git worktree remove`). Refuses a locked worktree or
+ * one with modified/untracked files (without force), then deletes the worktree
+ * directory and its admin dir. The branch is left intact. Refuses the main
+ * worktree or a non-worktree path.
+ */
+declare const worktreeRemove: (ctx: Context, path: string, opts?: WorktreeRemoveOptions) => Promise<WorktreeRemoveResult>;
+
+/**
+ * The nested-namespace surface for `repo.worktree.*`. Each method runs the
+ * caller-supplied `guard()` first (so a disposed repository throws before any
+ * work) and then forwards to the corresponding context-aware command in
+ * `commands/worktree.ts`.
+ */
+interface WorktreeNamespace {
+    readonly list: () => Promise<WorktreeListResult>;
+    readonly add: (opts: WorktreeAddOptions) => Promise<WorktreeAddResult>;
+    readonly move: (from: string, to: string, opts?: WorktreeMoveOptions) => Promise<WorktreeMoveResult>;
+    readonly remove: (path: string, opts?: WorktreeRemoveOptions) => Promise<WorktreeRemoveResult>;
+}
+/**
+ * Bind the `repo.worktree.*` nested-namespace dispatcher. `guard()` is the
+ * lifecycle gate from `openRepository`; it is invoked before every method
+ * forwards to its underlying command. The returned object is frozen.
+ */
+declare const bindWorktreeNamespace: (ctx: Context, guard: () => void) => WorktreeNamespace;
+
+/**
+ * Walk order. `'date'` (default) yields every reachable commit across all
+ * parents, newest committer-date first (git's default `git log` order);
+ * `'first-parent'` follows only the first parent (`git log --first-parent`).
+ */
+type LogOrder = 'date' | 'first-parent';
+interface LogOptions {
+    readonly rev?: string;
+    readonly order?: LogOrder;
+    readonly limit?: number;
+    readonly excluding?: ReadonlyArray<string>;
+    readonly before?: Date;
+    readonly minParents?: number;
+    readonly maxParents?: number;
+}
+interface LogEntry {
+    readonly id: ObjectId;
+    readonly tree: ObjectId;
+    readonly parents: ReadonlyArray<ObjectId>;
+    readonly author: AuthorIdentity;
+    readonly committer: AuthorIdentity;
+    readonly message: string;
+}
+/**
+ * Walk commits starting from `rev` (default: HEAD), yielding ordered `LogEntry`
+ * records. By default walks every reachable commit across all parents in
+ * committer-date order; `order: 'first-parent'` follows only the first parent.
+ * Honors `limit`, `excluding` (commit-ish stops), `before` (only commits with
+ * `committer.timestamp < before`), and `minParents`/`maxParents` (parent-count band).
+ */
+declare const log: (ctx: Context, opts?: LogOptions) => Promise<ReadonlyArray<LogEntry>>;
+
+interface MvOptions {
+    /** Overwrite an existing destination (a file source only). `-f`. */
+    readonly force?: boolean;
+    /** Validate and report the plan without touching index or working tree. `-n`. */
+    readonly dryRun?: boolean;
+    /** Skip refused (source → target) pairs instead of aborting the whole call. `-k`. */
+    readonly skipErrors?: boolean;
+}
+interface MvMove {
+    readonly from: FilePath;
+    readonly to: FilePath;
+}
+/** Per-source refusals that `skipErrors` collects rather than throwing. */
+type MvSkipReason = 'source-not-tracked' | 'bad-source' | 'destination-exists' | 'into-self';
+interface MvSkipped {
+    readonly source: FilePath;
+    readonly reason: MvSkipReason;
+}
+interface MvResult {
+    readonly moved: ReadonlyArray<MvMove>;
+    readonly skipped: ReadonlyArray<MvSkipped>;
+}
+/**
+ * Move/rename tracked paths in the index and the working tree, faithful to
+ * `git mv`. Each (source → target) pair is validated up front; on any refusal
+ * nothing is moved (unless `skipErrors`). Blob ids and modes are copied from the
+ * source's index entry — the working file is renamed as-is, never re-hashed.
+ */
+declare const mv: (ctx: Context, sources: ReadonlyArray<string>, destination: string, opts?: MvOptions) => Promise<MvResult>;
+
+interface PullOptions {
+    /**
+     * Remote to pull from. Default: `branch.<current>.remote` ?? the sole
+     * configured remote ?? `'origin'`.
+     */
+    readonly remote?: string;
+    /**
+     * Remote ref to merge — a short branch name resolved as
+     * `refs/remotes/<remote>/<ref>`. Default: short form of
+     * `branch.<current>.merge`. When neither is resolvable, pull throws
+     * `NO_UPSTREAM_CONFIGURED`.
+     */
+    readonly ref?: string;
+    /**
+     * Fast-forward policy for the integrate step, forwarded to `merge` (git
+     * `--ff` / `--ff-only` / `--no-ff`):
+     * - `'allow'` (default) — fast-forward when possible, else a true merge.
+     * - `'only'` — reject when a true merge would be required.
+     * - `'never'` — always create a merge commit, even when a fast-forward is possible.
+     */
+    readonly fastForward?: 'only' | 'never' | 'allow';
+    /** Prune deleted remote-tracking refs during the fetch step. */
+    readonly prune?: boolean;
+    /** Shallow fetch depth, forwarded to fetch. */
+    readonly depth?: number;
+    /** Override the generated merge commit message / MERGE_MSG. */
+    readonly message?: string;
+    /** Identity for the merge commit (true-merge path only). */
+    readonly author?: AuthorIdentity;
+    readonly committer?: AuthorIdentity;
+}
+interface PullResult {
+    readonly fetch: FetchResult;
+    readonly merge: MergeResult;
+}
+declare const pull: (ctx: Context, opts?: PullOptions) => Promise<PullResult>;
+
+interface PushOptions {
+    readonly remote?: string;
+    readonly refspecs?: ReadonlyArray<string>;
+    readonly force?: boolean;
+    readonly forceWithLease?: ObjectId | 'auto';
+    /** Skip the `pre-push` hook (git's `--no-verify`). */
+    readonly noVerify?: boolean;
+    /**
+     * GPG-sign the push certificate (git's `--signed`). `'yes'` refuses when
+     * the receiving end doesn't advertise `push-cert`; `'if-asked'` falls back
+     * to an unsigned push in that case. Falls back to `push.gpgSign` when unset.
+     */
+    readonly signed?: 'yes' | 'no' | 'if-asked';
+}
+interface PushedRef {
+    readonly name: RefName;
+    readonly oldId: ObjectId;
+    readonly newId: ObjectId;
+    readonly status: 'ok' | 'rejected';
+    readonly reason?: string;
+}
+interface PushResult {
+    readonly remote: string;
+    readonly url: string;
+    readonly pushedRefs: ReadonlyArray<PushedRef>;
+}
+declare const push: (ctx: Context, opts?: PushOptions) => Promise<PushResult>;
+
+/**
+ * Order the corresponded patches into git's `range-diff` output sequence
+ * (`output` in `range-diff.c`): drive by the new range, slotting deleted old
+ * commits in once their predecessors are shown. Each emitted pair becomes a
+ * structured `RangeDiffEntry` — status (`= ! < >`), the old/new commit position
+ * + oid, the shown subject (old's when present), and, for a `changed` pair, the
+ * structured diff-of-diffs (`diffLines` of the two `## ` patch texts).
+ */
+
+type RangeDiffStatus = 'unchanged' | 'changed' | 'only-old' | 'only-new';
+interface RangeDiffCommit {
+    /** 1-based position of the commit in its (merge-filtered, oldest-first) series. */
+    readonly position: number;
+    readonly id: ObjectId;
+}
+interface RangeDiffEntry {
+    readonly status: RangeDiffStatus;
+    readonly old?: RangeDiffCommit;
+    readonly new?: RangeDiffCommit;
+    readonly subject: string;
+    /** The diff-of-diffs (`diffLines(old.patch, new.patch)`); present iff `changed`. */
+    readonly diffOfDiffs?: LineDiff;
+}
+
+/**
+ * Tier-1 `range-diff` command — git's `git range-diff`: compare two commit
+ * ranges and report, commit-by-commit, which patches were added, removed, left
+ * unchanged, or changed. Returns structured data only (ADR-249): the ordered
+ * correspondence list, each changed pair carrying the structured diff-of-diffs.
+ * The command owns the I/O — resolving the range endpoints, walking each
+ * `base..tip` (date order, oldest-first, merges excluded), and reading the trees
+ * and blobs — then hands the pure domain orchestrator two hydrated patch series.
+ */
+
+/** A commit range — `base..tip`, each a commit-ish (full rev grammar). */
+interface RangeDiffRange {
+    readonly base: string;
+    readonly tip: string;
+}
+interface RangeDiffOptions {
+    /** The first / "old" range. */
+    readonly old: RangeDiffRange;
+    /** The second / "new" range. */
+    readonly new: RangeDiffRange;
+    /** git's `--creation-factor` (percentage); default `60`. */
+    readonly creationFactor?: number;
+}
+declare const rangeDiff: (ctx: Context, opts: RangeDiffOptions) => Promise<ReadonlyArray<RangeDiffEntry>>;
+
+/**
+ * Tier-1 `readFileAt` command — read a file's bytes as of a revision, the
+ * structured equivalent of `git show <rev>:<path>` / `git cat-file blob
+ * <rev>:<path>`.
+ *
+ * Resolves `rev` through the full rev-parse grammar (short names, `~`/`^`
+ * navigation, abbreviated oids, reflog selectors), peels to its root tree,
+ * descends `path`'s `/`-separated components, and returns the addressed blob —
+ * refusing a directory or gitlink with `UNEXPECTED_OBJECT_TYPE` and a missing
+ * path with `PATH_NOT_IN_TREE`. The library renders nothing; the caller owns any
+ * display.
+ */
+
+/** Structured result of reading a file's bytes as of a revision. */
+interface ReadFileAtResult {
+    /** The addressed blob's object id. */
+    readonly id: ObjectId;
+    /** The file's tree-entry mode (`100644` | `100755` | `120000`). */
+    readonly mode: FileMode;
+    /** The blob's raw, verbatim committed bytes. */
+    readonly content: Uint8Array;
+}
+/**
+ * Read the file addressed by `path` in the tree of `rev`.
+ *
+ * @param rev - any rev-parse expression (e.g. `HEAD`, `main`, `v1.0`, `HEAD~3`,
+ *   an abbreviated oid).
+ * @param path - a `/`-separated tree path to the file.
+ * @param options - forwarded to the final blob read; `maxBytes` bounds the file
+ *   (`OBJECT_TOO_LARGE` when exceeded), `verifyHash` re-checks its hash.
+ */
+declare const readFileAt: (ctx: Context, rev: string, path: string, options?: ReadObjectOptions) => Promise<ReadFileAtResult>;
+
+type ReflogAction = {
+    readonly action?: 'show';
+    readonly ref?: string;
+} | {
+    readonly action: 'exists';
+    readonly ref: string;
+} | {
+    readonly action: 'delete';
+    readonly ref: string;
+    readonly index: number;
+    readonly rewrite?: boolean;
+} | {
+    readonly action: 'expire';
+    readonly ref?: string;
+    readonly all?: boolean;
+    readonly expire?: string;
+    readonly expireUnreachable?: string;
+};
+/** One reflog entry as `show` presents it: newest-first, with a selector. */
+interface ReflogShowEntry {
+    readonly index: number;
+    readonly selector: string;
+    readonly entry: ReflogEntry;
+}
+type ReflogResult = {
+    readonly kind: 'show';
+    readonly ref: RefName;
+    readonly entries: ReadonlyArray<ReflogShowEntry>;
+} | {
+    readonly kind: 'exists';
+    readonly exists: boolean;
+} | {
+    readonly kind: 'expire';
+    readonly removed: number;
+    readonly kept: number;
+} | {
+    readonly kind: 'delete';
+    readonly removed: ReflogEntry;
+};
+declare const reflog: (ctx: Context, opts?: ReflogAction) => Promise<ReflogResult>;
+
+type ResetMode = 'soft' | 'mixed' | 'hard';
+interface ResetOptions {
+    readonly mode: ResetMode;
+    readonly rev: string;
+}
+interface ResetResult {
+    readonly mode: ResetMode;
+    readonly id: ObjectId;
+    readonly branch: RefName | undefined;
+}
+/**
+ * Reset HEAD (and optionally index/working tree) to `rev`.
+ *
+ * - `soft`: HEAD only.
+ * - `mixed`: HEAD + rebuild the index from the target commit's tree
+ *  (stat-cache donor strategy preserves cache for unchanged paths —
+ * ). Working tree is NOT touched.
+ * - `hard`: HEAD + index + working tree — materialise the target tree onto
+ *  the working tree with `force: true`, then commit the post-write
+ *  index entries. Bare repos are rejected upfront.
+ *
+ * Ordering: working tree → index → HEAD. The index lock wraps both the
+ * working-tree write AND the index commit, matching tightened
+ * pattern. A crash between the index commit and HEAD update leaves the index
+ * ahead of HEAD — same recoverable hazard as canonical git.
+ */
+declare const reset: (ctx: Context, opts: ResetOptions) => Promise<ResetResult>;
+
+declare const revParse: (ctx: Context, expression: string) => Promise<ObjectId>;
+
+interface RmOptions {
+    readonly cached?: boolean;
+    /** Override the safety valve (`-f`) — remove even staged / locally-modified paths. */
+    readonly force?: boolean;
+}
+interface RmResult {
+    readonly removed: ReadonlyArray<FilePath>;
+}
+/**
+ * Remove the given paths from the index (and from the working tree unless
+ * `cached: true`). Refuses when a path isn't tracked, matches `git rm`'s default.
+ */
+declare const rm: (ctx: Context, paths: ReadonlyArray<string>, opts?: RmOptions) => Promise<RmResult>;
+
+/** One commit within a `shortlog` group. */
+interface ShortlogCommit {
+    readonly id: ObjectId;
+    readonly email: string;
+    readonly subject: string;
+}
+/** A per-identity-name `shortlog` group; commits are oldest first. */
+interface ShortlogGroup {
+    readonly name: string;
+    readonly commits: ReadonlyArray<ShortlogCommit>;
+}
+
+/**
+ * Tier-1 `shortlog` command — git's `git shortlog`: walk the commits reachable
+ * from a revision and group them by author (or committer) identity. Returns
+ * structured data only (ADR-249): per-author groups keyed by the identity name,
+ * each commit carrying `{ id, email, subject }` (git's cleaned shortlog oneline),
+ * oldest first; groups byte-sorted by name. The `-e` / `-n` / `-s` renderings are
+ * caller projections.
+ */
+
+/** Which identity keys the grouping. */
+type ShortlogBy = 'author' | 'committer';
+interface ShortlogOptions {
+    /** Commit-ish to start the walk from (full rev grammar); default `'HEAD'`. */
+    readonly rev?: string;
+    /** Commit-ish stops excluded from the walk (git's `A..B` / `^X` ranges). */
+    readonly excluding?: ReadonlyArray<string>;
+    /** Group by author (default) or committer identity. */
+    readonly by?: ShortlogBy;
+}
+declare const shortlog: (ctx: Context, opts?: ShortlogOptions) => Promise<ReadonlyArray<ShortlogGroup>>;
+
+/**
+ * Tier-1 `show` command — structured object data for commit / tag / tree / blob
+ * revisions. Resolves each revision (full rev-parse grammar, no tag auto-peel),
+ * reads the object, and returns a structured `ShowResult`: a commit carries its
+ * `CommitData` plus the diff against its parent (`patch`) or, for a merge, one
+ * diff per parent (`perParent`); a tag carries its `TagData` and the recursively
+ * shown target; a tree carries its entries; a blob carries its raw content.
+ *
+ * The library renders nothing — assembling `git show`'s display (commit/Merge
+ * headers, dates, the unified patch, combined-diff for merges) from these fields
+ * is the caller's concern.
+ */
+
+type ShowInput = string | ReadonlyArray<string>;
+interface ShowOptions {
+    /**
+     * Attach per-file line counts (`added` / `deleted` / `binary`) to the diff(s)
+     * — the data half of git's `--numstat`. Off by default (no blob reads).
+     */
+    readonly withStat?: boolean;
+}
+interface ShowTreeEntry {
+    readonly name: string;
+    readonly mode: FileMode;
+    readonly id: ObjectId;
+}
+interface ShowCommitResult<D = TreeDiff> {
+    readonly kind: 'commit';
+    readonly id: ObjectId;
+    readonly commit: CommitData;
+    /** Diff against the single parent (root: against the empty tree). Absent for merges. */
+    readonly patch?: D;
+    /** One diff per parent, for a merge (≥2 parents). Absent for non-merges. */
+    readonly perParent?: ReadonlyArray<D>;
+}
+interface ShowTagResult<D = TreeDiff> {
+    readonly kind: 'tag';
+    readonly id: ObjectId;
+    readonly tag: TagData;
+    readonly target: ShowResult<D>;
+}
+interface ShowTreeResult {
+    readonly kind: 'tree';
+    readonly id: ObjectId;
+    readonly entries: ReadonlyArray<ShowTreeEntry>;
+}
+interface ShowBlobResult {
+    readonly kind: 'blob';
+    readonly id: ObjectId;
+    readonly content: Uint8Array;
+}
+type ShowResult<D = TreeDiff> = ShowCommitResult<D> | ShowTagResult<D> | ShowTreeResult | ShowBlobResult;
+declare function show(ctx: Context, rev: ReadonlyArray<string>, opts: ShowOptions & {
+    withStat: true;
+}): Promise<ReadonlyArray<ShowResult<StatTreeDiff>>>;
+declare function show(ctx: Context, rev: string | undefined, opts: ShowOptions & {
+    withStat: true;
+}): Promise<ShowResult<StatTreeDiff>>;
+declare function show(ctx: Context, rev: ReadonlyArray<string>, opts?: ShowOptions): Promise<ReadonlyArray<ShowResult>>;
+declare function show(ctx: Context, rev?: string, opts?: ShowOptions): Promise<ShowResult>;
+
+type ChangeKind = 'modified' | 'added' | 'deleted' | 'type-changed' | 'mode-changed';
+
+/** A blob reference on one side of a comparison: its object id and file mode. */
+interface BlobSide {
+    readonly id: ObjectId;
+    readonly mode: FileMode;
+}
+/**
+ * The working-tree side of a change: mode only. The working file need not be in
+ * the object store, so git reports its mode (`mW`) but no working blob oid.
+ */
+interface WorktreeSide {
+    readonly mode: FileMode;
+}
+/**
+ * One tracked path with a staged and/or unstaged change — the structured form of
+ * `git status --porcelain=v2`'s ordinary changed-entry line. At least one of
+ * `staged` (index vs HEAD, git's X) and `unstaged` (worktree vs index, git's Y) is
+ * present. The `head` / `index` / `worktree` sides carry the blobs that form the
+ * change's diffs; a side is omitted when the path does not exist there (staged add
+ * → no `head`; staged delete → no `index`; deleted in the worktree → no
+ * `worktree`). The hunks for any path are one read away — staged: `head` blob ↔
+ * `index` blob; unstaged: `index` blob ↔ the working file at `path`.
+ */
+interface ChangedPath {
+    readonly path: FilePath;
+    readonly staged?: ChangeKind;
+    readonly unstaged?: ChangeKind;
+    readonly head?: BlobSide;
+    readonly index?: BlobSide;
+    readonly worktree?: WorktreeSide;
+}
+/**
+ * An unmerged (conflicted) path: its git conflict state plus the per-stage blobs
+ * (`base` = stage 1, `ours` = stage 2, `theirs` = stage 3; omitted when that stage
+ * is absent) and the conflicted file's on-disk mode (`worktree`, git's `mW`;
+ * omitted when the file is absent on disk). The stages plus `worktree` make the
+ * entry lossless against git's porcelain unmerged reporting (v1 `XY` from `kind`,
+ * the full v2 `u`-line modes/oids from the stages and `worktree`).
+ */
+interface UnmergedEntry {
+    readonly kind: ConflictKind;
+    readonly path: FilePath;
+    readonly base?: BlobSide;
+    readonly ours?: BlobSide;
+    readonly theirs?: BlobSide;
+    readonly worktree?: WorktreeSide;
+}
+interface StatusResult {
+    readonly branch: RefName | undefined;
+    readonly detached: boolean;
+    readonly changes: ReadonlyArray<ChangedPath>;
+    readonly untracked: ReadonlyArray<FilePath>;
+    readonly unmerged: ReadonlyArray<UnmergedEntry>;
+    readonly clean: boolean;
+}
+/**
+ * Summarize the state of the working tree against git's columns, one correlated
+ * record per changed path. `changes` carries each tracked path's **staged** column
+ * (index vs HEAD-tree, git's "Changes to be committed") and **working-tree** column
+ * (index vs working tree) together with the blob endpoints of each side — the
+ * structured form of `git status --porcelain=v2`'s ordinary line. `untracked` is
+ * the separate set of untracked paths (git's `?` lines); `unmerged` is the
+ * conflicted column (stage 1/2/3 blobs, git's "Unmerged paths"). A conflicted path
+ * is reported only under `unmerged`. `clean` is true only when all three are empty.
+ *
+ * Progress reporting: emits `status:scan` start before the working-tree fan-out,
+ * updates every 100 lstat completions, and end in a finally block so the consumer
+ * always pairs start with end. `total` is undefined — a design choice that avoids
+ * revealing repository size to non-trusted progress sinks.
+ */
+declare const status: (ctx: Context) => Promise<StatusResult>;
+
+/**
+ * Tier-1 `whatchanged` command — git's `git whatchanged` (modern alias for
+ * `git log --raw --no-merges`): walk the commits reachable from a revision and
+ * pair each non-merge commit with the raw structured changes it introduced
+ * against its first parent (root: against the empty tree). Merge commits are
+ * excluded from the output but still traversed for reachability.
+ *
+ * Returns structured data only (ADR-249): each entry reuses `log`'s commit
+ * projection (`WhatchangedEntry extends LogEntry`) plus a `TreeDiff`. The `--raw`
+ * line rendering, oid abbreviation, and date formatting are caller concerns.
+ */
+
+interface WhatchangedOptions {
+    readonly rev?: string;
+    readonly order?: LogOrder;
+    readonly limit?: number;
+    readonly excluding?: ReadonlyArray<string>;
+    readonly before?: Date;
+}
+interface WhatchangedEntry extends LogEntry {
+    /** Raw changes against the first parent (root: against the empty tree). */
+    readonly changes: TreeDiff;
+}
+/**
+ * Walk commits from `rev` (default HEAD), excluding merges (≥2 parents), and pair
+ * each with its first-parent `TreeDiff` (recursive, rename-detecting like
+ * `git show`). Honors `order`, `limit` (counts emitted entries), `excluding`
+ * (commit-ish stops), and `before` (only `committer.timestamp < before`).
+ */
+declare const whatchanged: (ctx: Context, opts?: WhatchangedOptions) => Promise<ReadonlyArray<WhatchangedEntry>>;
+
+export { BINARY_DETECTION_BYTES as B, MAX_DIFF_EDIT_DISTANCE as aL, MAX_DIFF_ITERATION_FACTOR as aM, MAX_DIFF_LINES as aN, MAX_LINES as aO, MAX_LINE_BYTES as aP, nameRev as d$, add as d1, archive as d2, bindBranchNamespace as d3, bindBundleNamespace as d4, bindCherryPickNamespace as d5, bindConfigNamespace as d6, bindMergeNamespace as d7, bindNotesNamespace as d8, bindRebaseNamespace as d9, configGet as dA, configGetAll as dB, configGetRegexp as dC, configList as dD, configRemoveSection as dE, configRenameSection as dF, configSet as dG, configUnset as dH, configUnsetAll as dI, conflictsToIndexEntries as dJ, createPromisorRemote as dK, describe as dL, diff as dM, diffIndexAgainstTree as dN, diffLines as dO, fetch as dP, fetchMissing as dQ, fsck as dR, grep as dS, groupUnmergedEntries as dT, init as dU, isBinary as dV, log as dW, mergeAbort as dX, mergeContinue as dY, mergeRun as dZ, mv as d_, bindRemoteNamespace as da, bindRevertNamespace as db, bindSparseCheckoutNamespace as dc, bindStashNamespace as dd, bindSubmoduleNamespace as de, bindTagNamespace as df, bindWorktreeNamespace as dg, blame as dh, branchCreate as di, branchDelete as dj, branchList as dk, branchRename as dl, buildGrepMatcher as dm, bundleCreate as dn, bundleListHeads as dp, bundleVerify as dq, catFile as dr, checkout as ds, cherryPickAbort as dt, cherryPickContinue as du, cherryPickRun as dv, cherryPickSkip as dw, classifyUnmerged as dx, clone as dy, commit as dz, notesAdd as e0, notesList as e1, notesRead as e2, notesRemove as e3, pull as e4, push as e5, rangeDiff as e6, readFileAt as e7, rebaseAbort as e8, rebaseContinue as e9, stashApply as eA, stashDrop as eB, stashList as eC, stashPop as eD, stashPush as eE, status as eF, submoduleAdd as eG, submoduleDeinit as eH, submoduleInit as eI, submoduleList as eJ, submoduleSync as eK, submoduleUpdate as eL, tagCreate as eM, tagDelete as eN, tagList as eO, whatchanged as eP, worktreeAdd as eQ, worktreeList as eR, worktreeMove as eS, worktreeRemove as eT, rebaseRun as ea, rebaseSkip as eb, recordedPaths as ec, reflog as ed, remoteAdd as ee, remoteList as ef, remoteRemove as eg, remoteRename as eh, remoteSetUrl as ei, remoteShow as ej, reset as ek, revParse as el, revertAbort as em, revertContinue as en, revertRun as eo, revertSkip as ep, rm as eq, shortlog as er, show as es, sortedRecordedPaths as et, sparseCheckoutAdd as eu, sparseCheckoutDisable as ev, sparseCheckoutList as ew, sparseCheckoutReapply as ex, sparseCheckoutSet as ey, splitLines as ez };
+export type { ConfigGetInput as $, AddOptions as A, BundleRevArg as C, BundleVerifyInput as D, BundleVerifyResult as E, BundleVersion as F, CatFileInput as G, CatFileResult as H, ChangeKind as I, ChangedPath as J, CheckoutOptions as K, CheckoutResult as L, CherryPickAbortResult as M, CherryPickConflict as N, CherryPickContinueInput as O, CherryPickNamespace as P, CherryPickResult as Q, CherryPickRunInput as R, CherryPickedCommit as S, CloneOptions as T, CloneResult as U, CommitOptions as V, CommitResult as W, CommittedBlameLine as X, ConfigEntryView as Y, ConfigGetAllInput as Z, ConfigGetAllResult as _, AddResult as a, MvSkipped as a$, ConfigGetRegexpInput as a0, ConfigGetRegexpResult as a1, ConfigGetResult as a2, ConfigListInput as a3, ConfigListResult as a4, ConfigNamespace as a5, ConfigRemoveSectionInput as a6, ConfigRemoveSectionResult as a7, ConfigRenameSectionInput as a8, ConfigRenameSectionResult as a9, GrepResult as aA, GroupedIndex as aB, InitOptions as aC, InitResult as aD, LineDiff as aE, LineDiffOptions as aF, LineHunk as aG, LineVerdict as aH, LogEntry as aI, LogOptions as aJ, LogOrder as aK, MatchSpan as aQ, MergeAbortResult as aR, MergeContinueInput as aS, MergeContinueResult as aT, MergeNamespace as aU, MergeResult as aV, MergeRunInput as aW, MvMove as aX, MvOptions as aY, MvResult as aZ, MvSkipReason as a_, ConfigSetInput as aa, ConfigSetResult as ab, ConfigUnsetAllInput as ac, ConfigUnsetAllResult as ad, ConfigUnsetInput as ae, ConfigUnsetResult as af, ConflictKind as ag, DescribeOptions as ah, DescribeResult as ai, DiffOptions as aj, FetchMissingOptions as ak, FetchMissingResult as al, FetchOptions as am, FetchResult as an, FsckFinding as ao, FsckObjectType as ap, FsckOptions as aq, FsckResult as ar, FsckSeverity as as, GrepFixedPattern as at, GrepLineHit as au, GrepMatcher as av, GrepMatcherOptions as aw, GrepOptions as ax, GrepPathResult as ay, GrepPattern as az, ArchiveEntry as b, ShowCommitResult as b$, NameRevOptions as b0, NameRevResult as b1, NameRevStep as b2, NotesAddInput as b3, NotesAddResult as b4, NotesListInput as b5, NotesListResult as b6, NotesNamespace as b7, NotesReadInput as b8, NotesReadResult as b9, RemoteListResult as bA, RemoteNamespace as bB, RemoteRemoveInput as bC, RemoteRemoveResult as bD, RemoteRenameInput as bE, RemoteRenameResult as bF, RemoteSetUrlInput as bG, RemoteSetUrlResult as bH, RemoteShow as bI, RemoteShowInput as bJ, RemoteShowResult as bK, ResetMode as bL, ResetOptions as bM, ResetResult as bN, RevertAbortResult as bO, RevertConflict as bP, RevertNamespace as bQ, RevertResult as bR, RevertRunInput as bS, RevertedCommit as bT, RmOptions as bU, RmResult as bV, ShortlogBy as bW, ShortlogCommit as bX, ShortlogGroup as bY, ShortlogOptions as bZ, ShowBlobResult as b_, NotesRemoveInput as ba, NotesRemoveResult as bb, PullOptions as bc, PullResult as bd, PushOptions as be, PushResult as bf, RangeDiffCommit as bg, RangeDiffEntry as bh, RangeDiffOptions as bi, RangeDiffRange as bj, RangeDiffStatus as bk, ReadFileAtResult as bl, RebaseAbortResult as bm, RebaseConflict as bn, RebaseInstruction as bo, RebaseInteractiveAction as bp, RebaseNamespace as bq, RebaseResult as br, RebaseRunInput as bs, RebasedCommit as bt, ReflogAction as bu, ReflogResult as bv, ReflogShowEntry as bw, RemoteAddInput as bx, RemoteAddResult as by, RemoteInfo as bz, ArchiveOptions as c, WorktreeRemoveResult as c$, ShowInput as c0, ShowOptions as c1, ShowResult as c2, ShowTagResult as c3, ShowTreeEntry as c4, ShowTreeResult as c5, SparseCheckoutAddInput as c6, SparseCheckoutAppliedResult as c7, SparseCheckoutDisableInput as c8, SparseCheckoutListResult as c9, SubmoduleNamespace as cA, SubmoduleSyncEntry as cB, SubmoduleSyncOptions as cC, SubmoduleSyncResult as cD, SubmoduleUpdateEntry as cE, SubmoduleUpdateOptions as cF, SubmoduleUpdateResult as cG, TagCreateInput as cH, TagCreateResult as cI, TagDeleteInput as cJ, TagDeleteResult as cK, TagInfo as cL, TagListResult as cM, TagNamespace as cN, UncommittedBlameLine as cO, UnmergedEntry as cP, UnmergedEntryGroup as cQ, WhatchangedEntry as cR, WhatchangedOptions as cS, WorktreeAddOptions as cT, WorktreeAddResult as cU, WorktreeEntry as cV, WorktreeListResult as cW, WorktreeMoveOptions as cX, WorktreeMoveResult as cY, WorktreeNamespace as cZ, WorktreeRemoveOptions as c_, SparseCheckoutNamespace as ca, SparseCheckoutReapplyInput as cb, SparseCheckoutSetInput as cc, StashApplyInput as cd, StashApplyResult as ce, StashConflict as cf, StashDropInput as cg, StashDropResult as ch, StashListEntry as ci, StashListResult as cj, StashNamespace as ck, StashPopResult as cl, StashPushInput as cm, StashPushResult as cn, StatusResult as co, SubmoduleAddEntry as cp, SubmoduleAddOptions as cq, SubmoduleAddResult as cr, SubmoduleDeinitEntry as cs, SubmoduleDeinitOptions as ct, SubmoduleDeinitResult as cu, SubmoduleInitEntry as cv, SubmoduleInitOptions as cw, SubmoduleInitResult as cx, SubmoduleListOptions as cy, SubmoduleListResult as cz, ArchiveResult as d, WorktreeSide as d0, BlameLine as e, BlameLineBase as f, BlameOptions as g, BlameResult as h, BlobSide as i, BranchCreateInput as j, BranchCreateResult as k, BranchDeleteInput as l, BranchDeleteResult as m, BranchInfo as n, BranchListResult as o, BranchNamespace as p, BranchRenameInput as q, BranchRenameResult as r, BundleCreateOptions as s, BundleCreateResult as t, BundleHashAlgorithm as u, BundleListHeadsInput as v, BundleListHeadsResult as w, BundleNamespace as x, BundlePrerequisite as y, BundleRef as z };