@astrosheep/keiyaku 2.9.9 → 2.9.11

package/build/core/ledger-batch.js

@@ -1,194 +0,0 @@
-import { wrapGitError, runGitProcess } from "../git/core.js";
-import { GitStreamingBatchFramingError, GitStreamingBatchResponseEndedError, openGitStreamingBatch, } from "../git/streaming-batch.js";
-import { parseLedgerEntryCommitMessage } from "./entry.js";
-import { ACTIVE_LEDGER_REF_PREFIX, activeLedgerRef, } from "./ledger.js";
-const MAX_LEDGER_COMMIT_BYTES = 1024 * 1024;
-async function runLedgerGit(cwd, args) {
-    const result = await runGitProcess(cwd, args);
-    if (result.error || result.status !== 0) {
-        throw wrapGitError(args.join(" "), {
-            message: result.error?.message
-                ?? `git exited with status ${result.status ?? "unknown"}`,
-            stderr: result.stderr,
-            stdout: result.stdout,
-        }, cwd);
-    }
-    return Buffer.from(result.stdout, "utf8");
-}
-async function queryBatchObject(batch, expression) {
-    const record = await batch.request(expression, {
-        maxContentBytes: MAX_LEDGER_COMMIT_BYTES,
-    });
-    if (record.kind === "missing")
-        return null;
-    if (record.kind === "ambiguous") {
-        throw new Error(`[git cat-file ${expression}] object is ambiguous`);
-    }
-    return {
-        oid: record.record.oid,
-        type: record.record.type,
-        content: record.record.content,
-    };
-}
-function parseCommitObject(object) {
-    if (object.type !== "commit") {
-        throw new Error(`git cat-file expected commit ${object.oid}, received ${object.type}`);
-    }
-    const content = object.content.toString("utf8");
-    const messageStart = content.indexOf("\n\n");
-    if (messageStart < 0)
-        throw new Error(`git commit ${object.oid} has no message separator`);
-    const parents = [];
-    for (const line of content.slice(0, messageStart).split("\n")) {
-        if (!line.startsWith("parent "))
-            continue;
-        const parent = line.slice("parent ".length);
-        if (!/^[0-9a-f]{40,64}$/.test(parent)) {
-            throw new Error(`git commit ${object.oid} has an invalid parent header`);
-        }
-        parents.push(parent);
-    }
-    return { oid: object.oid, parents, message: content.slice(messageStart + 2) };
-}
-function parseLedgerRefs(output) {
-    return output
-        .toString("utf8")
-        .split(/\r?\n/)
-        .filter((ref) => ref.startsWith(ACTIVE_LEDGER_REF_PREFIX))
-        .map((ref) => ({ contractId: ref.slice(ACTIVE_LEDGER_REF_PREFIX.length), ref }));
-}
-async function readLedgerFromBatch(batch, ref, commits) {
-    const headObject = await queryBatchObject(batch, `${ref.ref}^{commit}`);
-    if (!headObject)
-        return null;
-    const head = parseCommitObject(headObject);
-    commits.set(head.oid, Promise.resolve(head));
-    const ordered = [];
-    const visited = new Set();
-    const visiting = new Set();
-    const visit = async (oid) => {
-        if (visited.has(oid))
-            return;
-        if (visiting.has(oid))
-            throw new Error(`git ledger ancestry contains a cycle at ${oid}`);
-        visiting.add(oid);
-        let pending = commits.get(oid);
-        if (!pending) {
-            pending = queryBatchObject(batch, oid).then((object) => {
-                if (!object)
-                    throw new Error(`[git cat-file ${oid}] object is missing`);
-                return parseCommitObject(object);
-            });
-            commits.set(oid, pending);
-        }
-        const commit = await pending;
-        for (const parent of commit.parents)
-            await visit(parent);
-        visiting.delete(oid);
-        visited.add(oid);
-        ordered.push(commit);
-    };
-    await visit(head.oid);
-    return {
-        contractId: ref.contractId,
-        ref: ref.ref,
-        head: head.oid,
-        entries: ordered.map((commit) => parseLedgerEntryCommitMessage(commit.message)),
-    };
-}
-async function closeBatch(cwd, batch) {
-    const close = await batch.close();
-    if (!close.aborted && (close.timedOut || close.signal || close.code !== 0)) {
-        throw wrapGitError("cat-file --batch", {
-            message: close.timedOut
-                ? "git timed out"
-                : close.signal
-                    ? `git exited from signal ${close.signal}`
-                    : `git exited with status ${close.code ?? "unknown"}`,
-            stderr: close.stderr.toString("utf8"),
-        }, cwd);
-    }
-}
-async function readLedgerRefs(cwd, refs) {
-    if (refs.length === 0)
-        return [];
-    const batch = openGitStreamingBatch(cwd);
-    const commits = new Map();
-    const results = [];
-    let readError;
-    try {
-        for (let index = 0; index < refs.length; index += 1) {
-            const ref = refs[index];
-            try {
-                const ledger = await readLedgerFromBatch(batch, ref, commits);
-                if (ledger)
-                    results.push(ledger);
-                else
-                    results.push({ id: ref.contractId, error: new Error(`ledger ref disappeared: ${ref.ref}`) });
-            }
-            catch (error) {
-                const diagnostic = error instanceof Error ? error : new Error(String(error));
-                results.push({ id: ref.contractId, error: diagnostic });
-                if (error instanceof GitStreamingBatchFramingError
-                    || error instanceof GitStreamingBatchResponseEndedError) {
-                    const isolationReason = error instanceof GitStreamingBatchResponseEndedError
-                        ? "response ended"
-                        : "malformed frame";
-                    for (const pending of refs.slice(index + 1)) {
-                        results.push({
-                            id: pending.contractId,
-                            error: new Error(`git cat-file batch terminated after ${isolationReason}: ${diagnostic.message}`),
-                        });
-                    }
-                    break;
-                }
-            }
-        }
-    }
-    catch (error) {
-        readError = error;
-    }
-    try {
-        await closeBatch(cwd, batch);
-    }
-    catch (error) {
-        if (!readError)
-            readError = error;
-    }
-    if (readError)
-        throw readError;
-    return results;
-}
-/** Read every ledger with two Git processes regardless of ledger or entry count. */
-export async function readAllLedgerSnapshots(cwd) {
-    const refOutput = await runLedgerGit(cwd, [
-        "for-each-ref",
-        "--sort=refname",
-        "--format=%(refname)",
-        ACTIVE_LEDGER_REF_PREFIX,
-    ]);
-    return readLedgerRefs(cwd, parseLedgerRefs(refOutput));
-}
-/** Read one exact ledger with one Git process and without enumerating other refs. */
-export async function readLedgerSnapshot(cwd, contractId) {
-    const ref = activeLedgerRef(contractId);
-    const batch = openGitStreamingBatch(cwd);
-    let ledger = null;
-    let readError;
-    try {
-        ledger = await readLedgerFromBatch(batch, { contractId, ref }, new Map());
-    }
-    catch (error) {
-        readError = error;
-    }
-    try {
-        await closeBatch(cwd, batch);
-    }
-    catch (error) {
-        if (!readError)
-            readError = error;
-    }
-    if (readError)
-        throw readError;
-    return ledger;
-}

package/build/core/ledger.js

@@ -1,84 +0,0 @@
-import { createGit, wrapGitError, } from "../git/core.js";
-import { formatLedgerEntryCommitMessage, parseLedgerEntryCommitMessage, } from "./entry.js";
-import { casUpdateRefLog, createRefLogCommit, listRefLogCommits, readRefLogCommitMessage, resolveRefLogHead, } from "./ref-log.js";
-export const ACTIVE_LEDGER_REF_PREFIX = "refs/keiyaku/active/";
-export function activeLedgerRef(contractId) {
-    return `${ACTIVE_LEDGER_REF_PREFIX}${contractId}`;
-}
-export async function appendEntry(cwd, ref, entry, expectedHead) {
-    const message = formatLedgerEntryCommitMessage(entry);
-    const separator = message.indexOf("\n\n");
-    const subject = message.slice(0, separator);
-    const body = message.slice(separator + 2).trimEnd();
-    const newHead = await createRefLogCommit(cwd, {
-        subject,
-        body,
-        parentHead: expectedHead,
-        errorLabel: `ledger ${entry.kind} ${entry.contract}`,
-    });
-    const casOk = await casUpdateRefLog(cwd, ref, newHead, expectedHead);
-    if (casOk)
-        return { ok: true, head: newHead };
-    // Intentional: CAS loss re-resolves and surfaces conflict/missing-ref without throw.
-    const currentHead = await resolveRefLogHead(cwd, ref);
-    if (currentHead === null) {
-        return { ok: false, reason: "missing-ref" };
-    }
-    return { ok: false, reason: "conflict", currentHead };
-}
-export async function appendWithRetry(cwd, ref, build, options = {}) {
-    const maxRetries = options.maxRetries ?? 3;
-    let currentHead = await resolveRefLogHead(cwd, ref);
-    const startedMissing = currentHead === null;
-    for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
-        const currentEntries = currentHead ? (await readLedgerRef(cwd, ref, currentHead)).entries : [];
-        const nextEntry = await build(currentHead, currentEntries);
-        if (nextEntry === null) {
-            return { ok: false, reason: "aborted", currentHead };
-        }
-        const result = await appendEntry(cwd, ref, nextEntry, currentHead);
-        if (result.ok)
-            return result;
-        if (result.reason === "missing-ref") {
-            if (!startedMissing) {
-                return result;
-            }
-            currentHead = null;
-            continue;
-        }
-        currentHead = result.currentHead;
-    }
-    if (currentHead === null) {
-        return { ok: false, reason: "missing-ref" };
-    }
-    return { ok: false, reason: "conflict", currentHead };
-}
-async function readLedgerRef(cwd, ref, head) {
-    const commits = await listRefLogCommits(cwd, head, ref);
-    const entries = [];
-    for (const commit of commits) {
-        entries.push(parseLedgerEntryCommitMessage(await readRefLogCommitMessage(cwd, commit)));
-    }
-    return { ref, head, entries };
-}
-export async function readLedger(cwd, contractId) {
-    const ref = activeLedgerRef(contractId);
-    const head = await resolveRefLogHead(cwd, ref);
-    if (!head)
-        return null;
-    return { contractId, ...(await readLedgerRef(cwd, ref, head)) };
-}
-export async function listContractIds(cwd) {
-    const git = createGit(cwd);
-    try {
-        const output = await git.raw(["for-each-ref", "--format=%(refname)", ACTIVE_LEDGER_REF_PREFIX]);
-        return output
-            .split(/\r?\n/)
-            .map((line) => line.trim())
-            .filter((line) => line.startsWith(ACTIVE_LEDGER_REF_PREFIX))
-            .map((ref) => ref.slice(ACTIVE_LEDGER_REF_PREFIX.length));
-    }
-    catch (error) {
-        throw wrapGitError(`for-each-ref ${ACTIVE_LEDGER_REF_PREFIX}`, error, cwd);
-    }
-}

package/build/core/projection/leash.js

@@ -1,87 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { DatabaseSync } from "node:sqlite";
-import { isErrnoException } from "../../errno.js";
-export const LEASH_FILE = "leash";
-export class ProjectionLeashError extends Error {
-    code = "PROJECTION_LEASH_ERROR";
-    constructor(message, options) {
-        super(message, options);
-        this.name = "ProjectionLeashError";
-    }
-}
-export function leashPath(projectionDirectory) {
-    return path.join(projectionDirectory, LEASH_FILE);
-}
-function errorDetail(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function readJournalMode(database) {
-    const row = database.prepare("PRAGMA journal_mode").get();
-    return typeof row?.journal_mode === "string" ? row.journal_mode.toLowerCase() : undefined;
-}
-/**
- * Birth-time initialization for the projection leash file.
- * Creates a brand-new extensionless rollback-journal SQLite database with the
- * minimal kernel-lock anchor schema, then closes all handles before return.
- * Fails if the target already exists. Stores zero product facts.
- */
-export function initializeProjectionLeash(projectionDirectory) {
-    let parent;
-    try {
-        parent = fs.statSync(projectionDirectory);
-    }
-    catch (error) {
-        throw new ProjectionLeashError(`projection leash parent directory does not exist at ${projectionDirectory}`, { cause: error });
-    }
-    if (!parent.isDirectory()) {
-        throw new ProjectionLeashError("projection leash parent must be a directory");
-    }
-    const target = leashPath(projectionDirectory);
-    let reserved = false;
-    try {
-        const fd = fs.openSync(target, "wx");
-        fs.closeSync(fd);
-        reserved = true;
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "EEXIST") {
-            throw new ProjectionLeashError(`projection leash already exists at ${target}`, { cause: error });
-        }
-        throw new ProjectionLeashError(`projection leash could not be initialized: ${errorDetail(error)}`, { cause: error });
-    }
-    let database;
-    try {
-        database = new DatabaseSync(target, {
-            enableDoubleQuotedStringLiterals: false,
-            allowExtension: false,
-        });
-        database.exec("PRAGMA busy_timeout = 0");
-        database.exec("PRAGMA journal_mode = DELETE");
-        database.exec("CREATE TABLE lock_anchor (id INTEGER PRIMARY KEY CHECK (id = 1))");
-        if (readJournalMode(database) !== "delete") {
-            throw new ProjectionLeashError("projection leash does not use rollback-journal mode");
-        }
-        database.prepare("SELECT id FROM lock_anchor LIMIT 1").get();
-        database.close();
-        database = undefined;
-        return target;
-    }
-    catch (error) {
-        try {
-            database?.close();
-        }
-        catch { /* preserve the causal initialization failure */ }
-        if (reserved) {
-            try {
-                fs.unlinkSync(target);
-            }
-            catch {
-                // Leave a partial file only if unlink itself fails.
-            }
-        }
-        if (error instanceof ProjectionLeashError)
-            throw error;
-        throw new ProjectionLeashError(`projection leash could not be initialized: ${errorDetail(error)}`, { cause: error });
-    }
-}

package/build/core/ref-log.js

@@ -1,119 +0,0 @@
-import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, parseRevListOutput, wrapGitError } from "../git/core.js";
-const EMPTY_TREE_HASH = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
-const MISSING_REF_SENTINEL = "0".repeat(40);
-/** Resolve a ref log head, or null when the ref is missing. */
-export async function resolveRefLogHead(cwd, ref, options = {}) {
-    const git = createGit(cwd);
-    const peel = options.peel ?? "commit";
-    const target = peel === "commit" ? `${ref}^{commit}` : ref;
-    try {
-        return (await git.raw(["rev-parse", "--verify", target])).trim();
-    }
-    catch (error) {
-        if (errorContainsAnyPattern(error, MISSING_HEAD_PATTERNS))
-            return null;
-        throw wrapGitError(`rev-parse ${ref}`, error, cwd);
-    }
-}
-/** Read the raw commit message bytes used by ref-log parsers (`show %B`). */
-export async function readRefLogCommitMessage(cwd, commit) {
-    const git = createGit(cwd);
-    try {
-        return await git.raw(["show", "-s", "--format=%B", commit]);
-    }
-    catch (error) {
-        throw wrapGitError(`show commit message ${commit}`, error, cwd);
-    }
-}
-/**
- * List commits reachable from `head` oldest-first.
- * `errorLabel` is the ref or range name used in wrapGitError text.
- */
-export async function listRefLogCommits(cwd, head, errorLabel = head) {
-    const git = createGit(cwd);
-    try {
-        return parseRevListOutput(await git.raw(["rev-list", "--reverse", head]));
-    }
-    catch (error) {
-        throw wrapGitError(`rev-list ${errorLabel}`, error, cwd);
-    }
-}
-/**
- * Create an empty-tree commit for a ref log entry.
- * Callers own subject/body byte layout so message formats stay domain-local.
- */
-export async function createRefLogCommit(cwd, input) {
-    const git = createGit(cwd);
-    const args = ["commit-tree", EMPTY_TREE_HASH];
-    if (input.parentHead)
-        args.push("-p", input.parentHead);
-    args.push("-m", input.subject, "-m", input.body);
-    try {
-        return (await git.raw(args)).trim();
-    }
-    catch (error) {
-        throw wrapGitError(`commit-tree ${input.errorLabel ?? input.subject}`, error, cwd);
-    }
-}
-/**
- * Compare-and-swap a ref to `newHead`.
- * Returns false on CAS failure; callers own re-resolve / degrade policy.
- */
-export async function casUpdateRefLog(cwd, ref, newHead, expectedOld) {
-    const git = createGit(cwd);
-    const oldValue = expectedOld ?? MISSING_REF_SENTINEL;
-    try {
-        await git.raw(["update-ref", ref, newHead, oldValue]);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function readRefLogAt(cwd, ref, head, parse) {
-    const commits = await listRefLogCommits(cwd, head, ref);
-    const entries = [];
-    for (const commit of commits) {
-        entries.push(parse(await readRefLogCommitMessage(cwd, commit)));
-    }
-    return entries;
-}
-export async function readRefLog(cwd, ref, parse) {
-    const head = await resolveRefLogHead(cwd, ref);
-    if (!head)
-        return [];
-    return readRefLogAt(cwd, ref, head, parse);
-}
-export async function appendRefLogWithRetry(cwd, ref, subjectFor, parse, build, options = {}) {
-    const maxRetries = options.maxRetries ?? 3;
-    let currentHead = await resolveRefLogHead(cwd, ref);
-    const startedMissing = currentHead === null;
-    for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
-        const entries = currentHead ? await readRefLogAt(cwd, ref, currentHead, parse) : [];
-        const entry = await build(entries);
-        if (entry === null)
-            return { ok: false, reason: "aborted", currentHead };
-        const newHead = await createRefLogCommit(cwd, {
-            subject: subjectFor(entry),
-            body: JSON.stringify(entry, null, 2),
-            parentHead: currentHead,
-        });
-        const casOk = await casUpdateRefLog(cwd, ref, newHead, currentHead);
-        if (casOk)
-            return { ok: true, head: newHead };
-        // Intentional degrade: re-resolve after CAS loss; missing-ref mid-flight is sticky
-        // when the ref existed at start (do not resurrect).
-        const resolved = await resolveRefLogHead(cwd, ref);
-        if (resolved === null) {
-            if (!startedMissing)
-                return { ok: false, reason: "missing-ref" };
-            currentHead = null;
-        }
-        else {
-            currentHead = resolved;
-        }
-    }
-    if (currentHead === null)
-        return { ok: false, reason: "missing-ref" };
-    return { ok: false, reason: "conflict", currentHead };
-}

package/build/core/renew-session.js

@@ -1,128 +0,0 @@
-import { randomUUID } from "node:crypto";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { FlowError } from "../flow-error.js";
-import { syncDirectory } from "../fs/durability.js";
-import { deleteRecoveryRef } from "../git/refs.js";
-import { KEIYAKU_FILE } from "../keiyaku.js";
-import { renderContractView } from "./contract-view.js";
-import { readLedger } from "./ledger.js";
-import { latestBase } from "./status/drift.js";
-import { findRegisteredContractWorktreePath } from "./worktree-path.js";
-const RENEW_SESSION_DIRECTORY = path.join(".keiyaku", "recovery");
-const RENEW_SESSION_FILE = "renew-session.json";
-function isSha(value) {
-    return typeof value === "string" && /^[0-9a-f]{40}$/.test(value);
-}
-function parseSession(raw) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-        throw new FlowError("INTERNAL_STATE", "renew recovery session is malformed");
-    }
-    const value = raw;
-    const keys = Object.keys(value).sort();
-    const expected = ["commission", "newBase", "oldBase", "oldHead", "recoveryRef"];
-    if (keys.length !== expected.length || keys.some((key, index) => key !== expected[index])) {
-        throw new FlowError("INTERNAL_STATE", "renew recovery session has unknown or missing fields");
-    }
-    if (typeof value.commission !== "string" || !value.commission ||
-        !isSha(value.oldBase) || !isSha(value.oldHead) || !isSha(value.newBase) ||
-        typeof value.recoveryRef !== "string" || !value.recoveryRef) {
-        throw new FlowError("INTERNAL_STATE", "renew recovery session has invalid coordinates");
-    }
-    return value;
-}
-async function sessionPath(cwd, commission) {
-    const worktree = await findRegisteredContractWorktreePath(cwd, commission);
-    return worktree ? path.join(worktree, RENEW_SESSION_DIRECTORY, RENEW_SESSION_FILE) : undefined;
-}
-export async function readRenewRecoverySession(cwd, commission) {
-    const filePath = await sessionPath(cwd, commission);
-    if (!filePath)
-        return null;
-    try {
-        return parseSession(JSON.parse(await fs.readFile(filePath, "utf8")));
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return null;
-        if (error instanceof FlowError)
-            throw error;
-        throw new FlowError("INTERNAL_STATE", `cannot read renew recovery session for ${commission}`, { cause: error });
-    }
-}
-export async function writeRenewRecoverySession(cwd, session) {
-    const filePath = await sessionPath(cwd, session.commission);
-    if (!filePath) {
-        throw new FlowError("INTERNAL_STATE", `renew --resolve requires ${session.commission}'s registered contract worktree`);
-    }
-    const existing = await readRenewRecoverySession(cwd, session.commission);
-    if (existing) {
-        throw new FlowError("RENEW_SESSION_OPEN", `renew recovery session is already open for ${session.commission}`, {
-            facts: { kind: "renew_session", commission: session.commission, nextAction: "continue-or-abort" },
-        });
-    }
-    const directory = path.dirname(filePath);
-    await fs.mkdir(directory, { recursive: true });
-    const temporary = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
-    await fs.writeFile(temporary, `${JSON.stringify(session)}\n`, { encoding: "utf8", flag: "wx" });
-    await fs.rename(temporary, filePath);
-    await syncDirectory(directory);
-    return filePath;
-}
-export async function removeRenewRecoverySession(cwd, commission) {
-    const filePath = await sessionPath(cwd, commission);
-    if (!filePath)
-        return;
-    try {
-        await fs.unlink(filePath);
-        await syncDirectory(path.dirname(filePath));
-    }
-    catch (error) {
-        if (error.code !== "ENOENT")
-            throw error;
-    }
-}
-function publishedRenewForSession(ledger, session) {
-    const tail = ledger.entries.at(-1);
-    if (session.commission !== ledger.contractId ||
-        tail?.kind !== "renew" ||
-        tail.data.oldBase !== session.oldBase ||
-        tail.data.oldHead !== session.oldHead ||
-        tail.data.newBase !== session.newBase ||
-        latestBase(ledger.entries) !== session.newBase)
-        return null;
-    const previous = ledger.entries.at(-2);
-    return {
-        renew: tail,
-        seal: previous?.kind === "seal" && previous.data.sealedBy === "renew" ? previous : null,
-    };
-}
-export async function convergeRenewRecoverySession(cwd, commission) {
-    const session = await readRenewRecoverySession(cwd, commission);
-    if (!session)
-        return { state: "none" };
-    const ledger = await readLedger(cwd, commission);
-    if (!ledger)
-        return { state: "live", session };
-    const published = publishedRenewForSession(ledger, session);
-    if (!published)
-        return { state: "live", session };
-    const worktree = await findRegisteredContractWorktreePath(cwd, commission);
-    if (!worktree) {
-        throw new FlowError("INTERNAL_STATE", `registered contract worktree disappeared for spent renew session ${commission}`);
-    }
-    await fs.writeFile(path.join(worktree, KEIYAKU_FILE), renderContractView({ id: commission, entries: ledger.entries }), "utf8");
-    const recoveryCleanup = await deleteRecoveryRef(cwd, session.recoveryRef, session.oldHead);
-    await removeRenewRecoverySession(cwd, commission);
-    return { state: "spent", session, ledger, ...published, recoveryCleanup };
-}
-export async function assertNoRenewRecoverySession(cwd, commission) {
-    const state = await convergeRenewRecoverySession(cwd, commission);
-    if (state.state === "none")
-        return null;
-    if (state.state === "spent")
-        return state;
-    throw new FlowError("RENEW_SESSION_OPEN", `renew recovery session is open for ${commission}`, {
-        facts: { kind: "renew_session", commission, nextAction: "continue-or-abort" },
-    });
-}

package/build/core/status/ledger-batch.js

@@ -1 +0,0 @@
-export { readAllLedgerSnapshots as readStatusLedgers, } from "../ledger-batch.js";