@scolladon/tsgit 1.0.0 → 1.1.0

package/dist/types/chunks/{context-CTaXSPiP.d.ts → context-o5TPfMB2.d.ts}

@@ -83,16 +83,16 @@ 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. */
@@ -140,7 +140,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.
@@ -212,7 +212,7 @@ interface LruCache<V> {
  * `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 +225,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 +237,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
@@ -261,20 +261,28 @@ interface ProgressReporter {
 }
 
 /**
- * Repository physical layout — where the working tree and .git directory live.
- * Renamed in Phase 10 from the previous `RepositoryConfig` (port-tier) to free that
+ * 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 +300,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 +312,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;

package/dist/types/chunks/{diff-change-B09vxnxy.d.cts → diff-change-Bm1zvVsC.d.cts}

@@ -1,4 +1,4 @@
-import { d as FilePath, O as ObjectId } from './context-d36639-i.cjs';
+import { d as FilePath, O as ObjectId } from './context-D84z1i5F.cjs';
 
 interface AuthorIdentity {
     readonly name: string;

package/dist/types/chunks/{diff-change-D7xSeCn9.d.ts → diff-change-alGRzD_j.d.ts}

@@ -1,4 +1,4 @@
-import { d as FilePath, O as ObjectId } from './context-CTaXSPiP.js';
+import { d as FilePath, O as ObjectId } from './context-o5TPfMB2.js';
 
 interface AuthorIdentity {
     readonly name: string;

package/dist/types/chunks/{repository-CFT9j9H6.d.cts → repository-23evW2h-.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 { f as FileSystem, H as HashService, C as Compressor, h as RepositoryConfig, L as Logger, P as ProgressReporter, b as Context } from './context-D84z1i5F.cjs';
+import { q as createCommit, r as diffTrees, s as getRepoRoot, t as mergeBase, u as readBlob, v as readIndex, w as readObject, x as readTree, y as resolveRef, z as updateRef, A as walkCommits, B as walkTree, E as walkWorkingTree, F as writeObject, H as writeSymbolicRef, J as writeTree } from './write-tree-DVp0RJ_r.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. */
@@ -72,6 +72,7 @@ interface Repository {
         readonly updateRef: BindCtx<typeof updateRef>;
         readonly walkCommits: BindCtx<typeof walkCommits>;
         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-BT7Xq1kJ.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 { f as FileSystem, H as HashService, C as Compressor, h as RepositoryConfig, L as Logger, P as ProgressReporter, b as Context } from './context-o5TPfMB2.js';
+import { q as createCommit, r as diffTrees, s as getRepoRoot, t as mergeBase, u as readBlob, v as readIndex, w as readObject, x as readTree, y as resolveRef, z as updateRef, A as walkCommits, B as walkTree, E as walkWorkingTree, F as writeObject, H as writeSymbolicRef, J as writeTree } from './write-tree-DNjhjS3t.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. */
@@ -72,6 +72,7 @@ interface Repository {
         readonly updateRef: BindCtx<typeof updateRef>;
         readonly walkCommits: BindCtx<typeof walkCommits>;
         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-DNjhjS3t.d.ts

@@ -0,0 +1,282 @@
+import { O as ObjectId, d as FilePath, e as FileStat, b as Context, R as RefName } from './context-o5TPfMB2.js';
+import { A as AuthorIdentity, F as FileMode, T as TreeDiff } from './diff-change-alGRzD_j.js';
+
+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;
+}
+
+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 IndexEntryFlags {
+    readonly assumeValid: boolean;
+    readonly extended: boolean;
+    readonly stage: 0 | 1 | 2 | 3;
+}
+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;
+    readonly entries: ReadonlyArray<IndexEntry>;
+    readonly extensions: ReadonlyArray<IndexExtension>;
+}
+
+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;
+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;
+}
+interface UpdateRefOptions {
+    readonly expected?: ObjectId | 'absent';
+    readonly delete?: boolean;
+}
+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;
+}
+
+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 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>;
+
+declare function resolveRef(ctx: Context, name: RefName | 'HEAD', options?: ResolveRefOptions): Promise<ObjectId>;
+
+declare function updateRef(ctx: Context, name: RefName, newId: ObjectId, options?: UpdateRefOptions): Promise<void>;
+
+declare function walkCommits(ctx: Context, options: WalkCommitsOptions): AsyncIterable<Commit>;
+
+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 { walkCommits as A, walkTree as B, walkWorkingTree as E, writeObject as F, writeSymbolicRef as H, writeTree as J, MAX_COMMIT_MESSAGE_BYTES as M, MAX_GITIGNORE_BYTES as b, MAX_HAVES as c, MAX_INDEX_BYTES as d, MAX_PEEL_DEPTH as e, MAX_PUSH_OBJECTS as f, MAX_SYMBOLIC_REF_DEPTH as g, MAX_WALK_QUEUE_SIZE as h, MAX_WALK_SEEDS as i, MAX_WORKING_TREE_BLOB_BYTES as j, createCommit as q, diffTrees as r, getRepoRoot as s, mergeBase as t, readBlob as u, readIndex as v, readObject as w, readTree as x, resolveRef as y, updateRef as z };
+export type { CreateCommitInput as C, DiffTreesInput as D, GitIndex as G, IndexEntry as I, ReadObjectOptions as R, UpdateRefOptions as U, WalkCommitsOptions as W, DiffTreesOptions as a, ResolveRefOptions as k, WalkIgnorePredicate as l, WalkTreeEntry as m, WalkTreeOptions as n, WalkWorkingTreeEntry as o, WalkWorkingTreeOptions as p };