@alpacakit/agents 0.1.0-beta.19 → 0.1.0-beta.21

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

@@ -0,0 +1,99 @@
+import { strictReadonlyObject, stringValueMapSchema } from "@alpacakit/core";
+import { z } from "zod";
+import { CHILD_PROCESS_ABSENCE_PROOF, CHILD_PROCESS_TERMINATION_KIND, CHILD_PROCESS_TERMINATION_PHASE, CHILD_PROCESS_UNKILLABLE_REASON, } from "../../core/controlled-process.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 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);
+export const controlledProcessStateSchema = stringValueMapSchema(CONTROLLED_PROCESS_STATE);
+export const supervisorBootIdSchema = lowerHex16ByteSchema.transform((value) => value);
+export const supervisorInstanceIdSchema = lowerHex16ByteSchema.transform((value) => value);
+export const controlledProcessRecordIdSchema = lowerHex16ByteSchema.transform((value) => value);
+export const supervisorSocketLocatorSchema = lowerHex16ByteSchema.transform((value) => value);
+export const supervisorCapabilitySchema = lowerHex32ByteSchema.transform((value) => value);
+export const controlledProcessRecordMacSchema = lowerHex32ByteSchema.transform((value) => value);
+export const supervisorAuthenticationMacSchema = lowerHex32ByteSchema.transform((value) => value);
+export const supervisorClientNonceSchema = lowerHex32ByteSchema.transform((value) => value);
+export const supervisorServerNonceSchema = lowerHex32ByteSchema.transform((value) => value);
+export const shimProcessIdSchema = z
+    .number()
+    .int()
+    .positive()
+    .max(Number.MAX_SAFE_INTEGER)
+    .transform((value) => value);
+export const processStartTokenSchema = z
+    .string()
+    .regex(PROCESS_START_TOKEN_PATTERN)
+    .transform((value) => value);
+export const controlledProcessIdentitySchema = strictReadonlyObject({
+    pid: shimProcessIdSchema,
+    processStartToken: processStartTokenSchema,
+});
+const controlledProcessRecordShape = strictReadonlyObject({
+    protocolVersion: z.literal(CONTROLLED_PROCESS_PROTOCOL_VERSION),
+    platform: controlledProcessPlatformSchema,
+    bootId: supervisorBootIdSchema,
+    supervisorInstanceId: supervisorInstanceIdSchema,
+    recordId: controlledProcessRecordIdSchema,
+    socketLocator: supervisorSocketLocatorSchema,
+    pid: shimProcessIdSchema,
+    state: controlledProcessStateSchema,
+    absenceProof: z
+        .enum([
+        CHILD_PROCESS_ABSENCE_PROOF.supervisorProbe,
+        CHILD_PROCESS_ABSENCE_PROOF.bootChanged,
+    ])
+        .nullable(),
+});
+export const controlledProcessRecordSchema = controlledProcessRecordShape.superRefine((record, context) => {
+    const terminal = record.state === CONTROLLED_PROCESS_STATE.absent ||
+        record.state === CONTROLLED_PROCESS_STATE.released;
+    if (terminal === (record.absenceProof === null)) {
+        context.addIssue({
+            code: "custom",
+            message: "Controlled process absence proof does not match state.",
+        });
+    }
+});
+export const signedControlledProcessRecordSchema = strictReadonlyObject({
+    record: controlledProcessRecordSchema,
+    recordMac: controlledProcessRecordMacSchema,
+});
+export const supervisorClientChallengeSchema = strictReadonlyObject({
+    kind: z.literal(SUPERVISOR_AUTHENTICATION_FRAME_KIND.clientChallenge),
+    recordId: controlledProcessRecordIdSchema,
+    clientNonce: supervisorClientNonceSchema,
+});
+export const supervisorChallengeSchema = strictReadonlyObject({
+    kind: z.literal(SUPERVISOR_AUTHENTICATION_FRAME_KIND.supervisorChallenge),
+    recordId: controlledProcessRecordIdSchema,
+    clientNonce: supervisorClientNonceSchema,
+    serverNonce: supervisorServerNonceSchema,
+    supervisorMac: supervisorAuthenticationMacSchema,
+});
+export const supervisorClientProofSchema = strictReadonlyObject({
+    kind: z.literal(SUPERVISOR_AUTHENTICATION_FRAME_KIND.clientProof),
+    recordId: controlledProcessRecordIdSchema,
+    clientNonce: supervisorClientNonceSchema,
+    serverNonce: supervisorServerNonceSchema,
+    supervisorMac: supervisorAuthenticationMacSchema,
+    clientMac: supervisorAuthenticationMacSchema,
+});
+export const childProcessTerminationResultSchema = z.discriminatedUnion("kind", [
+    strictReadonlyObject({
+        kind: z.literal(CHILD_PROCESS_TERMINATION_KIND.absent),
+        proof: stringValueMapSchema(CHILD_PROCESS_ABSENCE_PROOF),
+    }),
+    strictReadonlyObject({
+        kind: z.literal(CHILD_PROCESS_TERMINATION_KIND.pending),
+        phase: stringValueMapSchema(CHILD_PROCESS_TERMINATION_PHASE),
+        retryAfterMs: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+    }),
+    strictReadonlyObject({
+        kind: z.literal(CHILD_PROCESS_TERMINATION_KIND.unkillable),
+        reason: stringValueMapSchema(CHILD_PROCESS_UNKILLABLE_REASON),
+    }),
+]);

package/dist/internal/controlled-process/shim-entry.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=shim-entry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shim-entry.d.ts","sourceRoot":"","sources":["../../../src/internal/controlled-process/shim-entry.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,2 @@
+import { runControlledProcessShim } from "./shim-runtime.js";
+await runControlledProcessShim();

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

@@ -0,0 +1,2 @@
+export declare function runControlledProcessShim(): Promise<void>;
+//# sourceMappingURL=shim-runtime.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,57 @@
+import { spawn } from "node:child_process";
+import { readFramedRecords, readRequiredFrame, writeFramedRecord, } from "./framed-transport.js";
+import { readableFd, writableFd } from "./child-fd.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 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 frames = readFramedRecords(control)[Symbol.asyncIterator]();
+    const bootstrap = shimBootstrapSchema.parse(await readRequiredFrame(frames));
+    try {
+        shimAckSchema.parse(await readRequiredFrame(frames));
+    }
+    catch {
+        return;
+    }
+    process.on("SIGTERM", () => { });
+    const worker = spawn(bootstrap.worker.command, [...bootstrap.worker.args], {
+        cwd: bootstrap.worker.cwd,
+        env: bootstrap.worker.env,
+        detached: false,
+        shell: false,
+        stdio: ["pipe", "inherit", "inherit"],
+    });
+    const workerExit = waitForWorkerExit(worker);
+    worker.stdin.on("error", () => { });
+    if (bootstrap.worker.stdin !== null) {
+        worker.stdin.write(bootstrap.worker.stdin);
+    }
+    worker.stdin.end();
+    await writeFramedRecord(status, { kind: SHIM_FRAME_KIND.running });
+    const exit = await workerExit;
+    await writeFramedRecord(status, {
+        kind: SHIM_FRAME_KIND.workerExit,
+        code: exit.code,
+        signal: exit.signal,
+    });
+    setInterval(() => { }, KEEPALIVE_INTERVAL_MS);
+}
+function waitForWorkerExit(worker) {
+    return new Promise((resolve) => {
+        let spawnFailed = false;
+        worker.once("error", () => {
+            spawnFailed = true;
+        });
+        worker.once("close", (code, signal) => {
+            resolve({
+                code: spawnFailed ? SPAWN_FAILURE_EXIT_CODE : code,
+                signal,
+            });
+        });
+    });
+}

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

@@ -0,0 +1,67 @@
+import type { ChildProcessTerminationResult } from "../../core/controlled-process.js";
+import type { ExecExit } from "../../core/ports.js";
+import type { ControlledProcessRecord, SignedControlledProcessRecord, SupervisorCapability } from "./model.js";
+import type { SupervisorPlatformAdapter } from "./supervisor-platform.js";
+import type { SupervisorTimingOptions } from "./supervisor-model.js";
+export interface SupervisorRecordWriter {
+    write(record: SignedControlledProcessRecord): Promise<void>;
+}
+export declare class SupervisorCoordinator {
+    private record;
+    private readonly capability;
+    private readonly store;
+    private readonly platform;
+    private readonly timing;
+    private serial;
+    private outputClosed;
+    private shimExited;
+    private shimClosed;
+    private preAckAborted;
+    private groupAbsentObserved;
+    private absencePersistenceFailed;
+    private terminationRequested;
+    private sigkillSentHere;
+    private termDeadline;
+    private killDeadline;
+    private unkillableReason;
+    private workerExit;
+    private duplicateWorkerExit;
+    constructor(input: {
+        readonly record: ControlledProcessRecord;
+        readonly capability: SupervisorCapability;
+        readonly store: SupervisorRecordWriter;
+        readonly platform: SupervisorPlatformAdapter;
+        readonly timing: SupervisorTimingOptions;
+        readonly now: () => number;
+        readonly onAbsent: () => void;
+        readonly onReleased: () => void;
+    });
+    private readonly onAbsent;
+    private readonly onReleased;
+    private readonly now;
+    persistInitial(): Promise<void>;
+    acknowledge(): Promise<void>;
+    running(): Promise<void>;
+    recordWorkerExit(workerExit: ExecExit): Promise<void>;
+    recordShimExit(): Promise<void>;
+    recordShimClosed(): Promise<void>;
+    recordOutputClosed(): Promise<void>;
+    abortBeforeAck(): Promise<void>;
+    recordProtocolFailure(): Promise<void>;
+    tick(): Promise<void>;
+    terminate(): Promise<ChildProcessTerminationResult>;
+    probe(): Promise<ChildProcessTerminationResult>;
+    workerExitEvidence(): ExecExit | null;
+    release(): Promise<boolean>;
+    private beginTermination;
+    private converge;
+    private sendSigkillOnce;
+    private finishAbsenceWhenOutputCloses;
+    private observeGroupAbsence;
+    private result;
+    private transition;
+    private persist;
+    private enqueue;
+    private enqueueResult;
+}
+//# sourceMappingURL=supervisor-coordinator.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,325 @@
+import { CHILD_PROCESS_ABSENCE_PROOF, CHILD_PROCESS_TERMINATION_KIND, CHILD_PROCESS_TERMINATION_PHASE, CHILD_PROCESS_UNKILLABLE_REASON, } from "../../core/controlled-process.js";
+import { signControlledProcessRecord } from "./record.js";
+import { PROCESS_PROBE_KIND, PROCESS_SIGNAL_RESULT_KIND, } from "./supervisor-values.js";
+import { transitionControlledProcess } from "./lifecycle.js";
+import { CONTROLLED_PROCESS_PLATFORM, CONTROLLED_PROCESS_STATE, } from "./values.js";
+export class SupervisorCoordinator {
+    record;
+    capability;
+    store;
+    platform;
+    timing;
+    serial = Promise.resolve();
+    outputClosed = false;
+    shimExited = false;
+    shimClosed = false;
+    preAckAborted = false;
+    groupAbsentObserved = false;
+    absencePersistenceFailed = false;
+    terminationRequested = false;
+    sigkillSentHere = false;
+    termDeadline = 0;
+    killDeadline = 0;
+    unkillableReason = null;
+    workerExit = null;
+    duplicateWorkerExit = false;
+    constructor(input) {
+        this.record = input.record;
+        this.capability = input.capability;
+        this.store = input.store;
+        this.platform = input.platform;
+        this.timing = input.timing;
+        this.now = input.now;
+        this.onAbsent = input.onAbsent;
+        this.onReleased = input.onReleased;
+    }
+    onAbsent;
+    onReleased;
+    now;
+    persistInitial() {
+        return this.enqueue(async () => this.persist());
+    }
+    acknowledge() {
+        return this.enqueue(async () => {
+            await this.transition(CONTROLLED_PROCESS_STATE.acked);
+        });
+    }
+    running() {
+        return this.enqueue(async () => {
+            if (this.record.state === CONTROLLED_PROCESS_STATE.acked) {
+                await this.transition(CONTROLLED_PROCESS_STATE.running);
+                if (this.terminationRequested &&
+                    !this.groupAbsentObserved &&
+                    this.unkillableReason === null) {
+                    await this.beginTermination();
+                }
+            }
+        });
+    }
+    recordWorkerExit(workerExit) {
+        return this.enqueue(async () => {
+            if (this.workerExit !== null) {
+                this.duplicateWorkerExit = true;
+                this.unkillableReason = CHILD_PROCESS_UNKILLABLE_REASON.protocolFailure;
+                return;
+            }
+            this.workerExit = workerExit;
+            if (this.record.state === CONTROLLED_PROCESS_STATE.running &&
+                !this.groupAbsentObserved &&
+                this.unkillableReason === null) {
+                await this.beginTermination();
+            }
+        });
+    }
+    recordShimExit() {
+        return this.enqueue(async () => {
+            this.shimExited = true;
+            await this.converge();
+        });
+    }
+    recordShimClosed() {
+        return this.enqueue(async () => {
+            this.shimClosed = true;
+            await this.converge();
+        });
+    }
+    recordOutputClosed() {
+        return this.enqueue(async () => {
+            this.outputClosed = true;
+            await this.converge();
+        });
+    }
+    abortBeforeAck() {
+        return this.enqueue(async () => {
+            this.preAckAborted = true;
+            await this.converge();
+        });
+    }
+    recordProtocolFailure() {
+        return this.enqueue(async () => {
+            this.unkillableReason = CHILD_PROCESS_UNKILLABLE_REASON.protocolFailure;
+        });
+    }
+    tick() {
+        return this.enqueue(async () => this.converge());
+    }
+    terminate() {
+        return this.enqueueResult(async () => {
+            this.terminationRequested = true;
+            if (this.record.state === CONTROLLED_PROCESS_STATE.running &&
+                !this.groupAbsentObserved &&
+                this.unkillableReason === null) {
+                await this.beginTermination();
+            }
+            else {
+                await this.converge();
+            }
+            return this.result();
+        });
+    }
+    probe() {
+        return this.enqueueResult(async () => {
+            await this.converge();
+            return this.result();
+        });
+    }
+    workerExitEvidence() {
+        return this.workerExit;
+    }
+    release() {
+        return this.enqueueResult(async () => {
+            if (this.record.state === CONTROLLED_PROCESS_STATE.released) {
+                return true;
+            }
+            if (this.record.state !== CONTROLLED_PROCESS_STATE.absent) {
+                return false;
+            }
+            await this.transition(CONTROLLED_PROCESS_STATE.released);
+            this.onReleased();
+            return true;
+        });
+    }
+    async beginTermination() {
+        await this.transition(CONTROLLED_PROCESS_STATE.term);
+        this.termDeadline = this.now() + this.timing.termGraceMs;
+        const signal = this.platform.signalGroup(this.record.pid, "SIGTERM");
+        if (signal.kind === PROCESS_SIGNAL_RESULT_KIND.absent) {
+            await this.observeGroupAbsence();
+        }
+        else if (signal.kind === PROCESS_SIGNAL_RESULT_KIND.denied) {
+            this.unkillableReason =
+                CHILD_PROCESS_UNKILLABLE_REASON.probePermissionDenied;
+        }
+        else if (signal.kind === PROCESS_SIGNAL_RESULT_KIND.failed) {
+            this.unkillableReason = CHILD_PROCESS_UNKILLABLE_REASON.protocolFailure;
+        }
+    }
+    async converge() {
+        if (this.record.state === CONTROLLED_PROCESS_STATE.absent ||
+            this.record.state === CONTROLLED_PROCESS_STATE.released) {
+            return;
+        }
+        if (this.groupAbsentObserved) {
+            await this.finishAbsenceWhenOutputCloses();
+            return;
+        }
+        const probe = this.platform.probeGroup(this.record.pid);
+        if (probe.kind === PROCESS_PROBE_KIND.denied) {
+            if (this.record.state === CONTROLLED_PROCESS_STATE.killSent &&
+                this.record.platform === CONTROLLED_PROCESS_PLATFORM.darwin &&
+                this.sigkillSentHere &&
+                this.now() < this.killDeadline) {
+                return;
+            }
+            if (this.preAckAborted && !this.shimClosed) {
+                return;
+            }
+            this.unkillableReason =
+                CHILD_PROCESS_UNKILLABLE_REASON.probePermissionDenied;
+            return;
+        }
+        if (probe.kind === PROCESS_PROBE_KIND.failed) {
+            this.unkillableReason = CHILD_PROCESS_UNKILLABLE_REASON.protocolFailure;
+            return;
+        }
+        if (probe.kind === PROCESS_PROBE_KIND.absent) {
+            await this.observeGroupAbsence();
+            return;
+        }
+        if (this.unkillableReason !== null) {
+            return;
+        }
+        if (this.shimExited &&
+            this.record.state !== CONTROLLED_PROCESS_STATE.killSent &&
+            !(this.preAckAborted && !this.shimClosed)) {
+            this.unkillableReason =
+                CHILD_PROCESS_UNKILLABLE_REASON.shimLostWithLiveGroup;
+            return;
+        }
+        if (this.preAckAborted &&
+            (this.record.state === CONTROLLED_PROCESS_STATE.reserved ||
+                this.record.state === CONTROLLED_PROCESS_STATE.acked)) {
+            return;
+        }
+        if (this.record.state === CONTROLLED_PROCESS_STATE.term &&
+            this.now() >= this.termDeadline) {
+            await this.sendSigkillOnce();
+            return;
+        }
+        if (this.record.state === CONTROLLED_PROCESS_STATE.killSent &&
+            this.now() >= this.killDeadline) {
+            this.unkillableReason =
+                CHILD_PROCESS_UNKILLABLE_REASON.groupSurvivedSigkill;
+        }
+    }
+    async sendSigkillOnce() {
+        await this.transition(CONTROLLED_PROCESS_STATE.killSent);
+        this.killDeadline = this.now() + this.timing.killProbeTimeoutMs;
+        const signal = this.platform.signalGroup(this.record.pid, "SIGKILL");
+        if (signal.kind === PROCESS_SIGNAL_RESULT_KIND.sent) {
+            this.sigkillSentHere = true;
+        }
+        else if (signal.kind === PROCESS_SIGNAL_RESULT_KIND.absent) {
+            await this.observeGroupAbsence();
+        }
+        else if (signal.kind === PROCESS_SIGNAL_RESULT_KIND.denied) {
+            this.unkillableReason =
+                CHILD_PROCESS_UNKILLABLE_REASON.probePermissionDenied;
+        }
+        else if (signal.kind === PROCESS_SIGNAL_RESULT_KIND.failed) {
+            this.unkillableReason = CHILD_PROCESS_UNKILLABLE_REASON.protocolFailure;
+        }
+    }
+    async finishAbsenceWhenOutputCloses() {
+        if (!this.outputClosed || this.absencePersistenceFailed) {
+            return;
+        }
+        try {
+            await this.transition(CONTROLLED_PROCESS_STATE.absent);
+        }
+        catch (error) {
+            this.absencePersistenceFailed = true;
+            throw error;
+        }
+        if (!this.duplicateWorkerExit) {
+            this.unkillableReason = null;
+        }
+        this.onAbsent();
+    }
+    async observeGroupAbsence() {
+        this.groupAbsentObserved = true;
+        await this.finishAbsenceWhenOutputCloses();
+    }
+    result() {
+        if (this.unkillableReason !== null) {
+            return {
+                kind: CHILD_PROCESS_TERMINATION_KIND.unkillable,
+                reason: this.unkillableReason,
+            };
+        }
+        if (this.record.state === CONTROLLED_PROCESS_STATE.released) {
+            return {
+                kind: CHILD_PROCESS_TERMINATION_KIND.absent,
+                proof: CHILD_PROCESS_ABSENCE_PROOF.releasedReceipt,
+            };
+        }
+        if (this.record.state === CONTROLLED_PROCESS_STATE.absent) {
+            if (this.record.absenceProof === null) {
+                return {
+                    kind: CHILD_PROCESS_TERMINATION_KIND.unkillable,
+                    reason: CHILD_PROCESS_UNKILLABLE_REASON.protocolFailure,
+                };
+            }
+            return {
+                kind: CHILD_PROCESS_TERMINATION_KIND.absent,
+                proof: this.record.absenceProof,
+            };
+        }
+        const killPhase = this.record.state === CONTROLLED_PROCESS_STATE.killSent;
+        const termPhase = this.record.state === CONTROLLED_PROCESS_STATE.term;
+        const deadline = killPhase
+            ? this.killDeadline
+            : termPhase
+                ? this.termDeadline
+                : this.now() + this.timing.probeIntervalMs;
+        return {
+            kind: CHILD_PROCESS_TERMINATION_KIND.pending,
+            phase: killPhase
+                ? CHILD_PROCESS_TERMINATION_PHASE.killProbe
+                : CHILD_PROCESS_TERMINATION_PHASE.termGrace,
+            retryAfterMs: Math.max(1, deadline - this.now()),
+        };
+    }
+    async transition(next) {
+        const transitioned = {
+            ...this.record,
+            state: transitionControlledProcess(this.record.state, next),
+            absenceProof: next === CONTROLLED_PROCESS_STATE.absent
+                ? CHILD_PROCESS_ABSENCE_PROOF.supervisorProbe
+                : next === CONTROLLED_PROCESS_STATE.released
+                    ? this.record.absenceProof
+                    : null,
+        };
+        try {
+            await this.store.write(signControlledProcessRecord(transitioned, this.capability));
+        }
+        catch (error) {
+            this.unkillableReason = CHILD_PROCESS_UNKILLABLE_REASON.protocolFailure;
+            throw error;
+        }
+        this.record = transitioned;
+    }
+    persist() {
+        return this.store.write(signControlledProcessRecord(this.record, this.capability));
+    }
+    enqueue(operation) {
+        const result = this.serial.then(operation, operation);
+        this.serial = result.catch(() => undefined);
+        return result;
+    }
+    enqueueResult(operation) {
+        const result = this.serial.then(operation, operation);
+        this.serial = result.then(() => undefined, () => undefined);
+        return result;
+    }
+}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=supervisor-entry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"supervisor-entry.d.ts","sourceRoot":"","sources":["../../../src/internal/controlled-process/supervisor-entry.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,2 @@
+import { runControlledProcessSupervisor } from "./supervisor-runtime.js";
+await runControlledProcessSupervisor();

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

@@ -0,0 +1,92 @@
+import type { ValueOf } from "@alpacakit/core";
+import type { ChildProcessIdentity, ChildProcessTerminationResult } from "../../core/controlled-process.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_REQUEST_KIND, SUPERVISOR_RESPONSE_KIND } from "./supervisor-values.js";
+export type SupervisorWorkerOptions = {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly cwd: string;
+    readonly env: {
+        readonly [key: string]: string;
+    };
+    readonly stdin: string | null;
+};
+export type SupervisorTimingOptions = {
+    readonly termGraceMs: number;
+    readonly killProbeTimeoutMs: number;
+    readonly probeIntervalMs: number;
+};
+export type SupervisorBootstrap = {
+    readonly kind: typeof SUPERVISOR_BOOTSTRAP_FRAME_KIND.bootstrap;
+    readonly runtimeDirectory: string;
+    readonly shimEntryPath: string;
+    readonly worker: SupervisorWorkerOptions;
+    readonly timing: SupervisorTimingOptions;
+};
+export type SupervisorHostAck = {
+    readonly kind: typeof SUPERVISOR_BOOTSTRAP_FRAME_KIND.hostAck;
+};
+export type SupervisorIdentityFrame = {
+    readonly kind: typeof SUPERVISOR_BOOTSTRAP_FRAME_KIND.identity;
+    readonly identity: ChildProcessIdentity;
+};
+export type SupervisorLaunchFailedFrame = {
+    readonly kind: typeof SUPERVISOR_BOOTSTRAP_FRAME_KIND.launchFailed;
+    readonly reason: string;
+};
+export type ShimBootstrap = {
+    readonly kind: typeof SHIM_FRAME_KIND.bootstrap;
+    readonly worker: SupervisorWorkerOptions;
+};
+export type ShimAck = {
+    readonly kind: typeof SHIM_FRAME_KIND.ack;
+};
+export type ShimRunning = {
+    readonly kind: typeof SHIM_FRAME_KIND.running;
+};
+export type WorkerExit = {
+    readonly kind: typeof SHIM_FRAME_KIND.workerExit;
+    readonly code: number | null;
+    readonly signal: string | null;
+};
+export type SupervisorRequest = {
+    readonly kind: typeof SUPERVISOR_REQUEST_KIND.probe;
+} | {
+    readonly kind: typeof SUPERVISOR_REQUEST_KIND.terminate;
+} | {
+    readonly kind: typeof SUPERVISOR_REQUEST_KIND.release;
+};
+export type SupervisorResponse = {
+    readonly kind: typeof SUPERVISOR_RESPONSE_KIND.termination;
+    readonly result: ChildProcessTerminationResult;
+    readonly workerExit: ExecExit | null;
+} | {
+    readonly kind: typeof SUPERVISOR_RESPONSE_KIND.released;
+} | {
+    readonly kind: typeof SUPERVISOR_RESPONSE_KIND.releaseBeforeAbsent;
+};
+export type ProcessProbe = {
+    readonly kind: typeof PROCESS_PROBE_KIND.alive;
+} | {
+    readonly kind: typeof PROCESS_PROBE_KIND.absent;
+} | {
+    readonly kind: typeof PROCESS_PROBE_KIND.denied;
+} | {
+    readonly kind: typeof PROCESS_PROBE_KIND.failed;
+    readonly code: string;
+};
+export type ProcessSignalResult = {
+    readonly kind: typeof PROCESS_SIGNAL_RESULT_KIND.sent;
+} | {
+    readonly kind: typeof PROCESS_SIGNAL_RESULT_KIND.absent;
+} | {
+    readonly kind: typeof PROCESS_SIGNAL_RESULT_KIND.denied;
+} | {
+    readonly kind: typeof PROCESS_SIGNAL_RESULT_KIND.failed;
+    readonly code: string;
+};
+export type ControlledProcessOutput = {
+    readonly channel: ValueOf<typeof OUTPUT_CHANNEL_KIND>;
+    readonly text: string;
+};
+//# sourceMappingURL=supervisor-model.d.ts.map