@astrosheep/keiyaku 4.6.19 → 4.6.20

package/build/src/akuma/body-launch.js

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { abortable, abortableDelay } from "./abort.js";
+import { decodeSoulSeed } from "./heart/soul.js";
+import { sessionAdmissionSchema } from "./heart/rows.js";
+import { akumaPathsSchema } from "./identity.js";
+const launchSeedSchema = z.unknown().transform((value, context) => {
+    try {
+        return decodeSoulSeed(value);
+    }
+    catch {
+        context.addIssue({ code: "custom", message: "invalid Body birth seed" });
+        return z.NEVER;
+    }
+});
+export const bodyLaunchSchema = z
+    .object({
+    paths: akumaPathsSchema,
+    seed: launchSeedSchema.optional(),
+    birthSession: sessionAdmissionSchema.optional(),
+    initialBody: z.string().optional(),
+    initiator: z.string().optional(),
+    birthInitiator: z.string().optional(),
+    initialSchemaJson: z.string().optional(),
+    refuseIfHeld: z.boolean().optional(),
+    handoffFromBodySequence: z.number().int().positive().optional(),
+    completion: z.object({ contractId: z.string().optional() }).strict().optional(),
+})
+    .strict();
+/** Observe durable custody first, including once more after live launch completion. */
+export async function observeBodyLaunch(child, observe, schedule = abortableDelay, signal) {
+    for (;;) {
+        signal?.throwIfAborted();
+        const value = await observe();
+        if (value !== null)
+            return { kind: "observed", value };
+        const controller = new AbortController();
+        const timer = schedule(100, controller.signal).then(() => ({ kind: "timer" }));
+        let winner;
+        try {
+            const waited = Promise.race([child.completed.then((end) => ({ kind: "completed", end })), timer]);
+            winner = signal === undefined ? await waited : await abortable(waited, signal);
+        }
+        finally {
+            controller.abort();
+            await timer.catch(() => undefined);
+        }
+        if (winner.kind === "timer")
+            continue;
+        const final = await observe();
+        return final === null ? winner : { kind: "observed", value: final };
+    }
+}
+export function launchEndWake(end) {
+    return end.held
+        ? { kind: "held" }
+        : { kind: "failed", diagnostic: end.diagnostic, ...(end.child === undefined ? {} : { child: end.child }) };
+}

package/build/src/akuma/body-supervisor.d.ts

@@ -2,10 +2,10 @@ import { type BodyControlSnapshot, type HeldAkumaLeash } from "./heart/index.js"
 import type { AkumaPaths } from "./identity.js";
 export declare const CONTROL_RESPONSE_MS = 1000;
 export declare class BodySupervisor {
-    private readonly paths;
-    private readonly bodySequence;
-    private readonly leash;
+    private readonly body;
     private readonly reader;
+    private readonly launchSignal?;
+    readonly forceSignal?: AbortSignal | undefined;
     readonly signal: AbortSignal;
     private readonly controller;
     private readonly finished;
@@ -13,14 +13,15 @@ export declare class BodySupervisor {
     private waiter;
     private observation;
     private stopping?;
+    private readonly cancelLaunch;
     private constructor();
-    static open(paths: AkumaPaths, bodySequence: number, leash: HeldAkumaLeash): Promise<BodySupervisor>;
-    get reason(): "control" | "heart-gone" | undefined;
+    static open(paths: AkumaPaths, bodySequence: number, leash: HeldAkumaLeash, signal?: AbortSignal, forceSignal?: AbortSignal): Promise<BodySupervisor>;
+    get reason(): "control" | "heart-gone" | "launch" | undefined;
     current(): BodyControlSnapshot;
     recordHung(diagnostic: string, at: string): Promise<void>;
     refresh(): Promise<BodyControlSnapshot>;
     next(after: BodyControlSnapshot): Promise<BodyControlSnapshot>;
-    cancel(reason: "control" | "heart-gone"): void;
+    cancel(reason: "control" | "heart-gone" | "launch"): void;
     close(): Promise<void>;
     private observe;
 }

package/build/src/akuma/body-supervisor.js

@@ -4,10 +4,10 @@ import { createBodyHeartReader } from "./heart/index.js";
 const BODY_CONTROL_OBSERVATION_MS = 100;
 export const CONTROL_RESPONSE_MS = 1_000;
 export class BodySupervisor {
-    paths;
-    bodySequence;
-    leash;
+    body;
     reader;
+    launchSignal;
+    forceSignal;
     signal;
     controller = new AbortController();
     finished = new AbortController();
@@ -15,18 +15,22 @@ export class BodySupervisor {
     waiter;
     observation;
     stopping;
-    constructor(paths, bodySequence, leash, reader, observation) {
-        this.paths = paths;
-        this.bodySequence = bodySequence;
-        this.leash = leash;
+    cancelLaunch = () => this.cancel("launch");
+    constructor(body, reader, observation, launchSignal, forceSignal) {
+        this.body = body;
         this.reader = reader;
+        this.launchSignal = launchSignal;
+        this.forceSignal = forceSignal;
         this.signal = this.controller.signal;
         this.observation = observation;
+        launchSignal?.addEventListener("abort", this.cancelLaunch, { once: true });
+        if (launchSignal?.aborted)
+            this.cancelLaunch();
         this.observer = this.observe();
     }
-    static async open(paths, bodySequence, leash) {
+    static async open(paths, bodySequence, leash, signal, forceSignal) {
         const reader = createBodyHeartReader(paths);
-        return new BodySupervisor(paths, bodySequence, leash, reader, await reader.read());
+        return new BodySupervisor({ paths, sequence: bodySequence, leash }, reader, await reader.read(), signal, forceSignal);
     }
     get reason() {
         return this.stopping;
@@ -35,7 +39,7 @@ export class BodySupervisor {
         return this.observation;
     }
     async recordHung(diagnostic, at) {
-        await this.leash.recordBodyHung(this.paths, { sequence: this.bodySequence, diagnostic, at });
+        await this.body.leash.recordBodyHung(this.body.paths, { sequence: this.body.sequence, diagnostic, at });
     }
     async refresh() {
         const snapshot = await this.reader.read();
@@ -57,12 +61,13 @@ export class BodySupervisor {
         if (this.stopping !== undefined)
             return;
         this.stopping = reason;
-        this.controller.abort(new Error(reason === "control" ? "Akuma Body interrupted by durable control" : "Akuma Heart disappeared"));
+        this.controller.abort(new Error(reason === "heart-gone" ? "Akuma Heart disappeared" : "Akuma Body interrupted"));
         this.waiter?.(this.observation);
         this.waiter = undefined;
     }
     async close() {
         this.finished.abort();
+        this.launchSignal?.removeEventListener("abort", this.cancelLaunch);
         try {
             await this.observer;
         }
@@ -76,7 +81,7 @@ export class BodySupervisor {
             const snapshot = this.observation;
             if (snapshot.soul === null)
                 return this.cancel("heart-gone");
-            if (snapshot.stop?.bodySequence === this.bodySequence || snapshot.pause?.bodySequence === this.bodySequence) {
+            if (snapshot.stop?.bodySequence === this.body.sequence || snapshot.pause?.bodySequence === this.body.sequence) {
                 return this.cancel("control");
             }
             try {

package/build/src/akuma/body.d.ts

@@ -1,109 +1,28 @@
-import { z } from "zod";
-import type { AkumaCallRequestChildLaunch } from "./call-request.js";
 import { type AkumaPaths } from "./identity.js";
 import { type TellResult } from "./call-initial-tell.js";
 export type { TellResult, TellWake } from "./call-initial-tell.js";
 import { type WorldRoot } from "../world.js";
 import type { ProviderAdapter } from "./provider.js";
+import type { ExecutionAssociationReader } from "./execution-instructions.js";
 import type { ErasedRequestCommand } from "./request-wire.js";
-import { type OwnedProcess } from "../runtime/proc/run.js";
-export declare const LEASH_HELD_EXIT = 75;
+import { type BodyLaunch, type BodyLauncher, type LiveBodyLaunch } from "./body-launch.js";
 export { CONTROL_RESPONSE_MS } from "./body-supervisor.js";
-export declare const bodyLaunchSchema: z.ZodObject<{
-    paths: z.ZodObject<{
-        directory: z.ZodString;
-        heart: z.ZodString;
-        leash: z.ZodString;
-        log: z.ZodString;
-        requests: z.ZodString;
-    }, z.core.$strict>;
-    seed: z.ZodOptional<z.ZodPipe<z.ZodUnknown, z.ZodTransform<Omit<Readonly<{
-        id: import("./identity.js").AkuId;
-        archetype: string;
-        description?: string;
-        provider: import("./provider-recipe.js").ProviderExecution;
-        options: import("./provider-recipe.js").ProviderOptions;
-        cwd: string;
-        origin: import("./heart/facts.js").AkumaOrigin;
-        caller?: import("./caller.js").AkumaCaller;
-        allowed: import("./allowed.js").AllowedActions;
-        createdAt: string;
-    }>, "createdAt">, unknown>>>;
-    birthSession: z.ZodOptional<z.ZodObject<{
-        provider: z.ZodString;
-        coordinate: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
-            sessionFile: z.ZodString;
-            sessionId: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>, z.ZodTransform<{
-            sessionFile: string;
-            sessionId?: never;
-        } | {
-            sessionFile: string;
-            sessionId: string;
-        }, {
-            sessionFile: string;
-            sessionId?: string | undefined;
-        }>>, z.ZodObject<{
-            sessionId: z.ZodString;
-        }, z.core.$strict>]>;
-        cwd: z.ZodString;
-        options: z.ZodPipe<z.ZodObject<{
-            model: z.ZodOptional<z.ZodString>;
-            effort: z.ZodOptional<z.ZodString>;
-            network: z.ZodOptional<z.ZodEnum<{
-                disabled: "disabled";
-                enabled: "enabled";
-            }>>;
-            systemPrompt: z.ZodOptional<z.ZodString>;
-            systemPromptMode: z.ZodOptional<z.ZodEnum<{
-                replace: "replace";
-                append: "append";
-            }>>;
-        }, z.core.$strip>, z.ZodTransform<Readonly<{
-            systemPromptMode?: "replace" | "append";
-            systemPrompt?: string;
-            network?: "disabled" | "enabled";
-            effort?: string;
-            model?: string;
-        }>, {
-            model?: string | undefined;
-            effort?: string | undefined;
-            network?: "disabled" | "enabled" | undefined;
-            systemPrompt?: string | undefined;
-            systemPromptMode?: "replace" | "append" | undefined;
-        }>>;
-        admittedAt: z.ZodString;
-    }, z.core.$strict>>;
-    initialBody: z.ZodOptional<z.ZodString>;
-    initiator: z.ZodOptional<z.ZodString>;
-    birthInitiator: z.ZodOptional<z.ZodString>;
-    initialSchemaJson: z.ZodOptional<z.ZodString>;
-    refuseIfHeld: z.ZodOptional<z.ZodBoolean>;
-    completion: z.ZodOptional<z.ZodObject<{
-        contractId: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type BodyLaunch = z.infer<typeof bodyLaunchSchema>;
 export type TellWakeRuntime = Readonly<{
-    spawn(paths: AkumaPaths): Promise<OwnedProcess>;
+    spawn(paths: AkumaPaths): Promise<LiveBodyLaunch>;
     schedule?(milliseconds: number, signal: AbortSignal): Promise<void>;
 }>;
-type BodyRuntime = Readonly<{
+export type BodyRuntime = Readonly<{
     now(): string;
-    spawnChild?(launch: AkumaCallRequestChildLaunch): Promise<OwnedProcess>;
-    spawnBody?(launch: BodyLaunch): Promise<OwnedProcess>;
+    spawn: BodyLauncher;
+    requestSpawn: BodyLauncher;
+    signal?: AbortSignal;
+    forceSignal?: AbortSignal;
     world: WorldRoot;
     externalCommands: Readonly<Record<string, ErasedRequestCommand>>;
+    executionAssociation?: ExecutionAssociationReader;
 }>;
+export declare function tellWakeRuntime(spawn: BodyLauncher): TellWakeRuntime;
 export declare function recordPluginDiagnostic(paths: AkumaPaths, occurrence: string, error: unknown): Promise<void>;
-export declare function bodyProcessInput(launch: BodyLaunch, bodyModuleUrl?: string): Promise<{
-    argv: string[];
-    cwd: string;
-    env: Record<string, string>;
-    log: string;
-}>;
-export declare function handoffPendingTells(paths: AkumaPaths, spawn?: (launch: BodyLaunch) => Promise<OwnedProcess>): Promise<void>;
-export declare function driveAkumaBody(launch: BodyLaunch, adapter?: ProviderAdapter, runtimeInput?: Partial<BodyRuntime>): Promise<"held" | void>;
-export declare function spawnAkumaBody(launch: BodyLaunch): Promise<OwnedProcess>;
-export declare function runAkumaBody(launch: BodyLaunch, world: WorldRoot, externalCommands: Readonly<Record<string, ErasedRequestCommand>>): Promise<"held" | void>;
-export declare function wakeRecordedTell(paths: AkumaPaths, tellId: string, runtime?: TellWakeRuntime, signal?: AbortSignal): Promise<TellResult>;
+export declare function handoffPendingTells(paths: AkumaPaths, spawn: BodyLauncher): Promise<void>;
+export declare function driveAkumaBody(launch: BodyLaunch, adapter: ProviderAdapter | undefined, runtimeInput: Pick<BodyRuntime, "spawn" | "requestSpawn"> & Partial<Omit<BodyRuntime, "spawn" | "requestSpawn">>): Promise<"held" | "hung" | void>;
+export declare function wakeRecordedTell(paths: AkumaPaths, tellId: string, runtime: TellWakeRuntime, signal?: AbortSignal): Promise<TellResult>;