@astrosheep/keiyaku 4.0.0 → 4.0.2

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

@@ -1,5 +1,15 @@
-import type { AuditReport, ChangeId, ContractId, Fact, PlacementStop, ReconcileReport, RegionOverlap, 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;
@@ -7,34 +17,117 @@ export type AcceptedFact = Readonly<{
     kind: Fact["kind"];
 }>;
 export type Lag = ReconcileReport["lag"][number];
-export type DiffUnavailable = Readonly<{
-    reason: "git-unavailable";
-    snapshotId: 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;
-    leak?: NonNullable<AuditReport["leak"]>;
-    overlaps?: readonly RegionOverlap[];
-    overlapFailure?: string;
-    report?: AuditReport;
-    diff?: string | DiffUnavailable;
-    lag?: readonly Lag[];
+    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;
+    workspace?: Review["workspace"];
+    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";
@@ -47,9 +140,23 @@ export type ObservationResult = Readonly<{
     command: string;
     [key: string]: unknown;
 }>;
+export type GuidanceResult = Readonly<{
+    kind: "guidance";
+    contract: ContractId;
+    guidance: string;
+}>;
 export type StatusResult = Readonly<{
     kind: "status";
     report: KanshiReport;
     selection: "world" | "contract";
 }>;
-export type InvocationResult = AcceptedResult | RefusedResult | RetryResult | ObservationResult | StatusResult;
+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 | 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

@@ -0,0 +1,44 @@
+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";
+    path: string;
+    action: DerivedFileAction | "removed";
+}>;
+export type ContractFileLag = Readonly<{
+    kind: "contract-file-failed";
+    worktree: string;
+    path: string;
+    diagnostic: string;
+}>;
+export type ContractWorktreeResult = Readonly<{
+    effects: readonly ContractFileEffect[];
+    lag: readonly ContractFileLag[];
+}>;
+export type ContractAppointment = Readonly<{
+    kind: "absent";
+    path: string;
+}> | Readonly<{
+    kind: "appointed";
+    path: string;
+    contract: ContractId;
+}> | Readonly<{
+    kind: "invalid";
+    path: string;
+}>;
+export declare function readContractAppointment(repository: GitRepository): Promise<ContractAppointment>;
+export type ContractReservation = Readonly<{
+    kind: "reserved";
+    path: string;
+}> | Exclude<ContractAppointment, Readonly<{
+    kind: "absent";
+    path: string;
+}>>;
+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): 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

@@ -0,0 +1,251 @@
+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 { 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}\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 [
+        "## Arc", "", "### Sequence", "", String(arc.seq), "", "### Title", "", arc.title.trimEnd(), "",
+        "### Objective", "", arc.objective.trimEnd(), "", "### Brief", "", arc.brief.trimEnd(),
+    ].join("\n");
+}
+const FULFILLMENT = [
+    "## Fulfillment", "", "### Appointment", "",
+    "Each commission names exactly one seat: Deliverer or Reviewer.",
+    "If no seat was named, stop and ask the caller. Never infer it.", "",
+    "### Worktree", "",
+    "This file is a derived view of the journal-authoritative Contract. Never edit it to change the Contract.",
+    "Treat the directory containing `.keiyaku/KEIYAKU.md` as the Contract worktree root.",
+    "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 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 [
+        appointmentBytes(state.id).trimEnd(),
+        state.terms.document.bytes.trimEnd(),
+        ...(state.currentArc === undefined ? [] : [renderArc(state.currentArc.data)]),
+        FULFILLMENT,
+    ].join("\n\n").concat("\n");
+}
+async function isTracked(repository, relativePath) {
+    try {
+        await runGit(repository, ["ls-files", "--error-unmatch", "--", relativePath]);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof GitPlumbingError && error.status === 1)
+            return false;
+        throw error;
+    }
+}
+function generatedPath(worktree, name) {
+    return join(worktree, ".keiyaku", name);
+}
+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 contract = appointedContract(await readFile(path, "utf8"));
+    return contract === undefined ? { kind: "invalid", path } : { kind: "appointed", path, contract };
+}
+export async function reserveContractWorktree(repository, contract) {
+    const worktree = await worktreeRoot(repository);
+    const scoped = { ...repository, effectiveCwd: worktree };
+    const ignore = generatedPath(worktree, ".gitignore");
+    if (await isTracked(scoped, ".keiyaku/.gitignore"))
+        throw new Error(`generated path is tracked by Git: ${ignore}`);
+    await repairDerivedFile(ignore, IGNORE_BYTES);
+    const path = generatedPath(worktree, "KEIYAKU.md");
+    if (await isTracked(scoped, ".keiyaku/KEIYAKU.md"))
+        throw new Error(`generated path is tracked by Git: ${path}`);
+    if (await createFileDurablyExclusive(path, appointmentBytes(contract), 0o444))
+        return { kind: "reserved", path };
+    const appointment = await readContractAppointment(repository);
+    return appointment.kind === "absent" ? { kind: "invalid", path } : appointment;
+}
+export async function withContractWorktreeAppointment(repository, action) {
+    const root = await worktreeRoot(repository);
+    const lock = await acquireSqliteTransactionLock({
+        path: join(await worktreeGitDirectory(repository, root), "keiyaku", "contract-worktree.sqlite"),
+        mode: "immediate",
+    });
+    try {
+        return await action();
+    }
+    finally {
+        lock.close();
+    }
+}
+export async function releaseContractWorktree(repository, contract) {
+    const appointment = await readContractAppointment(repository);
+    if (appointment.kind !== "appointed" || appointment.contract !== contract)
+        return;
+    if (await readFile(appointment.path, "utf8") !== appointmentBytes(contract))
+        return;
+    try {
+        await unlink(appointment.path);
+    }
+    catch { /* reservation cleanup is best effort */ }
+}
+export async function removeContractWorktreeAppointment(repository, contract) {
+    const appointment = await readContractAppointment(repository);
+    if (appointment.kind !== "appointed" || appointment.contract !== contract)
+        return;
+    await unlink(appointment.path);
+}
+async function repair(repository, worktree, relativePath, bytes) {
+    const path = join(worktree, relativePath);
+    if (await isTracked(repository, relativePath))
+        throw new Error(`generated path is tracked by Git: ${path}`);
+    const action = await repairDerivedFile(path, bytes);
+    if (relativePath === ".keiyaku/KEIYAKU.md") {
+        try {
+            await chmod(path, 0o444);
+        }
+        catch { /* advisory protection only */ }
+    }
+    return { kind: "contract-file", path, action };
+}
+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: [],
+            lag: [{
+                    kind: "contract-file-failed",
+                    worktree,
+                    path: generatedPath(worktree, "KEIYAKU.md"),
+                    diagnostic: "Contract worktree is unavailable",
+                }],
+        };
+    }
+    const scoped = { ...repository, effectiveCwd: worktree };
+    const effects = [];
+    for (const [relativePath, bytes] of [
+        [".keiyaku/.gitignore", IGNORE_BYTES],
+        [".keiyaku/KEIYAKU.md", guidance],
+    ]) {
+        try {
+            effects.push(await repair(scoped, worktree, relativePath, bytes));
+        }
+        catch (error) {
+            return {
+                effects,
+                lag: [{
+                        kind: "contract-file-failed",
+                        worktree,
+                        path: join(worktree, relativePath),
+                        diagnostic: error instanceof Error ? error.message : String(error),
+                    }],
+            };
+        }
+    }
+    return { effects, lag: [] };
+}
+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 await materialize(repository, worktree, guidance);
+    }
+    const diagnostic = appointment.kind === "appointed"
+        ? `here worktree is appointed to ${appointment.contract}`
+        : `here Contract appointment is ${appointment.kind}`;
+    return {
+        effects: [],
+        lag: [{ kind: "contract-file-failed", worktree, path: appointment.path, diagnostic }],
+    };
+}
+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: [] };
+    }
+    if (appointment.kind === "invalid") {
+        return { effects: [], lag: [{
+                    kind: "contract-file-failed", worktree, path: appointment.path, diagnostic: "here Contract appointment is invalid",
+                }] };
+    }
+    try {
+        await unlink(appointment.path);
+        return { effects: [{ kind: "contract-file", path: appointment.path, action: "removed" }], lag: [] };
+    }
+    catch (error) {
+        return { effects: [], lag: [{
+                    kind: "contract-file-failed",
+                    worktree,
+                    path: appointment.path,
+                    diagnostic: error instanceof Error ? error.message : String(error),
+                }] };
+    }
+}
+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 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 await materialize(repository, worktreePath(repository, appointed.place), renderContractGuidance(state));
+}

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

@@ -1 +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): 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, openSync, 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,3 +40,44 @@ export function replaceFileDurably(path, bytes) {
         }
     }
 }
+export async function createFileDurablyExclusive(path, bytes, mode = 0o600) {
+    const parent = dirname(path);
+    await mkdir(parent, { recursive: true });
+    let descriptor;
+    try {
+        descriptor = openSync(path, "wx", mode);
+        writeFileSync(descriptor, bytes);
+        fsyncSync(descriptor);
+        closeSync(descriptor);
+        descriptor = undefined;
+        syncDirectory(parent);
+        return true;
+    }
+    catch (error) {
+        if (descriptor !== undefined)
+            closeSync(descriptor);
+        if (error.code === "EEXIST")
+            return false;
+        try {
+            await unlink(path);
+        }
+        catch { /* absent or best-effort cleanup */ }
+        throw error;
+    }
+}
+export async function repairDerivedFile(path, bytes) {
+    const expected = Buffer.from(bytes);
+    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 && (await readFile(path)).equals(expected))
+        return "unchanged";
+    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;
+    }
+}