@astrosheep/keiyaku 4.0.0 → 4.0.2

package/build/src/runtime/proc/line-rpc.js

@@ -1,5 +1,4 @@
-import { spawn } from "node:child_process";
-import { terminateProcessTree } from "./run.js";
+import { spawnStdioProcess } from "./stdio.js";
 function object(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -9,37 +8,25 @@ function text(value) {
     return typeof value === "string" && value.trim().length > 0 ? value : undefined;
 }
 export class LineRpcProcess {
-    child;
+    process;
     pending = new Map();
     notifications = new Set();
     serverRequests = new Set();
-    exited;
     nextId = 1;
     stdout = "";
-    stderr = "";
     closed = false;
     constructor(input) {
-        this.child = spawn(input.argv[0], input.argv.slice(1), {
-            cwd: input.cwd,
-            env: input.env ?? process.env,
-            detached: true,
-            stdio: ["pipe", "pipe", "pipe"],
-            windowsHide: true,
-        });
-        this.child.stdout.setEncoding("utf8");
-        this.child.stderr.setEncoding("utf8");
-        this.child.stdout.on("data", (chunk) => this.consume(chunk));
-        this.child.stderr.on("data", (chunk) => { this.stderr = `${this.stderr}${chunk}`.slice(-4_000); });
-        this.child.on("error", (error) => this.fail(error));
-        this.exited = new Promise((resolve) => this.child.once("close", (code, signal) => {
+        this.process = spawnStdioProcess(input);
+        this.process.output.setEncoding("utf8");
+        this.process.output.on("data", (chunk) => this.consume(chunk));
+        void this.process.exited.then((exit) => {
             this.closed = true;
-            this.fail(new Error(`line RPC process exited${code === null ? "" : ` with code ${code}`}`));
-            resolve({ code, signal, stderr: this.stderr.trim() });
-        }));
+            this.fail(new Error(`line RPC process exited${exit.code === null ? "" : ` with code ${exit.code}`}`));
+        });
     }
     onNotification(listener) { this.notifications.add(listener); }
     onServerRequest(listener) { this.serverRequests.add(listener); }
-    onExit(listener) { void this.exited.then(listener); }
+    onExit(listener) { void this.process.exited.then(listener); }
     consume(chunk) {
         this.stdout += chunk;
         for (;;) {
@@ -98,7 +85,7 @@ export class LineRpcProcess {
         const id = this.nextId++;
         return new Promise((resolve, reject) => {
             this.pending.set(id, { resolve, reject });
-            this.child.stdin.write(`${JSON.stringify({ id, method, ...(params === undefined ? {} : { params }) })}\n`, (error) => {
+            this.process.input.write(`${JSON.stringify({ id, method, ...(params === undefined ? {} : { params }) })}\n`, (error) => {
                 if (error === null || error === undefined)
                     return;
                 this.pending.delete(id);
@@ -108,17 +95,24 @@ export class LineRpcProcess {
     }
     notify(method) {
         if (!this.closed)
-            this.child.stdin.write(`${JSON.stringify({ method })}\n`);
+            this.process.input.write(`${JSON.stringify({ method })}\n`);
+    }
+    async endInputAndDrain(timeoutMs) {
+        if (this.closed) {
+            await this.process.exited;
+            return;
+        }
+        this.closed = true;
+        this.fail(new Error("line RPC process is closed"));
+        await this.process.endInputAndDrain(timeoutMs);
     }
     async close(force = false) {
         if (this.closed) {
-            await this.exited;
+            await this.process.exited;
             return;
         }
         this.closed = true;
         this.fail(new Error("line RPC process is closed"));
-        this.child.stdin.end();
-        await terminateProcessTree(this.child.pid, force);
-        await this.exited;
+        await this.process.close(force);
     }
 }

package/build/src/runtime/proc/run.d.ts

@@ -1,10 +1,12 @@
+import { type ChildProcess } from "node:child_process";
 type ProcessLaunch = Readonly<{
     readonly argv: readonly string[];
     readonly cwd?: string;
     readonly env?: NodeJS.ProcessEnv;
+    readonly signal?: AbortSignal;
 }>;
 export type ProcessInput = ProcessLaunch & Readonly<{
-    readonly timeoutMs: number;
+    readonly timeoutMs?: number;
 }>;
 type ProcessTerminal = Readonly<{
     readonly kind: "terminal";
@@ -23,32 +25,32 @@ type ProcessSpawnError = Readonly<{
 type ProcessUnknownExit = Readonly<{
     readonly kind: "unknown-exit";
 }>;
-export type ProcessOutcome = ProcessTerminal | ProcessTimeout | ProcessSpawnError | ProcessUnknownExit;
-export type ProcessCollar = Readonly<{
-    pid: number;
-    processGroup: number;
-    spawnedAt: string;
-}>;
-export type ProcessTreeProbe = Readonly<{
-    kind: "gone";
-}> | Readonly<{
-    kind: "alive";
-}> | Readonly<{
-    kind: "unverifiable";
-    diagnostic: string;
-}>;
-export type PutDownEvidence = "killed" | "already-dead" | "alive-after-sigkill" | "unavailable";
+type ProcessCancelled = Readonly<{
+    readonly kind: "cancelled";
+}>;
+export type ProcessOutcome = ProcessTerminal | ProcessTimeout | ProcessSpawnError | ProcessUnknownExit | ProcessCancelled;
+type ProcessStreamError = Readonly<{
+    readonly kind: "stream-error";
+    readonly diagnostic: string;
+}>;
+export type ProcessConsumption = Readonly<{
+    readonly outcome: ProcessOutcome | ProcessStreamError;
+    readonly pid: number | null;
+}>;
 export type DetachedProcessInput = Readonly<{
     argv: readonly string[];
     cwd: string;
     env?: NodeJS.ProcessEnv;
     log: string;
 }>;
-export declare function terminateProcessTree(pid: number | undefined, force?: boolean): Promise<void>;
-export declare function currentProcessCollar(): ProcessCollar;
-export declare function spawnDetachedProcess(input: DetachedProcessInput): Promise<ProcessCollar>;
-export declare function probeProcessTree(collar: ProcessCollar): ProcessTreeProbe;
-export declare function putDownProcessTree(collar: ProcessCollar): Promise<PutDownEvidence>;
+export type OwnedProcess = Readonly<{
+    pid: number;
+    terminate(force?: boolean): Promise<void>;
+    release(): void;
+}>;
+export declare function terminateOwnedProcess(child: ChildProcess, force?: boolean): Promise<void>;
+export declare function spawnDetachedProcess(input: DetachedProcessInput): Promise<OwnedProcess>;
 export declare function runProcess(input: ProcessInput): Promise<ProcessOutcome>;
 export declare function runProcessToExit(input: ProcessLaunch): Promise<ProcessOutcome>;
+export declare function consumeProcessStdout(input: ProcessInput, consume: (chunk: Buffer) => void): Promise<ProcessConsumption>;
 export {};

package/build/src/runtime/proc/run.js

@@ -1,5 +1,7 @@
-import { spawn, spawnSync } from "node:child_process";
-import { closeSync, openSync } from "node:fs";
+import { execFile, spawn } from "node:child_process";
+import { open } from "node:fs/promises";
+import { setTimeout as delay } from "node:timers/promises";
+import { promisify } from "node:util";
 const TERMINATION_GRACE_MS = 250;
 const STREAM_TAIL_BYTES = 16 * 1024;
 function tailCapture(limit) {
@@ -31,25 +33,21 @@ function tailCapture(limit) {
         },
     };
 }
-function wait(milliseconds) {
-    return new Promise((resolve) => setTimeout(resolve, milliseconds));
-}
 function ignoreMissingProcess(error) {
     if (error.code !== "ESRCH")
         throw error;
 }
-function terminateWindowsTree(pid) {
-    return new Promise((resolve) => {
-        const taskkill = spawn("taskkill", ["/PID", String(pid), "/T", "/F"], {
-            stdio: "ignore",
-            windowsHide: true,
-        });
-        taskkill.once("error", resolve);
-        taskkill.once("close", resolve);
+const WINDOWS_TERMINATION_TIMEOUT_MS = 1_000;
+const execFileAsync = promisify(execFile);
+async function terminateWindowsTree(pid) {
+    await execFileAsync("taskkill", ["/PID", String(pid), "/T", "/F"], {
+        timeout: WINDOWS_TERMINATION_TIMEOUT_MS,
+        windowsHide: true,
     });
 }
-export async function terminateProcessTree(pid, force = false) {
-    if (pid === undefined)
+export async function terminateOwnedProcess(child, force = false) {
+    const pid = child.pid;
+    if (pid === undefined || child.exitCode !== null || child.signalCode !== null)
         return;
     if (process.platform === "win32") {
         await terminateWindowsTree(pid);
@@ -64,6 +62,11 @@ export async function terminateProcessTree(pid, force = false) {
         }
         return;
     }
+    let exited = false;
+    const exit = new Promise((resolve) => {
+        child.once("exit", () => { exited = true; resolve(); });
+        child.once("close", () => { exited = true; resolve(); });
+    });
     try {
         process.kill(-pid, "SIGTERM");
     }
@@ -71,7 +74,9 @@ export async function terminateProcessTree(pid, force = false) {
         ignoreMissingProcess(error);
         return;
     }
-    await wait(TERMINATION_GRACE_MS);
+    await Promise.race([exit, delay(TERMINATION_GRACE_MS)]);
+    if (exited || child.exitCode !== null || child.signalCode !== null)
+        return;
     try {
         process.kill(-pid, "SIGKILL");
     }
@@ -79,28 +84,14 @@ export async function terminateProcessTree(pid, force = false) {
         ignoreMissingProcess(error);
     }
 }
-function processStartToken(pid) {
-    const command = process.platform === "win32"
-        ? ["powershell.exe", "-NoProfile", "-Command", `(Get-CimInstance Win32_Process -Filter \"ProcessId=${pid}\").CreationDate`]
-        : ["ps", "-o", "lstart=", "-p", String(pid)];
-    const result = spawnSync(command[0], command.slice(1), { encoding: "utf8", windowsHide: true });
-    const token = result.status === 0 ? result.stdout.trim() : "";
-    return token.length === 0 ? null : token;
-}
-export function currentProcessCollar() {
-    const spawnedAt = processStartToken(process.pid);
-    if (spawnedAt === null)
-        throw new Error(`cannot read process start identity for ${process.pid}`);
-    return { pid: process.pid, processGroup: process.pid, spawnedAt };
-}
 export async function spawnDetachedProcess(input) {
-    const log = openSync(input.log, "a");
+    const log = await open(input.log, "a");
     try {
         const child = spawn(input.argv[0], input.argv.slice(1), {
             cwd: input.cwd,
             env: input.env,
             detached: true,
-            stdio: ["ignore", log, log],
+            stdio: ["ignore", log.fd, log.fd],
             windowsHide: true,
         });
         await new Promise((resolve, reject) => {
@@ -109,46 +100,47 @@ export async function spawnDetachedProcess(input) {
         });
         if (child.pid === undefined)
             throw new Error("detached process spawned without a pid");
-        const spawnedAt = processStartToken(child.pid);
-        if (spawnedAt === null)
-            throw new Error(`cannot read process start identity for ${child.pid}`);
-        child.unref();
-        return { pid: child.pid, processGroup: child.pid, spawnedAt };
+        const pid = child.pid;
+        let state = "active";
+        let termination;
+        const invalidate = () => { state = "inert"; };
+        child.once("exit", invalidate);
+        child.once("close", invalidate);
+        return {
+            pid,
+            terminate(force = false) {
+                if (state === "inert")
+                    return Promise.resolve();
+                if (termination !== undefined)
+                    return termination;
+                state = "terminating";
+                termination = terminateOwnedProcess(child, force).finally(invalidate);
+                return termination;
+            },
+            release: () => {
+                if (state === "inert")
+                    return;
+                state = "inert";
+                child.unref();
+            },
+        };
     }
     finally {
-        closeSync(log);
+        await log.close();
     }
 }
-export function probeProcessTree(collar) {
-    try {
-        process.kill(process.platform === "win32" ? collar.pid : -collar.processGroup, 0);
-    }
-    catch (error) {
-        const code = error.code;
-        if (code === "ESRCH")
-            return { kind: "gone" };
-        return { kind: "unverifiable", diagnostic: error instanceof Error ? error.message : String(error) };
-    }
-    const current = processStartToken(collar.pid);
-    if (current === null && process.platform !== "win32")
-        return { kind: "alive" };
-    if (current === collar.spawnedAt)
-        return { kind: "alive" };
-    return { kind: "unverifiable", diagnostic: `process ${collar.pid} no longer matches its recorded start identity` };
-}
-export async function putDownProcessTree(collar) {
-    const before = probeProcessTree(collar);
-    if (before.kind === "gone")
-        return "already-dead";
-    if (before.kind === "unverifiable")
-        return "unavailable";
-    await terminateProcessTree(collar.pid);
-    const after = probeProcessTree(collar);
-    if (after.kind === "gone")
-        return "killed";
-    return after.kind === "alive" ? "alive-after-sigkill" : "unavailable";
+function terminalOutcome(code, stdout, stderr, consuming) {
+    return {
+        kind: "terminal",
+        code,
+        stdout: consuming ? "" : stdout.text,
+        stderr: stderr.text,
+        truncated: (consuming ? false : stdout.truncated) || stderr.truncated,
+    };
 }
-async function executeProcess(input, timeoutMs) {
+async function executeProcess(input, timeoutMs, consumeStdout) {
+    if (input.signal?.aborted === true)
+        return { outcome: { kind: "cancelled" }, pid: null };
     const child = spawn(input.argv[0], input.argv.slice(1), {
         cwd: input.cwd,
         env: input.env,
@@ -158,43 +150,85 @@ async function executeProcess(input, timeoutMs) {
     });
     const stdout = tailCapture(STREAM_TAIL_BYTES);
     const stderr = tailCapture(STREAM_TAIL_BYTES);
-    child.stdout.on("data", (chunk) => stdout.append(chunk));
-    child.stderr.on("data", (chunk) => stderr.append(chunk));
-    let timedOut = false;
+    let stop;
+    let streamError;
     let termination;
-    const requestStop = () => {
-        if (timedOut)
+    const requestStop = (reason) => {
+        if (stop !== undefined)
+            return;
+        stop = reason;
+        termination = terminateOwnedProcess(child);
+    };
+    const failStream = (error) => {
+        if (streamError !== undefined)
             return;
-        timedOut = true;
-        termination = terminateProcessTree(child.pid);
+        streamError = error;
+        requestStop("cancelled");
     };
-    const timeout = timeoutMs === undefined ? undefined : setTimeout(requestStop, timeoutMs);
+    child.stdout.on("data", (chunk) => {
+        if (consumeStdout === undefined) {
+            stdout.append(chunk);
+            return;
+        }
+        try {
+            consumeStdout(chunk);
+        }
+        catch (error) {
+            failStream(error);
+        }
+    });
+    child.stderr.on("data", (chunk) => stderr.append(chunk));
+    if (consumeStdout !== undefined) {
+        child.stdout.once("error", failStream);
+        child.stderr.once("error", failStream);
+    }
+    const cancel = () => requestStop("cancelled");
+    input.signal?.addEventListener("abort", cancel, { once: true });
+    const timeout = timeoutMs === undefined ? undefined : setTimeout(() => requestStop("timeout"), timeoutMs);
     const terminal = await new Promise((resolve) => {
         child.once("close", (code) => resolve({ kind: "closed", code }));
         child.once("error", (error) => resolve({ kind: "spawn-error", error }));
     });
     if (timeout !== undefined)
         clearTimeout(timeout);
+    input.signal?.removeEventListener("abort", cancel);
     await termination;
-    if (terminal.kind === "spawn-error")
-        return { kind: "spawn-error", diagnostic: terminal.error.message };
-    if (timedOut)
-        return { kind: "timeout" };
+    const pid = child.pid ?? null;
+    if (terminal.kind === "spawn-error") {
+        return { outcome: { kind: "spawn-error", diagnostic: terminal.error.message }, pid };
+    }
+    if (streamError !== undefined) {
+        return {
+            outcome: {
+                kind: "stream-error",
+                diagnostic: streamError instanceof Error ? streamError.message : String(streamError),
+            },
+            pid,
+        };
+    }
+    if (stop !== undefined)
+        return { outcome: { kind: stop }, pid };
     if (terminal.code === null)
-        return { kind: "unknown-exit" };
+        return { outcome: { kind: "unknown-exit" }, pid };
     const capturedStdout = stdout.result();
     const capturedStderr = stderr.result();
     return {
-        kind: "terminal",
-        code: terminal.code,
-        stdout: capturedStdout.text,
-        stderr: capturedStderr.text,
-        truncated: capturedStdout.truncated || capturedStderr.truncated,
+        outcome: terminalOutcome(terminal.code, capturedStdout, capturedStderr, consumeStdout !== undefined),
+        pid,
     };
 }
-export function runProcess(input) {
-    return executeProcess(input, input.timeoutMs);
+export async function runProcess(input) {
+    const result = await executeProcess(input, input.timeoutMs);
+    if (result.outcome.kind === "stream-error")
+        throw new Error("buffered process produced a stream consumer error");
+    return result.outcome;
+}
+export async function runProcessToExit(input) {
+    const result = await executeProcess(input, undefined);
+    if (result.outcome.kind === "stream-error")
+        throw new Error("buffered process produced a stream consumer error");
+    return result.outcome;
 }
-export function runProcessToExit(input) {
-    return executeProcess(input, undefined);
+export function consumeProcessStdout(input, consume) {
+    return executeProcess(input, input.timeoutMs, consume);
 }

package/build/src/runtime/proc/stdio.d.ts

@@ -0,0 +1,18 @@
+import type { Readable, Writable } from "node:stream";
+export type StdioProcessExit = Readonly<{
+    code: number | null;
+    signal: NodeJS.Signals | null;
+    stderr: string;
+}>;
+export type StdioProcess = Readonly<{
+    input: Writable;
+    output: Readable;
+    exited: Promise<StdioProcessExit>;
+    endInputAndDrain(timeoutMs?: number): Promise<void>;
+    close(force?: boolean): Promise<void>;
+}>;
+export declare function spawnStdioProcess(input: Readonly<{
+    argv: readonly [string, ...string[]];
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+}>): StdioProcess;

package/build/src/runtime/proc/stdio.js

@@ -0,0 +1,58 @@
+import { spawn } from "node:child_process";
+import { setTimeout as delay } from "node:timers/promises";
+import { terminateOwnedProcess } from "./run.js";
+const DEFAULT_DRAIN_TIMEOUT_MS = 1_000;
+export function spawnStdioProcess(input) {
+    const child = spawn(input.argv[0], input.argv.slice(1), {
+        cwd: input.cwd,
+        env: input.env ?? process.env,
+        detached: true,
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+    });
+    let stderr = "";
+    let inputEnded = false;
+    let forced;
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => { stderr = `${stderr}${chunk}`.slice(-4_000); });
+    const exited = new Promise((resolve) => {
+        child.once("close", (code, signal) => resolve({ code, signal, stderr: stderr.trim() }));
+        child.once("error", (error) => resolve({ code: null, signal: null, stderr: error.message }));
+    });
+    const endInput = () => {
+        if (inputEnded)
+            return;
+        inputEnded = true;
+        child.stdin.end();
+    };
+    const forceClose = async () => {
+        forced ??= (async () => {
+            await terminateOwnedProcess(child, true);
+            await exited;
+        })();
+        await forced;
+    };
+    const endInputAndDrain = async (timeoutMs = DEFAULT_DRAIN_TIMEOUT_MS) => {
+        endInput();
+        if (forced !== undefined) {
+            await forced;
+            return;
+        }
+        const timedOut = await Promise.race([
+            exited.then(() => false),
+            delay(timeoutMs, true, { ref: false }),
+        ]);
+        if (timedOut)
+            await forceClose();
+    };
+    const close = async (force = false) => {
+        endInput();
+        if (force) {
+            await forceClose();
+            return;
+        }
+        await terminateOwnedProcess(child, false);
+        await exited;
+    };
+    return { input: child.stdin, output: child.stdout, exited, endInputAndDrain, close };
+}

package/build/src/settings.d.ts

@@ -42,4 +42,10 @@ export type SettingsInput = Readonly<{
     root?: string;
     home?: string;
 }>;
-export declare function settings(input?: SettingsInput): Settings;
+export declare class SettingsError extends Error {
+    readonly kind = "settings";
+    constructor(message: string);
+}
+export declare function settings(input?: SettingsInput): Promise<Settings>;
+/** Read only the project scope owned by a materialized candidate snapshot. */
+export declare function projectSettings(root: string): Promise<Settings>;

package/build/src/settings.js

@@ -1,6 +1,13 @@
-import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
+export class SettingsError extends Error {
+    kind = "settings";
+    constructor(message) {
+        super(message);
+        this.name = "SettingsError";
+    }
+}
 function object(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -20,10 +27,10 @@ function freezeJson(value) {
 function bounded(error) {
     return (error instanceof Error ? error.message : String(error)).slice(0, 500);
 }
-function readScope(path) {
+async function readScope(path) {
     let bytes;
     try {
-        bytes = readFileSync(path, "utf8");
+        bytes = await readFile(path, "utf8");
     }
     catch (error) {
         if (error.code === "ENOENT")
@@ -60,20 +67,7 @@ function namespaceEntries(name, scope, loaded) {
         })),
     };
 }
-export function settings(input = {}) {
-    if (!object(input))
-        throw new TypeError("settings input must be an object");
-    if (input.root !== undefined && (typeof input.root !== "string" || input.root.trim().length === 0)) {
-        throw new TypeError("settings root must be a nonblank string");
-    }
-    if (input.home !== undefined && (typeof input.home !== "string" || input.home.trim().length === 0)) {
-        throw new TypeError("settings home must be a nonblank string");
-    }
-    const home = resolve(input.home ?? join(homedir(), ".keiyaku"));
-    const user = readScope(join(home, "settings.json"));
-    const project = input.root === undefined
-        ? { state: { kind: "absent" } }
-        : readScope(join(resolve(input.root), ".keiyaku", "settings.json"));
+function settingsFromScopes(project, user) {
     return Object.freeze({
         scopes: Object.freeze({ project: project.state, user: user.state }),
         namespace(name) {
@@ -97,3 +91,24 @@ export function settings(input = {}) {
         },
     });
 }
+export async function settings(input = {}) {
+    if (!object(input))
+        throw new TypeError("settings input must be an object");
+    if (input.root !== undefined && (typeof input.root !== "string" || input.root.trim().length === 0)) {
+        throw new TypeError("settings root must be a nonblank string");
+    }
+    if (input.home !== undefined && (typeof input.home !== "string" || input.home.trim().length === 0)) {
+        throw new TypeError("settings home must be a nonblank string");
+    }
+    const project = input.root === undefined
+        ? { state: { kind: "absent" } }
+        : await readScope(join(resolve(input.root), ".keiyaku", "settings.json"));
+    const user = await readScope(join(resolve(input.home ?? join(homedir(), ".keiyaku")), "settings.json"));
+    return settingsFromScopes(project, user);
+}
+/** Read only the project scope owned by a materialized candidate snapshot. */
+export async function projectSettings(root) {
+    if (typeof root !== "string" || root.trim().length === 0)
+        throw new TypeError("settings root must be a nonblank string");
+    return settingsFromScopes(await readScope(join(resolve(root), ".keiyaku", "settings.json")), { state: { kind: "absent" } });
+}

package/build/src/settlement/fence.d.ts

@@ -0,0 +1,5 @@
+import { type HeldSqliteTransactionLock } from "../coordination/sqlite-transaction-lock.js";
+import { type GitRepository } from "../git/repository.js";
+import type { TaskId } from "../task/identity.js";
+export declare function settlementFencePath(repository: GitRepository, taskId: TaskId): string;
+export declare function acquireTaskSettlementFence(repository: GitRepository, taskId: TaskId): Promise<HeldSqliteTransactionLock>;

package/build/src/settlement/fence.js

@@ -0,0 +1,14 @@
+import { createHash } from "node:crypto";
+import { resolve } from "node:path";
+import { acquireSqliteTransactionLock, } from "../coordination/sqlite-transaction-lock.js";
+import { commonGitDirectory } from "../git/repository.js";
+export function settlementFencePath(repository, taskId) {
+    const locator = createHash("sha256").update(taskId).digest("hex");
+    return resolve(commonGitDirectory(repository), "keiyaku", "locks", "settlement", `${locator}.sqlite`);
+}
+export function acquireTaskSettlementFence(repository, taskId) {
+    return acquireSqliteTransactionLock({
+        path: settlementFencePath(repository, taskId),
+        mode: "immediate",
+    });
+}