@astrosheep/keiyaku 4.1.0 → 4.1.2

package/build/src/contract-worktree.js

@@ -1,34 +1,58 @@
 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 { repairDerivedFile } from "./coordination/durable-file.js";
 import { contractId } from "./core/facts/types.js";
-import { registeredWorktrees, worktreeGitDirectory, worktreeRoot, } from "./git/repository.js";
+import { worktreeGitDirectory, worktreeRoot } from "./git/repository.js";
 import { GitPlumbingError, runGit } from "./git/process.js";
 import { worktreePath } from "./git/workspace.js";
-import { appointmentFor, placeRegisterPath, } from "./workspace-place.js";
+import { appointmentFor, placeRegisterPath } from "./workspace-place.js";
 const IGNORE_BYTES = ".gitignore\nKEIYAKU.md\n";
+const PRIMARY_IGNORE_BYTES = "*\n!settings.json\n!tasks/\n!tasks/**\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 appointmentBytes(contract) {
+    return `---\ncontract: ${contract}\ndescription: ${APPOINTMENT_DESCRIPTION}\n---\n`;
+}
 function renderArc(arc) {
     return [
-        "## Arc", "", "### Sequence", "", String(arc.seq), "", "### Title", "", arc.title.trimEnd(), "",
-        "### Objective", "", arc.objective.trimEnd(), "", "### Brief", "", arc.brief.trimEnd(),
+        "## Arc",
+        "",
+        "### Sequence",
+        "",
+        String(arc.seq),
+        "",
+        "### Title",
+        "",
+        arc.title.trimEnd(),
+        "",
+        "### Objective",
+        "",
+        arc.objective.trimEnd(),
+        "",
+        "### Brief",
+        "",
+        arc.brief.trimEnd(),
     ].join("\n");
 }
 const FULFILLMENT = [
-    "## Fulfillment", "", "### Appointment", "",
+    "## 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", "",
+    "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", "",
+    "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.",
-    "For work requiring three or more steps, prefer `keiyaku task -C <worktree>` "
-        + "to organize and manage Tasks.",
+    "For work requiring three or more steps, prefer `keiyaku task -C <worktree>` " + "to organize and manage Tasks.",
     "Promptly update progress for Tasks already present in the current worktree.",
     "Leave lifecycle decisions to the caller; report the candidate, verification performed, and any unmet term.",
     "Deliver from this worktree. A clean worktree delivers HEAD; uncommitted work",
@@ -38,7 +62,8 @@ const FULFILLMENT = [
     "and deliver again; while the merge stays uncommitted that continuation uses",
     "`--include-dirty`. Unresolved paths always refuse.",
     "",
-    "### Reviewer", "",
+    "### 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.",
@@ -49,7 +74,9 @@ export function renderContractGuidance(state) {
         state.terms.document.bytes.trimEnd(),
         ...(state.currentArc === undefined ? [] : [renderArc(state.currentArc.data)]),
         FULFILLMENT,
-    ].join("\n\n").concat("\n");
+    ]
+        .join("\n\n")
+        .concat("\n");
 }
 async function isTracked(repository, relativePath) {
     try {
@@ -88,57 +115,6 @@ export async function readContractAppointment(repository) {
     const contract = appointedContract(await readFile(path, "utf8"));
     return contract === undefined ? { kind: "invalid", path } : { kind: "appointed", path, contract };
 }
-async function readHereContractWorkspaceAppointment(repository, contract) {
-    const matches = [];
-    let worktrees;
-    try {
-        worktrees = await registeredWorktrees(repository);
-    }
-    catch (error) {
-        if (error instanceof GitPlumbingError)
-            return { kind: "failed", diagnostic: error.message };
-        throw error;
-    }
-    for (const worktree of worktrees) {
-        const appointment = await readContractAppointment({ ...repository, effectiveCwd: worktree.path });
-        if (appointment.kind === "appointed" && appointment.contract === contract)
-            matches.push(worktree.path);
-    }
-    if (matches.length === 0)
-        return { kind: "unappointed" };
-    if (matches.length > 1)
-        return { kind: "conflicted", paths: matches.sort() };
-    return { kind: "appointed", path: matches[0] };
-}
-function conflictDiagnostic(paths) {
-    const displayed = paths.slice(0, 3);
-    return `duplicate here Contract workspace appointments: ${displayed.join(", ")}${paths.length > displayed.length ? ", ..." : ""}`;
-}
-/** Fold existing here appointments over all registered worktrees for one Contract. */
-export async function resolveHereContractWorkspace(repository, contract) {
-    const appointment = await readHereContractWorkspaceAppointment(repository, contract);
-    if (appointment.kind === "failed")
-        return { kind: "failed", diagnostic: appointment.diagnostic, cause: "observation" };
-    if (appointment.kind === "conflicted") {
-        return { kind: "failed", diagnostic: conflictDiagnostic(appointment.paths), cause: "duplicate" };
-    }
-    return appointment;
-}
-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({
@@ -156,39 +132,13 @@ 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))
+    if ((await readFile(appointment.path, "utf8")) !== appointmentBytes(contract))
         return;
     try {
         await unlink(appointment.path);
     }
-    catch { /* reservation cleanup is best effort */ }
-}
-async function removeOwnedHereSupport(worktree) {
-    const path = generatedPath(worktree, ".gitignore");
-    try {
-        const value = await lstat(path);
-        if (!value.isFile() || value.isSymbolicLink())
-            return 0;
-        if (await readFile(path, "utf8") !== IGNORE_BYTES)
-            return 0;
-        await unlink(path);
-        return 1;
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return 0;
-        throw error;
-    }
-}
-/** Remove matching here appointments and their exact generated support from registered worktrees. */
-export async function nukeHereAppointments(repository) {
-    for (const registered of await registeredWorktrees(repository)) {
-        const scoped = { ...repository, effectiveCwd: registered.path };
-        const appointment = await readContractAppointment(scoped);
-        if (appointment.kind === "appointed") {
-            await unlink(appointment.path);
-            await removeOwnedHereSupport(registered.path);
-        }
+    catch {
+        /* reservation cleanup is best effort */
     }
 }
 async function repair(repository, worktree, relativePath, bytes) {
@@ -200,11 +150,31 @@ async function repair(repository, worktree, relativePath, bytes) {
         try {
             await chmod(path, 0o444);
         }
-        catch { /* advisory protection only */ }
+        catch {
+            /* advisory protection only */
+        }
     }
     return { kind: "contract-file", path, action };
 }
 async function materialize(repository, worktree, guidance) {
+    const effects = [];
+    const failed = (target, path, error) => ({
+        effects,
+        lag: [
+            {
+                kind: "contract-file-failed",
+                worktree: target,
+                path,
+                diagnostic: error instanceof Error ? error.message : String(error),
+            },
+        ],
+    });
+    try {
+        effects.push(await repair({ ...repository, effectiveCwd: repository.primaryWorktree }, repository.primaryWorktree, ".keiyaku/.gitignore", PRIMARY_IGNORE_BYTES));
+    }
+    catch (error) {
+        return failed(repository.primaryWorktree, join(repository.primaryWorktree, ".keiyaku", ".gitignore"), error);
+    }
     const stat = await lstat(worktree).catch((error) => {
         if (error.code === "ENOENT")
             return undefined;
@@ -212,17 +182,18 @@ async function materialize(repository, worktree, guidance) {
     });
     if (stat === undefined || !stat.isDirectory()) {
         return {
-            effects: [],
-            lag: [{
+            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],
@@ -231,73 +202,26 @@ async function materialize(repository, worktree, guidance) {
             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 failed(worktree, join(worktree, relativePath), error);
         }
     }
     return { effects, lag: [] };
 }
-async function here(repository, state, guidance, onConflict) {
-    const appointment = await resolveHereContractWorkspace(repository, state.id);
-    if (appointment.kind === "appointed")
-        return await materialize(repository, appointment.path, guidance);
-    if (appointment.kind === "failed") {
-        if (onConflict !== undefined)
-            return onConflict(appointment.diagnostic);
-        throw new Error(appointment.diagnostic);
-    }
-    return {
-        effects: [],
-        lag: [{
-                kind: "contract-file-failed",
-                worktree: repository.primaryWorktree,
-                path: generatedPath(repository.primaryWorktree, "KEIYAKU.md"),
-                diagnostic: "here Contract is unappointed",
-            }],
-    };
-}
-async function removeHere(repository, state) {
-    const effects = [];
-    for (const worktree of await registeredWorktrees(repository)) {
-        const appointment = await readContractAppointment({ ...repository, effectiveCwd: worktree.path });
-        if (appointment.kind !== "appointed" || appointment.contract !== state.id)
-            continue;
-        try {
-            await unlink(appointment.path);
-            effects.push({ kind: "contract-file", path: appointment.path, action: "removed" });
-        }
-        catch (error) {
-            return { effects, lag: [{ kind: "contract-file-failed", worktree: worktree.path, path: appointment.path, diagnostic: error instanceof Error ? error.message : String(error) }] };
-        }
-    }
-    return { effects, lag: [] };
-}
-export async function projectContractWorktree(repository, state, register, onConflict) {
-    if (state === null || state.terminal) {
-        return state?.coordinates.workspace === "here"
-            ? await removeHere(repository, state)
-            : { effects: [], lag: [] };
-    }
-    if (state.coordinates.workspace === "here") {
-        return await here(repository, state, renderContractGuidance(state), onConflict);
-    }
+export async function projectContractWorktree(repository, state, register, _onConflict) {
+    if (state === null || state.terminal)
+        return { effects: [], lag: [] };
     const appointed = register === undefined ? undefined : appointmentFor(register, state.id);
     if (appointed === undefined) {
         return {
             effects: [],
-            lag: [{
+            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.js

@@ -1,5 +1,5 @@
 import { randomBytes } from "node:crypto";
-import { closeSync, fsyncSync, openSync, renameSync, 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 syncDirectory(path) {
@@ -34,7 +34,9 @@ export async function replaceFileDurably(path, bytes) {
             try {
                 await unlink(temporary);
             }
-            catch { /* renamed, absent, or best-effort cleanup */ }
+            catch {
+                /* renamed, absent, or best-effort cleanup */
+            }
             if (error.code !== "EEXIST")
                 throw error;
         }
@@ -61,7 +63,9 @@ export async function createFileDurablyExclusive(path, bytes, mode = 0o600) {
         try {
             await unlink(path);
         }
-        catch { /* absent or best-effort cleanup */ }
+        catch {
+            /* absent or best-effort cleanup */
+        }
         throw error;
     }
 }

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

@@ -21,9 +21,11 @@ function isBusy(error) {
         return false;
     const value = error;
     const message = String(value.message ?? "").toLowerCase();
-    return value.errcode === SQLITE_BUSY || value.code === "ERR_SQLITE_BUSY"
-        || value.code === "ERR_SQLITE_LOCKED" || message.includes("database is locked")
-        || message.includes("database is busy");
+    return (value.errcode === SQLITE_BUSY ||
+        value.code === "ERR_SQLITE_BUSY" ||
+        value.code === "ERR_SQLITE_LOCKED" ||
+        message.includes("database is locked") ||
+        message.includes("database is busy"));
 }
 function closeDatabase(database) {
     let failure;
@@ -56,7 +58,9 @@ async function openLock(path, mode) {
     catch (error) {
         if (error instanceof SqliteTransactionLockError)
             throw error;
-        throw new SqliteTransactionLockError(`cannot prepare SQLite lock: ${detail(error)}`, "open-failed", { cause: error });
+        throw new SqliteTransactionLockError(`cannot prepare SQLite lock: ${detail(error)}`, "open-failed", {
+            cause: error,
+        });
     }
     let database;
     try {
@@ -72,32 +76,45 @@ async function openLock(path, mode) {
             closeDatabase(database);
         if (isBusy(error))
             throw error;
-        throw new SqliteTransactionLockError(`cannot acquire SQLite lock: ${detail(error)}`, "open-failed", { cause: error });
+        throw new SqliteTransactionLockError(`cannot acquire SQLite lock: ${detail(error)}`, "open-failed", {
+            cause: error,
+        });
     }
     let closed = false;
-    return { close() {
+    return {
+        close() {
             if (closed)
                 return;
             closed = true;
             const failure = closeDatabase(database);
             if (failure !== undefined) {
-                throw new SqliteTransactionLockError(`cannot release SQLite lock: ${detail(failure)}`, "release-failed", { cause: failure });
+                throw new SqliteTransactionLockError(`cannot release SQLite lock: ${detail(failure)}`, "release-failed", {
+                    cause: failure,
+                });
             }
-        } };
+        },
+    };
 }
 function wait(milliseconds, signal) {
     return new Promise((resolve, reject) => {
-        const finish = () => { signal?.removeEventListener("abort", abort); resolve(); };
+        const finish = () => {
+            signal?.removeEventListener("abort", abort);
+            resolve();
+        };
         const timer = setTimeout(finish, milliseconds);
-        const abort = () => { clearTimeout(timer); signal?.removeEventListener("abort", abort); reject(signal?.reason); };
+        const abort = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", abort);
+            reject(signal?.reason);
+        };
         signal?.addEventListener("abort", abort, { once: true });
         if (signal?.aborted)
             abort();
     });
 }
 export async function acquireSqliteTransactionLock(input) {
-    if (input.path.length === 0 || (input.timeoutMs !== undefined
-        && (!Number.isSafeInteger(input.timeoutMs) || input.timeoutMs < 0))) {
+    if (input.path.length === 0 ||
+        (input.timeoutMs !== undefined && (!Number.isSafeInteger(input.timeoutMs) || input.timeoutMs < 0))) {
         throw new SqliteTransactionLockError("SQLite lock path and timeout must be valid", "invalid");
     }
     const started = performance.now();

package/build/src/core/facts/codec.js

@@ -87,7 +87,8 @@ function validateTimestamp(value, path) {
     }
     const milliseconds = Date.parse(text);
     const canonical = Number.isFinite(milliseconds) ? new Date(milliseconds).toISOString() : "";
-    if (!Number.isFinite(milliseconds) || (text.includes(".") ? canonical !== text : canonical.replace(".000Z", "Z") !== text)) {
+    if (!Number.isFinite(milliseconds) ||
+        (text.includes(".") ? canonical !== text : canonical.replace(".000Z", "Z") !== text)) {
         fail(path, "expected a real canonical UTC timestamp");
     }
     return text;
@@ -96,7 +97,7 @@ function validateCoordinates(value, path) {
     const object = requireRecord(value, path);
     requireKeys(object, ["start", "workspace"], path, ["target"]);
     const workspace = stringValue(object.workspace, `${path}.workspace`);
-    if (workspace !== "worktree" && workspace !== "here")
+    if (workspace !== "worktree")
         fail(`${path}.workspace`, "unknown workspace");
     return {
         start: brandedValue(object.start, `${path}.start`, snapshotId),
@@ -282,5 +283,8 @@ export function decodeJournal(journal) {
         return [];
     if (journal.includes("\r") || !journal.endsWith("\n"))
         throw new AuthorityCorruptionError("journal must use LF lines and end with LF");
-    return journal.slice(0, -1).split("\n").map((line) => decodeEntry(line));
+    return journal
+        .slice(0, -1)
+        .split("\n")
+        .map((line) => decodeEntry(line));
 }

package/build/src/core/facts/types.d.ts

@@ -56,7 +56,7 @@ export declare function gate(value: string): Gate;
 export type ContractCoordinates = Readonly<{
     start: SnapshotId;
     target?: string;
-    workspace: "worktree" | "here";
+    workspace: "worktree";
 }>;
 export type ContractTerms = Readonly<{
     document: Readonly<{

package/build/src/core/subject.js

@@ -12,11 +12,16 @@ function parseKey(value, index) {
     }
     try {
         switch (value[0]) {
-            case "document": return { kind: "document", value: documentKey(value[1]) };
-            case "segment": return { kind: "segment", value: documentSegmentKey(value[1]) };
-            case "snapshot": return { kind: "snapshot", value: snapshotId(value[1]) };
-            case "change": return { kind: "change", value: changeId(value[1]) };
-            default: throw new AuthorityCorruptionError(`unknown dependency key kind '${value[0]}'`);
+            case "document":
+                return { kind: "document", value: documentKey(value[1]) };
+            case "segment":
+                return { kind: "segment", value: documentSegmentKey(value[1]) };
+            case "snapshot":
+                return { kind: "snapshot", value: snapshotId(value[1]) };
+            case "change":
+                return { kind: "change", value: changeId(value[1]) };
+            default:
+                throw new AuthorityCorruptionError(`unknown dependency key kind '${value[0]}'`);
         }
     }
     catch (error) {
@@ -69,10 +74,12 @@ function currentKeys(state) {
     return new Set([
         encodeKey({ kind: "document", value: state.terms.document.key }),
         ...state.terms.segments.map((value) => encodeKey({ kind: "segment", value })),
-        ...(integration === undefined ? [] : [
-            encodeKey({ kind: "snapshot", value: integration.snapshot }),
-            encodeKey({ kind: "change", value: integration.changeId }),
-        ]),
+        ...(integration === undefined
+            ? []
+            : [
+                encodeKey({ kind: "snapshot", value: integration.snapshot }),
+                encodeKey({ kind: "change", value: integration.changeId }),
+            ]),
     ]);
 }
 /** Build one memoized currentness test for a folded contract snapshot. */

package/build/src/core/verbs/abandon.d.ts

@@ -10,4 +10,4 @@ export type AbandonRefusal = Readonly<{
     kind: "contract-missing" | "terminal";
     contractId: ContractId;
 }>;
-export declare function decideAbandon({ input, attempt, observation }: DecideInput<AbandonInput>): OfferDecision<AbandonRefusal>;
+export declare function decideAbandon({ input, attempt, observation, }: DecideInput<AbandonInput>): OfferDecision<AbandonRefusal>;

package/build/src/core/verbs/abandon.js

@@ -1,5 +1,5 @@
 import { activeContract } from "../facts/observation.js";
-export function decideAbandon({ input, attempt, observation }) {
+export function decideAbandon({ input, attempt, observation, }) {
     const id = input.contractId;
     const current = activeContract(observation, id);
     if ("kind" in current)

package/build/src/core/verbs/amend.d.ts

@@ -11,4 +11,4 @@ export type AmendRefusal = Readonly<{
     kind: "contract-missing" | "terminal" | "terms-moved" | "unknown-prerequisite" | "cyclic-prerequisite";
     contractId: ContractId;
 }>;
-export declare function decideAmend<Failure>({ input, attempt, observation }: DecideInput<AmendInput<Failure>>): OfferDecision<AmendRefusal | Failure>;
+export declare function decideAmend<Failure>({ input, attempt, observation, }: DecideInput<AmendInput<Failure>>): OfferDecision<AmendRefusal | Failure>;

package/build/src/core/verbs/amend.js

@@ -1,6 +1,6 @@
 import { prerequisitesReach, samePrerequisites } from "../facts/eligibility.js";
 import { activeContract, prerequisiteStatus } from "../facts/observation.js";
-export function decideAmend({ input, attempt, observation }) {
+export function decideAmend({ input, attempt, observation, }) {
     const id = input.contractId;
     const current = activeContract(observation, id);
     if ("kind" in current)
@@ -9,12 +9,12 @@ export function decideAmend({ input, attempt, observation }) {
         throw new Error("existing contract requires an amend preparation and source terms");
     }
     const source = input.source;
-    const termsCurrent = source.document.key === current.terms.document.key
-        && source.segments.length === current.terms.segments.length
-        && source.segments.every((value, index) => value === current.terms.segments[index])
-        && source.gates.length === current.terms.gates.length
-        && source.gates.every((value, index) => value === current.terms.gates[index])
-        && samePrerequisites(source.after, current.terms.after);
+    const termsCurrent = source.document.key === current.terms.document.key &&
+        source.segments.length === current.terms.segments.length &&
+        source.segments.every((value, index) => value === current.terms.segments[index]) &&
+        source.gates.length === current.terms.gates.length &&
+        source.gates.every((value, index) => value === current.terms.gates[index]) &&
+        samePrerequisites(source.after, current.terms.after);
     if (!termsCurrent) {
         return { kind: "refused", refusal: { kind: "terms-moved", contractId: id } };
     }

package/build/src/core/verbs/attestation.js

@@ -17,5 +17,8 @@ export function decideAttestation({ input, attempt, observation, }) {
         ...(input.actor === undefined ? {} : { actor: input.actor }),
         data: input.preparation.data,
     };
-    return { kind: "offer", offer: { facts: [{ contractId: input.contractId, expectedHead: state.head, entries: [attestation] }] } };
+    return {
+        kind: "offer",
+        offer: { facts: [{ contractId: input.contractId, expectedHead: state.head, entries: [attestation] }] },
+    };
 }

package/build/src/core/verbs/bind.d.ts

@@ -10,4 +10,4 @@ export type BindRefusal = Readonly<{
     kind: "contract-exists" | "invalid-after" | "unknown-prerequisite";
     contractId: ContractId;
 }>;
-export declare function decideBind<Failure>({ input, attempt, observation }: DecideInput<BindInput<Failure>>): OfferDecision<BindRefusal | Failure>;
+export declare function decideBind<Failure>({ input, attempt, observation, }: DecideInput<BindInput<Failure>>): OfferDecision<BindRefusal | Failure>;

package/build/src/core/verbs/bind.js

@@ -1,5 +1,5 @@
 import { contractState, prerequisiteStatus } from "../facts/observation.js";
-export function decideBind({ input, attempt, observation }) {
+export function decideBind({ input, attempt, observation, }) {
     const id = input.contractId;
     const current = contractState(observation, id);
     if (current !== null)

package/build/src/core/verbs/placement.d.ts

@@ -17,5 +17,5 @@ export type PlacementRefusal = Readonly<{
     contractId: ContractId;
     unmet: readonly UnmetPrerequisite[];
 }>;
-export declare function decidePlacement({ input, attempt, observation }: DecideInput<PlacementInput>): OfferDecision<PlacementRefusal>;
+export declare function decidePlacement({ input, attempt, observation, }: DecideInput<PlacementInput>): OfferDecision<PlacementRefusal>;
 export {};

package/build/src/core/verbs/placement.js

@@ -16,7 +16,7 @@ function unmetPrerequisites(prerequisites, observation) {
     }
     return unmet;
 }
-export function decidePlacement({ input, attempt, observation }) {
+export function decidePlacement({ input, attempt, observation, }) {
     const id = input.contractId;
     const current = activeContract(observation, id);
     if ("kind" in current)
@@ -46,13 +46,15 @@ export function decidePlacement({ input, attempt, observation }) {
         kind: "offer",
         offer: {
             facts: [{ contractId: id, expectedHead: current.head, entries: [claimed] }],
-            ...(current.coordinates.target === undefined ? {} : {
-                target: {
-                    target: current.coordinates.target,
-                    expectedOid: integration.predecessor,
-                    newOid: integration.snapshot,
-                },
-            }),
+            ...(current.coordinates.target === undefined
+                ? {}
+                : {
+                    target: {
+                        target: current.coordinates.target,
+                        expectedOid: integration.predecessor,
+                        newOid: integration.snapshot,
+                    },
+                }),
         },
     };
 }