@astrosheep/keiyaku 4.0.1 → 4.0.2

package/build/src/cli/result.d.ts

@@ -1,6 +1,15 @@
-import type { AuditReport, ChangeId, ContractId, Fact, PlacementStop, ReconcileReport, RegionOverlap, Review, SettlementReport, SnapshotId, VerificationStop } from "../index.js";
+import type { AuditReport, ContractId, Fact, MutationResult, PlacementStop, ReconcileReport, Review, VerificationReuse, VerificationStop } from "../index.js";
 import type { KanshiReport } from "../kanshi/index.js";
+import type { RegionRead, Section } from "../kanshi/index.js";
 import type { Catalog } from "../index.js";
+import type { RegionObservation } from "../library/region.js";
+export type BindDraftReceipt = Readonly<{
+    path: string;
+    warning?: string;
+} | {
+    path?: never;
+    warning: string;
+}>;
 export type Effect = ReconcileReport["effects"][number];
 export type AcceptedFact = Readonly<{
     contract: ContractId;
@@ -8,36 +17,117 @@ export type AcceptedFact = Readonly<{
     kind: Fact["kind"];
 }>;
 export type Lag = ReconcileReport["lag"][number];
-export type DiffUnavailable = Readonly<{
-    reason: "git-unavailable";
-    integrationSnapshot: SnapshotId;
-    changeId: ChangeId;
-}>;
-export type AcceptedResult = Readonly<{
+type MutationEnvelope = Pick<MutationResult<unknown>, "head" | "effects" | "settlement">;
+export type AcceptedEnvelope = Readonly<{
     kind: "accepted";
-    verb: string;
     contract: ContractId;
-    head: string | null;
+    head: MutationEnvelope["head"];
     facts: readonly AcceptedFact[];
-    effects: readonly Effect[];
-    settlement: SettlementReport;
-    target?: string | null;
+    effects: MutationEnvelope["effects"];
+    settlement: MutationEnvelope["settlement"];
+    lag?: readonly [Lag, ...Lag[]];
+}>;
+export type AcceptedBindResult = AcceptedEnvelope & Readonly<{
+    verb: "bind";
+    target: string | null;
+    verification?: never;
+    verificationReuse?: never;
+    placement?: never;
+    cleanup?: never;
+    leak?: never;
+    report?: never;
+    workspace?: never;
+    diff?: never;
+}> & RegionObservation;
+export type AcceptedAmendResult = AcceptedEnvelope & Readonly<{
+    verb: "amend";
+    diff: string;
+    target?: never;
+    verification?: never;
+    verificationReuse?: never;
+    placement?: never;
+    cleanup?: never;
+    leak?: never;
+    report?: never;
+    workspace?: never;
+}> & RegionObservation;
+export type AcceptedDeliverResult = AcceptedEnvelope & Readonly<{
+    verb: "deliver";
     verification?: VerificationStop;
+    verificationReuse?: VerificationReuse;
+    placement?: PlacementStop;
+    cleanup?: MutationResult<unknown>["cleanup"];
+    leak?: MutationResult<unknown>["leak"];
+    target?: never;
+    overlaps?: never;
+    overlapFailure?: never;
+    report?: never;
+    workspace?: never;
+    diff?: never;
+}>;
+export type AcceptedReviewResult = AcceptedEnvelope & Readonly<{
+    verb: "review";
     placement?: PlacementStop;
-    cleanup?: NonNullable<AuditReport["cleanup"]>;
-    leak?: NonNullable<AuditReport["leak"]>;
-    overlaps?: readonly RegionOverlap[];
-    overlapFailure?: string;
-    report?: AuditReport;
     workspace?: Review["workspace"];
-    diff?: string | DiffUnavailable;
-    lag?: readonly Lag[];
+    target?: never;
+    verification?: never;
+    verificationReuse?: never;
+    cleanup?: never;
+    leak?: never;
+    overlaps?: never;
+    overlapFailure?: never;
+    report?: never;
+    diff?: never;
+}>;
+export type AcceptedArcResult = AcceptedEnvelope & Readonly<{
+    verb: "arc";
+    target?: never;
+    verification?: never;
+    verificationReuse?: never;
+    placement?: never;
+    cleanup?: never;
+    leak?: never;
+    overlaps?: never;
+    overlapFailure?: never;
+    report?: never;
+    workspace?: never;
+    diff?: never;
+}>;
+export type AcceptedAbandonResult = AcceptedEnvelope & Readonly<{
+    verb: "abandon";
+    target?: never;
+    verification?: never;
+    verificationReuse?: never;
+    placement?: never;
+    cleanup?: never;
+    leak?: never;
+    overlaps?: never;
+    overlapFailure?: never;
+    report?: never;
+    workspace?: never;
+    diff?: never;
 }>;
+export type AcceptedAuditResult = AcceptedEnvelope & Readonly<{
+    verb: "audit";
+    report: AuditReport;
+    cleanup?: MutationResult<unknown>["cleanup"];
+    leak?: MutationResult<unknown>["leak"];
+    target?: never;
+    verification?: never;
+    verificationReuse?: never;
+    placement?: never;
+    overlaps?: never;
+    overlapFailure?: never;
+    workspace?: never;
+    diff?: never;
+}>;
+export type AcceptedResult = AcceptedBindResult | AcceptedAmendResult | AcceptedDeliverResult | AcceptedReviewResult | AcceptedArcResult | AcceptedAbandonResult | AcceptedAuditResult;
 export type RefusedResult = Readonly<{
     kind: "refused";
     verb: string;
     contract?: ContractId;
     refusal: unknown;
+    draft?: BindDraftReceipt;
 }>;
 export type RetryResult = Readonly<{
     kind: "retry";
@@ -60,8 +150,13 @@ export type StatusResult = Readonly<{
     report: KanshiReport;
     selection: "world" | "contract";
 }>;
+export type RegionResult = Readonly<{
+    kind: "region";
+    region: Section<RegionRead>;
+}>;
 export type CatalogResult = Readonly<{
     kind: "catalog";
     catalog: Catalog;
 }>;
-export type InvocationResult = AcceptedResult | RefusedResult | RetryResult | ObservationResult | GuidanceResult | StatusResult | CatalogResult;
+export type InvocationResult = AcceptedResult | RefusedResult | RetryResult | ObservationResult | GuidanceResult | StatusResult | RegionResult | CatalogResult;
+export {};

package/build/src/cli/usage.d.ts

@@ -3,4 +3,5 @@ export declare class CliUsageError extends Error {
     readonly projection?: string | undefined;
     constructor(diagnostic: string, projection?: string | undefined);
 }
+export declare function isBlankInput(value: string): boolean;
 export declare function usageLine(usage: string): string;

package/build/src/cli/usage.js

@@ -8,6 +8,9 @@ export class CliUsageError extends Error {
         this.name = "CliUsageError";
     }
 }
+export function isBlankInput(value) {
+    return value.trim().length === 0;
+}
 export function usageLine(usage) {
     return usage.split("\n").map((line, index) => {
         if (index === 0)

package/build/src/contract-worktree.d.ts

@@ -1,6 +1,7 @@
 import { type DerivedFileAction } from "./coordination/durable-file.js";
 import { type ContractId, type ContractState } from "./core/facts/types.js";
 import { type GitRepository } from "./git/repository.js";
+import { type PlaceRegister } from "./workspace-place.js";
 export declare function renderContractGuidance(state: ContractState): string;
 export type ContractFileEffect = Readonly<{
     kind: "contract-file";
@@ -28,7 +29,7 @@ export type ContractAppointment = Readonly<{
     kind: "invalid";
     path: string;
 }>;
-export declare function readContractAppointment(repository: GitRepository): ContractAppointment;
+export declare function readContractAppointment(repository: GitRepository): Promise<ContractAppointment>;
 export type ContractReservation = Readonly<{
     kind: "reserved";
     path: string;
@@ -36,8 +37,8 @@ export type ContractReservation = Readonly<{
     kind: "absent";
     path: string;
 }>>;
-export declare function reserveContractWorktree(repository: GitRepository, contract: ContractId): ContractReservation;
+export declare function reserveContractWorktree(repository: GitRepository, contract: ContractId): Promise<ContractReservation>;
 export declare function withContractWorktreeAppointment<T>(repository: GitRepository, action: () => T | Promise<T>): Promise<T>;
-export declare function releaseContractWorktree(repository: GitRepository, contract: ContractId): void;
-export declare function removeContractWorktreeAppointment(repository: GitRepository, contract: ContractId): void;
-export declare function projectContractWorktree(repository: GitRepository, state: ContractState | null): ContractWorktreeResult;
+export declare function releaseContractWorktree(repository: GitRepository, contract: ContractId): Promise<void>;
+export declare function removeContractWorktreeAppointment(repository: GitRepository, contract: ContractId): Promise<void>;
+export declare function projectContractWorktree(repository: GitRepository, state: ContractState | null, register?: PlaceRegister): Promise<ContractWorktreeResult>;

package/build/src/contract-worktree.js

@@ -1,13 +1,35 @@
-import { chmodSync, lstatSync, readFileSync, unlinkSync } from "node:fs";
+import { chmod, lstat, readFile, unlink } from "node:fs/promises";
 import { join } from "node:path";
 import { acquireSqliteTransactionLock } from "./coordination/sqlite-transaction-lock.js";
 import { createFileDurablyExclusive, repairDerivedFile, } from "./coordination/durable-file.js";
 import { contractId } from "./core/facts/types.js";
 import { GitPlumbingError, runGit, worktreeGitDirectory, worktreeRoot, } from "./git/repository.js";
-import { deliveryWorktreePath } from "./git/workspace.js";
+import { worktreePath } from "./git/workspace.js";
+import { appointmentFor, placeRegisterPath, readPlaceRegister, } from "./workspace-place.js";
 const IGNORE_BYTES = ".gitignore\nKEIYAKU.md\n";
+const APPOINTMENT_DESCRIPTION = "This is a read-only projection. Do not edit manually.";
 function appointmentBytes(contract) {
-    return `---\ncontract: ${contract}\n---\n`;
+    return `---\ncontract: ${contract}\ndescription: ${APPOINTMENT_DESCRIPTION}\n---\n`;
+}
+function appointedContract(bytes) {
+    const lines = bytes.split(/\r?\n/u);
+    if (lines[0] !== "---")
+        return undefined;
+    const close = lines.indexOf("---", 1);
+    if (close !== 2 && close !== 3)
+        return undefined;
+    const identity = lines[1];
+    const description = lines[2];
+    if (identity === undefined || !identity.startsWith("contract: "))
+        return undefined;
+    if (close === 3 && (description === undefined || !description.startsWith("description: ")))
+        return undefined;
+    try {
+        return contractId(identity.slice("contract: ".length));
+    }
+    catch {
+        return undefined;
+    }
 }
 function renderArc(arc) {
     return [
@@ -25,10 +47,12 @@ const FULFILLMENT = [
     "Read the complete Contract before acting and keep work inside that worktree.", "",
     "### Deliverer", "",
     "Implement and verify the Objective under the Design, Region, and Criteria in this Contract.",
+    "When an Arc is active, stay within that current chapter.",
     "Leave lifecycle decisions to the caller; report the candidate, verification performed, and any unmet term.", "",
     "### Reviewer", "",
-    "Review the current candidate against the complete Contract and report material findings with direct evidence.",
-    "Do not modify the candidate. State which Criteria are covered and identify missing or unsupported evidence.",
+    "Review this Contract worktree against the complete Contract.",
+    "Review the complete current worktree snapshot, not a named candidate commit.",
+    "Do not modify it; report covered Criteria, findings, and missing evidence.",
 ].join("\n");
 export function renderContractGuidance(state) {
     return [
@@ -38,9 +62,9 @@ export function renderContractGuidance(state) {
         FULFILLMENT,
     ].join("\n\n").concat("\n");
 }
-function isTracked(repository, relativePath) {
+async function isTracked(repository, relativePath) {
     try {
-        runGit(repository, ["ls-files", "--error-unmatch", "--", relativePath]);
+        await runGit(repository, ["ls-files", "--error-unmatch", "--", relativePath]);
         return true;
     }
     catch (error) {
@@ -52,42 +76,39 @@ function isTracked(repository, relativePath) {
 function generatedPath(worktree, name) {
     return join(worktree, ".keiyaku", name);
 }
-export function readContractAppointment(repository) {
-    const path = generatedPath(worktreeRoot(repository), "KEIYAKU.md");
-    const stat = lstatSync(path, { throwIfNoEntry: false });
+export async function readContractAppointment(repository) {
+    const path = generatedPath(await worktreeRoot(repository), "KEIYAKU.md");
+    const stat = await lstat(path).catch((error) => {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    });
     if (stat === undefined)
         return { kind: "absent", path };
     if (!stat.isFile() || stat.isSymbolicLink())
         return { kind: "invalid", path };
-    const match = /^---\r?\ncontract: ([^\r\n]+)\r?\n---(?:\r?\n|$)/u.exec(readFileSync(path, "utf8"));
-    if (match?.[1] === undefined)
-        return { kind: "invalid", path };
-    try {
-        return { kind: "appointed", path, contract: contractId(match[1]) };
-    }
-    catch {
-        return { kind: "invalid", path };
-    }
+    const contract = appointedContract(await readFile(path, "utf8"));
+    return contract === undefined ? { kind: "invalid", path } : { kind: "appointed", path, contract };
 }
-export function reserveContractWorktree(repository, contract) {
-    const worktree = worktreeRoot(repository);
+export async function reserveContractWorktree(repository, contract) {
+    const worktree = await worktreeRoot(repository);
     const scoped = { ...repository, effectiveCwd: worktree };
     const ignore = generatedPath(worktree, ".gitignore");
-    if (isTracked(scoped, ".keiyaku/.gitignore"))
+    if (await isTracked(scoped, ".keiyaku/.gitignore"))
         throw new Error(`generated path is tracked by Git: ${ignore}`);
-    repairDerivedFile(ignore, IGNORE_BYTES);
+    await repairDerivedFile(ignore, IGNORE_BYTES);
     const path = generatedPath(worktree, "KEIYAKU.md");
-    if (isTracked(scoped, ".keiyaku/KEIYAKU.md"))
+    if (await isTracked(scoped, ".keiyaku/KEIYAKU.md"))
         throw new Error(`generated path is tracked by Git: ${path}`);
-    if (createFileDurablyExclusive(path, appointmentBytes(contract), 0o444))
+    if (await createFileDurablyExclusive(path, appointmentBytes(contract), 0o444))
         return { kind: "reserved", path };
-    const appointment = readContractAppointment(repository);
+    const appointment = await readContractAppointment(repository);
     return appointment.kind === "absent" ? { kind: "invalid", path } : appointment;
 }
 export async function withContractWorktreeAppointment(repository, action) {
-    const root = worktreeRoot(repository);
+    const root = await worktreeRoot(repository);
     const lock = await acquireSqliteTransactionLock({
-        path: join(worktreeGitDirectory(repository, root), "keiyaku", "contract-worktree.sqlite"),
+        path: join(await worktreeGitDirectory(repository, root), "keiyaku", "contract-worktree.sqlite"),
         mode: "immediate",
     });
     try {
@@ -97,38 +118,42 @@ export async function withContractWorktreeAppointment(repository, action) {
         lock.close();
     }
 }
-export function releaseContractWorktree(repository, contract) {
-    const appointment = readContractAppointment(repository);
+export async function releaseContractWorktree(repository, contract) {
+    const appointment = await readContractAppointment(repository);
     if (appointment.kind !== "appointed" || appointment.contract !== contract)
         return;
-    if (readFileSync(appointment.path, "utf8") !== appointmentBytes(contract))
+    if (await readFile(appointment.path, "utf8") !== appointmentBytes(contract))
         return;
     try {
-        unlinkSync(appointment.path);
+        await unlink(appointment.path);
     }
     catch { /* reservation cleanup is best effort */ }
 }
-export function removeContractWorktreeAppointment(repository, contract) {
-    const appointment = readContractAppointment(repository);
+export async function removeContractWorktreeAppointment(repository, contract) {
+    const appointment = await readContractAppointment(repository);
     if (appointment.kind !== "appointed" || appointment.contract !== contract)
         return;
-    unlinkSync(appointment.path);
+    await unlink(appointment.path);
 }
-function repair(repository, worktree, relativePath, bytes) {
+async function repair(repository, worktree, relativePath, bytes) {
     const path = join(worktree, relativePath);
-    if (isTracked(repository, relativePath))
+    if (await isTracked(repository, relativePath))
         throw new Error(`generated path is tracked by Git: ${path}`);
-    const action = repairDerivedFile(path, bytes);
+    const action = await repairDerivedFile(path, bytes);
     if (relativePath === ".keiyaku/KEIYAKU.md") {
         try {
-            chmodSync(path, 0o444);
+            await chmod(path, 0o444);
         }
         catch { /* advisory protection only */ }
     }
     return { kind: "contract-file", path, action };
 }
-function materialize(repository, worktree, guidance) {
-    const stat = lstatSync(worktree, { throwIfNoEntry: false });
+async function materialize(repository, worktree, guidance) {
+    const stat = await lstat(worktree).catch((error) => {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    });
     if (stat === undefined || !stat.isDirectory()) {
         return {
             effects: [],
@@ -147,7 +172,7 @@ function materialize(repository, worktree, guidance) {
         [".keiyaku/KEIYAKU.md", guidance],
     ]) {
         try {
-            effects.push(repair(scoped, worktree, relativePath, bytes));
+            effects.push(await repair(scoped, worktree, relativePath, bytes));
         }
         catch (error) {
             return {
@@ -163,11 +188,11 @@ function materialize(repository, worktree, guidance) {
     }
     return { effects, lag: [] };
 }
-function here(repository, state, guidance) {
-    const worktree = worktreeRoot(repository);
-    const appointment = readContractAppointment(repository);
+async function here(repository, state, guidance) {
+    const worktree = await worktreeRoot(repository);
+    const appointment = await readContractAppointment(repository);
     if (appointment.kind === "appointed" && appointment.contract === state.id) {
-        return materialize(repository, worktree, guidance);
+        return await materialize(repository, worktree, guidance);
     }
     const diagnostic = appointment.kind === "appointed"
         ? `here worktree is appointed to ${appointment.contract}`
@@ -177,9 +202,9 @@ function here(repository, state, guidance) {
         lag: [{ kind: "contract-file-failed", worktree, path: appointment.path, diagnostic }],
     };
 }
-function removeHere(repository, contract) {
-    const worktree = worktreeRoot(repository);
-    const appointment = readContractAppointment(repository);
+async function removeHere(repository, contract) {
+    const worktree = await worktreeRoot(repository);
+    const appointment = await readContractAppointment(repository);
     if (appointment.kind === "absent" || (appointment.kind === "appointed" && appointment.contract !== contract)) {
         return { effects: [], lag: [] };
     }
@@ -189,7 +214,7 @@ function removeHere(repository, contract) {
                 }] };
     }
     try {
-        unlinkSync(appointment.path);
+        await unlink(appointment.path);
         return { effects: [{ kind: "contract-file", path: appointment.path, action: "removed" }], lag: [] };
     }
     catch (error) {
@@ -201,13 +226,26 @@ function removeHere(repository, contract) {
                 }] };
     }
 }
-export function projectContractWorktree(repository, state) {
-    if (state === null)
-        return { effects: [], lag: [] };
+export async function projectContractWorktree(repository, state, register) {
+    if (state === null || state.terminal) {
+        return state?.coordinates.workspace === "here"
+            ? await removeHere(repository, state.id)
+            : { effects: [], lag: [] };
+    }
     if (state.coordinates.workspace === "here") {
-        return state.terminal ? removeHere(repository, state.id) : here(repository, state, renderContractGuidance(state));
+        return await here(repository, state, renderContractGuidance(state));
+    }
+    const appointed = appointmentFor(register ?? await readPlaceRegister(repository), state.id);
+    if (appointed === undefined) {
+        return {
+            effects: [],
+            lag: [{
+                    kind: "contract-file-failed",
+                    worktree: repository.primaryWorktree,
+                    path: placeRegisterPath(repository),
+                    diagnostic: "managed Contract is unappointed",
+                }],
+        };
     }
-    return state.terminal
-        ? { effects: [], lag: [] }
-        : materialize(repository, deliveryWorktreePath(repository, state.id), renderContractGuidance(state));
+    return await materialize(repository, worktreePath(repository, appointed.place), renderContractGuidance(state));
 }

package/build/src/coordination/durable-file.d.ts

@@ -1,4 +1,5 @@
-export declare function replaceFileDurably(path: string, bytes: string | Uint8Array): void;
+export declare function syncDirectory(path: string): void;
+export declare function replaceFileDurably(path: string, bytes: string | Uint8Array): Promise<void>;
 export type DerivedFileAction = "created" | "updated" | "unchanged";
-export declare function createFileDurablyExclusive(path: string, bytes: string | Uint8Array, mode?: number): boolean;
-export declare function repairDerivedFile(path: string, bytes: string | Uint8Array): DerivedFileAction;
+export declare function createFileDurablyExclusive(path: string, bytes: string | Uint8Array, mode?: number): Promise<boolean>;
+export declare function repairDerivedFile(path: string, bytes: string | Uint8Array): Promise<DerivedFileAction>;

package/build/src/coordination/durable-file.js

@@ -1,7 +1,19 @@
 import { randomBytes } from "node:crypto";
-import { closeSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { closeSync, fsyncSync, openSync, renameSync, writeFileSync, } from "node:fs";
+import { lstat, mkdir, readFile, unlink } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
-export function replaceFileDurably(path, bytes) {
+export function syncDirectory(path) {
+    if (process.platform === "win32")
+        return;
+    const directory = openSync(path, "r");
+    try {
+        fsyncSync(directory);
+    }
+    finally {
+        closeSync(directory);
+    }
+}
+export async function replaceFileDurably(path, bytes) {
     const parent = dirname(path);
     for (;;) {
         const temporary = resolve(parent, `.tmp-${randomBytes(8).toString("hex")}`);
@@ -13,20 +25,14 @@ export function replaceFileDurably(path, bytes) {
             closeSync(descriptor);
             descriptor = undefined;
             renameSync(temporary, path);
-            const directory = openSync(parent, "r");
-            try {
-                fsyncSync(directory);
-            }
-            finally {
-                closeSync(directory);
-            }
+            syncDirectory(parent);
             return;
         }
         catch (error) {
             if (descriptor !== undefined)
                 closeSync(descriptor);
             try {
-                unlinkSync(temporary);
+                await unlink(temporary);
             }
             catch { /* renamed, absent, or best-effort cleanup */ }
             if (error.code !== "EEXIST")
@@ -34,9 +40,9 @@ export function replaceFileDurably(path, bytes) {
         }
     }
 }
-export function createFileDurablyExclusive(path, bytes, mode = 0o600) {
+export async function createFileDurablyExclusive(path, bytes, mode = 0o600) {
     const parent = dirname(path);
-    mkdirSync(parent, { recursive: true });
+    await mkdir(parent, { recursive: true });
     let descriptor;
     try {
         descriptor = openSync(path, "wx", mode);
@@ -44,13 +50,7 @@ export function createFileDurablyExclusive(path, bytes, mode = 0o600) {
         fsyncSync(descriptor);
         closeSync(descriptor);
         descriptor = undefined;
-        const directory = openSync(parent, "r");
-        try {
-            fsyncSync(directory);
-        }
-        finally {
-            closeSync(directory);
-        }
+        syncDirectory(parent);
         return true;
     }
     catch (error) {
@@ -59,21 +59,25 @@ export function createFileDurablyExclusive(path, bytes, mode = 0o600) {
         if (error.code === "EEXIST")
             return false;
         try {
-            unlinkSync(path);
+            await unlink(path);
         }
         catch { /* absent or best-effort cleanup */ }
         throw error;
     }
 }
-export function repairDerivedFile(path, bytes) {
+export async function repairDerivedFile(path, bytes) {
     const expected = Buffer.from(bytes);
-    mkdirSync(dirname(path), { recursive: true });
-    const stat = lstatSync(path, { throwIfNoEntry: false });
+    await mkdir(dirname(path), { recursive: true });
+    const stat = await lstat(path).catch((error) => {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    });
     if (stat !== undefined && (!stat.isFile() || stat.isSymbolicLink())) {
         throw new Error(`derived file is not a regular file: ${path}`);
     }
-    if (stat !== undefined && readFileSync(path).equals(expected))
+    if (stat !== undefined && (await readFile(path)).equals(expected))
         return "unchanged";
-    replaceFileDurably(path, expected);
+    await replaceFileDurably(path, expected);
     return stat === undefined ? "created" : "updated";
 }

package/build/src/coordination/sqlite-transaction-lock.d.ts

@@ -12,3 +12,7 @@ export declare function acquireSqliteTransactionLock(input: {
     timeoutMs?: number;
     signal?: AbortSignal;
 }): Promise<HeldSqliteTransactionLock>;
+export declare function tryAcquireSqliteTransactionLock(input: {
+    path: string;
+    mode: SqliteTransactionLockMode;
+}): Promise<HeldSqliteTransactionLock | null>;

package/build/src/coordination/sqlite-transaction-lock.js

@@ -1,5 +1,5 @@
 import { randomInt } from "node:crypto";
-import { lstatSync, mkdirSync } from "node:fs";
+import { lstat, mkdir } from "node:fs/promises";
 import { dirname } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 const SQLITE_BUSY = 5;
@@ -41,13 +41,17 @@ function closeDatabase(database) {
     }
     return failure;
 }
-function openLock(path, mode) {
+async function openLock(path, mode) {
     try {
-        const stat = lstatSync(path, { throwIfNoEntry: false });
+        const stat = await lstat(path).catch((error) => {
+            if (error.code === "ENOENT")
+                return undefined;
+            throw error;
+        });
         if (stat && (!stat.isFile() || stat.isSymbolicLink())) {
             throw new SqliteTransactionLockError(`SQLite lock is not a regular file: ${path}`, "invalid");
         }
-        mkdirSync(dirname(path), { recursive: true });
+        await mkdir(dirname(path), { recursive: true });
     }
     catch (error) {
         if (error instanceof SqliteTransactionLockError)
@@ -101,7 +105,7 @@ export async function acquireSqliteTransactionLock(input) {
     for (;;) {
         input.signal?.throwIfAborted();
         try {
-            return openLock(input.path, input.mode);
+            return await openLock(input.path, input.mode);
         }
         catch (error) {
             if (!isBusy(error))
@@ -117,3 +121,16 @@ export async function acquireSqliteTransactionLock(input) {
         }
     }
 }
+export async function tryAcquireSqliteTransactionLock(input) {
+    if (input.path.length === 0) {
+        throw new SqliteTransactionLockError("SQLite lock path must be valid", "invalid");
+    }
+    try {
+        return await openLock(input.path, input.mode);
+    }
+    catch (error) {
+        if (isBusy(error))
+            return null;
+        throw error;
+    }
+}