@astrosheep/keiyaku 2.9.8 → 2.9.10

package/build/core/entry.js

@@ -1,305 +0,0 @@
-import { z } from "zod";
-const SHA_RE = /^[0-9a-f]{7,40}$/i;
-const ISO_UTC_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
-const CONTRACT_ID_RE = /^\S+$/;
-const SUBJECT_RE = /^keiyaku: (bind|arc|seal|amend|renew|petition|verdict|claim|forfeit|bootstrap) ([^\s]+)$/;
-const shaSchema = z.string().regex(SHA_RE, "expected git sha");
-const isoUtcSchema = z.string().regex(ISO_UTC_RE, "expected ISO 8601 UTC timestamp");
-const nonEmptyString = z.string().trim().min(1);
-const nonBlankString = z.string().refine((value) => value.trim().length > 0, "expected non-empty string");
-// Scope patterns are gitignore text: do not trim, or escaped trailing spaces (`foo\ `) are destroyed.
-const scopePatternString = z
-    .string()
-    .refine((value) => value.trim().length > 0, "expected non-empty scope pattern");
-// Catalog base (2-13 lowercase letters) or generation overflow base2, base3, ...
-const placeSchema = z.string().regex(/^[a-z]{2,13}(?:[2-9]|[1-9][0-9]+)?$/);
-export const entryKindSchema = z.enum([
-    "bind",
-    "arc",
-    "seal",
-    "amend",
-    "renew",
-    "petition",
-    "verdict",
-    "claim",
-    "forfeit",
-    "bootstrap",
-]);
-const diffstatSchema = z
-    .object({
-    files: z.number().int().nonnegative(),
-    insertions: z.number().int().nonnegative(),
-    deletions: z.number().int().nonnegative(),
-})
-    .strict();
-const scopeAuditSchema = z
-    .object({
-    violations: z.array(nonEmptyString),
-})
-    .strict();
-export const fullBranchRefSchema = z
-    .string()
-    .regex(/^refs\/heads\/\S+$/, "expected full branch ref");
-export const bindBootstrapPlanSchema = z
-    .object({
-    command: z.array(nonEmptyString).min(1),
-    timeoutMs: z.number().int().min(1).max(3_600_000),
-})
-    .strict();
-export const bindEntryDataSchema = z
-    .object({
-    name: nonEmptyString,
-    objective: nonEmptyString,
-    scope: z.array(scopePatternString).min(1),
-    checks: z.array(nonBlankString).min(1),
-    extensions: z
-        .array(z
-        .object({
-        title: nonBlankString,
-        content: z.string(),
-    })
-        .strict()),
-    base: shaSchema,
-    target: fullBranchRefSchema,
-    workspace: z.enum(["worktree", "here"]),
-    after: z.array(nonEmptyString).optional(),
-    place: placeSchema.nullable().optional(),
-    bootstrap: bindBootstrapPlanSchema.optional(),
-})
-    .strict();
-const bootstrapExitResultSchema = z
-    .object({
-    kind: z.literal("exit"),
-    code: z.number().int().min(0).max(255),
-})
-    .strict();
-const bootstrapSignalResultSchema = z
-    .object({
-    kind: z.literal("signal"),
-    signal: z.string().min(1),
-})
-    .strict();
-const bootstrapTimeoutResultSchema = z
-    .object({
-    kind: z.literal("timeout"),
-})
-    .strict();
-const bootstrapSpawnResultSchema = z
-    .object({
-    kind: z.literal("spawn"),
-    message: z.string(),
-})
-    .strict();
-export const bootstrapResultSchema = z.discriminatedUnion("kind", [
-    bootstrapExitResultSchema,
-    bootstrapSignalResultSchema,
-    bootstrapTimeoutResultSchema,
-    bootstrapSpawnResultSchema,
-]);
-export const bootstrapEntryDataSchema = z
-    .object({
-    result: bootstrapResultSchema,
-    durationMs: z
-        .number()
-        .int()
-        .nonnegative()
-        .refine((value) => Number.isSafeInteger(value), "durationMs must be a safe integer"),
-    stderrTail: z.string().optional(),
-    stderrTruncated: z.boolean().optional(),
-})
-    .strict();
-export const arcEntryDataSchema = z
-    .object({
-    arc: z.number().int().positive(),
-    title: nonEmptyString,
-    objective: nonEmptyString,
-    brief: nonEmptyString,
-})
-    .strict();
-export const sealEntryDataSchema = z
-    .object({
-    arc: z.number().int().nonnegative(),
-    sealedBy: z.enum(["arc", "renew", "petition"]),
-    oldFence: shaSchema,
-    newFence: shaSchema,
-    receipts: z.array(shaSchema),
-    diffstat: diffstatSchema,
-    scopeAudit: scopeAuditSchema,
-})
-    .strict();
-export const amendEntryDataSchema = z
-    .object({
-    amendment: nonBlankString,
-    scopeDelta: z
-        .object({
-        add: z.array(scopePatternString),
-    })
-        .strict()
-        .optional(),
-})
-    .strict();
-export const renewEntryDataSchema = z
-    .object({
-    oldBase: shaSchema,
-    newBase: shaSchema,
-    oldHead: shaSchema,
-    newHead: shaSchema,
-})
-    .strict();
-const positiveSafeSeatSchema = z
-    .number()
-    .int()
-    .positive()
-    .refine((value) => Number.isSafeInteger(value), "seat must be a positive safe integer");
-// Current petitions always carry target + seat. Legacy residuals omit both and
-// exist only for diagnostic/rejection paths — never for production writers.
-export const petitionEntryDataSchema = z.union([
-    z
-        .object({
-        intent: z.literal("claim"),
-        oath: nonEmptyString,
-        target: fullBranchRefSchema,
-        seat: positiveSafeSeatSchema,
-    })
-        .strict(),
-    z
-        .object({
-        intent: z.literal("forfeit"),
-        target: fullBranchRefSchema,
-        seat: positiveSafeSeatSchema,
-    })
-        .strict(),
-    z
-        .object({
-        intent: z.literal("claim"),
-        oath: nonEmptyString,
-    })
-        .strict(),
-    z
-        .object({
-        intent: z.literal("forfeit"),
-    })
-        .strict(),
-]);
-export const verdictEntryDataSchema = z
-    .object({
-    result: z.enum(["approved", "rejected"]),
-    summary: nonEmptyString,
-})
-    .strict();
-export const claimEntryDataSchema = z
-    .object({
-    mergeCommit: shaSchema,
-})
-    .strict();
-export const forfeitEntryDataSchema = z
-    .object({
-    reason: z.enum(["manual", "bind-failed"]),
-    by: nonEmptyString,
-    note: nonEmptyString.optional(),
-})
-    .strict();
-function makeEntrySchema(kind, data, version = 1) {
-    return z
-        .object({
-        v: z.literal(version),
-        kind: z.literal(kind),
-        contract: z.string().trim().regex(CONTRACT_ID_RE, "contract id cannot contain whitespace"),
-        at: isoUtcSchema,
-        actor: nonEmptyString,
-        data,
-    })
-        .strict();
-}
-export const bindEntrySchema = makeEntrySchema("bind", bindEntryDataSchema);
-export const arcEntrySchema = makeEntrySchema("arc", arcEntryDataSchema);
-export const sealEntrySchema = makeEntrySchema("seal", sealEntryDataSchema, 2);
-export const amendEntrySchema = makeEntrySchema("amend", amendEntryDataSchema);
-export const renewEntrySchema = makeEntrySchema("renew", renewEntryDataSchema);
-export const petitionEntrySchema = makeEntrySchema("petition", petitionEntryDataSchema);
-export const verdictEntrySchema = makeEntrySchema("verdict", verdictEntryDataSchema);
-export const claimEntrySchema = makeEntrySchema("claim", claimEntryDataSchema);
-export const forfeitEntrySchema = makeEntrySchema("forfeit", forfeitEntryDataSchema);
-export const bootstrapEntrySchema = makeEntrySchema("bootstrap", bootstrapEntryDataSchema);
-export const ledgerEntrySchema = z.discriminatedUnion("kind", [
-    bindEntrySchema,
-    arcEntrySchema,
-    sealEntrySchema,
-    amendEntrySchema,
-    renewEntrySchema,
-    petitionEntrySchema,
-    verdictEntrySchema,
-    claimEntrySchema,
-    forfeitEntrySchema,
-    bootstrapEntrySchema,
-]);
-export class LedgerEntryFormatError extends Error {
-    code = "INVALID_LEDGER_ENTRY_FORMAT";
-    constructor(message, options) {
-        super(message, options);
-        this.name = "LedgerEntryFormatError";
-    }
-}
-export class LedgerEntrySchemaError extends Error {
-    code = "INVALID_LEDGER_ENTRY_SCHEMA";
-    constructor(message, options) {
-        super(message, options);
-        this.name = "LedgerEntrySchemaError";
-    }
-}
-export function formatLedgerEntrySubject(entry) {
-    return `keiyaku: ${entry.kind} ${entry.contract}`;
-}
-export function formatLedgerEntryCommitMessage(entry) {
-    const result = ledgerEntrySchema.safeParse(entry);
-    if (!result.success) {
-        throw new LedgerEntrySchemaError(`ledger entry schema validation failed: ${result.error.message}`, {
-            cause: result.error,
-        });
-    }
-    return `${formatLedgerEntrySubject(result.data)}\n\n${JSON.stringify(result.data, null, 2)}\n`;
-}
-export function parseLedgerEntryCommitMessage(message) {
-    const normalized = message.replace(/\r\n/g, "\n");
-    const separatorIndex = normalized.indexOf("\n\n");
-    if (separatorIndex < 0) {
-        throw new LedgerEntryFormatError("ledger entry commit message must contain a blank line before the JSON body");
-    }
-    const subject = normalized.slice(0, separatorIndex).trim();
-    const subjectMatch = SUBJECT_RE.exec(subject);
-    if (!subjectMatch) {
-        throw new LedgerEntryFormatError("ledger entry subject must match 'keiyaku: <kind> <contract>'");
-    }
-    const body = normalized.slice(separatorIndex + 2).trim();
-    let parsed;
-    try {
-        parsed = JSON.parse(body);
-    }
-    catch (error) {
-        throw new LedgerEntryFormatError("ledger entry JSON body is not valid JSON", { cause: error });
-    }
-    if (typeof parsed === "object" && parsed !== null && Object.hasOwn(parsed, "repoId")) {
-        const { repoId: _legacyRepoId, ...current } = parsed;
-        parsed = current;
-    }
-    if (typeof parsed === "object" && parsed !== null &&
-        parsed.kind === "amend") {
-        const data = parsed.data;
-        const scopeDelta = typeof data === "object" && data !== null
-            ? data.scopeDelta
-            : undefined;
-        if (typeof scopeDelta === "object" && scopeDelta !== null && Object.hasOwn(scopeDelta, "remove")) {
-            throw new LedgerEntrySchemaError("ledger entry schema validation failed: scopeDelta.remove is obsolete; ledger row is corrupt");
-        }
-    }
-    const result = ledgerEntrySchema.safeParse(parsed);
-    if (!result.success) {
-        throw new LedgerEntrySchemaError(`ledger entry schema validation failed: ${result.error.message}`, {
-            cause: result.error,
-        });
-    }
-    if (result.data.kind !== subjectMatch[1] || result.data.contract !== subjectMatch[2]) {
-        throw new LedgerEntryFormatError("ledger entry subject does not match the JSON body");
-    }
-    return result.data;
-}

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 });
-    }
-}