@voyantjs/workflows-orchestrator-node 0.107.5 → 0.107.6

package/dist/node-selfhost-deps.js

@@ -0,0 +1,403 @@
+import { createServer } from "node:http";
+import { resolve as resolvePath } from "node:path";
+import { handleStepRequest } from "@voyantjs/workflows/handler";
+import { createInMemoryRateLimiter } from "@voyantjs/workflows/rate-limit";
+import { createInMemoryRunStore, resume, resumeDueAlarms, trigger, } from "@voyantjs/workflows-orchestrator";
+import { createChunkBus } from "./dashboard-chunks.js";
+import { startServer } from "./dashboard-http-server.js";
+import { renderMetrics } from "./dashboard-metrics.js";
+import { assertReadableDirectory, assertReadableFile, findDashboardDir, } from "./dashboard-static.js";
+import { loadEntryFile } from "./entry-loader.js";
+import { durationToMs, generateLocalRunId } from "./local-runtime.js";
+import { createDefaultWakeupLeaseOwner, localTenantMeta } from "./node-selfhost-defaults.js";
+import { mergeTags, requireExternalResumeFromStep, requireExternalSeedResults, } from "./node-selfhost-resume-input.js";
+import { nodeStepRunner } from "./node-step-runner.js";
+import { createPersistentWakeupManager } from "./persistent-wakeup-manager.js";
+import { createPostgresConnection } from "./postgres.js";
+import { createPostgresSnapshotRunStore } from "./postgres-snapshot-run-store.js";
+import { createPostgresWakeupStore } from "./postgres-wakeup-store.js";
+import { buildResumeJournal, buildSeededResumeJournal } from "./resume-run.js";
+import { recordToSnapshot, snapshotToRecord } from "./run-record-snapshot.js";
+import { createScheduler } from "./scheduler.js";
+import { createFsSnapshotRunStore } from "./snapshot-run-store.js";
+import { createFsWakeupStore } from "./wakeup-store.js";
+export async function startNodeSelfHostServer(opts) {
+    const deps = await createNodeSelfHostDeps(opts);
+    return startServer({
+        port: opts.port ?? 3232,
+        host: opts.host ?? "127.0.0.1",
+    }, deps);
+}
+export async function createNodeSelfHostDeps(opts) {
+    let staticDir = opts.staticDir;
+    if (!staticDir)
+        staticDir = await findDashboardDir(process.cwd());
+    if (!staticDir && typeof import.meta.url === "string") {
+        const here = resolvePath(new URL(".", import.meta.url).pathname);
+        staticDir = await findDashboardDir(here);
+    }
+    if (staticDir) {
+        await assertReadableDirectory(staticDir, "dashboard static dir");
+    }
+    const databaseUrl = opts.databaseUrl ?? process.env.DATABASE_URL;
+    const pg = databaseUrl ? createPostgresConnection({ databaseUrl }) : undefined;
+    const store = opts.store ?? (pg ? createPostgresSnapshotRunStore({ db: pg.db }) : createFsSnapshotRunStore());
+    const wfMod = await import("@voyantjs/workflows");
+    wfMod.__resetRegistry();
+    const entryAbs = resolvePath(process.cwd(), opts.entryFile);
+    await assertReadableFile(entryAbs, "workflow entry");
+    await loadEntryFile(entryAbs, { cacheBust: opts.cacheBustEntry });
+    const _handlerMod = await import("@voyantjs/workflows/handler");
+    const rateLimiter = createInMemoryRateLimiter();
+    const chunkBus = createChunkBus();
+    const stepHandler = async (req, stepOpts) => handleStepRequest(req, { rateLimiter, nodeStepRunner, services: opts.services }, stepOpts);
+    const wakeupStore = pg ? createPostgresWakeupStore({ db: pg.db }) : createFsWakeupStore();
+    const leaseOwner = opts.wakeupLeaseOwner ?? createDefaultWakeupLeaseOwner();
+    const listWorkflows = () => wfMod.__listRegisteredWorkflows().map((workflow) => ({
+        id: workflow.id,
+        description: workflow.config.description,
+    }));
+    const registeredWorkflows = listWorkflows();
+    if (registeredWorkflows.length === 0) {
+        throw new Error("voyant workflows selfhost: workflow entry registered no workflows. " +
+            `Check "${entryAbs}" and ensure it calls workflow(...).`);
+    }
+    const healthCheck = () => ({
+        ok: true,
+        service: "voyant-workflows-selfhost",
+    });
+    const readinessCheck = async () => {
+        const checks = {
+            workflowEntry: "ok",
+        };
+        const details = {};
+        if (pg) {
+            try {
+                await pg.pool.query("select 1");
+                checks.database = "ok";
+            }
+            catch (err) {
+                checks.database = "error";
+                details.database = err instanceof Error ? err.message : String(err);
+            }
+        }
+        return {
+            ok: Object.values(checks).every((status) => status === "ok"),
+            service: "voyant-workflows-selfhost",
+            checks,
+            details: Object.keys(details).length > 0 ? details : undefined,
+        };
+    };
+    const collectMetrics = async () => {
+        const runs = await store.list();
+        const wakeups = await wakeupStore.list();
+        const runsByStatus = runs.reduce((acc, run) => {
+            acc[run.status] = (acc[run.status] ?? 0) + 1;
+            return acc;
+        }, {});
+        return renderMetrics({
+            workflowsRegistered: listWorkflows().length,
+            schedulesRegistered: listSchedules ? listSchedules().length : 0,
+            runsTotal: runs.length,
+            wakeupsTotal: wakeups.length,
+            runsByStatus,
+            generatedAtMs: Date.now(),
+        });
+    };
+    const wakeupManager = createPersistentWakeupManager({
+        wakeupStore,
+        listRuns: () => store.list(),
+        getRun: (runId) => store.get(runId),
+        saveRun: async (stored) => {
+            if (!store.update) {
+                throw new Error("snapshot run store does not support update");
+            }
+            return store.update(stored);
+        },
+        toRecord: (stored) => snapshotToRecord(stored),
+        fromRecord: (record, base) => recordToSnapshot(record, base),
+        handler: stepHandler,
+        onStreamChunk: ({ runId, chunk }) => chunkBus.publish({ runId, chunk }),
+        logger: (level, message, data) => {
+            const error = typeof data === "object" && data !== null && "error" in data ? data.error : undefined;
+            const details = error ? `: ${String(error)}` : "";
+            if (level === "error")
+                console.error(`[voyant] ${message}${details}`);
+            else
+                console.warn(`[voyant] ${message}${details}`);
+        },
+        createRunStore: createInMemoryRunStore,
+        resumeDueAlarmsImpl: resumeDueAlarms,
+        leaseOwner,
+        intervalMs: opts.wakeupPollIntervalMs,
+        leaseMs: opts.wakeupLeaseMs,
+    });
+    const cancelRun = async ({ runId }) => {
+        const existing = await store.get(runId);
+        if (!existing)
+            return { ok: false, message: `run "${runId}" not found`, exitCode: 1 };
+        if (existing.status !== "waiting") {
+            return {
+                ok: false,
+                message: `run "${runId}" is not parked (status: ${existing.status})`,
+                exitCode: 2,
+            };
+        }
+        if (!store.update) {
+            return { ok: false, message: "snapshot run store does not support update", exitCode: 1 };
+        }
+        const now = Date.now();
+        const updated = {
+            ...existing,
+            status: "cancelled",
+            completedAt: now,
+            durationMs: now - existing.startedAt,
+            result: {
+                ...existing.result,
+                status: "cancelled",
+                cancelledAt: now,
+            },
+        };
+        const saved = await store.update(updated);
+        await wakeupManager.clear(runId);
+        return { ok: true, saved };
+    };
+    const triggerRun = async ({ workflowId, input, runId, tags, triggeredByUserId, }) => {
+        const workflow = wfMod.__listRegisteredWorkflows().find((entry) => entry.id === workflowId);
+        if (!workflow) {
+            return {
+                ok: false,
+                message: `workflow "${workflowId}" is not registered in ${entryAbs}.`,
+                exitCode: 2,
+            };
+        }
+        const nextRunId = runId ?? generateLocalRunId();
+        const memStore = createInMemoryRunStore();
+        let record;
+        try {
+            record = await trigger({
+                runId: nextRunId,
+                workflowId,
+                workflowVersion: "local",
+                input,
+                tenantMeta: localTenantMeta,
+                tags,
+                triggeredBy: triggeredByUserId === undefined || triggeredByUserId === null
+                    ? { kind: "api" }
+                    : { kind: "api", actor: triggeredByUserId },
+                timeoutMs: durationToMs(workflow.config.timeout),
+            }, {
+                store: memStore,
+                handler: stepHandler,
+                onStreamChunk: (chunk) => chunkBus.publish({ runId: nextRunId, chunk }),
+            });
+        }
+        catch (err) {
+            return {
+                ok: false,
+                message: err instanceof Error ? err.message : String(err),
+                exitCode: 1,
+            };
+        }
+        if (!store.update) {
+            return { ok: false, message: "snapshot run store does not support update", exitCode: 1 };
+        }
+        const stored = recordToSnapshot(record);
+        stored.entryFile = entryAbs;
+        const saved = await store.update(stored);
+        await wakeupManager.syncStoredRun(saved);
+        return { ok: true, saved };
+    };
+    const resumeRun = async ({ parentRunId, workflowId: requestedWorkflowId, input, resumeFromStep, seedResults, runId, tags, triggeredByUserId, }) => {
+        const existing = await store.get(parentRunId);
+        let parent;
+        if (existing) {
+            try {
+                parent = snapshotToRecord(existing);
+            }
+            catch (err) {
+                return {
+                    ok: false,
+                    message: err instanceof Error ? err.message : String(err),
+                    exitCode: 1,
+                };
+            }
+        }
+        else if (!requestedWorkflowId) {
+            return {
+                ok: false,
+                message: `parent run "${parentRunId}" not found; pass workflowId, resumeFromStep, ` +
+                    "and seedResults to resume from an external workflow-runs parent",
+                exitCode: 1,
+            };
+        }
+        const workflowId = parent?.workflowId ?? requestedWorkflowId;
+        const workflow = wfMod.__listRegisteredWorkflows().find((entry) => entry.id === workflowId);
+        if (!workflow) {
+            return {
+                ok: false,
+                message: `workflow "${workflowId}" is not registered in ${entryAbs}.`,
+                exitCode: 2,
+            };
+        }
+        let resumeSeed;
+        try {
+            resumeSeed = parent
+                ? buildResumeJournal({
+                    parent,
+                    resumeFromStep,
+                    seedResults,
+                })
+                : buildSeededResumeJournal({
+                    parentRunId,
+                    resumeFromStep: requireExternalResumeFromStep(resumeFromStep),
+                    seedResults: requireExternalSeedResults(seedResults),
+                });
+        }
+        catch (err) {
+            return {
+                ok: false,
+                message: err instanceof Error ? err.message : String(err),
+                exitCode: 2,
+            };
+        }
+        const memStore = createInMemoryRunStore();
+        const nextRunId = runId ?? generateLocalRunId();
+        let record;
+        try {
+            record = await trigger({
+                runId: nextRunId,
+                workflowId,
+                workflowVersion: parent?.workflowVersion ?? "local",
+                input: input === undefined ? parent?.input : input,
+                tenantMeta: parent?.tenantMeta ?? localTenantMeta,
+                environment: parent?.environment,
+                triggeredBy: triggeredByUserId === undefined || triggeredByUserId === null
+                    ? { kind: "api" }
+                    : { kind: "api", actor: triggeredByUserId },
+                tags: mergeTags(parent?.tags, [
+                    "resume:true",
+                    `parentRunId:${parent?.id ?? parentRunId}`,
+                    ...(tags ?? []),
+                ]),
+                timeoutMs: durationToMs(workflow.config.timeout),
+                initialJournal: resumeSeed.journal,
+                initialMetadataAppliedCount: resumeSeed.metadataAppliedCount,
+            }, {
+                store: memStore,
+                handler: stepHandler,
+                onStreamChunk: (chunk) => chunkBus.publish({ runId: nextRunId, chunk }),
+            });
+        }
+        catch (err) {
+            return {
+                ok: false,
+                message: err instanceof Error ? err.message : String(err),
+                exitCode: 1,
+            };
+        }
+        if (!store.update) {
+            return { ok: false, message: "snapshot run store does not support update", exitCode: 1 };
+        }
+        const stored = recordToSnapshot(record, {
+            entryFile: entryAbs,
+            replayOf: parent?.id ?? parentRunId,
+        });
+        const saved = await store.update(stored);
+        await wakeupManager.syncStoredRun(saved);
+        return {
+            ok: true,
+            saved,
+            parentRunId: parent?.id ?? parentRunId,
+            resumeFromStep: resumeSeed.resumeFromStep,
+        };
+    };
+    const injectWaitpoint = async ({ runId, injection }) => {
+        const existing = await store.get(runId);
+        if (!existing) {
+            return { ok: false, message: `run "${runId}" not found`, exitCode: 1 };
+        }
+        if (existing.status !== "waiting") {
+            return {
+                ok: false,
+                message: `run "${runId}" is not parked (status: ${existing.status})`,
+                exitCode: 2,
+            };
+        }
+        const record = snapshotToRecord(existing);
+        if (!record) {
+            return { ok: false, message: `run "${runId}" has no resumable snapshot`, exitCode: 1 };
+        }
+        const memStore = createInMemoryRunStore();
+        await memStore.save(record);
+        const out = await resume({ runId, injection }, {
+            store: memStore,
+            handler: stepHandler,
+            onStreamChunk: (chunk) => chunkBus.publish({ runId, chunk }),
+        });
+        if (!out.ok) {
+            const exitCode = out.status === "no_match" || out.status === "not_parked" ? 2 : 1;
+            return { ok: false, message: out.message, exitCode };
+        }
+        if (!store.update) {
+            return { ok: false, message: "snapshot run store does not support update", exitCode: 1 };
+        }
+        const saved = await store.update(recordToSnapshot(out.record, existing));
+        await wakeupManager.syncStoredRun(saved);
+        return { ok: true, saved };
+    };
+    try {
+        await wakeupManager.bootstrap();
+    }
+    catch (err) {
+        console.warn(`[voyant] failed to bootstrap wakeup leases from run store: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    wakeupManager.start();
+    let scheduler;
+    let listSchedules;
+    const sources = [];
+    for (const workflow of wfMod.__listRegisteredWorkflows()) {
+        const decl = workflow.config.schedule;
+        if (!decl)
+            continue;
+        const decls = Array.isArray(decl) ? decl : [decl];
+        for (const source of decls) {
+            sources.push({ workflowId: workflow.id, decl: source });
+        }
+    }
+    if (sources.length > 0) {
+        scheduler = createScheduler({
+            sources,
+            onFire: async ({ workflowId, input }) => {
+                await triggerRun({ workflowId, input });
+            },
+            logger: (level, message) => {
+                if (level === "error")
+                    console.error(`[scheduler] ${message}`);
+                else if (level === "warn")
+                    console.warn(`[scheduler] ${message}`);
+            },
+        });
+        listSchedules = () => scheduler.nextFirings();
+    }
+    return {
+        store,
+        createServer,
+        healthCheck,
+        readinessCheck,
+        collectMetrics,
+        shutdown: async () => {
+            wakeupManager.stop();
+            await pg?.close();
+        },
+        staticDir,
+        triggerRun,
+        resumeRun,
+        listWorkflows,
+        injectWaitpoint,
+        scheduler,
+        listSchedules,
+        cancelRun,
+        chunkBus,
+    };
+}

package/dist/node-selfhost-resume-input.d.ts

@@ -0,0 +1,4 @@
+export declare function mergeTags(...groups: ReadonlyArray<ReadonlyArray<string> | undefined>): string[];
+export declare function requireExternalResumeFromStep(resumeFromStep: string | undefined): string;
+export declare function requireExternalSeedResults(seedResults: Record<string, unknown> | undefined): Record<string, unknown>;
+//# sourceMappingURL=node-selfhost-resume-input.d.ts.map

package/dist/node-selfhost-resume-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-selfhost-resume-input.d.ts","sourceRoot":"","sources":["../src/node-selfhost-resume-input.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,GAAG,MAAM,EAAE,aAAa,CAAC,aAAa,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC,GAAG,MAAM,EAAE,CAM/F;AAED,wBAAgB,6BAA6B,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAOxF;AAED,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAC/C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAOzB"}

package/dist/node-selfhost-resume-input.js

@@ -0,0 +1,20 @@
+export function mergeTags(...groups) {
+    const tags = new Set();
+    for (const group of groups) {
+        for (const tag of group ?? [])
+            tags.add(tag);
+    }
+    return Array.from(tags);
+}
+export function requireExternalResumeFromStep(resumeFromStep) {
+    if (!resumeFromStep) {
+        throw new Error("resumeFromStep is required when the parent run is not stored by this self-host server");
+    }
+    return resumeFromStep;
+}
+export function requireExternalSeedResults(seedResults) {
+    if (!seedResults) {
+        throw new Error("seedResults is required when the parent run is not stored by this self-host server");
+    }
+    return seedResults;
+}

package/dist/node-standalone-driver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-standalone-driver.d.ts","sourceRoot":"","sources":["../src/node-standalone-driver.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EACV,aAAa,EAOd,MAAM,4BAA4B,CAAA;AAInC,OAAO,EAML,KAAK,SAAS,EAId,KAAK,WAAW,EAEjB,MAAM,kCAAkC,CAAA;AACzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAWxD,KAAK,EAAE,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,CAAA;AAIpC,MAAM,WAAW,2BAA2B;IAC1C,4EAA4E;IAC5E,EAAE,EAAE,EAAE,CAAA;IACN,wEAAwE;IACxE,kBAAkB,CAAC,EAAE,YAAY,GAAG,SAAS,GAAG,aAAa,CAAA;IAC7D,wDAAwD;IACxD,UAAU,CAAC,EAAE,SAAS,CAAC,YAAY,CAAC,CAAA;IACpC,gDAAgD;IAChD,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;IAClB;;;;OAIG;IACH,OAAO,CAAC,EAAE,WAAW,CAAA;IACrB;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAA;IAC/B;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,2DAA2D;IAC3D,sBAAsB,CAAC,EAAE,MAAM,CAAA;IAC/B,2EAA2E;IAC3E,qBAAqB,CAAC,EAAE,OAAO,CAAA;CAChC;AAUD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,2BAA2B,GAAG,aAAa,CAuX3F"}
+{"version":3,"file":"node-standalone-driver.d.ts","sourceRoot":"","sources":["../src/node-standalone-driver.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EACV,aAAa,EAOd,MAAM,4BAA4B,CAAA;AAInC,OAAO,EAML,KAAK,SAAS,EAId,KAAK,WAAW,EAEjB,MAAM,kCAAkC,CAAA;AACzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAWxD,KAAK,EAAE,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,CAAA;AAIpC,MAAM,WAAW,2BAA2B;IAC1C,4EAA4E;IAC5E,EAAE,EAAE,EAAE,CAAA;IACN,wEAAwE;IACxE,kBAAkB,CAAC,EAAE,YAAY,GAAG,SAAS,GAAG,aAAa,CAAA;IAC7D,wDAAwD;IACxD,UAAU,CAAC,EAAE,SAAS,CAAC,YAAY,CAAC,CAAA;IACpC,gDAAgD;IAChD,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;IAClB;;;;OAIG;IACH,OAAO,CAAC,EAAE,WAAW,CAAA;IACrB;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAA;IAC/B;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,2DAA2D;IAC3D,sBAAsB,CAAC,EAAE,MAAM,CAAA;IAC/B,2EAA2E;IAC3E,qBAAqB,CAAC,EAAE,OAAO,CAAA;CAChC;AAiED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,2BAA2B,GAAG,aAAa,CAuX3F"}

package/dist/node-standalone-driver.js

@@ -1,4 +1,5 @@
 // Mode 2 driver — pure Node, Postgres-backed.
+// agent-quality: file-size exception -- Public driver factory currently owns manifest, trigger, event-ingest, schedule, and admin wiring; split only with a dedicated driver-surface refactor.
 //
 // Returns a `DriverFactory` (per architecture doc §6.3) that the framework
 // invokes after `createApp()` has assembled its `ModuleContainer`. Composes:
@@ -30,6 +31,42 @@ const DEFAULT_TENANT_META = {
     organizationId: "default",
 };
 const DEFAULT_MANIFEST_KEEP = 3;
+function serializeWorkflowManifest(manifest) {
+    return { ...manifest };
+}
+function deserializeWorkflowManifest(manifest) {
+    const { schemaVersion, projectId, versionId, builtAt, builderVersion, capabilities, workflows, eventFilters, bindings, environments, } = manifest;
+    if (schemaVersion !== 1 ||
+        typeof projectId !== "string" ||
+        typeof versionId !== "string" ||
+        typeof builtAt !== "number" ||
+        typeof builderVersion !== "string" ||
+        !isStringArray(capabilities) ||
+        !Array.isArray(workflows) ||
+        !Array.isArray(eventFilters) ||
+        !isRecord(bindings) ||
+        !isRecord(environments)) {
+        throw new Error("stored workflow manifest has an invalid shape");
+    }
+    return {
+        schemaVersion,
+        projectId,
+        versionId,
+        builtAt,
+        builderVersion,
+        capabilities,
+        workflows: workflows,
+        eventFilters: eventFilters,
+        bindings: bindings,
+        environments: environments,
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
 /**
  * Build the Mode 2 driver factory. The factory closes over its options
  * and returns a fresh `WorkflowDriver` when `createApp()` (or a test)
@@ -114,7 +151,7 @@ export function createNodeStandaloneDriver(opts) {
             const result = await manifestStore.registerManifest({
                 environment: args.environment,
                 versionId: args.manifest.versionId,
-                manifest: args.manifest,
+                manifest: serializeWorkflowManifest(args.manifest),
             });
             // Best-effort prune; failures here shouldn't fail boot.
             try {
@@ -133,7 +170,7 @@ export function createNodeStandaloneDriver(opts) {
             const envelope = await manifestStore.getCurrent(args.environment);
             if (!envelope)
                 return null;
-            return envelope.manifest;
+            return deserializeWorkflowManifest(envelope.manifest);
         }
         async function trigger(workflow, input, triggerOpts) {
             assertNotShutdown(shuttingDown);
@@ -167,7 +204,7 @@ export function createNodeStandaloneDriver(opts) {
                 };
             }
             const eventId = await ensureEventId(args.envelope);
-            const manifest = stored.manifest;
+            const manifest = deserializeWorkflowManifest(stored.manifest);
             const routed = routeEvent({
                 manifest,
                 envelope: args.envelope,

package/dist/node-step-runner.d.ts

@@ -0,0 +1,3 @@
+import type { StepRunner } from "@voyantjs/workflows/handler";
+export declare const nodeStepRunner: StepRunner;
+//# sourceMappingURL=node-step-runner.d.ts.map

package/dist/node-step-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-step-runner.d.ts","sourceRoot":"","sources":["../src/node-step-runner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAE7D,eAAO,MAAM,cAAc,EAAE,UAyB5B,CAAA"}

package/dist/node-step-runner.js

@@ -0,0 +1,26 @@
+export const nodeStepRunner = async ({ attempt, fn, stepCtx }) => {
+    const startedAt = Date.now();
+    try {
+        const output = await fn(stepCtx);
+        return { attempt, status: "ok", output, startedAt, finishedAt: Date.now() };
+    }
+    catch (err) {
+        const error = err;
+        const code = typeof err.code === "string"
+            ? err.code
+            : "UNKNOWN";
+        return {
+            attempt,
+            status: "err",
+            error: {
+                category: "USER_ERROR",
+                code,
+                message: error?.message ?? String(err),
+                name: error?.name,
+                stack: error?.stack,
+            },
+            startedAt,
+            finishedAt: Date.now(),
+        };
+    }
+};

package/dist/postgres-manifest-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"postgres-manifest-store.d.ts","sourceRoot":"","sources":["../src/postgres-manifest-store.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAIxD,KAAK,UAAU,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,CAAA;AAE5C;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAClC;AAED,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,gBAAgB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAE5E,iEAAiE;IACjE,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAA;IAEjE,uEAAuE;IACvE,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CACjF;AAED,MAAM,WAAW,4BAA4B;IAC3C,EAAE,EAAE,UAAU,CAAA;CACf;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,4BAA4B,GAAG,aAAa,CA8F7F"}
+{"version":3,"file":"postgres-manifest-store.d.ts","sourceRoot":"","sources":["../src/postgres-manifest-store.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAIxD,KAAK,UAAU,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,CAAA;AAE5C;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAClC;AAED,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,gBAAgB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAE5E,iEAAiE;IACjE,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAA;IAEjE,uEAAuE;IACvE,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CACjF;AAED,MAAM,WAAW,4BAA4B;IAC3C,EAAE,EAAE,UAAU,CAAA;CACf;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,4BAA4B,GAAG,aAAa,CAgG7F"}

package/dist/postgres-manifest-store.js

@@ -73,9 +73,13 @@ export function createPostgresManifestStore(opts) {
             const keepIds = newest.map((r) => r.versionId);
             if (keepIds.length === 0)
                 return { deleted: 0 };
-            const result = await db.execute(sql `DELETE FROM ${workflowManifestsTable}
+            const result = await db.execute(
+            // agent-quality: raw-sql reviewed -- owner: workflows-orchestrator-node; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            sql `DELETE FROM ${workflowManifestsTable}
             WHERE environment = ${environment}
-            AND version_id NOT IN (${sql.join(keepIds.map((id) => sql `${id}`), sql `, `)})`);
+            AND version_id NOT IN (${sql.join(
+            // agent-quality: raw-sql reviewed -- owner: workflows-orchestrator-node; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            keepIds.map((id) => sql `${id}`), sql `, `)})`);
             return { deleted: result.rowCount ?? 0 };
         },
     };

package/dist/postgres-run-record-store.js

@@ -134,7 +134,7 @@ function recordToValues(record) {
             completedAt: record.completedAt,
         }),
         input: normalizeJson(record.input),
-        runRecord: normalizeRequiredJson(record),
+        runRecord: normalizeRequiredJson({ ...record }),
         entryFile: null,
         replayOf: null,
         idempotencyKey: record.idempotencyKey ?? null,

package/dist/postgres-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"postgres-schema.d.ts","sourceRoot":"","sources":["../src/postgres-schema.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0C7B,CAAA;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcxB,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAelC,CAAA"}
+{"version":3,"file":"postgres-schema.d.ts","sourceRoot":"","sources":["../src/postgres-schema.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2C7B,CAAA;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcxB,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBlC,CAAA"}

package/dist/postgres-schema.js

@@ -31,6 +31,7 @@ export const snapshotRunsTable = pgTable("voyant_snapshot_runs", {
      */
     idempotencyIdx: uniqueIndex("voyant_snapshot_runs_idempotency_idx")
         .on(table.workflowId, table.idempotencyKey)
+        // agent-quality: raw-sql reviewed -- owner: workflows-orchestrator-node; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
         .where(sql `${table.idempotencyKey} IS NOT NULL`),
 }));
 export const wakeupsTable = pgTable("voyant_wakeups", {
@@ -64,5 +65,6 @@ export const workflowManifestsTable = pgTable("voyant_workflow_manifests", {
     pk: primaryKey({ columns: [table.environment, table.versionId] }),
     currentIdx: uniqueIndex("voyant_workflow_manifests_current_idx")
         .on(table.environment)
+        // agent-quality: raw-sql reviewed -- owner: workflows-orchestrator-node; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
         .where(sql `${table.isCurrent}`),
 }));

package/dist/sleep-alarm-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sleep-alarm-manager.d.ts","sourceRoot":"","sources":["../src/sleep-alarm-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,KAAK,SAAS,EACd,eAAe,EACf,KAAK,WAAW,EAChB,KAAK,WAAW,EACjB,MAAM,kCAAkC,CAAA;AAEzC,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,qBAAqB,CAAC,OAAO,SAAS,mBAAmB;IACxE,QAAQ,EAAE,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC,CAAA;IAClC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAAA;IACvD,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAC9C,QAAQ,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,SAAS,CAAA;IACxC,UAAU,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC,EAAE,OAAO,KAAK,OAAO,CAAA;IAC1D,OAAO,EAAE,WAAW,CAAA;IACpB,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,WAAW,CAAA;KAAE,KAAK,IAAI,CAAA;IACtE,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,OAAO,UAAU,CAAA;IAC9B,YAAY,CAAC,EAAE,OAAO,YAAY,CAAA;IAClC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;IAC1E,cAAc,CAAC,EAAE,OAAO,sBAAsB,CAAA;IAC9C,mBAAmB,CAAC,EAAE,OAAO,eAAe,CAAA;CAC7C;AAED,MAAM,WAAW,iBAAiB,CAAC,OAAO,SAAS,mBAAmB;IACpE,QAAQ,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAA;IACnC,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAC9B,SAAS,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC9B,IAAI,EAAE,MAAM,IAAI,CAAA;CACjB;AAED,wBAAgB,uBAAuB,CAAC,OAAO,SAAS,mBAAmB,EACzE,IAAI,EAAE,qBAAqB,CAAC,OAAO,CAAC,GACnC,iBAAiB,CAAC,OAAO,CAAC,CAmF5B;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS,CASxE"}
+{"version":3,"file":"sleep-alarm-manager.d.ts","sourceRoot":"","sources":["../src/sleep-alarm-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,KAAK,SAAS,EACd,eAAe,EACf,KAAK,WAAW,EAChB,KAAK,WAAW,EACjB,MAAM,kCAAkC,CAAA;AAEzC,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,qBAAqB,CAAC,OAAO,SAAS,mBAAmB;IACxE,QAAQ,EAAE,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC,CAAA;IAClC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAAA;IACvD,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAC9C,QAAQ,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,SAAS,CAAA;IACxC,UAAU,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC,EAAE,OAAO,KAAK,OAAO,CAAA;IAC1D,OAAO,EAAE,WAAW,CAAA;IACpB,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,WAAW,CAAA;KAAE,KAAK,IAAI,CAAA;IACtE,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,OAAO,UAAU,CAAA;IAC9B,YAAY,CAAC,EAAE,OAAO,YAAY,CAAA;IAClC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;IAC1E,cAAc,CAAC,EAAE,OAAO,sBAAsB,CAAA;IAC9C,mBAAmB,CAAC,EAAE,OAAO,eAAe,CAAA;CAC7C;AAED,MAAM,WAAW,iBAAiB,CAAC,OAAO,SAAS,mBAAmB;IACpE,QAAQ,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAA;IACnC,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAC9B,SAAS,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC9B,IAAI,EAAE,MAAM,IAAI,CAAA;CACjB;AAaD,wBAAgB,uBAAuB,CAAC,OAAO,SAAS,mBAAmB,EACzE,IAAI,EAAE,qBAAqB,CAAC,OAAO,CAAC,GACnC,iBAAiB,CAAC,OAAO,CAAC,CAmF5B;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS,CASxE"}

package/dist/sleep-alarm-manager.js

@@ -1,4 +1,12 @@
 import { createInMemoryRunStore, resumeDueAlarms, } from "@voyantjs/workflows-orchestrator";
+function unrefTimer(timer) {
+    if (typeof timer === "object" &&
+        timer !== null &&
+        "unref" in timer &&
+        typeof timer.unref === "function") {
+        timer.unref();
+    }
+}
 export function createSleepAlarmManager(deps) {
     const now = deps.now ?? (() => Date.now());
     const setTimeoutImpl = deps.setTimeout ?? setTimeout;
@@ -59,7 +67,7 @@ export function createSleepAlarmManager(deps) {
                 });
             });
         }, delay);
-        timer.unref?.();
+        unrefTimer(timer);
         timers.set(stored.id, timer);
     };
     return {

package/dist/store-stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store-stream.d.ts","sourceRoot":"","sources":["../src/store-stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAE1E,MAAM,MAAM,UAAU,GAClB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,SAAS,SAAS,EAAE,CAAA;CAAE,GAChD;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,SAAS,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,GAAG,EAAE,SAAS,CAAA;CAAE,GACnC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAEtC,MAAM,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAA;AAEvD,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,CAAC,QAAQ,EAAE,aAAa,KAAK,MAAM,IAAI,CAAA;IAClD,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IACzB,IAAI,EAAE,MAAM,IAAI,CAAA;IAChB,eAAe,EAAE,MAAM,MAAM,CAAA;CAC9B;AAED,MAAM,WAAW,kBAAkB;IACjC,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,OAAO,WAAW,CAAA;IAChC,aAAa,CAAC,EAAE,OAAO,aAAa,CAAA;CACrC;AAED,wBAAgB,aAAa,CAC3B,IAAI,EAAE,SAAS,SAAS,EAAE,EAC1B,IAAI,EAAE,SAAS,SAAS,EAAE,GACzB,UAAU,EAAE,CAuBd;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,gBAAgB,EACvB,IAAI,GAAE,kBAAuB,GAC5B,WAAW,CA8Db"}
+{"version":3,"file":"store-stream.d.ts","sourceRoot":"","sources":["../src/store-stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAE1E,MAAM,MAAM,UAAU,GAClB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,SAAS,SAAS,EAAE,CAAA;CAAE,GAChD;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,SAAS,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,GAAG,EAAE,SAAS,CAAA;CAAE,GACnC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAEtC,MAAM,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAA;AAEvD,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,CAAC,QAAQ,EAAE,aAAa,KAAK,MAAM,IAAI,CAAA;IAClD,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IACzB,IAAI,EAAE,MAAM,IAAI,CAAA;IAChB,eAAe,EAAE,MAAM,MAAM,CAAA;CAC9B;AAED,MAAM,WAAW,kBAAkB;IACjC,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,OAAO,WAAW,CAAA;IAChC,aAAa,CAAC,EAAE,OAAO,aAAa,CAAA;CACrC;AAaD,wBAAgB,aAAa,CAC3B,IAAI,EAAE,SAAS,SAAS,EAAE,EAC1B,IAAI,EAAE,SAAS,SAAS,EAAE,GACzB,UAAU,EAAE,CAuBd;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,gBAAgB,EACvB,IAAI,GAAE,kBAAuB,GAC5B,WAAW,CA8Db"}