@alpacakit/agents 0.1.0-beta.35 → 0.1.0-beta.36

package/dist/internal/controlled-process/host-controller.js

@@ -1,7 +1,9 @@
 // biome-ignore-all lint/nursery/noExcessiveLinesPerFile: Section 5.103 confines the correction to this existing host lifecycle owner.
 import { spawn } from "node:child_process";
 import { CHILD_PROCESS_ABSENCE_PROOF, CHILD_PROCESS_TERMINATION_EVIDENCE_KIND, CHILD_PROCESS_TERMINATION_KIND, CHILD_PROCESS_UNKILLABLE_REASON, } from "../../core/controlled-process.js";
+import { CONTROLLED_PROCESS_LAUNCH_FAILURE_RETRYABILITY } from "../../core/error.js";
 import { readFramedRecords, readRequiredFrame, writeFramedRecord, } from "./framed-transport.js";
+import { ControlledProcessLaunchError, workerInputManifest, writeWorkerInput, } from "./input-transport.js";
 import { transitionControlledProcess } from "./lifecycle.js";
 import { controlledProcessRecordMatchesToken, signControlledProcessRecord, verifySignedControlledProcessRecord, } from "./record.js";
 import { assertSecureRuntimeDirectory, resolveSupervisorSocketNamespace, SignedRecordStore, supervisorSocketPath, } from "./record-store.js";
@@ -14,6 +16,7 @@ import { decodeProcessStartToken } from "./token.js";
 import { CONTROLLED_PROCESS_STATE } from "./values.js";
 const HOST_BOOTSTRAP_FD = 3;
 const HOST_IDENTITY_FD = 4;
+const HOST_INPUT_FD = 5;
 const OUTPUT_QUEUE_HIGH_WATER_BYTES = 64 * 1024;
 const OUTPUT_QUEUE_LOW_WATER_BYTES = 32 * 1024;
 const PRE_READY_CLEANUP_AUTHORITY = {
@@ -29,8 +32,9 @@ const TERMINATION_OBSERVATION_SOURCE = {
     supervisorClose: "supervisor_close",
     offlineFallback: "offline_fallback",
 };
-class SupervisorReportedLaunchFailure extends Error {
+class SupervisorReportedLaunchFailure extends ControlledProcessLaunchError {
 }
+// biome-ignore lint/complexity/noExcessiveLinesPerFunction: Launch, readiness, and pre-ready cleanup share one custody scope.
 export async function launchControlledProcess(input) {
     const platform = createSupervisorPlatformAdapter();
     const runtimeDirectory = await assertSecureRuntimeDirectory(input.runtimeDirectory, platform.uid);
@@ -39,6 +43,7 @@ export async function launchControlledProcess(input) {
     void supervisorClose.promise.catch(() => undefined);
     const control = supervisor.stdio[HOST_BOOTSTRAP_FD];
     const identityStream = supervisor.stdio[HOST_IDENTITY_FD];
+    const inputStream = supervisor.stdio.at(HOST_INPUT_FD);
     const identityFrames = readFramedRecords(identityStream)[Symbol.asyncIterator]();
     let output = null;
     let identity = null;
@@ -50,29 +55,52 @@ export async function launchControlledProcess(input) {
             kind: SUPERVISOR_BOOTSTRAP_FRAME_KIND.bootstrap,
             runtimeDirectory,
             shimEntryPath: input.shimEntryPath,
-            worker: input.worker,
+            worker: {
+                command: input.worker.command,
+                args: input.worker.args,
+                cwd: input.worker.cwd,
+                env: input.worker.env,
+            },
+            input: workerInputManifest(input.worker.stdin),
             timing: input.timing,
         });
+        const inputTransfer = writeWorkerInput(inputStream, input.worker.stdin);
+        void inputTransfer.catch(() => undefined);
         identity = await readSupervisorIdentity(identityFrames);
-        let hostAckComplete = false;
-        const readinessObservation = observeSupervisorReadiness(identityFrames, () => hostAckComplete);
+        let hostAckWriteStarted = false;
+        const readinessObservation = observeSupervisorReadiness(identityFrames, () => hostAckWriteStarted);
         await input.lifecycle.beforeExec(identity);
         descriptorCommitted = true;
+        hostAckWriteStarted = true;
         await writeFramedRecord(control, {
             kind: SUPERVISOR_BOOTSTRAP_FRAME_KIND.hostAck,
         });
-        hostAckComplete = true;
         control.end();
-        const readiness = await concludeSupervisorReadiness({
-            observation: readinessObservation,
-            identity,
-            runtimeDirectory,
-            supervisorClose,
-            timing: input.timing,
-        });
+        const [inputSettlement, readinessSettlement] = await Promise.allSettled([
+            inputTransfer,
+            concludeSupervisorReadiness({
+                observation: readinessObservation,
+                identity,
+                runtimeDirectory,
+                supervisorClose,
+                timing: input.timing,
+            }),
+        ]);
+        if (readinessSettlement.status === "rejected") {
+            throw readinessSettlement.reason;
+        }
+        const readiness = readinessSettlement.value;
         if (readiness.kind === "failure") {
             cleanupAuthority = readiness.cleanupAuthority;
-            throw readiness.error;
+            if (readiness.error instanceof SupervisorReportedLaunchFailure) {
+                throw readiness.error;
+            }
+            throw inputSettlement.status === "rejected"
+                ? inputSettlement.reason
+                : readiness.error;
+        }
+        if (inputSettlement.status === "rejected") {
+            throw inputSettlement.reason;
         }
         const readyIdentity = identity;
         let terminationRequested = false;
@@ -101,12 +129,14 @@ export async function launchControlledProcess(input) {
         };
     }
     catch (primaryFailure) {
-        if (primaryFailure instanceof SupervisorReportedLaunchFailure) {
+        if (primaryFailure instanceof SupervisorReportedLaunchFailure &&
+            identity === null) {
             cleanupAuthority = PRE_READY_CLEANUP_AUTHORITY.reportedFailure;
         }
         try {
             await cleanupPreReadySupervisor({
                 control,
+                inputStream,
                 identity,
                 descriptorCommitted,
                 runtimeDirectory,
@@ -118,26 +148,32 @@ export async function launchControlledProcess(input) {
             });
         }
         catch (cleanupFailure) {
+            if (primaryFailure instanceof ControlledProcessLaunchError) {
+                throw new ControlledProcessLaunchError({
+                    ...primaryFailure.failure,
+                    retryability: CONTROLLED_PROCESS_LAUNCH_FAILURE_RETRYABILITY.permanent,
+                }, new AggregateError([primaryFailure, cleanupFailure], `Controlled process launch and pre-ready cleanup both failed (${cleanupAuthority}).`));
+            }
             throw new AggregateError([primaryFailure, cleanupFailure], "Controlled process launch and pre-ready cleanup both failed.");
         }
         throw primaryFailure;
     }
 }
-function observeSupervisorReadiness(frames, hostAckComplete) {
+function observeSupervisorReadiness(frames, hostAckWriteStarted) {
     return frames.next().then((result) => ({
         kind: "result",
         result,
-        observedBeforeHostAck: !hostAckComplete(),
+        observedBeforeHostAckWrite: !hostAckWriteStarted(),
     }), (error) => ({
         kind: "failure",
         error,
-        observedBeforeHostAck: !hostAckComplete(),
+        observedBeforeHostAckWrite: !hostAckWriteStarted(),
     }));
 }
 async function concludeSupervisorReadiness(input) {
     const observation = await input.observation;
-    if (observation.observedBeforeHostAck) {
-        return readinessFailure(new Error("Supervisor readiness arrived before host ACK completed."), PRE_READY_CLEANUP_AUTHORITY.unprobed);
+    if (observation.observedBeforeHostAckWrite) {
+        return readinessFailure(new Error("Supervisor readiness arrived before the host ACK write began."), PRE_READY_CLEANUP_AUTHORITY.unprobed);
     }
     if (observation.kind === "failure") {
         return readinessFailure(observation.error, PRE_READY_CLEANUP_AUTHORITY.unprobed);
@@ -145,7 +181,7 @@ async function concludeSupervisorReadiness(input) {
     if (!observation.result.done) {
         const failure = supervisorLaunchFailedFrameSchema.safeParse(observation.result.value);
         if (failure.success) {
-            return readinessFailure(new Error(failure.data.reason), PRE_READY_CLEANUP_AUTHORITY.rollbackCompleted);
+            return readinessFailure(new SupervisorReportedLaunchFailure(failure.data.failure), PRE_READY_CLEANUP_AUTHORITY.live);
         }
         return readinessFailure(new Error("Supervisor readiness frame is invalid."), PRE_READY_CLEANUP_AUTHORITY.unprobed);
     }
@@ -209,6 +245,9 @@ async function cleanupPreReadySupervisor(input) {
     if (!input.control.destroyed && !input.control.writableEnded) {
         input.control.end();
     }
+    if (!input.inputStream.destroyed && !input.inputStream.writableEnded) {
+        input.inputStream.destroy();
+    }
     if (input.output !== null) {
         await input.output.queue[Symbol.asyncIterator]().return?.();
     }
@@ -377,7 +416,8 @@ async function raceSupervisorRequestWithClose(input) {
     return result;
 }
 function preReadyCleanupDeadline(timing) {
-    const budget = Math.min(Number.MAX_SAFE_INTEGER, timing.termGraceMs + timing.killProbeTimeoutMs + timing.probeIntervalMs);
+    const budget = Math.min(Number.MAX_SAFE_INTEGER, (timing.termGraceMs + timing.killProbeTimeoutMs + timing.probeIntervalMs) *
+        2);
     return Math.min(Number.MAX_SAFE_INTEGER, Date.now() + budget);
 }
 function beforeDeadline(operation, deadline, message) {
@@ -716,7 +756,7 @@ function spawnSupervisor(entryPath) {
     const child = spawn(process.execPath, [entryPath], {
         detached: true,
         env: {},
-        stdio: ["ignore", "pipe", "pipe", "pipe", "pipe"],
+        stdio: ["ignore", "pipe", "pipe", "pipe", "pipe", "pipe"],
     });
     containSupervisorStdioErrors(child);
     child.once("error", () => { });
@@ -777,7 +817,7 @@ async function readSupervisorIdentity(frames) {
     }
     const failure = supervisorLaunchFailedFrameSchema.safeParse(frame);
     if (failure.success) {
-        throw new SupervisorReportedLaunchFailure(failure.data.reason);
+        throw new SupervisorReportedLaunchFailure(failure.data.failure);
     }
     throw new Error("Supervisor identity frame is invalid.");
 }

package/dist/internal/controlled-process/input-transport.d.ts

@@ -0,0 +1,17 @@
+import type { Readable, Writable } from "node:stream";
+import type { ControlledProcessLaunchFailure, WorkerInputManifest } from "./supervisor-model.js";
+export declare class ControlledProcessLaunchError extends Error {
+    readonly failure: ControlledProcessLaunchFailure;
+    constructor(failure: ControlledProcessLaunchFailure, cause?: unknown);
+}
+export declare function workerInputManifest(input: string | null): WorkerInputManifest;
+export declare function writeWorkerInput(writable: Writable, input: string | null): Promise<void>;
+export declare function transferWorkerInput(input: {
+    readonly readable: Readable;
+    readonly writable: Writable;
+    readonly manifest: WorkerInputManifest;
+    readonly stage: ControlledProcessLaunchFailure["stage"];
+    readonly timeoutMs: number;
+}): Promise<void>;
+export declare function launchFailure(code: ControlledProcessLaunchFailure["code"], stage: ControlledProcessLaunchFailure["stage"], expectedBytes: number | null, actualBytes: number | null, message: string, cause?: unknown): ControlledProcessLaunchError;
+//# sourceMappingURL=input-transport.d.ts.map

package/dist/internal/controlled-process/input-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-transport.d.ts","sourceRoot":"","sources":["../../../src/internal/controlled-process/input-transport.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAKtD,OAAO,KAAK,EACV,8BAA8B,EAC9B,mBAAmB,EACpB,MAAM,uBAAuB,CAAC;AAK/B,qBAAa,4BAA6B,SAAQ,KAAK;IACrD,QAAQ,CAAC,OAAO,EAAE,8BAA8B,CAAC;gBAErC,OAAO,EAAE,8BAA8B,EAAE,KAAK,CAAC,EAAE,OAAO;CAKrE;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,mBAAmB,CAU7E;AAED,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,MAAM,GAAG,IAAI,GACnB,OAAO,CAAC,IAAI,CAAC,CAiBf;AAED,wBAAsB,mBAAmB,CAAC,KAAK,EAAE;IAC/C,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAC;IACvC,QAAQ,CAAC,KAAK,EAAE,8BAA8B,CAAC,OAAO,CAAC,CAAC;IACxD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,GAAG,OAAO,CAAC,IAAI,CAAC,CAuGhB;AAED,wBAAgB,aAAa,CAC3B,IAAI,EAAE,8BAA8B,CAAC,MAAM,CAAC,EAC5C,KAAK,EAAE,8BAA8B,CAAC,OAAO,CAAC,EAC9C,aAAa,EAAE,MAAM,GAAG,IAAI,EAC5B,WAAW,EAAE,MAAM,GAAG,IAAI,EAC1B,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,OAAO,GACd,4BAA4B,CAW9B"}

package/dist/internal/controlled-process/input-transport.js

@@ -0,0 +1,188 @@
+import { createHash } from "node:crypto";
+import { CONTROLLED_PROCESS_LAUNCH_FAILURE_CODE, CONTROLLED_PROCESS_LAUNCH_FAILURE_RETRYABILITY, } from "../../core/error.js";
+import { WORKER_INPUT_KIND } from "./supervisor-values.js";
+const SHA256_HEX_PATTERN = /^[a-f0-9]{64}$/u;
+export class ControlledProcessLaunchError extends Error {
+    failure;
+    constructor(failure, cause) {
+        super(failure.message, cause === undefined ? undefined : { cause });
+        this.name = "ControlledProcessLaunchError";
+        this.failure = failure;
+    }
+}
+export function workerInputManifest(input) {
+    if (input === null) {
+        return { kind: WORKER_INPUT_KIND.none };
+    }
+    const bytes = Buffer.from(input, "utf8");
+    return {
+        kind: WORKER_INPUT_KIND.stream,
+        byteLength: bytes.byteLength,
+        sha256: createHash("sha256").update(bytes).digest("hex"),
+    };
+}
+export async function writeWorkerInput(writable, input) {
+    const bytes = input === null ? Buffer.alloc(0) : Buffer.from(input, "utf8");
+    try {
+        if (bytes.byteLength > 0) {
+            await writeChunk(writable, bytes);
+        }
+        await endWritable(writable);
+    }
+    catch (error) {
+        throw launchFailure(CONTROLLED_PROCESS_LAUNCH_FAILURE_CODE.inputWriteFailed, "host_to_supervisor", bytes.byteLength, null, "Worker input data channel failed while writing.", error);
+    }
+}
+export async function transferWorkerInput(input) {
+    const expectedBytes = input.manifest.kind === WORKER_INPUT_KIND.none
+        ? 0
+        : input.manifest.byteLength;
+    const expectedDigest = input.manifest.kind === WORKER_INPUT_KIND.none
+        ? null
+        : input.manifest.sha256;
+    let actualBytes = 0;
+    const digest = createHash("sha256");
+    let timeout = null;
+    let timeoutFailure = null;
+    const transfer = transferWorkerInputBytes();
+    void transfer.catch(() => undefined);
+    try {
+        await Promise.race([
+            transfer,
+            new Promise((_resolve, reject) => {
+                timeout = setTimeout(() => {
+                    timeoutFailure = launchFailure(CONTROLLED_PROCESS_LAUNCH_FAILURE_CODE.inputTransferTimeout, input.stage, expectedBytes, actualBytes, "Worker input transfer exceeded its launch deadline.");
+                    input.readable.destroy();
+                    input.writable.destroy();
+                    reject(timeoutFailure);
+                }, input.timeoutMs);
+            }),
+        ]);
+    }
+    catch (error) {
+        if (timeoutFailure !== null) {
+            throw timeoutFailure;
+        }
+        throw error;
+    }
+    finally {
+        if (timeout !== null) {
+            clearTimeout(timeout);
+        }
+    }
+    async function transferWorkerInputBytes() {
+        try {
+            for await (const rawChunk of input.readable) {
+                const chunk = Buffer.isBuffer(rawChunk)
+                    ? rawChunk
+                    : Buffer.from(String(rawChunk), "utf8");
+                actualBytes += chunk.byteLength;
+                if (actualBytes > expectedBytes) {
+                    throw launchFailure(CONTROLLED_PROCESS_LAUNCH_FAILURE_CODE.inputOverrun, input.stage, expectedBytes, actualBytes, "Worker input contained bytes beyond its declared length.");
+                }
+                digest.update(chunk);
+                if (chunk.byteLength > 0) {
+                    await writeChunk(input.writable, chunk);
+                }
+            }
+            if (actualBytes !== expectedBytes) {
+                throw launchFailure(CONTROLLED_PROCESS_LAUNCH_FAILURE_CODE.inputEarlyEof, input.stage, expectedBytes, actualBytes, "Worker input ended before its declared length.");
+            }
+            if (expectedDigest !== null &&
+                (!SHA256_HEX_PATTERN.test(expectedDigest) ||
+                    digest.digest("hex") !== expectedDigest)) {
+                throw launchFailure(CONTROLLED_PROCESS_LAUNCH_FAILURE_CODE.inputDigestMismatch, input.stage, expectedBytes, actualBytes, "Worker input did not match its declared SHA-256 digest.");
+            }
+            await endWritable(input.writable);
+        }
+        catch (error) {
+            input.writable.destroy();
+            if (error instanceof ControlledProcessLaunchError) {
+                throw error;
+            }
+            throw launchFailure(CONTROLLED_PROCESS_LAUNCH_FAILURE_CODE.inputWriteFailed, input.stage, expectedBytes, actualBytes, "Worker input data channel failed during transfer.", error);
+        }
+    }
+}
+export function launchFailure(code, stage, expectedBytes, actualBytes, message, cause) {
+    const retryability = code === CONTROLLED_PROCESS_LAUNCH_FAILURE_CODE.inputWriteFailed ||
+        code === CONTROLLED_PROCESS_LAUNCH_FAILURE_CODE.inputTransferTimeout ||
+        code === CONTROLLED_PROCESS_LAUNCH_FAILURE_CODE.workerExited
+        ? CONTROLLED_PROCESS_LAUNCH_FAILURE_RETRYABILITY.transient
+        : CONTROLLED_PROCESS_LAUNCH_FAILURE_RETRYABILITY.permanent;
+    return new ControlledProcessLaunchError({ code, retryability, stage, expectedBytes, actualBytes, message }, cause);
+}
+function writeChunk(writable, chunk) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const cleanup = () => {
+            writable.off("error", failed);
+            writable.off("close", closed);
+        };
+        const settle = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            if (error === null) {
+                resolve();
+                return;
+            }
+            reject(error);
+        };
+        const failed = (error) => settle(error);
+        const closed = () => settle(new Error("Worker input writable closed during write."));
+        writable.once("error", failed);
+        writable.once("close", closed);
+        if (writable.destroyed || writable.closed || writable.writableEnded) {
+            closed();
+            return;
+        }
+        try {
+            writable.write(chunk, (error) => settle(error ?? null));
+        }
+        catch (error) {
+            settle(error instanceof Error
+                ? error
+                : new Error("Worker input writable write failed."));
+        }
+    });
+}
+function endWritable(writable) {
+    if (writable.destroyed || writable.closed) {
+        return Promise.reject(new Error("Worker input writable closed before end settlement."));
+    }
+    if (writable.writableFinished) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const cleanup = () => {
+            writable.off("error", failed);
+            writable.off("close", closed);
+        };
+        const settle = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            if (error === null) {
+                resolve();
+                return;
+            }
+            reject(error);
+        };
+        const failed = (error) => settle(error);
+        const closed = () => settle(new Error("Worker input writable closed before end settlement."));
+        writable.once("error", failed);
+        writable.once("close", closed);
+        try {
+            writable.end((error) => settle(error ?? null));
+        }
+        catch (error) {
+            settle(error instanceof Error
+                ? error
+                : new Error("Worker input writable end failed."));
+        }
+    });
+}

package/dist/internal/controlled-process/lifecycle.d.ts

@@ -1,5 +1,5 @@
 import type { ControlledProcessState } from "./model.js";
-export declare const CONTROLLED_PROCESS_TRANSITIONS: readonly [readonly ["reserved", "acked"], readonly ["reserved", "absent"], readonly ["acked", "running"], readonly ["acked", "absent"], readonly ["running", "term"], readonly ["running", "absent"], readonly ["term", "kill_sent"], readonly ["term", "absent"], readonly ["kill_sent", "absent"], readonly ["absent", "released"]];
+export declare const CONTROLLED_PROCESS_TRANSITIONS: readonly [readonly ["reserved", "acked"], readonly ["reserved", "absent"], readonly ["acked", "running"], readonly ["acked", "term"], readonly ["acked", "absent"], readonly ["running", "term"], readonly ["running", "absent"], readonly ["term", "kill_sent"], readonly ["term", "absent"], readonly ["kill_sent", "absent"], readonly ["absent", "released"]];
 export declare function isControlledProcessTransitionAllowed(from: ControlledProcessState, to: ControlledProcessState): boolean;
 export declare function transitionControlledProcess(from: ControlledProcessState, to: ControlledProcessState): ControlledProcessState;
 //# sourceMappingURL=lifecycle.d.ts.map

package/dist/internal/controlled-process/lifecycle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../src/internal/controlled-process/lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAQzD,eAAO,MAAM,8BAA8B,uUAWgB,CAAC;AAE5D,wBAAgB,oCAAoC,CAClD,IAAI,EAAE,sBAAsB,EAC5B,EAAE,EAAE,sBAAsB,GACzB,OAAO,CAIT;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,sBAAsB,EAC5B,EAAE,EAAE,sBAAsB,GACzB,sBAAsB,CAKxB"}
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../src/internal/controlled-process/lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAQzD,eAAO,MAAM,8BAA8B,mWAYgB,CAAC;AAE5D,wBAAgB,oCAAoC,CAClD,IAAI,EAAE,sBAAsB,EAC5B,EAAE,EAAE,sBAAsB,GACzB,OAAO,CAIT;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,sBAAsB,EAC5B,EAAE,EAAE,sBAAsB,GACzB,sBAAsB,CAKxB"}

package/dist/internal/controlled-process/lifecycle.js

@@ -3,6 +3,7 @@ export const CONTROLLED_PROCESS_TRANSITIONS = [
     [CONTROLLED_PROCESS_STATE.reserved, CONTROLLED_PROCESS_STATE.acked],
     [CONTROLLED_PROCESS_STATE.reserved, CONTROLLED_PROCESS_STATE.absent],
     [CONTROLLED_PROCESS_STATE.acked, CONTROLLED_PROCESS_STATE.running],
+    [CONTROLLED_PROCESS_STATE.acked, CONTROLLED_PROCESS_STATE.term],
     [CONTROLLED_PROCESS_STATE.acked, CONTROLLED_PROCESS_STATE.absent],
     [CONTROLLED_PROCESS_STATE.running, CONTROLLED_PROCESS_STATE.term],
     [CONTROLLED_PROCESS_STATE.running, CONTROLLED_PROCESS_STATE.absent],

package/dist/internal/controlled-process/schema.d.ts

@@ -30,7 +30,7 @@ export declare const controlledProcessIdentitySchema: z.ZodReadonly<z.ZodObject<
     processStartToken: z.ZodPipe<z.ZodString, z.ZodTransform<ProcessStartToken, string>>;
 }, z.core.$strip>>;
 export declare const controlledProcessRecordSchema: z.ZodReadonly<z.ZodObject<{
-    protocolVersion: z.ZodLiteral<"alpacakit-supervisor-v1">;
+    protocolVersion: z.ZodLiteral<"alpacakit-supervisor-v2">;
     platform: z.ZodEnum<{
         darwin: "darwin";
         linux: "linux";
@@ -60,7 +60,7 @@ export declare const controlledProcessRecordSchema: z.ZodReadonly<z.ZodObject<{
 }, z.core.$strip>>;
 export declare const signedControlledProcessRecordSchema: z.ZodReadonly<z.ZodObject<{
     record: z.ZodReadonly<z.ZodObject<{
-        protocolVersion: z.ZodLiteral<"alpacakit-supervisor-v1">;
+        protocolVersion: z.ZodLiteral<"alpacakit-supervisor-v2">;
         platform: z.ZodEnum<{
             darwin: "darwin";
             linux: "linux";

package/dist/internal/controlled-process/schema.js

@@ -5,7 +5,7 @@ import { SUPERVISOR_CONVERGENCE_REASON } from "./supervisor-values.js";
 import { CONTROLLED_PROCESS_PLATFORM, CONTROLLED_PROCESS_PROTOCOL_VERSION, CONTROLLED_PROCESS_STATE, SUPERVISOR_AUTHENTICATION_FRAME_KIND, } from "./values.js";
 const LOWER_HEX_16_BYTE_PATTERN = /^[0-9a-f]{32}$/u;
 const LOWER_HEX_32_BYTE_PATTERN = /^[0-9a-f]{64}$/u;
-const PROCESS_START_TOKEN_PATTERN = /^alpacakit-supervisor-v1:(?:darwin|linux):[0-9a-f]{32}:[0-9a-f]{32}:[0-9a-f]{32}:[0-9a-f]{32}:[0-9a-f]{64}$/u;
+const PROCESS_START_TOKEN_PATTERN = /^alpacakit-supervisor-v2:(?:darwin|linux):[0-9a-f]{32}:[0-9a-f]{32}:[0-9a-f]{32}:[0-9a-f]{32}:[0-9a-f]{64}$/u;
 const lowerHex16ByteSchema = z.string().regex(LOWER_HEX_16_BYTE_PATTERN);
 export const lowerHex32ByteSchema = z.string().regex(LOWER_HEX_32_BYTE_PATTERN);
 export const controlledProcessPlatformSchema = stringValueMapSchema(CONTROLLED_PROCESS_PLATFORM);

package/dist/internal/controlled-process/shim-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shim-runtime.d.ts","sourceRoot":"","sources":["../../../src/internal/controlled-process/shim-runtime.ts"],"names":[],"mappings":"AAeA,wBAAsB,wBAAwB,IAAI,OAAO,CAAC,IAAI,CAAC,CAgC9D"}
+{"version":3,"file":"shim-runtime.d.ts","sourceRoot":"","sources":["../../../src/internal/controlled-process/shim-runtime.ts"],"names":[],"mappings":"AAuBA,wBAAsB,wBAAwB,IAAI,OAAO,CAAC,IAAI,CAAC,CAiF9D"}

package/dist/internal/controlled-process/shim-runtime.js

@@ -1,15 +1,19 @@
 import { spawn } from "node:child_process";
+import { CONTROLLED_PROCESS_LAUNCH_FAILURE_CODE } from "../../core/error.js";
 import { readableFd, writableFd } from "./child-fd.js";
 import { readFramedRecords, readRequiredFrame, writeFramedRecord, } from "./framed-transport.js";
+import { ControlledProcessLaunchError, launchFailure, transferWorkerInput, } from "./input-transport.js";
 import { shimAckSchema, shimBootstrapSchema } from "./supervisor-schema.js";
 import { SHIM_FRAME_KIND } from "./supervisor-values.js";
 const SHIM_CONTROL_FD = 3;
 const SHIM_STATUS_FD = 4;
+const SHIM_INPUT_FD = 5;
 const SPAWN_FAILURE_EXIT_CODE = 127;
 const KEEPALIVE_INTERVAL_MS = 60_000;
 export async function runControlledProcessShim() {
     const control = readableFd(SHIM_CONTROL_FD);
     const status = writableFd(SHIM_STATUS_FD);
+    const input = readableFd(SHIM_INPUT_FD);
     const frames = readFramedRecords(control)[Symbol.asyncIterator]();
     const bootstrap = shimBootstrapSchema.parse(await readRequiredFrame(frames));
     try {
@@ -18,7 +22,12 @@ export async function runControlledProcessShim() {
     catch {
         return;
     }
-    process.on("SIGTERM", () => { });
+    let exitFailedLaunchOnSigterm = false;
+    process.on("SIGTERM", () => {
+        if (exitFailedLaunchOnSigterm) {
+            process.exit(0);
+        }
+    });
     const worker = spawn(bootstrap.worker.command, [...bootstrap.worker.args], {
         cwd: bootstrap.worker.cwd,
         env: bootstrap.worker.env,
@@ -28,10 +37,34 @@ export async function runControlledProcessShim() {
     });
     const workerExit = waitForWorkerExit(worker);
     worker.stdin.on("error", () => { });
-    if (bootstrap.worker.stdin !== null) {
-        worker.stdin.write(bootstrap.worker.stdin);
+    const delivery = transferWorkerInput({
+        readable: input,
+        writable: worker.stdin,
+        manifest: bootstrap.input,
+        stage: "shim_to_worker",
+        timeoutMs: bootstrap.inputTimeoutMs,
+    });
+    void delivery.catch(() => undefined);
+    const launch = await Promise.race([
+        delivery.then(() => ({ kind: "delivered" }), (error) => ({ kind: "failed", error })),
+        workerExit.then((exit) => ({ kind: "exited", exit })),
+    ]);
+    if (launch.kind === "exited") {
+        const failure = launchFailure(CONTROLLED_PROCESS_LAUNCH_FAILURE_CODE.workerExited, "shim_to_worker", bootstrap.input.kind === "stream" ? bootstrap.input.byteLength : 0, null, `Worker exited during input delivery with code ${launch.exit.code ?? "null"}.`);
+        exitFailedLaunchOnSigterm = true;
+        await reportLaunchFailure(status, failure);
+        setInterval(() => { }, KEEPALIVE_INTERVAL_MS);
+        return;
+    }
+    if (launch.kind === "failed") {
+        const { error } = launch;
+        exitFailedLaunchOnSigterm = true;
+        await reportLaunchFailure(status, error instanceof ControlledProcessLaunchError
+            ? error
+            : launchFailure(CONTROLLED_PROCESS_LAUNCH_FAILURE_CODE.inputWriteFailed, "shim_to_worker", bootstrap.input.kind === "stream" ? bootstrap.input.byteLength : 0, null, "Worker stdin delivery failed.", error));
+        setInterval(() => { }, KEEPALIVE_INTERVAL_MS);
+        return;
     }
-    worker.stdin.end();
     await writeFramedRecord(status, { kind: SHIM_FRAME_KIND.running });
     const exit = await workerExit;
     await writeFramedRecord(status, {
@@ -41,6 +74,12 @@ export async function runControlledProcessShim() {
     });
     setInterval(() => { }, KEEPALIVE_INTERVAL_MS);
 }
+async function reportLaunchFailure(status, error) {
+    await writeFramedRecord(status, {
+        kind: SHIM_FRAME_KIND.launchFailed,
+        failure: error.failure,
+    });
+}
 function waitForWorkerExit(worker) {
     return new Promise((resolve) => {
         let spawnFailed = false;

package/dist/internal/controlled-process/supervisor-coordinator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"supervisor-coordinator.d.ts","sourceRoot":"","sources":["../../../src/internal/controlled-process/supervisor-coordinator.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"supervisor-coordinator.d.ts","sourceRoot":"","sources":["../../../src/internal/controlled-process/supervisor-coordinator.ts"],"names":[],"mappings":"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"}

package/dist/internal/controlled-process/supervisor-coordinator.js

@@ -65,7 +65,8 @@ export class SupervisorCoordinator {
                 return;
             }
             this.workerExit = workerExit;
-            if (this.record.state === CONTROLLED_PROCESS_STATE.running &&
+            if ((this.record.state === CONTROLLED_PROCESS_STATE.running ||
+                this.record.state === CONTROLLED_PROCESS_STATE.acked) &&
                 !this.groupAbsentObserved &&
                 this.unkillableReason === null) {
                 await this.beginTermination();
@@ -108,7 +109,8 @@ export class SupervisorCoordinator {
         return this.enqueueResult(async () => {
             this.terminationRequested = true;
             this.terminationConvergenceReason ??= convergenceReason;
-            if (this.record.state === CONTROLLED_PROCESS_STATE.running &&
+            if ((this.record.state === CONTROLLED_PROCESS_STATE.running ||
+                this.record.state === CONTROLLED_PROCESS_STATE.acked) &&
                 !this.groupAbsentObserved &&
                 this.unkillableReason === null) {
                 await this.beginTermination();

package/dist/internal/controlled-process/supervisor-model.d.ts

@@ -1,5 +1,6 @@
 import type { ValueOf } from "@alpacakit/core";
 import type { ChildProcessIdentity, ChildProcessTerminationResult } from "../../core/controlled-process.js";
+import type { CONTROLLED_PROCESS_LAUNCH_FAILURE_CODE, CONTROLLED_PROCESS_LAUNCH_FAILURE_RETRYABILITY } from "../../core/error.js";
 import type { ExecExit } from "../../core/ports.js";
 import type { OUTPUT_CHANNEL_KIND, PROCESS_PROBE_KIND, PROCESS_SIGNAL_RESULT_KIND, SHIM_FRAME_KIND, SUPERVISOR_BOOTSTRAP_FRAME_KIND, SUPERVISOR_CONVERGENCE_REASON, SUPERVISOR_REQUEST_KIND, SUPERVISOR_RESPONSE_KIND } from "./supervisor-values.js";
 export type SupervisorWorkerOptions = {
@@ -9,7 +10,21 @@ export type SupervisorWorkerOptions = {
     readonly env: {
         readonly [key: string]: string;
     };
-    readonly stdin: string | null;
+};
+export type WorkerInputManifest = {
+    readonly kind: "none";
+} | {
+    readonly kind: "stream";
+    readonly byteLength: number;
+    readonly sha256: string;
+};
+export type ControlledProcessLaunchFailure = {
+    readonly code: ValueOf<typeof CONTROLLED_PROCESS_LAUNCH_FAILURE_CODE>;
+    readonly retryability: ValueOf<typeof CONTROLLED_PROCESS_LAUNCH_FAILURE_RETRYABILITY>;
+    readonly stage: "host_to_supervisor" | "supervisor_to_shim" | "shim_to_worker" | "control_protocol";
+    readonly expectedBytes: number | null;
+    readonly actualBytes: number | null;
+    readonly message: string;
 };
 export type SupervisorTimingOptions = {
     readonly termGraceMs: number;
@@ -23,6 +38,7 @@ export type SupervisorBootstrap = {
     readonly runtimeDirectory: string;
     readonly shimEntryPath: string;
     readonly worker: SupervisorWorkerOptions;
+    readonly input: WorkerInputManifest;
     readonly timing: SupervisorTimingOptions;
 };
 export type SupervisorHostAck = {
@@ -34,11 +50,13 @@ export type SupervisorIdentityFrame = {
 };
 export type SupervisorLaunchFailedFrame = {
     readonly kind: typeof SUPERVISOR_BOOTSTRAP_FRAME_KIND.launchFailed;
-    readonly reason: string;
+    readonly failure: ControlledProcessLaunchFailure;
 };
 export type ShimBootstrap = {
     readonly kind: typeof SHIM_FRAME_KIND.bootstrap;
     readonly worker: SupervisorWorkerOptions;
+    readonly input: WorkerInputManifest;
+    readonly inputTimeoutMs: number;
 };
 export type ShimAck = {
     readonly kind: typeof SHIM_FRAME_KIND.ack;
@@ -46,6 +64,10 @@ export type ShimAck = {
 export type ShimRunning = {
     readonly kind: typeof SHIM_FRAME_KIND.running;
 };
+export type ShimLaunchFailed = {
+    readonly kind: typeof SHIM_FRAME_KIND.launchFailed;
+    readonly failure: ControlledProcessLaunchFailure;
+};
 export type WorkerExit = {
     readonly kind: typeof SHIM_FRAME_KIND.workerExit;
     readonly code: number | null;