@voyant-travel/workflows-orchestrator 0.107.10

package/dist/driver-inmemory.js

@@ -0,0 +1,394 @@
+// agent-quality: file-size exception -- owner: workflows-orchestrator; existing module stays co-located until a dedicated split preserves behavior and tests.
+// In-memory WorkflowDriver — primarily for tests, also for short-lived
+// scripts and the parameterized compliance suite.
+//
+// Wraps the existing pure orchestrator functions (trigger / resume / cancel)
+// with `createInMemoryRunStore` for state and an in-process `StepHandler`
+// glue (`handleStepRequest` from `@voyant-travel/workflows/handler`). Manifests
+// live in a `Map<environment, { manifest, versionId }>`.
+//
+// State lives in the closure returned by `createInMemoryDriver` — every
+// call to the factory yields a fresh, isolated driver. No global state.
+//
+// Authoritative architecture: docs/architecture/workflows-runtime-architecture.md §6.
+import { ManifestNotRegisteredError, } from "@voyant-travel/workflows/driver";
+import { deriveStableEventId } from "@voyant-travel/workflows/events";
+import { handleStepRequest } from "@voyant-travel/workflows/handler";
+import { createInProcessConcurrencyCoordinator, } from "./concurrency.js";
+import { routeEvent } from "./event-router.js";
+import { createInMemoryRunStore } from "./in-memory-store.js";
+import { cancel as orchestratorCancel, trigger as orchestratorTrigger, resumeDueAlarms, } from "./orchestrator.js";
+import { createScheduler, manifestScheduleSources } from "./schedule.js";
+const DEFAULT_TENANT_META = {
+    tenantId: "default",
+    projectId: "default",
+    organizationId: "default",
+};
+/**
+ * Build an in-memory driver factory. The factory closes over its
+ * options and returns a fresh `WorkflowDriver` when `createApp()`
+ * (or a test) calls it with `DriverFactoryDeps`.
+ *
+ * Usage in tests:
+ *
+ *     const driver = createInMemoryDriver()(testFactoryDeps())
+ *     await driver.registerManifest({ environment: "production", manifest })
+ *     await driver.trigger(myWorkflow, { … }, { idempotencyKey: "abc" })
+ */
+export function createInMemoryDriver(opts = {}) {
+    return (deps) => {
+        const store = createInMemoryRunStore();
+        const manifests = new Map();
+        const scheduleRunners = new Map();
+        const now = opts.now ?? deps.now ?? (() => Date.now());
+        const tenantMeta = opts.tenantMeta ?? DEFAULT_TENANT_META;
+        const defaultEnv = opts.defaultEnvironment ?? "development";
+        // 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));
+        let shuttingDown = false;
+        const concurrency = createInProcessConcurrencyCoordinator({
+            async cancelRun(runId, reason) {
+                const out = await orchestratorCancel({ runId, reason }, { store, handler, now });
+                if (out.ok && isTerminal(out.record.status)) {
+                    concurrency.releaseRun(out.record);
+                }
+            },
+        });
+        // ---- WorkflowDriver implementation ----
+        async function registerManifest(args) {
+            assertNotShutdown(shuttingDown);
+            manifests.set(args.environment, {
+                manifest: args.manifest,
+                versionId: args.manifest.versionId,
+            });
+            startScheduleRunner(args.environment, args.manifest);
+            return { versionId: args.manifest.versionId };
+        }
+        async function getManifest(args) {
+            return manifests.get(args.environment)?.manifest ?? null;
+        }
+        async function trigger(workflow, input, triggerOpts) {
+            assertNotShutdown(shuttingDown);
+            const workflowId = typeof workflow === "string" ? workflow : workflow.id;
+            const env = triggerOpts?.environment ?? defaultEnv;
+            const policy = resolveConcurrencyPolicy(workflow, workflowId, env, manifests);
+            // The orchestrator core handles idempotencyKey natively (deterministic
+            // runId derivation from `(workflowId, idempotencyKey)`); the driver just
+            // forwards the field. Persistent stores like `voyant_snapshot_runs`
+            // additionally read `RunRecord.idempotencyKey` to populate their own
+            // dedup column.
+            const record = await triggerRecord({
+                workflowId,
+                workflowVersion: triggerOpts?.lockToVersion ?? "v1",
+                input: input,
+                tenantMeta,
+                environment: env,
+                tags: triggerOpts?.tags,
+                idempotencyKey: triggerOpts?.idempotencyKey,
+                delay: triggerOpts?.delay,
+                priority: triggerOpts?.priority,
+            }, policy);
+            scheduleDelayedRun(record);
+            return runRecordToRun(record);
+        }
+        async function ingestEvent(args) {
+            assertNotShutdown(shuttingDown);
+            const stored = manifests.get(args.environment);
+            if (!stored) {
+                return {
+                    ok: false,
+                    reason: "manifest_not_registered",
+                    message: new ManifestNotRegisteredError(args.environment).message,
+                };
+            }
+            const eventId = await ensureEventId(args.envelope);
+            const routed = routeEvent({
+                manifest: stored.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 triggerRecord({
+                        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,
+                        },
+                    }, resolveConcurrencyPolicy(entry.targetWorkflowId, entry.targetWorkflowId, args.environment, manifests));
+                    scheduleDelayedRun(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;
+                }
+            }
+            // Drivers return ok:true if at least one match queued; ok:false only if
+            // every match errored (per architecture doc §15.5).
+            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;
+            for (const runner of scheduleRunners.values()) {
+                runner.stop();
+            }
+            scheduleRunners.clear();
+        }
+        function startScheduleRunner(environment, manifest) {
+            const existing = scheduleRunners.get(environment);
+            existing?.stop();
+            scheduleRunners.delete(environment);
+            if (opts.disableScheduleRunner)
+                return;
+            const sources = manifestScheduleSources(manifest);
+            if (sources.length === 0)
+                return;
+            const runner = createScheduler({
+                sources,
+                environment,
+                now,
+                tickMs: opts.schedulePollIntervalMs,
+                onFire: async ({ workflowId, input, scheduleId, fireAt }) => {
+                    assertNotShutdown(shuttingDown);
+                    const record = await triggerRecord({
+                        workflowId,
+                        workflowVersion: "v1",
+                        input,
+                        tenantMeta,
+                        environment,
+                        idempotencyKey: `${scheduleId}:${fireAt}`,
+                        triggeredBy: { kind: "schedule", scheduleId },
+                    }, resolveConcurrencyPolicy(workflowId, workflowId, environment, manifests));
+                    scheduleDelayedRun(record);
+                },
+                logger: (level, msg, data) => deps.logger(level, msg, data),
+            });
+            if (runner.sourceCount() === 0)
+                return;
+            runner.start();
+            scheduleRunners.set(environment, runner);
+        }
+        function scheduleDelayedRun(record) {
+            if (record.status !== "waiting")
+                return;
+            const wakeAt = earliestWakeAt(record);
+            if (wakeAt === undefined)
+                return;
+            const delayMs = Math.max(0, wakeAt - now());
+            const timer = setTimeout(() => {
+                void resumeDueAlarms({ runId: record.id }, { store, handler, now }).then(async (resumed) => {
+                    if (!resumed) {
+                        const latest = await store.get(record.id);
+                        if (latest)
+                            scheduleDelayedRun(latest);
+                        return;
+                    }
+                    if (isTerminal(resumed.status)) {
+                        concurrency.releaseRun(resumed);
+                    }
+                    scheduleDelayedRun(resumed);
+                });
+            }, delayMs);
+            timer.unref?.();
+        }
+        async function triggerRecord(args, policy) {
+            return concurrency.run({
+                workflowId: args.workflowId,
+                input: args.input,
+                policy,
+                holderId: concurrencyHolderId(args),
+            }, (hooks) => orchestratorTrigger({
+                ...args,
+                onRunRecordCreated: hooks.onRunRecordCreated,
+            }, { store, handler, now }));
+        }
+        // ---- WorkflowAdmin (partial; sufficient for compliance tests) ----
+        const admin = {
+            async listRuns(listOpts) {
+                const filterEnv = listOpts?.environment;
+                const filterStatus = normalizeStatusFilter(listOpts?.status);
+                const filterWorkflow = listOpts?.workflowId;
+                const filterTag = listOpts?.tag;
+                const filterSince = toEpoch(listOpts?.since);
+                const filterUntil = toEpoch(listOpts?.until);
+                const limit = listOpts?.limit ?? 100;
+                const results = [];
+                for (const rec of await store.list({})) {
+                    if (filterEnv && rec.environment !== filterEnv)
+                        continue;
+                    if (filterStatus && !filterStatus.includes(rec.status))
+                        continue;
+                    if (filterWorkflow && rec.workflowId !== filterWorkflow)
+                        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));
+                }
+                results.sort((a, b) => b.startedAt - a.startedAt);
+                const page = results.slice(0, limit);
+                const nextCursor = results.length > limit ? String(limit) : undefined;
+                return { runs: page, nextCursor };
+            },
+            async getRun(runId) {
+                const rec = await store.get(runId);
+                return rec ? runRecordToDetail(rec) : null;
+            },
+            async cancelRun(runId, cancelOpts) {
+                // The orchestrator core's cancel() does NOT run compensations by default
+                // (per workflows-runtime-architecture.md §21.21). The `compensate` flag
+                // is accepted but no-ops in v1; honoring it would require an engine
+                // behavior change tracked separately.
+                void cancelOpts?.compensate;
+                const out = await orchestratorCancel({ runId, reason: cancelOpts?.reason }, { store, handler, now });
+                if (out.ok && isTerminal(out.record.status)) {
+                    concurrency.releaseRun(out.record);
+                }
+            },
+            // streamRun is not implemented for InMemory in PR1. Dashboards that
+            // probe `driver.admin.streamRun` get `undefined` and fall back to
+            // their non-streaming view. Mode 2 + Mode 1 implement this in later
+            // PRs against their respective journal sources.
+        };
+        return {
+            registerManifest,
+            trigger,
+            ingestEvent,
+            getManifest,
+            shutdown,
+            admin,
+        };
+    };
+}
+function concurrencyHolderId(args) {
+    if (args.runId !== undefined)
+        return args.runId;
+    if (args.idempotencyKey !== undefined)
+        return `idem-${args.workflowId}-${args.idempotencyKey}`;
+    return undefined;
+}
+function earliestWakeAt(record) {
+    let earliest;
+    for (const waitpoint of record.pendingWaitpoints) {
+        if (waitpoint.kind !== "DATETIME")
+            continue;
+        const wakeAt = typeof waitpoint.meta.wakeAt === "number" ? waitpoint.meta.wakeAt : undefined;
+        if (wakeAt === undefined)
+            continue;
+        earliest = earliest === undefined ? wakeAt : Math.min(earliest, wakeAt);
+    }
+    return earliest;
+}
+// ---- Helpers ----
+function assertNotShutdown(shuttingDown) {
+    if (shuttingDown) {
+        throw new Error("InMemoryDriver: shutdown() has been called; new operations are refused.");
+    }
+}
+function resolveConcurrencyPolicy(workflow, workflowId, environment, manifests) {
+    if (typeof workflow !== "string" && workflow.config?.concurrency) {
+        return workflow.config.concurrency;
+    }
+    const manifest = manifests.get(environment)?.manifest;
+    return manifest?.workflows.find((entry) => entry.id === workflowId)?.concurrency;
+}
+function isTerminal(status) {
+    return (status === "completed" ||
+        status === "failed" ||
+        status === "cancelled" ||
+        status === "compensated" ||
+        status === "compensation_failed");
+}
+async function ensureEventId(envelope) {
+    if (envelope.metadata?.eventId)
+        return envelope.metadata.eventId;
+    // Content-derived fallback per architecture doc §15.2. Two ingests
+    // with byte-equal envelopes produce the same id, so retries dedupe
+    // through the driver's `${filterId}:${eventId}` idempotency key.
+    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/event-router.d.ts

@@ -0,0 +1,51 @@
+import { type PredicateEnvelope } from "@voyant-travel/workflows/events";
+import type { WorkflowManifest } from "@voyant-travel/workflows/protocol";
+/**
+ * Outcome of routing a single envelope through every filter in a manifest.
+ * Each match describes exactly enough for a driver to call `trigger()`:
+ *   - `targetWorkflowId` and `input` are the trigger args.
+ *   - `idempotencyKey` derives from `${filterId}:${eventId}` so retries of
+ *     the same envelope produce a stable run regardless of which driver
+ *     applies the trigger.
+ */
+export type RouterMatch = {
+    filterId: string;
+    targetWorkflowId: string;
+    input: unknown;
+    idempotencyKey: string;
+    status: "matched";
+} | {
+    filterId: string;
+    status: "skipped";
+    reason: "where_eval_error" | "input_projection_error";
+    details?: string;
+};
+export interface RouteEventArgs {
+    manifest: WorkflowManifest;
+    envelope: PredicateEnvelope;
+    /**
+     * Stable id for the envelope. Drivers derive this from
+     * `metadata.eventId` (when set) or fall back to a content hash; passing
+     * it in keeps the router pure.
+     */
+    eventId: string;
+    /**
+     * Optional caller-supplied idempotency override (per
+     * `IngestEventArgs.idempotencyKey`). When set, the per-match key
+     * becomes `${filterId}:${suppliedKey}` instead of
+     * `${filterId}:${eventId}`.
+     */
+    idempotencyOverride?: string;
+}
+/**
+ * Route an envelope through a manifest. Pure: no IO, no side effects.
+ * Returns one entry per filter that targets the envelope's eventType, in
+ * the order they appear in `manifest.eventFilters` (which is itself
+ * id-sorted from `buildManifest`).
+ *
+ * `where` evaluation errors and `input` projection errors are isolated to
+ * the offending filter — other filters still produce matches. Drivers
+ * surface skips as `IngestMatch.status === "skipped"` in the response.
+ */
+export declare function routeEvent(args: RouteEventArgs): RouterMatch[];
+//# sourceMappingURL=event-router.d.ts.map

package/dist/event-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-router.d.ts","sourceRoot":"","sources":["../src/event-router.ts"],"names":[],"mappings":"AAUA,OAAO,EAGL,KAAK,iBAAiB,EAGvB,MAAM,iCAAiC,CAAA;AACxC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAA;AAIzE;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,GACnB;IACE,QAAQ,EAAE,MAAM,CAAA;IAChB,gBAAgB,EAAE,MAAM,CAAA;IACxB,KAAK,EAAE,OAAO,CAAA;IACd,cAAc,EAAE,MAAM,CAAA;IACtB,MAAM,EAAE,SAAS,CAAA;CAClB,GACD;IACE,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,SAAS,CAAA;IACjB,MAAM,EAAE,kBAAkB,GAAG,wBAAwB,CAAA;IACrD,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAEL,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,QAAQ,EAAE,iBAAiB,CAAA;IAC3B;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAA;IACf;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAC7B;AAID;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,cAAc,GAAG,WAAW,EAAE,CA6C9D"}

package/dist/event-router.js

@@ -0,0 +1,68 @@
+// Pure event router — given a manifest and an envelope, decide which
+// filters match and produce the per-match descriptors drivers feed into
+// `trigger()`.
+//
+// Drivers (InMemory, Mode 2 / Postgres, Mode 1 / CF edge) wrap this in
+// their own `ingestEvent` impl: they fetch the manifest from their store,
+// call `routeEvent(...)`, then invoke `trigger()` per match.
+//
+// Architecture: docs/architecture/workflows-runtime-architecture.md §15.
+import { evaluatePredicate, projectInput, } from "@voyant-travel/workflows/events";
+// ---- Public API ----
+/**
+ * Route an envelope through a manifest. Pure: no IO, no side effects.
+ * Returns one entry per filter that targets the envelope's eventType, in
+ * the order they appear in `manifest.eventFilters` (which is itself
+ * id-sorted from `buildManifest`).
+ *
+ * `where` evaluation errors and `input` projection errors are isolated to
+ * the offending filter — other filters still produce matches. Drivers
+ * surface skips as `IngestMatch.status === "skipped"` in the response.
+ */
+export function routeEvent(args) {
+    const out = [];
+    for (const filter of args.manifest.eventFilters) {
+        if (filter.eventType !== args.envelope.name)
+            continue;
+        // Predicate gate.
+        if (filter.where !== undefined) {
+            try {
+                const matched = evaluatePredicate(filter.where, args.envelope);
+                if (!matched)
+                    continue;
+            }
+            catch (err) {
+                out.push({
+                    filterId: filter.id,
+                    status: "skipped",
+                    reason: "where_eval_error",
+                    details: err instanceof Error ? err.message : String(err),
+                });
+                continue;
+            }
+        }
+        // Input projection.
+        let input;
+        try {
+            input = projectInput(filter.input, args.envelope);
+        }
+        catch (err) {
+            out.push({
+                filterId: filter.id,
+                status: "skipped",
+                reason: "input_projection_error",
+                details: err instanceof Error ? err.message : String(err),
+            });
+            continue;
+        }
+        const baseKey = args.idempotencyOverride ?? args.eventId;
+        out.push({
+            filterId: filter.id,
+            targetWorkflowId: filter.targetWorkflowId,
+            input,
+            idempotencyKey: `${filter.id}:${baseKey}`,
+            status: "matched",
+        });
+    }
+    return out;
+}

package/dist/http-step-handler.d.ts

@@ -0,0 +1,25 @@
+import type { StepHandler, WorkflowStepRequest } from "./types.js";
+export interface HttpStepTarget {
+    url: string;
+    fetch(request: Request): Promise<Response>;
+    label?: string;
+}
+export interface HttpStepHandlerDeps {
+    /**
+     * Resolve the transport target for this workflow-step invocation.
+     * Adapters can map `tenantMeta.tenantScript` to a dispatch-namespace
+     * binding, a service URL, or a local proxy.
+     */
+    resolveTarget: (req: WorkflowStepRequest) => HttpStepTarget | Promise<HttpStepTarget>;
+    /** Optional HMAC signer for the X-Voyant-Dispatch-Auth header. */
+    sign?: (body: string, req: WorkflowStepRequest) => Promise<string> | string;
+    /** Optional logger for step-level observability. */
+    logger?: (level: "info" | "warn" | "error", msg: string, data?: object) => void;
+}
+/**
+ * Build a StepHandler that serializes WorkflowStepRequest over HTTP.
+ * The concrete transport target is adapter-specific; the request/response
+ * mapping is shared across Cloudflare, Node, and future adapters.
+ */
+export declare function createHttpStepHandler(deps: HttpStepHandlerDeps): StepHandler;
+//# sourceMappingURL=http-step-handler.d.ts.map

package/dist/http-step-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-step-handler.d.ts","sourceRoot":"","sources":["../src/http-step-handler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAwB,MAAM,YAAY,CAAA;AAQxF,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;IAC1C,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,aAAa,EAAE,CAAC,GAAG,EAAE,mBAAmB,KAAK,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CAAA;IACrF,kEAAkE;IAClE,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,mBAAmB,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAA;IAC3E,oDAAoD;IACpD,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;CAChF;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,mBAAmB,GAAG,WAAW,CA+D5E"}

package/dist/http-step-handler.js

@@ -0,0 +1,78 @@
+import { PROTOCOL_VERSION } from "@voyant-travel/workflows/protocol";
+/**
+ * Build a StepHandler that serializes WorkflowStepRequest over HTTP.
+ * The concrete transport target is adapter-specific; the request/response
+ * mapping is shared across Cloudflare, Node, and future adapters.
+ */
+export function createHttpStepHandler(deps) {
+    return async (req, stepOpts) => {
+        const body = JSON.stringify(req);
+        const headers = {
+            "content-type": "application/json; charset=utf-8",
+            "x-voyant-protocol": String(PROTOCOL_VERSION),
+        };
+        if (deps.sign) {
+            headers["x-voyant-dispatch-auth"] = await deps.sign(body, req);
+        }
+        const target = await deps.resolveTarget(req);
+        deps.logger?.("info", "http-step: invoking tenant step", {
+            target: target.label ?? target.url,
+            runId: req.runId,
+            workflowId: req.workflowId,
+            invocation: req.invocationCount,
+        });
+        let response;
+        try {
+            response = await target.fetch(new Request(target.url, {
+                method: "POST",
+                headers,
+                body,
+                signal: stepOpts?.signal,
+            }));
+        }
+        catch (err) {
+            deps.logger?.("error", "http-step: tenant fetch threw", {
+                target: target.label ?? target.url,
+                runId: req.runId,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return {
+                status: 502,
+                body: {
+                    error: "tenant_unreachable",
+                    message: err instanceof Error ? err.message : String(err),
+                },
+            };
+        }
+        const text = await response.text();
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            return {
+                status: 502,
+                body: {
+                    error: "tenant_invalid_response",
+                    message: `tenant returned non-JSON body (HTTP ${response.status})`,
+                },
+            };
+        }
+        if (response.status !== 200) {
+            return { status: response.status, body: toErrorBody(parsed, response.status) };
+        }
+        return { status: 200, body: parsed };
+    };
+}
+function toErrorBody(parsed, fallbackStatus) {
+    if (parsed !== null &&
+        typeof parsed === "object" &&
+        typeof parsed.error === "string" &&
+        typeof parsed.message === "string") {
+        return parsed;
+    }
+    return {
+        error: "tenant_error",
+        message: `tenant returned HTTP ${fallbackStatus}`,
+    };
+}

package/dist/in-memory-store.d.ts

@@ -0,0 +1,5 @@
+import type { OrchestratorRunStatus, RunRecordStore } from "./types.js";
+export declare function createInMemoryRunStore(): RunRecordStore;
+/** Keep the unused import happy — guards against accidental type-only drift. */
+export type { OrchestratorRunStatus };
+//# sourceMappingURL=in-memory-store.d.ts.map

package/dist/in-memory-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory-store.d.ts","sourceRoot":"","sources":["../src/in-memory-store.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,qBAAqB,EAAa,cAAc,EAAE,MAAM,YAAY,CAAA;AAElF,wBAAgB,sBAAsB,IAAI,cAAc,CA8BvD;AAMD,gFAAgF;AAChF,YAAY,EAAE,qBAAqB,EAAE,CAAA"}

package/dist/in-memory-store.js

@@ -0,0 +1,41 @@
+// A pure in-memory RunRecordStore. Useful for tests and local-only
+// orchestrator harnesses. The production store is Postgres-backed
+// and lives in voyant-cloud.
+export function createInMemoryRunStore() {
+    const records = new Map();
+    return {
+        async get(id) {
+            const r = records.get(id);
+            return r ? clone(r) : undefined;
+        },
+        async save(record) {
+            records.set(record.id, clone(record));
+            return clone(record);
+        },
+        async tryInsert(record) {
+            // Atomic-by-construction: Map.has + Map.set inside a single
+            // microtask. Concurrent `tryInsert(idA)` calls all schedule on the
+            // same JS event loop and only the first one observes the slot
+            // empty — subsequent callers see the inserted record.
+            const existing = records.get(record.id);
+            if (existing)
+                return { record: clone(existing), created: false };
+            records.set(record.id, clone(record));
+            return { record: clone(record), created: true };
+        },
+        async list(filter = {}) {
+            let out = [...records.values()].map(clone);
+            if (filter.workflowId)
+                out = out.filter((r) => r.workflowId === filter.workflowId);
+            if (filter.status)
+                out = out.filter((r) => r.status === filter.status);
+            out.sort((a, b) => b.startedAt - a.startedAt);
+            if (filter.limit !== undefined)
+                out = out.slice(0, filter.limit);
+            return out;
+        },
+    };
+}
+function clone(value) {
+    return structuredClone(value);
+}