@scolladon/tsgit 1.0.0 → 1.2.0

package/dist/types/chunks/{context-d36639-i.d.cts → context-CMrHCVwK.d.cts}

@@ -83,20 +83,25 @@ interface FileSystem {
     /**
      * Write bytes to file. Fails with FILE_EXISTS if the file already exists (exclusive create).
      *
-     * Contract obligations (Phase 7 §14.17):
+     * Contract obligations:
      * - **Parent-directory creation:** the adapter MUST ensure parent directories exist before the
-     *   exclusive write. Equivalent to `mkdir -p dirname(path)` before `open(path, O_EXCL)`. If the
-     *   parent is removed between the implicit mkdir and the open (e.g. concurrent `git gc` prunes
-     *   the fanout), the adapter retries once: re-create the parent, re-attempt the open. On a second
-     *   ENOENT the error propagates as FILE_NOT_FOUND.
+     *  exclusive write. Equivalent to `mkdir -p dirname(path)` before `open(path, O_EXCL)`. If the
+     *  parent is removed between the implicit mkdir and the open (e.g. concurrent `git gc` prunes
+     *  the fanout), the adapter retries once: re-create the parent, re-attempt the open. On a second
+     *  ENOENT the error propagates as FILE_NOT_FOUND.
      * - **Symlink-safe ancestor check:** the adapter MUST reject writes where any ancestor directory
-     *   of `path` is a symbolic link whose resolved target is outside the containment root. This
-     *   closes the attack where an attacker replaces `objects/xx/` with a symlink pointing elsewhere.
-     *   Implementation: lstat-walk the ancestor chain, or use `openat`-style relative opens.
+     *  of `path` is a symbolic link whose resolved target is outside the containment root. This
+     *  closes the attack where an attacker replaces `objects/xx/` with a symlink pointing elsewhere.
+     *  Implementation: lstat-walk the ancestor chain, or use `openat`-style relative opens.
      */
     readonly writeExclusive: (path: string, data: Uint8Array) => Promise<void>;
     /** Write UTF-8 string to file, creating parent directories as needed. */
     readonly writeUtf8: (path: string, content: string) => Promise<void>;
+    /**
+     * Append UTF-8 to a file, creating parent directories and the file as
+     * needed. Atomic per-call for line-sized writes (relies on `O_APPEND`).
+     */
+    readonly appendUtf8: (path: string, content: string) => Promise<void>;
     /** Check if path exists. */
     readonly exists: (path: string) => Promise<boolean>;
     /** Get file/directory metadata. Throws FILE_NOT_FOUND if not found. Follows symlinks. */
@@ -140,7 +145,7 @@ interface FileSystem {
      * - Node: `fs.open(path, O_NOFOLLOW | (mode === 'write' ? O_WRONLY : O_RDONLY))`.
      * - Memory: rejects with `PERMISSION_DENIED` when the leaf is a memory symlink entry.
      * - Browser OPFS: throws `UNSUPPORTED_OPERATION` (OPFS has no symlinks; callers can
-     *   fall back to a plain `read`/`write` because the no-follow guarantee holds vacuously).
+     *  fall back to a plain `read`/`write` because the no-follow guarantee holds vacuously).
      *
      * Throws `FILE_NOT_FOUND` if the leaf does not exist (in `read` mode).
      * Throws `PERMISSION_DENIED` if the leaf is a symlink.
@@ -206,13 +211,73 @@ interface LruCache<V> {
     readonly entryCount: number;
 }
 
+/**
+ * The lifecycle hooks tsgit invokes. Extend the union to add a hook.
+ *
+ * Kept in the domain layer because both the `HookRunner` port and the
+ * `HOOK_FAILED` command error reference it — a port may import domain, but
+ * domain may never import a port.
+ */
+type HookName = 'pre-commit' | 'commit-msg' | 'pre-push';
+
+/**
+ * A single hook invocation. The port is stateless — every fact the adapter
+ * needs to resolve and spawn the hook travels in this request.
+ */
+interface HookRequest {
+    /** Hook to run. */
+    readonly name: HookName;
+    /** Absolute directory holding hook scripts — `core.hooksPath` or `${gitDir}/hooks`. */
+    readonly hooksDir: string;
+    /** Working directory for the spawned process — the working-tree root. */
+    readonly workDir: string;
+    /** Absolute `.git` directory — exported to the hook environment as `GIT_DIR`. */
+    readonly gitDir: string;
+    /** Positional arguments (e.g. the `COMMIT_EDITMSG` path for `commit-msg`). */
+    readonly args: ReadonlyArray<string>;
+    /** Bytes piped to the hook's stdin. Empty string ⇒ stdin closed empty. */
+    readonly stdin: string;
+    /** Cancels a running hook — the adapter kills the child when it aborts. */
+    readonly signal?: AbortSignal;
+}
+/**
+ * Outcome of a hook invocation.
+ *
+ * `skipped` — the hook file is absent or not executable; nothing ran. Git
+ * treats both as "no hook, proceed".
+ *
+ * `ran` — the hook ran to completion; `exitCode` is authoritative (a non-zero
+ * value is the caller's signal to abort).
+ */
+type HookResult = {
+    readonly kind: 'skipped';
+} | {
+    readonly kind: 'ran';
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+};
+/**
+ * Runs git lifecycle hooks. Optional on `Context`: when absent, hooks are
+ * inert (the browser has no runner; a host may opt out).
+ */
+interface HookRunner {
+    /**
+     * Resolve `${hooksDir}/${name}`; when it exists and is executable, spawn it
+     * with `args`, `stdin`, `cwd = workDir`, and `GIT_DIR` in the environment.
+     * Resolves with the exit code and captured output. NEVER rejects for a
+     * non-zero exit — interpreting the exit code is the caller's policy.
+     */
+    readonly run: (request: HookRequest) => Promise<HookResult>;
+}
+
 /**
  * General-purpose level-based logger consumed by the facade and any cross-cutting
  * concern (dispose, validation, lifecycle). Independent from the transport-tier
  * `Logger` in `transport/types.ts`, which is event-based and HTTP-shaped.
  *
  * The facade wraps user-supplied loggers with sanitization at construction time
- * (see Phase 10 design §8.5). Implementations should be tolerant of high call
+ * . Implementations should be tolerant of high call
  * frequency and MUST NOT throw — a throwing logger crashes nothing.
  */
 interface Logger {
@@ -225,8 +290,8 @@ interface Logger {
 declare const noopLogger: Logger;
 /**
  * Wrap a user-supplied logger so every `message` + every string value in the
- * `context` object passes through `sanitize()` (Phase 9 §4.7) before reaching
- * the sink. Per design §8.5 the facade applies this at construction time so no
+ * `context` object passes through `sanitize()` before reaching
+ * the sink. the facade applies this at construction time so no
  * downstream caller ever feeds raw control bytes to a user-controlled sink.
  *
  * Methods that the user did not supply are absent on the wrapper (preserves
@@ -237,7 +302,7 @@ declare const wrapLoggerSanitizer: (logger: Logger) => Logger;
 
 /**
  * Progress reporter shape consumed by long-running commands. The facade
- * (Phase 10) accepts a user-supplied implementation via
+ *  accepts a user-supplied implementation via
  * `OpenRepositoryOptions.progress` and plumbs it onto `Context.progress`.
  *
  * Reporters are synchronous and fire-and-forget. The facade wraps every call
@@ -260,21 +325,51 @@ interface ProgressReporter {
     readonly end: (op: string) => void;
 }
 
+/** Outcome of a promisor-remote lazy fetch (ADR-081). */
+interface PromisorFetchOutcome {
+    /**
+     * False when the repository has no promisor remote configured — the caller
+     * (`readObject`) then falls through to its normal `OBJECT_NOT_FOUND`.
+     */
+    readonly attempted: boolean;
+    /** Objects the caller asked for. */
+    readonly requested: number;
+    /** Objects that were missing locally and were fetched from the promisor. */
+    readonly fetched: number;
+}
 /**
- * Repository physical layout — where the working tree and .git directory live.
- * Renamed in Phase 10 from the previous `RepositoryConfig` (port-tier) to free that
+ * Capability for fetching objects that a partial clone omitted, from the
+ * configured promisor remote. Wired onto `Context` by `openRepository` and
+ * consumed by `readObject` on a miss — the dependency-inverting seam that lets
+ * a primitive trigger a command-tier fetch without importing upward.
+ */
+interface PromisorRemote {
+    fetch(oids: ReadonlyArray<ObjectId>): Promise<PromisorFetchOutcome>;
+}
+
+/**
+ * Repository physical layout — where the working tree and.git directory live.
+ * Renamed in from the previous `RepositoryConfig` (port-tier) to free that
  * name for the facade-tier `RepositoryConfig` shape (auth/parallelism/etc.).
  */
 interface RepositoryLayout {
     /** Absolute path to the repository root (working tree). */
     readonly workDir: string;
-    /** Absolute path to the .git directory (usually `${workDir}/.git`, but may differ for bare repos or worktrees). */
+    /** Absolute path to the.git directory (usually `${workDir}/.git`, but may differ for bare repos or worktrees). */
     readonly gitDir: string;
     /** Whether this is a bare repository. */
     readonly bare: boolean;
+    /**
+     * Home directory for `~`-expansion in config-driven paths (e.g.
+     * `core.excludesFile = ~/.config/git/ignore`). Populated by the node
+     * shim from `os.homedir()`; memory adapter accepts an option; browser
+     * leaves it `undefined`. When `undefined`, loaders that need home
+     * expansion treat the source as missing.
+     */
+    readonly homeDir?: string;
 }
 /**
- * Author / committer identity — Phase 9 §4.7 shape.
+ * Author / committer identity shape.
  */
 interface AuthorIdentity {
     readonly name: string;
@@ -292,7 +387,7 @@ type AuthStrategy = {
     readonly password: string;
 };
 /**
- * Facade-tier configuration. Phase 10 introduces this shape; it carries the
+ * Facade-tier configuration. introduces this shape; it carries the
  * auth/parallelism/SSRF/network options the facade plumbs into network-pipeline.
  * All fields are optional — primitives and commands consult only the keys they need.
  */
@@ -304,7 +399,17 @@ interface RepositoryConfig {
     readonly upstreamRef?: RefName;
     readonly allowInsecure?: boolean;
     readonly allowPrivateNetworks?: boolean;
+    /**
+     * Hard cap (bytes) on a single pack body buffered in memory by `fetchPack`.
+     * Server-controlled byte counts above this raise `PACK_TOO_LARGE`. Default
+     * 512 MiB. Lower it for hardened deployments that clone only small repos.
+     */
     readonly maxResponseBytes?: number;
+    /**
+     * Hard cap on the entry-count field declared in a received pack header.
+     * Server-controlled `uint32` values above this raise `PACK_TOO_LARGE` before
+     * `fetchPack` allocates per-entry state. Default 50_000_000.
+     */
     readonly maxObjectsPerPack?: number;
     readonly detectRenames?: boolean;
     readonly breakStaleLockMs?: number;
@@ -332,6 +437,13 @@ interface Context {
     readonly logger?: Logger;
     /** Optional abort signal for cancelling long-running operations. */
     readonly signal?: AbortSignal;
+    /** Optional hook runner. Absent ⇒ hooks are inert (browser, or opted out). */
+    readonly hooks?: HookRunner;
+    /**
+     * Optional promisor-remote capability. Populated by `openRepository`;
+     * `readObject` consults it to lazy-fetch an object a partial clone omitted.
+     */
+    readonly promisor?: PromisorRemote;
 }
 interface CreateContextParts {
     readonly fs: FileSystem;
@@ -346,9 +458,10 @@ interface CreateContextParts {
     readonly config?: RepositoryConfig;
     readonly logger?: Logger;
     readonly signal?: AbortSignal;
+    readonly hooks?: HookRunner;
 }
 /** Assemble a frozen Context from its constituent ports + layout. */
 declare function createContext(parts: CreateContextParts): Context;
 
-export { ObjectId as O, RefName as R, FilePath as d, createContext as j, noopLogger as n, wrapLoggerSanitizer as w };
-export type { AuthStrategy as A, Compressor as C, DirEntry as D, FileHandle as F, HashService as H, InflateStreamResult as I, Logger as L, ProgressReporter as P, AuthorIdentity as a, Context as b, CreateContextParts as c, FileStat as e, FileSystem as f, Hasher as g, RepositoryConfig as h, RepositoryLayout as i };
+export { ObjectId as O, RefName as R, FilePath as d, createContext as p, noopLogger as q, wrapLoggerSanitizer as w };
+export type { AuthStrategy as A, Compressor as C, DirEntry as D, FileHandle as F, HashService as H, InflateStreamResult as I, Logger as L, ProgressReporter as P, AuthorIdentity as a, Context as b, CreateContextParts as c, FileStat as e, FileSystem as f, Hasher as g, HookName as h, HookRequest as i, HookResult as j, HookRunner as k, PromisorFetchOutcome as l, PromisorRemote as m, RepositoryConfig as n, RepositoryLayout as o };

package/dist/types/chunks/reflog-entry-BIf-zt__.d.cts

@@ -0,0 +1,331 @@
+import { O as ObjectId, d as FilePath, R as RefName, e as FileStat } from './context-CMrHCVwK.cjs';
+
+interface AuthorIdentity {
+    readonly name: string;
+    readonly email: string;
+    readonly timestamp: number;
+    readonly timezoneOffset: string;
+}
+
+interface Blob {
+    readonly type: 'blob';
+    readonly id: ObjectId;
+    readonly content: Uint8Array;
+}
+
+interface ExtraHeader {
+    readonly key: string;
+    readonly value: string;
+}
+interface CommitData {
+    readonly tree: ObjectId;
+    readonly parents: ReadonlyArray<ObjectId>;
+    readonly author: AuthorIdentity;
+    readonly committer: AuthorIdentity;
+    readonly message: string;
+    readonly gpgSignature?: string;
+    readonly extraHeaders: ReadonlyArray<ExtraHeader>;
+}
+interface Commit {
+    readonly type: 'commit';
+    readonly id: ObjectId;
+    readonly data: CommitData;
+}
+
+declare const FILE_MODE: {
+    readonly REGULAR: "100644";
+    readonly EXECUTABLE: "100755";
+    readonly SYMLINK: "120000";
+    readonly DIRECTORY: "40000";
+    readonly GITLINK: "160000";
+};
+type FileMode = (typeof FILE_MODE)[keyof typeof FILE_MODE];
+
+type ObjectType = 'blob' | 'tree' | 'commit' | 'tag';
+
+interface TagData {
+    readonly object: ObjectId;
+    readonly objectType: ObjectType;
+    readonly tagName: string;
+    readonly tagger?: AuthorIdentity;
+    readonly message: string;
+    readonly gpgSignature?: string;
+    readonly extraHeaders: ReadonlyArray<ExtraHeader>;
+}
+interface Tag {
+    readonly type: 'tag';
+    readonly id: ObjectId;
+    readonly data: TagData;
+}
+
+interface TreeEntry {
+    readonly mode: FileMode;
+    readonly name: string;
+    readonly id: ObjectId;
+}
+interface Tree {
+    readonly type: 'tree';
+    readonly id: ObjectId;
+    readonly entries: ReadonlyArray<TreeEntry>;
+}
+
+type GitObject = Blob | Tree | Commit | Tag;
+
+interface AddChange {
+    readonly type: 'add';
+    readonly newPath: FilePath;
+    readonly newId: ObjectId;
+    readonly newMode: FileMode;
+}
+interface DeleteChange {
+    readonly type: 'delete';
+    readonly oldPath: FilePath;
+    readonly oldId: ObjectId;
+    readonly oldMode: FileMode;
+}
+interface ModifyChange {
+    readonly type: 'modify';
+    readonly path: FilePath;
+    readonly oldId: ObjectId;
+    readonly newId: ObjectId;
+    readonly oldMode: FileMode;
+    readonly newMode: FileMode;
+}
+interface RenameChange {
+    readonly type: 'rename';
+    readonly oldPath: FilePath;
+    readonly newPath: FilePath;
+    readonly id: ObjectId;
+    readonly mode: FileMode;
+}
+interface TypeChangeChange {
+    readonly type: 'type-change';
+    readonly path: FilePath;
+    readonly oldId: ObjectId;
+    readonly newId: ObjectId;
+    readonly oldMode: FileMode;
+    readonly newMode: FileMode;
+}
+type DiffChange = AddChange | DeleteChange | ModifyChange | RenameChange | TypeChangeChange;
+interface TreeDiff {
+    readonly changes: ReadonlyArray<DiffChange>;
+}
+
+interface RenameDetectOptions {
+    readonly limit?: number;
+    readonly maxSameIdDeletes?: number;
+}
+
+/**
+ * Primitive option shapes, walker value types, and shared constants.
+ * Defined in one location to avoid circular imports between primitive modules.
+ */
+
+/** Max symbolic-ref dereferences resolveRef will follow. */
+declare const MAX_SYMBOLIC_REF_DEPTH = 5;
+/** Max tag-peel hops resolveRef / readTree will follow when peeling. */
+declare const MAX_PEEL_DEPTH = 5;
+/** Max seeds walkCommits.from can contain. */
+declare const MAX_WALK_SEEDS = 1024;
+/** Hard cap on walkCommits' pending queue size to prevent unbounded heap growth. */
+declare const MAX_WALK_QUEUE_SIZE: number;
+/** Max.git/index file size readIndex will accept. */
+declare const MAX_INDEX_BYTES: number;
+/** Max commit message byte length createCommit will accept. */
+declare const MAX_COMMIT_MESSAGE_BYTES: number;
+/**
+ * Per-file size cap enforced by `add --all` before reading working-tree
+ * bytes into memory. Mirrors `MAX_CONFLICT_OUTPUT_BYTES` (256 MiB) so the
+ * write-side memory ceiling matches the read-side ceiling.
+ * See `docs/adr/032-add-all-large-file-guard.md`.
+ */
+declare const MAX_WORKING_TREE_BLOB_BYTES: number;
+/**
+ * Per-file cap on `.gitignore`, `.git/info/exclude`, and the global
+ * excludesFile. 1 MiB leaves a 20× margin over real-world max-size
+ * gitignore corpora. See `docs/adr/036-gitignore-bounded-read.md`.
+ */
+declare const MAX_GITIGNORE_BYTES: number;
+/**
+ * Per-file cap on a single `.git/logs/<ref>` reflog file. 16 MiB is generous
+ * — `reflog expire` is the size-management story; this guard only stops an
+ * adversarial or corrupt log from being buffered unbounded into memory.
+ */
+declare const MAX_REFLOG_BYTES: number;
+interface ReadObjectOptions {
+    readonly verifyHash?: boolean;
+    /**
+     * Reject objects whose serialised payload exceeds this byte count, before
+     * inflating the full content into memory. Counts the raw object content
+     * (post-inflate, pre-loose-header). When unset, no cap applies.
+     *
+     * Used by `merge`'s content merger to bound peak memory when an adversarial
+     * remote ships pathologically large blobs. See `docs/design/phase-13-8-
+     * bounded-object-reads.md`.
+     */
+    readonly maxBytes?: number;
+}
+interface ResolveRefOptions {
+    readonly peel?: boolean;
+    readonly maxSymbolicDepth?: number;
+    readonly maxPeelDepth?: number;
+}
+/**
+ * `updateRef` option shapes. A write requires a `reflogMessage` — git's
+ * builtins always supply a reason string; the type checker forces every
+ * present and future ref write to state why the ref moved. A delete drops the
+ * reflog file, so it carries no message.
+ */
+type UpdateRefOptions = {
+    readonly delete?: false;
+    readonly expected?: ObjectId | 'absent';
+    readonly reflogMessage: string;
+} | {
+    readonly delete: true;
+    readonly expected?: ObjectId | 'absent';
+};
+interface WalkCommitsOptions {
+    readonly from: ReadonlyArray<ObjectId>;
+    readonly until?: ReadonlyArray<ObjectId>;
+    readonly order?: 'topo' | 'first-parent';
+    readonly ignoreMissing?: boolean;
+    readonly verifyHash?: boolean;
+    /**
+     * Commits whose parents must NOT be enqueued. Used for shallow boundaries
+     * . The commit itself is still yielded — only its parents are
+     * skipped. Callers that want to also skip the boundary commit pass it in
+     * `until`.
+     */
+    readonly shallow?: ReadonlySet<ObjectId>;
+}
+/** Maximum `have` lines a single-round fetch will send. */
+declare const MAX_HAVES = 256;
+/** Hard cap on objects enumerated for a single push. design */
+declare const MAX_PUSH_OBJECTS = 1000000;
+interface WalkTreeEntry {
+    readonly path: FilePath;
+    readonly id: ObjectId;
+    readonly mode: FileMode;
+}
+interface WalkTreeOptions {
+    readonly recursive?: boolean;
+    readonly maxDepth?: number;
+    readonly maxEntries?: number;
+}
+interface WalkWorkingTreeEntry {
+    readonly path: FilePath;
+    readonly stat: FileStat;
+}
+type WalkIgnorePredicate = (path: FilePath, isDirectory: boolean) => boolean | Promise<boolean>;
+interface WalkWorkingTreeOptions {
+    readonly maxDepth?: number;
+    readonly maxEntries?: number;
+    /**
+     * predicate. Invoked on every directory BEFORE descent
+     * (returning `true` prunes the entire subtree, skipping its `lstat`
+     * cost) and on every leaf BEFORE yielding (returning `true` drops
+     * the leaf). May be sync or async.
+     */
+    readonly ignore?: WalkIgnorePredicate;
+}
+interface CreateCommitInput {
+    readonly tree: ObjectId;
+    readonly parents: ReadonlyArray<ObjectId>;
+    readonly author: AuthorIdentity;
+    readonly committer: AuthorIdentity;
+    readonly message: string;
+    readonly gpgSignature?: string;
+    readonly extraHeaders?: ReadonlyArray<ExtraHeader>;
+}
+type DiffTreesInput = Tree | ObjectId | undefined;
+interface DiffTreesOptions {
+    readonly detectRenames?: boolean;
+    readonly renameOptions?: RenameDetectOptions;
+}
+/**
+ * Per-file cap on a single `.gitmodules` blob. 1 MiB matches the
+ * `MAX_GITIGNORE_BYTES` budget: real `.gitmodules` files are KB-scale even in
+ * very large superprojects, so a 1 MiB ceiling is a generous DoS guard
+ * applied before inflate.
+ */
+declare const MAX_GITMODULES_BYTES: number;
+/**
+ * Recursion backstop for `walkSubmodules` — the cycle guard (visited gitdir
+ * set) handles the genuine-cycle case; this cap stops a pathologically deep
+ * but acyclic nest from running away.
+ */
+declare const MAX_SUBMODULE_DEPTH = 100;
+/** One submodule surfaced by `walkSubmodules`: a gitlink joined with its `.gitmodules` row. */
+interface SubmoduleEntry {
+    /**
+     * The `[submodule "<name>"]` subsection name in the `.gitmodules` of the
+     * tree that contains this gitlink. Falls back to `path` when no row matches
+     * the gitlink (a gitlink committed without a corresponding config entry).
+     */
+    readonly name: string;
+    /** Slash-joined path from the *superproject* root to the gitlink. */
+    readonly path: FilePath;
+    /** `submodule.<name>.url` — absent when no `.gitmodules` row matched. */
+    readonly url?: string;
+    /** `submodule.<name>.branch` — absent when the key is unset. */
+    readonly branch?: string;
+    /** The commit object id the gitlink pins (the tree entry's id). */
+    readonly commit: ObjectId;
+    /** Recursion depth; 0 for a direct submodule of the superproject. */
+    readonly depth: number;
+    /** Path of the containing submodule; absent for `depth === 0` entries. */
+    readonly parent?: FilePath;
+}
+/**
+ * One entry yielded by `catFileBatch` — a discriminated union so that a
+ * single bad id never aborts the stream. `ok: true` carries the parsed
+ * object plus its canonical payload size (matches the `<size>` field of
+ * `git cat-file --batch`'s header). `ok: false` is shaped to extend later:
+ * `reason` is a literal union so a future variant is an additive change.
+ */
+/**
+ * Optional knobs for the `catFileBatch` primitive — currently a single
+ * `maxBytes` cap forwarded to each per-id `readObject` call so a long
+ * batch over untrusted ids cannot exhaust the heap. Defaults to no cap.
+ */
+interface CatFileBatchOptions {
+    /**
+     * Per-object byte cap. Rejected pre-inflate; same semantics as
+     * `ReadObjectOptions.maxBytes`. When unset, no cap applies (parity
+     * with `readObject`).
+     */
+    readonly maxBytes?: number;
+}
+type CatFileBatchEntry = {
+    readonly ok: true;
+    readonly id: ObjectId;
+    readonly type: GitObject['type'];
+    readonly size: number;
+    readonly object: GitObject;
+} | {
+    readonly ok: false;
+    readonly id: ObjectId;
+    readonly reason: 'missing';
+};
+interface WalkSubmodulesOptions {
+    /** Tree-ish to walk. Default: `HEAD`. */
+    readonly ref?: RefName | ObjectId;
+    /** 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;
+}
+
+/** One line of a reflog file: a single ref movement from `oldId` to `newId`. */
+interface ReflogEntry {
+    readonly oldId: ObjectId;
+    readonly newId: ObjectId;
+    readonly identity: AuthorIdentity;
+    readonly message: string;
+}
+
+export { MAX_COMMIT_MESSAGE_BYTES as M, MAX_GITIGNORE_BYTES as e, MAX_GITMODULES_BYTES as f, MAX_HAVES as g, MAX_INDEX_BYTES as h, MAX_PEEL_DEPTH as i, MAX_PUSH_OBJECTS as j, MAX_REFLOG_BYTES as k, MAX_SUBMODULE_DEPTH as l, MAX_SYMBOLIC_REF_DEPTH as m, MAX_WALK_QUEUE_SIZE as n, MAX_WALK_SEEDS as o, MAX_WORKING_TREE_BLOB_BYTES as p };
+export type { AuthorIdentity as A, Blob as B, CatFileBatchEntry as C, DiffTreesInput as D, FileMode as F, GitObject as G, ReadObjectOptions as R, SubmoduleEntry as S, Tree as T, UpdateRefOptions as U, WalkCommitsOptions as W, CatFileBatchOptions as a, Commit as b, CreateCommitInput as c, DiffTreesOptions as d, ReflogEntry as q, ResolveRefOptions as r, TreeDiff as s, TreeEntry as t, WalkIgnorePredicate as u, WalkSubmodulesOptions as v, WalkTreeEntry as w, WalkTreeOptions as x, WalkWorkingTreeEntry as y, WalkWorkingTreeOptions as z };