@scolladon/tsgit 1.3.0 → 2.0.1

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

@@ -1,6 +1,26 @@
-import { d as FilePath, b as Context, R as RefName, O as ObjectId, m as PromisorRemote } from '../chunks/context-BORy7yXb.js';
-import { C as CatFileBatchEntry, A as AuthorIdentity, s as TreeDiff, q as ReflogEntry, S as SubmoduleEntry } from '../chunks/reflog-entry-C2Hsdobk.js';
-import '../chunks/http-transport-DirKfK2S.js';
+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;
@@ -27,47 +47,51 @@ interface AddResult {
  */
 declare const add: (ctx: Context, paths: ReadonlyArray<string>, opts?: AddOptions) => Promise<AddResult>;
 
-type BranchAction = {
-    readonly kind: 'list';
-} | {
-    readonly kind: 'create';
-    readonly name: string;
-    readonly startPoint?: string;
-    readonly force?: boolean;
-} | {
-    readonly kind: 'delete';
-    readonly name: string;
-    readonly force?: boolean;
-} | {
-    readonly kind: 'rename';
-    readonly from: string;
-    readonly to: string;
-    readonly force?: boolean;
-};
 interface BranchInfo {
     readonly name: RefName;
     readonly id: ObjectId;
     readonly current: boolean;
 }
-type BranchResult = {
-    readonly kind: 'list';
+interface BranchListResult {
     readonly branches: ReadonlyArray<BranchInfo>;
-} | {
-    readonly kind: 'create';
+}
+interface BranchCreateInput {
+    readonly name: string;
+    readonly startPoint?: string;
+    readonly force?: boolean;
+}
+interface BranchCreateResult {
     readonly name: RefName;
     readonly id: ObjectId;
-} | {
-    readonly kind: 'delete';
+}
+interface BranchDeleteInput {
+    readonly name: string;
+    readonly force?: boolean;
+}
+interface BranchDeleteResult {
     readonly name: RefName;
-} | {
-    readonly kind: 'rename';
+}
+interface BranchRenameInput {
+    readonly from: string;
+    readonly to: string;
+    readonly force?: boolean;
+}
+interface BranchRenameResult {
     readonly from: RefName;
     readonly to: RefName;
-};
-declare const branch: (ctx: Context, action: BranchAction) => Promise<BranchResult>;
+}
+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`,
@@ -108,6 +132,69 @@ interface CheckoutResult {
 }
 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>>;
 
@@ -167,18 +254,174 @@ interface CommitResult {
  */
 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 and return the resulting `TreeDiff`. When `from`
- * is omitted, defaults to HEAD's tree; when `to` is omitted, defaults to
- * `undefined` (interpreted by `diffTrees` as the empty tree).
+ * 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 const diff: (ctx: Context, opts?: DiffOptions) => Promise<TreeDiff>;
+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;
@@ -249,6 +492,485 @@ interface InitResult {
  */
 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;
@@ -277,6 +999,12 @@ interface MergeOptions {
     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;
@@ -315,6 +1043,66 @@ type MergeResult = {
  */
 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>;
@@ -410,6 +1198,8 @@ 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 {
@@ -421,37 +1211,6 @@ interface RmResult {
  */
 declare const rm: (ctx: Context, paths: ReadonlyArray<string>, opts?: RmOptions) => Promise<RmResult>;
 
-type SparseCheckoutAction = {
-    readonly action: 'list';
-} | {
-    readonly action: 'set';
-    readonly patterns: ReadonlyArray<string>;
-    readonly cone?: boolean;
-    readonly force?: boolean;
-} | {
-    readonly action: 'add';
-    readonly patterns: ReadonlyArray<string>;
-    readonly force?: boolean;
-} | {
-    readonly action: 'reapply';
-    readonly force?: boolean;
-} | {
-    readonly action: 'disable';
-    readonly force?: boolean;
-};
-type SparseCheckoutResult = {
-    readonly kind: 'list';
-    readonly cone: boolean;
-    readonly patterns: ReadonlyArray<string>;
-} | {
-    readonly kind: 'applied';
-    readonly cone: boolean;
-    readonly materialized: number;
-    readonly removed: number;
-    readonly retained: ReadonlyArray<FilePath>;
-};
-declare const sparseCheckout: (ctx: Context, opts: SparseCheckoutAction) => Promise<SparseCheckoutResult>;
-
 type ChangeKind = 'modified' | 'added' | 'deleted' | 'untracked';
 interface ChangeEntry {
     readonly kind: ChangeKind;
@@ -496,33 +1255,5 @@ type SubmodulesResult = {
 };
 declare const submodules: (ctx: Context, opts?: SubmodulesAction) => Promise<SubmodulesResult>;
 
-type TagAction = {
-    readonly kind: 'list';
-} | {
-    readonly kind: 'create';
-    readonly name: string;
-    readonly target?: string;
-    readonly force?: boolean;
-} | {
-    readonly kind: 'delete';
-    readonly name: string;
-};
-interface TagInfo {
-    readonly name: RefName;
-    readonly id: ObjectId;
-}
-type TagResult = {
-    readonly kind: 'list';
-    readonly tags: ReadonlyArray<TagInfo>;
-} | {
-    readonly kind: 'create';
-    readonly name: RefName;
-    readonly id: ObjectId;
-} | {
-    readonly kind: 'delete';
-    readonly name: RefName;
-};
-declare const tag: (ctx: Context, action: TagAction) => Promise<TagResult>;
-
-export { CatFileBatchEntry, SubmoduleEntry, add, branch, catFile, checkout, clone, commit, createPromisorRemote, diff, fetch, fetchMissing, init, log, merge, push, reflog, reset, revParse, rm, sparseCheckout, status, submodules, tag };
-export type { AddOptions, AddResult, BranchAction, BranchInfo, BranchResult, CatFileInput, CatFileResult, ChangeEntry, ChangeKind, CheckoutOptions, CheckoutResult, CloneOptions, CloneResult, CommitOptions, CommitResult, DiffOptions, FetchMissingOptions, FetchMissingResult, FetchOptions, FetchResult, InitOptions, InitResult, LogEntry, LogOptions, MergeOptions, MergeResult, PushOptions, PushResult, ReflogAction, ReflogResult, ReflogShowEntry, ResetMode, ResetOptions, ResetResult, RmOptions, RmResult, SparseCheckoutAction, SparseCheckoutResult, StatusResult, SubmodulesAction, SubmodulesResult, TagAction, TagInfo, TagResult };
+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 };