@voyantjs/workflows-orchestrator-node 0.107.5 → 0.107.7

package/dist/dashboard-chunks.d.ts

@@ -0,0 +1,17 @@
+export interface ChunkEvent {
+    runId: string;
+    chunk: {
+        streamId: string;
+        seq: number;
+        encoding: "text" | "json" | "base64";
+        chunk: unknown;
+        final: boolean;
+        at: number;
+    };
+}
+export interface ChunkBus {
+    publish(event: ChunkEvent): void;
+    subscribe(fn: (event: ChunkEvent) => void): () => void;
+}
+export declare function createChunkBus(): ChunkBus;
+//# sourceMappingURL=dashboard-chunks.d.ts.map

package/dist/dashboard-chunks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dashboard-chunks.d.ts","sourceRoot":"","sources":["../src/dashboard-chunks.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE;QACL,QAAQ,EAAE,MAAM,CAAA;QAChB,GAAG,EAAE,MAAM,CAAA;QACX,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAA;QACpC,KAAK,EAAE,OAAO,CAAA;QACd,KAAK,EAAE,OAAO,CAAA;QACd,EAAE,EAAE,MAAM,CAAA;KACX,CAAA;CACF;AAED,MAAM,WAAW,QAAQ;IACvB,OAAO,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAAA;IAChC,SAAS,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,GAAG,MAAM,IAAI,CAAA;CACvD;AAED,wBAAgB,cAAc,IAAI,QAAQ,CAiBzC"}

package/dist/dashboard-chunks.js

@@ -0,0 +1,19 @@
+export function createChunkBus() {
+    const subs = new Set();
+    return {
+        publish(event) {
+            for (const fn of subs) {
+                try {
+                    fn(event);
+                }
+                catch {
+                    // Ignore subscriber errors so streaming keeps going.
+                }
+            }
+        },
+        subscribe(fn) {
+            subs.add(fn);
+            return () => subs.delete(fn);
+        },
+    };
+}

package/dist/dashboard-http-server.d.ts

@@ -0,0 +1,6 @@
+import type { ServeDeps, ServeHandle } from "./dashboard-types.js";
+export declare function startServer(options: {
+    port: number;
+    host: string;
+}, deps: ServeDeps): Promise<ServeHandle>;
+//# sourceMappingURL=dashboard-http-server.d.ts.map

package/dist/dashboard-http-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dashboard-http-server.d.ts","sourceRoot":"","sources":["../src/dashboard-http-server.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AASlE,wBAAsB,WAAW,CAC/B,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EACvC,IAAI,EAAE,SAAS,GACd,OAAO,CAAC,WAAW,CAAC,CAiFtB"}

package/dist/dashboard-http-server.js

@@ -0,0 +1,99 @@
+import { handleRequest } from "./dashboard-request.js";
+import { handleRunSseStream, handleSseStream } from "./dashboard-sse.js";
+import { createStaticReader, urlPath } from "./dashboard-static.js";
+import { createStoreStream } from "./store-stream.js";
+function closeAllConnections(server) {
+    if ("closeAllConnections" in server && typeof server.closeAllConnections === "function") {
+        server.closeAllConnections();
+    }
+}
+export async function startServer(options, deps) {
+    const readStatic = deps.readStatic ?? (deps.staticDir ? createStaticReader(deps.staticDir) : undefined);
+    const hasStaticDashboard = Boolean(readStatic);
+    let storeStream;
+    const getStoreStream = () => {
+        if (!storeStream)
+            storeStream = createStoreStream(deps.store);
+        return storeStream;
+    };
+    const server = deps.createServer(async (req, res) => {
+        const method = (req.method ?? "GET").toUpperCase();
+        const url = req.url ?? "/";
+        if ((method === "GET" || method === "HEAD") && urlPath(url) === "/api/runs/stream") {
+            handleSseStream(res, getStoreStream(), deps.chunkBus);
+            return;
+        }
+        const perRunMatch = urlPath(url).match(/^\/api\/runs\/([^/]+)\/stream$/);
+        if ((method === "GET" || method === "HEAD") && perRunMatch) {
+            const runId = decodeURIComponent(perRunMatch[1]);
+            handleRunSseStream(res, runId, getStoreStream(), deps.chunkBus, deps.store);
+            return;
+        }
+        try {
+            const body = method === "POST" ? await readRequestBody(req) : undefined;
+            const response = await handleRequest({ method, url, body }, {
+                store: deps.store,
+                healthCheck: deps.healthCheck,
+                readinessCheck: deps.readinessCheck,
+                collectMetrics: deps.collectMetrics,
+                readStatic,
+                hasStaticDashboard,
+                triggerRun: deps.triggerRun,
+                resumeRun: deps.resumeRun,
+                listWorkflows: deps.listWorkflows,
+                injectWaitpoint: deps.injectWaitpoint,
+                listSchedules: deps.listSchedules,
+                cancelRun: deps.cancelRun,
+            });
+            res.writeHead(response.status, response.headers);
+            res.end(response.body);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            res.writeHead(500, { "content-type": "application/json" });
+            res.end(JSON.stringify({ error: "internal_error", message }));
+        }
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(options.port, options.host, () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    deps.scheduler?.start();
+    return {
+        url: `http://${options.host}:${options.port}`,
+        close: () => new Promise((resolve, reject) => {
+            deps.scheduler?.stop();
+            storeStream?.stop();
+            closeAllConnections(server);
+            server.close((err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                Promise.resolve(deps.shutdown?.()).then(() => resolve(), reject);
+            });
+        }),
+    };
+}
+async function readRequestBody(req) {
+    const maxBytes = 1_000_000;
+    return new Promise((resolve, reject) => {
+        let total = 0;
+        const chunks = [];
+        req.on("data", (chunk) => {
+            total += chunk.length;
+            if (total > maxBytes) {
+                req.destroy(new Error("request body exceeds 1MB"));
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on("end", () => {
+            resolve(Buffer.concat(chunks).toString("utf8"));
+        });
+        req.on("error", reject);
+    });
+}

package/dist/dashboard-metrics.d.ts

@@ -0,0 +1,3 @@
+import type { MetricsSnapshot } from "./dashboard-types.js";
+export declare function renderMetrics(snapshot: MetricsSnapshot): string;
+//# sourceMappingURL=dashboard-metrics.d.ts.map

package/dist/dashboard-metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dashboard-metrics.d.ts","sourceRoot":"","sources":["../src/dashboard-metrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAE3D,wBAAgB,aAAa,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,CAgC/D"}

package/dist/dashboard-metrics.js

@@ -0,0 +1,26 @@
+export function renderMetrics(snapshot) {
+    const lines = [
+        "# HELP voyant_selfhost_up Self-host server availability.",
+        "# TYPE voyant_selfhost_up gauge",
+        "voyant_selfhost_up 1",
+        "# HELP voyant_selfhost_workflows_registered Registered workflow count.",
+        "# TYPE voyant_selfhost_workflows_registered gauge",
+        `voyant_selfhost_workflows_registered ${snapshot.workflowsRegistered}`,
+        "# HELP voyant_selfhost_schedules_registered Registered schedule count.",
+        "# TYPE voyant_selfhost_schedules_registered gauge",
+        `voyant_selfhost_schedules_registered ${snapshot.schedulesRegistered}`,
+        "# HELP voyant_selfhost_runs_total Persisted run count.",
+        "# TYPE voyant_selfhost_runs_total gauge",
+        `voyant_selfhost_runs_total ${snapshot.runsTotal}`,
+        "# HELP voyant_selfhost_runs_status Run count by status.",
+        "# TYPE voyant_selfhost_runs_status gauge",
+    ];
+    for (const [status, count] of Object.entries(snapshot.runsByStatus).sort(([a], [b]) => a.localeCompare(b))) {
+        lines.push(`voyant_selfhost_runs_status{status="${escapeMetricLabelValue(status)}"} ${count}`);
+    }
+    lines.push("# HELP voyant_selfhost_wakeups_total Persisted wakeup count.", "# TYPE voyant_selfhost_wakeups_total gauge", `voyant_selfhost_wakeups_total ${snapshot.wakeupsTotal}`, "# HELP voyant_selfhost_metrics_generated_at_seconds Metrics generation timestamp.", "# TYPE voyant_selfhost_metrics_generated_at_seconds gauge", `voyant_selfhost_metrics_generated_at_seconds ${Math.floor(snapshot.generatedAtMs / 1000)}`, "");
+    return lines.join("\n");
+}
+function escapeMetricLabelValue(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+}

package/dist/dashboard-request.d.ts

@@ -0,0 +1,7 @@
+import type { HandlerResponse, RequestHandlerDeps } from "./dashboard-types.js";
+export declare function handleRequest(req: {
+    method: string;
+    url: string;
+    body?: string;
+}, deps: RequestHandlerDeps): Promise<HandlerResponse>;
+//# sourceMappingURL=dashboard-request.d.ts.map

package/dist/dashboard-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dashboard-request.d.ts","sourceRoot":"","sources":["../src/dashboard-request.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAgB,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAG7F,wBAAsB,aAAa,CACjC,GAAG,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,EACnD,IAAI,EAAE,kBAAkB,GACvB,OAAO,CAAC,eAAe,CAAC,CAiT1B"}

package/dist/dashboard-request.js

@@ -0,0 +1,436 @@
+import { URL } from "node:url";
+import { renderMetrics } from "./dashboard-metrics.js";
+import { mimeFor } from "./dashboard-static.js";
+export async function handleRequest(req, deps) {
+    const method = (req.method ?? "GET").toUpperCase();
+    const url = new URL(req.url, "http://local");
+    if (method === "OPTIONS") {
+        return {
+            status: 204,
+            headers: {
+                "access-control-allow-origin": "*",
+                "access-control-allow-methods": "GET, OPTIONS, POST",
+                "access-control-allow-headers": "content-type",
+            },
+            body: "",
+        };
+    }
+    if (method === "POST") {
+        const cancelMatch = url.pathname.match(/^\/api\/runs\/([^/]+)\/cancel$/);
+        if (cancelMatch) {
+            if (!deps.cancelRun) {
+                return json(501, {
+                    error: "cancel_not_supported",
+                    message: "This self-host server was started without a workflow entry. " +
+                        "Restart with `--file <path>` to enable cancellation.",
+                });
+            }
+            const runId = decodeURIComponent(cancelMatch[1]);
+            const result = await deps.cancelRun({ runId });
+            if (!result.ok) {
+                return json(result.exitCode === 2 ? 400 : 404, {
+                    error: "cancel_failed",
+                    message: result.message,
+                });
+            }
+            return json(200, { saved: result.saved });
+        }
+        const resumeMatch = url.pathname.match(/^\/api\/runs\/([^/]+)\/resume$/);
+        if (resumeMatch) {
+            if (!deps.resumeRun) {
+                return json(501, {
+                    error: "resume_not_supported",
+                    message: "This self-host server was started without a workflow entry. " +
+                        "Restart with `--file <path>` to enable failed-step resume.",
+                });
+            }
+            const parsed = parseResumeRequestBody(req.body);
+            if (!parsed.ok) {
+                return json(parsed.status, { error: parsed.error, message: parsed.message });
+            }
+            const parentRunId = decodeURIComponent(resumeMatch[1]);
+            const result = await deps.resumeRun({ parentRunId, ...parsed.body });
+            if (!result.ok) {
+                return json(result.exitCode === 2 ? 400 : 404, {
+                    error: "resume_failed",
+                    message: result.message,
+                });
+            }
+            return json(200, {
+                saved: result.saved,
+                parentRunId: result.parentRunId,
+                resumeFromStep: result.resumeFromStep,
+            });
+        }
+        const eventsMatch = url.pathname.match(/^\/api\/runs\/([^/]+)\/events$/);
+        const signalsMatch = url.pathname.match(/^\/api\/runs\/([^/]+)\/signals$/);
+        const tokenMatch = url.pathname.match(/^\/api\/runs\/([^/]+)\/tokens\/([^/]+)$/);
+        if (eventsMatch || signalsMatch || tokenMatch) {
+            if (!deps.injectWaitpoint) {
+                return json(501, {
+                    error: "inject_not_supported",
+                    message: "This self-host server was started without a workflow entry. " +
+                        "Restart with `--file <path>` to enable event / signal / token injection.",
+                });
+            }
+            let parsed;
+            try {
+                parsed = req.body ? JSON.parse(req.body) : {};
+            }
+            catch (err) {
+                return json(400, {
+                    error: "invalid_json",
+                    message: err instanceof Error ? err.message : String(err),
+                });
+            }
+            let injection;
+            if (eventsMatch) {
+                if (typeof parsed.eventType !== "string" || parsed.eventType.length === 0) {
+                    return json(400, { error: "invalid_body", message: "`eventType` (string) is required" });
+                }
+                injection = { kind: "EVENT", eventType: parsed.eventType, payload: parsed.payload };
+            }
+            else if (signalsMatch) {
+                if (typeof parsed.name !== "string" || parsed.name.length === 0) {
+                    return json(400, { error: "invalid_body", message: "`name` (string) is required" });
+                }
+                injection = { kind: "SIGNAL", name: parsed.name, payload: parsed.payload };
+            }
+            else {
+                injection = {
+                    kind: "MANUAL",
+                    tokenId: decodeURIComponent(tokenMatch[2]),
+                    payload: parsed.payload,
+                };
+            }
+            const runId = decodeURIComponent((eventsMatch?.[1] ?? signalsMatch?.[1] ?? tokenMatch?.[1]));
+            const result = await deps.injectWaitpoint({ runId, injection });
+            if (!result.ok) {
+                return json(result.exitCode === 2 ? 400 : 404, {
+                    error: "inject_failed",
+                    message: result.message,
+                });
+            }
+            return json(200, { saved: result.saved });
+        }
+        if (url.pathname === "/api/runs") {
+            if (!deps.triggerRun) {
+                return json(501, {
+                    error: "trigger_not_supported",
+                    message: "This self-host server was started without a workflow entry. " +
+                        "Restart with `--file <path>` to enable triggering.",
+                });
+            }
+            let parsed;
+            try {
+                parsed = req.body ? JSON.parse(req.body) : {};
+            }
+            catch (err) {
+                return json(400, {
+                    error: "invalid_json",
+                    message: err instanceof Error ? err.message : String(err),
+                });
+            }
+            if (typeof parsed.workflowId !== "string" || parsed.workflowId.length === 0) {
+                return json(400, {
+                    error: "invalid_body",
+                    message: "`workflowId` (string) is required",
+                });
+            }
+            if (parsed.runId !== undefined && typeof parsed.runId !== "string") {
+                return json(400, {
+                    error: "invalid_body",
+                    message: "`runId` must be a string when provided",
+                });
+            }
+            if (parsed.tags !== undefined && !isStringArray(parsed.tags)) {
+                return json(400, {
+                    error: "invalid_body",
+                    message: "`tags` must be an array of strings when provided",
+                });
+            }
+            if (parsed.triggeredByUserId !== undefined &&
+                parsed.triggeredByUserId !== null &&
+                typeof parsed.triggeredByUserId !== "string") {
+                return json(400, {
+                    error: "invalid_body",
+                    message: "`triggeredByUserId` must be a string or null when provided",
+                });
+            }
+            const result = await deps.triggerRun({
+                workflowId: parsed.workflowId,
+                input: parsed.input,
+                runId: parsed.runId,
+                tags: parsed.tags,
+                triggeredByUserId: parsed.triggeredByUserId,
+            });
+            if (!result.ok) {
+                return json(result.exitCode === 2 ? 400 : 404, {
+                    error: "trigger_failed",
+                    message: result.message,
+                });
+            }
+            return json(200, { saved: result.saved });
+        }
+        return json(404, { error: "route_not_found", path: url.pathname });
+    }
+    if (method !== "GET" && method !== "HEAD") {
+        return json(405, { error: "method_not_allowed", allowed: ["GET", "HEAD", "OPTIONS", "POST"] });
+    }
+    if (url.pathname === "/healthz") {
+        const report = await resolveHealthReport(deps.healthCheck, {
+            ok: true,
+            service: "voyant-workflows-selfhost",
+        });
+        return json(report.ok ? 200 : 503, report);
+    }
+    if (url.pathname === "/readyz") {
+        const report = await resolveHealthReport(deps.readinessCheck, {
+            ok: Boolean(deps.triggerRun),
+            service: "voyant-workflows-selfhost",
+            checks: {
+                workflowEntry: deps.triggerRun ? "ok" : "error",
+            },
+            details: deps.triggerRun
+                ? undefined
+                : {
+                    workflowEntry: "This self-host server was started without a workflow entry.",
+                },
+        });
+        return json(report.ok ? 200 : 503, report);
+    }
+    if (url.pathname === "/metrics") {
+        const body = await resolveMetricsBody(deps.collectMetrics);
+        return {
+            status: 200,
+            headers: {
+                "content-type": "text/plain; version=0.0.4; charset=utf-8",
+                "cache-control": "no-store",
+            },
+            body,
+        };
+    }
+    if (url.pathname === "/" || url.pathname === "") {
+        if (deps.hasStaticDashboard && deps.readStatic) {
+            const bytes = await deps.readStatic("index.html");
+            if (bytes) {
+                return {
+                    status: 200,
+                    headers: {
+                        "content-type": "text/html; charset=utf-8",
+                        "cache-control": "no-store",
+                    },
+                    body: bytes,
+                };
+            }
+        }
+        return json(200, {
+            service: "voyant workflows selfhost",
+            endpoints: ["/api/runs", "/api/runs/:id"],
+        });
+    }
+    if (deps.hasStaticDashboard && deps.readStatic && !url.pathname.startsWith("/api/")) {
+        const clean = url.pathname.replace(/^\/+/, "");
+        if (clean && !clean.includes("..")) {
+            const bytes = await deps.readStatic(clean);
+            if (bytes) {
+                return {
+                    status: 200,
+                    headers: {
+                        "content-type": mimeFor(clean),
+                        "cache-control": "no-store",
+                    },
+                    body: bytes,
+                };
+            }
+        }
+    }
+    if (url.pathname === "/api/workflows") {
+        const workflows = deps.listWorkflows ? deps.listWorkflows() : [];
+        return json(200, { workflows });
+    }
+    if (url.pathname === "/api/schedules") {
+        const schedules = deps.listSchedules ? deps.listSchedules() : [];
+        return json(200, { schedules });
+    }
+    if (url.pathname === "/api/runs") {
+        const filter = {};
+        const workflowId = url.searchParams.get("workflow") ?? url.searchParams.get("workflowId");
+        if (workflowId)
+            filter.workflowId = workflowId;
+        const status = url.searchParams.get("status");
+        if (status)
+            filter.status = status;
+        const limitRaw = url.searchParams.get("limit");
+        if (limitRaw !== null) {
+            const limit = Number.parseInt(limitRaw, 10);
+            if (Number.isNaN(limit) || limit < 0) {
+                return json(400, {
+                    error: "invalid_limit",
+                    message: `limit must be a non-negative integer (got "${limitRaw}")`,
+                });
+            }
+            filter.limit = limit;
+        }
+        const runs = await deps.store.list(filter);
+        return json(200, { runs });
+    }
+    const runMatch = url.pathname.match(/^\/api\/runs\/([^/]+)$/);
+    if (runMatch) {
+        const runId = decodeURIComponent(runMatch[1]);
+        const run = await deps.store.get(runId);
+        if (!run)
+            return json(404, { error: "not_found", runId });
+        return json(200, { run });
+    }
+    return json(404, { error: "route_not_found", path: url.pathname });
+}
+function parseResumeRequestBody(body) {
+    let parsed;
+    try {
+        parsed = body ? JSON.parse(body) : {};
+    }
+    catch (err) {
+        return {
+            ok: false,
+            status: 400,
+            error: "invalid_json",
+            message: err instanceof Error ? err.message : String(err),
+        };
+    }
+    if (!isPlainObject(parsed)) {
+        return {
+            ok: false,
+            status: 400,
+            error: "invalid_body",
+            message: "request body must be an object",
+        };
+    }
+    if (parsed.resumeFromStep !== undefined && typeof parsed.resumeFromStep !== "string") {
+        return {
+            ok: false,
+            status: 400,
+            error: "invalid_body",
+            message: "`resumeFromStep` must be a string when provided",
+        };
+    }
+    if (parsed.workflowId !== undefined && typeof parsed.workflowId !== "string") {
+        return {
+            ok: false,
+            status: 400,
+            error: "invalid_body",
+            message: "`workflowId` must be a string when provided",
+        };
+    }
+    if (parsed.runId !== undefined && typeof parsed.runId !== "string") {
+        return {
+            ok: false,
+            status: 400,
+            error: "invalid_body",
+            message: "`runId` must be a string when provided",
+        };
+    }
+    if (parsed.triggeredByUserId !== undefined &&
+        parsed.triggeredByUserId !== null &&
+        typeof parsed.triggeredByUserId !== "string") {
+        return {
+            ok: false,
+            status: 400,
+            error: "invalid_body",
+            message: "`triggeredByUserId` must be a string or null when provided",
+        };
+    }
+    if (parsed.tags !== undefined && !isStringArray(parsed.tags)) {
+        return {
+            ok: false,
+            status: 400,
+            error: "invalid_body",
+            message: "`tags` must be an array of strings when provided",
+        };
+    }
+    if (parsed.seedResults !== undefined && !isPlainObject(parsed.seedResults)) {
+        return {
+            ok: false,
+            status: 400,
+            error: "invalid_body",
+            message: "`seedResults` must be an object when provided",
+        };
+    }
+    return {
+        ok: true,
+        body: {
+            input: parsed.input,
+            workflowId: parsed.workflowId,
+            resumeFromStep: parsed.resumeFromStep,
+            seedResults: parsed.seedResults,
+            runId: parsed.runId,
+            tags: parsed.tags,
+            triggeredByUserId: parsed.triggeredByUserId,
+        },
+    };
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function json(status, body) {
+    return {
+        status,
+        headers: {
+            "content-type": "application/json; charset=utf-8",
+            "access-control-allow-origin": "*",
+            "cache-control": "no-store",
+        },
+        body: JSON.stringify(body, null, 2),
+    };
+}
+async function resolveHealthReport(check, fallback) {
+    if (!check)
+        return fallback;
+    try {
+        return await check();
+    }
+    catch (err) {
+        return {
+            ok: false,
+            service: fallback.service,
+            checks: {
+                ...(fallback.checks ?? {}),
+                self: "error",
+            },
+            details: {
+                ...(fallback.details ?? {}),
+                error: err instanceof Error ? err.message : String(err),
+            },
+        };
+    }
+}
+async function resolveMetricsBody(collectMetrics) {
+    if (!collectMetrics) {
+        return renderMetrics({
+            workflowsRegistered: 0,
+            schedulesRegistered: 0,
+            runsTotal: 0,
+            wakeupsTotal: 0,
+            runsByStatus: {},
+            generatedAtMs: Date.now(),
+        });
+    }
+    try {
+        return await collectMetrics();
+    }
+    catch (err) {
+        return [
+            "# HELP voyant_selfhost_metrics_error Metrics collection failure state.",
+            "# TYPE voyant_selfhost_metrics_error gauge",
+            "voyant_selfhost_metrics_error 1",
+            `# metrics_error ${escapeMetricLabelValue(err instanceof Error ? err.message : String(err))}`,
+            "",
+        ].join("\n");
+    }
+}
+function escapeMetricLabelValue(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+}