@scolladon/tsgit 1.0.0 → 1.2.0

package/dist/types/chunks/reflog-entry-D9P2hCgv.d.ts

@@ -0,0 +1,331 @@
+import { O as ObjectId, d as FilePath, R as RefName, e as FileStat } from './context-BORy7yXb.js';
+
+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 };

package/dist/types/chunks/{repository-CFT9j9H6.d.cts → repository-BqibvTOu.d.cts}

@@ -1,6 +1,6 @@
-import { add, branch, checkout, clone, commit, diff, fetch, init, log, merge, push, reset, revParse, rm, status, tag } from '../commands/index.cjs';
-import { createCommit, diffTrees, getRepoRoot, mergeBase, readBlob, readIndex, readObject, readTree, resolveRef, updateRef, walkCommits, walkTree, writeObject, writeSymbolicRef, writeTree } from '../primitives/index.cjs';
-import { f as FileSystem, H as HashService, C as Compressor, h as RepositoryConfig, L as Logger, P as ProgressReporter, b as Context } from './context-d36639-i.cjs';
+import { add, branch, catFile, checkout, clone, commit, diff, fetch, fetchMissing, init, log, merge, push, reflog, reset, revParse, rm, sparseCheckout, status, submodules, tag } from '../commands/index.cjs';
+import { f as FileSystem, H as HashService, C as Compressor, n as RepositoryConfig, L as Logger, P as ProgressReporter, k as HookRunner, b as Context } from './context-CMrHCVwK.cjs';
+import { c as catFileBatch, a as createCommit, d as diffTrees, g as getRepoRoot, m as mergeBase, r as readBlob, b as readIndex, e as readObject, f as readTree, h as recordRefUpdate, i as resolveRef, j as runHook, u as updateRef, w as walkCommits, k as walkSubmodules, l as walkTree, n as walkWorkingTree, o as writeObject, p as writeSymbolicRef, q as writeTree } from './write-tree-B8G6kgTy.cjs';
 import { b as HttpTransport } from './http-transport-DirKfK2S.cjs';
 
 /**
@@ -12,7 +12,7 @@ type BindCtx<F> = F extends (ctx: Context, ...rest: infer A) => infer R ? (...ar
  * User-facing options passed to `openRepository`. Subset of the design's
  * `OpenRepositoryOptions` that this Step 3 implementation honors. Every field
  * is optional; the facade fills sensible defaults. Field-level validation runs
- * eagerly before the Repository is returned (Phase 10 §8.1).
+ * eagerly before the Repository is returned.
  */
 interface OpenRepositoryOptions {
     /** Working directory. Default: `process.cwd()` on Node, `'/'` on browser/memory. */
@@ -30,6 +30,15 @@ interface OpenRepositoryOptions {
     readonly progress?: ProgressReporter;
     /** AbortSignal threaded into every bound method's ctx.signal. */
     readonly signal?: AbortSignal;
+    /**
+     * Hook runner. Omit to inherit the runtime default (Node wires one; the
+     * browser does not). Pass `false` to disable hooks entirely.
+     *
+     * WARNING: a wired runner spawns `.git/hooks/*` scripts that inherit the
+     * full `process.env` of the calling process — including any secrets it
+     * holds. Pass `false` when operating on a repository you do not trust.
+     */
+    readonly hooks?: HookRunner | false;
     /**
      * Opt OUT of adapter validator wrapping for `fs` and `transport`. NEVER set
      * with adapters whose code you do not control; a raw transport receives
@@ -45,21 +54,27 @@ interface OpenRepositoryOptions {
 interface Repository {
     readonly add: BindCtx<typeof add>;
     readonly branch: BindCtx<typeof branch>;
+    readonly catFile: BindCtx<typeof catFile>;
     readonly checkout: BindCtx<typeof checkout>;
     readonly clone: BindCtx<typeof clone>;
     readonly commit: BindCtx<typeof commit>;
     readonly diff: BindCtx<typeof diff>;
     readonly fetch: BindCtx<typeof fetch>;
+    readonly fetchMissing: BindCtx<typeof fetchMissing>;
     readonly init: BindCtx<typeof init>;
     readonly log: BindCtx<typeof log>;
     readonly merge: BindCtx<typeof merge>;
     readonly push: BindCtx<typeof push>;
+    readonly reflog: BindCtx<typeof reflog>;
     readonly reset: BindCtx<typeof reset>;
     readonly revParse: BindCtx<typeof revParse>;
     readonly rm: BindCtx<typeof rm>;
+    readonly sparseCheckout: BindCtx<typeof sparseCheckout>;
     readonly status: BindCtx<typeof status>;
+    readonly submodules: BindCtx<typeof submodules>;
     readonly tag: BindCtx<typeof tag>;
     readonly primitives: {
+        readonly catFileBatch: BindCtx<typeof catFileBatch>;
         readonly createCommit: BindCtx<typeof createCommit>;
         readonly diffTrees: BindCtx<typeof diffTrees>;
         readonly getRepoRoot: BindCtx<typeof getRepoRoot>;
@@ -68,10 +83,14 @@ interface Repository {
         readonly readIndex: BindCtx<typeof readIndex>;
         readonly readObject: BindCtx<typeof readObject>;
         readonly readTree: BindCtx<typeof readTree>;
+        readonly recordRefUpdate: BindCtx<typeof recordRefUpdate>;
         readonly resolveRef: BindCtx<typeof resolveRef>;
+        readonly runHook: BindCtx<typeof runHook>;
         readonly updateRef: BindCtx<typeof updateRef>;
         readonly walkCommits: BindCtx<typeof walkCommits>;
+        readonly walkSubmodules: BindCtx<typeof walkSubmodules>;
         readonly walkTree: BindCtx<typeof walkTree>;
+        readonly walkWorkingTree: BindCtx<typeof walkWorkingTree>;
         readonly writeObject: BindCtx<typeof writeObject>;
         readonly writeSymbolicRef: BindCtx<typeof writeSymbolicRef>;
         readonly writeTree: BindCtx<typeof writeTree>;

package/dist/types/chunks/{repository-ntg7eXb2.d.ts → repository-C4rN09Am.d.ts}

@@ -1,6 +1,6 @@
-import { add, branch, checkout, clone, commit, diff, fetch, init, log, merge, push, reset, revParse, rm, status, tag } from '../commands/index.js';
-import { createCommit, diffTrees, getRepoRoot, mergeBase, readBlob, readIndex, readObject, readTree, resolveRef, updateRef, walkCommits, walkTree, writeObject, writeSymbolicRef, writeTree } from '../primitives/index.js';
-import { f as FileSystem, H as HashService, C as Compressor, h as RepositoryConfig, L as Logger, P as ProgressReporter, b as Context } from './context-CTaXSPiP.js';
+import { add, branch, catFile, checkout, clone, commit, diff, fetch, fetchMissing, init, log, merge, push, reflog, reset, revParse, rm, sparseCheckout, status, submodules, tag } from '../commands/index.js';
+import { f as FileSystem, H as HashService, C as Compressor, n as RepositoryConfig, L as Logger, P as ProgressReporter, k as HookRunner, b as Context } from './context-BORy7yXb.js';
+import { c as catFileBatch, a as createCommit, d as diffTrees, g as getRepoRoot, m as mergeBase, r as readBlob, b as readIndex, e as readObject, f as readTree, h as recordRefUpdate, i as resolveRef, j as runHook, u as updateRef, w as walkCommits, k as walkSubmodules, l as walkTree, n as walkWorkingTree, o as writeObject, p as writeSymbolicRef, q as writeTree } from './write-tree-BXCDChvv.js';
 import { b as HttpTransport } from './http-transport-DirKfK2S.js';
 
 /**
@@ -12,7 +12,7 @@ type BindCtx<F> = F extends (ctx: Context, ...rest: infer A) => infer R ? (...ar
  * User-facing options passed to `openRepository`. Subset of the design's
  * `OpenRepositoryOptions` that this Step 3 implementation honors. Every field
  * is optional; the facade fills sensible defaults. Field-level validation runs
- * eagerly before the Repository is returned (Phase 10 §8.1).
+ * eagerly before the Repository is returned.
  */
 interface OpenRepositoryOptions {
     /** Working directory. Default: `process.cwd()` on Node, `'/'` on browser/memory. */
@@ -30,6 +30,15 @@ interface OpenRepositoryOptions {
     readonly progress?: ProgressReporter;
     /** AbortSignal threaded into every bound method's ctx.signal. */
     readonly signal?: AbortSignal;
+    /**
+     * Hook runner. Omit to inherit the runtime default (Node wires one; the
+     * browser does not). Pass `false` to disable hooks entirely.
+     *
+     * WARNING: a wired runner spawns `.git/hooks/*` scripts that inherit the
+     * full `process.env` of the calling process — including any secrets it
+     * holds. Pass `false` when operating on a repository you do not trust.
+     */
+    readonly hooks?: HookRunner | false;
     /**
      * Opt OUT of adapter validator wrapping for `fs` and `transport`. NEVER set
      * with adapters whose code you do not control; a raw transport receives
@@ -45,21 +54,27 @@ interface OpenRepositoryOptions {
 interface Repository {
     readonly add: BindCtx<typeof add>;
     readonly branch: BindCtx<typeof branch>;
+    readonly catFile: BindCtx<typeof catFile>;
     readonly checkout: BindCtx<typeof checkout>;
     readonly clone: BindCtx<typeof clone>;
     readonly commit: BindCtx<typeof commit>;
     readonly diff: BindCtx<typeof diff>;
     readonly fetch: BindCtx<typeof fetch>;
+    readonly fetchMissing: BindCtx<typeof fetchMissing>;
     readonly init: BindCtx<typeof init>;
     readonly log: BindCtx<typeof log>;
     readonly merge: BindCtx<typeof merge>;
     readonly push: BindCtx<typeof push>;
+    readonly reflog: BindCtx<typeof reflog>;
     readonly reset: BindCtx<typeof reset>;
     readonly revParse: BindCtx<typeof revParse>;
     readonly rm: BindCtx<typeof rm>;
+    readonly sparseCheckout: BindCtx<typeof sparseCheckout>;
     readonly status: BindCtx<typeof status>;
+    readonly submodules: BindCtx<typeof submodules>;
     readonly tag: BindCtx<typeof tag>;
     readonly primitives: {
+        readonly catFileBatch: BindCtx<typeof catFileBatch>;
         readonly createCommit: BindCtx<typeof createCommit>;
         readonly diffTrees: BindCtx<typeof diffTrees>;
         readonly getRepoRoot: BindCtx<typeof getRepoRoot>;
@@ -68,10 +83,14 @@ interface Repository {
         readonly readIndex: BindCtx<typeof readIndex>;
         readonly readObject: BindCtx<typeof readObject>;
         readonly readTree: BindCtx<typeof readTree>;
+        readonly recordRefUpdate: BindCtx<typeof recordRefUpdate>;
         readonly resolveRef: BindCtx<typeof resolveRef>;
+        readonly runHook: BindCtx<typeof runHook>;
         readonly updateRef: BindCtx<typeof updateRef>;
         readonly walkCommits: BindCtx<typeof walkCommits>;
+        readonly walkSubmodules: BindCtx<typeof walkSubmodules>;
         readonly walkTree: BindCtx<typeof walkTree>;
+        readonly walkWorkingTree: BindCtx<typeof walkWorkingTree>;
         readonly writeObject: BindCtx<typeof writeObject>;
         readonly writeSymbolicRef: BindCtx<typeof writeSymbolicRef>;
         readonly writeTree: BindCtx<typeof writeTree>;

package/dist/types/chunks/write-tree-B8G6kgTy.d.cts

@@ -0,0 +1,154 @@
+import { O as ObjectId, d as FilePath, b as Context, R as RefName, h as HookName } from './context-CMrHCVwK.cjs';
+import { F as FileMode, a as CatFileBatchOptions, C as CatFileBatchEntry, c as CreateCommitInput, D as DiffTreesInput, d as DiffTreesOptions, s as TreeDiff, R as ReadObjectOptions, B as Blob, G as GitObject, T as Tree, r as ResolveRefOptions, U as UpdateRefOptions, W as WalkCommitsOptions, b as Commit, v as WalkSubmodulesOptions, S as SubmoduleEntry, x as WalkTreeOptions, w as WalkTreeEntry, z as WalkWorkingTreeOptions, y as WalkWorkingTreeEntry, t as TreeEntry } from './reflog-entry-BIf-zt__.cjs';
+
+interface IndexEntryFlags {
+    readonly assumeValid: boolean;
+    readonly stage: 0 | 1 | 2 | 3;
+    /** Index v3 extended flag — the path is intentionally absent from the working tree. */
+    readonly skipWorktree: boolean;
+    /** Index v3 extended flag — `git add -N` placeholder. Modelled for faithful round-tripping. */
+    readonly intentToAdd: boolean;
+}
+interface IndexEntry {
+    readonly ctimeSeconds: number;
+    readonly ctimeNanoseconds: number;
+    readonly mtimeSeconds: number;
+    readonly mtimeNanoseconds: number;
+    readonly dev: number;
+    readonly ino: number;
+    readonly mode: FileMode;
+    readonly uid: number;
+    readonly gid: number;
+    readonly fileSize: number;
+    readonly id: ObjectId;
+    readonly flags: IndexEntryFlags;
+    readonly path: FilePath;
+}
+interface IndexExtension {
+    readonly signature: string;
+    readonly data: Uint8Array;
+}
+interface GitIndex {
+    readonly version: 2 | 3;
+    readonly entries: ReadonlyArray<IndexEntry>;
+    readonly extensions: ReadonlyArray<IndexExtension>;
+}
+
+declare function catFileBatch(ctx: Context, ids: AsyncIterable<ObjectId> | Iterable<ObjectId>, options?: CatFileBatchOptions): AsyncIterable<CatFileBatchEntry>;
+
+declare function createCommit(ctx: Context, input: CreateCommitInput): Promise<ObjectId>;
+
+declare function diffTrees(ctx: Context, a: DiffTreesInput, b: DiffTreesInput, options?: DiffTreesOptions): Promise<TreeDiff>;
+
+/**
+ * Compute a merge base — the first commit reachable from BOTH `a` and `b`.
+ *
+ * Algorithm: bidirectional BFS with two visited sets. After each layer
+ * advance, check the intersection. When non-empty, return the
+ * lexicographically smallest oid (deterministic tie-breaker).
+ *
+ * Returns `undefined` for unrelated histories. Documented limitation: cherry-picks
+ * and criss-cross merges may yield non-optimal bases — `recursive`-strategy
+ * multi-base resolution is v2.
+ */
+declare const mergeBase: (ctx: Context, a: ObjectId, b: ObjectId) => Promise<ObjectId | undefined>;
+
+/**
+ * Pure path helpers composing `ctx.layout.gitDir` with known sub-paths.
+ * No I/O. No port access. Primitive step 3.
+ */
+
+/**
+ * Repository working-tree root. Returns the workDir from the current context;
+ * facade-tier code is responsible for discovery / realpath pinning
+ * at construction time. Primitives consume the already-resolved path.
+ */
+declare const getRepoRoot: (ctx: Context) => FilePath;
+declare const sparseCheckoutPath: (gitDir: string) => string;
+
+declare function readBlob(ctx: Context, id: ObjectId, options?: ReadObjectOptions): Promise<Blob>;
+
+declare function readIndex(ctx: Context): Promise<GitIndex>;
+
+declare function readObject(ctx: Context, id: ObjectId, options?: ReadObjectOptions): Promise<GitObject>;
+
+declare function readTree(ctx: Context, ref: RefName | ObjectId): Promise<Tree>;
+
+/**
+ * The single reflog *writer*. Self-contained: reads config, applies the gate,
+ * resolves identity, sanitises the message, and appends one entry. Callers
+ * supply only a human-readable message.
+ */
+
+/**
+ * Append a reflog entry for `ref` if logging applies. A no-op when the gate is
+ * closed for `ref` — once a reflog file exists every update appends to it,
+ * otherwise the `core.logAllRefUpdates` prefix rule decides.
+ */
+declare function recordRefUpdate(ctx: Context, ref: RefName, oldId: ObjectId, newId: ObjectId, message: string): Promise<void>;
+
+declare function resolveRef(ctx: Context, name: RefName | 'HEAD', options?: ResolveRefOptions): Promise<ObjectId>;
+
+/** Optional arguments and stdin a caller threads into a hook invocation. */
+interface HookInput {
+    readonly args?: ReadonlyArray<string>;
+    readonly stdin?: string;
+}
+/**
+ * Run a named git hook through `ctx.hooks`. A no-op when no `HookRunner` is
+ * wired (browser, or opted out), when the hook file is absent / not executable
+ * (`skipped`), or when the hook exits 0. Throws `HOOK_FAILED` on a non-zero
+ * exit.
+ */
+declare const runHook: (ctx: Context, name: HookName, input?: HookInput) => Promise<void>;
+
+declare function updateRef(ctx: Context, name: RefName, newId: ObjectId, options: UpdateRefOptions): Promise<void>;
+
+declare function walkCommits(ctx: Context, options: WalkCommitsOptions): AsyncIterable<Commit>;
+
+/**
+ * Yield every gitlink reachable in `ref`'s tree, joined with its `.gitmodules`
+ * metadata. With `recursive: true`, descend into each nested submodule whose
+ * absorbed gitdir (`${gitDir}/modules/<name>`) is locally available; nested
+ * yields carry `depth >= 1` and a `parent` path. Uninitialised / missing /
+ * cyclic nested submodules contribute their own entry but no children — the
+ * absence of further yields is the signal, matching `git submodule status
+ * --recursive`.
+ */
+declare function walkSubmodules(ctx: Context, options?: WalkSubmodulesOptions): AsyncIterable<SubmoduleEntry>;
+
+declare function walkTree(ctx: Context, treeIdOrObject: ObjectId | Tree, options?: WalkTreeOptions): AsyncIterable<WalkTreeEntry>;
+
+/**
+ * Depth-first walk of the working tree starting at `ctx.layout.workDir`.
+ *
+ * Yields leaf entries (files and symlinks) as `{ path, stat }`. Directories
+ * are descended into, not yielded. `.git` at any level is skipped
+ * (case-insensitive, NTFS-trimmed). Embedded repositories (directories
+ * containing a `.git` child) are skipped entirely — yields nothing under
+ * them. Symlinks are surfaced via `lstat` (no follow); a symlink to a
+ * directory is yielded as a leaf, not descended into.
+ *
+ * The host repository's own `.git` is NOT treated as an embedded-repo
+ * marker — at the workDir root we only skip the `.git` entry itself, not
+ * the workDir.
+ */
+declare function walkWorkingTree(ctx: Context, options?: WalkWorkingTreeOptions): AsyncIterable<WalkWorkingTreeEntry>;
+
+declare function writeObject(ctx: Context, object: GitObject): Promise<ObjectId>;
+
+/**
+ * Write a symbolic ref atomically. Used for HEAD updates that point at a
+ * branch, branch renames affecting the current HEAD, and `clone`/`init`
+ * to set the initial HEAD.
+ *
+ * Single-level only in v1: target MUST be a direct ref name (no chained
+ * symrefs). Validation runs through `validateRefName` for both `name` and
+ * `target` — invalid inputs throw INVALID_REF before any I/O.
+ */
+declare const writeSymbolicRef: (ctx: Context, name: RefName, target: RefName) => Promise<void>;
+
+declare function writeTree(ctx: Context, entries: ReadonlyArray<TreeEntry>): Promise<ObjectId>;
+
+export { createCommit as a, readIndex as b, catFileBatch as c, diffTrees as d, readObject as e, readTree as f, getRepoRoot as g, recordRefUpdate as h, resolveRef as i, runHook as j, walkSubmodules as k, walkTree as l, mergeBase as m, walkWorkingTree as n, writeObject as o, writeSymbolicRef as p, writeTree as q, readBlob as r, sparseCheckoutPath as s, updateRef as u, walkCommits as w };
+export type { GitIndex as G, HookInput as H, IndexEntry as I };