@scolladon/tsgit 2.0.1 → 3.1.0

package/dist/types/primitives/index.d.ts

@@ -1,692 +1,4 @@
-import { G as GitIndex, I as IndexEntry } from '../chunks/index-entry-UD4dvtKh.js';
-import { c as FilePath, O as ObjectId, b as Context, j as RefName } from '../chunks/context-CCL0_F8R.js';
-import { F as FileMode, b as ConfigScope, c as ConfigKey, A as AuthorIdentity, R as ReflogEntry } from '../chunks/reflog-entry-CSzjnZd4.js';
-export { C as CatFileBatchEntry, d as CatFileBatchOptions, e as CreateCommitInput, D as DiffTreesInput, f as DiffTreesOptions, M as MAX_COMMIT_MESSAGE_BYTES, g as MAX_GITIGNORE_BYTES, h as MAX_GITMODULES_BYTES, i as MAX_HAVES, j as MAX_INDEX_BYTES, k as MAX_PEEL_DEPTH, l as MAX_PUSH_OBJECTS, m as MAX_REFLOG_BYTES, n as MAX_SUBMODULE_DEPTH, o as MAX_SYMBOLIC_REF_DEPTH, p as MAX_WALK_QUEUE_SIZE, q as MAX_WALK_SEEDS, r as MAX_WORKING_TREE_BLOB_BYTES, s as ReadObjectOptions, t as ResolveRefOptions, S as SubmoduleEntry, T as TreeDiff, U as UpdateRefOptions, W as WalkCommitsOptions, u as WalkIgnorePredicate, v as WalkSubmodulesOptions, w as WalkTreeEntry, x as WalkTreeOptions, y as WalkWorkingTreeEntry, z as WalkWorkingTreeOptions } from '../chunks/reflog-entry-CSzjnZd4.js';
-export { H as HashBlobOptions, z as HookInput, I as IsIgnoredMatch, A as IsIgnoredMatchSource, B as IsIgnoredQuery, S as SetEntryFlagsOptions, C as StageEntryOptions, D as StageEntrySource, U as UnstageEntryOptions, c as catFileBatch, a as createCommit, d as diffTrees, g as getRepoRoot, h as hashBlob, i as isIgnored, m as mergeBase, r as readBlob, b as readIndex, e as readObject, f as readTree, j as recordRefUpdate, k as resolveRef, l as runHook, s as setEntryFlags, E as sparseCheckoutPath, n as stageEntry, u as unstageEntry, o as updateRef, w as walkCommits, p as walkSubmodules, q as walkTree, t as walkWorkingTree, v as writeObject, x as writeSymbolicRef, y as writeTree } from '../chunks/write-tree-DRI-LzSr.js';
-import { H as HttpTransport } from '../chunks/http-transport--_NdQOiw.js';
-
-interface FlatTreeEntry {
-    readonly id: ObjectId;
-    readonly mode: FileMode;
-}
-interface FlatTree {
-    readonly entries: ReadonlyMap<FilePath, FlatTreeEntry>;
-}
-
-/** `true` ⇒ the path is in the sparse set (materialise it). */
-type SparseMatcher = (path: FilePath) => boolean;
-
-/**
- * Pure helper that diffs a current GitIndex against a target tree's flat
- * entry list and emits an ordered ChangesetEntry list. No FS, no ctx; the
- * impure write side lives in `apply-changeset.ts`.
- *
- * Stage-0 entries only — unmerged stages are invisible to checkout (Phase
- * 13.1 design step 5).
- */
-
-interface ChangesetEntry {
-    readonly kind: 'add' | 'update' | 'delete' | 'noop';
-    readonly path: FilePath;
-    readonly mode: FileMode;
-    readonly id: ObjectId | undefined;
-    readonly previousId: ObjectId | undefined;
-    readonly previousMode: FileMode | undefined;
-}
-interface ChangesetStats {
-    readonly add: number;
-    readonly update: number;
-    readonly delete: number;
-    readonly noop: number;
-}
-interface Changeset {
-    readonly entries: ReadonlyArray<ChangesetEntry>;
-    readonly stats: ChangesetStats;
-}
-interface TargetEntry {
-    readonly path: FilePath;
-    readonly id: ObjectId;
-    readonly mode: FileMode;
-}
-declare const computeChangeset: (currentIndex: GitIndex, targetTree: ReadonlyArray<TargetEntry>) => Changeset;
-
-interface ApplyChangesetOpts {
-    readonly changeset: Changeset;
-    readonly force: boolean;
-    readonly workdir: string;
-}
-interface ApplyChangesetResult {
-    readonly writtenEntries: ReadonlyArray<IndexEntry>;
-    readonly written: number;
-    readonly deleted: number;
-}
-/**
- * `true` when a working-tree file exists at `absPath` but its blob content
- * hash differs from `expectedId`. An absent file is not dirty. Shared by
- * `applySparseCheckout`'s narrowing pre-scan (design §9).
- */
-declare const isWorkingTreeDirty: (ctx: Context, absPath: string, expectedId: string) => Promise<boolean>;
-declare const applyChangeset: (ctx: Context, opts: ApplyChangesetOpts) => Promise<ApplyChangesetResult>;
-
-/**
- * Project a target tree onto a fresh stage-0 IndexEntry list, preserving
- * stat-cache fields from the prior index where the path's `id` AND `mode`
- * both match (the "stat-cache donor" strategy).
- *
- * Pure with respect to the working tree: this primitive never calls
- * `fs.lstat`, `fs.read`, or any working-tree-side API. It only reads git
- * objects via `walkTree` → `readObject` for nested trees.
- *
- * Used by `reset --mixed` to rebuild the index from a target
- * commit's tree. Will be re-used by `reset --hard` composed
- * with `materializeTree` to also write the working tree.
- *
- * ## Preconditions
- *
- * `currentIndex` MUST be read under the same `acquireIndexLock` that will
- * later commit the result. Reading the index BEFORE the lock is acquired
- * lets a concurrent writer mutate it between the donor-map build and the
- * commit, producing a result that reflects neither the pre-reset nor the
- * post-reset state. See `reset.ts:rebuildIndexFromCommit` for the
- * canonical pattern: acquire → read → build → commit → release-in-finally.
- */
-
-interface BuildIndexFromTreeOpts {
-    readonly targetTree: ObjectId;
-    readonly currentIndex: GitIndex;
-    /**
-     * Sparse-checkout filter. When supplied, an excluded path is rebuilt as a
-     * zero-stat skip-worktree entry and an in-pattern path has any stale
-     * skip-worktree bit cleared. `undefined` ⇒ sparse inactive — the rebuilt
-     * index is byte-identical to the non-sparse behaviour.
-     */
-    readonly sparse?: SparseMatcher;
-}
-declare const buildIndexFromTree: (ctx: Context, opts: BuildIndexFromTreeOpts) => Promise<ReadonlyArray<IndexEntry>>;
-
-interface BuildPackInput {
-    readonly oids: ReadonlyArray<ObjectId>;
-}
-interface BuildPackResult {
-    readonly bytes: Uint8Array;
-    /** Hex SHA of the pack body, also the trailer (last 20 bytes). */
-    readonly sha: string;
-    readonly objectCount: number;
-}
-declare const buildPack: (ctx: Context, input: BuildPackInput) => Promise<BuildPackResult>;
-
-/**
- * Single source of truth for "is this index entry dirty in the working tree?".
- *
- * Compares the working file at `entry.path` against the entry's `(id, mode)`:
- * `absent` when no working file exists, `modified` when the derived working
- * mode or the content hash differs, else `unchanged`. Content is hashed via the
- * uncapped `serializeAndHash` core (never the size-capped `hashBlob` write path),
- * so a read-only comparison never throws on a large working file. Symlink
- * content is its target (`readlink`), not the followed file.
- *
- * Consumed by `status` (reporting) and `rm` (the local-modification valve).
- */
-
-type WorkingTreeComparison = 'absent' | 'unchanged' | 'modified';
-declare const compareWorkingTreeEntry: (ctx: Context, entry: IndexEntry) => Promise<WorkingTreeComparison>;
-
-/**
- * Subset of `.git/config` that v1 commands consume. Only fields actually used by
- * commands are typed — the parser ignores everything else (lenient, like git itself).
- */
-interface ParsedConfig {
-    readonly core?: {
-        readonly bare?: boolean;
-        readonly excludesFile?: string;
-        readonly logAllRefUpdates?: boolean | 'always';
-        readonly hooksPath?: string;
-        readonly sparseCheckout?: boolean;
-        readonly sparseCheckoutCone?: boolean;
-    };
-    readonly user?: {
-        readonly name: string;
-        readonly email: string;
-    };
-    readonly remote?: ReadonlyMap<string, {
-        readonly url?: string;
-        /** `remote.<name>.pushurl` — push-only URL; `push` reads `pushUrl ?? url`. */
-        readonly pushUrl?: string;
-        readonly fetch?: ReadonlyArray<string>;
-        /** `remote.<name>.promisor` — true when this is a partial-clone promisor remote. */
-        readonly promisor?: boolean;
-        /** `remote.<name>.partialclonefilter` — the canonical filter spec applied at clone. */
-        readonly partialCloneFilter?: string;
-    }>;
-    readonly branch?: ReadonlyMap<string, {
-        readonly remote?: string;
-        readonly merge?: string;
-    }>;
-    /** `[extensions]` — `partialClone` names the promisor remote of a partial clone. */
-    readonly extensions?: {
-        readonly partialClone?: string;
-    };
-}
-/**
- * Read and cache `${gitDir}/config`. Missing → empty config (not an error).
- *
- * The cache is keyed on `Context` identity; a new context (e.g., after a write
- * that re-creates the repo) gets a fresh read. Concurrent calls share the same
- * in-flight promise (per-context single-flight).
- */
-declare const readConfig: (ctx: Context) => Promise<ParsedConfig>;
-/**
- * Drop the cached `readConfig` entry for a single `Context`. The production
- * invalidator: a config write (`updateCoreConfig`) calls this so a subsequent
- * `readConfig` on the same context re-reads the file instead of serving the
- * stale parse.
- */
-declare const invalidateConfigCache: (ctx: Context) => void;
-/**
- * One `[section "subsection"]` block of a git-config-format INI file: the
- * section name, an optional quoted subsection, and its key/value entries.
- * Exported so `.gitmodules` parsing — byte-identical grammar — reuses one
- * tokenizer (ADR-086).
- */
-interface IniSection {
-    readonly section: string;
-    readonly subsection: string | undefined;
-    readonly entries: ReadonlyArray<{
-        readonly key: string;
-        readonly value: string;
-    }>;
-}
-/**
- * Tokenize git-config-format INI text into its sections. Lenient, like git:
- * orphan and malformed lines are skipped; comments and backslash
- * continuations are honored.
- */
-declare const parseIniSections: (text: string) => ReadonlyArray<IniSection>;
-
-/**
- * Drop the per-scope sections cache for a single `Context`. Called by
- * `invalidateConfigCache` in `config-read.ts` so writers can invalidate both
- * caches atomically.
- */
-declare const invalidateScopedConfigCache: (ctx: Context) => void;
-/**
- * Read the raw IniSection array for a single config scope, or a scope-tagged
- * flat array merged in precedence order (`system → global → local → worktree`)
- * when `scope` is omitted.
- *
- * Per-Context, per-scope cached: a second call with the same `(ctx, scope)`
- * shares the in-flight promise of the first. `invalidateConfigCache(ctx)` (from
- * `config-read.ts`) drops the cached entries here too.
- *
- * In the merged-read path (`scope` omitted), scopes that are unavailable on
- * the current adapter (`CONFIG_SCOPE_NOT_AVAILABLE`, `CONFIG_SYSTEM_PATH_UNRESOLVED`)
- * are silently skipped — the caller gets whatever scopes the adapter can
- * actually surface. Single-scope calls raise instead, so the caller can react
- * to a missing scope explicitly.
- */
-declare const readConfigSections: ({ ctx, scope, }: {
-    readonly ctx: Context;
-    readonly scope?: ConfigScope;
-}) => Promise<ReadonlyArray<{
-    readonly scope: ConfigScope;
-    readonly section: IniSection;
-}>>;
-/**
- * Look up a single value for a fully-qualified key (`section.name` or
- * `section.subsection.name`). Behaviour:
- *
- * - When `scope` is provided, reads only that scope. If the key has more than
- *   one match in that scope, throws `CONFIG_MULTIPLE_VALUES` (carries `scope`).
- * - When `scope` is omitted, merges across the four scopes. Same multi-value
- *   throw if more than one entry matches anywhere across the merged view
- *   (without the `scope` discriminator).
- * - Absent key: returns `{ key, value: undefined }`; never throws.
- *
- * Branding: the returned `key` is the caller's input cast to `ConfigKey`;
- * `parseConfigKey` validates the string before this cast, so the brand is
- * load-bearing only at the type level.
- */
-declare const getConfigValue: ({ ctx, key, scope, }: {
-    readonly ctx: Context;
-    readonly key: string;
-    readonly scope?: ConfigScope;
-}) => Promise<{
-    readonly key: ConfigKey;
-    readonly value: string;
-    readonly scope: ConfigScope;
-} | {
-    readonly key: ConfigKey;
-    readonly value: undefined;
-}>;
-/**
- * Look up every value for a key. Returns matches in scope-precedence order
- * (and physical-file order within each scope). Empty array when the key is
- * absent. Never throws on multi-value.
- */
-declare const getAllConfigValues: ({ ctx, key, scope, }: {
-    readonly ctx: Context;
-    readonly key: string;
-    readonly scope?: ConfigScope;
-}) => Promise<{
-    readonly key: ConfigKey;
-    readonly values: ReadonlyArray<{
-        readonly value: string;
-        readonly scope: ConfigScope;
-    }>;
-}>;
-
-interface EnumeratePushObjectsInput {
-    /**
-     * Object ids the caller wants on the remote. Each MUST resolve to a
-     * commit or an annotated tag (tags are unwrapped to commits before the
-     * commit walk).
-     */
-    readonly wants: ReadonlyArray<ObjectId>;
-    /** Object ids the remote already has (server's advertised ref tips). */
-    readonly haves: ReadonlyArray<ObjectId>;
-    /** Hard cap on objects emitted. Defaults to MAX_PUSH_OBJECTS. */
-    readonly maxObjects?: number;
-}
-declare function enumeratePushObjects(ctx: Context, input: EnumeratePushObjectsInput): AsyncIterable<ObjectId>;
-
-/**
- * Enumerate every current ref: `HEAD`, loose refs under `.git/refs/**`, and
- * packed-refs entries — deduplicated. Used by `reflog expire` to seed the
- * reachable-commit walk; not on any hot path.
- */
-
-declare function enumerateRefs(ctx: Context): Promise<ReadonlyArray<RefName>>;
-
-interface FetchPackInput {
-    /** Advertised refs the caller wants. MUST be non-empty (server-side requirement). */
-    readonly wants: ReadonlyArray<ObjectId>;
-    /** Objects the caller already has (negotiation). Empty for clone, populated for fetch. */
-    readonly haves: ReadonlyArray<ObjectId>;
-    /** Negotiated capabilities (intersection of advertised + supported). */
-    readonly capabilities: ReadonlyArray<string>;
-    /** Base remote URL (the same URL passed to clone). */
-    readonly url: string;
-    /** Progress op label — clone uses 'clone:write-objects', fetch uses 'fetch:write-objects'. */
-    readonly progressOp: string;
-    /**
-     * Shallow clone depth. When set, sends `deepen N` and consumes the
-     * accompanying `shallow <oid>` / `unshallow <oid>` response block.
-     *
-     */
-    readonly depth?: number;
-    /**
-     * Partial-clone object filter — a canonical filter spec. When set, a
-     * `filter` line is emitted; the caller must have negotiated the `filter`
-     * capability.
-     */
-    readonly filter?: string;
-    /**
-     * When true, write an empty `pack-<sha>.promisor` sentinel beside the pack
-     * so the objects it references but omits are treated as promised.
-     */
-    readonly promisor?: boolean;
-}
-interface FetchPackResult {
-    readonly packPath: string;
-    readonly idxPath: string;
-    readonly objectCount: number;
-    /** Hex-encoded SHA of the pack trailer; also the on-disk filename stem. */
-    readonly packSha: string;
-    /** Commits the server advertised as new shallow boundaries (empty when depth is unset). */
-    readonly shallow: ReadonlyArray<ObjectId>;
-    /** Commits the server advertised as no-longer-shallow (empty when depth is unset). */
-    readonly unshallow: ReadonlyArray<ObjectId>;
-}
-declare const fetchPack: (ctx: Context, transport: HttpTransport, input: FetchPackInput) => Promise<FetchPackResult>;
-
-/**
- * Flatten a nested `Tree` object into the `FlatTree` shape that the
- * `mergeTrees` domain primitive consumes.
- *
- * Bridges `walkTree`'s iterator into the `FlatTree` Map of
- * `path → { id, mode }`. Consumed by `merge.ts`'s clean-merge tree walk
- * and by `rm`'s HEAD-vs-index staged-change check (the safety valve), so
- * it is exported from the primitives barrel.
- *
- * Pure with respect to the working tree — only reads git objects via
- * `walkTree`.
- */
-
-declare const flattenTree: (ctx: Context, treeId: ObjectId) => Promise<FlatTree>;
-
-/**
- * Compose `walkTree → computeChangeset → applyChangeset` to update the
- * working tree to a target tree's contents.
- *
- * - Branch switch mode: `paths === undefined` — diff the entire current
- *  index against the entire target tree.
- * - Path-restore mode: `paths !== undefined` — restrict both sides of
- *  the diff to those paths.
- *
- * Returns the new IndexEntry list for the caller to commit, plus
- * written/deleted counts. The primitive does NOT commit the index — the
- * caller decides.
- *
- * ## Stat-source contract for `newIndexEntries` (load-bearing for)
- *
- * - **Paths that were written/added** (`add` or `update` changeset entries):
- *  the IndexEntry carries **post-write `lstat`-derived stat fields**
- *  (ctime/mtime/dev/ino/uid/gid/fileSize). These reflect the file we just
- *  wrote, so the next `status` runs the fast `isStatClean` path.
- * - **Paths whose changeset classification was `noop`** (skipped — index
- *  already matched target by `id + mode`): the IndexEntry is the caller's
- *  `currentIndex` entry verbatim. Donor stats survive across the call.
- * - `reset --hard` therefore MUST set `forceRewriteAll: true` so every noop
- *  upgrades to update and the post-write stats land in the output. Without
- *  that, a locally-modified working-tree file that the index still records
- *  as clean would survive the reset, AND the donor stats would be stale
- *  relative to the actual disk state.
- */
-
-interface MaterializeTreeOpts {
-    readonly targetTree: ObjectId;
-    readonly currentIndex: GitIndex;
-    readonly force?: boolean;
-    readonly paths?: ReadonlySet<FilePath>;
-    /**
-     * When true, every target-tree path is written to the working tree
-     * unconditionally — even paths the index→target diff classified as `noop`
-     * (same `id` AND `mode`). Required by `reset --hard`, where the working
-     * tree may diverge from the index (uncommitted local modifications); the
-     * standard index→target diff cannot see that drift, so noops would skip
-     * paths the caller wants overwritten. Default `false` keeps the Phase
-     * 13.1 checkout behaviour: clean files are never spuriously rewritten.
-     */
-    readonly forceRewriteAll?: boolean;
-    /**
-     * Branch-switch sparse-checkout filter. Honoured ONLY when `paths` is
-     * undefined. A target-tree path the matcher rejects is NOT written to the
-     * working tree; its `newIndexEntries` record carries `skipWorktree: true`
-     * (the index keeps every path — git-faithful). A path the matcher accepts
-     * that the *current* index records as skip-worktree (absent on disk) is
-     * materialised even when its `id` matches, because the current index is
-     * filtered to drop skip-worktree entries before the diff — such a path
-     * classifies as `add`, never `noop`.
-     */
-    readonly sparse?: SparseMatcher;
-}
-interface MaterializeTreeResult {
-    readonly newIndexEntries: ReadonlyArray<IndexEntry>;
-    readonly written: number;
-    readonly deleted: number;
-}
-declare const materializeTree: (ctx: Context, opts: MaterializeTreeOpts) => Promise<MaterializeTreeResult>;
-
-/**
- * Hard cap on the `.git/info/sparse-checkout` file — 1 MiB, mirroring
- * `MAX_GITIGNORE_BYTES`. A plain literal (not `1024 * 1024`) so a boundary test
- * keyed on the constant cannot drift with an arithmetic mutation of it.
- */
-declare const MAX_SPARSE_PATTERN_FILE_BYTES = 1048576;
-/**
- * Read `.git/info/sparse-checkout` as UTF-8 text. An absent file yields
- * `undefined`; a file whose byte length exceeds
- * `MAX_SPARSE_PATTERN_FILE_BYTES` throws `SPARSE_PATTERN_FILE_TOO_LARGE`
- * (checked before decode so an over-cap file never reaches the decoder).
- */
-declare const readSparsePatternText: (ctx: Context) => Promise<string | undefined>;
-/**
- * Build the sparse matcher for the current repository. Returns `undefined`
- * when `core.sparseCheckout` is falsy/absent — sparse is inactive and callers
- * behave exactly as a non-sparse repo. When active, the matcher is parsed in
- * the mode `core.sparseCheckoutCone` dictates; a cone file that degrades to
- * non-cone matching logs one warning.
- */
-declare const loadSparseMatcher: (ctx: Context) => Promise<SparseMatcher | undefined>;
-
-/**
- * Committer identity for reflog entries: config `user.*` plus a fresh
- * timestamp, or a portable fallback when `user.*` is unset. Never throws —
- * reflog logging must not abort a ref update.
- */
-declare function resolveReflogIdentity(ctx: Context): Promise<AuthorIdentity>;
-
-/**
- * Thin I/O layer over `.git/logs/<ref>` reflog files. Append is the hot path;
- * whole-file rewrite and delete back the `reflog` command's expire / delete.
- */
-
-/** Append one entry to `ref`'s reflog, creating the file and parents as needed. */
-declare function appendReflog(ctx: Context, ref: RefName, entry: ReflogEntry): Promise<void>;
-/** Read `ref`'s reflog, oldest-first. Returns `[]` when the file is absent. */
-declare function readReflog(ctx: Context, ref: RefName): Promise<ReadonlyArray<ReflogEntry>>;
-/** Whether `ref` has a reflog file at all. */
-declare function reflogExists(ctx: Context, ref: RefName): Promise<boolean>;
-/** Replace `ref`'s reflog with exactly `entries`. Used by expire / delete. */
-declare function writeReflog(ctx: Context, ref: RefName, entries: ReadonlyArray<ReflogEntry>): Promise<void>;
-/** Remove `ref`'s reflog file. A no-op when the file is already absent. */
-declare function deleteReflog(ctx: Context, ref: RefName): Promise<void>;
-/** Every reflog under `.git/logs/`, each as the `RefName` it logs. */
-declare function listReflogs(ctx: Context): Promise<ReadonlyArray<RefName>>;
-
-/**
- * Read `.git/shallow`. Returns an empty set when the file does not exist or
- * contains no oids. Malformed lines are tolerated (skipped) — canonical
- * git behaves the same; a corrupted shallow file should not block a fetch.
- */
-declare const readShallow: (ctx: Context) => Promise<ReadonlySet<ObjectId>>;
-interface ShallowUpdate {
-    readonly shallow: ReadonlyArray<ObjectId>;
-    readonly unshallow: ReadonlyArray<ObjectId>;
-}
-/**
- * Apply a set of shallow / unshallow updates to `.git/shallow`. Writes
- * atomically via lock-rename; deletes the file when the resulting set is
- * empty.
- */
-declare const updateShallow: (ctx: Context, updates: ShallowUpdate) => Promise<void>;
-
-/**
- * Synthesise a nested `Tree` object from a flat `GitIndex` and return the
- * root tree's `ObjectId`. Sub-trees are written to the object store as a
- * side-effect of the recursive descent — only stage-0 entries contribute.
- *
- * Used by `checkout({ paths, source: 'index' })` to restore
- * the working tree from staged content even when the index has diverged
- * from HEAD via `add` / `rm`. The previous placeholder fell back to
- * HEAD's tree, which silently lost the divergence.
- *
- * The synthesis is the inverse of `buildIndexFromTree`:
- * "tree → index" and "index → tree" form a round-trip identity for any
- * stage-0-only index.
- *
- * Pure with respect to the working tree — never calls `fs.lstat`,
- * `fs.read`, or any working-tree-side API. Only writes git objects via
- * the existing `writeTree` primitive.
- *
- * ## Safety
- *
- * - **Path validation**:.7 hoisted segment-level validation into
- *  `parseIndex` (`src/domain/git-index/path-validator.ts`). Every
- *  `IndexEntry` reaching this primitive THROUGH THE CANONICAL PARSER
- *  carries a `FilePath` value already free of `..`, `.`, empty segments,
- *  and leading-slash absolute paths. However, the primitive is also
- *  reachable from callers that construct `IndexEntry` records outside
- *  the parser (test fixtures, in-memory adapters, future synthesisers).
- *  Defence-in-depth: every entry is re-validated here so the primitive
- *  stays safe even when the parser-trusted path is bypassed.
- * - **Depth cap**: synthesis bounds recursion at `MAX_TREE_DEPTH` (4096,
- *  matching git's canonical limit). The cap is enforced at the input
- *  boundary by counting slashes — by the time recursion would catch a
- *  pathological depth, the JS engine has already exhausted its call
- *  stack. Path validation does NOT subsume this check: a path can be
- *  safe segment-by-segment (no `..`/`.`/empty) and still be 10 000
- *  levels deep.
- */
-
-/**
- * Public entry: pass the `entries` array directly (typically
- * `index.entries`, but callers holding a filtered list may supply it
- * without wrapping in a fake `GitIndex`).
- */
-declare const synthesizeTreeFromIndex: (ctx: Context, entries: ReadonlyArray<IndexEntry>) => Promise<ObjectId>;
-
-/**
- * Targeted `.git/config` writer (ADR-082). tsgit has no general INI writer;
- * this performs line surgery that preserves comments, blank lines, key order,
- * casing of unrelated keys, and every other section byte-for-byte. It writes
- * one `key = value` per call under any `[section]` / `[section "subsection"]`.
- *
- * @writes
- *   surface: config
- *   kind:    readback-only
- *   format:  git-config-text
- */
-
-/**
- * Set `key` under `[section]` / `[section "subsection"]`, preserving every
- * other byte verbatim.
- *
- * - existing section with that key ⇒ its value is replaced;
- * - existing section without that key ⇒ a `\t<key> = <value>` line is
- *   inserted right after the header;
- * - no such section ⇒ `[section]\n\t<key> = <value>\n` is appended.
- */
-declare const setConfigEntryInText: (text: string, section: string, subsection: string | undefined, key: string, value: string) => string;
-/** `setConfigEntryInText` bound to the `[core]` section — kept for legacy callers. */
-declare const setCoreConfigEntryInText: (text: string, key: string, value: string) => string;
-/** One `key = value` write under `[section]` / `[section "subsection"]`. */
-interface ConfigEntry {
-    readonly section: string;
-    readonly subsection?: string;
-    readonly key: string;
-    readonly value: string;
-}
-/**
- * Read `${gitDir}/config` (a missing file is treated as `''`), fold
- * `setConfigEntryInText` over `entries`, write the result, and invalidate the
- * per-`Context` `readConfig` cache so a later read sees the new values.
- */
-declare const updateConfigEntries: (ctx: Context, entries: ReadonlyArray<ConfigEntry>) => Promise<void>;
-/** Fold a batch of `[core]` `key = value` writes via `updateConfigEntries`. */
-declare const updateCoreConfig: (ctx: Context, entries: Record<string, string>) => Promise<void>;
-/**
- * Mixed-operation batch entry. Folded over the on-disk text in order in
- * a single `writeUtf8`. Use this when `remote` CRUD needs a section-
- * remove paired with branch-referrer key removals in one atomic write.
- */
-type ConfigOperation = {
-    readonly kind: 'set';
-    readonly section: string;
-    readonly subsection?: string;
-    readonly key: string;
-    readonly value: string;
-} | {
-    /**
-     * Insert a fresh `key = value` line after the section header WITHOUT
-     * replacing any existing entry with the same key. Use for multi-value
-     * keys (`fetch`) where every call must yield an additional line.
-     */
-    readonly kind: 'appendEntry';
-    readonly section: string;
-    readonly subsection?: string;
-    readonly key: string;
-    readonly value: string;
-} | {
-    readonly kind: 'removeEntry';
-    readonly section: string;
-    readonly subsection?: string;
-    readonly key: string;
-} | {
-    readonly kind: 'removeSection';
-    readonly section: string;
-    readonly subsection?: string;
-} | {
-    readonly kind: 'renameSection';
-    readonly section: string;
-    readonly from: string;
-    readonly to: string;
-};
-declare const applyConfigOpInText: (text: string, op: ConfigOperation) => string;
-/**
- * Write a single `key = value` entry into the config file for the given scope
- * (default `'local'`). Re-runs of the same call with a different value
- * overwrite the existing entry in place (preserving comments and surrounding
- * content). The key is validated via `parseConfigKey` (throws
- * `CONFIG_KEY_INVALID` on a malformed input) and the value is validated by
- * `assertValueSafe` (throws `CONFIG_VALUE_INVALID` on a banned control char)
- * BEFORE any I/O — a rejected input never touches the file system.
- *
- * The branding on `ConfigKey` is enforced at the type level; this primitive
- * accepts a raw string and parses it internally so it can be used directly
- * from porcelain wrappers that hold un-branded callers' input.
- */
-declare const setConfigEntry: ({ ctx, key, value, scope, }: {
-    readonly ctx: Context;
-    readonly key: string;
-    readonly value: string;
-    readonly scope?: ConfigScope;
-}) => Promise<void>;
-/**
- * Remove a single `key = value` entry from the given scope. Idempotent — if
- * the key is absent the call is a no-op (no I/O). If the key appears more
- * than once in the targeted scope, throws `CONFIG_MULTIPLE_VALUES` with
- * `requested: 'remove'` (the caller should use `unsetAllConfigEntries` to
- * clear every occurrence).
- */
-declare const unsetConfigEntry: ({ ctx, key, scope, }: {
-    readonly ctx: Context;
-    readonly key: string;
-    readonly scope?: ConfigScope;
-}) => Promise<void>;
-/**
- * Remove every occurrence of `key` from the targeted scope. Idempotent — a
- * missing key produces no I/O. Unlike `unsetConfigEntry`, multi-valued keys
- * are explicitly supported: all matching lines are removed in a single
- * read-modify-write pass.
- */
-declare const unsetAllConfigEntries: ({ ctx, key, scope, }: {
-    readonly ctx: Context;
-    readonly key: string;
-    readonly scope?: ConfigScope;
-}) => Promise<void>;
-/**
- * Rename `[<section> "<oldSubsection>"]` to `[<section> "<newSubsection>"]`.
- * Both inputs are dotted (`'remote.origin'`). The two section families MUST
- * match — renaming across families (e.g. `remote.origin` → `branch.main`) is
- * rejected with `INVALID_OPTION`. Throws `CONFIG_SECTION_NOT_FOUND` if the
- * source section does not exist in the targeted scope.
- */
-declare const renameConfigSection: ({ ctx, oldName, newName, scope, }: {
-    readonly ctx: Context;
-    readonly oldName: string;
-    readonly newName: string;
-    readonly scope?: ConfigScope;
-}) => Promise<void>;
-/**
- * Delete `[<section> "<subsection>"]` and its body. `sectionName` is dotted
- * (`'remote.origin'`). Throws `CONFIG_SECTION_NOT_FOUND` when the section is
- * absent in the targeted scope.
- */
-declare const removeConfigSection: ({ ctx, sectionName, scope, }: {
-    readonly ctx: Context;
-    readonly sectionName: string;
-    readonly scope?: ConfigScope;
-}) => Promise<void>;
-
-/**
- * Write the `.git/info/sparse-checkout` pattern file. The command tier
- * computes the text (via `serializeCone` or raw non-cone lines); this
- * primitive only persists it (design §7.3).
- *
- * @writes
- *   surface: sparseCheckoutFile
- *   kind:    byte-identical
- *   format:  git-sparse-checkout
- */
-
-/**
- * Persist `text` to `.git/info/sparse-checkout`. The `.git/info` directory is
- * created defensively first — `writeUtf8` creates parents on every adapter,
- * but an explicit `mkdir` keeps the contract clear and survives adapters that
- * tighten that guarantee.
- */
-declare const writeSparsePatternText: (ctx: Context, text: string) => Promise<void>;
-
-export { MAX_SPARSE_PATTERN_FILE_BYTES, appendReflog, applyChangeset, applyConfigOpInText, buildIndexFromTree, buildPack, compareWorkingTreeEntry, computeChangeset, deleteReflog, enumeratePushObjects, enumerateRefs, fetchPack, flattenTree, getAllConfigValues, getConfigValue, invalidateConfigCache, invalidateScopedConfigCache, isWorkingTreeDirty, listReflogs, loadSparseMatcher, materializeTree, parseIniSections, readConfig, readConfigSections, readReflog, readShallow, readSparsePatternText, reflogExists, removeConfigSection, renameConfigSection, resolveReflogIdentity, setConfigEntry, setConfigEntryInText, setCoreConfigEntryInText, synthesizeTreeFromIndex, unsetAllConfigEntries, unsetConfigEntry, updateConfigEntries, updateCoreConfig, updateShallow, writeReflog, writeSparsePatternText };
-export type { ApplyChangesetOpts, ApplyChangesetResult, BuildIndexFromTreeOpts, BuildPackInput, BuildPackResult, Changeset, ChangesetEntry, ChangesetStats, ConfigEntry, EnumeratePushObjectsInput, FetchPackInput, FetchPackResult, IniSection, MaterializeTreeOpts, MaterializeTreeResult, ParsedConfig, WorkingTreeComparison };
+export { A as ApplyChangesetOpts, a as ApplyChangesetResult, B as BlobStream, b as BuildIndexFromTreeOpts, c as BuildPackInput, d as BuildPackResult, C as Changeset, e as ChangesetEntry, f as ChangesetStats, g as ConfigEntry, D as DEFAULT_NOTES_REF, E as EnumerateObjectsOptions, h as EnumeratePushObjectsInput, F as FetchPackInput, i as FetchPackResult, H as HashBlobOptions, j as HookInput, I as IniSection, k as IsIgnoredMatch, l as IsIgnoredMatchSource, m as IsIgnoredQuery, L as LoadedNotesTree, M as MAX_SPARSE_PATTERN_FILE_BYTES, n as MaterializeTreeOpts, o as MaterializeTreeResult, p as MergeBaseOptions, P as ParsedConfig, q as PushDefaultMode, S as SignPayloadResult, r as SignRequest, s as StreamBlobOptions, V as ValuelessEntry, W as WorkingTreeComparison, t as WorkingTreeDelta, u as WriteNotesTreeInput, v as appendReflog, w as applyChangeset, x as applyConfigOpInText, y as bisectMidpoint, z as buildIndexFromTree, G as buildPack, J as catFileBatch, K as compareWorkingTreeDelta, N as compareWorkingTreeEntry, O as computeChangeset, Q as createCommit, R as createTag, T as deleteReflog, U as diffTrees, X as enumerateObjects, Y as enumeratePushObjects, Z as enumerateRefs, _ as fetchPack, $ as findFirstValuelessEntry, a0 as flattenTree, a1 as getAllConfigValues, a2 as getConfigValue, a3 as getRepoRoot, a4 as hasObject, a5 as hashBlob, a6 as invalidateConfigCache, a7 as invalidateScopedConfigCache, a8 as isIgnored, a9 as isWorkingTreeDirty, aa as listReflogs, ab as loadNotesTree, ac as loadSparseMatcher, ad as materializeTree, ae as materializeWorktreeFromHead, af as mergeBase, ag as parseIniSections, ah as readBlob, ai as readConfig, aj as readConfigSections, ak as readHeadTree, al as readIndex, am as readObject, an as readReflog, ao as readShallow, ap as readSparsePatternText, aq as readTree, ar as reflogExists, as as removeConfigSection, at as renameConfigSection, au as resolveNotesRef, av as resolveRef, aw as resolveReflogIdentity, ax as resolveSigningSelector, ay as runHook, az as runInformationalHook, aA as setConfigEntry, aB as setConfigEntryInText, aC as setCoreConfigEntryInText, aD as signPayload, aE as sparseCheckoutPath, aF as streamBlob, aG as synthesizeTreeFromIndex, aH as unsetAllConfigEntries, aI as unsetConfigEntry, aJ as updateConfigEntries, aK as updateCoreConfig, aL as updateRef, aM as updateShallow, aN as walkCommits, aO as walkCommitsByDate, aP as walkSubmodules, aQ as walkTree, aR as walkWorkingTree, aS as writeNotesTree, aT as writeObject, aU as writeReflog, aV as writeSparsePatternText, aW as writeTree } from '../chunks/index-B_A8VLaf.js';
+export { B as BisectMidpoint, C as CatFileBatchEntry, c as CatFileBatchOptions, g as CreateCommitInput, h as CreateTagInput, n as DiffTreesInput, o as DiffTreesOptions, M as MAX_COMMIT_MESSAGE_BYTES, v as MAX_GITATTRIBUTES_BYTES, w as MAX_GITIGNORE_BYTES, x as MAX_GITMODULES_BYTES, y as MAX_HAVES, z as MAX_INDEX_BYTES, H as MAX_PEEL_DEPTH, J as MAX_PUSH_OBJECTS, K as MAX_REFLOG_BYTES, O as MAX_SUBMODULE_DEPTH, P as MAX_SYMBOLIC_REF_DEPTH, Q as MAX_WALK_QUEUE_SIZE, R as MAX_WALK_SEEDS, S as MAX_WORKING_TREE_BLOB_BYTES, V as ReadObjectOptions, Y as ResolveRefOptions, a4 as SubmoduleEntry, a8 as TreeDiff, aa as UpdateRefOptions, ab as WalkCommitsByDateOptions, ac as WalkCommitsOptions, aS as WalkIgnorePredicate, ad as WalkSubmodulesOptions, ae as WalkTreeEntry, af as WalkTreeOptions, ag as WalkWorkingTreeEntry, ah as WalkWorkingTreeOptions } from '../chunks/reflog-entry-Cqh3QrPH.js';
+import '../chunks/context-sIhhtk2u.js';
+import '../chunks/http-transport-DirKfK2S.js';