just-git 1.3.1 → 1.3.3

package/dist/repo/index.d.ts

@@ -1,4 +1,77 @@
-import { _ as ObjectId, $ as Identity, d as GitContext, f as GitRepo, F as FileSystem, a0 as TreeDiffEntry, V as RefEntry, a1 as Commit, O as ObjectStore, a2 as ObjectType, a3 as RawObject, a4 as PackObject, a as RefStore, a5 as Ref } from '../hooks-BtbyLyYE.js';
+import { g as GitRepo, a1 as RefEntry, e as Commit, i as ObjectId, h as Identity, a7 as TreeDiffEntry, d as GitContext, F as FileSystem } from '../hooks-t3k-y0u_.js';
+
+/**
+ * Core grep matching logic shared by the `git grep` command and the
+ * repo-level `grep` helper.
+ */
+interface GrepMatch {
+    lineNo: number;
+    line: string;
+}
+
+/** Resolve a ref name (e.g. "HEAD", "refs/heads/main") to a commit hash. Returns null if not found. */
+declare function resolveRef(repo: GitRepo, name: string): Promise<string | null>;
+/** List all local branches (`refs/heads/*`). */
+declare function listBranches(repo: GitRepo): Promise<RefEntry[]>;
+/** List all tags (`refs/tags/*`). */
+declare function listTags(repo: GitRepo): Promise<RefEntry[]>;
+/** Read and parse a commit object by its hash. */
+declare function readCommit(repo: GitRepo, hash: string): Promise<Commit>;
+/** Read a blob's raw bytes by its hash. */
+declare function readBlob(repo: GitRepo, hash: string): Promise<Uint8Array>;
+/** Read a blob as a UTF-8 string by its hash. */
+declare function readBlobText(repo: GitRepo, hash: string): Promise<string>;
+/**
+ * Read a file's content at a specific commit.
+ * Returns null if the file doesn't exist at that commit.
+ */
+declare function readFileAtCommit(repo: GitRepo, commitHash: string, filePath: string): Promise<string | null>;
+/** Options for {@link grep}. */
+interface GrepOptions {
+    /** Treat patterns as fixed strings, not regexps. */
+    fixed?: boolean;
+    /** Case-insensitive matching. */
+    ignoreCase?: boolean;
+    /** Match whole words only. */
+    wordRegexp?: boolean;
+    /** Require ALL patterns to hit at least one line in a file (AND). Default is OR. */
+    allMatch?: boolean;
+    /** Invert the match — return non-matching lines. */
+    invert?: boolean;
+    /** Limit matches per file. */
+    maxCount?: number;
+    /** Max directory depth (0 = only root-level files). */
+    maxDepth?: number;
+    /** Only search files whose paths match these globs. Matched against the full repo-relative path. */
+    paths?: string[];
+}
+/** A single file's grep results from {@link grep}. */
+interface GrepFileMatch {
+    /** Repo-relative file path. */
+    path: string;
+    /** Matching lines (empty for binary matches). */
+    matches: GrepMatch[];
+    /** True when the file is binary and a pattern matched its raw content. */
+    binary: boolean;
+}
+
+/**
+ * Search files at a commit for lines matching one or more patterns.
+ *
+ * Operates purely on the object store — no filesystem, index, or
+ * worktree needed. Takes a commit hash (not a ref name) and returns
+ * structured match results.
+ *
+ * ```ts
+ * const results = await grep(repo, commitHash, ["TODO", "FIXME"]);
+ * for (const file of results) {
+ *   for (const m of file.matches) {
+ *     console.log(`${file.path}:${m.lineNo}: ${m.line}`);
+ *   }
+ * }
+ * ```
+ */
+declare function grep(repo: GitRepo, commitHash: string, patterns: (string | RegExp)[], options?: GrepOptions): Promise<GrepFileMatch[]>;
 
 interface BlameEntry {
     hash: ObjectId;
@@ -18,39 +91,6 @@ interface BlameEntry {
     };
 }
 
-/**
- * Core grep matching logic shared by the `git grep` command and the
- * repo-level `grep` helper.
- */
-interface GrepMatch {
-    lineNo: number;
-    line: string;
-}
-
-interface MergeConflict {
-    path: string;
-    reason: "content" | "delete-modify" | "add-add" | "rename-delete" | "rename-rename" | "directory-rename";
-    /** For delete-modify / rename-delete: which side deleted the file. */
-    deletedBy?: "ours" | "theirs";
-    /** For rename conflicts: the old (base) path. */
-    oldPath?: string;
-    /** For rename/rename: the path ours renamed to. */
-    oursPath?: string;
-    /** For rename/rename: the path theirs renamed to. */
-    theirsPath?: string;
-    /**
-     * For content conflicts arising from renames: the path where ours' version
-     * was before the merge. If different from `path`, indicates ours had the
-     * file at a different location.
-     */
-    oursOrigPath?: string;
-    /**
-     * For content conflicts arising from renames: the path where theirs'
-     * version was before the merge.
-     */
-    theirsOrigPath?: string;
-}
-
 /** A flattened file entry from walking a tree recursively. */
 interface FlatTreeEntry {
     path: string;
@@ -58,14 +98,7 @@ interface FlatTreeEntry {
     hash: ObjectId;
 }
 
-/**
- * Standalone helper functions for working with GitRepo.
- *
- * Thin wrappers over lib/ primitives. Useful inside server hooks
- * and equally useful outside the server for direct repo inspection.
- */
-
-/** Commit metadata returned by {@link getNewCommits}. */
+/** Commit metadata returned by {@link getNewCommits} and {@link walkCommitHistory}. */
 interface CommitInfo {
     hash: string;
     message: string;
@@ -74,35 +107,40 @@ interface CommitInfo {
     author: Identity;
     committer: Identity;
 }
-/**
- * Walk commits introduced by a ref update (newHash excluding oldHash).
- * If oldHash is null (new ref), walks all ancestors of newHash.
- */
-declare function getNewCommits(repo: GitRepo, oldHash: string | null, newHash: string): AsyncGenerator<CommitInfo>;
+/** Recursively walk a tree object and return all file entries with their full paths. */
+declare function flattenTree(repo: GitRepo, treeHash: string): Promise<FlatTreeEntry[]>;
+/** Diff two tree objects and return the list of added/deleted/modified entries. Pass null for an empty tree. */
+declare function diffTrees(repo: GitRepo, treeA: string | null, treeB: string | null): Promise<TreeDiffEntry[]>;
 /**
  * Get the files changed between two commits.
- * Reads the tree hash from each commit and diffs them.
  * If oldHash is null (new ref), diffs against an empty tree.
  */
 declare function getChangedFiles(repo: GitRepo, oldHash: string | null, newHash: string): Promise<TreeDiffEntry[]>;
+/**
+ * Walk commits introduced by a ref update (newHash excluding oldHash).
+ * If oldHash is null (new ref), walks all ancestors of newHash.
+ */
+declare function getNewCommits(repo: GitRepo, oldHash: string | null, newHash: string): AsyncGenerator<CommitInfo>;
 /** Check whether `candidate` is an ancestor of `descendant` in the commit graph. */
 declare function isAncestor(repo: GitRepo, candidate: string, descendant: string): Promise<boolean>;
-/** Resolve a ref name (e.g. "HEAD", "refs/heads/main") to a commit hash. Returns null if not found. */
-declare function resolveRef(repo: GitRepo, name: string): Promise<string | null>;
-/** List all local branches (`refs/heads/*`). */
-declare function listBranches(repo: GitRepo): Promise<RefEntry[]>;
-/** List all tags (`refs/tags/*`). */
-declare function listTags(repo: GitRepo): Promise<RefEntry[]>;
-/** Read and parse a commit object by its hash. */
-declare function readCommit(repo: GitRepo, hash: string): Promise<Commit>;
-/** Read a blob's raw bytes by its hash. */
-declare function readBlob(repo: GitRepo, hash: string): Promise<Uint8Array>;
-/** Read a blob as a UTF-8 string by its hash. */
-declare function readBlobText(repo: GitRepo, hash: string): Promise<string>;
-/** Recursively walk a tree object and return all file entries with their full paths. */
-declare function flattenTree(repo: GitRepo, treeHash: string): Promise<FlatTreeEntry[]>;
-/** Diff two tree objects and return the list of added/deleted/modified entries. Pass null for an empty tree. */
-declare function diffTrees(repo: GitRepo, treeA: string | null, treeB: string | null): Promise<TreeDiffEntry[]>;
+/** Find the merge base(s) of two commits. Returns one hash for most cases, multiple for criss-cross merges. */
+declare function findMergeBases(repo: GitRepo, commitA: string, commitB: string): Promise<string[]>;
+/**
+ * Count how many commits `localHash` is ahead of and behind `upstreamHash`.
+ */
+declare function countAheadBehind(repo: GitRepo, localHash: string, upstreamHash: string): Promise<{
+    ahead: number;
+    behind: number;
+}>;
+/**
+ * Compute line-by-line blame for a file at a given commit.
+ * Returns one entry per line with the originating commit, author, and content.
+ * Optionally restrict to a line range with `startLine` / `endLine` (1-based).
+ */
+declare function blame(repo: GitRepo, commitHash: string, path: string, opts?: {
+    startLine?: number;
+    endLine?: number;
+}): Promise<BlameEntry[]>;
 /** A single hunk in a file diff. */
 interface DiffHunk {
     oldStart: number;
@@ -147,43 +185,22 @@ declare function diffCommits(repo: GitRepo, base: string, head: string, options?
     /** Enable rename detection (default true). */
     renames?: boolean;
 }): Promise<FileDiff[]>;
-/** Find the merge base(s) of two commits. Returns one hash for most cases, multiple for criss-cross merges. */
-declare function findMergeBases(repo: GitRepo, commitA: string, commitB: string): Promise<string[]>;
-/** Result of a tree-level merge via {@link mergeTrees} or {@link mergeTreesFromTreeHashes}. */
-interface MergeTreesResult {
-    /** Hash of the result tree (may contain conflict-marker blobs). */
-    treeHash: string;
-    /** True if the merge completed without conflicts. */
-    clean: boolean;
-    /** Details of each conflict, if any. */
-    conflicts: MergeConflict[];
-    /** Informational messages from the merge engine. */
-    messages: string[];
-}
 /**
- * Three-way tree merge using merge-ort. Operates purely on the object
- * store — no filesystem or worktree needed.
- *
- * Takes two commit hashes, finds their merge base(s) automatically
- * (handling criss-cross merges via recursive base merging), and produces
- * a result tree with conflict-marker blobs embedded for any conflicts.
+ * Walk the commit graph starting from one or more hashes, yielding
+ * commits in reverse chronological order. Supports excluding commits
+ * reachable from specified hashes, following only first parents, and
+ * filtering to commits that touch specific paths.
  *
- * Use `mergeTreesFromTreeHashes` if you already have tree hashes and a
- * known base tree.
- */
-declare function mergeTrees(repo: GitRepo, oursCommit: string, theirsCommit: string, labels?: {
-    ours?: string;
-    theirs?: string;
-}): Promise<MergeTreesResult>;
-/**
- * Three-way tree merge from raw tree hashes. Useful when you already
- * have the base/ours/theirs trees and don't want automatic merge-base
- * computation.
+ * When `paths` is provided, history simplification is applied: at
+ * merge points, only TREESAME parents are followed (matching git's
+ * default simplification for `git log -- <path>`).
  */
-declare function mergeTreesFromTreeHashes(repo: GitRepo, baseTree: string | null, oursTree: string, theirsTree: string, labels?: {
-    ours?: string;
-    theirs?: string;
-}): Promise<MergeTreesResult>;
+declare function walkCommitHistory(repo: GitRepo, startHash: string | string[], opts?: {
+    exclude?: string[];
+    firstParent?: boolean;
+    paths?: string[];
+}): AsyncGenerator<CommitInfo>;
+
 /** Options for {@link createCommit}. */
 interface CreateCommitOptions {
     /** Hash of the tree object for this commit. */
@@ -222,9 +239,6 @@ interface TreeEntryInput {
  * Build a tree object from a flat list of entries and write it to the
  * object store. When `mode` is omitted, the object store is consulted:
  * tree objects get "040000", everything else gets "100644".
- *
- * For creating blobs to reference in the tree, write content directly
- * via `repo.objectStore.write("blob", content)`.
  */
 declare function writeTree(repo: GitRepo, entries: TreeEntryInput[]): Promise<string>;
 /**
@@ -232,11 +246,67 @@ declare function writeTree(repo: GitRepo, entries: TreeEntryInput[]): Promise<st
  * Returns the blob's hash.
  */
 declare function writeBlob(repo: GitRepo, content: string): Promise<string>;
+
+interface MergeConflict {
+    path: string;
+    reason: "content" | "delete-modify" | "add-add" | "rename-delete" | "rename-rename" | "directory-rename";
+    /** For delete-modify / rename-delete: which side deleted the file. */
+    deletedBy?: "ours" | "theirs";
+    /** For rename conflicts: the old (base) path. */
+    oldPath?: string;
+    /** For rename/rename: the path ours renamed to. */
+    oursPath?: string;
+    /** For rename/rename: the path theirs renamed to. */
+    theirsPath?: string;
+    /**
+     * For content conflicts arising from renames: the path where ours' version
+     * was before the merge. If different from `path`, indicates ours had the
+     * file at a different location.
+     */
+    oursOrigPath?: string;
+    /**
+     * For content conflicts arising from renames: the path where theirs'
+     * version was before the merge.
+     */
+    theirsOrigPath?: string;
+}
+
+/** Result of a tree-level merge via {@link mergeTrees} or {@link mergeTreesFromTreeHashes}. */
+interface MergeTreesResult {
+    /** Hash of the result tree (may contain conflict-marker blobs). */
+    treeHash: string;
+    /** True if the merge completed without conflicts. */
+    clean: boolean;
+    /** Details of each conflict, if any. */
+    conflicts: MergeConflict[];
+    /** Informational messages from the merge engine. */
+    messages: string[];
+}
 /**
- * Read a file's content at a specific commit.
- * Returns null if the file doesn't exist at that commit.
+ * Three-way tree merge using merge-ort. Operates purely on the object
+ * store — no filesystem or worktree needed.
+ *
+ * Takes two commit hashes, finds their merge base(s) automatically
+ * (handling criss-cross merges via recursive base merging), and produces
+ * a result tree with conflict-marker blobs embedded for any conflicts.
+ *
+ * Use `mergeTreesFromTreeHashes` if you already have tree hashes and a
+ * known base tree.
  */
-declare function readFileAtCommit(repo: GitRepo, commitHash: string, filePath: string): Promise<string | null>;
+declare function mergeTrees(repo: GitRepo, oursCommit: string, theirsCommit: string, labels?: {
+    ours?: string;
+    theirs?: string;
+}): Promise<MergeTreesResult>;
+/**
+ * Three-way tree merge from raw tree hashes. Useful when you already
+ * have the base/ours/theirs trees and don't want automatic merge-base
+ * computation.
+ */
+declare function mergeTreesFromTreeHashes(repo: GitRepo, baseTree: string | null, oursTree: string, theirsTree: string, labels?: {
+    ours?: string;
+    theirs?: string;
+}): Promise<MergeTreesResult>;
+
 /** Result of {@link extractTree}. */
 interface ExtractTreeResult {
     commitHash: string;
@@ -249,9 +319,6 @@ interface ExtractTreeResult {
  * Accepts a ref name ("HEAD", "refs/heads/main") or a raw commit hash.
  * Writes all tracked files under `targetDir` (default "/"). No `.git`
  * directory is created — just the working tree.
- *
- * Useful inside server hooks and platform callbacks to inspect, build,
- * or lint the code at a given commit without affecting the repo itself.
  */
 declare function extractTree(repo: GitRepo, refOrHash: string, fs: FileSystem, targetDir?: string): Promise<ExtractTreeResult>;
 interface CreateWorktreeOptions {
@@ -262,7 +329,7 @@ interface CreateWorktreeOptions {
     /** Path to the `.git` directory on the VFS (default: `<workTree>/.git`). */
     gitDir?: string;
 }
-/** Result of {@link createWorktree}. */
+/** Result of {@link createWorktree} and {@link createSandboxWorktree}. */
 interface WorktreeResult {
     /** The fully-wired GitContext, ready for use with lib/ functions. */
     ctx: GitContext;
@@ -296,84 +363,38 @@ interface WorktreeResult {
  */
 declare function createWorktree(repo: GitRepo, fs: FileSystem, options?: CreateWorktreeOptions): Promise<WorktreeResult>;
 /**
- * Count how many commits `localHash` is ahead of and behind `upstreamHash`.
- * Useful for tracking info display and branch comparison.
- */
-declare function countAheadBehind(repo: GitRepo, localHash: string, upstreamHash: string): Promise<{
-    ahead: number;
-    behind: number;
-}>;
-
-/**
- * Compute line-by-line blame for a file at a given commit.
- * Returns one entry per line with the originating commit, author, and content.
- * Optionally restrict to a line range with `startLine` / `endLine` (1-based).
- */
-declare function blame(repo: GitRepo, commitHash: string, path: string, opts?: {
-    startLine?: number;
-    endLine?: number;
-}): Promise<BlameEntry[]>;
-/**
- * Walk the commit graph starting from one or more hashes, yielding
- * commits in reverse chronological order. Supports excluding commits
- * reachable from specified hashes, following only first parents, and
- * filtering to commits that touch specific paths.
+ * Create an ephemeral worktree backed by overlay stores and a lazy filesystem.
  *
- * When `paths` is provided, history simplification is applied: at
- * merge points, only TREESAME parents are followed (matching git's
- * default simplification for `git log -- <path>`).
- */
-declare function walkCommitHistory(repo: GitRepo, startHash: string | string[], opts?: {
-    exclude?: string[];
-    firstParent?: boolean;
-    paths?: string[];
-}): AsyncGenerator<CommitInfo>;
-/** Options for {@link grep}. */
-interface GrepOptions {
-    /** Treat patterns as fixed strings, not regexps. */
-    fixed?: boolean;
-    /** Case-insensitive matching. */
-    ignoreCase?: boolean;
-    /** Match whole words only. */
-    wordRegexp?: boolean;
-    /** Require ALL patterns to hit at least one line in a file (AND). Default is OR. */
-    allMatch?: boolean;
-    /** Invert the match — return non-matching lines. */
-    invert?: boolean;
-    /** Limit matches per file. */
-    maxCount?: number;
-    /** Max directory depth (0 = only root-level files). */
-    maxDepth?: number;
-    /** Only search files whose paths match these globs. Matched against the full repo-relative path. */
-    paths?: string[];
-}
-/** A single file's grep results from {@link grep}. */
-interface GrepFileMatch {
-    /** Repo-relative file path. */
-    path: string;
-    /** Matching lines (empty for binary matches). */
-    matches: GrepMatch[];
-    /** True when the file is binary and a pattern matched its raw content. */
-    binary: boolean;
-}
-
-/**
- * Search files at a commit for lines matching one or more patterns.
+ * - Object/ref writes go to an in-memory overlay (real repo untouched)
+ * - Worktree files are read lazily from the object store on demand
+ * - All state is discarded when the returned context goes out of scope
  *
- * Operates purely on the object store — no filesystem, index, or
- * worktree needed. Takes a commit hash (not a ref name) and returns
- * structured match results.
+ * Designed for server hooks that need to run tools against pushed code
+ * without paying the cost of materializing the entire tree and without
+ * risking mutation of the real repository.
  *
  * ```ts
- * const results = await grep(repo, commitHash, ["TODO", "FIXME"]);
- * for (const file of results) {
- *   for (const m of file.matches) {
- *     console.log(`${file.path}:${m.lineNo}: ${m.line}`);
+ * hooks: {
+ *   async preReceive({ repo, updates }) {
+ *     const { ctx } = await createSandboxWorktree(repo, {
+ *       ref: updates[0].newHash,
+ *     });
+ *     const git = createGit({
+ *       objectStore: ctx.objectStore,
+ *       refStore: ctx.refStore,
+ *     });
+ *     const bash = new Bash({ fs: ctx.fs, cwd: ctx.workTree! });
+ *     const result = await bash.exec("cat package.json");
  *   }
  * }
  * ```
  */
-declare function grep(repo: GitRepo, commitHash: string, patterns: (string | RegExp)[], options?: GrepOptions): Promise<GrepFileMatch[]>;
+declare function createSandboxWorktree(repo: GitRepo, options?: {
+    ref?: string;
+    workTree?: string;
+    gitDir?: string;
+}): Promise<WorktreeResult>;
+
 /**
  * Wrap a `GitRepo` so all write operations throw.
  *
@@ -382,9 +403,6 @@ declare function grep(repo: GitRepo, commitHash: string, patterns: (string | Reg
  * writeRef, deleteRef, ingestPack, compareAndSwapRef) throw with
  * a descriptive error.
  *
- * Use with `createWorktree` and/or `GitOptions.objectStore` /
- * `GitOptions.refStore` to enforce read-only access:
- *
  * ```ts
  * const ro = readonlyRepo(storage.repo("my-repo"));
  * const { ctx } = await createWorktree(ro, fs, { workTree: "/repo" });
@@ -403,100 +421,12 @@ declare function readonlyRepo(repo: GitRepo): GitRepo;
  * compareAndSwapRef) are captured in an in-memory overlay
  * and never reach the inner repo.
  *
- * Use for ephemeral operations (CI, previews, dry-run merges)
- * where you need full read-write semantics but must not
- * mutate the real repository.
- *
  * ```ts
  * const ephemeral = overlayRepo(storage.repo("my-repo"));
- * // writes succeed but only exist in memory
  * await ephemeral.objectStore.write("blob", content);
  * // original repo is untouched
  * ```
  */
 declare function overlayRepo(repo: GitRepo): GitRepo;
-/**
- * Create an ephemeral worktree backed by overlay stores and a lazy filesystem.
- *
- * - Object/ref writes go to an in-memory overlay (real repo untouched)
- * - Worktree files are read lazily from the object store on demand
- * - All state is discarded when the returned context goes out of scope
- *
- * Designed for server hooks that need to run tools against pushed code
- * without paying the cost of materializing the entire tree and without
- * risking mutation of the real repository.
- *
- * ```ts
- * hooks: {
- *   async preReceive({ repo, updates }) {
- *     const { ctx } = await createSandboxWorktree(repo, {
- *       ref: updates[0].newHash,
- *     });
- *     const git = createGit({
- *       objectStore: ctx.objectStore,
- *       refStore: ctx.refStore,
- *     });
- *     const bash = new Bash({ fs: ctx.fs, cwd: ctx.workTree! });
- *     const result = await bash.exec("cat package.json");
- *     // reads lazily from object store — only touched files are loaded
- *   }
- * }
- * ```
- */
-declare function createSandboxWorktree(repo: GitRepo, options?: {
-    ref?: string;
-    workTree?: string;
-    gitDir?: string;
-}): Promise<WorktreeResult>;
-
-/**
- * Git object storage: compressed loose objects for new writes, with
- * retained packfiles from fetch/clone. Pack indices are loaded eagerly
- * during discovery for fast hash lookups; pack data is loaded lazily
- * on first read from each pack.
- */
-declare class PackedObjectStore implements ObjectStore {
-    private fs;
-    private gitDir;
-    private packs;
-    private loadedPackNames;
-    private discoverPromise;
-    private cache;
-    private packDir;
-    constructor(fs: FileSystem, gitDir: string, cacheMaxBytes?: number);
-    write(type: ObjectType, content: Uint8Array): Promise<ObjectId>;
-    read(hash: ObjectId): Promise<RawObject>;
-    exists(hash: ObjectId): Promise<boolean>;
-    ingestPack(packData: Uint8Array): Promise<number>;
-    ingestPackStream(entries: AsyncIterable<PackObject>): Promise<number>;
-    invalidatePacks(): void;
-    findByPrefix(prefix: string): Promise<ObjectId[]>;
-    /** Load the pack data for a slot on demand. */
-    private ensureReader;
-    /** Scan `.git/objects/pack/` for existing pack/idx pairs. */
-    private discover;
-    private doDiscover;
-}
-
-/**
- * Default filesystem-backed ref storage. Reads/writes loose ref files
- * under `.git/`, with `packed-refs` as fallback for reads and listings.
- */
-declare class FileSystemRefStore implements RefStore {
-    private fs;
-    private gitDir;
-    private casLocks;
-    constructor(fs: FileSystem, gitDir: string);
-    readRef(name: string): Promise<Ref | null>;
-    writeRef(name: string, refOrHash: Ref | string): Promise<void>;
-    deleteRef(name: string): Promise<void>;
-    listRefs(prefix?: string): Promise<RefEntry[]>;
-    compareAndSwapRef(name: string, expectedOldHash: string | null, newRef: Ref | null): Promise<boolean>;
-    private compareAndSwapUnsafe;
-    private resolveRefInternal;
-    private readPackedRefs;
-    private removePackedRef;
-    private walkRefs;
-}
 
-export { type BlameEntry, type CommitInfo, type CreateCommitOptions, type CreateWorktreeOptions, type DiffHunk, type ExtractTreeResult, type FileDiff, FileSystemRefStore, GitRepo, type GrepFileMatch, type GrepMatch, type GrepOptions, Identity, type MergeConflict, type MergeTreesResult, PackedObjectStore, type TreeEntryInput, type WorktreeResult, blame, countAheadBehind, createCommit, createSandboxWorktree, createWorktree, diffCommits, diffTrees, extractTree, findMergeBases, flattenTree, getChangedFiles, getNewCommits, grep, isAncestor, listBranches, listTags, mergeTrees, mergeTreesFromTreeHashes, overlayRepo, readBlob, readBlobText, readCommit, readFileAtCommit, readonlyRepo, resolveRef, walkCommitHistory, writeBlob, writeTree };
+export { type BlameEntry, Commit, type CommitInfo, type CreateCommitOptions, type CreateWorktreeOptions, type DiffHunk, type ExtractTreeResult, type FileDiff, type FlatTreeEntry, GitRepo, type GrepFileMatch, type GrepMatch, type GrepOptions, Identity, type MergeConflict, type MergeTreesResult, RefEntry, TreeDiffEntry, type TreeEntryInput, type WorktreeResult, blame, countAheadBehind, createCommit, createSandboxWorktree, createWorktree, diffCommits, diffTrees, extractTree, findMergeBases, flattenTree, getChangedFiles, getNewCommits, grep, isAncestor, listBranches, listTags, mergeTrees, mergeTreesFromTreeHashes, overlayRepo, readBlob, readBlobText, readCommit, readFileAtCommit, readonlyRepo, resolveRef, walkCommitHistory, writeBlob, writeTree };