@astrosheep/keiyaku 2.9.13 → 4.0.1

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

@@ -0,0 +1,145 @@
+import { spawn } from "node:child_process";
+import { terminateProcessTree } from "./run.js";
+const DEFAULT_DRAIN_TIMEOUT_MS = 1_000;
+function bounded(promise, milliseconds) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => resolve(undefined), milliseconds);
+        void promise.then((value) => { clearTimeout(timer); resolve(value); }, (error) => { clearTimeout(timer); reject(error); });
+    });
+}
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function text(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+export class LineRpcProcess {
+    child;
+    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.closed = true;
+            this.fail(new Error(`line RPC process exited${code === null ? "" : ` with code ${code}`}`));
+            resolve({ code, signal, stderr: this.stderr.trim() });
+        }));
+    }
+    onNotification(listener) { this.notifications.add(listener); }
+    onServerRequest(listener) { this.serverRequests.add(listener); }
+    onExit(listener) { void this.exited.then(listener); }
+    consume(chunk) {
+        this.stdout += chunk;
+        for (;;) {
+            const newline = this.stdout.indexOf("\n");
+            if (newline < 0)
+                return;
+            const line = this.stdout.slice(0, newline).trim();
+            this.stdout = this.stdout.slice(newline + 1);
+            if (line.length > 0)
+                this.receive(line);
+        }
+    }
+    receive(line) {
+        let decoded;
+        try {
+            decoded = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        const message = object(decoded);
+        if (message === undefined)
+            return;
+        if (typeof message.id === "number" && ("result" in message || "error" in message)) {
+            const pending = this.pending.get(message.id);
+            if (pending === undefined)
+                return;
+            this.pending.delete(message.id);
+            const error = object(message.error);
+            if (error !== undefined)
+                pending.reject(new Error(text(error.message) ?? "line RPC error"));
+            else
+                pending.resolve(message.result);
+            return;
+        }
+        const method = text(message.method);
+        if (method === undefined)
+            return;
+        const params = object(message.params);
+        if (typeof message.id === "number" || typeof message.id === "string") {
+            for (const listener of this.serverRequests)
+                listener({ id: message.id, method, ...(params === undefined ? {} : { params }) });
+            return;
+        }
+        for (const listener of this.notifications)
+            listener({ method, ...(params === undefined ? {} : { params }) });
+    }
+    fail(error) {
+        for (const pending of this.pending.values())
+            pending.reject(error);
+        this.pending.clear();
+    }
+    request(method, params) {
+        if (this.closed)
+            return Promise.reject(new Error("line RPC process is closed"));
+        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) => {
+                if (error === null || error === undefined)
+                    return;
+                this.pending.delete(id);
+                reject(error);
+            });
+        });
+    }
+    notify(method) {
+        if (!this.closed)
+            this.child.stdin.write(`${JSON.stringify({ method })}\n`);
+    }
+    async endInputAndDrain(timeoutMs = DEFAULT_DRAIN_TIMEOUT_MS) {
+        if (this.closed) {
+            await this.exited;
+            return;
+        }
+        this.closed = true;
+        this.fail(new Error("line RPC process is closed"));
+        this.child.stdin.end();
+        const drained = await bounded(this.exited, timeoutMs);
+        if (drained === undefined) {
+            await terminateProcessTree(this.child.pid, true);
+            await this.exited;
+        }
+    }
+    async close(force = false) {
+        if (this.closed) {
+            await this.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;
+    }
+}

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

@@ -0,0 +1,70 @@
+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;
+}>;
+type ProcessTerminal = Readonly<{
+    readonly kind: "terminal";
+    readonly code: number;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly truncated: boolean;
+}>;
+type ProcessTimeout = Readonly<{
+    readonly kind: "timeout";
+}>;
+type ProcessSpawnError = Readonly<{
+    readonly kind: "spawn-error";
+    readonly diagnostic: string;
+}>;
+type ProcessUnknownExit = Readonly<{
+    readonly kind: "unknown-exit";
+}>;
+type ProcessCancelled = Readonly<{
+    readonly kind: "cancelled";
+}>;
+export type ProcessOutcome = ProcessTerminal | ProcessTimeout | ProcessSpawnError | ProcessUnknownExit | ProcessCancelled;
+export type ProcessIdentity = Readonly<{
+    pid: number;
+    spawnedAt: string;
+}>;
+export type ProcessIdentityProbe = Readonly<{
+    kind: "gone" | "alive" | "replaced";
+}> | Readonly<{
+    kind: "unverifiable";
+    diagnostic: string;
+}>;
+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";
+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 currentProcessIdentity(): ProcessIdentity;
+export declare function probeProcessIdentity(identity: ProcessIdentity): ProcessIdentityProbe;
+export declare function spawnDetachedProcess(input: DetachedProcessInput): Promise<ProcessCollar>;
+export declare function probeProcessTree(collar: ProcessCollar): ProcessTreeProbe;
+export declare function putDownProcessTree(collar: ProcessCollar): Promise<PutDownEvidence>;
+export declare function runProcess(input: ProcessInput): Promise<ProcessOutcome>;
+export declare function runProcessToExit(input: ProcessLaunch): Promise<ProcessOutcome>;
+export {};

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

@@ -0,0 +1,226 @@
+import { spawn, spawnSync } from "node:child_process";
+import { closeSync, openSync } from "node:fs";
+const TERMINATION_GRACE_MS = 250;
+const STREAM_TAIL_BYTES = 16 * 1024;
+function tailCapture(limit) {
+    const bytes = Buffer.allocUnsafe(limit);
+    let total = 0;
+    let cursor = 0;
+    return {
+        append(chunk) {
+            if (chunk.length >= limit) {
+                chunk.copy(bytes, 0, chunk.length - limit);
+                total += chunk.length;
+                cursor = 0;
+                return;
+            }
+            const first = Math.min(chunk.length, limit - cursor);
+            chunk.copy(bytes, cursor, 0, first);
+            if (first < chunk.length)
+                chunk.copy(bytes, 0, first);
+            total += chunk.length;
+            cursor = (cursor + chunk.length) % limit;
+        },
+        result() {
+            const size = Math.min(total, limit);
+            const start = total > limit ? cursor : 0;
+            const value = start === 0
+                ? bytes.subarray(0, size)
+                : Buffer.concat([bytes.subarray(start), bytes.subarray(0, start)]);
+            return { text: value.toString("utf8"), truncated: total > 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);
+    });
+}
+export async function terminateProcessTree(pid, force = false) {
+    if (pid === undefined)
+        return;
+    if (process.platform === "win32") {
+        await terminateWindowsTree(pid);
+        return;
+    }
+    if (force) {
+        try {
+            process.kill(-pid, "SIGKILL");
+        }
+        catch (error) {
+            ignoreMissingProcess(error);
+        }
+        return;
+    }
+    try {
+        process.kill(-pid, "SIGTERM");
+    }
+    catch (error) {
+        ignoreMissingProcess(error);
+        return;
+    }
+    await wait(TERMINATION_GRACE_MS);
+    try {
+        process.kill(-pid, "SIGKILL");
+    }
+    catch (error) {
+        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 identity = currentProcessIdentity();
+    return { ...identity, processGroup: identity.pid };
+}
+export function currentProcessIdentity() {
+    const spawnedAt = processStartToken(process.pid);
+    if (spawnedAt === null)
+        throw new Error(`cannot read process start identity for ${process.pid}`);
+    return { pid: process.pid, spawnedAt };
+}
+export function probeProcessIdentity(identity) {
+    try {
+        process.kill(identity.pid, 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(identity.pid);
+    if (current === null)
+        return { kind: "unverifiable", diagnostic: `cannot read process start identity for ${identity.pid}` };
+    if (current === identity.spawnedAt)
+        return { kind: "alive" };
+    return { kind: "replaced" };
+}
+export async function spawnDetachedProcess(input) {
+    const log = openSync(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],
+            windowsHide: true,
+        });
+        await new Promise((resolve, reject) => {
+            child.once("spawn", resolve);
+            child.once("error", reject);
+        });
+        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 };
+    }
+    finally {
+        closeSync(log);
+    }
+}
+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";
+}
+async function executeProcess(input, timeoutMs) {
+    if (input.signal?.aborted === true)
+        return { kind: "cancelled" };
+    const child = spawn(input.argv[0], input.argv.slice(1), {
+        cwd: input.cwd,
+        env: input.env,
+        detached: true,
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true,
+    });
+    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 stop;
+    let termination;
+    const requestStop = (reason) => {
+        if (stop !== undefined)
+            return;
+        stop = reason;
+        termination = terminateProcessTree(child.pid);
+    };
+    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 (stop !== undefined)
+        return { kind: stop };
+    if (terminal.code === null)
+        return { kind: "unknown-exit" };
+    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,
+    };
+}
+export function runProcess(input) {
+    return executeProcess(input, input.timeoutMs);
+}
+export function runProcessToExit(input) {
+    return executeProcess(input, undefined);
+}

package/build/src/settings.d.ts

@@ -0,0 +1,51 @@
+export type SettingsScope = "project" | "user";
+export type SettingsScopeState = Readonly<{
+    kind: "absent";
+    path?: string;
+}> | Readonly<{
+    kind: "failed";
+    path: string;
+    diagnostic: string;
+}> | Readonly<{
+    kind: "read";
+    path: string;
+    namespaces: readonly string[];
+}>;
+export type SettingsEntry = Readonly<{
+    name: string;
+    value: unknown;
+    source: SettingsScope;
+    shadows: boolean;
+}>;
+export type SettingsNamespaceFailure = Readonly<{
+    scope: SettingsScope;
+    diagnostic: string;
+}>;
+export type SettingsNamespaceView = Readonly<{
+    kind: "read";
+    name: string;
+    entries: readonly SettingsEntry[];
+}> | Readonly<{
+    kind: "failed";
+    name: string;
+    entries: readonly SettingsEntry[];
+    failures: readonly SettingsNamespaceFailure[];
+}>;
+export type Settings = Readonly<{
+    scopes: Readonly<{
+        project: SettingsScopeState;
+        user: SettingsScopeState;
+    }>;
+    namespace(name: string): SettingsNamespaceView;
+}>;
+export type SettingsInput = Readonly<{
+    root?: string;
+    home?: string;
+}>;
+export declare class SettingsError extends Error {
+    readonly kind = "settings";
+    constructor(message: string);
+}
+export declare function settings(input?: SettingsInput): Settings;
+/** Read only the project scope owned by a materialized candidate snapshot. */
+export declare function projectSettings(root: string): Settings;

package/build/src/settings.js

@@ -0,0 +1,114 @@
+import { readFileSync } from "node:fs";
+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);
+}
+function freezeJson(value) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            freezeJson(item);
+        return Object.freeze(value);
+    }
+    if (object(value)) {
+        for (const item of Object.values(value))
+            freezeJson(item);
+        return Object.freeze(value);
+    }
+    return value;
+}
+function bounded(error) {
+    return (error instanceof Error ? error.message : String(error)).slice(0, 500);
+}
+function readScope(path) {
+    let bytes;
+    try {
+        bytes = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { state: { kind: "absent", path } };
+        return { state: { kind: "failed", path, diagnostic: bounded(error) } };
+    }
+    try {
+        const decoded = JSON.parse(bytes);
+        if (!object(decoded))
+            throw new TypeError("settings root must be an object");
+        const root = freezeJson(decoded);
+        return { state: { kind: "read", path, namespaces: Object.freeze(Object.keys(root).sort()) }, root };
+    }
+    catch (error) {
+        return { state: { kind: "failed", path, diagnostic: bounded(error) } };
+    }
+}
+function namespaceEntries(name, scope, loaded) {
+    if (loaded.state.kind === "failed") {
+        return { entries: [], failure: { scope, diagnostic: loaded.state.diagnostic } };
+    }
+    const value = loaded.root?.[name];
+    if (value === undefined)
+        return { entries: [] };
+    if (!object(value)) {
+        return { entries: [], failure: { scope, diagnostic: `${name} must be an object of named values` } };
+    }
+    return {
+        entries: Object.keys(value).sort().map((entryName) => ({
+            name: entryName,
+            value: value[entryName],
+            source: scope,
+            shadows: false,
+        })),
+    };
+}
+function settingsFromScopes(project, user) {
+    return Object.freeze({
+        scopes: Object.freeze({ project: project.state, user: user.state }),
+        namespace(name) {
+            if (typeof name !== "string" || name.trim().length === 0)
+                throw new TypeError("settings namespace must be nonblank");
+            const fromUser = namespaceEntries(name, "user", user);
+            const fromProject = namespaceEntries(name, "project", project);
+            const userByName = new Map(fromUser.entries.map((entry) => [entry.name, entry]));
+            const projectByName = new Map(fromProject.entries.map((entry) => [entry.name, entry]));
+            const names = [...new Set([...userByName.keys(), ...projectByName.keys()])].sort();
+            const entries = Object.freeze(names.map((entryName) => {
+                const higher = projectByName.get(entryName);
+                if (higher !== undefined)
+                    return Object.freeze({ ...higher, shadows: userByName.has(entryName) });
+                return userByName.get(entryName);
+            }));
+            const failures = Object.freeze([fromUser.failure, fromProject.failure].filter((failure) => failure !== undefined));
+            return failures.length === 0
+                ? Object.freeze({ kind: "read", name, entries })
+                : Object.freeze({ kind: "failed", name, entries, failures });
+        },
+    });
+}
+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 project = input.root === undefined
+        ? { state: { kind: "absent" } }
+        : readScope(join(resolve(input.root), ".keiyaku", "settings.json"));
+    const user = 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 function projectSettings(root) {
+    if (typeof root !== "string" || root.trim().length === 0)
+        throw new TypeError("settings root must be a nonblank string");
+    return settingsFromScopes(readScope(join(resolve(root), ".keiyaku", "settings.json")), { state: { kind: "absent" } });
+}

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

@@ -0,0 +1,9 @@
+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>;
+export declare function withTaskSettlementFence<T>(input: Readonly<{
+    repository: GitRepository;
+    taskId: TaskId;
+}>, action: () => T | Promise<T>): Promise<T>;

package/build/src/settlement/fence.js

@@ -0,0 +1,23 @@
+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",
+    });
+}
+export async function withTaskSettlementFence(input, action) {
+    const held = await acquireTaskSettlementFence(input.repository, input.taskId);
+    try {
+        return await action();
+    }
+    finally {
+        held.close();
+    }
+}

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

@@ -0,0 +1,36 @@
+import type { TreeUpdate } from "../core/facts/offer.js";
+import { type ContractId } from "../core/facts/types.js";
+import type { GitDecisionObservation } from "../git/observe.js";
+import type { GitRepository } from "../git/repository.js";
+import { type GitDecodeChannel, type GitReadObservation, type GitTreeSelection } from "../git/read-observation.js";
+import { type TaskId } from "../task/identity.js";
+export declare function taskHolderObservationSelection(): GitTreeSelection;
+export type TaskHolder = Readonly<{
+    version: 1;
+    taskId: TaskId;
+    contractId: ContractId;
+    disposition: "held" | "released";
+}>;
+export type TaskHolderProjection = ReadonlyMap<ContractId, TaskHolder>;
+export declare function claimTaskHolder(taskId: TaskId, owner: ContractId): TreeUpdate;
+type AdmissionOutcome = Readonly<{
+    kind: string;
+}>;
+export type TaskHolderAdmission<T extends AdmissionOutcome> = Readonly<{
+    kind: "completed";
+    result: T;
+}> | Readonly<{
+    kind: "accepted-release-failed";
+    result: T;
+    taskId: TaskId;
+    diagnostic: string;
+}>;
+export declare function finishTaskHolderAdmission<T extends AdmissionOutcome>(taskId: TaskId, result: T, close: () => void): TaskHolderAdmission<T>;
+export declare function claimTaskHolderWithFence<T extends AdmissionOutcome>(repository: GitRepository, taskId: TaskId, action: () => T | Promise<T>): Promise<TaskHolderAdmission<T>>;
+export declare function releaseTaskHolder(channel: GitDecodeChannel, observation: GitDecisionObservation, owner: ContractId): Promise<TreeUpdate | null>;
+export declare function readTaskHolderProjectionFromDecision(channel: GitDecodeChannel, observation: GitDecisionObservation): Promise<TaskHolderProjection>;
+export declare function observeTaskHolderProjection(repository: GitRepository, channel: GitDecodeChannel): Promise<TaskHolderProjection>;
+export declare function releaseTaskHolderWithFence<T extends AdmissionOutcome>(repository: GitRepository, channel: GitDecodeChannel, owner: ContractId, action: () => T | Promise<T>): Promise<TaskHolderAdmission<T>>;
+export declare function readTaskHoldersAt(observation: Pick<GitReadObservation, "snapshot" | "readBlobs">): Promise<readonly TaskHolder[]>;
+export declare function readTaskHolderProjectionAt(observation: GitReadObservation): Promise<TaskHolderProjection>;
+export {};