@voyantjs/workflows-orchestrator-node 0.28.1 → 0.29.0

package/dist/fs-run-record-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fs-run-record-store.d.ts","sourceRoot":"","sources":["../src/fs-run-record-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,qBAAqB,EACrB,SAAS,EACT,cAAc,EACf,MAAM,kCAAkC,CAAA;AAEzC,MAAM,WAAW,uBAAuB;IACtC,oFAAoF;IACpF,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,wBAAgB,sBAAsB,CAAC,IAAI,GAAE,uBAA4B,GAAG,cAAc,CA6BzF;AA+BD,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,SAAS,SAAS,EAAE,EAC1B,MAAM,GAAE;IACN,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,MAAM,CAAC,EAAE,qBAAqB,CAAA;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAA;CACV,GACL,SAAS,EAAE,CASb"}
+{"version":3,"file":"fs-run-record-store.d.ts","sourceRoot":"","sources":["../src/fs-run-record-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,qBAAqB,EACrB,SAAS,EACT,cAAc,EACf,MAAM,kCAAkC,CAAA;AAEzC,MAAM,WAAW,uBAAuB;IACtC,oFAAoF;IACpF,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,wBAAgB,sBAAsB,CAAC,IAAI,GAAE,uBAA4B,GAAG,cAAc,CAkDzF;AA+BD,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,SAAS,SAAS,EAAE,EAC1B,MAAM,GAAE;IACN,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,MAAM,CAAC,EAAE,qBAAqB,CAAA;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAA;CACV,GACL,SAAS,EAAE,CASb"}

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

@@ -11,6 +11,29 @@ export function createFsRunRecordStore(opts = {}) {
             await writeFile(join(rootDir, record.id, "run-record.json"), JSON.stringify(record, null, 2));
             return record;
         },
+        async tryInsert(record) {
+            // Single-process FS store: atomicity comes from `mkdir` without
+            // `recursive: true` — succeeds exactly once per path, EEXIST
+            // otherwise. The orchestrator only enters this branch for
+            // idempotency-derived runIds, so the directory's prior existence
+            // means another caller already created the run.
+            try {
+                await mkdir(rootDir, { recursive: true });
+                await mkdir(join(rootDir, record.id));
+            }
+            catch (err) {
+                const code = err.code;
+                if (code !== "EEXIST")
+                    throw err;
+                const existing = await readRunFile(join(rootDir, record.id, "run-record.json"));
+                if (existing)
+                    return { record: existing, created: false };
+                // Dir exists but no record file — partial-write race window;
+                // fall through and write our record.
+            }
+            await writeFile(join(rootDir, record.id, "run-record.json"), JSON.stringify(record, null, 2));
+            return { record, created: true };
+        },
         async list(filter = {}) {
             const entries = await safeReaddir(rootDir);
             const runs = [];

package/dist/index.d.ts

@@ -3,9 +3,12 @@ export { type EntryFile, type LoadEntryOptions, loadEntryFile, } from "./entry-l
 export { createFsRunRecordStore, type FsRunRecordStoreOptions, filterRunRecords, } from "./fs-run-record-store.js";
 export { durationToMs, generateLocalRunId, } from "./local-runtime.js";
 export { defaultMigrationsDir, loadPostgresMigrations, type PostgresMigration, type RunPostgresMigrationsOptions, runPostgresMigrations, } from "./migrate.js";
+export { createNodeStandaloneDriver, type NodeStandaloneDriverOptions, } from "./node-standalone-driver.js";
 export { createPersistentWakeupManager, type PersistentWakeupManager, type PersistentWakeupManagerDeps, } from "./persistent-wakeup-manager.js";
 export { type CreatePostgresConnectionOptions, createPostgresConnection, type PostgresConnection, } from "./postgres.js";
-export { snapshotRunsTable, wakeupsTable, } from "./postgres-schema.js";
+export { createPostgresManifestStore, type ManifestEnvelope, type ManifestStore, type PostgresManifestStoreOptions, } from "./postgres-manifest-store.js";
+export { createPostgresRunRecordStore, type PostgresRunRecordStoreOptions, } from "./postgres-run-record-store.js";
+export { snapshotRunsTable, wakeupsTable, workflowManifestsTable, } from "./postgres-schema.js";
 export { createPostgresSnapshotRunStore, type PostgresSnapshotRunStoreOptions, rowToStoredRun, storedRunToRow, } from "./postgres-snapshot-run-store.js";
 export { createPostgresWakeupStore, type PostgresWakeupStoreOptions, rowToWakeupRecord, wakeupToRow, } from "./postgres-wakeup-store.js";
 export { type BuildResumeJournalInput, type BuildResumeJournalResult, type BuildSeededResumeJournalInput, buildResumeJournal, buildSeededResumeJournal, } from "./resume-run.js";

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -3,9 +3,12 @@ export { loadEntryFile, } from "./entry-loader.js";
 export { createFsRunRecordStore, filterRunRecords, } from "./fs-run-record-store.js";
 export { durationToMs, generateLocalRunId, } from "./local-runtime.js";
 export { defaultMigrationsDir, loadPostgresMigrations, runPostgresMigrations, } from "./migrate.js";
+export { createNodeStandaloneDriver, } from "./node-standalone-driver.js";
 export { createPersistentWakeupManager, } from "./persistent-wakeup-manager.js";
 export { createPostgresConnection, } from "./postgres.js";
-export { snapshotRunsTable, wakeupsTable, } from "./postgres-schema.js";
+export { createPostgresManifestStore, } from "./postgres-manifest-store.js";
+export { createPostgresRunRecordStore, } from "./postgres-run-record-store.js";
+export { snapshotRunsTable, wakeupsTable, workflowManifestsTable, } from "./postgres-schema.js";
 export { createPostgresSnapshotRunStore, rowToStoredRun, storedRunToRow, } from "./postgres-snapshot-run-store.js";
 export { createPostgresWakeupStore, rowToWakeupRecord, wakeupToRow, } from "./postgres-wakeup-store.js";
 export { buildResumeJournal, buildSeededResumeJournal, } from "./resume-run.js";

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

@@ -0,0 +1,72 @@
+import type { DriverFactory } from "@voyantjs/workflows/driver";
+import { type RunRecord, type StepHandler } from "@voyantjs/workflows-orchestrator";
+import type { drizzle } from "drizzle-orm/node-postgres";
+type Db = ReturnType<typeof drizzle>;
+export interface NodeStandaloneDriverOptions {
+    /** Long-lived Postgres connection (drizzle-orm `node-postgres` adapter). */
+    db: Db;
+    /** Default environment for `trigger()` calls that don't specify one. */
+    defaultEnvironment?: "production" | "preview" | "development";
+    /** Tenant metadata stamped onto every triggered run. */
+    tenantMeta?: RunRecord["tenantMeta"];
+    /** Injectable clock; defaults to `Date.now`. */
+    now?: () => number;
+    /**
+     * Step handler override. Defaults to in-process `handleStepRequest`
+     * with the framework-supplied `services` container plumbed through
+     * (so step bodies can resolve via `ctx.services.resolve(...)`).
+     */
+    handler?: StepHandler;
+    /**
+     * Latest N manifest versions to retain per environment after each
+     * registerManifest. Defaults to 3 (per architecture doc §14.2). Set to
+     * a high number to disable pruning effectively.
+     */
+    manifestVersionsToKeep?: number;
+    /**
+     * Time-wheel poll interval, ms. The wakeup manager (architecture doc
+     * §7.2) polls `voyant_wakeups` for due alarms and resumes parked runs
+     * via the orchestrator. Defaults to 1_000 ms. Lower values reduce
+     * sleep-resume latency at the cost of DB load.
+     */
+    wakeupPollIntervalMs?: number;
+    /**
+     * Wakeup lease TTL, ms. A poll instance leases a due wakeup for this
+     * long; if the process dies mid-process, another instance picks the
+     * wakeup back up after the lease expires. Defaults to 4× the poll
+     * interval (or 5_000 ms, whichever is greater).
+     */
+    wakeupLeaseMs?: number;
+    /**
+     * Lease owner identifier. Used to disambiguate poller instances
+     * across processes. Defaults to a random per-driver token.
+     */
+    wakeupLeaseOwner?: string;
+    /**
+     * When `true`, the wakeup poller does NOT auto-start on construction.
+     * Callers must invoke the returned driver's lifecycle hooks
+     * themselves — useful for tests that want to control the poll
+     * cadence. Defaults to `false` (poller starts immediately).
+     */
+    disableTimeWheel?: boolean;
+}
+/**
+ * Build the Mode 2 driver factory. The factory closes over its options
+ * and returns a fresh `WorkflowDriver` when `createApp()` (or a test)
+ * calls it with `DriverFactoryDeps`.
+ *
+ * Usage:
+ *
+ *     createApp({
+ *       workflows: {
+ *         driver: createNodeStandaloneDriver({ db, defaultEnvironment: "production" }),
+ *       },
+ *     })
+ *
+ * Or in compliance tests:
+ *
+ *     const driver = createNodeStandaloneDriver({ db: testDb })(testFactoryDeps())
+ */
+export declare function createNodeStandaloneDriver(opts: NodeStandaloneDriverOptions): DriverFactory;
+export {};
+//# sourceMappingURL=node-standalone-driver.d.ts.map

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

@@ -0,0 +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,EAGL,KAAK,SAAS,EAEd,KAAK,WAAW,EACjB,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;CAC3B;AAUD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,2BAA2B,GAAG,aAAa,CA6R3F"}

package/dist/node-standalone-driver.js

@@ -0,0 +1,357 @@
+// Mode 2 driver — pure Node, Postgres-backed.
+//
+// Returns a `DriverFactory` (per architecture doc §6.3) that the framework
+// invokes after `createApp()` has assembled its `ModuleContainer`. Composes:
+//
+//   * `createPostgresRunRecordStore` — primary state, against
+//      `voyant_snapshot_runs.run_record` JSONB.
+//   * `createPostgresManifestStore`   — manifest history, against
+//      `voyant_workflow_manifests`.
+//   * In-process step handler glued to `handleStepRequest` from
+//      `@voyantjs/workflows/handler` — the workflow body executes in the
+//      same Node process as the driver.
+//
+// The Postgres time wheel (`createPersistentWakeupManager`) is started via
+// the returned driver's `start()` lifecycle helper or — when used from
+// `createApp()` — by the framework's bootstrap.
+//
+// See architecture doc §7 for the full Mode 2 design.
+import { deriveStableEventId } from "@voyantjs/workflows/events";
+import { handleStepRequest } from "@voyantjs/workflows/handler";
+import { cancel as orchestratorCancel, trigger as orchestratorTrigger, routeEvent, } from "@voyantjs/workflows-orchestrator";
+import { createPersistentWakeupManager, } from "./persistent-wakeup-manager.js";
+import { createPostgresManifestStore } from "./postgres-manifest-store.js";
+import { createPostgresRunRecordStore } from "./postgres-run-record-store.js";
+import { createPostgresWakeupStore } from "./postgres-wakeup-store.js";
+import { syncWakeupFromRecord } from "./wakeup-store.js";
+const DEFAULT_TENANT_META = {
+    tenantId: "default",
+    projectId: "default",
+    organizationId: "default",
+};
+const DEFAULT_MANIFEST_KEEP = 3;
+/**
+ * Build the Mode 2 driver factory. The factory closes over its options
+ * and returns a fresh `WorkflowDriver` when `createApp()` (or a test)
+ * calls it with `DriverFactoryDeps`.
+ *
+ * Usage:
+ *
+ *     createApp({
+ *       workflows: {
+ *         driver: createNodeStandaloneDriver({ db, defaultEnvironment: "production" }),
+ *       },
+ *     })
+ *
+ * Or in compliance tests:
+ *
+ *     const driver = createNodeStandaloneDriver({ db: testDb })(testFactoryDeps())
+ */
+export function createNodeStandaloneDriver(opts) {
+    return (deps) => {
+        const runStore = createPostgresRunRecordStore({ db: opts.db });
+        const manifestStore = createPostgresManifestStore({ db: opts.db });
+        const wakeupStore = createPostgresWakeupStore({ db: opts.db });
+        const now = opts.now ?? deps.now ?? (() => Date.now());
+        const tenantMeta = opts.tenantMeta ?? DEFAULT_TENANT_META;
+        const defaultEnv = opts.defaultEnvironment ?? "development";
+        const keep = opts.manifestVersionsToKeep ?? DEFAULT_MANIFEST_KEEP;
+        const leaseOwner = opts.wakeupLeaseOwner ?? `node-standalone-${randomToken()}`;
+        // Wire the framework-supplied service container through to step bodies.
+        // The handler closes over `deps.services` so every step invocation
+        // surfaces it as `ctx.services` inside the workflow body.
+        const handler = opts.handler ??
+            (async (req, stepOpts) => handleStepRequest(req, { services: deps.services }, stepOpts));
+        // Persistent wakeup manager — polls `voyant_wakeups` for runs
+        // parked on DATETIME waitpoints and resumes them via the orchestrator's
+        // `resumeDueAlarms`. This is what makes `ctx.sleep(...)` actually
+        // wake up in Mode 2 (architecture doc §7.2).
+        const wakeupManager = createPersistentWakeupManager({
+            wakeupStore,
+            handler,
+            leaseOwner,
+            leaseMs: opts.wakeupLeaseMs,
+            intervalMs: opts.wakeupPollIntervalMs,
+            now,
+            logger: (level, message, data) => deps.logger(level, message, data),
+            // For Mode 2 the "stored" representation IS the RunRecord — the
+            // postgres-run-record-store carries the full state on `run_record`
+            // JSONB. So toRecord/fromRecord are identity.
+            async getRun(runId) {
+                return runStore.get(runId);
+            },
+            async saveRun(record) {
+                await runStore.save(record);
+                return record;
+            },
+            toRecord: (record) => record,
+            fromRecord: (record) => record,
+            async listRuns() {
+                // Bootstrap-time list of currently-parked runs to seed the wakeup
+                // store. Mode 2 uses status="waiting" filter on the run-record store.
+                return runStore.list({ status: "waiting" });
+            },
+        });
+        if (!opts.disableTimeWheel) {
+            // Auto-start the poller. Callers can opt out via `disableTimeWheel`
+            // for tests that want to control the cadence manually (poll explicitly
+            // via `manager.poll()`).
+            wakeupManager.start();
+        }
+        let shuttingDown = false;
+        // ---- WorkflowDriver implementation ----
+        async function registerManifest(args) {
+            assertNotShutdown(shuttingDown);
+            const result = await manifestStore.registerManifest({
+                environment: args.environment,
+                versionId: args.manifest.versionId,
+                manifest: args.manifest,
+            });
+            // Best-effort prune; failures here shouldn't fail boot.
+            try {
+                await manifestStore.pruneToVersions(args.environment, keep);
+            }
+            catch (err) {
+                deps.logger("warn", "manifest prune failed (non-fatal)", {
+                    environment: args.environment,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+            return result;
+        }
+        async function getManifest(args) {
+            const envelope = await manifestStore.getCurrent(args.environment);
+            if (!envelope)
+                return null;
+            return envelope.manifest;
+        }
+        async function trigger(workflow, input, triggerOpts) {
+            assertNotShutdown(shuttingDown);
+            const workflowId = typeof workflow === "string" ? workflow : workflow.id;
+            const env = triggerOpts?.environment ?? defaultEnv;
+            const record = await orchestratorTrigger({
+                workflowId,
+                workflowVersion: triggerOpts?.lockToVersion ?? "v1",
+                input: input,
+                tenantMeta,
+                environment: env,
+                tags: triggerOpts?.tags,
+                idempotencyKey: triggerOpts?.idempotencyKey,
+            }, { store: runStore, handler, now });
+            // Sync wakeup row so the time-wheel can resume DATETIME-parked runs.
+            // No-op if the run completed inline (status !== "waiting").
+            await syncWakeupFromRecord(wakeupStore, record);
+            return runRecordToRun(record);
+        }
+        async function ingestEvent(args) {
+            assertNotShutdown(shuttingDown);
+            const stored = await manifestStore.getCurrent(args.environment);
+            if (!stored) {
+                return {
+                    ok: false,
+                    reason: "manifest_not_registered",
+                    message: `No manifest is registered for environment "${args.environment}".`,
+                };
+            }
+            const eventId = await ensureEventId(args.envelope);
+            const manifest = stored.manifest;
+            const routed = routeEvent({
+                manifest,
+                envelope: args.envelope,
+                eventId,
+                idempotencyOverride: args.idempotencyKey,
+            });
+            const matches = [];
+            let anyTriggered = false;
+            let anyFailed = false;
+            for (const entry of routed) {
+                if (entry.status === "skipped") {
+                    matches.push({
+                        filterId: entry.filterId,
+                        status: "skipped",
+                        reason: entry.reason,
+                        details: entry.details,
+                    });
+                    continue;
+                }
+                try {
+                    const record = await orchestratorTrigger({
+                        workflowId: entry.targetWorkflowId,
+                        workflowVersion: "v1",
+                        input: entry.input,
+                        tenantMeta,
+                        environment: args.environment,
+                        idempotencyKey: entry.idempotencyKey,
+                        triggeredBy: {
+                            kind: "event",
+                            eventId,
+                            eventType: args.envelope.name,
+                            filterId: entry.filterId,
+                        },
+                    }, { store: runStore, handler, now });
+                    await syncWakeupFromRecord(wakeupStore, record);
+                    matches.push({
+                        filterId: entry.filterId,
+                        targetWorkflowId: entry.targetWorkflowId,
+                        runId: record.id,
+                        idempotencyKey: entry.idempotencyKey,
+                        status: "queued",
+                    });
+                    anyTriggered = true;
+                }
+                catch (err) {
+                    matches.push({
+                        filterId: entry.filterId,
+                        targetWorkflowId: entry.targetWorkflowId,
+                        status: "error",
+                        reason: err instanceof Error ? err.message : String(err),
+                    });
+                    anyFailed = true;
+                }
+            }
+            if (matches.length > 0 && !anyTriggered && anyFailed) {
+                return {
+                    ok: false,
+                    reason: "trigger_failed_for_all_matches",
+                    message: "every matched filter failed to trigger",
+                };
+            }
+            return { ok: true, eventId, matches };
+        }
+        async function shutdown() {
+            shuttingDown = true;
+            // Stop the time-wheel poller so the process can exit cleanly.
+            // Idempotent — calling stop() on an already-stopped manager is a
+            // no-op.
+            wakeupManager.stop();
+        }
+        // ---- WorkflowAdmin (full; Mode 2 has Postgres-native query support) ----
+        const admin = {
+            async listRuns(listOpts) {
+                const filterStatus = normalizeStatusFilter(listOpts?.status);
+                const filterEnv = listOpts?.environment;
+                const filterWorkflow = listOpts?.workflowId;
+                const filterTag = listOpts?.tag;
+                const filterSince = toEpoch(listOpts?.since);
+                const filterUntil = toEpoch(listOpts?.until);
+                const limit = listOpts?.limit ?? 100;
+                // Take a generous fetch window; in-memory filter for fields the
+                // store doesn't index (env, tag, since/until). For real load we'd
+                // push these down into the query — out of scope for PR1 step 6.
+                const records = await runStore.list({
+                    workflowId: filterWorkflow,
+                    status: filterStatus?.[0],
+                    limit: limit * 2,
+                });
+                const results = [];
+                for (const rec of records) {
+                    if (filterStatus && !filterStatus.includes(rec.status))
+                        continue;
+                    if (filterEnv && rec.environment !== filterEnv)
+                        continue;
+                    if (filterTag && !rec.tags.includes(filterTag))
+                        continue;
+                    if (filterSince !== undefined && rec.startedAt < filterSince)
+                        continue;
+                    if (filterUntil !== undefined && rec.startedAt > filterUntil)
+                        continue;
+                    results.push(runRecordToSummary(rec));
+                }
+                const page = results.slice(0, limit);
+                const nextCursor = results.length > limit ? String(limit) : undefined;
+                return { runs: page, nextCursor };
+            },
+            async getRun(runId) {
+                const rec = await runStore.get(runId);
+                return rec ? runRecordToDetail(rec) : null;
+            },
+            async cancelRun(runId, cancelOpts) {
+                // The orchestrator core's cancel() does NOT run compensations by
+                // default (architecture doc §21.21). The `compensate` flag is
+                // accepted but no-ops in v1.
+                void cancelOpts?.compensate;
+                await orchestratorCancel({ runId, reason: cancelOpts?.reason }, { store: runStore, handler, now });
+            },
+            streamRun(runId) {
+                // Live journal-event streaming is a follow-up — needs LISTEN/NOTIFY
+                // wired against the run store or a polling source. PR1 ships
+                // listRuns + getRun; streamRun returns an immediately-exhausted
+                // iterable so dashboards probing it get a clean empty stream
+                // instead of an undefined.
+                void runId;
+                return {
+                    [Symbol.asyncIterator]() {
+                        return {
+                            next: async () => ({ value: undefined, done: true }),
+                        };
+                    },
+                };
+            },
+        };
+        return {
+            registerManifest,
+            trigger,
+            ingestEvent,
+            getManifest,
+            shutdown,
+            admin,
+        };
+    };
+}
+// ---- Helpers ----
+function assertNotShutdown(shuttingDown) {
+    if (shuttingDown) {
+        throw new Error("NodeStandaloneDriver: shutdown() has been called; new operations are refused.");
+    }
+}
+function randomToken() {
+    return Math.floor(Math.random() * 1_000_000_000)
+        .toString(36)
+        .padStart(6, "0");
+}
+async function ensureEventId(envelope) {
+    if (envelope.metadata?.eventId)
+        return envelope.metadata.eventId;
+    // Content-derived fallback per architecture doc §15.2 — closes the
+    // dedup hole reviewer P2.2 flagged.
+    return deriveStableEventId(envelope);
+}
+function runRecordToRun(rec) {
+    return {
+        id: rec.id,
+        workflowId: rec.workflowId,
+        status: rec.status,
+        startedAt: rec.startedAt,
+    };
+}
+function runRecordToSummary(rec) {
+    return {
+        id: rec.id,
+        workflowId: rec.workflowId,
+        status: rec.status,
+        startedAt: rec.startedAt,
+        completedAt: rec.completedAt,
+        tags: [...rec.tags],
+        environment: rec.environment,
+    };
+}
+function runRecordToDetail(rec) {
+    return {
+        ...runRecordToSummary(rec),
+        version: rec.workflowVersion,
+        input: rec.input,
+        output: rec.output,
+        error: rec.error,
+        durationMs: rec.completedAt !== undefined ? Math.max(0, rec.completedAt - rec.startedAt) : undefined,
+    };
+}
+function normalizeStatusFilter(s) {
+    if (s === undefined)
+        return undefined;
+    return Array.isArray(s) ? s : [s];
+}
+function toEpoch(v) {
+    if (v === undefined)
+        return undefined;
+    return typeof v === "number" ? v : v.getTime();
+}

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

@@ -0,0 +1,35 @@
+import type { drizzle } from "drizzle-orm/node-postgres";
+type ManifestDb = ReturnType<typeof drizzle>;
+/**
+ * Structural view of `WorkflowManifest` (from `@voyantjs/workflows/protocol`).
+ * Declared locally to avoid pulling the workflows package's protocol export
+ * into this store — every consumer satisfies the shape via TypeScript
+ * structural compat, same pattern Voyant uses elsewhere.
+ */
+export interface ManifestEnvelope {
+    environment: string;
+    versionId: string;
+    manifest: Record<string, unknown>;
+}
+export interface ManifestStore {
+    /**
+     * Idempotent. Same `(environment, versionId)` returns without re-write.
+     * New `versionId` for an existing environment marks the new row
+     * `is_current = true` and the previous current `is_current = false`.
+     */
+    registerManifest(envelope: ManifestEnvelope): Promise<{
+        versionId: string;
+    }>;
+    /** Returns the current manifest for the environment, or null. */
+    getCurrent(environment: string): Promise<ManifestEnvelope | null>;
+    /** Retain the latest `keep` versions per environment; delete older. */
+    pruneToVersions(environment: string, keep: number): Promise<{
+        deleted: number;
+    }>;
+}
+export interface PostgresManifestStoreOptions {
+    db: ManifestDb;
+}
+export declare function createPostgresManifestStore(opts: PostgresManifestStoreOptions): ManifestStore;
+export {};
+//# sourceMappingURL=postgres-manifest-store.d.ts.map

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

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

package/dist/postgres-manifest-store.js

@@ -0,0 +1,82 @@
+// Postgres-backed manifest store. Holds the serialized WorkflowManifest
+// pushed at `createApp()` boot via `driver.registerManifest(...)` and read
+// by `driver.getManifest(...)` for boot-time mismatch detection and the
+// dashboard's filter inspector.
+//
+// One row is "current" per environment, enforced by the partial unique
+// index `voyant_workflow_manifests_current_idx` (migration 0004). History
+// is retained — `pruneToVersions(n)` keeps the latest N per environment.
+//
+// See architecture doc §14 for the manifest lifecycle.
+import { and, desc, eq, ne, sql } from "drizzle-orm";
+import { workflowManifestsTable } from "./postgres-schema.js";
+export function createPostgresManifestStore(opts) {
+    const db = opts.db;
+    return {
+        async registerManifest(envelope) {
+            // Atomically: insert new row, flip is_current to false on every other
+            // row for this environment, mark this row is_current = true. Single
+            // transaction so concurrent registrations don't leave two rows current.
+            await db.transaction(async (tx) => {
+                await tx
+                    .insert(workflowManifestsTable)
+                    .values({
+                    environment: envelope.environment,
+                    versionId: envelope.versionId,
+                    manifest: envelope.manifest,
+                    isCurrent: true,
+                })
+                    .onConflictDoNothing({
+                    target: [workflowManifestsTable.environment, workflowManifestsTable.versionId],
+                });
+                // Demote any existing current row that isn't this versionId.
+                await tx
+                    .update(workflowManifestsTable)
+                    .set({ isCurrent: false })
+                    .where(and(eq(workflowManifestsTable.environment, envelope.environment), eq(workflowManifestsTable.isCurrent, true), ne(workflowManifestsTable.versionId, envelope.versionId)));
+                // Promote the just-registered row in case it already existed
+                // (re-register of the same versionId).
+                await tx
+                    .update(workflowManifestsTable)
+                    .set({ isCurrent: true })
+                    .where(and(eq(workflowManifestsTable.environment, envelope.environment), eq(workflowManifestsTable.versionId, envelope.versionId)));
+            });
+            return { versionId: envelope.versionId };
+        },
+        async getCurrent(environment) {
+            const rows = await db
+                .select()
+                .from(workflowManifestsTable)
+                .where(and(eq(workflowManifestsTable.environment, environment), eq(workflowManifestsTable.isCurrent, true)))
+                .limit(1);
+            const row = rows[0];
+            if (!row)
+                return null;
+            return {
+                environment: row.environment,
+                versionId: row.versionId,
+                manifest: row.manifest,
+            };
+        },
+        async pruneToVersions(environment, keep) {
+            if (keep < 1) {
+                throw new Error(`pruneToVersions: keep must be >= 1, got ${keep}`);
+            }
+            // Get the IDs of the latest `keep` rows for this environment, then
+            // delete everything else.
+            const newest = await db
+                .select({ versionId: workflowManifestsTable.versionId })
+                .from(workflowManifestsTable)
+                .where(eq(workflowManifestsTable.environment, environment))
+                .orderBy(desc(workflowManifestsTable.registeredAt))
+                .limit(keep);
+            const keepIds = newest.map((r) => r.versionId);
+            if (keepIds.length === 0)
+                return { deleted: 0 };
+            const result = await db.execute(sql `DELETE FROM ${workflowManifestsTable}
+            WHERE environment = ${environment}
+            AND version_id NOT IN (${sql.join(keepIds.map((id) => sql `${id}`), sql `, `)})`);
+            return { deleted: result.rowCount ?? 0 };
+        },
+    };
+}

package/dist/postgres-run-record-store.d.ts

@@ -0,0 +1,9 @@
+import type { OrchestratorRunStatus, RunRecordStore } from "@voyantjs/workflows-orchestrator";
+import type { drizzle } from "drizzle-orm/node-postgres";
+type SnapshotDb = ReturnType<typeof drizzle>;
+export interface PostgresRunRecordStoreOptions {
+    db: SnapshotDb;
+}
+export declare function createPostgresRunRecordStore(opts: PostgresRunRecordStoreOptions): RunRecordStore;
+export type { OrchestratorRunStatus };
+//# sourceMappingURL=postgres-run-record-store.d.ts.map

package/dist/postgres-run-record-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-run-record-store.d.ts","sourceRoot":"","sources":["../src/postgres-run-record-store.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EACV,qBAAqB,EAErB,cAAc,EACf,MAAM,kCAAkC,CAAA;AAEzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAIxD,KAAK,UAAU,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,CAAA;AAE5C,MAAM,WAAW,6BAA6B;IAC5C,EAAE,EAAE,UAAU,CAAA;CACf;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,6BAA6B,GAAG,cAAc,CAkGhG;AAwDD,YAAY,EAAE,qBAAqB,EAAE,CAAA"}