@astrosheep/keiyaku 4.5.7 → 4.5.8

package/build/src/library/configuration.js

@@ -73,9 +73,11 @@ function command(value, coordinate, ErrorType) {
     if (!record(value))
         throw new ErrorType(`${coordinate} must be an object`);
     for (const key of Object.keys(value)) {
-        if (key !== "argv" && key !== "timeoutMs")
+        if (key !== "name" && key !== "argv" && key !== "timeoutMs")
             throw new ErrorType(`${coordinate} has unknown field: ${key}`);
     }
+    if (typeof value.name !== "string" || value.name.trim().length === 0)
+        throw new ErrorType(`${coordinate}.name must be nonblank`);
     if (!Array.isArray(value.argv) || value.argv.length === 0 || !value.argv.every((item) => typeof item === "string")) {
         throw new ErrorType(`${coordinate}.argv must be a nonempty string array`);
     }
@@ -86,7 +88,11 @@ function command(value, coordinate, ErrorType) {
         value.timeoutMs > 2_147_483_647) {
         throw new ErrorType(`${coordinate}.timeoutMs must be an integer from 1 through 2147483647`);
     }
-    return Object.freeze({ argv: Object.freeze([...value.argv]), timeoutMs: value.timeoutMs });
+    return Object.freeze({
+        name: value.name.trim(),
+        argv: Object.freeze([...value.argv]),
+        timeoutMs: value.timeoutMs,
+    });
 }
 function commands(value, coordinate, ErrorType) {
     if (!Array.isArray(value))

package/build/src/library/continuation.js

@@ -1,6 +1,9 @@
 import { observeActiveContractWorld } from "../git/observe.js";
 import { withGitReadObservation } from "../git/read-observation.js";
+import { reconcileDependentWorktree } from "../git/reconcile.js";
+import { worktreePath } from "../git/workspace.js";
 import { continueDeliveryOperation } from "../protocol/deliver.js";
+import { appointmentFor, readPlaceRegister } from "../workspace-place.js";
 function reverseDependents(world) {
     const index = new Map();
     for (const record of world.contracts.values()) {
@@ -27,48 +30,81 @@ function appendAccepted(primary, child) {
         ...(effects.length === 0 && lag.length === 0 ? {} : { physical: { effects, lag } }),
     };
 }
+function appendPhysical(primary, physical) {
+    const effects = [...(primary.physical?.effects ?? []), ...physical.effects];
+    const lag = [...(primary.physical?.lag ?? []), ...physical.lag];
+    return {
+        ...primary,
+        ...(effects.length === 0 && lag.length === 0 ? {} : { physical: { effects, lag } }),
+    };
+}
+// The bounded dependency walk keeps selection, physical follow, and child admission together.
+// eslint-disable-next-line max-lines-per-function
 export async function continueDeliveredDependents(input) {
     const world = await withGitReadObservation(input.scope, input.channel, async (observation) => await observeActiveContractWorld(observation));
     const dependents = reverseDependents(world);
-    const pending = [input.contractId];
+    const places = await readPlaceRegister(input.scope);
+    const initialTarget = typeof input.accepted.value === "object" && input.accepted.value !== null && "completion" in input.accepted.value
+        ? (input.accepted.value
+            .completion?.integration ?? undefined)
+        : undefined;
+    const pending = [{ contractId: input.contractId, target: initialTarget }];
     const attempted = new Set();
-    const newlyClaimed = new Set(pending);
+    const newlyClaimed = new Set([input.contractId]);
     const claimed = [];
     const stopped = [];
     let accepted = input.accepted;
+    const process = async (candidate, predecessorTarget) => {
+        const contractId = candidate.state.id;
+        if (!candidate.state.terms.after.every((dependency) => newlyClaimed.has(dependency) || world.eligibility.get(dependency)?.terminal?.kind === "claimed")) {
+            return { accepted, outcome: "skip" };
+        }
+        attempted.add(contractId);
+        if (predecessorTarget !== undefined && candidate.state.coordinates.workspace === "worktree") {
+            const appointment = appointmentFor(places, contractId);
+            if (appointment !== undefined) {
+                const reconciled = await reconcileDependentWorktree(input.scope, contractId, worktreePath(input.scope, appointment.place), predecessorTarget);
+                accepted = appendPhysical(accepted, reconciled);
+                if (reconciled.lag.length > 0)
+                    return { accepted, outcome: "stopped" };
+            }
+        }
+        const child = await continueDeliveryOperation({
+            scope: input.scope,
+            channel: input.channel,
+            state: candidate.state,
+            journal: candidate.journal,
+            deriveDocument: input.deriveDocument,
+            ...(input.actor === undefined ? {} : { actor: input.actor }),
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
+        });
+        accepted = appendAccepted(accepted, child.admission);
+        if (child.evidence.completion !== undefined) {
+            newlyClaimed.add(contractId);
+            pending.push({ contractId, target: child.evidence.completion.integration });
+            return { accepted, outcome: "claimed" };
+        }
+        const stop = child.evidence.placement;
+        if (stop === undefined)
+            throw new Error("incomplete continuation is missing its placement stop");
+        return {
+            accepted,
+            outcome: "stopped",
+            stop: "refusal" in stop && stop.refusal.kind === "terminal" ? { kind: "already-terminal" } : stop,
+        };
+    };
     while (pending.length > 0) {
         const parent = pending.shift();
-        for (const candidate of dependents.get(parent) ?? []) {
+        for (const candidate of dependents.get(parent.contractId) ?? []) {
             const contractId = candidate.state.id;
-            if (attempted.has(contractId) ||
-                !candidate.state.terms.after.every((dependency) => newlyClaimed.has(dependency) || world.eligibility.get(dependency)?.terminal?.kind === "claimed"))
+            if (attempted.has(contractId))
                 continue;
-            attempted.add(contractId);
-            const child = await continueDeliveryOperation({
-                scope: input.scope,
-                channel: input.channel,
-                state: candidate.state,
-                journal: candidate.journal,
-                deriveDocument: input.deriveDocument,
-                ...(input.actor === undefined ? {} : { actor: input.actor }),
-                ...(input.signal === undefined ? {} : { signal: input.signal }),
-            });
-            accepted = appendAccepted(accepted, child.admission);
-            if (child.evidence.completion !== undefined) {
+            const result = await process(candidate, parent.target);
+            accepted = result.accepted;
+            if (result.outcome === "claimed")
                 claimed.push(contractId);
-                newlyClaimed.add(contractId);
-                pending.push(contractId);
-                continue;
-            }
-            const stop = child.evidence.placement;
-            if (stop === undefined)
-                throw new Error("incomplete continuation is missing its placement stop");
-            if ("refusal" in stop && stop.refusal.kind === "terminal") {
-                stopped.push({ contractId, stop: { kind: "already-terminal" } });
-            }
-            else {
-                stopped.push({ contractId, stop });
-            }
+            if (result.outcome === "stopped" && result.stop !== undefined)
+                stopped.push({ contractId, stop: result.stop });
         }
     }
     return {

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

@@ -9,8 +9,16 @@ import { observeRegion } from "./region.js";
 import { scopeForRepo } from "./repo.js";
 import { worktreeHooksOption } from "./configuration.js";
 function acceptedBindResult(result, region) {
-    const { facts, head, effects, lags, settlement } = result;
-    return { facts, head, keiyaku: result.value, effects, lags, settlement, ...region };
+    const { facts, head, lags, settlementLags, recoverySnapshot } = result;
+    return {
+        facts,
+        head,
+        keiyaku: result.value,
+        lags,
+        settlementLags,
+        ...(recoverySnapshot === undefined ? {} : { recoverySnapshot }),
+        ...region,
+    };
 }
 export async function bindKeiyaku(input, createHandle) {
     const values = requireInput(input, "Keiyaku.bind input");

package/build/src/library/contract-forwarding-reconciliation-result.d.ts

@@ -0,0 +1,96 @@
+import { z } from "zod";
+export declare const reconciliationLagSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"worktree-retained">;
+    path: z.ZodString;
+}, z.core.$strict>, z.ZodPipe<z.ZodObject<{
+    kind: z.ZodLiteral<"worktree-follow-retained">;
+    path: z.ZodString;
+    tender: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
+    head: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
+    reason: z.ZodEnum<{
+        "head-moved": "head-moved";
+        "head-attached": "head-attached";
+        "operation-in-progress": "operation-in-progress";
+        "unsupported-parent-shape": "unsupported-parent-shape";
+    }>;
+    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodTransform<{
+    kind: "worktree-follow-retained";
+    path: string;
+    tender: import("../core/facts/types.js").SnapshotId;
+    head: import("../core/facts/types.js").SnapshotId;
+    reason: "head-moved" | "head-attached" | "operation-in-progress" | "unsupported-parent-shape";
+} | {
+    paths: string[];
+    kind: "worktree-follow-retained";
+    path: string;
+    tender: import("../core/facts/types.js").SnapshotId;
+    head: import("../core/facts/types.js").SnapshotId;
+    reason: "head-moved" | "head-attached" | "operation-in-progress" | "unsupported-parent-shape";
+}, {
+    kind: "worktree-follow-retained";
+    path: string;
+    tender: import("../core/facts/types.js").SnapshotId;
+    head: import("../core/facts/types.js").SnapshotId;
+    reason: "head-moved" | "head-attached" | "operation-in-progress" | "unsupported-parent-shape";
+    paths?: string[] | undefined;
+}>>, z.ZodPipe<z.ZodObject<{
+    kind: z.ZodLiteral<"unsealed-bytes">;
+    path: z.ZodString;
+    paths: z.ZodArray<z.ZodString>;
+    head: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>>;
+}, z.core.$strict>, z.ZodTransform<{
+    kind: "unsealed-bytes";
+    path: string;
+    paths: string[];
+} | {
+    head: import("../core/facts/types.js").SnapshotId;
+    kind: "unsealed-bytes";
+    path: string;
+    paths: string[];
+}, {
+    kind: "unsealed-bytes";
+    path: string;
+    paths: string[];
+    head?: import("../core/facts/types.js").SnapshotId | undefined;
+}>>, z.ZodObject<{
+    kind: z.ZodLiteral<"target-checkout-retained">;
+    path: z.ZodString;
+    target: z.ZodString;
+    diagnostic: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"reconcile-failed">;
+    stage: z.ZodEnum<{
+        observation: "observation";
+        effect: "effect";
+    }>;
+    diagnostic: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"worktree-hook-failed">;
+    phase: z.ZodEnum<{
+        destroy: "destroy";
+        create: "create";
+    }>;
+    path: z.ZodString;
+    command: z.ZodNumber;
+    name: z.ZodString;
+    failure: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"exit">;
+        code: z.ZodNumber;
+        stdout: z.ZodString;
+        stderr: z.ZodString;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"timeout">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"spawn-error">;
+        diagnostic: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unknown-exit">;
+    }, z.core.$strict>]>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"contract-file-failed">;
+    worktree: z.ZodString;
+    path: z.ZodString;
+    diagnostic: z.ZodString;
+}, z.core.$strict>]>;

package/build/src/library/contract-forwarding-reconciliation-result.js

@@ -0,0 +1,83 @@
+import { snapshotId } from "../core/facts/types.js";
+import { z } from "zod";
+function canonicalSnapshot(value, context) {
+    try {
+        return snapshotId(value);
+    }
+    catch {
+        context.addIssue({ code: "custom", message: "expected SnapshotId" });
+        return z.NEVER;
+    }
+}
+const nonblankStringSchema = z.string().refine((value) => value.trim() !== "");
+const snapshotIdSchema = z.string().transform(canonicalSnapshot);
+const hookFailureSchema = z.union([
+    z
+        .object({
+        kind: z.literal("exit"),
+        code: z.number().int(),
+        stdout: z.string(),
+        stderr: z.string(),
+        truncated: z.boolean(),
+    })
+        .strict(),
+    z.object({ kind: z.literal("timeout") }).strict(),
+    z.object({ kind: z.literal("spawn-error"), diagnostic: z.string() }).strict(),
+    z.object({ kind: z.literal("unknown-exit") }).strict(),
+]);
+export const reconciliationLagSchema = z.union([
+    z.object({ kind: z.literal("worktree-retained"), path: nonblankStringSchema }).strict(),
+    z
+        .object({
+        kind: z.literal("worktree-follow-retained"),
+        path: nonblankStringSchema,
+        tender: snapshotIdSchema,
+        head: snapshotIdSchema,
+        reason: z.enum(["head-moved", "head-attached", "operation-in-progress", "unsupported-parent-shape"]),
+        paths: z.array(nonblankStringSchema).optional(),
+    })
+        .strict()
+        .transform(({ paths, ...lag }) => (paths === undefined ? lag : { ...lag, paths })),
+    z
+        .object({
+        kind: z.literal("unsealed-bytes"),
+        path: nonblankStringSchema,
+        paths: z.array(nonblankStringSchema),
+        head: snapshotIdSchema.optional(),
+    })
+        .strict()
+        .transform(({ head, ...lag }) => (head === undefined ? lag : { ...lag, head })),
+    z
+        .object({
+        kind: z.literal("target-checkout-retained"),
+        path: nonblankStringSchema,
+        target: nonblankStringSchema,
+        diagnostic: nonblankStringSchema,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("reconcile-failed"),
+        stage: z.enum(["observation", "effect"]),
+        diagnostic: nonblankStringSchema,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("worktree-hook-failed"),
+        phase: z.enum(["create", "destroy"]),
+        path: nonblankStringSchema,
+        command: z.number().int().nonnegative(),
+        name: nonblankStringSchema,
+        failure: hookFailureSchema,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("contract-file-failed"),
+        worktree: nonblankStringSchema,
+        path: nonblankStringSchema,
+        diagnostic: nonblankStringSchema,
+    })
+        .strict(),
+]);