@acpus/runtime 0.8.0 → 0.9.0-alpha.1

package/dist/supervisor-app.js

@@ -1,694 +0,0 @@
-import { Hono } from "hono";
-import { WorkflowInterpreter, generateRunId } from "./interpreter.js";
-import { InputValidationFailure } from "./validate-input.js";
-import { SignalPayloadValidationError } from "./validate-signal.js";
-import { applyAgentOverrides, compileWorkflow, emptyAgentOverrideResult, optionalSubmissionMetadata, parseWorkflowSpecForOverrides, serializeWorkflowSpecForOverrides, workflowSourceResolver } from "@acpus/core";
-import { resolve } from "node:path";
-import { isRunTerminal } from "./types.js";
-import { ForkError, materializeForkedRun, planForkedRun } from "./fork.js";
-import { ArtifactReferences } from "./artifacts.js";
-import { HookConfigLoader } from "./hooks/loader.js";
-import { HookRunner } from "./hooks/runner.js";
-import { isUnsafeRunId } from "./run-id.js";
-/**
- * Creates a Hono HTTP app for the acpus Run Supervisor.
- *
- * Note: Node keys contain "/" characters (e.g. "workflow/step-a"), which are
- * incompatible with URL path segments. Node-addressed routes accept the nodeKey
- * as a query parameter instead.
- *
- * Returns the Hono app plus control handles for the runner to query
- * idle-shutdown state and inject health-overrides after listen.
- */
-export function createSupervisorApp(config, store, agentExecutor, programExecutor) {
-    const app = new Hono();
-    // Active interpreter instances
-    const interpreters = new Map();
-    // In-flight runToCompletion promises, keyed by runId, to prevent concurrent
-    // execution races during Run-level resume or retry.
-    const inFlightRuns = new Map();
-    // Mutex guard: runIds currently being resumed or retried. Prevents concurrent
-    // resume or retry requests from starting duplicate runToCompletion executions.
-    const resumingRunIds = new Set();
-    // Lease tracking for idle shutdown
-    const clientLeases = new Map();
-    let lastActiveAt = Date.now();
-    // Health overrides set by the runner after the server binds to a port
-    let healthStartedAt = "";
-    let healthEndpoint = "";
-    const workspaceRoot = resolve(config.workspace ?? process.cwd());
-    const sourceResolver = workflowSourceResolver(workspaceRoot);
-    const hookConfigLoader = new HookConfigLoader(workspaceRoot);
-    /** Refresh lease on every request with client headers. */
-    function refreshLease(clientId, clientKind) {
-        if (!clientId || !clientKind)
-            return;
-        clientLeases.set(clientId, { kind: clientKind, lastSeen: Date.now() });
-        lastActiveAt = Date.now();
-    }
-    /** Expire stale leases (TTL 2s). */
-    function expireLeases() {
-        const now = Date.now();
-        for (const [id, lease] of clientLeases) {
-            if (now - lease.lastSeen > 2000) {
-                clientLeases.delete(id);
-            }
-        }
-    }
-    /** Count of non-expired leases. */
-    function activeClientCount() {
-        expireLeases();
-        return clientLeases.size;
-    }
-    /** Count of Runs with status === "running". */
-    function runningCount() {
-        let count = 0;
-        for (const runId of store.listRunIds()) {
-            const meta = store.readRunMeta(runId);
-            if (meta?.status === "running")
-                count++;
-        }
-        return count;
-    }
-    /** Get the most recent active timestamp (for idle shutdown). */
-    function getLastActiveAt() {
-        expireLeases();
-        let maxLease = 0;
-        for (const lease of clientLeases.values()) {
-            if (lease.lastSeen > maxLease)
-                maxLease = lease.lastSeen;
-        }
-        return Math.max(lastActiveAt, maxLease);
-    }
-    /** Create an interpreter bound to this supervisor's store + executors. */
-    function newInterpreter(runId) {
-        const nowTimestamp = runId ? store.readRunMeta(runId)?.createdAt : undefined;
-        // Rebuild the frozen hook runner from the Run's persisted snapshot so retry,
-        // resume, and fork executions all reuse the same frozen configuration.
-        const snapshot = runId ? store.readHookConfig(runId) : undefined;
-        const hookRunner = snapshot ? new HookRunner(snapshot.mergedConfig) : undefined;
-        return new WorkflowInterpreter(store, agentExecutor, programExecutor, { nowTimestamp, hookRunner });
-    }
-    /**
-     * Freeze the merged hook configuration for a newly-created Run. Writes
-     * hook-config.json and records the hash on Run metadata when any hooks apply;
-     * otherwise leaves no file and no hash so the Run incurs zero hook overhead.
-     */
-    function freezeHookConfig(runId) {
-        const snapshot = hookConfigLoader.freeze();
-        if (!snapshot)
-            return;
-        store.writeHookConfig(runId, snapshot);
-        const meta = store.readRunMeta(runId);
-        if (meta) {
-            meta.hookConfigHash = snapshot.hash;
-            store.writeRunMeta(runId, meta);
-            return meta;
-        }
-    }
-    /**
-     * Interpreter for a forward-progress control action (resume or retry). When the
-     * supervisor has restarted (in-memory map empty) but the Run persists, lazily
-     * recover one and reset stale `running` nodes so the action can proceed.
-     * Returns `undefined` only when the Run does not exist on disk.
-     */
-    function getOrRecoverInterpreter(runId) {
-        const live = interpreters.get(runId);
-        if (live)
-            return live;
-        if (!store.hasRun(runId))
-            return undefined;
-        const recovered = newInterpreter(runId);
-        recovered.recoverStaleNodes(runId);
-        interpreters.set(runId, recovered);
-        return recovered;
-    }
-    /**
-     * Read-only interpreter used by replay. Lazily creates one for cross-process
-     * access but NEVER mutates persisted state (no crash recovery). Returns
-     * `undefined` only when the Run does not exist on disk.
-     */
-    function getReadOnlyInterpreter(runId) {
-        const live = interpreters.get(runId);
-        if (live)
-            return live;
-        if (!store.hasRun(runId))
-            return undefined;
-        return newInterpreter(runId);
-    }
-    /** Prune interpreters for terminal Runs from the in-memory map. */
-    function pruneTerminalInterpreters() {
-        for (const [runId] of interpreters) {
-            const meta = store.readRunMeta(runId);
-            if (meta && isRunTerminal(meta.status)) {
-                interpreters.delete(runId);
-            }
-        }
-    }
-    // ─── Lease refresh middleware (runs before route handlers) ────────
-    app.use("*", async (c, next) => {
-        const clientId = c.req.header("x-acpus-client-id");
-        const clientKind = c.req.header("x-acpus-client-kind");
-        refreshLease(clientId, clientKind);
-        await next();
-    });
-    // ─── runId path-traversal guard ──────────────────────────────────
-    app.use("/runs/:runId/*", async (c, next) => {
-        const runId = c.req.param("runId");
-        if (isUnsafeRunId(runId)) {
-            return c.json({ error: "Invalid runId format" }, 400);
-        }
-        await next();
-    });
-    /** Fire-and-forget runToCompletion with proper tracking and cleanup. */
-    function startRunExecution(interpreter, ir, input, runId) {
-        const promise = interpreter.runToCompletion(ir, { input }, runId)
-            .catch(() => {
-            // runToCompletion always resolves with the RunState (never rejects
-            // with undefined), but the catch silences any unexpected throw.
-            const meta = store.readRunMeta(runId);
-            return meta ?? {
-                runId,
-                workflowName: "",
-                status: "failed",
-                irDigest: "",
-                inputDigest: "",
-                createdAt: "",
-                updatedAt: "",
-                runAttempt: 1
-            };
-        })
-            .finally(() => {
-            inFlightRuns.delete(runId);
-            pruneTerminalInterpreters();
-            if (runningCount() === 0)
-                lastActiveAt = Date.now();
-        });
-        inFlightRuns.set(runId, promise);
-    }
-    function startPersistedRunExecution(interpreter, runId) {
-        const ir = store.readIr(runId);
-        const input = store.readInput(runId);
-        if (ir && input) {
-            startRunExecution(interpreter, ir, input, runId);
-        }
-    }
-    /**
-     * Node-level retry may run for a long time. Wait one event-loop turn so
-     * synchronous validation errors surface as 409s, then detach once execution
-     * has started so interactive clients are not kept alive by the request.
-     */
-    function settleImmediate(promise) {
-        return Promise.race([
-            promise.then((value) => ({ kind: "settled", value })).catch((error) => ({ kind: "rejected", error })),
-            new Promise((resolve) => setImmediate(() => resolve({ kind: "pending" })))
-        ]);
-    }
-    function consumeDetachedControl(promise) {
-        void promise.catch(() => undefined);
-    }
-    // ─── Health ──────────────────────────────────────────────────────
-    app.get("/health", (c) => {
-        const health = {
-            ok: true,
-            schemaVersion: 1,
-            workspace: workspaceRoot,
-            pid: process.pid,
-            endpoint: healthEndpoint,
-            startedAt: healthStartedAt,
-            version: "0.1.0",
-            runningCount: runningCount(),
-            activeClients: activeClientCount()
-        };
-        return c.json(health);
-    });
-    // ─── Runs ────────────────────────────────────────────────────────
-    app.post("/runs", async (c) => {
-        const body = await c.req.json();
-        if (!body.spec) {
-            return c.json({ error: "spec is required" }, 400);
-        }
-        let sourcePath;
-        if (body.sourcePath) {
-            try {
-                sourcePath = sourceResolver.validateSourcePath(body.sourcePath);
-            }
-            catch (error) {
-                return c.json({ error: errorMessage(error) }, 400);
-            }
-        }
-        let effectiveSource = body.spec;
-        let submitMetadata = emptyAgentOverrideResult();
-        try {
-            if (body.agentOverrides !== undefined) {
-                const parsedSpec = parseWorkflowSpecForOverrides(body.spec);
-                submitMetadata = applyAgentOverrides(parsedSpec, body.agentOverrides);
-                effectiveSource = serializeWorkflowSpecForOverrides(submitMetadata.effectiveSpec);
-            }
-        }
-        catch (error) {
-            return c.json({ error: errorMessage(error) }, 400);
-        }
-        const result = compileWorkflow(effectiveSource, {
-            sourcePath,
-            includeResolver: sourceResolver.createIncludeResolver(sourcePath)
-        });
-        if (!result.ok || !result.ir) {
-            return c.json({ error: "Compilation failed", diagnostics: result.diagnostics }, 400);
-        }
-        const initInterpreter = newInterpreter();
-        let runState;
-        try {
-            runState = initInterpreter.initRun(result.ir, {
-                input: body.input ?? {},
-                workflowRef: body.workflowRef,
-                workflowSourcePath: sourcePath,
-                ...optionalSubmissionMetadata(submitMetadata),
-                skipHooks: Boolean(body.skipHooks)
-            });
-        }
-        catch (error) {
-            if (error instanceof InputValidationFailure) {
-                return c.json({ error: "Input validation failed", validationErrors: error.errors }, 400);
-            }
-            throw error;
-        }
-        // Freeze hook configuration once at Run creation unless this submission
-        // explicitly disabled hooks. Retry/resume reuse the Run's frozen state.
-        if (!body.skipHooks)
-            runState = freezeHookConfig(runState.runId) ?? runState;
-        const interpreter = newInterpreter(runState.runId);
-        interpreters.set(runState.runId, interpreter);
-        lastActiveAt = Date.now();
-        // initRun has already validated and filled defaults; read the validated
-        // input from the store rather than re-using the raw body.input.
-        const validatedInput = store.readInput(runState.runId) ?? body.input ?? {};
-        startRunExecution(interpreter, result.ir, validatedInput, runState.runId);
-        return c.json(runState, 201);
-    });
-    app.get("/runs", (c) => {
-        const runIds = store.listRunIds();
-        const summaries = [];
-        for (const id of runIds) {
-            const meta = store.readRunMeta(id);
-            if (meta) {
-                summaries.push({
-                    runId: meta.runId,
-                    workflowName: meta.workflowName,
-                    workflowRef: meta.workflowRef,
-                    workflowSourcePath: meta.workflowSourcePath,
-                    status: meta.status,
-                    createdAt: meta.createdAt,
-                    updatedAt: meta.updatedAt,
-                    lineage: meta.lineage
-                });
-            }
-            // Skip corrupt Run metadata deterministically (don't crash)
-        }
-        // Sort by updatedAt descending, limit to most recent 50
-        summaries.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-        return c.json(summaries.slice(0, 50));
-    });
-    app.get("/runs/:runId", (c) => {
-        const runId = c.req.param("runId");
-        const meta = store.readRunMeta(runId);
-        if (!meta) {
-            return c.json({ error: "Run not found" }, 404);
-        }
-        const nodes = store.listNodeStates(runId);
-        return c.json({ ...meta, nodes });
-    });
-    app.post("/runs/clean", async (c) => {
-        pruneTerminalInterpreters();
-        const body = await c.req.json().catch(() => ({}));
-        const result = store.cleanTerminalRuns({ dryRun: Boolean(body.dryRun) });
-        if (!body.dryRun) {
-            for (const item of result.deleted) {
-                interpreters.delete(item.runId);
-            }
-        }
-        lastActiveAt = Date.now();
-        return c.json(result);
-    });
-    // ─── Nodes ───────────────────────────────────────────────────────
-    app.get("/runs/:runId/nodes", (c) => {
-        const runId = c.req.param("runId");
-        if (!store.hasRun(runId)) {
-            return c.json({ error: "Run not found" }, 404);
-        }
-        return c.json(store.listNodeStates(runId));
-    });
-    app.get("/runs/:runId/ir", (c) => {
-        const runId = c.req.param("runId");
-        if (!store.hasRun(runId)) {
-            return c.json({ error: "Run not found" }, 404);
-        }
-        const ir = store.readIr(runId);
-        if (!ir) {
-            return c.json({ error: "IR not found" }, 404);
-        }
-        return c.json(ir);
-    });
-    app.get("/runs/:runId/input", (c) => {
-        const runId = c.req.param("runId");
-        if (!store.hasRun(runId)) {
-            return c.json({ error: "Run not found" }, 404);
-        }
-        const input = store.readInput(runId);
-        if (!input) {
-            return c.json({ error: "Input not found" }, 404);
-        }
-        return c.json({ input });
-    });
-    app.get("/runs/:runId/node", (c) => {
-        const runId = c.req.param("runId");
-        const nodeKey = c.req.query("key");
-        if (!nodeKey) {
-            return c.json({ error: "key query parameter is required" }, 400);
-        }
-        const state = store.readNodeState(runId, nodeKey);
-        if (!state) {
-            return c.json({ error: "Node not found" }, 404);
-        }
-        return c.json(state);
-    });
-    app.get("/runs/:runId/artifact-path", (c) => {
-        const runId = c.req.param("runId");
-        const uri = c.req.query("uri");
-        if (!uri) {
-            return c.json({ error: "uri query parameter is required" }, 400);
-        }
-        if (!store.hasRun(runId)) {
-            return c.json({ error: "Run not found" }, 404);
-        }
-        // Validate that the URI's runId matches the route's :runId to prevent
-        // cross-run artifact path resolution.
-        const parsed = ArtifactReferences.tryParse(uri);
-        if (parsed && parsed.runId !== runId) {
-            return c.json({ error: "Artifact URI runId does not match route runId" }, 400);
-        }
-        const absPath = store.resolveArtifactPath(uri);
-        if (!absPath) {
-            return c.json({ error: "Invalid artifact uri" }, 400);
-        }
-        return c.json({ absPath });
-    });
-    // ─── Control ────────────────────────────────────────────────────
-    app.post("/runs/:runId/pause", async (c) => {
-        const runId = c.req.param("runId");
-        // Run-level pause
-        const meta = store.readRunMeta(runId);
-        if (!meta)
-            return c.json({ error: "Run not found" }, 404);
-        if (meta.status !== "running")
-            return c.json({ error: `Cannot pause a run in state '${meta.status}'` }, 409);
-        const interpreter = interpreters.get(runId);
-        if (!interpreter)
-            return c.json({ error: "Run is not actively executing; pause requires an in-flight run" }, 409);
-        interpreter.pauseRun(runId);
-        const updated = store.readRunMeta(runId);
-        return c.json(updated);
-    });
-    app.post("/runs/:runId/resume", async (c) => {
-        const runId = c.req.param("runId");
-        // Run-level resume
-        if (resumingRunIds.has(runId)) {
-            return c.json({ error: "Run is already being resumed or retried" }, 409);
-        }
-        const meta = store.readRunMeta(runId);
-        if (!meta)
-            return c.json({ error: "Run not found" }, 404);
-        if (meta.status !== "paused")
-            return c.json({ error: `Cannot resume a run in state '${meta.status}'` }, 409);
-        // Wait for any in-flight runToCompletion to settle before resuming,
-        // preventing concurrent execution race on the same interpreter.
-        const inFlight = inFlightRuns.get(runId);
-        if (inFlight)
-            await inFlight;
-        resumingRunIds.add(runId);
-        try {
-            const interpreter = getOrRecoverInterpreter(runId);
-            if (!interpreter)
-                return c.json({ error: "Run not found" }, 404);
-            await interpreter.resumeRun(runId);
-            interpreters.set(runId, interpreter);
-            lastActiveAt = Date.now();
-            startPersistedRunExecution(interpreter, runId);
-            const updated = store.readRunMeta(runId);
-            return c.json(updated);
-        }
-        finally {
-            resumingRunIds.delete(runId);
-        }
-    });
-    app.post("/runs/:runId/cancel", async (c) => {
-        const runId = c.req.param("runId");
-        // Run-level cancel
-        const meta = store.readRunMeta(runId);
-        if (!meta)
-            return c.json({ error: "Run not found" }, 404);
-        if (meta.status !== "running" && meta.status !== "paused") {
-            return c.json({ error: `Cannot cancel a run in state '${meta.status}'` }, 409);
-        }
-        const interpreter = interpreters.get(runId) ?? getOrRecoverInterpreter(runId);
-        if (!interpreter)
-            return c.json({ error: "Run not found" }, 404);
-        interpreter.cancelRun(runId);
-        // Wait for in-flight runToCompletion to settle after cancel, so its catch
-        // block sees the "cancelled" abort intent and writes "cancelled" status
-        // instead of overwriting with "paused" from a prior pauseRun.
-        const inFlight = inFlightRuns.get(runId);
-        if (inFlight)
-            await inFlight;
-        pruneTerminalInterpreters();
-        const updated = store.readRunMeta(runId);
-        return c.json(updated);
-    });
-    app.post("/runs/:runId/retry", async (c) => {
-        const runId = c.req.param("runId");
-        const nodeKey = c.req.query("key");
-        if (nodeKey) {
-            const interpreter = getOrRecoverInterpreter(runId);
-            if (!interpreter)
-                return c.json({ error: "Run not found" }, 404);
-            const retry = interpreter.retryNode(runId, nodeKey);
-            const immediate = await settleImmediate(retry);
-            if (immediate.kind === "rejected") {
-                const err = immediate.error;
-                return c.json({ error: err instanceof Error ? err.message : String(err) }, 409);
-            }
-            if (immediate.kind === "pending")
-                consumeDetachedControl(retry);
-            lastActiveAt = Date.now();
-            const state = store.readNodeState(runId, nodeKey);
-            return c.json(state);
-        }
-        // Run-level retry
-        if (resumingRunIds.has(runId)) {
-            return c.json({ error: "Run is already being resumed or retried" }, 409);
-        }
-        const meta = store.readRunMeta(runId);
-        if (!meta)
-            return c.json({ error: "Run not found" }, 404);
-        if (meta.status !== "failed") {
-            return c.json({ error: `Cannot retry a run in state '${meta.status}'` }, 409);
-        }
-        const inFlight = inFlightRuns.get(runId);
-        if (inFlight)
-            await inFlight;
-        resumingRunIds.add(runId);
-        try {
-            const interpreter = getOrRecoverInterpreter(runId);
-            if (!interpreter)
-                return c.json({ error: "Run not found" }, 404);
-            interpreter.retryRun(runId);
-            interpreters.set(runId, interpreter);
-            lastActiveAt = Date.now();
-            startPersistedRunExecution(interpreter, runId);
-            const updated = store.readRunMeta(runId);
-            return c.json(updated);
-        }
-        finally {
-            resumingRunIds.delete(runId);
-        }
-    });
-    // ─── Fork ────────────────────────────────────────────────────────
-    //
-    // Derive a new Run from a terminal source Run by supplying a possibly-
-    // modified Workflow Spec. Inheritance is keyed by Node Definition Hash; the
-    // first divergence becomes the default Fork Origin. `dryRun: true` returns
-    // the plan without creating a Run.
-    app.post("/runs/:runId/fork", async (c) => {
-        const runId = c.req.param("runId");
-        const body = await c.req.json().catch(() => ({}));
-        const priorMeta = store.readRunMeta(runId);
-        if (!priorMeta)
-            return c.json({ error: "Run not found" }, 404);
-        if (!body.spec) {
-            return c.json({ error: "spec is required" }, 400);
-        }
-        let sourcePath;
-        if (body.sourcePath) {
-            try {
-                sourcePath = sourceResolver.validateSourcePath(body.sourcePath);
-            }
-            catch (error) {
-                return c.json({ error: errorMessage(error) }, 400);
-            }
-        }
-        let submitMetadata = emptyAgentOverrideResult();
-        let effectiveSource = body.spec;
-        try {
-            if (body.agentOverrides !== undefined || Object.keys(priorMeta.agentOverrides ?? {}).length > 0) {
-                const parsedSpec = parseWorkflowSpecForOverrides(body.spec);
-                submitMetadata = applyAgentOverrides(parsedSpec, body.agentOverrides, {
-                    inherited: priorMeta.agentOverrides ?? {}
-                });
-                effectiveSource = serializeWorkflowSpecForOverrides(submitMetadata.effectiveSpec);
-            }
-        }
-        catch (error) {
-            return c.json({ kind: "fork-rejected", error: errorMessage(error) }, 400);
-        }
-        const compileResult = compileWorkflow(effectiveSource, {
-            sourcePath,
-            includeResolver: sourceResolver.createIncludeResolver(sourcePath)
-        });
-        if (!compileResult.ok || !compileResult.ir) {
-            return c.json({ kind: "fork-rejected", error: "Compilation failed", diagnostics: compileResult.diagnostics }, 400);
-        }
-        let plan;
-        try {
-            plan = planForkedRun(store, {
-                sourceRunId: runId,
-                ir: compileResult.ir,
-                overrideOriginNodeKey: body.overrideOriginNodeKey
-            });
-        }
-        catch (error) {
-            if (error instanceof ForkError) {
-                return c.json({ kind: "fork-rejected", error: error.message }, 409);
-            }
-            throw error;
-        }
-        if (body.dryRun) {
-            return c.json({
-                dryRun: true,
-                plan,
-                agentOverrides: submitMetadata.agentOverrides,
-                submissionWarnings: submitMetadata.warnings
-            });
-        }
-        const forkRunId = generateRunId();
-        let materialized;
-        try {
-            materialized = materializeForkedRun(store, {
-                sourceRunId: runId,
-                forkRunId,
-                ir: compileResult.ir,
-                input: body.input,
-                workflowRef: body.workflowRef ?? priorMeta.workflowRef,
-                workflowSourcePath: sourcePath ?? priorMeta.workflowSourcePath,
-                plan,
-                ...optionalSubmissionMetadata(submitMetadata),
-                skipHooks: priorMeta.skipHooks
-            });
-        }
-        catch (error) {
-            if (error instanceof InputValidationFailure) {
-                return c.json({ error: "Input validation failed", validationErrors: error.errors }, 400);
-            }
-            throw error;
-        }
-        const interpreter = newInterpreter(forkRunId);
-        interpreters.set(forkRunId, interpreter);
-        lastActiveAt = Date.now();
-        startRunExecution(interpreter, compileResult.ir, materialized.input, forkRunId);
-        return c.json({ run: materialized.run, plan: materialized.plan }, 201);
-    });
-    // ─── Replay ──────────────────────────────────────────────────────
-    app.post("/runs/:runId/replay", (c) => {
-        const runId = c.req.param("runId");
-        const interpreter = getReadOnlyInterpreter(runId);
-        if (!interpreter)
-            return c.json({ error: "Run not found" }, 404);
-        const result = interpreter.replay(runId);
-        return c.json(result);
-    });
-    // ─── Signal ───────────────────────────────────────────────────────
-    //
-    // Deliver an external decision payload to a Signal Node that is currently
-    // `awaiting`. Node-addressed only (`?key=` required). The request body is the
-    // payload object directly. The resolver lives in the in-memory interpreter,
-    // so a live in-flight run is required (409 otherwise). A payload that fails
-    // the node's declared output schema is rejected with 422 and the node stays
-    // `awaiting`.
-    app.post("/runs/:runId/signal", async (c) => {
-        const runId = c.req.param("runId");
-        const nodeKey = c.req.query("key");
-        if (!nodeKey) {
-            return c.json({ error: "key query parameter is required (signals are node-level)" }, 400);
-        }
-        const payload = await c.req.json().catch(() => undefined);
-        if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
-            return c.json({ error: "Signal payload must be a JSON object" }, 400);
-        }
-        const interpreter = interpreters.get(runId);
-        if (!interpreter) {
-            return store.hasRun(runId)
-                ? c.json({ error: "Run is not actively executing; signal requires an in-flight run" }, 409)
-                : c.json({ error: "Run not found" }, 404);
-        }
-        try {
-            interpreter.submitSignal(runId, nodeKey, payload);
-        }
-        catch (err) {
-            // A non-conforming payload is a request-body problem (422); the node
-            // stays `awaiting`. A missing resolver ("not awaiting") is a state
-            // conflict (409).
-            if (err instanceof SignalPayloadValidationError) {
-                return c.json({ error: err.message }, 422);
-            }
-            return c.json({ error: err instanceof Error ? err.message : String(err) }, 409);
-        }
-        // submitSignal resolves the in-memory promise; the awaiting → completed
-        // write happens in the executeNode continuation on a later microtask. Wait
-        // briefly for the node to leave `awaiting` so we return the settled state.
-        let state = store.readNodeState(runId, nodeKey);
-        for (let i = 0; i < 100 && state?.state === "awaiting"; i++) {
-            await new Promise((r) => setTimeout(r, 5));
-            state = store.readNodeState(runId, nodeKey);
-        }
-        return c.json(state);
-    });
-    // ─── Output & Artifacts ──────────────────────────────────────────
-    app.get("/runs/:runId/output", (c) => {
-        const runId = c.req.param("runId");
-        const meta = store.readRunMeta(runId);
-        if (!meta)
-            return c.json({ error: "Run not found" }, 404);
-        const output = meta.status === "completed" ? (meta.output ?? {}) : {};
-        const body = { status: meta.status, output };
-        if (meta.status === "failed" && meta.error)
-            body.error = meta.error;
-        return c.json(body);
-    });
-    return {
-        app,
-        /** Expose for the runner to read idle-shutdown state. */
-        getLastActiveAt: () => getLastActiveAt(),
-        /** Expose for the runner to check how many Runs are still active. */
-        runningCount: () => runningCount(),
-        /** Expose for the runner to write the startedAt and endpoint after listen. */
-        setHealthOverrides: (overrides) => {
-            if (overrides.startedAt)
-                healthStartedAt = overrides.startedAt;
-            if (overrides.endpoint)
-                healthEndpoint = overrides.endpoint;
-        }
-    };
-}
-function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-//# sourceMappingURL=supervisor-app.js.map