just-git 1.2.0 → 1.2.4

package/dist/{hooks-Boa35Qx_.d.ts → hooks-4DvkF2xT.d.ts}

@@ -1,30 +1,91 @@
+/** File/directory metadata returned by {@link FileSystem.stat} and {@link FileSystem.lstat}. */
 interface FileStat {
+    /** True if the path points to a regular file. */
     isFile: boolean;
+    /** True if the path points to a directory. */
     isDirectory: boolean;
+    /** True if the path is a symbolic link (only meaningful from {@link FileSystem.lstat}). */
     isSymbolicLink: boolean;
+    /** Unix file mode (e.g. `0o100644` for a regular file, `0o040755` for a directory). */
     mode: number;
+    /** File size in bytes (0 for directories). */
     size: number;
+    /** Last modification time. */
     mtime: Date;
 }
+/**
+ * Filesystem interface required by just-git.
+ *
+ * Implement this to run git operations against any storage backend —
+ * in-memory, real disk, IndexedDB, remote, etc. All paths are absolute
+ * POSIX-style strings (e.g. `"/repo/src/index.ts"`).
+ *
+ * The three optional symlink methods (`lstat`, `readlink`, `symlink`) enable
+ * symlink support. When omitted, symlinks degrade to plain files containing
+ * the target path as content (`core.symlinks=false` behavior).
+ *
+ * See {@link MemoryFileSystem} for a ready-made in-memory implementation.
+ */
 interface FileSystem {
+    /**
+     * Read a file's contents as a UTF-8 string.
+     * @throws Error if the path doesn't exist or is a directory.
+     */
     readFile(path: string): Promise<string>;
+    /**
+     * Read a file's contents as raw bytes.
+     * @throws Error if the path doesn't exist or is a directory.
+     */
     readFileBuffer(path: string): Promise<Uint8Array>;
+    /**
+     * Write content to a file, creating it if it doesn't exist and
+     * overwriting if it does. Parent directories must already exist.
+     */
     writeFile(path: string, content: string | Uint8Array): Promise<void>;
+    /** Check whether a path exists (file, directory, or symlink). */
     exists(path: string): Promise<boolean>;
+    /**
+     * Get file/directory metadata, following symlinks.
+     * @throws Error if the path doesn't exist.
+     */
     stat(path: string): Promise<FileStat>;
+    /**
+     * Create a directory.
+     * @throws Error if the parent doesn't exist (unless `recursive: true`) or the path already exists as a file.
+     */
     mkdir(path: string, options?: {
         recursive?: boolean;
     }): Promise<void>;
+    /**
+     * List the names of entries in a directory (not full paths).
+     * @throws Error if the path doesn't exist or is not a directory.
+     */
     readdir(path: string): Promise<string[]>;
+    /**
+     * Remove a file or directory.
+     * @throws Error if the path doesn't exist (unless `force: true`) or is a non-empty directory (unless `recursive: true`).
+     */
     rm(path: string, options?: {
         recursive?: boolean;
         force?: boolean;
     }): Promise<void>;
-    /** Stat without following symlinks. Falls back to stat() semantics when not implemented. */
+    /**
+     * Get file/directory metadata without following symlinks.
+     * Falls back to {@link stat} semantics when not implemented.
+     * @throws Error if the path doesn't exist.
+     */
     lstat?(path: string): Promise<FileStat>;
-    /** Read the target of a symbolic link. */
+    /**
+     * Read the target path of a symbolic link.
+     * @throws Error if the path doesn't exist or is not a symlink.
+     */
     readlink?(path: string): Promise<string>;
-    /** Create a symbolic link pointing to target at the given path. */
+    /**
+     * Create a symbolic link at `path` pointing to `target`.
+     * @param target - The path the symlink should point to.
+     * @param path - Where to create the symlink.
+     * @throws Error if `path` already exists.
+     */
     symlink?(target: string, path: string): Promise<void>;
 }
 
@@ -91,6 +152,7 @@ interface Index {
     version: number;
     entries: IndexEntry[];
 }
+/** A resolved ref name and its target commit hash. */
 interface RefEntry {
     name: string;
     hash: ObjectId;
@@ -201,6 +263,7 @@ interface TreeDiffEntry {
     newMode?: string;
 }
 
+/** HTTP authentication credentials for Smart HTTP transport. */
 type HttpAuth = {
     type: "basic";
     username: string;
@@ -210,16 +273,29 @@ type HttpAuth = {
     token: string;
 };
 
+/** Result of executing a git command. */
 interface ExecResult {
     stdout: string;
     stderr: string;
     exitCode: number;
 }
 
+/**
+ * Callback that provides HTTP authentication for remote operations.
+ * Called with the remote URL; return credentials or null for anonymous access.
+ */
 type CredentialProvider = (url: string) => HttpAuth | null | Promise<HttpAuth | null>;
+/**
+ * Override the author/committer identity for commits.
+ *
+ * When `locked` is true, this identity always wins — even if the agent
+ * sets `GIT_AUTHOR_NAME` or runs `git config user.name`. When unlocked
+ * (default), acts as a fallback when env vars and git config are absent.
+ */
 interface IdentityOverride {
     name: string;
     email: string;
+    /** When true, this identity cannot be overridden by env vars or git config. */
     locked?: boolean;
 }
 /**
@@ -237,7 +313,12 @@ interface ConfigOverrides {
     locked?: Record<string, string>;
     defaults?: Record<string, string>;
 }
+/** Custom fetch function signature for HTTP transport. */
 type FetchFunction = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+/**
+ * Controls which remote URLs the git instance may access over HTTP.
+ * Set to `false` on {@link GitOptions.network} to block all HTTP access.
+ */
 interface NetworkPolicy {
     /**
      * Allowed URL patterns. Can be:
@@ -248,20 +329,28 @@ interface NetworkPolicy {
     /** Custom fetch function for HTTP transport. Falls back to globalThis.fetch. */
     fetch?: FetchFunction;
 }
+/**
+ * Returned from pre-hooks to block an operation.
+ * The optional `message` is surfaced as stderr.
+ */
 interface Rejection {
     reject: true;
     message?: string;
 }
+/** Type guard for {@link Rejection}. */
 declare function isRejection(value: unknown): value is Rejection;
+/** Fired before a commit is created. Return a {@link Rejection} to block. */
 interface PreCommitEvent {
     readonly repo: GitRepo;
     readonly index: Index;
     readonly treeHash: ObjectId;
 }
+/** Fired after `preCommit` passes. Mutate `message` to rewrite the commit message. */
 interface CommitMsgEvent {
     readonly repo: GitRepo;
     message: string;
 }
+/** Fired before a merge commit. Mutate `message` to rewrite the merge message. */
 interface MergeMsgEvent {
     readonly repo: GitRepo;
     message: string;
@@ -269,6 +358,7 @@ interface MergeMsgEvent {
     readonly headHash: ObjectId;
     readonly theirsHash: ObjectId;
 }
+/** Fired after a commit is successfully created. */
 interface PostCommitEvent {
     readonly repo: GitRepo;
     readonly hash: ObjectId;
@@ -277,6 +367,7 @@ interface PostCommitEvent {
     readonly parents: readonly ObjectId[];
     readonly author: Identity;
 }
+/** Fired before a three-way merge commit is written. Return a {@link Rejection} to block. */
 interface PreMergeCommitEvent {
     readonly repo: GitRepo;
     readonly mergeMessage: string;
@@ -284,6 +375,7 @@ interface PreMergeCommitEvent {
     readonly headHash: ObjectId;
     readonly theirsHash: ObjectId;
 }
+/** Fired after a merge completes (fast-forward or three-way). */
 interface PostMergeEvent {
     readonly repo: GitRepo;
     readonly headHash: ObjectId;
@@ -291,12 +383,14 @@ interface PostMergeEvent {
     readonly strategy: "fast-forward" | "three-way";
     readonly commitHash: ObjectId | null;
 }
+/** Fired after a branch checkout or detached HEAD checkout completes. */
 interface PostCheckoutEvent {
     readonly repo: GitRepo;
     readonly prevHead: ObjectId | null;
     readonly newHead: ObjectId;
     readonly isBranchCheckout: boolean;
 }
+/** Fired before objects are transferred during `git push`. Return a {@link Rejection} to block. */
 interface PrePushEvent {
     readonly repo: GitRepo;
     readonly remote: string;
@@ -310,17 +404,21 @@ interface PrePushEvent {
         delete: boolean;
     }>;
 }
+/** Fired after a push completes. Same payload as {@link PrePushEvent}. */
 type PostPushEvent = PrePushEvent;
+/** Fired before a rebase begins. Return a {@link Rejection} to block. */
 interface PreRebaseEvent {
     readonly repo: GitRepo;
     readonly upstream: string;
     readonly branch: string | null;
 }
+/** Fired before a checkout or switch. Return a {@link Rejection} to block. */
 interface PreCheckoutEvent {
     readonly repo: GitRepo;
     readonly target: string;
     readonly mode: "switch" | "detach" | "create-branch" | "paths";
 }
+/** Fired before a fetch begins. Return a {@link Rejection} to block. */
 interface PreFetchEvent {
     readonly repo: GitRepo;
     readonly remote: string;
@@ -329,12 +427,14 @@ interface PreFetchEvent {
     readonly prune: boolean;
     readonly tags: boolean;
 }
+/** Fired after a fetch completes. */
 interface PostFetchEvent {
     readonly repo: GitRepo;
     readonly remote: string;
     readonly url: string;
     readonly refsUpdated: number;
 }
+/** Fired before a clone begins. Return a {@link Rejection} to block. */
 interface PreCloneEvent {
     readonly repo?: GitRepo;
     readonly repository: string;
@@ -342,6 +442,7 @@ interface PreCloneEvent {
     readonly bare: boolean;
     readonly branch: string | null;
 }
+/** Fired after a clone completes. */
 interface PostCloneEvent {
     readonly repo: GitRepo;
     readonly repository: string;
@@ -349,11 +450,13 @@ interface PostCloneEvent {
     readonly bare: boolean;
     readonly branch: string | null;
 }
+/** Fired before a pull begins. Return a {@link Rejection} to block. */
 interface PrePullEvent {
     readonly repo: GitRepo;
     readonly remote: string;
     readonly branch: string | null;
 }
+/** Fired after a pull completes. */
 interface PostPullEvent {
     readonly repo: GitRepo;
     readonly remote: string;
@@ -361,16 +464,19 @@ interface PostPullEvent {
     readonly strategy: "up-to-date" | "fast-forward" | "three-way" | "rebase";
     readonly commitHash: ObjectId | null;
 }
+/** Fired before a reset. Return a {@link Rejection} to block. */
 interface PreResetEvent {
     readonly repo: GitRepo;
     readonly mode: "soft" | "mixed" | "hard" | "paths";
     readonly target: string | null;
 }
+/** Fired after a reset completes. */
 interface PostResetEvent {
     readonly repo: GitRepo;
     readonly mode: "soft" | "mixed" | "hard" | "paths";
     readonly targetHash: ObjectId | null;
 }
+/** Fired before `git clean`. Return a {@link Rejection} to block. */
 interface PreCleanEvent {
     readonly repo: GitRepo;
     readonly dryRun: boolean;
@@ -379,11 +485,13 @@ interface PreCleanEvent {
     readonly removeIgnored: boolean;
     readonly onlyIgnored: boolean;
 }
+/** Fired after `git clean` completes. */
 interface PostCleanEvent {
     readonly repo: GitRepo;
     readonly removed: readonly string[];
     readonly dryRun: boolean;
 }
+/** Fired before `git rm`. Return a {@link Rejection} to block. */
 interface PreRmEvent {
     readonly repo: GitRepo;
     readonly paths: readonly string[];
@@ -391,60 +499,71 @@ interface PreRmEvent {
     readonly recursive: boolean;
     readonly force: boolean;
 }
+/** Fired after `git rm` completes. */
 interface PostRmEvent {
     readonly repo: GitRepo;
     readonly removedPaths: readonly string[];
     readonly cached: boolean;
 }
+/** Fired before a cherry-pick. Return a {@link Rejection} to block. */
 interface PreCherryPickEvent {
     readonly repo: GitRepo;
     readonly mode: "pick" | "continue" | "abort";
     readonly commit: string | null;
 }
+/** Fired after a cherry-pick completes. */
 interface PostCherryPickEvent {
     readonly repo: GitRepo;
     readonly mode: "pick" | "continue" | "abort";
     readonly commitHash: ObjectId | null;
     readonly hadConflicts: boolean;
 }
+/** Fired before a revert. Return a {@link Rejection} to block. */
 interface PreRevertEvent {
     readonly repo: GitRepo;
     readonly mode: "revert" | "continue" | "abort";
     readonly commit: string | null;
 }
+/** Fired after a revert completes. */
 interface PostRevertEvent {
     readonly repo: GitRepo;
     readonly mode: "revert" | "continue" | "abort";
     readonly commitHash: ObjectId | null;
     readonly hadConflicts: boolean;
 }
+/** Fired before a stash operation. Return a {@link Rejection} to block. */
 interface PreStashEvent {
     readonly repo: GitRepo;
     readonly action: "push" | "pop" | "apply" | "list" | "drop" | "show" | "clear";
     readonly ref: string | null;
 }
+/** Fired after a stash operation completes. */
 interface PostStashEvent {
     readonly repo: GitRepo;
     readonly action: "push" | "pop" | "apply" | "list" | "drop" | "show" | "clear";
     readonly ok: boolean;
 }
+/** Fired whenever a ref is created or updated. */
 interface RefUpdateEvent {
     readonly repo: GitRepo;
     readonly ref: string;
     readonly oldHash: ObjectId | null;
     readonly newHash: ObjectId;
 }
+/** Fired whenever a ref is deleted. */
 interface RefDeleteEvent {
     readonly repo: GitRepo;
     readonly ref: string;
     readonly oldHash: ObjectId | null;
 }
+/** Fired whenever a git object (blob, tree, commit, tag) is written to the store. */
 interface ObjectWriteEvent {
     readonly repo: GitRepo;
     readonly type: ObjectType;
     readonly hash: ObjectId;
 }
 
+/** Fired before any git subcommand executes. Return a {@link Rejection} to block. */
 interface BeforeCommandEvent {
     readonly command: string;
     readonly args: string[];
@@ -452,6 +571,7 @@ interface BeforeCommandEvent {
     readonly cwd: string;
     readonly env: Map<string, string>;
 }
+/** Fired after any git subcommand completes. */
 interface AfterCommandEvent {
     readonly command: string;
     readonly args: string[];
@@ -459,6 +579,16 @@ interface AfterCommandEvent {
 }
 type PreHookReturn = void | Rejection | Promise<void | Rejection>;
 type PostHookReturn = void | Promise<void>;
+/**
+ * Hook callbacks for intercepting git operations.
+ *
+ * Pre-hooks can return a {@link Rejection} to block the operation.
+ * Post-hooks are fire-and-forget. Low-level events (`onRefUpdate`,
+ * `onRefDelete`, `onObjectWrite`) fire synchronously on every
+ * ref/object write.
+ *
+ * Use {@link composeGitHooks} to combine multiple hook sets.
+ */
 interface GitHooks {
     preCommit?: (event: PreCommitEvent) => PreHookReturn;
     commitMsg?: (event: CommitMsgEvent) => PreHookReturn;
@@ -495,6 +625,13 @@ interface GitHooks {
     beforeCommand?: (event: BeforeCommandEvent) => PreHookReturn;
     afterCommand?: (event: AfterCommandEvent) => PostHookReturn;
 }
+/**
+ * Combine multiple {@link GitHooks} objects into one.
+ *
+ * Pre-hooks chain in order, short-circuiting on the first {@link Rejection}.
+ * Post-hooks and low-level events chain in order, individually try/caught.
+ * Mutable-message hooks (`commitMsg`, `mergeMsg`) pass the mutated message through.
+ */
 declare function composeGitHooks(...hookSets: (GitHooks | undefined)[]): GitHooks;
 
-export { isRejection as $, type AfterCommandEvent as A, type BeforeCommandEvent as B, type CredentialProvider as C, type PreFetchEvent as D, type ExecResult as E, type FileSystem as F, type GitContext as G, type HttpAuth as H, type IdentityOverride as I, type PreMergeCommitEvent as J, type PrePullEvent as K, type PrePushEvent as L, type MergeMsgEvent as M, type NetworkPolicy as N, type ObjectId as O, type PostCheckoutEvent as P, type PreRebaseEvent as Q, type RemoteResolver as R, type PreResetEvent as S, type PreRevertEvent as T, type PreRmEvent as U, type PreStashEvent as V, type RefDeleteEvent as W, type RefEntry as X, type RefUpdateEvent as Y, type Rejection as Z, composeGitHooks as _, type GitRepo as a, type Identity as a0, type TreeDiffEntry as a1, type Commit as a2, type ObjectType as a3, type RawObject as a4, type Ref as a5, type GitHooks as b, type ObjectStore as c, type RefStore as d, type ConfigOverrides as e, type FetchFunction as f, type FileStat as g, type CommitMsgEvent as h, type ObjectWriteEvent as i, type PostCherryPickEvent as j, type PostCleanEvent as k, type PostCloneEvent as l, type PostCommitEvent as m, type PostFetchEvent as n, type PostMergeEvent as o, type PostPullEvent as p, type PostPushEvent as q, type PostResetEvent as r, type PostRevertEvent as s, type PostRmEvent as t, type PostStashEvent as u, type PreCheckoutEvent as v, type PreCherryPickEvent as w, type PreCleanEvent as x, type PreCloneEvent as y, type PreCommitEvent as z };
+export { type Identity as $, type AfterCommandEvent as A, type BeforeCommandEvent as B, type CredentialProvider as C, type PrePullEvent as D, type ExecResult as E, type FileSystem as F, type GitHooks as G, type HttpAuth as H, type IdentityOverride as I, type PrePushEvent as J, type PreRebaseEvent as K, type PreResetEvent as L, type MergeMsgEvent as M, type NetworkPolicy as N, type ObjectStore as O, type PostCheckoutEvent as P, type PreRevertEvent as Q, type RemoteResolver as R, type PreRmEvent as S, type PreStashEvent as T, type RefDeleteEvent as U, type RefEntry as V, type RefUpdateEvent as W, type Rejection as X, composeGitHooks as Y, isRejection as Z, type ObjectId as _, type RefStore as a, type TreeDiffEntry as a0, type Commit as a1, type ObjectType as a2, type RawObject as a3, type Ref as a4, type ConfigOverrides as b, type FileStat as c, type GitContext as d, type CommitMsgEvent as e, type GitRepo as f, type ObjectWriteEvent as g, type PostCherryPickEvent as h, type PostCleanEvent as i, type PostCloneEvent as j, type PostCommitEvent as k, type PostFetchEvent as l, type PostMergeEvent as m, type PostPullEvent as n, type PostPushEvent as o, type PostResetEvent as p, type PostRevertEvent as q, type PostRmEvent as r, type PostStashEvent as s, type PreCheckoutEvent as t, type PreCherryPickEvent as u, type PreCleanEvent as v, type PreCloneEvent as w, type PreCommitEvent as x, type PreFetchEvent as y, type PreMergeCommitEvent as z };

package/dist/index.d.ts

@@ -1,53 +1,5 @@
-import { O as ObjectId, G as GitContext, a as GitRepo, F as FileSystem, E as ExecResult, b as GitHooks, C as CredentialProvider, I as IdentityOverride, N as NetworkPolicy, R as RemoteResolver, c as ObjectStore, d as RefStore, e as ConfigOverrides, f as FetchFunction, g as FileStat } from './hooks-Boa35Qx_.js';
-export { A as AfterCommandEvent, B as BeforeCommandEvent, h as CommitMsgEvent, H as HttpAuth, M as MergeMsgEvent, i as ObjectWriteEvent, P as PostCheckoutEvent, j as PostCherryPickEvent, k as PostCleanEvent, l as PostCloneEvent, m as PostCommitEvent, n as PostFetchEvent, o as PostMergeEvent, p as PostPullEvent, q as PostPushEvent, r as PostResetEvent, s as PostRevertEvent, t as PostRmEvent, u as PostStashEvent, v as PreCheckoutEvent, w as PreCherryPickEvent, x as PreCleanEvent, y as PreCloneEvent, z as PreCommitEvent, D as PreFetchEvent, J as PreMergeCommitEvent, K as PrePullEvent, L as PrePushEvent, Q as PreRebaseEvent, S as PreResetEvent, T as PreRevertEvent, U as PreRmEvent, V as PreStashEvent, W as RefDeleteEvent, X as RefEntry, Y as RefUpdateEvent, Z as Rejection, _ as composeGitHooks, $ as isRejection } from './hooks-Boa35Qx_.js';
-
-/** Depth value that represents "full history" (used by --unshallow). */
-declare const INFINITE_DEPTH = 2147483647;
-/** Shallow boundary delta: what to add/remove from `.git/shallow`. */
-interface ShallowUpdate {
-    /** Commits to add to the shallow boundary. */
-    shallow: ObjectId[];
-    /** Commits to remove from the shallow boundary (now have full parents). */
-    unshallow: ObjectId[];
-}
-/**
- * Read the set of shallow boundary commit hashes from `.git/shallow`.
- * Returns an empty set if the file doesn't exist or is empty.
- */
-declare function readShallowCommits(ctx: GitContext): Promise<Set<ObjectId>>;
-/**
- * Write the shallow boundary set to `.git/shallow`.
- * Removes the file if the set is empty (repo is no longer shallow).
- */
-declare function writeShallowCommits(ctx: GitContext, hashes: Set<ObjectId>): Promise<void>;
-/** Check whether a repo is shallow (has a non-empty `.git/shallow` file). */
-declare function isShallowRepo(ctx: GitContext): Promise<boolean>;
-/**
- * Merge a `ShallowUpdate` into the current `.git/shallow` file.
- * Adds new shallow commits, removes unshallowed ones, persists the result.
- */
-declare function applyShallowUpdates(ctx: GitContext, updates: ShallowUpdate, existing?: Set<ObjectId>): Promise<void>;
-/**
- * Compute the shallow boundary for a depth-limited fetch.
- *
- * BFS from `wants` up to `depth` levels of commit parents. Commits
- * at exactly depth N (whose parents would exceed the limit) become
- * the new shallow boundary. Any commit in `clientShallows` that is
- * now within the traversal depth gets unshallowed.
- *
- * The returned `shallow` set is the new boundary — commits whose
- * parents the client should NOT expect to have. The `unshallow` set
- * is commits that were previously shallow but are now within depth.
- */
-declare function computeShallowBoundary(repo: GitRepo, wants: ObjectId[], depth: number, clientShallows: Set<ObjectId>): Promise<ShallowUpdate>;
-
-/** Options for shallow/depth-limited fetches. */
-interface ShallowFetchOptions {
-    /** Maximum commit depth from the wanted refs. */
-    depth?: number;
-    /** Commits currently in the client's `.git/shallow` file. */
-    existingShallows?: Set<ObjectId>;
-}
+import { F as FileSystem, G as GitHooks, C as CredentialProvider, I as IdentityOverride, N as NetworkPolicy, R as RemoteResolver, O as ObjectStore, a as RefStore, b as ConfigOverrides, E as ExecResult, c as FileStat, d as GitContext } from './hooks-4DvkF2xT.js';
+export { A as AfterCommandEvent, B as BeforeCommandEvent, e as CommitMsgEvent, f as GitRepo, H as HttpAuth, M as MergeMsgEvent, g as ObjectWriteEvent, P as PostCheckoutEvent, h as PostCherryPickEvent, i as PostCleanEvent, j as PostCloneEvent, k as PostCommitEvent, l as PostFetchEvent, m as PostMergeEvent, n as PostPullEvent, o as PostPushEvent, p as PostResetEvent, q as PostRevertEvent, r as PostRmEvent, s as PostStashEvent, t as PreCheckoutEvent, u as PreCherryPickEvent, v as PreCleanEvent, w as PreCloneEvent, x as PreCommitEvent, y as PreFetchEvent, z as PreMergeCommitEvent, D as PrePullEvent, J as PrePushEvent, K as PreRebaseEvent, L as PreResetEvent, Q as PreRevertEvent, S as PreRmEvent, T as PreStashEvent, U as RefDeleteEvent, V as RefEntry, W as RefUpdateEvent, X as Rejection, Y as composeGitHooks, Z as isRejection } from './hooks-4DvkF2xT.js';
 
 /** Options for subcommand execution (mirrors just-bash's CommandExecOptions). */
 interface CommandExecOptions {
@@ -70,7 +22,15 @@ interface CommandContext {
     exec?: (command: string, options: CommandExecOptions) => Promise<ExecResult>;
     signal?: AbortSignal;
 }
+/** Git subcommand name. Used with {@link GitOptions.disabled} to block specific commands. */
 type GitCommandName = "init" | "clone" | "fetch" | "pull" | "push" | "add" | "blame" | "commit" | "status" | "log" | "branch" | "tag" | "checkout" | "diff" | "reset" | "merge" | "cherry-pick" | "revert" | "rebase" | "mv" | "rm" | "remote" | "config" | "show" | "stash" | "rev-parse" | "ls-files" | "clean" | "switch" | "restore" | "reflog" | "repack" | "gc" | "bisect";
+/**
+ * Configuration for a {@link Git} instance.
+ *
+ * Controls hooks, identity, credentials, network access, command
+ * restrictions, and config overrides for all commands run through
+ * this instance.
+ */
 interface GitOptions {
     hooks?: GitHooks;
     credentials?: CredentialProvider;
@@ -102,21 +62,6 @@ interface GitOptions {
      */
     config?: ConfigOverrides;
 }
-/**
- * Bundle of operator-level extensions threaded into command handlers
- * via closures and merged onto GitContext after discovery.
- */
-interface GitExtensions {
-    hooks?: GitHooks;
-    credentialProvider?: CredentialProvider;
-    identityOverride?: IdentityOverride;
-    fetchFn?: FetchFunction;
-    networkPolicy?: NetworkPolicy | false;
-    resolveRemote?: RemoteResolver;
-    objectStore?: ObjectStore;
-    refStore?: RefStore;
-    configOverrides?: ConfigOverrides;
-}
 /** Simplified context for {@link Git.exec}. */
 interface ExecContext {
     fs: FileSystem;
@@ -124,6 +69,19 @@ interface ExecContext {
     env?: Record<string, string>;
     stdin?: string;
 }
+/**
+ * Git command handler. Runs git subcommands against a virtual filesystem.
+ *
+ * Create via {@link createGit}. Use as a standalone executor with
+ * {@link Git.exec}, or pass directly into just-bash's `customCommands`
+ * to make `git` available inside a virtual shell.
+ *
+ * ```ts
+ * const git = createGit();
+ * const fs = new MemoryFileSystem();
+ * await git.exec("init", { fs, cwd: "/repo" });
+ * ```
+ */
 declare class Git {
     readonly name = "git";
     private blocked;
@@ -146,12 +104,7 @@ declare class Git {
     exec: (command: string, ctx: ExecContext) => Promise<ExecResult>;
     execute: (args: string[], ctx: CommandContext) => Promise<ExecResult>;
 }
-/**
- * Tokenize a command string with basic shell quoting.
- * Supports single quotes, double quotes (with backslash escapes),
- * and whitespace splitting. Strips a leading "git" token if present.
- */
-declare function tokenizeCommand(input: string): string[];
+/** Create a new {@link Git} command handler with the given options. */
 declare function createGit(options?: GitOptions): Git;
 
 /**
@@ -194,4 +147,4 @@ declare class MemoryFileSystem implements FileSystem {
  */
 declare function findRepo(fs: FileSystem, startPath: string): Promise<GitContext | null>;
 
-export { type CommandContext, type CommandExecOptions, ConfigOverrides, CredentialProvider, type ExecContext, ExecResult, FetchFunction, FileStat, FileSystem, Git, type GitCommandName, GitContext, type GitExtensions, GitHooks, type GitOptions, GitRepo, INFINITE_DEPTH, IdentityOverride, MemoryFileSystem, NetworkPolicy, ObjectStore, RefStore, RemoteResolver, type ShallowFetchOptions, type ShallowUpdate, applyShallowUpdates, computeShallowBoundary, createGit, findRepo, isShallowRepo, readShallowCommits, tokenizeCommand, writeShallowCommits };
+export { ConfigOverrides, CredentialProvider, type ExecContext, ExecResult, FileStat, FileSystem, Git, type GitCommandName, GitContext, GitHooks, type GitOptions, IdentityOverride, MemoryFileSystem, NetworkPolicy, ObjectStore, RefStore, RemoteResolver, createGit, findRepo };