wingfoil 0.2.1 → 0.3.0

package/dist/storage/commit.d.ts

@@ -1,7 +1,39 @@
+import { StorageError } from './errors';
 /** Options for {@link commitPaths} — carries the git-author/env override used by callers (e.g. task-029's wizard). */
 export interface CommitOptions {
     /** Additional environment for the git invocations (merged over `process.env`). */
     readonly env?: NodeJS.ProcessEnv;
+    /**
+     * The commit's author, passed to git as `GIT_AUTHOR_NAME` / `GIT_AUTHOR_EMAIL` in its environment,
+     * over `process.env` and over any `GIT_AUTHOR_*` in {@link CommitOptions.env}. Set by a caller that
+     * has already checked an identity and must record exactly that one (task-132, `bug-149`); absent,
+     * git resolves the author itself. The environment, not `--author "<name> <<email>>"`: git re-parses
+     * that string, so a `<` in the name moved the email it recorded (task-132 review, finding 2).
+     */
+    readonly author?: {
+        readonly name: string;
+        readonly email: string;
+    };
+    /**
+     * The success warnings the operation has collected before it commits (task-210 review, F4). The real
+     * run ignores them — the operation reports them itself — while a dry run, which stops at the commit,
+     * carries them into its result, so `--dry-run` warns about what the real run would warn about.
+     */
+    readonly warnings?: readonly string[];
+    /**
+     * {@link CommitOptions.warnings} as a dry run words them, when a warning reports something done ("was
+     * rewritten") that a plan only intends ("would be rewritten"). Absent, a dry run carries `warnings`.
+     */
+    readonly plannedWarnings?: readonly string[];
+    /**
+     * Trailer lines (`Key: value`) the commit records in its **final** paragraph, before the
+     * `WingFoil-Version:` line ({@link stampedMessage}) — the one paragraph git reads trailers from
+     * (`%(trailers)`). `workflow finalize`'s phase-record trailers (`spec-003` § "Evidence", task-226) and
+     * `memory add --workflow`'s step linkage (task-227, `spec-017` §4.8) ride here: in a paragraph of their
+     * own before the signature, git would not read them. Absent or empty, the message is exactly what it was
+     * before.
+     */
+    readonly trailers?: readonly string[];
 }
 /**
  * Stage exactly `paths` (root-relative or absolute; each passed verbatim after `--` so a path that
@@ -10,16 +42,103 @@ export interface CommitOptions {
  * neither committed nor unstaged (bug-027) — this also holds for the first commit of an empty
  * repository (`wingfoil init`).
  *
+ * **What the commit records is `message` plus the build signature** (task-192, `dl-111`): a final
+ * trailer paragraph `WingFoil-Version: <semver> (<sha>)` ({@link stampedMessage}), so every commit
+ * WingFoil writes says which build wrote it and a hand-written one carries no such line. The body is
+ * normalized by `--cleanup=whitespace`, pinned rather than inherited from `commit.cleanup`
+ * (`bug-051`). Callers keep returning their own `message` in `CoreResult.commit`; the signature is
+ * this primitive's, not the operation's.
+ *
  * Determinism note (REQ-SYS-07): a git commit's sha necessarily incorporates the author/commit
  * timestamp, so two runs produce different shas — that is inherent to *creating* history and is not
  * a context-building read path (the determinism rule targets read/derivation paths, e.g.
  * `computeStateSnapshot`), so it is correct and intended here.
  *
+ * A mutating operation commits through {@link writeAndCommit}, which writes, commits and undoes a
+ * refused commit in one place; during a dry run this function throws instead of committing (task-210).
+ *
  * @throws whatever `git` raises (via `execFileSync`) — e.g. nothing staged to commit, or `root` is
  *   not a git repository. Callers that must translate those into a `CoreResult` do so at their layer
  *   (see `src/core/init.ts`); this primitive stays a thin, throwing mechanism by design.
  */
 export declare function commitPaths(root: string, paths: readonly string[], message: string, options?: CommitOptions): string;
+/**
+ * The root-relative paths the index holds a change to, against `HEAD` (`git diff --cached --name-only`),
+ * in git's order — what a plain `git commit` would record. Empty when the index matches `HEAD`.
+ */
+export declare function stagedPaths(root: string, options?: CommitOptions): string[];
+/**
+ * Make one commit that changes **no file** — `workflow finalize`'s phase record (`spec-017` §7.9, task-226) —
+ * with `message`, {@link CommitOptions.trailers} and the build signature in its final paragraph, returning
+ * its sha. The commit primitive's third form, beside {@link writeAndCommit}:
+ *
+ * - **`git commit --only --allow-empty`, no pathspec** — git's documented form for an empty commit that
+ *   records nothing the index holds: a change the operator staged is neither committed nor unstaged
+ *   (`bug-027`, `dl-106`), even when a caller skipped the dirty-index guard (`requireCleanIndex`,
+ *   `src/core/write-guard.ts`) that refuses it first.
+ * - **`--cleanup=whitespace`** pinned over `commit.cleanup` (`bug-051`), as for every tool commit.
+ * - **Dry run** (`dl-106` W2): inside `captureDryRun` nothing is committed; the plan is the subject, the
+ *   full message, no paths and no diff.
+ *
+ * @throws {@link CommitFailure} (`E_COMMIT_FAILED`) when git does not make the commit (a refusing hook);
+ *   nothing was written, so there is nothing to put back.
+ */
+export declare function commitEmpty(root: string, message: string, options?: CommitOptions): string;
+/**
+ * One path a write changes: its new `content`, or `null` to delete it. `path` is root-relative or
+ * absolute, as {@link commitPaths} accepts it.
+ */
+export interface PathChange {
+    readonly path: string;
+    readonly content: string | null;
+}
+/**
+ * Write `changes` and commit exactly those paths as one commit with `message`, returning its sha — the
+ * single primitive every mutating operation writes through (task-210), so that two behaviours are
+ * implemented once for all of them:
+ *
+ * - **Dry run** (`dl-106` W2, `spec-008` §2 `--dry-run`). Inside `captureDryRun` (`./dry-run`), nothing
+ *   is written: the commit the call would make — subject, full message with the `WingFoil-Version:`
+ *   trailer, sorted root-relative paths, and the diff from `HEAD` to the blobs it would record
+ *   (`planDiff`) — is recorded with {@link CommitOptions.warnings}, and the operation stops here. Every
+ *   guard and refusal the operation runs before its write has already run, so a dry run of a refused
+ *   operation is refused the same way.
+ * - **A failed commit leaves nothing behind** (`bug-217`). When writing a file or git's `add`/`commit`
+ *   fails (a refusing hook, a full disk, an unparseable author date, a held `index.lock`), the working
+ *   tree is put back first — a created file is deleted, then every directory the write created, deepest
+ *   first across all paths; an overwritten or deleted file gets its bytes back — and then, when it
+ *   differs from what it was, the index entry of every path, whatever the operator had staged there. So
+ *   a retry of `memory add` gets the same id and nothing rides into the operator's next commit. A git
+ *   failure is then reported as {@link CommitFailure} (`E_COMMIT_FAILED`), naming the paths repository-
+ *   relative and quoting git's explanation with the project root removed — and, if the index could not
+ *   be put back, saying so. A filesystem failure is rethrown as it was raised (the index is untouched by
+ *   then).
+ *
+ * Callers run their confinement and dirty-target guards before calling: this primitive writes where it
+ * is told.
+ */
+export declare function writeAndCommit(root: string, changes: readonly PathChange[], message: string, options?: CommitOptions): string;
+/**
+ * `E_COMMIT_FAILED` (task-210, `bug-217`): git did not make the commit of a write, and
+ * {@link writeAndCommit} has put the working tree back. Carries its parts so a caller that must word
+ * the failure differently (approve's supersede recovery) does not parse the message.
+ */
+export declare class CommitFailure extends StorageError {
+    /** The repository-relative paths the commit would have contained. */
+    readonly paths: readonly string[];
+    /** git's explanation, on one line, with the project root removed. */
+    readonly gitDetail: string;
+    /** Why the index entries could not be put back, when they could not; `undefined` when they were. */
+    readonly indexProblem: string | undefined;
+    constructor(root: string, paths: readonly string[], raw: string, indexProblem: string | undefined);
+}
+/**
+ * The reason a caller quotes for a failed write it reports in its own words (approve's supersede
+ * recovery, task-210 review F5): for a {@link CommitFailure}, `E_COMMIT_FAILED: git did not commit
+ * <paths>: <explanation>` — without the clause saying the working tree is as it was, which such a caller
+ * is about to make untrue — plus the index problem, if any; for anything else, `String(error)`.
+ */
+export declare function commitFailureSummary(error: unknown): string;
 /**
  * git's canonical empty tree object, the same on every repository (`git hash-object -t tree
  * /dev/null`). Used as the parent of a **root** commit so "what changed between this commit and its
@@ -27,15 +146,49 @@ export declare function commitPaths(root: string, paths: readonly string[], mess
  */
 export declare const EMPTY_TREE_SHA = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 /**
- * The content of `path` at revision `rev`, or `null` when the path does not exist there (git exits
- * non-zero, which `execFileSync` raises).
+ * The content of `path` at revision `rev`, or `null` when git answers with its `fatal:` exit `128`:
+ * the path is absent there, or `rev` does not resolve (or `root` is no repository).
+ *
+ * Read through `runGitRead` (`./git-read`, task-142 review): stderr is captured, never inherited, and
+ * the buffer is `GIT_READ_MAX_BUFFER`. Before, a document past Node's 1 MiB default made
+ * `execFileSync` throw `ENOBUFS` and a blanket `catch` answered `null` — "absent" for a document that
+ * is there, which `memory amend`, the loaders and the write guard turned into a wrong refusal. A
+ * failure that is not git's answer — git that cannot be spawned, an answer past the buffer — now
+ * throws `StorageError` `E_GIT_READ_FAILED`. Exit `128` stays `null`: git gives it to an absent path
+ * and to an unreadable object alike, and this read does not tell them apart.
  *
  * `rev` is any revision git accepts before a `:` — a sha, `HEAD`, or the index stage `:0`, which is
  * how a caller reads what the user has **staged** as opposed to what is in the working tree. The two
  * can disagree, and the difference is load-bearing: `git add` would silently replace a staged version
  * with the working-tree one.
+ *
+ * @throws {@link StorageError} `E_GIT_READ_FAILED` when git cannot be spawned or its answer exceeds
+ *   the read buffer (task-142 review).
  */
 export declare function readPathAtRev(root: string, rev: string, path: string, options?: CommitOptions): string | null;
+/**
+ * Whether `content`, put through the filters git applies when it stores `path` (`core.autocrlf`,
+ * `.gitattributes` `eol`/`text`/`filter`), is exactly the blob `rev` holds at `path` — git's own
+ * answer to "is this what was committed", rather than a byte comparison with `git show`, which on a
+ * machine that normalizes line endings sees an LF blob where the working tree holds CRLF (task-193
+ * review). Compares object ids: `git hash-object --path=<path> --stdin` of the bytes against
+ * `git rev-parse <rev>:<path>`. `false` when `rev` does not hold `path`.
+ *
+ * @param root - The repository.
+ * @param rev - The revision whose blob is compared (a commit sha).
+ * @param path - Root-relative path, which selects the filters as well as the blob.
+ * @param content - The text as it was written to the working tree.
+ * @param options - {@link CommitOptions} (the environment git runs with).
+ */
+export declare function committedBlobMatches(root: string, rev: string, path: string, content: string, options?: CommitOptions): boolean;
+/**
+ * Whether git would store `content`, written to the working tree at `path`, as exactly the blob
+ * `blob` — `content` put through the filters git applies to `path` (`core.autocrlf`, `.gitattributes`),
+ * `blob` taken as-is. The counterpart of {@link committedBlobMatches} for a blob that exists only in
+ * memory (`memory submit`'s rendering of the committed document, task-209 review F1): it compares
+ * `git hash-object --path=<path> --stdin` with `git hash-object --no-filters --stdin`.
+ */
+export declare function storesAsBlob(root: string, path: string, content: string, blob: string, options?: CommitOptions): boolean;
 /**
  * The two-character `git status --porcelain` code for `path` (index status, then working-tree
  * status), or the empty string when the path is clean — unmodified in both, and tracked.
@@ -86,7 +239,161 @@ export declare function changedPathsBetween(root: string, from: string, to: stri
  * @param prefix - Root-relative directory to limit the listing to; **omitted or empty lists the whole
  *   tree**, because `git ls-tree -- ''` is an error rather than a match-all. Passed verbatim after
  *   `--`, so a path that looks like a flag is never misread.
- * @returns The paths, or `null` when `rev` does not resolve.
+ * @returns The paths, or `null` when `rev` does not resolve (git's exit `128`).
+ * @throws {@link StorageError} `E_GIT_READ_FAILED` when git cannot be spawned or its answer exceeds
+ *   the read buffer (task-142 review).
  */
 export declare function listPathsAtRev(root: string, rev: string, prefix?: string, options?: CommitOptions): string[] | null;
+/** One blob {@link listBlobEntriesAtRev} lists: its path, and whether git records it as a symbolic link. */
+export interface BlobEntry {
+    readonly path: string;
+    /** Mode `120000`: the blob holds the link's target text, not a file's content (task-171, `bug-189`). */
+    readonly symlink: boolean;
+}
+/**
+ * {@link listPathsAtRev} with each blob's kind: the same paths, in the same order, each marked when git
+ * records it as a **symbolic link** (mode `120000`). A link is a blob, so `listPathsAtRev` lists it and
+ * `readPathAtRev` reads back its target text; a reader that must not take that text for a document
+ * (the Memory scan, task-171, `bug-189`) asks here instead. Same `null` and same errors as
+ * {@link listPathsAtRev}.
+ */
+export declare function listBlobEntriesAtRev(root: string, rev: string, prefix: string, options?: CommitOptions): BlobEntry[] | null;
+/**
+ * The full 40-hex sha of the **commit** `rev` names, or `null` when it names none: an unknown name, an
+ * unborn `HEAD` in a repository with no commits, a tree or a blob (`git rev-parse --verify --quiet`
+ * exits `1` for all of them).
+ *
+ * The `…AtRev` readers (`src/core/loaders.ts`, `src/memory/query.ts`) resolve their revision through
+ * this **once**, then read every byte at the sha, so one read cannot mix two commits when a ref moves
+ * while it runs. `^{commit}` peels a tag to its commit and refuses anything that is not one.
+ *
+ * **A failure is not "no such commit"** (task-137 review): a `root` git cannot read as a repository
+ * (exit `128`) or a `git` that cannot be spawned throws {@link StorageError} `E_GIT_READ_FAILED`, so a
+ * caller never reports a broken environment as a missing revision.
+ *
+ * The syntax of `rev` is the caller's to check — the core resolver (`resolveRevision`,
+ * `src/core/revision.ts`) refuses a malformed one before it gets here, so that nothing shaped like a
+ * flag ever reaches git's argument list.
+ *
+ * @throws {@link StorageError} `E_GIT_READ_FAILED` when git cannot answer at all.
+ */
+export declare function resolveCommitAtRev(root: string, rev: string, options?: CommitOptions): string | null;
+/**
+ * The content of each of `paths` at revision `rev`, in input order — the bytes as UTF-8, or `null` when
+ * the revision does not hold that path as a **file** — read through **one** `git cat-file --batch`
+ * process instead of one `git show` per path. For a file or an absent path that is what
+ * {@link readPathAtRev} answers; for a directory it is `null`, where `git show` would print the tree's
+ * listing, which is no file's content.
+ *
+ * Why it exists (task-137): `spec-017` §1.1 reads every Memory document at `HEAD` on every workflow
+ * read, and `spec-012` builds an agent context from a commit. On this repository's 664 Memory and plan
+ * documents one `git show` per file took 5.49 s, the batch 0.39 s (task-137 design notes).
+ *
+ * **Fails closed.** A batch that cannot run, exits non-zero or answers past
+ * {@link BATCH_READ_MAX_BUFFER} throws {@link StorageError} `E_GIT_READ_FAILED`: a failed read must not
+ * pass for "every path is absent". `null` is reserved for a path the revision really does not hold.
+ *
+ * A path holding a newline or a carriage return cannot travel on the line-based batch protocol (git
+ * ends the request at the newline and strips a trailing CR); it is read on its own with
+ * {@link readPathAtRev}, which gives the same answer. Pass a resolved sha as `rev` when several calls
+ * must see one commit.
+ *
+ * @param root - Project root (the git repository).
+ * @param rev - A revision naming one commit — best a sha already resolved (`resolveCommitAtRev`). It
+ *   travels inside each request line, so a rev holding a newline, a carriage return, a `:` or a NUL is
+ *   refused with {@link StorageError} `E_INVALID_REVISION`: a newline would shift every answer onto
+ *   the wrong path, and a `:` would change which path is read.
+ * @param paths - Root-relative POSIX paths.
+ * @returns One entry per path, in the same order.
+ * @throws {@link StorageError} `E_INVALID_REVISION` for such a rev; `E_GIT_READ_FAILED` when the
+ *   batch read fails.
+ */
+export declare function readPathsAtRev(root: string, rev: string, paths: readonly string[], options?: CommitOptions): (string | null)[];
+/** One `<rev>:<path>` read of {@link readRevisionPaths}. */
+export interface RevisionPath {
+    /** A revision naming one commit: a sha, or an expression over one (`<sha>^1`). */
+    readonly rev: string;
+    /** Root-relative POSIX path. */
+    readonly path: string;
+}
+/**
+ * The content of each `<rev>:<path>` request — each at its OWN revision — in input order: the bytes as
+ * UTF-8, or `null` when that revision does not hold that path as a file, a revision that names no
+ * commit included (the first parent of a root commit, `<sha>^1`). The many-revision counterpart of
+ * {@link readPathsAtRev}, with its answers and its refusals, in **one** `git cat-file --batch`.
+ *
+ * Why it exists (`task-278`, `bug-308`): `reconstructMemoryTransitions` (`src/memory/audit.ts`) reads
+ * a document at every commit of its history AND at each commit's first parent; one `git show` per
+ * read would double the spawns of the governance check's slowest path, a batch replaces them all.
+ *
+ * @param root - Project root (the git repository).
+ * @param requests - The revisions and paths to read.
+ * @param options - {@link CommitOptions} (the environment git runs with).
+ * @returns One entry per request, in the same order.
+ * @throws {@link StorageError} `E_INVALID_REVISION` for a rev holding a newline, a carriage return, a
+ *   `:` or a NUL; `E_GIT_READ_FAILED` when the batch read fails.
+ */
+export declare function readRevisionPaths(root: string, requests: readonly RevisionPath[], options?: CommitOptions): (string | null)[];
+/**
+ * Every **file** any of `revs` holds under `prefix`, as one sorted, de-duplicated list of
+ * root-relative POSIX paths — the union of {@link listPathsAtRev} over `revs`, read in a number of git
+ * processes that does not depend on how many revisions there are (`bug-178`, absorbed by `task-142`).
+ *
+ * `memory add`'s id counter reads every local branch and remote-tracking ref (`dl-101` §2 (a)); one
+ * `git ls-tree` per ref made its cost grow with the clone's branch count. Here one
+ * `git cat-file --batch` resolves every revision's tree at `prefix`, and each further level of the
+ * directory costs one more batch, asking only for the subtrees no earlier answer already held — so the
+ * process count is the depth of the directory under `prefix` plus one, and branches that share a
+ * subtree (most of them, most of the time) read it once.
+ *
+ * It answers what {@link listPathsAtRev} answers, unioned — compared case by case in
+ * `test/storage/list-paths-at-revs.test.ts` rather than claimed by construction: blobs only (a symbolic
+ * link is a blob, a gitlink is not a file), a subtree recognised by its mode's **type bits** so a
+ * legacy zero-padded `040000` is still a directory, the path bytes as UTF-8, sorted (REQ-SYS-07). The
+ * prefix is taken in canonical spelling — leading `./` segments and trailing `/` are dropped — and a
+ * prefix naming a file lists that file unless it ends in `/`. Other non-canonical spellings (`..`,
+ * `//` inside) are not normalised, and `ls-tree`'s pathspec matching may answer them differently.
+ *
+ * @param root - Project root (the git repository).
+ * @param revs - Revisions naming commits — best full shas. One that names no commit fails the read.
+ * @param prefix - Root-relative directory or file, canonical spelling (see above); empty lists whole trees.
+ * @returns The union of the paths, sorted.
+ * @throws {@link StorageError} `E_GIT_READ_FAILED` when a revision names no commit or tree, or the
+ *   batch read fails; `E_INVALID_REVISION` for a revision that cannot travel on the batch protocol.
+ */
+export declare function listPathsAtRevs(root: string, revs: readonly string[], prefix?: string, options?: CommitOptions): string[];
+/** A blob a revision holds under a directory: its path, its object name, and whether it is a link. */
+export interface BlobAtRev extends BlobEntry {
+    /** The blob's object name: equal oids are equal bytes, so a reader parses each distinct one once. */
+    readonly oid: string;
+}
+/**
+ * The blobs each of `revs` holds under `directory`, one sorted list per revision, in input order —
+ * {@link listPathsAtRevs}' batched walk (task-142, `bug-178`), keeping per revision what it holds and
+ * each blob's oid. The walk asks one `git cat-file --batch` per directory level for the trees no earlier
+ * answer held, so revisions that share a subtree read it once, and the process count is the directory's
+ * depth plus one whatever the number of revisions (task-274, the WIP-limit count across refs).
+ *
+ * A revision without `directory` holds nothing there. Gitlinks are skipped; a symbolic link is listed,
+ * marked. `directory` is root-relative, without a trailing `/`; empty means the whole tree.
+ *
+ * @throws {@link StorageError} `E_INVALID_REVISION` for a revision that cannot travel on the batch
+ *   protocol; `E_GIT_READ_FAILED` when a revision names no commit or tree, or the batch read fails.
+ */
+export declare function listBlobsAtRevs(root: string, revs: readonly string[], directory: string, options?: CommitOptions): BlobAtRev[][];
+/**
+ * The content of each blob `oids` names, as UTF-8, read through one `git cat-file --batch` (task-274).
+ * Duplicates are read once.
+ *
+ * @throws {@link StorageError} `E_GIT_READ_FAILED` when an oid names no blob or the batch read fails.
+ */
+export declare function readBlobs(root: string, oids: readonly string[], options?: CommitOptions): Map<string, string>;
+/**
+ * The best common ancestor of `base` with each of `revs` (`git merge-base`), in input order, or `null`
+ * for a revision that shares no history with `base` (task-274: a ref's copy of an element counts only
+ * when the ref changed it since this commit). One `git merge-base` per revision.
+ *
+ * @throws {@link StorageError} `E_GIT_READ_FAILED` when git fails for another reason.
+ */
+export declare function mergeBasesWith(root: string, base: string, revs: readonly string[], options?: CommitOptions): (string | null)[];
 //# sourceMappingURL=commit.d.ts.map

package/dist/storage/commit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"commit.d.ts","sourceRoot":"","sources":["../../src/storage/commit.ts"],"names":[],"mappings":"AAoBA,sHAAsH;AACtH,MAAM,WAAW,aAAa;IAC5B,kFAAkF;IAClF,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CAClC;AA6BD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,aAAkB,GAC1B,MAAM,CAOR;AASD;;;;GAIG;AACH,eAAO,MAAM,cAAc,6CAA6C,CAAC;AAEzE;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,GAAG,IAAI,CAMjH;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,CAMnG;AAED,mFAAmF;AACnF,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,CAM3F;AAED,uGAAuG;AACvG,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,EAAE,CAIjH;AAYD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,MAAM,SAAK,EACX,OAAO,GAAE,aAAkB,GAC1B,MAAM,EAAE,GAAG,IAAI,CAejB"}
+{"version":3,"file":"commit.d.ts","sourceRoot":"","sources":["../../src/storage/commit.ts"],"names":[],"mappings":"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"}