@astrosheep/keiyaku 4.1.0 → 4.1.2

package/build/src/protocol/read/status.js

@@ -1,7 +1,7 @@
 import { observeActiveContractWorld, observeContractsForAdmissionInObservationAt, observeDeliveryTargetAt, withContractReadObservationAt, } from "../../git/observe.js";
 import { decodeContractDocument } from "../../body/decode.js";
-import { observeTargetLag, observeWorkspace, worktreePath, } from "../../git/workspace.js";
-import { appointmentFor, readPlaceRegister, } from "../../workspace-place.js";
+import { observeTargetLag, observeWorkspace, worktreePath } from "../../git/workspace.js";
+import { appointmentFor, readPlaceRegister } from "../../workspace-place.js";
 import { gateReports } from "../../core/facts/gate.js";
 function titleFor(state) {
     try {
@@ -19,7 +19,7 @@ function phaseFor(state) {
     if (state.terminal?.kind === "abandoned")
         return "abandoned";
     if (state.delivery !== null)
-        return "pending-delivery";
+        return "tendered";
     if (state.bound !== null)
         return "bound";
     return "waiting";
@@ -49,37 +49,32 @@ async function managedWorkspaceFacts(repository, state, register, targetObservat
     ]);
     return { appointed, workspaceObservation, targetLag };
 }
-async function hereWorkspaceFacts(repository, contractId, targetObservation, resolveHereWorkspace) {
-    const resolved = resolveHereWorkspace === undefined
-        ? { kind: "unappointed" }
-        : await resolveHereWorkspace(contractId);
-    if (resolved.kind === "failed") {
-        return {
-            appointed: undefined,
-            workspaceObservation: { kind: "failed", diagnostic: resolved.diagnostic },
-            targetLag: targetObservation === null ? { kind: "none" } : { kind: "unknown" },
-        };
-    }
-    if (resolved.kind === "unappointed") {
-        return {
-            appointed: undefined,
-            workspaceObservation: { kind: "unappointed" },
-            targetLag: targetObservation === null ? { kind: "none" } : { kind: "unknown" },
-        };
-    }
-    const [workspaceObservation, targetLag] = await Promise.all([
-        observeWorkspace(repository, { kind: "here" }, resolved.path),
-        observeTargetLag(repository, resolved.path, targetObservation?.head),
-    ]);
-    return { appointed: undefined, workspaceObservation, targetLag };
+function afterEndpoint(state) {
+    if (state === undefined || state === null)
+        return { kind: "missing" };
+    if (state.terminal?.kind === "claimed")
+        return { kind: "claimed" };
+    if (state.terminal?.kind === "abandoned")
+        return { kind: "abandoned" };
+    return { kind: "active", phase: phaseFor(state) };
+}
+function afterEdges(state, endpoints) {
+    return state.terms.after.map((contractId) => ({
+        contractId,
+        endpoint: afterEndpoint(endpoints.get(contractId)),
+    }));
+}
+function reverseDependents(id, rows) {
+    return rows
+        .filter((row) => row.disposition === "active" && row.after.some((edge) => edge.contractId === id))
+        .map((row) => ({ contractId: row.id, phase: row.phase }))
+        .sort((left, right) => left.contractId.localeCompare(right.contractId));
 }
 async function rowFor(input) {
-    const { repository, state, bindAt, lastJournalAt, targetObservation, register, resolveHereWorkspace } = input;
+    const { repository, state, bindAt, lastJournalAt, targetObservation, register, after, dependents } = input;
     const workspace = state.coordinates.workspace;
     const gates = gateReports(state);
-    const { appointed, workspaceObservation, targetLag } = workspace === "worktree"
-        ? await managedWorkspaceFacts(repository, state, register, targetObservation)
-        : await hereWorkspaceFacts(repository, state.id, targetObservation, resolveHereWorkspace);
+    const { appointed, workspaceObservation, targetLag } = await managedWorkspaceFacts(repository, state, register, targetObservation);
     return {
         id: state.id,
         title: titleFor(state),
@@ -100,62 +95,85 @@ async function rowFor(input) {
             reports: gates.reports.map((report) => ({ gate: report.gate, current: report.current })),
             satisfied: gates.satisfied,
         },
+        after,
+        dependents,
     };
 }
+async function afterEndpointMap(observation, known, ids) {
+    const missing = ids.filter((id) => !known.has(id));
+    if (missing.length === 0)
+        return known;
+    const extra = await observeContractsForAdmissionInObservationAt(observation, missing);
+    return new Map([...known, ...[...extra.journals].map(([id, record]) => [id, record.state])]);
+}
 /** Build the Contract board from one immutable git observation. */
-export async function readContractBoard(observation, selected, resolveHereWorkspace) {
-    if (selected !== undefined) {
-        const contract = await readContractObservation(observation, selected, resolveHereWorkspace);
-        return {
-            root: observation.repository.primaryWorktree,
-            state: observation.snapshot.commit,
-            rows: contract.kind === "missing" ? [] : [contract.row],
-        };
-    }
+export async function readContractBoard(observation, include) {
+    const observedAt = new Date().toISOString();
     const observed = await observeActiveContractWorld(observation);
+    const contracts = new Map(observed.contracts);
+    let endpoints = new Map(observed.eligibility);
+    if (include !== undefined && !contracts.has(include)) {
+        const extra = await observeContractsForAdmissionInObservationAt(observation, [include]);
+        const record = extra.journals.get(include);
+        if (record === undefined)
+            throw new Error(`missing requested Contract observation: ${include}`);
+        contracts.set(include, record);
+        endpoints.set(include, record.state);
+        if (record.state !== null) {
+            endpoints = new Map(await afterEndpointMap(observation, endpoints, record.state.terms.after));
+        }
+    }
     const register = await readPlaceRegister(observation.repository);
-    const rows = [];
-    for (const value of observed.contracts.values()) {
+    const projected = await Promise.all([...contracts.values()].flatMap((value) => {
         if (value.state === null)
-            continue;
+            return [];
         const state = value.state;
-        const bindAt = value.entries[0].at;
-        const lastJournalAt = lastJournalAtFor(value.entries);
-        rows.push(observeDeliveryTargetAt(observation, state).then((target) => rowFor({
-            repository: observation.repository,
-            state,
-            bindAt,
-            lastJournalAt,
-            targetObservation: target,
-            register,
-            ...(resolveHereWorkspace === undefined ? {} : { resolveHereWorkspace }),
-        })));
-    }
-    return { root: observation.repository.primaryWorktree, state: observed.snapshot, rows: await Promise.all(rows) };
+        return [
+            observeDeliveryTargetAt(observation, state).then((target) => rowFor({
+                repository: observation.repository,
+                state,
+                bindAt: value.entries[0].at,
+                lastJournalAt: lastJournalAtFor(value.entries),
+                targetObservation: target,
+                register,
+                after: afterEdges(state, endpoints),
+                dependents: [],
+            })),
+        ];
+    }));
+    const rows = projected.map((row) => ({ ...row, dependents: reverseDependents(row.id, projected) }));
+    return {
+        root: observation.repository.primaryWorktree,
+        state: observed.snapshot,
+        observedAt,
+        rows,
+    };
 }
 /** Observe one Contract and its target from one fresh ref epoch. */
-export async function readContractObservation(observation, id, resolveHereWorkspace) {
+export async function readContractObservation(observation, id) {
     const observed = await observeContractsForAdmissionInObservationAt(observation, [id]);
     const record = observed.journals.get(id);
     if (record === undefined)
         throw new Error(`missing requested Contract observation: ${id}`);
     const state = record.state;
-    return state === null
-        ? { kind: "missing", id }
-        : {
-            kind: "present",
-            row: await rowFor({
-                repository: observation.repository,
-                state,
-                bindAt: record.entries[0].at,
-                lastJournalAt: lastJournalAtFor(record.entries),
-                targetObservation: await observeDeliveryTargetAt(observation, state),
-                register: await readPlaceRegister(observation.repository),
-                ...(resolveHereWorkspace === undefined ? {} : { resolveHereWorkspace }),
-            }),
-        };
+    if (state === null)
+        return { kind: "missing", id };
+    const endpoints = await afterEndpointMap(observation, new Map([[id, state]]), state.terms.after);
+    return {
+        kind: "present",
+        row: await rowFor({
+            repository: observation.repository,
+            state,
+            bindAt: record.entries[0].at,
+            lastJournalAt: lastJournalAtFor(record.entries),
+            targetObservation: await observeDeliveryTargetAt(observation, state),
+            register: await readPlaceRegister(observation.repository),
+            after: afterEdges(state, endpoints),
+            dependents: [],
+        }),
+    };
 }
 /** Observe one Contract and its target from one fresh ref epoch. */
-export async function readContractObservationAt(repository, channel, id, resolveHereWorkspace) {
-    return withContractReadObservationAt(repository, channel, id, async (observation) => await readContractObservation(observation, id, resolveHereWorkspace));
+export async function readContractObservationAt(repository, channel, id) {
+    return withContractReadObservationAt(repository, channel, id, async (observation) => await readContractObservation(observation, id));
 }

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

@@ -31,5 +31,6 @@ export declare function worldContractStates(input: Readonly<{
 export declare function reconcileAllOperation(input: Readonly<{
     scope: RepositoryScope;
     channel: GitDecodeChannel;
+    states: readonly ContractState[];
 }> & ReconcileOptions): Promise<RepoReconcileReport>;
 export {};

package/build/src/protocol/reconcile.js

@@ -23,11 +23,10 @@ export async function reconcileOperation(input) {
 }
 export async function worldContractStates(input) {
     const observation = await withGitReadObservation(input.scope, input.channel, async (read) => await observeContractWorld(read));
-    return [...observation.contracts.values()].flatMap((value) => value.state === null ? [] : [value.state]);
+    return [...observation.contracts.values()].flatMap((value) => (value.state === null ? [] : [value.state]));
 }
 export async function reconcileAllOperation(input) {
-    const observation = await withGitReadObservation(input.scope, input.channel, async (read) => await observeContractWorld(read));
-    const contracts = (await reconcileBatch(input.scope, input.channel, observation.contracts.keys(), {
+    const contracts = (await reconcileBatch(input.scope, input.channel, input.states.map((state) => state.id), {
         hooks: input.hooks,
         retryHooks: input.retryHooks,
         retainTerminalWorktree: input.retainTerminalWorktree ?? false,

package/build/src/protocol/reintegrate.js

@@ -1,5 +1,5 @@
 import { contractState } from "../core/facts/observation.js";
-import { decideReintegrate, } from "../core/verbs/reintegrate.js";
+import { decideReintegrate } from "../core/verbs/reintegrate.js";
 import { materializeReintegrationSnapshot, persistedTender, planIntegration, } from "../git/integration.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";

package/build/src/protocol/review.d.ts

@@ -19,7 +19,6 @@ export type ReviewValue = CompletionEvidence & Readonly<{
 export declare function prepareReview(repository: RepositoryScope, stage: Readonly<{
     contractId: import("../core/facts/types.js").ContractId;
     coordinates: ContractState["coordinates"];
-    workspacePath?: string;
 }>): Promise<{
     kind: "prepared";
     data: Readonly<{

package/build/src/protocol/review.js

@@ -18,7 +18,6 @@ async function captureReviewableWorktree(repository, stage) {
     const tender = await captureTender(repository, {
         ...stage,
         ...(appointed === undefined ? {} : { place: appointed.place }),
-        ...(stage.workspacePath === undefined ? {} : { workspacePath: stage.workspacePath }),
     });
     if (tender.kind === "refused")
         return tender;
@@ -59,30 +58,26 @@ async function reviewAttempt(input, attempt) {
     let preparation;
     let workspace;
     let tender;
-    let workspacePath;
     if (state !== null) {
-        workspacePath = state.terminal === null && state.coordinates.workspace === "here"
-            ? await input.resolveHereWorkspace?.(state.id)
-            : undefined;
         const prepared = await captureReviewableWorktree(input.scope, {
             contractId: state.id,
             coordinates: state.coordinates,
-            ...(workspacePath === undefined ? {} : { workspacePath }),
         });
-        preparation = prepared.kind === "refused"
-            ? { kind: "refused", refusal: prepared.refusal }
-            : {
-                kind: "prepared",
-                data: {
-                    gate: REVIEWED,
-                    subject: dependencyKeySet([
-                        { kind: "document", value: state.terms.document.key },
-                        { kind: "change", value: prepared.data.changeId },
-                    ]),
-                    verdict: input.verdict,
-                    ...(input.summary === undefined ? {} : { summary: input.summary }),
-                },
-            };
+        preparation =
+            prepared.kind === "refused"
+                ? { kind: "refused", refusal: prepared.refusal }
+                : {
+                    kind: "prepared",
+                    data: {
+                        gate: REVIEWED,
+                        subject: dependencyKeySet([
+                            { kind: "document", value: state.terms.document.key },
+                            { kind: "change", value: prepared.data.changeId },
+                        ]),
+                        verdict: input.verdict,
+                        ...(input.summary === undefined ? {} : { summary: input.summary }),
+                    },
+                };
         if (prepared.kind === "prepared") {
             workspace = prepared.data.workspace;
             tender = prepared.data.tender;
@@ -114,7 +109,6 @@ async function reviewAttempt(input, attempt) {
             value: {
                 ...(workspace === undefined ? {} : { workspace }),
                 ...(tender === undefined ? {} : { tender }),
-                ...(workspacePath === undefined ? {} : { workspacePath }),
             },
         };
     return admission;
@@ -150,7 +144,6 @@ export async function reviewOperation(input) {
         verification: derivation?.verification ?? { kind: "prepared", data: null },
         initial: review,
         verifyInitial: false,
-        ...(review.value.workspacePath === undefined ? {} : { hereWorkspacePath: review.value.workspacePath }),
     });
     return admitted(completed.admission, reviewValue(review.value, completed.evidence));
 }

package/build/src/protocol/run.d.ts

@@ -35,6 +35,7 @@ export type RunProtocolInput<Input extends Readonly<{
     extendAttempt?: (attempt: AttemptContext, observedContractCount: number) => AttemptContext;
     /** Add opaque companions from the exact immutable observation for this attempt. */
     decorateOffer?: CompanionDecorator;
+    validateAdmission?: (observation: GitDecisionObservation) => Refusal | undefined | Promise<Refusal | undefined>;
     observationSelection?: GitTreeSelection;
 }> & (Readonly<{
     input: Input;

package/build/src/protocol/run.js

@@ -1,4 +1,4 @@
-import { extendAdmissionPathsAt, observeContractsForAdmissionAt, } from "../git/observe.js";
+import { extendAdmissionPathsAt, observeContractsForAdmissionAt } from "../git/observe.js";
 import { admitDecidedOffer } from "./attempt.js";
 /** Form one decided offer without admitting or reinterpreting it. */
 export async function prepareProtocolAttempt(input, baseAttempt) {
@@ -11,9 +11,7 @@ export async function prepareProtocolAttempt(input, baseAttempt) {
         : { kind: "prepared", input: input.input, assertions: [] };
     if (preparedInput.kind === "refused")
         return preparedInput;
-    const attempt = input.extendAttempt === undefined
-        ? baseAttempt
-        : input.extendAttempt(baseAttempt, observation.size);
+    const attempt = input.extendAttempt === undefined ? baseAttempt : input.extendAttempt(baseAttempt, observation.size);
     const decision = input.decide({ input: preparedInput.input, attempt, observation });
     if (decision.kind === "refused")
         return decision;
@@ -54,8 +52,9 @@ export async function runProtocol(input) {
             offer: prepared.offer,
             primaryContract: input.input.contractId,
             assertions: prepared.assertions,
+            ...(input.validateAdmission === undefined ? {} : { validateAdmission: input.validateAdmission }),
         });
-        if (result.kind === "accepted" || result.kind === "publication-failed")
+        if (result.kind === "accepted" || result.kind === "publication-failed" || result.kind === "refused")
             return result;
         if (result.kind === "collision" && index + 1 === attempts.length)
             return result;

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

@@ -0,0 +1,33 @@
+import { type ChildProcess } from "node:child_process";
+export type LaunchIntent = "handoff" | "retained";
+export type DetachedProcessInput = Readonly<{
+    argv: readonly string[];
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+    log: string;
+}>;
+export type SpawnLaunchPolicy = Readonly<{
+    kind: "spawn";
+    detached: boolean;
+    windowsHide: true;
+    shell: false;
+}>;
+export type PlatformLaunchPolicy = Readonly<{
+    kind: "windows-launcher";
+}> | SpawnLaunchPolicy;
+export declare function platformLaunchPolicy(intent: LaunchIntent, platform?: NodeJS.Platform): PlatformLaunchPolicy;
+export declare function spawnOptionsFor<Stdio>(intent: LaunchIntent, input: Readonly<{
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}>, stdio: Stdio, platform?: NodeJS.Platform): Readonly<{
+    cwd: string | undefined;
+    env: NodeJS.ProcessEnv | undefined;
+    detached: boolean;
+    stdio: Stdio;
+    windowsHide: true;
+    shell: false;
+}>;
+export declare function windowsLauncherPath(): string;
+export declare function spawnLoggedProcess(input: DetachedProcessInput, intent: LaunchIntent): Promise<ChildProcess>;
+export declare function handoffWindowsLaunch(input: DetachedProcessInput, launcher?: string): Promise<void>;
+export declare function handoffProcess(input: DetachedProcessInput): Promise<void>;

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

@@ -0,0 +1,98 @@
+import { spawn } from "node:child_process";
+import { open } from "node:fs/promises";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+export function platformLaunchPolicy(intent, platform = process.platform) {
+    if (platform === "win32" && intent === "handoff")
+        return { kind: "windows-launcher" };
+    return {
+        kind: "spawn",
+        detached: platform !== "win32",
+        windowsHide: true,
+        shell: false,
+    };
+}
+export function spawnOptionsFor(intent, input, stdio, platform = process.platform) {
+    const policy = platformLaunchPolicy(intent, platform);
+    if (policy.kind !== "spawn")
+        throw new Error("Windows Body handoff uses the GUI launcher");
+    return {
+        cwd: input.cwd,
+        env: input.env,
+        detached: policy.detached,
+        stdio,
+        windowsHide: policy.windowsHide,
+        shell: policy.shell,
+    };
+}
+export function windowsLauncherPath() {
+    const sourcePath = fileURLToPath(new URL("./windows-launch.exe", import.meta.url));
+    if (process.platform === "win32" && !/[\\/]build[\\/]/u.test(sourcePath)) {
+        return resolve(sourcePath, "../../../../build/src/runtime/proc/windows-launch.exe");
+    }
+    return sourcePath;
+}
+function launchFailure(command, diagnostic) {
+    const error = new Error(diagnostic.length > 0 ? diagnostic : `spawn ${command} UNKNOWN`);
+    const code = /\b(?:ENOENT|EACCES|EINVAL)\b/.exec(error.message)?.[0];
+    if (code)
+        error.code = code;
+    error.syscall = "spawn";
+    error.path = command;
+    return error;
+}
+async function waitSpawned(child) {
+    await new Promise((resolve, reject) => {
+        child.once("spawn", resolve);
+        child.once("error", reject);
+    });
+    if (child.pid === undefined)
+        throw new Error("detached process spawned without a pid");
+}
+export async function spawnLoggedProcess(input, intent) {
+    const log = await open(input.log, "a");
+    try {
+        const child = spawn(input.argv[0], input.argv.slice(1), spawnOptionsFor(intent, input, ["ignore", log.fd, log.fd]));
+        await waitSpawned(child);
+        return child;
+    }
+    finally {
+        await log.close();
+    }
+}
+export async function handoffWindowsLaunch(input, launcher = windowsLauncherPath()) {
+    const child = spawn(launcher, [input.log, ...input.argv], {
+        cwd: input.cwd,
+        env: input.env,
+        stdio: ["ignore", "ignore", "pipe"],
+        windowsHide: true,
+        shell: false,
+    });
+    let stderr = "";
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (chunk) => {
+        stderr = `${stderr}${chunk}`.slice(-4_000);
+    });
+    const closed = new Promise((resolve) => {
+        child.once("close", (exitCode) => resolve(exitCode));
+    });
+    try {
+        await waitSpawned(child);
+    }
+    catch (error) {
+        throw error instanceof Error ? error : new Error(String(error));
+    }
+    const code = await closed;
+    if (code === 0)
+        return;
+    throw launchFailure(input.argv[0] ?? launcher, stderr.trim());
+}
+export async function handoffProcess(input) {
+    const policy = platformLaunchPolicy("handoff");
+    if (policy.kind === "windows-launcher") {
+        await handoffWindowsLaunch(input);
+        return;
+    }
+    const child = await spawnLoggedProcess(input, "handoff");
+    child.unref();
+}

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

@@ -24,9 +24,15 @@ export class LineRpcProcess {
             this.fail(new Error(`line RPC process exited${exit.code === null ? "" : ` with code ${exit.code}`}`));
         });
     }
-    onNotification(listener) { this.notifications.add(listener); }
-    onServerRequest(listener) { this.serverRequests.add(listener); }
-    onExit(listener) { void this.process.exited.then(listener); }
+    onNotification(listener) {
+        this.notifications.add(listener);
+    }
+    onServerRequest(listener) {
+        this.serverRequests.add(listener);
+    }
+    onExit(listener) {
+        void this.process.exited.then(listener);
+    }
     consume(chunk) {
         this.stdout += chunk;
         for (;;) {

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

@@ -1,4 +1,6 @@
 import { type ChildProcess } from "node:child_process";
+import { type DetachedProcessInput } from "./launch.js";
+export { handoffProcess, type DetachedProcessInput } from "./launch.js";
 type ProcessLaunch = Readonly<{
     readonly argv: readonly string[];
     readonly cwd?: string;
@@ -37,14 +39,19 @@ export type ProcessConsumption = Readonly<{
     readonly outcome: ProcessOutcome | ProcessStreamError;
     readonly pid: number | null;
 }>;
-export type DetachedProcessInput = Readonly<{
-    argv: readonly string[];
-    cwd: string;
-    env?: NodeJS.ProcessEnv;
-    log: string;
+export type RunLogReference = Readonly<{
+    path: string;
+    from: number;
+    to: number;
+}>;
+export type DetachedProcessExit = Readonly<{
+    code: number | null;
+    signal: NodeJS.Signals | null;
+    log: RunLogReference;
 }>;
 export type OwnedProcess = Readonly<{
     pid: number;
+    exited: Promise<DetachedProcessExit>;
     terminate(force?: boolean): Promise<void>;
     release(): void;
 }>;
@@ -54,4 +61,3 @@ export declare function runProcess(input: ProcessInput): Promise<ProcessOutcome>
 export declare function runCrossPlatformProcess(input: ProcessInput): Promise<ProcessOutcome>;
 export declare function runProcessToExit(input: ProcessLaunch): Promise<ProcessOutcome>;
 export declare function consumeProcessStdout(input: ProcessInput, consume: (chunk: Buffer) => void): Promise<ProcessConsumption>;
-export {};