@scolladon/tsgit 2.0.1 → 3.1.0

package/dist/types/commands/index.d.ts

@@ -1,1259 +1,4 @@
-import { O as ObjectId, j as RefName, b as Context, c as FilePath, n as PromisorRemote } from '../chunks/context-CCL0_F8R.js';
-import { C as CatFileBatchEntry, A as AuthorIdentity, c as ConfigKey, b as ConfigScope, T as TreeDiff, R as ReflogEntry, S as SubmoduleEntry } from '../chunks/reflog-entry-CSzjnZd4.js';
-import '../chunks/http-transport--_NdQOiw.js';
-
-interface AbortMergeResult {
-    /** 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 abortMerge: (ctx: Context) => Promise<AbortMergeResult>;
-
-interface AddOptions {
-    readonly force?: boolean;
-    readonly all?: boolean;
-    readonly breakStaleLockMs?: number;
-}
-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>;
-
-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 ConflictType = 'content' | 'add-add' | 'modify-delete' | 'type-change' | 'rename-rename' | 'gitlink' | 'binary';
-
-interface PatchPathPrefix {
-    readonly old: string;
-    readonly new: string;
-}
-
-/**
- * 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 target: 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>;
-
-/** Pluggable DNS resolver. Returns the addresses for `host`, in order. */
-type DnsResolver = (host: string) => Promise<ReadonlyArray<string>>;
-
-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;
-    /** DNS resolver injected by the caller; required to enforce SSRF guards. */
-    readonly resolver?: DnsResolver;
-    readonly allowInsecure?: boolean;
-    readonly allowPrivateNetworks?: boolean;
-    /**
-     * 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;
-}
-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;
-    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;
-        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;
-    readonly value: string;
-    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;
-    readonly previousValue: string;
-} | {
-    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 ContinueMergeOptions {
-    /** 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 ContinueMergeResult = 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 continueMerge: (ctx: Context, opts?: ContinueMergeOptions) => Promise<ContinueMergeResult>;
-
-type DiffFormat = 'tree' | 'patch';
-interface DiffOptions {
-    /** Resolve to a tree. Accepts ref name, oid, or 'HEAD'. */
-    readonly from?: string;
-    readonly to?: string;
-    readonly detectRenames?: boolean;
-    /** Output format. Default `'tree'` for backward compatibility. */
-    readonly format?: DiffFormat;
-    /** Lines of equal context bracketing each hunk. Default `3`. Patch-only. */
-    readonly contextLines?: number;
-    /** Path prefixes on `diff --git`, `--- a/`, `+++ b/` lines. Default `{ old: 'a/', new: 'b/' }`. */
-    readonly pathPrefix?: PatchPathPrefix;
-}
-interface PatchResult {
-    readonly format: 'patch';
-    readonly text: string;
-    readonly diff: TreeDiff;
-}
-type DiffResult = TreeDiff | PatchResult;
-/**
- * Diff two tree-like targets. Returns a structured `TreeDiff` by default;
- * pass `format: 'patch'` for a canonical unified-diff text plus the
- * structured view bundled together.
- */
-declare function diff(ctx: Context, opts?: DiffOptions & {
-    format?: 'tree';
-}): Promise<TreeDiff>;
-declare function diff(ctx: Context, opts: DiffOptions & {
-    format: 'patch';
-}): Promise<PatchResult>;
-
-interface FetchOptions {
-    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;
-
-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;
-
-/**
- * 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;
-
-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;
-
-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;
-}
-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;
-
-interface LogOptions {
-    readonly from?: string;
-    readonly limit?: number;
-    readonly excluding?: ReadonlyArray<string>;
-    readonly before?: Date;
-}
-interface LogEntry {
-    readonly id: ObjectId;
-    readonly tree: ObjectId;
-    readonly parents: ReadonlyArray<ObjectId>;
-    readonly author: AuthorIdentity;
-    readonly committer: AuthorIdentity;
-    readonly message: string;
-}
-/**
- * Walk first-parent commits starting from `from` (default: HEAD), yielding
- * ordered `LogEntry` records. Honors `limit`, `excluding` (oid stops), and
- * `before` (only commits with `committer.timestamp < before`).
- */
-declare const log: (ctx: Context, opts?: LogOptions) => Promise<ReadonlyArray<LogEntry>>;
-
-interface MergeOptions {
-    readonly target: string;
-    readonly message?: string;
-    readonly fastForwardOnly?: boolean;
-    readonly noFastForward?: boolean;
-    readonly author?: AuthorIdentity;
-    readonly committer?: AuthorIdentity;
-    /**
-     * Reflog action prefix, mirroring git's GIT_REFLOG_ACTION. Replaces the
-     * default `merge <target>` prefix in the fast-forward and merge-commit reflog
-     * messages (e.g. `pull` → `pull: Fast-forward`). Defaults to `merge <target>`.
-     */
-    readonly reflogLabel?: 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;
-};
-/**
- * Merge `target` into the current HEAD branch.
- *
- * - Up-to-date: target is ancestor of HEAD → no-op.
- * - Fast-forward: HEAD is ancestor of target → branch advances.
- * - True merge for diverged histories:.4a wired the three-way
- *  tree merge (`mergeTrees` + `mergeContent`) so a CLEAN merge commits
- *  the merged tree directly.4b persists conflict state on
- *  disk (marker files, stage-1/2/3 index entries, MERGE_HEAD /
- *  MERGE_MSG / ORIG_HEAD) and returns `{ kind: 'conflict',... }`.
- *  Resolution path: edit the marker files, `repo.add(paths)`,
- *  `repo.commit({ message })` — the resulting commit has two parents.
- */
-declare const merge: (ctx: Context, opts: MergeOptions) => Promise<MergeResult>;
-
-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;
-    /** Break a stale `index.lock` older than N ms (same contract as rm/add). */
-    readonly breakStaleLockMs?: number;
-}
-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` ?? `'origin'`. */
-    readonly remote?: string;
-    /**
-     * Short branch name to merge. Default: short form of `branch.<current>.merge`.
-     * When neither is resolvable, pull throws `NO_UPSTREAM_CONFIGURED`.
-     */
-    readonly branch?: string;
-    /** Reject the pull when a true merge would be required. */
-    readonly fastForwardOnly?: boolean;
-    /** Always create a merge commit, even when a fast-forward is possible. */
-    readonly noFastForward?: boolean;
-    /** 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;
-}
-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>;
-
-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 target: string;
-}
-interface ResetResult {
-    readonly mode: ResetMode;
-    readonly id: ObjectId;
-    readonly branch: RefName | undefined;
-}
-/**
- * Reset HEAD (and optionally index/working tree) to `target`.
- *
- * - `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;
-    readonly breakStaleLockMs?: number;
-}
-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>;
-
-type ChangeKind = 'modified' | 'added' | 'deleted' | 'untracked';
-interface ChangeEntry {
-    readonly kind: ChangeKind;
-    readonly path: FilePath;
-}
-interface StatusResult {
-    readonly branch: RefName | undefined;
-    readonly detached: boolean;
-    readonly indexChanges: ReadonlyArray<ChangeEntry>;
-    readonly workingTreeChanges: ReadonlyArray<ChangeEntry>;
-    readonly clean: boolean;
-}
-/**
- * Summarize the state of the working tree relative to the index, and the
- * branch HEAD points at. Working-tree-vs-HEAD diff (Git's "staged" column)
- * is approximated via index-vs-working-tree comparisons until
- * adds the stat-cache fast path.
- *
- * Progress reporting: emits `status:scan` start before the
- * fan-out, updates at every 100 lstat completions, and end in a finally
- * block so the consumer always pairs start with end. `total` is undefined
- * — design choice that prevents revealing repository size to non-trusted
- * progress sinks.
- */
-declare const status: (ctx: Context) => Promise<StatusResult>;
-
-type SubmodulesAction = {
-    readonly action?: 'list';
-    /** 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;
-};
-type SubmodulesResult = {
-    readonly kind: 'list';
-    readonly entries: ReadonlyArray<SubmoduleEntry>;
-};
-declare const submodules: (ctx: Context, opts?: SubmodulesAction) => Promise<SubmodulesResult>;
-
-export { CatFileBatchEntry, SubmoduleEntry, abortMerge, add, bindBranchNamespace, bindCherryPickNamespace, bindConfigNamespace, bindRebaseNamespace, bindRemoteNamespace, bindRevertNamespace, bindSparseCheckoutNamespace, bindStashNamespace, bindTagNamespace, branchCreate, branchDelete, branchList, branchRename, catFile, checkout, cherryPickAbort, cherryPickContinue, cherryPickRun, cherryPickSkip, clone, commit, configGet, configGetAll, configGetRegexp, configList, configRemoveSection, configRenameSection, configSet, configUnset, configUnsetAll, continueMerge, createPromisorRemote, diff, fetch, fetchMissing, init, log, merge, mv, pull, push, rebaseAbort, rebaseContinue, rebaseRun, rebaseSkip, reflog, remoteAdd, remoteList, remoteRemove, remoteRename, remoteSetUrl, remoteShow, reset, revParse, revertAbort, revertContinue, revertRun, revertSkip, rm, sparseCheckoutAdd, sparseCheckoutDisable, sparseCheckoutList, sparseCheckoutReapply, sparseCheckoutSet, stashApply, stashDrop, stashList, stashPop, stashPush, status, submodules, tagCreate, tagDelete, tagList };
-export type { AbortMergeResult, AddOptions, AddResult, BranchCreateInput, BranchCreateResult, BranchDeleteInput, BranchDeleteResult, BranchInfo, BranchListResult, BranchNamespace, BranchRenameInput, BranchRenameResult, CatFileInput, CatFileResult, ChangeEntry, ChangeKind, CheckoutOptions, CheckoutResult, CherryPickAbortResult, CherryPickConflict, CherryPickContinueInput, CherryPickNamespace, CherryPickResult, CherryPickRunInput, CherryPickedCommit, CloneOptions, CloneResult, CommitOptions, CommitResult, ConfigEntryView, ConfigGetAllInput, ConfigGetAllResult, ConfigGetInput, ConfigGetRegexpInput, ConfigGetRegexpResult, ConfigGetResult, ConfigListInput, ConfigListResult, ConfigNamespace, ConfigRemoveSectionInput, ConfigRemoveSectionResult, ConfigRenameSectionInput, ConfigRenameSectionResult, ConfigSetInput, ConfigSetResult, ConfigUnsetAllInput, ConfigUnsetAllResult, ConfigUnsetInput, ConfigUnsetResult, ContinueMergeOptions, ContinueMergeResult, DiffFormat, DiffOptions, DiffResult, FetchMissingOptions, FetchMissingResult, FetchOptions, FetchResult, InitOptions, InitResult, LogEntry, LogOptions, MergeOptions, MergeResult, MvMove, MvOptions, MvResult, MvSkipReason, MvSkipped, PatchResult, PullOptions, PullResult, PushOptions, PushResult, RebaseAbortResult, RebaseConflict, RebaseInstruction, RebaseInteractiveAction, RebaseNamespace, RebaseResult, RebaseRunInput, RebasedCommit, ReflogAction, ReflogResult, ReflogShowEntry, RemoteAddInput, RemoteAddResult, RemoteInfo, RemoteListResult, RemoteNamespace, RemoteRemoveInput, RemoteRemoveResult, RemoteRenameInput, RemoteRenameResult, RemoteSetUrlInput, RemoteSetUrlResult, RemoteShow, RemoteShowInput, RemoteShowResult, ResetMode, ResetOptions, ResetResult, RevertAbortResult, RevertConflict, RevertNamespace, RevertResult, RevertRunInput, RevertedCommit, RmOptions, RmResult, SparseCheckoutAddInput, SparseCheckoutAppliedResult, SparseCheckoutDisableInput, SparseCheckoutListResult, SparseCheckoutNamespace, SparseCheckoutReapplyInput, SparseCheckoutSetInput, StashApplyInput, StashApplyResult, StashConflict, StashDropInput, StashDropResult, StashListEntry, StashListResult, StashNamespace, StashPopResult, StashPushInput, StashPushResult, StatusResult, SubmodulesAction, SubmodulesResult, TagCreateInput, TagCreateResult, TagDeleteInput, TagDeleteResult, TagInfo, TagListResult, TagNamespace };
+export { A as AddOptions, a as AddResult, b as ArchiveEntry, c as ArchiveOptions, d as ArchiveResult, e as BlameLine, f as BlameLineBase, g as BlameOptions, h as BlameResult, i as BlobSide, j as BranchCreateInput, k as BranchCreateResult, l as BranchDeleteInput, m as BranchDeleteResult, n as BranchInfo, o as BranchListResult, p as BranchNamespace, q as BranchRenameInput, r as BranchRenameResult, s as BundleCreateOptions, t as BundleCreateResult, u as BundleHashAlgorithm, v as BundleListHeadsInput, w as BundleListHeadsResult, x as BundleNamespace, y as BundlePrerequisite, z as BundleRef, C as BundleRevArg, D as BundleVerifyInput, E as BundleVerifyResult, F as BundleVersion, G as CatFileInput, H as CatFileResult, I as ChangeKind, J as ChangedPath, K as CheckoutOptions, L as CheckoutResult, M as CherryPickAbortResult, N as CherryPickConflict, O as CherryPickContinueInput, P as CherryPickNamespace, Q as CherryPickResult, R as CherryPickRunInput, S as CherryPickedCommit, T as CloneOptions, U as CloneResult, V as CommitOptions, W as CommitResult, X as CommittedBlameLine, Y as ConfigEntryView, Z as ConfigGetAllInput, _ as ConfigGetAllResult, $ as ConfigGetInput, a0 as ConfigGetRegexpInput, a1 as ConfigGetRegexpResult, a2 as ConfigGetResult, a3 as ConfigListInput, a4 as ConfigListResult, a5 as ConfigNamespace, a6 as ConfigRemoveSectionInput, a7 as ConfigRemoveSectionResult, a8 as ConfigRenameSectionInput, a9 as ConfigRenameSectionResult, aa as ConfigSetInput, ab as ConfigSetResult, ac as ConfigUnsetAllInput, ad as ConfigUnsetAllResult, ae as ConfigUnsetInput, af as ConfigUnsetResult, ag as ConflictKind, ah as DescribeOptions, ai as DescribeResult, aj as DiffOptions, ak as FetchMissingOptions, al as FetchMissingResult, am as FetchOptions, an as FetchResult, ao as FsckFinding, ap as FsckObjectType, aq as FsckOptions, ar as FsckResult, as as FsckSeverity, au as GrepLineHit, ax as GrepOptions, ay as GrepPathResult, aA as GrepResult, aC as InitOptions, aD as InitResult, aI as LogEntry, aJ as LogOptions, aK as LogOrder, aR as MergeAbortResult, aS as MergeContinueInput, aT as MergeContinueResult, aU as MergeNamespace, aV as MergeResult, aW as MergeRunInput, aX as MvMove, aY as MvOptions, aZ as MvResult, a_ as MvSkipReason, a$ as MvSkipped, b0 as NameRevOptions, b1 as NameRevResult, b2 as NameRevStep, b3 as NotesAddInput, b4 as NotesAddResult, b5 as NotesListInput, b6 as NotesListResult, b7 as NotesNamespace, b8 as NotesReadInput, b9 as NotesReadResult, ba as NotesRemoveInput, bb as NotesRemoveResult, bc as PullOptions, bd as PullResult, be as PushOptions, bf as PushResult, bg as RangeDiffCommit, bh as RangeDiffEntry, bi as RangeDiffOptions, bj as RangeDiffRange, bk as RangeDiffStatus, bl as ReadFileAtResult, bm as RebaseAbortResult, bn as RebaseConflict, bo as RebaseInstruction, bp as RebaseInteractiveAction, bq as RebaseNamespace, br as RebaseResult, bs as RebaseRunInput, bt as RebasedCommit, bu as ReflogAction, bv as ReflogResult, bw as ReflogShowEntry, bx as RemoteAddInput, by as RemoteAddResult, bz as RemoteInfo, bA as RemoteListResult, bB as RemoteNamespace, bC as RemoteRemoveInput, bD as RemoteRemoveResult, bE as RemoteRenameInput, bF as RemoteRenameResult, bG as RemoteSetUrlInput, bH as RemoteSetUrlResult, bI as RemoteShow, bJ as RemoteShowInput, bK as RemoteShowResult, bL as ResetMode, bM as ResetOptions, bN as ResetResult, bO as RevertAbortResult, bP as RevertConflict, bQ as RevertNamespace, bR as RevertResult, bS as RevertRunInput, bT as RevertedCommit, bU as RmOptions, bV as RmResult, bW as ShortlogBy, bX as ShortlogCommit, bY as ShortlogGroup, bZ as ShortlogOptions, b_ as ShowBlobResult, b$ as ShowCommitResult, c0 as ShowInput, c1 as ShowOptions, c2 as ShowResult, c3 as ShowTagResult, c4 as ShowTreeEntry, c5 as ShowTreeResult, c6 as SparseCheckoutAddInput, c7 as SparseCheckoutAppliedResult, c8 as SparseCheckoutDisableInput, c9 as SparseCheckoutListResult, ca as SparseCheckoutNamespace, cb as SparseCheckoutReapplyInput, cc as SparseCheckoutSetInput, cd as StashApplyInput, ce as StashApplyResult, cf as StashConflict, cg as StashDropInput, ch as StashDropResult, ci as StashListEntry, cj as StashListResult, ck as StashNamespace, cl as StashPopResult, cm as StashPushInput, cn as StashPushResult, co as StatusResult, cp as SubmoduleAddEntry, cq as SubmoduleAddOptions, cr as SubmoduleAddResult, cs as SubmoduleDeinitEntry, ct as SubmoduleDeinitOptions, cu as SubmoduleDeinitResult, cv as SubmoduleInitEntry, cw as SubmoduleInitOptions, cx as SubmoduleInitResult, cy as SubmoduleListOptions, cz as SubmoduleListResult, cA as SubmoduleNamespace, cB as SubmoduleSyncEntry, cC as SubmoduleSyncOptions, cD as SubmoduleSyncResult, cE as SubmoduleUpdateEntry, cF as SubmoduleUpdateOptions, cG as SubmoduleUpdateResult, cH as TagCreateInput, cI as TagCreateResult, cJ as TagDeleteInput, cK as TagDeleteResult, cL as TagInfo, cM as TagListResult, cN as TagNamespace, cO as UncommittedBlameLine, cP as UnmergedEntry, cR as WhatchangedEntry, cS as WhatchangedOptions, cT as WorktreeAddOptions, cU as WorktreeAddResult, cV as WorktreeEntry, cW as WorktreeListResult, cX as WorktreeMoveOptions, cY as WorktreeMoveResult, cZ as WorktreeNamespace, c_ as WorktreeRemoveOptions, c$ as WorktreeRemoveResult, d0 as WorktreeSide, d1 as add, d2 as archive, d3 as bindBranchNamespace, d4 as bindBundleNamespace, d5 as bindCherryPickNamespace, d6 as bindConfigNamespace, d7 as bindMergeNamespace, d8 as bindNotesNamespace, d9 as bindRebaseNamespace, da as bindRemoteNamespace, db as bindRevertNamespace, dc as bindSparseCheckoutNamespace, dd as bindStashNamespace, de as bindSubmoduleNamespace, df as bindTagNamespace, dg as bindWorktreeNamespace, dh as blame, di as branchCreate, dj as branchDelete, dk as branchList, dl as branchRename, dn as bundleCreate, dp as bundleListHeads, dq as bundleVerify, dr as catFile, ds as checkout, dt as cherryPickAbort, du as cherryPickContinue, dv as cherryPickRun, dw as cherryPickSkip, dy as clone, dz as commit, dA as configGet, dB as configGetAll, dC as configGetRegexp, dD as configList, dE as configRemoveSection, dF as configRenameSection, dG as configSet, dH as configUnset, dI as configUnsetAll, dK as createPromisorRemote, dL as describe, dM as diff, dP as fetch, dQ as fetchMissing, dR as fsck, dS as grep, dU as init, dW as log, dX as mergeAbort, dY as mergeContinue, dZ as mergeRun, d_ as mv, d$ as nameRev, e0 as notesAdd, e1 as notesList, e2 as notesRead, e3 as notesRemove, e4 as pull, e5 as push, e6 as rangeDiff, e7 as readFileAt, e8 as rebaseAbort, e9 as rebaseContinue, ea as rebaseRun, eb as rebaseSkip, ed as reflog, ee as remoteAdd, ef as remoteList, eg as remoteRemove, eh as remoteRename, ei as remoteSetUrl, ej as remoteShow, ek as reset, el as revParse, em as revertAbort, en as revertContinue, eo as revertRun, ep as revertSkip, eq as rm, er as shortlog, es as show, eu as sparseCheckoutAdd, ev as sparseCheckoutDisable, ew as sparseCheckoutList, ex as sparseCheckoutReapply, ey as sparseCheckoutSet, eA as stashApply, eB as stashDrop, eC as stashList, eD as stashPop, eE as stashPush, eF as status, eG as submoduleAdd, eH as submoduleDeinit, eI as submoduleInit, eJ as submoduleList, eK as submoduleSync, eL as submoduleUpdate, eM as tagCreate, eN as tagDelete, eO as tagList, eP as whatchanged, eQ as worktreeAdd, eR as worktreeList, eS as worktreeMove, eT as worktreeRemove } from '../chunks/index-B5Dps3fg.js';
+export { A as AddChange, C as CatFileBatchEntry, f as CopyChange, k as DeleteChange, l as DiffChange, m as DiffChangeType, T as ModifyChange, W as RenameChange, a0 as StatDiffChange, a1 as StatFields, a3 as StatTreeDiff, a4 as SubmoduleEntry, a8 as TreeDiff, a9 as TypeChangeChange } from '../chunks/reflog-entry-Cqh3QrPH.js';
+import '../chunks/context-sIhhtk2u.js';
+import '../chunks/http-transport-DirKfK2S.js';