@astrosheep/keiyaku 4.5.11 → 4.5.13

package/build/src/library/mutation.js

@@ -1,43 +1,216 @@
-import { deferredTaskHolderSettlement } from "../settlement/settle.js";
-import { completeReconcile } from "./reconcile.js";
-export function completionInput(scope, channel, contractId, value, hooks) {
-    return { scope, channel, contractId, value, hooks };
+import { decodeJournalEntry } from "../core/facts/codec.js";
+import { contractHead, snapshotId, } from "../core/facts/types.js";
+import { decodePrivateStateSeatCloseLag, decodeWorktreeLeak } from "../git/result-codec.js";
+import { concatenatePrivateStateSeatClose } from "../git/private-state-seat.js";
+import { decodeVerificationCleanupFailure } from "../protocol/result-codec.js";
+import { decodeSettlementLag } from "../settlement/result-codec.js";
+import { completeReconcile, decodeReconciliationLag } from "./reconcile.js";
+import { decodeAuditReport } from "../protocol/audit.js";
+import { decodeMaterializedConflict } from "../protocol/deliver.js";
+import { decodeReviewValue } from "../protocol/review.js";
+import { decodeContinuationReport } from "./continuation.js";
+import { deliveryValueSchema } from "./delivery.js";
+import { ownerSchema } from "./result-codec.js";
+import { z } from "zod";
+function pendingSurface(surface, required) {
+    return { surface, required };
+}
+export function decodeMutationPendingSurface(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw new Error("malformed pending surface");
+    const object = value;
+    if (Object.keys(object).some((key) => key !== "surface" && key !== "required"))
+        throw new Error("malformed pending surface");
+    if (object.surface !== "verification" &&
+        object.surface !== "placement" &&
+        object.surface !== "continuation" &&
+        object.surface !== "reconciliation" &&
+        object.surface !== "settlement" &&
+        object.surface !== "cleanup")
+        throw new Error("malformed pending surface");
+    if (typeof object.required !== "boolean")
+        throw new Error("malformed pending surface");
+    return { surface: object.surface, required: object.required };
+}
+export const mutationPendingSurfaceSchema = ownerSchema(decodeMutationPendingSurface, "expected pending surface");
+export function decodeReview(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw new Error("malformed review");
+    const { continuation, ...protocol } = value;
+    const review = decodeReviewValue(protocol);
+    return continuation === undefined ? review : { ...review, continuation: decodeContinuationReport(continuation) };
+}
+export const auditReportSchema = ownerSchema(decodeAuditReport, "expected audit report");
+const reviewSchema = ownerSchema(decodeReview, "expected review");
+const materializedConflictSchema = ownerSchema(decodeMaterializedConflict, "expected materialized conflict");
+export const mutationResultSchema = (value) => ownerSchema((input) => {
+    if (input === null || typeof input !== "object" || Array.isArray(input))
+        throw new Error("malformed mutation result");
+    const object = input;
+    if (object.kind !== "accepted")
+        throw new Error("malformed mutation result");
+    if (typeof object.head !== "string")
+        throw new Error("malformed mutation result");
+    const parsedValue = value.safeParse(object.value);
+    if (!parsedValue.success)
+        throw new Error("malformed mutation result");
+    if (!Array.isArray(object.facts) ||
+        !Array.isArray(object.lags) ||
+        !Array.isArray(object.settlementLags) ||
+        !Array.isArray(object.pending))
+        throw new Error("malformed mutation result");
+    const allowed = new Set([
+        "kind",
+        "facts",
+        "head",
+        "value",
+        "lags",
+        "settlementLags",
+        "pending",
+        "recoverySnapshot",
+        "cleanup",
+        "leak",
+        "seatClose",
+    ]);
+    for (const key of Object.keys(object))
+        if (!allowed.has(key))
+            throw new Error("malformed mutation result");
+    return {
+        kind: "accepted",
+        facts: object.facts.map(decodeJournalEntry),
+        head: contractHead(object.head),
+        value: parsedValue.data,
+        lags: object.lags.map(decodeReconciliationLag),
+        settlementLags: object.settlementLags.map(decodeSettlementLag),
+        pending: object.pending.map(decodeMutationPendingSurface),
+        ...(object.recoverySnapshot === undefined
+            ? {}
+            : { recoverySnapshot: snapshotId(String(object.recoverySnapshot)) }),
+        ...(object.cleanup === undefined ? {} : { cleanup: decodeVerificationCleanupFailure(object.cleanup) }),
+        ...(object.leak === undefined ? {} : { leak: decodeWorktreeLeak(object.leak) }),
+        ...(object.seatClose === undefined
+            ? {}
+            : {
+                seatClose: Array.isArray(object.seatClose)
+                    ? object.seatClose.map(decodePrivateStateSeatCloseLag)
+                    : (() => {
+                        throw new Error("malformed mutation result");
+                    })(),
+            }),
+    };
+}, "expected mutation result");
+export const deliveryResultSchema = z.union([
+    mutationResultSchema(deliveryValueSchema),
+    materializedConflictSchema,
+]);
+export const reviewResultSchema = mutationResultSchema(reviewSchema);
+export const auditResultSchema = mutationResultSchema(auditReportSchema);
+export function noValuePending(_value) {
+    return [];
+}
+export function auditPending(value) {
+    return value.verification.kind === "stopped" ? [pendingSurface("verification", true)] : [];
+}
+export function completionPending(value) {
+    const pending = [];
+    if (value.verification !== undefined)
+        pending.push(pendingSurface("verification", true));
+    if (value.placement !== undefined)
+        pending.push(pendingSurface("placement", true));
+    if (value.continuation !== undefined && value.continuation.stopped.length > 0) {
+        pending.push(pendingSurface("continuation", true));
+    }
+    return pending;
+}
+export function obligationPending(input) {
+    const pending = [];
+    if (input.lags.length > 0)
+        pending.push(pendingSurface("reconciliation", true));
+    if (input.settlementLags.length > 0)
+        pending.push(pendingSurface("settlement", true));
+    if (input.cleanup !== undefined || input.leak !== undefined || (input.seatClose?.length ?? 0) > 0) {
+        pending.push(pendingSurface("cleanup", false));
+    }
+    return pending;
+}
+export function collectAcceptedPending(valuePending, obligations) {
+    return [...valuePending, ...obligationPending(obligations)];
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object";
+}
+function phasePendingFromValue(value) {
+    if (!isRecord(value))
+        return [];
+    if ("candidate" in value && "verification" in value && "target" in value) {
+        return auditPending(value);
+    }
+    if ("verification" in value || "placement" in value || "continuation" in value) {
+        return completionPending(value);
+    }
+    return [];
+}
+function obligationSurfacesFromAccepted(input) {
+    return {
+        lags: input.lags,
+        settlementLags: input.settlementLags,
+        ...(input.cleanup === undefined ? {} : { cleanup: input.cleanup }),
+        ...(input.leak === undefined ? {} : { leak: input.leak }),
+        ...(input.seatClose === undefined || input.seatClose.length === 0 ? {} : { seatClose: input.seatClose }),
+    };
+}
+/** Purely projects the leading mutation's finality without changing its details. */
+export function projectMutationFinality(input) {
+    if (input.kind !== "accepted")
+        return { kind: "not-admitted" };
+    const pending = collectAcceptedPending(phasePendingFromValue(input.value), obligationSurfacesFromAccepted(input));
+    return pending.length === 0 ? { kind: "complete" } : { kind: "accepted-pending", pending };
+}
+export function completionInput(input) {
+    return { ...input, valuePending: input.valuePending ?? noValuePending };
+}
+function concatenateSettlementSeatClose(current, reports) {
+    return reports.reduce((seatClose, report) => concatenatePrivateStateSeatClose(seatClose, report.settlement.seatClose), current);
 }
 export async function completeMutation(input) {
     const { scope, channel, contractId, accepted, value, hooks } = input;
+    const valuePending = input.valuePending ?? noValuePending;
     const contracts = [...new Set([contractId, ...accepted.facts.map((fact) => fact.contract)])];
     const reports = [];
     for (const affected of contracts) {
         reports.push(await completeReconcile({ scope, channel, contractId: affected, hooks, retryHooks: false }));
     }
+    const seatClose = concatenateSettlementSeatClose(accepted.seatClose, reports);
     const obligations = {
         ...(accepted.cleanup === undefined ? {} : { cleanup: accepted.cleanup }),
         ...(accepted.leak === undefined ? {} : { leak: accepted.leak }),
+        ...(seatClose === undefined || seatClose.length === 0 ? {} : { seatClose }),
     };
     const effects = [...(accepted.physical?.effects ?? []), ...reports.flatMap((report) => report.effects)];
     const recoverySnapshot = effects.findLast((effect) => effect.kind === "recovery-snapshot")?.snapshot;
+    const publicValue = value(accepted.value);
+    const lags = [...(accepted.physical?.lag ?? []), ...reports.flatMap((report) => report.lag)];
+    const settlementLags = reports.flatMap((report) => report.settlement.lags);
     return {
+        kind: "accepted",
         facts: accepted.facts,
         head: accepted.head,
-        value: value(accepted.value),
-        lags: [...(accepted.physical?.lag ?? []), ...reports.flatMap((report) => report.lag)],
-        settlementLags: reports.flatMap((report) => report.settlement.lags),
+        value: publicValue,
+        lags,
+        settlementLags,
+        pending: collectAcceptedPending(valuePending(publicValue), {
+            lags,
+            settlementLags,
+            ...obligations,
+        }),
         ...(recoverySnapshot === undefined ? {} : { recoverySnapshot }),
         ...obligations,
     };
 }
 export async function completeHolderMutation(input) {
     const accepted = input.requireAccepted(input.admission.result);
-    const completed = await completeMutation({ ...input.completion, accepted });
-    if (input.admission.kind === "completed")
-        return completed;
-    const deferred = deferredTaskHolderSettlement({
-        contractId: input.completion.contractId,
-        taskId: input.admission.taskId,
-        diagnostic: input.admission.diagnostic,
-    });
-    return {
-        ...completed,
-        settlementLags: [...completed.settlementLags, ...deferred.lags],
-    };
+    // Fence teardown after confirmed admission is custodial residue. Settlement in
+    // completeMutation already reports any still-owed holder publication; do not
+    // invent a second owed-holder lag from fence close alone.
+    return await completeMutation({ ...input.completion, accepted });
 }

package/build/src/library/nuke.d.ts

@@ -1,3 +1,5 @@
+import { type PrivateStateSeatCloseLag } from "../git/private-state-seat.js";
+import type { GitRepository } from "../git/process.js";
 import { type WorldRoot } from "../world.js";
 export type NukeInput = Readonly<{
     world: WorldRoot;
@@ -6,9 +8,13 @@ export type NukeInput = Readonly<{
 export type NukeResult = Readonly<{
     kind: "success";
     world: WorldRoot;
+    seatClose?: readonly PrivateStateSeatCloseLag[];
 }> | Readonly<{
     kind: "failed";
     world: WorldRoot;
     diagnostic: string;
+    seatClose?: readonly PrivateStateSeatCloseLag[];
 }>;
-export declare function nukeKeiyaku(input: NukeInput): Promise<NukeResult>;
+type NukeGitOptions = Readonly<Pick<GitRepository, "onPrivateStateSeatContention" | "onPrivateStateSeatClose">>;
+export declare function nukeKeiyaku(input: NukeInput, gitOptions?: NukeGitOptions): Promise<NukeResult>;
+export {};

package/build/src/library/nuke.js

@@ -1,7 +1,9 @@
+/** @architectureCompositionRoot */
 import { rmdir } from "node:fs/promises";
 import { resolve } from "node:path";
 import { stopAkuma } from "../akuma/nuke.js";
 import { nukeGit } from "../git/nuke.js";
+import { appendPrivateStateSeatClose } from "../git/private-state-seat.js";
 import { nukeTask } from "../task/operations.js";
 import { World } from "../world.js";
 import { KeiyakuRefused } from "./refusal.js";
@@ -25,7 +27,10 @@ async function nukeInput(input) {
     const confirm = value.confirm === undefined ? undefined : requireMarkdown(value.confirm, "confirm");
     return { world, ...(confirm === undefined ? {} : { confirm }) };
 }
-export async function nukeKeiyaku(input) {
+function withSeatClose(result, seatClose) {
+    return seatClose === undefined || seatClose.length === 0 ? result : { ...result, seatClose };
+}
+export async function nukeKeiyaku(input, gitOptions) {
     const value = await nukeInput(input);
     if (value.confirm === undefined) {
         throw new KeiyakuRefused({ kind: "nuke-confirmation-required", world: value.world });
@@ -37,6 +42,7 @@ export async function nukeKeiyaku(input) {
             confirmation: value.confirm,
         });
     }
+    let seatClose;
     try {
         const deleteAkuma = await stopAkuma(value.world);
         let failed = false;
@@ -52,13 +58,21 @@ export async function nukeKeiyaku(input) {
                 }
             }
         };
-        await Promise.all([attempt(deleteAkuma()), attempt(nukeGit(value.world)), attempt(nukeTask(value.world))]);
+        await Promise.all([
+            attempt(deleteAkuma()),
+            attempt(nukeGit(value.world, "git", gitOptions).then((outcome) => {
+                if (outcome.closeLag !== undefined) {
+                    seatClose = appendPrivateStateSeatClose(seatClose, outcome.closeLag);
+                }
+            })),
+            attempt(nukeTask(value.world)),
+        ]);
         if (failed)
             throw firstDiagnostic;
         await removeEmptyWorldMarker(value.world);
-        return { kind: "success", world: value.world };
+        return withSeatClose({ kind: "success", world: value.world }, seatClose);
     }
     catch (error) {
-        return { kind: "failed", world: value.world, diagnostic: diagnostic(error) };
+        return withSeatClose({ kind: "failed", world: value.world, diagnostic: diagnostic(error) }, seatClose);
     }
 }

package/build/src/library/reconcile.d.ts

@@ -1,3 +1,4 @@
+/** @architectureCompositionRoot */
 import type { ContractId } from "../core/facts/types.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
 import { type ReconcileReport } from "../protocol/reconcile.js";
@@ -5,6 +6,7 @@ import { type RepositoryScope } from "../protocol/operations.js";
 import { type SettlementReport } from "../settlement/settle.js";
 import type { WorktreeHooks } from "./configuration.js";
 import { type ContractFileEffect, type ContractFileLag } from "../contract-worktree.js";
+import { z } from "zod";
 export type ReconcileCompletion = Readonly<{
     effects: readonly (ReconcileReport["effects"][number] | ContractFileEffect)[];
     lag: readonly (ReconcileReport["lag"][number] | ContractFileLag)[];
@@ -14,6 +16,18 @@ export type ReconcileCompletion = Readonly<{
         name: string;
     }[];
 }>;
+export declare function decodeReconciliationLag(value: unknown): ReconcileCompletion["lag"][number];
+export declare const reconciliationLagSchema: z.ZodType<import("../git/reconcile.js").ReconcileLag | Readonly<{
+    kind: "contract-file-failed";
+    worktree: string;
+    path: string;
+    diagnostic: string;
+}>, unknown, z.core.$ZodTypeInternals<import("../git/reconcile.js").ReconcileLag | Readonly<{
+    kind: "contract-file-failed";
+    worktree: string;
+    path: string;
+    diagnostic: string;
+}>, unknown>>;
 export type RepoContractReconcileReport = ReconcileCompletion;
 type RepoReconcileContracts = readonly Readonly<{
     contractId: ContractId;

package/build/src/library/reconcile.js

@@ -4,8 +4,19 @@ import { reconcileObservationFailure } from "../git/reconcile.js";
 import { worktreePath } from "../git/workspace.js";
 import { stateOperation } from "../protocol/operations.js";
 import { settle, settleAll } from "../settlement/settle.js";
-import { projectContractWorktree } from "../contract-worktree.js";
+import { decodeContractFileLag, projectContractWorktree, } from "../contract-worktree.js";
+import { decodeGitReconcileLag } from "../git/result-codec.js";
+import { ownerSchema } from "./result-codec.js";
 import { appointManagedWorktrees, placeRegisterPath, releaseManagedWorktrees, } from "../workspace-place.js";
+export function decodeReconciliationLag(value) {
+    try {
+        return decodeGitReconcileLag(value);
+    }
+    catch {
+        return decodeContractFileLag(value);
+    }
+}
+export const reconciliationLagSchema = ownerSchema(decodeReconciliationLag, "expected reconciliation lag");
 function registerLag(scope, error) {
     return {
         kind: "contract-file-failed",
@@ -169,6 +180,12 @@ export async function completeRepoReconcile(input) {
         retainTerminalWorktree: true,
         places,
     });
+    const projections = [];
+    for (const contract of retained.contracts) {
+        projections.push(realizedOrRetainedManagedWorktree(input.scope, contract.report, places.get(contract.contractId))
+            ? await projectContractWorktree(input.scope, contract.state, appointed)
+            : { effects: [], lag: [] });
+    }
     const settlements = await settleAll({
         repository: input.scope,
         channel: input.channel,
@@ -181,16 +198,13 @@ export async function completeRepoReconcile(input) {
         ? await reconcileAllOperation({ ...input, states, places })
         : null;
     const later = cleanup === null ? null : new Map(cleanup.contracts.map((contract) => [contract.contractId, contract.report]));
-    const released = [];
+    const released = retained.contracts
+        .filter((contract) => releaseEligible(contract.state, later?.get(contract.contractId), places.has(contract.contractId)))
+        .map((contract) => contract.contractId);
     const contracts = [];
     for (const [index, contract] of retained.contracts.entries()) {
         const report = later?.get(contract.contractId);
-        if (releaseEligible(contract.state, report, places.has(contract.contractId))) {
-            released.push(contract.contractId);
-        }
-        const projection = realizedOrRetainedManagedWorktree(input.scope, contract.report, places.get(contract.contractId))
-            ? await projectContractWorktree(input.scope, contract.state, appointed)
-            : { effects: [], lag: [] };
+        const projection = projections[index];
         contracts.push({
             contractId: contract.contractId,
             report: {

package/build/src/library/refusal.d.ts

@@ -1,6 +1,7 @@
-import type { ContractId } from "../core/facts/types.js";
+import { type ContractId } from "../core/facts/types.js";
 import type { IntentOutcome, IntentRefusal, IntentRetry } from "../protocol/operations.js";
 import type { AcceptedIntent } from "./mutation.js";
+import { z } from "zod";
 export type ForkSourceRefusal = Readonly<{
     kind: "fork-source-missing" | "fork-source-unavailable" | "fork-source-invalid" | "fork-source-moved";
     contractId: ContractId;
@@ -16,14 +17,21 @@ export type NukeConfirmationRequiredRefusal = Readonly<{
 }>;
 export type KeiyakuRefusal = IntentRefusal | ForkSourceRefusal | NukeConfirmationRefusal | NukeConfirmationRequiredRefusal;
 export type KeiyakuRetryReason = IntentRetry;
+export declare function decodeKeiyakuRefusal(value: unknown): KeiyakuRefusal;
+export declare const keiyakuRefusalSchema: z.ZodType<KeiyakuRefusal, unknown, z.core.$ZodTypeInternals<KeiyakuRefusal, unknown>>;
+export declare const keiyakuRetryReasonSchema: z.ZodType<import("../protocol/run.js").ProtocolTerminal, unknown, z.core.$ZodTypeInternals<import("../protocol/run.js").ProtocolTerminal, unknown>>;
 export declare class KeiyakuRefused extends Error {
     readonly refusal: KeiyakuRefusal;
+    readonly kind: "refused";
     constructor(refusal: KeiyakuRefusal);
     get code(): KeiyakuRefusal["kind"];
 }
 export declare class KeiyakuRetry extends Error {
     readonly reason: KeiyakuRetryReason;
+    readonly kind: "retry";
     constructor(reason: KeiyakuRetryReason);
     get code(): KeiyakuRetryReason["kind"];
 }
+export declare function encodeContractLiveFailure(error: unknown): unknown | null;
+export declare function decodeContractLiveFailure(value: unknown): Error | null;
 export declare function requireAccepted<Value, Refusal extends KeiyakuRefusal>(result: IntentOutcome<Value, Refusal>): AcceptedIntent<Value>;

package/build/src/library/refusal.js

@@ -1,5 +1,59 @@
+import { contractId } from "../core/facts/types.js";
+import { decodeIntentRefusal, decodeProtocolTerminal } from "../protocol/result-codec.js";
+import { ownerSchema } from "./result-codec.js";
+import { z } from "zod";
+function decodeForkSourceRefusal(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw new Error("malformed fork-source refusal");
+    const object = value;
+    if (Object.keys(object).some((key) => key !== "kind" && key !== "contractId"))
+        throw new Error("malformed fork-source refusal");
+    if (object.kind !== "fork-source-missing" &&
+        object.kind !== "fork-source-unavailable" &&
+        object.kind !== "fork-source-invalid" &&
+        object.kind !== "fork-source-moved")
+        throw new Error("malformed fork-source refusal");
+    if (typeof object.contractId !== "string")
+        throw new Error("malformed fork-source refusal");
+    return { kind: object.kind, contractId: contractId(object.contractId) };
+}
+function decodeNukeRefusal(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw new Error("malformed nuke refusal");
+    const object = value;
+    if (object.kind === "nuke-confirmation-required") {
+        if (Object.keys(object).some((key) => key !== "kind" && key !== "world"))
+            throw new Error("malformed nuke refusal");
+        if (typeof object.world !== "string" || object.world.trim() === "")
+            throw new Error("malformed nuke refusal");
+        return { kind: "nuke-confirmation-required", world: object.world };
+    }
+    if (object.kind !== "nuke-confirmation-mismatch")
+        throw new Error("malformed nuke refusal");
+    if (Object.keys(object).some((key) => key !== "kind" && key !== "world" && key !== "confirmation"))
+        throw new Error("malformed nuke refusal");
+    if (typeof object.world !== "string" || object.world.trim() === "" || typeof object.confirmation !== "string")
+        throw new Error("malformed nuke refusal");
+    return { kind: "nuke-confirmation-mismatch", world: object.world, confirmation: object.confirmation };
+}
+export function decodeKeiyakuRefusal(value) {
+    try {
+        return decodeIntentRefusal(value);
+    }
+    catch {
+        try {
+            return decodeForkSourceRefusal(value);
+        }
+        catch {
+            return decodeNukeRefusal(value);
+        }
+    }
+}
+export const keiyakuRefusalSchema = ownerSchema(decodeKeiyakuRefusal, "expected keiyaku refusal");
+export const keiyakuRetryReasonSchema = ownerSchema(decodeProtocolTerminal, "expected keiyaku retry");
 export class KeiyakuRefused extends Error {
     refusal;
+    kind = "refused";
     constructor(refusal) {
         super(`Keiyaku refused: ${refusal.kind}`);
         this.refusal = refusal;
@@ -11,6 +65,7 @@ export class KeiyakuRefused extends Error {
 }
 export class KeiyakuRetry extends Error {
     reason;
+    kind = "retry";
     constructor(reason) {
         super(reason.kind === "publication-failed" ? reason.diagnostic : `Keiyaku retry required: ${reason.kind}`);
         this.reason = reason;
@@ -20,6 +75,27 @@ export class KeiyakuRetry extends Error {
         return this.reason.kind;
     }
 }
+const contractLiveFailureSchema = z.union([
+    z.object({ kind: z.literal("refused"), refusal: keiyakuRefusalSchema }).strict(),
+    z.object({ kind: z.literal("retry"), reason: keiyakuRetryReasonSchema }).strict(),
+]);
+export function encodeContractLiveFailure(error) {
+    if (error instanceof KeiyakuRefused) {
+        return { kind: "refused", refusal: error.refusal };
+    }
+    if (error instanceof KeiyakuRetry) {
+        return { kind: "retry", reason: error.reason };
+    }
+    return null;
+}
+export function decodeContractLiveFailure(value) {
+    const parsed = contractLiveFailureSchema.safeParse(value);
+    if (!parsed.success)
+        return null;
+    return parsed.data.kind === "refused"
+        ? new KeiyakuRefused(decodeKeiyakuRefusal(parsed.data.refusal))
+        : new KeiyakuRetry(parsed.data.reason);
+}
 export function requireAccepted(result) {
     if (result.kind === "refused")
         throw new KeiyakuRefused(result.refusal);

package/build/src/library/region.d.ts

@@ -1,7 +1,6 @@
 import type { ContractId } from "../core/facts/types.js";
 import { type GitDecodeChannel } from "../git/read-observation.js";
 import { type RepositoryScope } from "../protocol/operations.js";
-import type { ContractDocumentProjection } from "../protocol/read/documents.js";
 export type RegionOverlap = Readonly<{
     contract: ContractId;
     patterns: readonly Readonly<{
@@ -20,12 +19,5 @@ export type AmendRegionObservation = RegionObservation | Readonly<{
     overlaps?: never;
     overlapFailure?: never;
 }>;
-export type RegionDeclarationRead = Readonly<{
-    contract: ContractId;
-    patterns: readonly string[];
-}>;
-export declare function readRegionDeclarations(documents: readonly ContractDocumentProjection[]): readonly RegionDeclarationRead[];
-export declare function regionOverlaps(mine: readonly string[], declarations: readonly RegionDeclarationRead[]): readonly RegionOverlap[];
-export declare function validateRegionPatterns(patterns: unknown): readonly [string, ...string[]];
 export declare function observeRegion(scope: RepositoryScope, channel: GitDecodeChannel, self: ContractId, mine: readonly string[]): Promise<RegionObservation>;
 export declare function observeChangedRegion(scope: RepositoryScope, self: ContractId, changed: ReadonlySet<string> | undefined, mine: readonly string[]): Promise<AmendRegionObservation>;

package/build/src/library/region.js

@@ -1,35 +1,7 @@
 import { decodeContractDocument } from "../body/decode.js";
-import { assertRegionPattern, regionsOverlap } from "../body/region.js";
+import { regionsOverlap } from "../body/region.js";
 import { withGitDecodeChannel } from "../git/read-observation.js";
 import { documentsOperationAt } from "../protocol/operations.js";
-export function readRegionDeclarations(documents) {
-    return documents.map((document) => ({
-        contract: document.contract,
-        patterns: decodeContractDocument(document.documentBytes).region,
-    }));
-}
-export function regionOverlaps(mine, declarations) {
-    const overlaps = [];
-    for (const declaration of declarations) {
-        const pairs = regionsOverlap(mine, declaration.patterns);
-        if (pairs.length === 0)
-            continue;
-        overlaps.push({
-            contract: declaration.contract,
-            patterns: pairs.map(([minePattern, theirsPattern]) => ({ mine: minePattern, theirs: theirsPattern })),
-        });
-    }
-    return overlaps;
-}
-export function validateRegionPatterns(patterns) {
-    if (!Array.isArray(patterns) || patterns.length === 0)
-        throw new Error("Region query requires one or more path patterns");
-    return patterns.map((pattern) => {
-        if (typeof pattern !== "string")
-            throw new Error("Region path patterns must be strings");
-        return assertRegionPattern(pattern);
-    });
-}
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/build/src/library/result-codec.d.ts

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare function ownerSchema<Value>(decode: (value: unknown) => Value, message: string): z.ZodType<Value>;

package/build/src/library/result-codec.js

@@ -0,0 +1,12 @@
+import { z } from "zod";
+export function ownerSchema(decode, message) {
+    return z.unknown().transform((value, context) => {
+        try {
+            return decode(value);
+        }
+        catch {
+            context.addIssue({ code: "custom", message });
+            return z.NEVER;
+        }
+    });
+}

package/build/src/markdown/lex.js

@@ -131,10 +131,17 @@ function frontmatterValue(value) {
     }
     throw new MarkdownParseError("unsupported frontmatter value");
 }
+function parserDiagnostics(errors) {
+    return [...errors]
+        .sort((left, right) => left.pos[0] - right.pos[0] || left.pos[1] - right.pos[1])
+        .map((error) => error.message);
+}
 function parseFrontmatter(source) {
     const parsed = parseDocument(source, { merge: false, prettyErrors: false, strict: true, uniqueKeys: true });
-    if (parsed.errors.length > 0)
-        throw new MarkdownParseError(parsed.errors[0].message);
+    if (parsed.errors.length > 0) {
+        const diagnostics = parserDiagnostics(parsed.errors);
+        throw new MarkdownParseError(diagnostics.join("\n"), diagnostics);
+    }
     validateFrontmatterNode(parsed.contents);
     if (!isMap(parsed.contents))
         throw new MarkdownParseError("frontmatter must be a mapping");

package/build/src/markdown/types.d.ts

@@ -113,6 +113,7 @@ export type HeadingNode = Spanned & Readonly<{
 export type MarkdownBlockNode = SectionNode | ListNode | CodeBlockNode | BlockquoteNode | TextNode | HeadingNode;
 export type MarkdownNode = DocumentNode | MarkdownBlockNode | ListItemNode;
 export declare class MarkdownParseError extends Error {
-    constructor(message: string);
+    readonly diagnostics: readonly string[];
+    constructor(message: string, diagnostics?: readonly string[]);
 }
 export {};

package/build/src/markdown/types.js

@@ -1,6 +1,8 @@
 export class MarkdownParseError extends Error {
-    constructor(message) {
+    diagnostics;
+    constructor(message, diagnostics = [message]) {
         super(message);
         this.name = "MarkdownParseError";
+        this.diagnostics = diagnostics;
     }
 }

package/build/src/plugin/akuma-signals.d.ts

@@ -0,0 +1,12 @@
+import type { Settings } from "../settings.js";
+import type { WorldRoot } from "../world.js";
+type CalledPluginSignalInput = Readonly<{
+    world: WorldRoot;
+    settings?: Settings;
+    reportDiagnostic: (message: string) => void;
+    akumaId: string;
+    callerAkumaId?: string;
+    contractId?: string;
+}>;
+export declare function emitCalledPluginSignal(input: CalledPluginSignalInput): Promise<void>;
+export {};