@astrosheep/keiyaku 4.5.20 → 4.5.21

package/build/src/cli/render/terminal.js

@@ -12,6 +12,16 @@ export function gitShortStat(stat) {
     return parts.join(", ");
 }
 const GRAPHEMES = new Intl.Segmenter("und", { granularity: "grapheme" });
+const NON_ASCII = /[^\x20-\x7e]/u;
+const MARK = /\p{Mark}/u;
+const PICTOGRAPHIC = /\p{Extended_Pictographic}/u;
+const EMOJI_DEFAULT = /\p{Emoji_Presentation}/u;
+const ZWJ = 0x200d;
+const TEXT_PRESENTATION = 0xfe0e;
+const EMOJI_PRESENTATION = 0xfe0f;
+const REGIONAL_FIRST = 0x1f1e6;
+const REGIONAL_LAST = 0x1f1ff;
+const ZERO_WIDTH = new Set([0x200b, 0x200c, 0x200d, 0x200e, 0x200f, 0x2060, 0xfeff]);
 const WIDE_RANGES = [
     [0x1100, 0x115f],
     [0x2329, 0x232a],
@@ -25,33 +35,59 @@ const WIDE_RANGES = [
     [0x1f300, 0x1faff],
     [0x20000, 0x3fffd],
 ];
-function characterColumns(character) {
-    const point = character.codePointAt(0);
-    if (point === undefined || point === 0 || /\p{Mark}/u.test(character) || point === 0xfe0f)
+/** Columns one code point occupies when its grapheme cluster gives it no wider form. */
+function baseColumns(point) {
+    if (point === 0 || point < 0x20 || (point >= 0x7f && point < 0xa0))
         return 0;
-    if (point < 0x20 || (point >= 0x7f && point < 0xa0))
+    if (ZERO_WIDTH.has(point) || MARK.test(String.fromCodePoint(point)))
         return 0;
     if (point === 0x303f)
         return 1;
     return WIDE_RANGES.some(([first, last]) => point >= first && point <= last) ? 2 : 1;
 }
+/**
+ * Columns one grapheme cluster occupies. A cluster is one terminal cell group even
+ * when it is built from many code points, so ZWJ sequences, flags, keycaps and
+ * variation selectors never count the width of their parts.
+ */
+function graphemeColumns(cluster) {
+    const points = [...cluster].map((character) => character.codePointAt(0));
+    if (points.every((point) => point === EMOJI_PRESENTATION || point === TEXT_PRESENTATION))
+        return 0;
+    const first = points[0];
+    if (points.length > 1 && points.every((point) => point >= REGIONAL_FIRST && point <= REGIONAL_LAST))
+        return 2;
+    // A presentation selector decides a text-default symbol: text stays narrow, emoji widens it.
+    if (points.includes(TEXT_PRESENTATION))
+        return baseColumns(first);
+    if (points.includes(EMOJI_PRESENTATION))
+        return 2;
+    // A joined pictographic sequence is one wide cluster; a plain text symbol is not.
+    if (points.includes(ZWJ) && PICTOGRAPHIC.test(cluster))
+        return 2;
+    if (EMOJI_DEFAULT.test(cluster))
+        return 2;
+    return baseColumns(first);
+}
 export function displayColumns(value) {
+    if (!NON_ASCII.test(value))
+        return value.length;
     let columns = 0;
-    for (const character of value)
-        columns += characterColumns(character);
+    for (const { segment } of GRAPHEMES.segment(value))
+        columns += graphemeColumns(segment);
     return columns;
 }
 export function takeDisplayColumns(value, maximum) {
-    const characters = [...GRAPHEMES.segment(value)].map(({ segment }) => segment);
+    const clusters = [...GRAPHEMES.segment(value)].map(({ segment }) => segment);
     let columns = 0;
     let index = 0;
-    for (; index < characters.length; index += 1) {
-        const width = displayColumns(characters[index]);
+    for (; index < clusters.length; index += 1) {
+        const width = graphemeColumns(clusters[index]);
         if (columns + width > maximum)
             break;
         columns += width;
     }
-    return { text: characters.slice(0, index).join(""), rest: characters.slice(index).join("") };
+    return { text: clusters.slice(0, index).join(""), rest: clusters.slice(index).join("") };
 }
 export function truncateDisplayText(value, maximum) {
     const clean = safeText(value);
@@ -210,10 +246,6 @@ export function tone(value, kind, color) {
     const code = kind === "dim" ? 2 : kind === "recent" ? 32 : kind === "attention" ? 33 : 31;
     return `\u001b[${code}m${value}\u001b[0m`;
 }
-export function boundedActivity(value, columns, prefix) {
-    const budget = Math.max(1, columns - displayColumns(prefix));
-    return `activity "${truncateDisplayText(value, Math.max(1, budget - displayColumns('activity ""')))}` + `"`;
-}
 export function plumbFacts(facts, columns) {
     const lines = [];
     let current = "  ";
@@ -255,7 +287,7 @@ export function entityLines(entity) {
     ];
 }
 export function renderSectionBlock({ name, rows, hasMore = false, }) {
-    const lines = [`[ ${name} ]`, "", ...rows.flat()];
+    const lines = [`${name}`, "", ...rows.flat()];
     if (hasMore)
         lines.push("…");
     return lines;

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

@@ -46,6 +46,7 @@ export type AcceptedBindResult = AcceptedEnvelope & Readonly<{
         path: string;
     }>;
     target: string | null;
+    warnings?: readonly string[];
     completion?: never;
     verification?: never;
     verificationReuse?: never;

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

@@ -1,5 +1,7 @@
 import type { TaskInvocationResult } from "./commands/task-invoke.js";
 import type { ParsedCommand, ParsedExecution } from "./parse.js";
+import type { ExecutionEvent } from "../library/execution.js";
+export declare function writeExecutionProgress(events: AsyncIterable<ExecutionEvent>, stream?: NodeJS.WritableStream): Promise<void>;
 export declare function writeTask(command: Extract<ParsedCommand, {
     command: "task";
 }>, result: TaskInvocationResult): Promise<number>;

package/build/src/cli/runtime.js

@@ -5,10 +5,16 @@ import { safeText } from "./render/terminal.js";
 function writeCliStream(stream, body) {
     stream.write(body.endsWith("\n") ? body : `${body}\n`);
 }
-async function writeExecutionProgress(events) {
-    const { executionProgressLines } = await import("./render/execution-progress.js");
-    for await (const event of events)
-        writeCliStream(process.stderr, executionProgressLines(event, displayContext()).join("\n"));
+export async function writeExecutionProgress(events, stream = process.stderr) {
+    const { renderExecutionProgress } = await import("./render/execution-progress.js");
+    const terminal = stream;
+    await renderExecutionProgress(events, {
+        stream: terminal,
+        context: {
+            columns: terminal.isTTY === true && Number.isInteger(terminal.columns) ? (terminal.columns ?? 80) : 80,
+            color: false,
+        },
+    });
 }
 function cliCancellation() {
     const controller = new AbortController();
@@ -132,7 +138,7 @@ function writeWorldScopeRefusal(error, command) {
     const body = command.output === "json"
         ? JSON.stringify(error.refusal)
         : [
-            `✕ selector  ${error.refusal.kind}`,
+            `× selector  ${error.refusal.kind}`,
             `  world  ${safeText(error.refusal.world)}`,
             ...error.refusal.ids.map((id) => `  given  ${safeText(id)}`),
             `  accepts  ${guide.accepts}`,
@@ -154,9 +160,9 @@ async function commandFailureText(error, command) {
             }, "selector");
         }
         const { renderRefusalFacts } = await import("./render/refusal.js");
-        return [`✕ ${command.command} refused`, ...renderRefusalFacts(error.refusal, "  ", displayContext().columns)].join("\n");
+        return [`× ${command.command} refused`, ...renderRefusalFacts(error.refusal, "  ", displayContext().columns)].join("\n");
     }
-    return `✕ ${command.command} failed\n  diagnostic  ${safeText(diagnostic)}`;
+    return `× ${command.command} failed\n  diagnostic  ${safeText(diagnostic)}`;
 }
 export async function runCliCommand(invocation) {
     const command = invocation.command;

package/build/src/cli/usage.js

@@ -34,9 +34,9 @@ export function unknownCommandGuide(guide, given) {
 }
 export function renderUsageMessage(diagnostic, guide, kind = "usage") {
     if (guide === undefined) {
-        return `✕ ${kind}\n  diagnostic  ${diagnostic}`;
+        return `× ${kind}\n  diagnostic  ${diagnostic}`;
     }
-    const lines = [`✕ ${kind}  ${guide.scope}`];
+    const lines = [`× ${kind}  ${guide.scope}`];
     if (!guide.hideDiagnostic && diagnostic.length > 0) {
         lines.push(`  diagnostic  ${diagnostic}`);
     }

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

@@ -0,0 +1 @@
+export declare function installedPackageVersion(): Promise<string>;

package/build/src/cli/version.js

@@ -0,0 +1,25 @@
+import { readFile } from "node:fs/promises";
+const PACKAGE_NAME = "@astrosheep/keiyaku";
+export async function installedPackageVersion() {
+    const manifest = JSON.parse(await readFile(owningManifestUrl(), "utf8"));
+    if (!isOwningManifest(manifest)) {
+        throw new Error(`Keiyaku package manifest must name ${PACKAGE_NAME} and contain a nonempty version`);
+    }
+    return manifest.version;
+}
+function owningManifestUrl() {
+    const relativePath = import.meta.url.endsWith("/src/cli/version.ts")
+        ? "../../package.json"
+        : import.meta.url.endsWith("/build/src/cli/version.js")
+            ? "../../../package.json"
+            : undefined;
+    if (relativePath === undefined)
+        throw new Error("Keiyaku package metadata has an unsupported module layout");
+    return new URL(relativePath, import.meta.url);
+}
+function isOwningManifest(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const manifest = value;
+    return manifest.name === PACKAGE_NAME && typeof manifest.version === "string" && manifest.version.trim().length > 0;
+}

package/build/src/git/workspace.d.ts

@@ -49,7 +49,7 @@ export type WorkspaceChangeCounts = Readonly<{
 }>;
 export type ConflictRecovery = Readonly<{
     materialize: "deliver --materialize-conflict --include-dirty";
-    continue: "deliver --include-dirty";
+    deliver: "deliver --include-dirty";
     staging: "not-required";
 }>;
 export declare const conflictRecovery: ConflictRecovery;

package/build/src/git/workspace.js

@@ -195,7 +195,7 @@ export async function unmergedWorkspacePaths(repository, workspace) {
 }
 export const conflictRecovery = Object.freeze({
     materialize: "deliver --materialize-conflict --include-dirty",
-    continue: "deliver --include-dirty",
+    deliver: "deliver --include-dirty",
     staging: "not-required",
 });
 function countsOf(changes) {

package/build/src/identity/mint.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Mint one identity segment from a fitted stem by drawing a fresh random suffix
+ * and letting the caller admit the candidate. A collision redraws the suffix
+ * within the attempt budget; exhaustion returns the last collision rather than
+ * lengthening the identity.
+ */
+export declare function mintIdentitySegment<Value>(input: Readonly<{
+    stem: string;
+    attempts: number;
+    drawSuffix: () => string;
+    attempt: (segment: string) => Promise<Value>;
+    collision: (value: Value) => boolean;
+}>): Promise<Value>;

package/build/src/identity/mint.js

@@ -0,0 +1,26 @@
+const IDENTITY_SUFFIX_PATTERN = /^[0-9a-f]{4}$/u;
+function requireIdentitySuffix(value) {
+    if (!IDENTITY_SUFFIX_PATTERN.test(value)) {
+        throw new Error("identity suffix must be four lowercase hexadecimal digits");
+    }
+    return value;
+}
+/**
+ * Mint one identity segment from a fitted stem by drawing a fresh random suffix
+ * and letting the caller admit the candidate. A collision redraws the suffix
+ * within the attempt budget; exhaustion returns the last collision rather than
+ * lengthening the identity.
+ */
+export async function mintIdentitySegment(input) {
+    if (!Number.isSafeInteger(input.attempts) || input.attempts < 1) {
+        throw new Error("identity mint attempt budget must be a positive safe integer");
+    }
+    let result;
+    for (let index = 0; index < input.attempts; index += 1) {
+        const suffix = requireIdentitySuffix(input.drawSuffix());
+        result = await input.attempt(`${input.stem}-${suffix}`);
+        if (!input.collision(result))
+            return result;
+    }
+    return result;
+}

package/build/src/identity/normalize.d.ts

@@ -1,6 +1,10 @@
 export declare function normalizeIdentityStem(input: Readonly<{
     source: string;
 }>): string;
+export declare function fitIdentityStemWords(input: Readonly<{
+    stem: string;
+    maxCodePoints: number;
+}>): string;
 export declare function fitIdentityStem(input: Readonly<{
     stem: string;
     maxBytes: number;

package/build/src/identity/normalize.js

@@ -21,6 +21,36 @@ export function normalizeIdentityStem(input) {
     }
     return result;
 }
+export function fitIdentityStemWords(input) {
+    if (!Number.isSafeInteger(input.maxCodePoints) || input.maxCodePoints < 1) {
+        throw new Error("identity stem code point budget must be a positive safe integer");
+    }
+    const words = input.stem.split("-");
+    let fitted = truncateGraphemes(words[0], input.maxCodePoints);
+    let count = [...fitted].length;
+    for (const word of words.slice(1)) {
+        const candidate = count + 1 + [...word].length;
+        if (candidate > input.maxCodePoints)
+            break;
+        fitted += `-${word}`;
+        count = candidate;
+    }
+    if (fitted.length === 0)
+        throw new Error("identity stem is empty after fitting");
+    return fitted;
+}
+function truncateGraphemes(value, maxCodePoints) {
+    let result = "";
+    let count = 0;
+    for (const { segment } of GRAPHEMES.segment(value)) {
+        const size = [...segment].length;
+        if (count + size > maxCodePoints)
+            break;
+        result += segment;
+        count += size;
+    }
+    return result;
+}
 export function fitIdentityStem(input) {
     if (!Number.isSafeInteger(input.maxBytes) || input.maxBytes < 1) {
         throw new Error("identity stem byte budget must be a positive safe integer");

package/build/src/index.d.ts

@@ -1,4 +1,6 @@
 export * from "./library/keiyaku.js";
+export { Akuma, Schema, ALLOWED_ACTIONS, AkumaBusyError, AkumaDecodeError, AkumaNotBornError, AkumaProviderError, } from "./akuma/index.js";
+export type { AkumaBirthInput, AkumaHistoryOptions, AkumaIdleOptions, AkumaSignalOptions, AkumaTellOptions, InterruptReceipt, KillEvidence, JsonSchema, JsonSchemaDocument, AkuId, AkumaStatus, ActivityHistory, ActivityRow, AllowedAction, AllowedActions, } from "./akuma/index.js";
 export { settings } from "./settings.js";
 export { World, WorldError } from "./world.js";
 export type { WorldResolution, WorldResolutionInput, WorldRoot } from "./world.js";

package/build/src/index.js

@@ -1,3 +1,4 @@
 export * from "./library/keiyaku.js";
+export { Akuma, Schema, ALLOWED_ACTIONS, AkumaBusyError, AkumaDecodeError, AkumaNotBornError, AkumaProviderError, } from "./akuma/index.js";
 export { settings } from "./settings.js";
 export { World, WorldError } from "./world.js";

package/build/src/kanshi/read.js

@@ -15,7 +15,7 @@ import { readDocuments } from "../protocol/read/documents.js";
 import { contractId } from "../core/facts/types.js";
 import { selectKanshi, selectRegion } from "./select.js";
 import { FLEET_SNAPSHOT_ROWS, FLEET_VISIBLE_ROWS } from "./fleet.js";
-import { observeRecentTaskStatus } from "../task/index.js";
+import { observeRecentTaskStatus, TaskAuthorityCorruptionError } from "../task/index.js";
 function diagnostic(error) {
     let source;
     if (error instanceof Error)
@@ -224,6 +224,15 @@ function joinTasks(rows, holders, observeContract) {
         return { ...row, contract: { id: contractId, observed: observeContract(contractId) } };
     });
 }
+/** Attribute a Task board failure to the malformed document that caused it, when one is known. */
+function taskFailure(error) {
+    return {
+        message: diagnostic(error),
+        ...(error instanceof TaskAuthorityCorruptionError && error.coordinate !== undefined
+            ? { coordinate: error.coordinate }
+            : {}),
+    };
+}
 async function readTaskWorld(path) {
     if (path === null)
         return { kind: "absent" };
@@ -231,14 +240,18 @@ async function readTaskWorld(path) {
         return { kind: "present", observation: await observeTaskBoard(path) };
     }
     catch (error) {
-        return { kind: "failed", failure: { message: diagnostic(error) } };
+        return { kind: "failed", failure: taskFailure(error) };
     }
 }
+/**
+ * A selected Contract's own Task namespace view. A failed Task board is reported once by the
+ * board's Task section, so the entity block omits it rather than repeating the same row.
+ */
 function namespaceTaskSection(board, id) {
     if (board.kind === "absent")
         return { kind: "absent" };
     if (board.kind === "failed")
-        return { kind: "failed", failure: board.failure };
+        return undefined;
     return { kind: "present", value: board.observation.selectNamespace(contractNamespace(id)) };
 }
 async function readTasks(path, holders, observeContract) {
@@ -247,7 +260,7 @@ async function readTasks(path, holders, observeContract) {
     return observeRecentTaskStatus(path, { limit: 10 }).then((recent) => ({
         kind: "present",
         value: { root: path, hasMore: recent.hasMore, rows: joinTasks(recent.rows, holders, observeContract) },
-    }), (error) => ({ kind: "failed", failure: { message: diagnostic(error) } }));
+    }), (error) => ({ kind: "failed", failure: taskFailure(error) }));
 }
 async function joinAkuma(path, observeContract, dispatches, aliases) {
     if (aliases.kind !== "present")

package/build/src/kanshi/report.d.ts

@@ -17,6 +17,7 @@ export type Section<Value> = Readonly<{
     kind: "failed";
     failure: Readonly<{
         message: string;
+        coordinate?: string;
     }>;
 }>;
 export type ContractEndpointObservation = ContractDisposition | "missing" | "unavailable";

package/build/src/library/akuma-creation.d.ts

@@ -54,6 +54,7 @@ export type CallInput = Readonly<{
     alias?: AkumaAlias;
     allowed?: readonly AllowedAction[];
     schema?: Schema<unknown>;
+    initiator?: string;
 }>;
 export type CallObservation = Readonly<{
     kind: "detached";
@@ -89,6 +90,7 @@ export type BornCall = Readonly<{
     schemaTell?: Readonly<{
         body: string;
         schema: Schema<unknown>;
+        initiator?: string;
     }>;
 }>;
 export type ForkInput = Readonly<{

package/build/src/library/akuma-creation.js

@@ -242,26 +242,29 @@ async function resolveAliasStage(path, alias, dispatch, akuma) {
         return { kind: "failed", failure: integrationFailure(error) };
     }
 }
+const CALL_INPUT_KEYS = [
+    "path",
+    "archetype",
+    "body",
+    "cwd",
+    "readonly",
+    "mode",
+    "timeoutMs",
+    "home",
+    "settings",
+    "contract",
+    "alias",
+    "allowed",
+    "schema",
+    "initiator",
+];
 async function prepareCall(input, context) {
     const values = requireInput(input, "Keiyaku.call input");
-    onlyKeys(values, [
-        "path",
-        "archetype",
-        "body",
-        "cwd",
-        "readonly",
-        "mode",
-        "timeoutMs",
-        "home",
-        "settings",
-        "contract",
-        "alias",
-        "allowed",
-        "schema",
-    ], "Keiyaku.call input");
+    onlyKeys(values, CALL_INPUT_KEYS, "Keiyaku.call input");
     const path = await World.prove(nonblank(values.path, "path"));
     const archetype = nonblank(values.archetype, "archetype");
     const body = text(values.body, "body");
+    const initiator = values.initiator === undefined ? undefined : text(values.initiator, "initiator");
     const readonlyRequested = callReadonly(values.readonly, "readonly must be true").readonly;
     const cwd = values.cwd === undefined ? undefined : nonblank(values.cwd, "cwd");
     const mode = callMode(values.mode);
@@ -279,6 +282,7 @@ async function prepareCall(input, context) {
     const call = {
         archetype,
         ...(values.schema === undefined ? { body } : {}),
+        ...(initiator === undefined ? {} : { initiator }),
         ...(readonlyRequested === undefined ? {} : { readonly: readonlyRequested }),
         ...(values.allowed === undefined ? {} : { allowed: values.allowed }),
         ...(values.schema === undefined ? {} : { schema: values.schema }),
@@ -305,7 +309,15 @@ async function prepareCall(input, context) {
         timeoutMs,
         dispatch,
         alias: aliasStage,
-        ...(values.schema === undefined ? {} : { schemaTell: { body, schema: values.schema } }),
+        ...(values.schema === undefined
+            ? {}
+            : {
+                schemaTell: {
+                    body,
+                    schema: values.schema,
+                    ...(initiator === undefined ? {} : { initiator }),
+                },
+            }),
     };
 }
 async function publishCall(born, execution) {
@@ -326,8 +338,12 @@ async function publishCall(born, execution) {
                 target: handle.id,
                 body: tell.body,
                 schema: tell.schema,
+                ...(tell.initiator === undefined ? {} : { initiator: tell.initiator }),
             })
-            : PublicAkuma.select(born.path, handle.id).tell(tell.body, { schema: tell.schema }));
+            : PublicAkuma.select(born.path, handle.id).tell(tell.body, {
+                schema: tell.schema,
+                ...(tell.initiator === undefined ? {} : { initiator: tell.initiator }),
+            }));
         if (born.mode === "detach")
             void pending.catch(() => undefined);
         else

package/build/src/library/bind.js

@@ -2,16 +2,17 @@ import { randomBytes } from "node:crypto";
 import { decodeContractDocument } from "../body/decode.js";
 import { contractIdFromSegment } from "../core/facts/types.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { fitIdentityStem, normalizeIdentityStem } from "../identity/normalize.js";
+import { mintIdentitySegment } from "../identity/mint.js";
+import { fitIdentityStemWords, normalizeIdentityStem } from "../identity/normalize.js";
 import { bindOperation } from "../protocol/bind.js";
 import { stateOperation } from "../protocol/operations.js";
 import { claimTaskHolder, claimTaskHolderWithFence } from "../settlement/holder.js";
 import { KeiyakuRefused } from "./refusal.js";
 import { contractTerms, documentDerivation } from "./input.js";
-function candidateId(title, collision) {
-    const stem = fitIdentityStem({ stem: normalizeIdentityStem({ source: title }) || "contract", maxBytes: 48 });
-    const suffix = collision === 0 ? "" : `-${randomBytes(8).toString("hex")}`;
-    return contractIdFromSegment(`${stem}${suffix}`);
+const CONTRACT_ID_CODE_POINTS = 32;
+const CONTRACT_ID_ATTEMPTS = 4;
+function drawContractSuffix() {
+    return randomBytes(2).toString("hex");
 }
 async function attempt(input, id) {
     return bindOperation({
@@ -33,16 +34,17 @@ async function attempt(input, id) {
     });
 }
 async function attemptCandidates(input) {
-    let result;
-    for (let collision = 0; collision <= 3; collision += 1) {
-        const id = candidateId(input.title, collision);
-        result = await attempt(input, id);
-        if (result.kind === "accepted")
-            return result;
-        if (result.kind !== "refused" || result.refusal.kind !== "contract-exists")
-            return result;
-    }
-    return result;
+    const stem = fitIdentityStemWords({
+        stem: normalizeIdentityStem({ source: input.title }) || "contract",
+        maxCodePoints: CONTRACT_ID_CODE_POINTS,
+    });
+    return await mintIdentitySegment({
+        stem,
+        attempts: CONTRACT_ID_ATTEMPTS,
+        drawSuffix: drawContractSuffix,
+        attempt: (segment) => attempt(input, contractIdFromSegment(segment)),
+        collision: (result) => result.kind === "refused" && result.refusal.kind === "contract-exists",
+    });
 }
 export async function admitBindWithAppointment(input) {
     return await attemptCandidates(input);
@@ -86,7 +88,7 @@ export async function admitForkBindWithAppointment(input) {
         throw error;
     }
     const markdown = sourceDocument.document.bytes.replace(/^\s*#\s*[^\r\n]*(?:\r?\n|$)/u, `# Fork · ${sourceDocument.title}${sourceDocument.document.bytes.includes("\r\n") ? "\r\n" : "\n"}`);
-    const document = decodeContractDocument(markdown);
+    const document = decodeContractDocument(markdown, { requireTimeout: true });
     const terms = contractTerms(document, source.terms.gates, source.terms.after);
     const admission = await attemptCandidates({
         scope: input.scope,

package/build/src/library/contract-bind.d.ts

@@ -20,7 +20,9 @@ type BindInput = Readonly<{
 type BindResult<Handle> = Readonly<Omit<MutationResult<Handle>, "value"> & {
     keiyaku: Handle;
     workspace?: ContractWorkspaceLocation;
-} & RegionObservation>;
+} & RegionObservation & {
+    warnings?: readonly string[];
+}>;
 type HandleFactory<Handle> = (contractId: ContractId, scope: RepositoryScope) => Handle;
 export declare function bindKeiyaku<Handle>(input: BindInput, createHandle: HandleFactory<Handle>): Promise<BindResult<Handle>>;
 export declare function parseMarkdownBindDocument(markdown: string): import("../body/types.js").DecodedContractDocument;

package/build/src/library/contract-bind.js

@@ -7,10 +7,11 @@ import { completionInput, completeHolderMutation, completeMutation } from "./mut
 import { reconcileLagScope } from "./reconcile.js";
 import { requireAccepted } from "./refusal.js";
 import { observeRegion } from "./region.js";
+import { regionWarnings } from "../body/region.js";
 import { scopeForRepo } from "./repo.js";
 import { worktreeHooksOption } from "./configuration.js";
 import { placeRegisterPath, readManagedWorktreeAppointment, } from "../workspace-place.js";
-async function acceptedBindResult(result, region, scope, contractId) {
+async function acceptedBindResult(result, region, scope, contractId, warnings = []) {
     const { value: keiyaku, ...base } = result;
     const appointment = await readManagedWorktreeAppointment(scope, contractId);
     const registerPath = placeRegisterPath(scope);
@@ -34,6 +35,7 @@ async function acceptedBindResult(result, region, scope, contractId) {
         pending: scopedAppointmentLag.length === 0
             ? base.pending
             : [...base.pending, { surface: "reconciliation", required: true }],
+        ...(warnings.length === 0 ? {} : { warnings }),
         ...region,
     };
 }
@@ -85,7 +87,7 @@ export async function bindKeiyaku(input, createHandle) {
     return bindMarkdownFromValues(values, "targetless", createHandle);
 }
 export function parseMarkdownBindDocument(markdown) {
-    return decodeContractDocument(requireMarkdown(markdown));
+    return decodeContractDocument(requireMarkdown(markdown), { requireTimeout: true });
 }
 /** Internal CLI composition; not exported from the package root. */
 export async function bindFromCli(input, createHandle) {
@@ -133,6 +135,6 @@ async function bindMarkdownFromValues(values, omittedTarget, createHandle) {
                 admission: admission.admission,
                 requireAccepted,
             });
-        return await acceptedBindResult(result, await observeRegion(scope, channel, id, document.region), scope, id);
+        return await acceptedBindResult(result, await observeRegion(scope, channel, id, document.region), scope, id, regionWarnings(document.region));
     });
 }

package/build/src/library/contract-operations.d.ts

@@ -91,7 +91,7 @@ declare const materializedHandoffReferenceSchema: z.ZodObject<{
     handoffBase: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
     recovery: z.ZodObject<{
         materialize: z.ZodLiteral<"deliver --materialize-conflict --include-dirty">;
-        continue: z.ZodLiteral<"deliver --include-dirty">;
+        deliver: z.ZodLiteral<"deliver --include-dirty">;
         staging: z.ZodLiteral<"not-required">;
     }, z.core.$strict>;
     conflictPaths: z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<readonly string[], string[]>>;
@@ -216,7 +216,7 @@ declare const contractServiceSchema: z.ZodUnion<readonly [z.ZodObject<{
     handoffBase: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
     recovery: z.ZodObject<{
         materialize: z.ZodLiteral<"deliver --materialize-conflict --include-dirty">;
-        continue: z.ZodLiteral<"deliver --include-dirty">;
+        deliver: z.ZodLiteral<"deliver --include-dirty">;
         staging: z.ZodLiteral<"not-required">;
     }, z.core.$strict>;
     conflictPaths: z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<readonly string[], string[]>>;

package/build/src/library/contract-operations.js

@@ -31,7 +31,7 @@ const contractRequestBaseSchema = z.object({ repoRoot: absolutePathSchema, contr
 const conflictRecoverySchema = z
     .object({
     materialize: z.literal("deliver --materialize-conflict --include-dirty"),
-    continue: z.literal("deliver --include-dirty"),
+    deliver: z.literal("deliver --include-dirty"),
     staging: z.literal("not-required"),
 })
     .strict();

package/build/src/library/contract-types.d.ts

@@ -13,6 +13,7 @@ import type { ContractWorkspaceLocation } from "../workspace-place.js";
 export type BindResult = Readonly<Omit<MutationResult<Keiyaku>, "value"> & {
     keiyaku: Keiyaku;
     workspace?: ContractWorkspaceLocation;
+    warnings?: readonly string[];
 } & RegionObservation>;
 export type Fact = JournalEntry;
 export type ContractHistoryEvent = Readonly<{