@scolladon/tsgit 2.0.1 → 3.1.0

package/dist/types/chunks/reflog-entry-Dy-O27Dd.d.cts

@@ -0,0 +1,697 @@
+import { O as ObjectId, H as HashConfig, F as FilePath, R as RefName, f as FileStat } from './context-CF1YF2S8.cjs';
+
+/**
+ * A validated git-config key. Branded to prevent string-typed callers from
+ * passing a raw, unvalidated string into config primitives. Construct via
+ * `parseConfigKey` only.
+ */
+type ConfigKey = string & {
+    readonly __brand: 'ConfigKey';
+};
+/**
+ * The four canonical git-config scopes. Order in the union is also the read
+ * precedence (lowest precedence first): system → global → local → worktree.
+ */
+type ConfigScope = 'system' | 'global' | 'local' | 'worktree';
+
+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];
+declare function validateFileMode(mode: string): FileMode;
+declare function normalizeFileMode(mode: string): FileMode;
+declare function isDirectory(mode: FileMode): boolean;
+/**
+ * Derive a working-tree file's git mode from its `lstat`. A symbolic link is
+ * `120000` regardless of its permission bits; a regular file is `100755` when
+ * any of the `0o111` execute bits is set, else `100644`. This is the single
+ * definition staging and the working-tree comparison both use, so an added file
+ * and a later modified-check agree on the mode.
+ */
+declare function deriveWorkingMode(stat: {
+    readonly isSymbolicLink: boolean;
+    readonly mode: number;
+}): FileMode;
+
+interface AuthorIdentity {
+    readonly name: string;
+    readonly email: string;
+    readonly timestamp: number;
+    readonly timezoneOffset: string;
+}
+declare function parseIdentity(line: string): AuthorIdentity;
+declare function serializeIdentity(identity: AuthorIdentity): string;
+
+interface Blob {
+    readonly type: 'blob';
+    readonly id: ObjectId;
+    readonly content: Uint8Array;
+}
+declare function parseBlobContent(id: ObjectId, content: Uint8Array): Blob;
+declare function serializeBlobContent(blob: Blob): Uint8Array;
+
+/**
+ * Commit serializer. Produces the canonical Git commit-object payload
+ * (`tree <sha>\nparent <sha>*\nauthor …\ncommitter …\n\n<message>`) that
+ * sits inside a loose commit object. SHA equality is the contract;
+ * disk-bytes vary by zlib compression level (loose object caveat).
+ *
+ * @writes
+ *   surface: commit
+ *   kind:    equivalent-under-readback
+ *   format:  git-commit-object
+ */
+
+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 function parseCommitContent(id: ObjectId, content: Uint8Array): Commit;
+declare function serializeCommitContent(commit: Commit): Uint8Array;
+
+type ObjectType = 'blob' | 'tree' | 'commit' | 'tag';
+declare function parseHeader(rawBytes: Uint8Array): {
+    readonly type: ObjectType;
+    readonly size: number;
+    readonly contentOffset: number;
+};
+declare function serializeHeader(type: ObjectType, contentSize: number): Uint8Array;
+
+/**
+ * Tag serializer. Produces the canonical annotated-tag payload
+ * (`object <sha>\ntype <type>\ntag <name>\ntagger …\n\n<message>`) inside a
+ * loose tag object.
+ *
+ * @writes
+ *   surface: tag
+ *   kind:    equivalent-under-readback
+ *   format:  git-tag-object
+ */
+
+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;
+}
+declare function parseTagContent(id: ObjectId, content: Uint8Array): Tag;
+declare function serializeTagContent(tag: Tag): Uint8Array;
+
+interface TreeEntry {
+    readonly mode: FileMode;
+    readonly name: string;
+    readonly id: ObjectId;
+}
+interface Tree {
+    readonly type: 'tree';
+    readonly id: ObjectId;
+    readonly entries: ReadonlyArray<TreeEntry>;
+}
+declare function parseTreeContent(id: ObjectId, content: Uint8Array, hash: HashConfig): Tree;
+declare function serializeTreeContent(tree: Tree, hash: HashConfig): Uint8Array;
+declare function sortTreeEntries(entries: ReadonlyArray<TreeEntry>): ReadonlyArray<TreeEntry>;
+declare function treeEntryCompare(a: TreeEntry, b: TreeEntry): number;
+
+type GitObject = Blob | Tree | Commit | Tag;
+declare function parseObject(id: ObjectId, rawBytes: Uint8Array, hash: HashConfig): GitObject;
+declare function serializeObject(object: GitObject, hash: HashConfig): Uint8Array;
+
+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;
+}
+/** The common case — a freshly staged, materialised, stage-0 entry. */
+declare const STAGE0_FLAGS: IndexEntryFlags;
+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>;
+    /**
+     * Trailing hash bytes (SHA-1: 20 bytes, SHA-256: 32 bytes) that close the
+     * index file format. Read but historically discarded; surfaced here so
+     * `CachingIndexResolver` can use it for the racy-stat fallback path
+     * (compare trailing bytes when `(mtime, size, ino)` match an observed
+     * stat but the underlying file may have been mutated in the racy-stat
+     * window — see design §10.4). Empty (`Uint8Array(0)`) when constructed
+     * from the empty-index defaults in `readIndex` (no underlying file).
+     */
+    readonly trailerSha: Uint8Array;
+}
+interface StatData {
+    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;
+}
+declare function isStatClean(entry: IndexEntry, stat: StatData): boolean;
+/**
+ * Build a stage-0 index entry for a tree path that is absent from the working
+ * tree: every stat field zeroed, the `skipWorktree` flag set. `status` skips
+ * skip-worktree entries, so the zeroed stats are never consulted.
+ *
+ * Shared by the sparse-aware primitives (`materializeTree`,
+ * `buildIndexFromTree`) so the synthesised-entry shape lives in one place.
+ */
+declare const skipWorktreeEntry: (entry: {
+    readonly path: FilePath;
+    readonly id: ObjectId;
+    readonly mode: FileMode;
+}) => IndexEntry;
+
+/**
+ * Pure spanhash similarity scorer — git's diffcore-delta.c algorithm.
+ * I/O-free; never imports platform adapters.
+ *
+ * Algorithm (mirrors git's `hash_chars` + `diffcore_count_changes`):
+ * 1. Split each blob into chunks delimited by LF or up to 64 bytes, whichever
+ *    comes first (same rule git applies for text vs binary).
+ * 2. Hash each chunk with git's two-accumulator rolling hash and store its byte
+ *    count in a hash-map keyed by `(accum1 + accum2 * 0x61) % HASHBASE`.
+ * 3. For each chunk hash present in BOTH src and dst, count min(src_cnt, dst_cnt)
+ *    bytes as "copied".
+ * 4. score = (src_copied * MAX_SCORE) / max(src_size, dst_size)
+ */
+/** Raw score ceiling; mirrors git's MAX_SCORE = 60000. */
+declare const MAX_SCORE = 60000;
+/** Default rename threshold (50% of MAX_SCORE). */
+declare const DEFAULT_RENAME_THRESHOLD = 30000;
+/** Default -B break-attempt gate (50% of MAX_SCORE). */
+declare const DEFAULT_BREAK_SCORE = 30000;
+/** Default -B keep-broken gate (60% of MAX_SCORE). */
+declare const DEFAULT_MERGE_SCORE = 36000;
+/**
+ * Structured similarity datum shared by RenameChange, CopyChange, and the
+ * broken field on ModifyChange. score is in 0..MAX_SCORE; maxScore is always
+ * MAX_SCORE so callers can reconstruct the denominator.
+ */
+interface SimilarityScore {
+    readonly score: number;
+    readonly maxScore: number;
+}
+/**
+ * Estimate the similarity between two byte blobs using git's spanhash algorithm.
+ * Returns a raw score in 0..MAX_SCORE.
+ *
+ * Special cases:
+ * - Both empty → MAX_SCORE (identical trivially)
+ * - Identical content → MAX_SCORE (checked via reference equality for speed)
+ * - One empty, other non-empty → 0
+ */
+declare function estimateSimilarity(src: Uint8Array, dst: Uint8Array): number;
+/**
+ * Project a raw score to an integer percent, truncating (not rounding).
+ * Mirrors git's `(int)(score * 100 / MAX_SCORE)`.
+ */
+declare function toSimilarityPercent(score: number): number;
+
+type DiffChangeType = 'add' | 'delete' | 'modify' | 'rename' | 'type-change' | 'copy';
+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;
+    /** Dissimilarity datum when -B kept this modify broken. score = MAX_SCORE − similarity. */
+    readonly broken?: SimilarityScore;
+}
+interface RenameChange {
+    readonly type: 'rename';
+    readonly oldPath: FilePath;
+    readonly newPath: FilePath;
+    readonly oldId: ObjectId;
+    readonly newId: ObjectId;
+    readonly oldMode: FileMode;
+    readonly newMode: FileMode;
+    readonly similarity: SimilarityScore;
+}
+interface TypeChangeChange {
+    readonly type: 'type-change';
+    readonly path: FilePath;
+    readonly oldId: ObjectId;
+    readonly newId: ObjectId;
+    readonly oldMode: FileMode;
+    readonly newMode: FileMode;
+}
+interface CopyChange {
+    readonly type: 'copy';
+    readonly oldPath: FilePath;
+    readonly newPath: FilePath;
+    readonly oldId: ObjectId;
+    readonly newId: ObjectId;
+    readonly oldMode: FileMode;
+    readonly newMode: FileMode;
+    readonly similarity: SimilarityScore;
+}
+type DiffChange = AddChange | DeleteChange | ModifyChange | RenameChange | TypeChangeChange | CopyChange;
+interface TreeDiff {
+    readonly changes: ReadonlyArray<DiffChange>;
+}
+
+interface FlatTreeEntry {
+    readonly id: ObjectId;
+    readonly mode: FileMode;
+}
+interface FlatTree {
+    readonly entries: ReadonlyMap<FilePath, FlatTreeEntry>;
+}
+declare const MAX_FLAT_TREE_ENTRIES = 1000000;
+
+type WhitespaceMode = 'all' | 'change' | 'at-eol' | 'none';
+interface LineKey {
+    readonly mode: WhitespaceMode;
+    readonly ignoreCrAtEol: boolean;
+}
+declare function normalizeLine(bytes: Uint8Array, key: LineKey): Uint8Array;
+declare function linesEqualUnder(a: Uint8Array, b: Uint8Array, key: LineKey): boolean;
+declare function resolveLineKey(fields: {
+    readonly ignoreWhitespace?: 'all' | 'change' | 'at-eol';
+    readonly ignoreCrAtEol?: boolean;
+    readonly ignoreBlankLines?: boolean;
+}): LineKey;
+declare function lineKeyIsActive(key: LineKey): boolean;
+
+interface RenameDetectOptions {
+    readonly limit?: number;
+    readonly maxSameIdDeletes?: number;
+    readonly threshold?: number;
+    readonly copies?: 'off' | 'on' | 'harder';
+    /** Per-copy threshold (0..MAX_SCORE). Defaults to `threshold` when absent. */
+    readonly copyThreshold?: number;
+    /**
+     * Break-rewrite detection (-B).
+     * score: dissimilarity gate (>= score → attempt break; default DEFAULT_BREAK_SCORE).
+     * merge: keep-broken gate (>= merge → emit broken modify; default DEFAULT_MERGE_SCORE).
+     * A merge value of 0 maps to DEFAULT_MERGE_SCORE.
+     * false (default) → no break detection.
+     */
+    readonly breakRewrites?: {
+        readonly score: number;
+        readonly merge: number;
+    } | false;
+}
+declare function detectRenames(diff: TreeDiff, options?: RenameDetectOptions): TreeDiff;
+
+/**
+ * Per-file line counts for one changed path — the data half of git's
+ * `--numstat`. `binary` flags a file whose either side trips binary detection
+ * (then `added`/`deleted` are zero, matching git's `-`); otherwise the counts
+ * come from the line diff. The cosmetic graph (`--stat` widths, `Bin … bytes`)
+ * is the caller's to render from these counts plus the blob sizes.
+ */
+interface StatFields {
+    readonly added: number;
+    readonly deleted: number;
+    readonly binary: boolean;
+}
+/** A `DiffChange` carrying its per-file line counts (populated via `withStat`). */
+type StatDiffChange = DiffChange & StatFields;
+/** A tree diff whose every change carries `StatFields`. */
+interface StatTreeDiff {
+    readonly changes: ReadonlyArray<StatDiffChange>;
+}
+/** Options for `computeStatFields` controlling line normalization and blank suppression. */
+interface StatFieldsOptions {
+    readonly lineKey?: LineKey;
+    readonly ignoreBlankLines?: boolean;
+    /** Override the binary-vs-text decision for the numstat surface. `'binary'` ⇒
+     *  `{ added: 0, deleted: 0, binary: true }`; `'text'` ⇒ count lines even over NUL;
+     *  `undefined` ⇒ today's `isBinary` content-sniff. */
+    readonly numstatBinaryOverride?: 'binary' | 'text';
+}
+/**
+ * Count added/deleted lines between two blob contents. A binary side short-
+ * circuits to `{ 0, 0, binary: true }`; otherwise added lines are the
+ * theirs-only hunks and deleted lines the ours-only hunks of the line diff
+ * (`old` is ours, `next` is theirs).
+ *
+ * When `options.lineKey` is set the line-equality is whitespace-normalized.
+ * When `options.ignoreBlankLines` is true, hunks whose lines are all blank
+ * (empty after the active line-key normalization) do not contribute to counts.
+ */
+declare const computeStatFields: (old: Uint8Array, next: Uint8Array, options?: StatFieldsOptions) => StatFields;
+
+/**
+ * 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 `.gitattributes`, `.git/info/attributes`, and the global
+ * attributesFile. 1 MiB matches the `.gitignore` cap — both are small text
+ * files in practice; the guard only stops a pathological input.
+ */
+declare const MAX_GITATTRIBUTES_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>;
+}
+/**
+ * Options for `walkCommitsByDate` — the all-parents, commit-date-ordered history
+ * walk (newest committer-date first, oid-ascending tie-break). Mirrors the
+ * boundary/missing/hash knobs of {@link WalkCommitsOptions} but carries no
+ * `order`: the date order is the primitive's identity.
+ */
+interface WalkCommitsByDateOptions {
+    readonly from: ReadonlyArray<ObjectId>;
+    readonly until?: ReadonlyArray<ObjectId>;
+    /**
+     * Commits whose parents must NOT be walked (shallow boundary). The commit
+     * itself is still yielded — only its parents are skipped.
+     */
+    readonly shallow?: ReadonlySet<ObjectId>;
+    readonly ignoreMissing?: boolean;
+    readonly verifyHash?: boolean;
+}
+/** 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>;
+}
+interface CreateTagInput {
+    readonly object: ObjectId;
+    readonly objectType: ObjectType;
+    readonly tagName: string;
+    readonly tagger: AuthorIdentity;
+    readonly message: string;
+    readonly gpgSignature?: string;
+    readonly extraHeaders?: ReadonlyArray<ExtraHeader>;
+}
+type DiffTreesInput = Tree | ObjectId | undefined;
+interface DiffTreesOptions {
+    readonly detectRenames?: boolean;
+    readonly renameOptions?: RenameDetectOptions;
+    /**
+     * Recurse into sub-directories, surfacing nested blobs as full-path changes
+     * (git's recursive diff) instead of one change per top-level sub-tree. Both
+     * sides are flattened to full-path blob entries before classification.
+     */
+    readonly recursive?: boolean;
+    /**
+     * Attach per-file line counts (`added` / `deleted` / `binary`) to every change
+     * — the data half of git's `--numstat`. Off by default: the tree-level diff
+     * reads no blob contents; `withStat` opts into the line-level pass (blob loads +
+     * line diff), so the result is a `StatTreeDiff`.
+     */
+    readonly withStat?: boolean;
+    /**
+     * Whitespace normalization mode applied to line equality during diff. Mirrors
+     * git's `-w` (`'all'`), `-b` (`'change'`), and `--ignore-space-at-eol`
+     * (`'at-eol'`). Absent means exact byte comparison.
+     */
+    readonly ignoreWhitespace?: 'all' | 'change' | 'at-eol';
+    /**
+     * When true, a trailing CR immediately before the line terminator is ignored
+     * during line comparison. Mirrors git's `--ignore-cr-at-eol`.
+     */
+    readonly ignoreCrAtEol?: boolean;
+    /**
+     * When true, change groups consisting solely of blank lines are omitted from
+     * line counts and treated as no-change for the drop pass. Mirrors git's
+     * `--ignore-blank-lines`.
+     */
+    readonly ignoreBlankLines?: boolean;
+}
+/**
+ * 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;
+}
+
+/**
+ * Structured result returned by `bisectMidpoint`.
+ *
+ * Field semantics are faithful to `git rev-list --bisect-vars`:
+ *  - `candidateCount` = `bisect_all`
+ *  - `remainingIfGood` = `bisect_good` = candidateCount − reaches − 1
+ *    (negative sentinel −1 when candidateCount = 1, meaning "no candidates
+ *     remain if the midpoint tests good").
+ *  - `remainingIfBad` = `bisect_bad` = reaches − 1
+ *  - `remainingSteps` = `bisect_steps` = estimateSteps(candidateCount)
+ */
+interface BisectMidpoint {
+    readonly nextCommit: ObjectId;
+    readonly candidateCount: number;
+    /** Candidates still to test if `nextCommit` proves good; −1 when candidateCount = 1. */
+    readonly remainingIfGood: number;
+    /** Candidates still to test if `nextCommit` proves bad. */
+    readonly remainingIfBad: number;
+    /** Rough number of test rounds remaining; mirrors `git bisect_steps`. */
+    readonly remainingSteps: 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 { DEFAULT_BREAK_SCORE as D, FILE_MODE as F, MAX_PEEL_DEPTH as H, MAX_PUSH_OBJECTS as J, MAX_REFLOG_BYTES as K, MAX_COMMIT_MESSAGE_BYTES as M, MAX_SCORE as N, MAX_SUBMODULE_DEPTH as O, MAX_SYMBOLIC_REF_DEPTH as P, MAX_WALK_QUEUE_SIZE as Q, MAX_WALK_SEEDS as R, MAX_WORKING_TREE_BLOB_BYTES as S, STAGE0_FLAGS as Z, resolveLineKey as aA, serializeBlobContent as aB, serializeCommitContent as aC, serializeHeader as aD, serializeIdentity as aE, serializeObject as aF, serializeTagContent as aG, serializeTreeContent as aH, skipWorktreeEntry as aI, sortTreeEntries as aJ, toSimilarityPercent as aK, treeEntryCompare as aL, validateFileMode as aM, computeStatFields as aj, deriveWorkingMode as ak, detectRenames as al, estimateSimilarity as am, isDirectory as an, isStatClean as ao, lineKeyIsActive as ap, linesEqualUnder as aq, normalizeFileMode as ar, normalizeLine as as, parseBlobContent as at, parseCommitContent as au, parseHeader as av, parseIdentity as aw, parseObject as ax, parseTagContent as ay, parseTreeContent as az, DEFAULT_MERGE_SCORE as i, DEFAULT_RENAME_THRESHOLD as j, MAX_FLAT_TREE_ENTRIES as u, MAX_GITATTRIBUTES_BYTES as v, MAX_GITIGNORE_BYTES as w, MAX_GITMODULES_BYTES as x, MAX_HAVES as y, MAX_INDEX_BYTES as z };
+export type { StatData as $, AddChange as A, BisectMidpoint as B, CatFileBatchEntry as C, ExtraHeader as E, GitIndex as G, IndexEntryFlags as I, LineKey as L, ModifyChange as T, ObjectType as U, ReadObjectOptions as V, RenameChange as W, RenameDetectOptions as X, ResolveRefOptions as Y, SimilarityScore as _, AuthorIdentity as a, StatDiffChange as a0, StatFields as a1, StatFieldsOptions as a2, StatTreeDiff as a3, SubmoduleEntry as a4, Tag as a5, TagData as a6, Tree as a7, TreeDiff as a8, TypeChangeChange as a9, ConfigScope as aN, IndexEntry as aO, ConfigKey as aP, ReflogEntry as aQ, TreeEntry as aR, WalkIgnorePredicate as aS, UpdateRefOptions as aa, WalkCommitsByDateOptions as ab, WalkCommitsOptions as ac, WalkSubmodulesOptions as ad, WalkTreeEntry as ae, WalkTreeOptions as af, WalkWorkingTreeEntry as ag, WalkWorkingTreeOptions as ah, WhitespaceMode as ai, Blob as b, CatFileBatchOptions as c, Commit as d, CommitData as e, CopyChange as f, CreateCommitInput as g, CreateTagInput as h, DeleteChange as k, DiffChange as l, DiffChangeType as m, DiffTreesInput as n, DiffTreesOptions as o, FileMode as p, FlatTree as q, FlatTreeEntry as r, GitObject as s, IndexExtension as t };