@nwire/forge 0.10.1 → 0.11.0

package/dist/plugins/projections-chain.js

@@ -0,0 +1,86 @@
+/**
+ * Projection chain runner — the EventPublishing step that folds an
+ * event into every registered projection that listens for it.
+ *
+ * Self-contained: takes its dependencies as constructor arguments. Both
+ * `projectionsPlugin` and the bundled `ForgeDispatcher` instantiate one
+ * of these and call `apply(event, envelope)` from their respective hook
+ * attachment.
+ *
+ * Per-event behaviour:
+ *   1. Look up projections that listen for `event.eventName`.
+ *   2. For each, load the per-tenant state, run the reducer, save.
+ *   3. Push `projection.folded` telemetry on success or `projection.failed`
+ *      on a reducer throw (then re-raise so the EventPublishing chain
+ *      surfaces the failure).
+ */
+import { serializeError } from "@nwire/app";
+export class ProjectionChainRunner {
+    runtime;
+    store;
+    projections = new Map();
+    projectionsByEvent = new Map();
+    constructor(runtime, store) {
+        this.runtime = runtime;
+        this.store = store;
+    }
+    /** Register a projection. Throws on duplicate names. */
+    register(projection) {
+        if (this.projections.has(projection.name)) {
+            throw new Error(`projectionsPlugin: projection "${projection.name}" already registered.`);
+        }
+        this.projections.set(projection.name, projection);
+        for (const event of projection.listens) {
+            const list = this.projectionsByEvent.get(event.name) ?? [];
+            list.push(projection);
+            this.projectionsByEvent.set(event.name, list);
+        }
+    }
+    /** All registered projection names, in registration order. */
+    listProjections() {
+        return [...this.projections.keys()];
+    }
+    /** Apply one event to every projection that listens for it. */
+    async apply(event, envelope) {
+        const projections = this.projectionsByEvent.get(event.eventName);
+        if (!projections || projections.length === 0)
+            return;
+        const tenant = envelope.tenant ?? "";
+        const appName = this.runtime.appName;
+        for (const projection of projections) {
+            const reducer = projection.on[event.eventName];
+            if (!reducer)
+                continue;
+            const t0 = performance.now();
+            try {
+                const current = (await this.store.load(projection.name, tenant)) ?? projection.initial();
+                const next = reducer(current, event.payload);
+                await this.store.save(projection.name, next, tenant);
+                this.runtime.pushTelemetry({
+                    kind: "projection.folded",
+                    projection: projection.name,
+                    event: event.eventName,
+                    tenant,
+                    durationMs: performance.now() - t0,
+                    envelope,
+                    appName,
+                    ts: new Date().toISOString(),
+                });
+            }
+            catch (err) {
+                this.runtime.pushTelemetry({
+                    kind: "projection.failed",
+                    projection: projection.name,
+                    event: event.eventName,
+                    tenant,
+                    durationMs: performance.now() - t0,
+                    error: serializeError(err),
+                    envelope,
+                    appName,
+                    ts: new Date().toISOString(),
+                });
+                throw err;
+            }
+        }
+    }
+}

package/dist/plugins/projections-plugin.d.ts

@@ -0,0 +1,36 @@
+/**
+ * `projectionsPlugin` — standalone forge projection concern.
+ *
+ *   import { createApp } from "@nwire/app";
+ *   import { projectionsPlugin, forgePlugin } from "@nwire/forge";
+ *
+ *   const app = createApp({
+ *     appName: "orders",
+ *     plugins: [
+ *       forgePlugin,
+ *       projectionsPlugin([OrdersDashboard, ItemsByStatus]),
+ *     ],
+ *   });
+ *
+ * Owns:
+ *   - the `forge.projectionStore` container binding
+ *   - the projection registry (private to the plugin's `ProjectionChainRunner`)
+ *   - the `forge.publish.projections` step on the EventPublishing chain
+ *     (priority 600 — between actors and workflows)
+ *   - the `forge.projectionChain` container binding so queriesPlugin (and
+ *     other consumers) can resolve the runner
+ *
+ * If `forgePlugin`'s `options.projections` is also passed, both installs
+ * fold every event — install ONE path, not both. A diagnostic warning
+ * fires at `AppReady` when both attachments are present.
+ */
+import type { PluginDefinition } from "@nwire/app";
+import { type ProjectionStore } from "../stores/projection-store.js";
+import type { ProjectionDefinition } from "../primitives/define-projection.js";
+export declare const FORGE_PROJECTION_CHAIN_BINDING: "forge.projectionChain";
+export declare const FORGE_PROJECTION_STORE_BINDING: "forge.projectionStore";
+export interface ProjectionsPluginOptions {
+    /** Override the projection store. Defaults to `InMemoryProjectionStore`. */
+    readonly projectionStore?: ProjectionStore;
+}
+export declare function projectionsPlugin(projections: readonly ProjectionDefinition<any>[], opts?: ProjectionsPluginOptions): PluginDefinition;

package/dist/plugins/projections-plugin.js

@@ -0,0 +1,63 @@
+/**
+ * `projectionsPlugin` — standalone forge projection concern.
+ *
+ *   import { createApp } from "@nwire/app";
+ *   import { projectionsPlugin, forgePlugin } from "@nwire/forge";
+ *
+ *   const app = createApp({
+ *     appName: "orders",
+ *     plugins: [
+ *       forgePlugin,
+ *       projectionsPlugin([OrdersDashboard, ItemsByStatus]),
+ *     ],
+ *   });
+ *
+ * Owns:
+ *   - the `forge.projectionStore` container binding
+ *   - the projection registry (private to the plugin's `ProjectionChainRunner`)
+ *   - the `forge.publish.projections` step on the EventPublishing chain
+ *     (priority 600 — between actors and workflows)
+ *   - the `forge.projectionChain` container binding so queriesPlugin (and
+ *     other consumers) can resolve the runner
+ *
+ * If `forgePlugin`'s `options.projections` is also passed, both installs
+ * fold every event — install ONE path, not both. A diagnostic warning
+ * fires at `AppReady` when both attachments are present.
+ */
+import { InMemoryProjectionStore } from "../stores/projection-store.js";
+import { EVENT_PUBLISHING_PRIORITIES } from "../framework-events.js";
+import { ProjectionChainRunner } from "./projections-chain.js";
+export const FORGE_PROJECTION_CHAIN_BINDING = "forge.projectionChain";
+export const FORGE_PROJECTION_STORE_BINDING = "forge.projectionStore";
+export function projectionsPlugin(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+projections, opts = {}) {
+    return {
+        name: "forge.projections",
+        register({ bind }) {
+            const store = opts.projectionStore ?? new InMemoryProjectionStore();
+            bind(FORGE_PROJECTION_STORE_BINDING, () => store);
+        },
+        setup({ runtime, container, on }) {
+            const store = container.resolve(FORGE_PROJECTION_STORE_BINDING);
+            const chain = new ProjectionChainRunner(runtime, store);
+            for (const projection of projections) {
+                chain.register(projection);
+            }
+            container.register(FORGE_PROJECTION_CHAIN_BINDING, chain);
+            runtime.hooks.EventPublishing.use(async (payload, next) => {
+                await chain.apply(payload.event, payload.envelope);
+                await next();
+            }, { name: "forge.publish.projections", priority: EVENT_PUBLISHING_PRIORITIES.projections });
+            on("AppReady", () => {
+                const hookChain = runtime.hooks.EventPublishing;
+                const steps = (hookChain.chain ?? []).filter((s) => s.name === "forge.publish.projections");
+                if (steps.length > 1) {
+                    // eslint-disable-next-line no-console
+                    console.warn(`projectionsPlugin: detected ${steps.length} "forge.publish.projections" steps on the EventPublishing chain. ` +
+                        `Install either projectionsPlugin OR forgePlugin's options.projections path, not both.`);
+                }
+            });
+        },
+    };
+}

package/dist/plugins/queries-chain.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Query runner — the read-side equivalent of the EventPublishing chain.
+ *
+ * Queries don't participate in the publish chain; they execute on
+ * demand against the projection store (`projection.execute(state, input)`)
+ * or via a handler closure (`query.handler(input, ctx)`). The runner is
+ * a thin holder around the registry + execution logic that both the
+ * standalone `queriesPlugin` and the bundled `ForgeDispatcher` use.
+ *
+ * Per-call behaviour:
+ *   1. Look up the query by name.
+ *   2. Validate input against the query's schema.
+ *   3. If `projection + execute` is configured, load the projection's
+ *      per-tenant state and run execute.
+ *   4. If `handler` is configured, run it with a minimal ctx exposing
+ *      `resolve` (container) and `tenant`.
+ *   5. Push `query.executed` telemetry on success.
+ */
+import { type Runtime } from "@nwire/app";
+import type { Container } from "@nwire/container";
+import type { QueryDefinition } from "../primitives/define-query.js";
+import type { ProjectionStore } from "../stores/projection-store.js";
+export declare class QueryRunner {
+    private readonly runtime;
+    private readonly container;
+    private readonly projectionStore;
+    readonly queries: Map<string, QueryDefinition<any, any, any>>;
+    constructor(runtime: Runtime, container: Container, projectionStore: ProjectionStore);
+    register(query: QueryDefinition<any, any, any>): void;
+    /** All registered query names, in registration order. */
+    listQueries(): readonly string[];
+    run<TResult = unknown>(queryName: string, input: unknown, tenant?: string): Promise<TResult>;
+}

package/dist/plugins/queries-chain.js

@@ -0,0 +1,77 @@
+/**
+ * Query runner — the read-side equivalent of the EventPublishing chain.
+ *
+ * Queries don't participate in the publish chain; they execute on
+ * demand against the projection store (`projection.execute(state, input)`)
+ * or via a handler closure (`query.handler(input, ctx)`). The runner is
+ * a thin holder around the registry + execution logic that both the
+ * standalone `queriesPlugin` and the bundled `ForgeDispatcher` use.
+ *
+ * Per-call behaviour:
+ *   1. Look up the query by name.
+ *   2. Validate input against the query's schema.
+ *   3. If `projection + execute` is configured, load the projection's
+ *      per-tenant state and run execute.
+ *   4. If `handler` is configured, run it with a minimal ctx exposing
+ *      `resolve` (container) and `tenant`.
+ *   5. Push `query.executed` telemetry on success.
+ */
+import { isValidated, markValidated } from "@nwire/messages";
+export class QueryRunner {
+    runtime;
+    container;
+    projectionStore;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    queries = new Map();
+    constructor(runtime, container, projectionStore) {
+        this.runtime = runtime;
+        this.container = container;
+        this.projectionStore = projectionStore;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    register(query) {
+        if (this.queries.has(query.name)) {
+            throw new Error(`queriesPlugin: query "${query.name}" already registered.`);
+        }
+        this.queries.set(query.name, query);
+    }
+    /** All registered query names, in registration order. */
+    listQueries() {
+        return [...this.queries.keys()];
+    }
+    async run(queryName, input, tenant = "") {
+        const query = this.queries.get(queryName);
+        if (!query) {
+            throw new Error(`queriesPlugin: no query registered with name "${queryName}".`);
+        }
+        const t0 = performance.now();
+        const validated = isValidated(input) ? input : markValidated(query.schema.parse(input));
+        const appName = this.runtime.appName;
+        let result;
+        if (query.projection && query.execute) {
+            const state = (await this.projectionStore.load(query.projection.name, tenant)) ??
+                query.projection.initial();
+            result = (await query.execute(state, validated));
+        }
+        else if (query.handler) {
+            result = (await query.handler(validated, {
+                resolve: (name) => this.container.resolve(name),
+                tenant,
+            }));
+        }
+        else {
+            throw new Error(`queriesPlugin: query "${queryName}" has neither projection+execute nor a handler — ` +
+                `defineQuery must be given one or the other.`);
+        }
+        this.runtime.pushTelemetry({
+            kind: "query.executed",
+            query: queryName,
+            input: validated,
+            tenant,
+            durationMs: performance.now() - t0,
+            appName,
+            ts: new Date().toISOString(),
+        });
+        return result;
+    }
+}

package/dist/plugins/queries-plugin.d.ts

@@ -0,0 +1,41 @@
+/**
+ * `queriesPlugin` — standalone forge query concern.
+ *
+ *   import { createApp } from "@nwire/app";
+ *   import {
+ *     projectionsPlugin,
+ *     queriesPlugin,
+ *     forgePlugin,
+ *   } from "@nwire/forge";
+ *
+ *   const app = createApp({
+ *     appName: "orders",
+ *     plugins: [
+ *       forgePlugin,
+ *       projectionsPlugin([OrdersDashboard]),
+ *       queriesPlugin([listOrders, getOrderById]),
+ *     ],
+ *   });
+ *
+ * Owns:
+ *   - the query registry (private to the plugin's `QueryRunner`)
+ *   - the `forge.queryRunner` container binding
+ *   - the `forge.query` capability (binding consumed by handler ctx as
+ *     `ctx.resolve("useProjection")` and equivalent paths)
+ *
+ * Queries don't participate in the EventPublishing chain. They execute
+ * on demand against either a projection's per-tenant state (when
+ * `projection + execute` is set) or a handler closure. Projection state
+ * comes from the `forge.projectionStore` binding, which `projectionsPlugin`
+ * or `forgePlugin` provides.
+ *
+ * If `forgePlugin`'s `options.queries` is also passed, two QueryRunners
+ * exist and the bundled one is reachable through the existing forge
+ * dispatcher binding. Both work, but the standalone plugin's runner is
+ * the one bound on `FORGE_QUERY_RUNNER_BINDING`. A warning at AppReady
+ * flags the duplicate install.
+ */
+import type { PluginDefinition } from "@nwire/app";
+import type { QueryDefinition } from "../primitives/define-query.js";
+export declare const FORGE_QUERY_RUNNER_BINDING: "forge.queryRunner";
+export declare function queriesPlugin(queries: readonly QueryDefinition<any, any, any>[]): PluginDefinition;

package/dist/plugins/queries-plugin.js

@@ -0,0 +1,74 @@
+/**
+ * `queriesPlugin` — standalone forge query concern.
+ *
+ *   import { createApp } from "@nwire/app";
+ *   import {
+ *     projectionsPlugin,
+ *     queriesPlugin,
+ *     forgePlugin,
+ *   } from "@nwire/forge";
+ *
+ *   const app = createApp({
+ *     appName: "orders",
+ *     plugins: [
+ *       forgePlugin,
+ *       projectionsPlugin([OrdersDashboard]),
+ *       queriesPlugin([listOrders, getOrderById]),
+ *     ],
+ *   });
+ *
+ * Owns:
+ *   - the query registry (private to the plugin's `QueryRunner`)
+ *   - the `forge.queryRunner` container binding
+ *   - the `forge.query` capability (binding consumed by handler ctx as
+ *     `ctx.resolve("useProjection")` and equivalent paths)
+ *
+ * Queries don't participate in the EventPublishing chain. They execute
+ * on demand against either a projection's per-tenant state (when
+ * `projection + execute` is set) or a handler closure. Projection state
+ * comes from the `forge.projectionStore` binding, which `projectionsPlugin`
+ * or `forgePlugin` provides.
+ *
+ * If `forgePlugin`'s `options.queries` is also passed, two QueryRunners
+ * exist and the bundled one is reachable through the existing forge
+ * dispatcher binding. Both work, but the standalone plugin's runner is
+ * the one bound on `FORGE_QUERY_RUNNER_BINDING`. A warning at AppReady
+ * flags the duplicate install.
+ */
+import { FORGE_PROJECTION_STORE_BINDING } from "./projections-plugin.js";
+import { QueryRunner } from "./queries-chain.js";
+export const FORGE_QUERY_RUNNER_BINDING = "forge.queryRunner";
+export function queriesPlugin(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+queries) {
+    return {
+        name: "forge.queries",
+        setup({ runtime, container, on }) {
+            if (!container.has(FORGE_PROJECTION_STORE_BINDING)) {
+                throw new Error(`queriesPlugin: ${FORGE_PROJECTION_STORE_BINDING} is not bound. ` +
+                    `Install projectionsPlugin or forgePlugin before queriesPlugin so the projection store exists.`);
+            }
+            const projectionStore = container.resolve(FORGE_PROJECTION_STORE_BINDING);
+            const runner = new QueryRunner(runtime, container, projectionStore);
+            for (const query of queries)
+                runner.register(query);
+            container.register(FORGE_QUERY_RUNNER_BINDING, runner);
+            on("AppReady", () => {
+                // Diagnostic only — the bundled forge dispatcher also exposes
+                // queries via its own internal registry. Both work, but the
+                // standalone runner is the binding consumers see at
+                // FORGE_QUERY_RUNNER_BINDING.
+                const dispatcher = container.has("forge.dispatcher")
+                    ? container.resolve("forge.dispatcher")
+                    : undefined;
+                const bundledNames = dispatcher?.listQueries?.() ?? [];
+                const overlap = runner.listQueries().filter((n) => bundledNames.includes(n));
+                if (overlap.length > 0) {
+                    // eslint-disable-next-line no-console
+                    console.warn(`queriesPlugin: ${overlap.length} query name(s) (${overlap.join(", ")}) are also registered on forgePlugin's bundled queries. ` +
+                        `Install either queriesPlugin OR forgePlugin's options.queries path, not both.`);
+                }
+            });
+        },
+    };
+}

package/dist/plugins/workflows-chain.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Workflow chain runner — the EventPublishing step that drives every
+ * registered workflow whose subscribed events include the current one.
+ *
+ * Self-contained: takes its dependencies (runtime, timer store, effects
+ * factory) as constructor arguments. Both `workflowsPlugin` and the
+ * bundled `ForgeDispatcher` instantiate one of these and call
+ * `apply(event, envelope)` from their respective hook attachment.
+ *
+ * Per-event behaviour:
+ *   1. Look up workflows by subscribed event name.
+ *   2. For each, build a per-fire `FireContext` (load/save/drop the
+ *      correlated instance, schedule timers, emit effects).
+ *   3. Fire the workflow with retry per `workflow.retry`, then push
+ *      `reaction.fired` / `reaction.failed` / `reaction.exhausted` telemetry.
+ *   4. Per-workflow fire hook (`workflow.fire:<name>`) runs before each
+ *      attempt; throws there are logged, not fatal.
+ */
+import { type Hook } from "@nwire/hooks";
+import { type MessageEnvelope } from "@nwire/envelope";
+import { type Runtime } from "@nwire/app";
+import type { WorkflowDefinition, WorkflowInstance, WorkflowEffects } from "../primitives/define-workflow.js";
+import type { EventMessage } from "../messages/event-message.js";
+import type { WorkflowFireHookCtx } from "../runtime/forge-types.js";
+import type { WorkflowTimerStore } from "../stores/workflow-timer-store.js";
+/**
+ * Resolves the dispatch effects (send / enqueue / publish) the workflow
+ * sees on each fire. Returned in a fresh closure per event so envelope
+ * propagation stays correct.
+ */
+export type WorkflowEffectsFactory = (envelope: MessageEnvelope) => WorkflowEffects;
+export declare class WorkflowChainRunner {
+    private readonly runtime;
+    readonly timerStore: WorkflowTimerStore;
+    private readonly buildEffects;
+    readonly workflows: Map<string, WorkflowDefinition>;
+    readonly workflowsByEvent: Map<string, WorkflowDefinition[]>;
+    readonly perWorkflowHooks: Map<string, Hook<WorkflowFireHookCtx>>;
+    /** In-memory per-workflow instance stores, keyed by correlationKey. */
+    readonly workflowInstances: Map<string, Map<string, WorkflowInstance>>;
+    constructor(runtime: Runtime, timerStore: WorkflowTimerStore, buildEffects: WorkflowEffectsFactory);
+    register(workflow: WorkflowDefinition): void;
+    /** All registered workflow definitions, in registration order. */
+    listWorkflows(): readonly WorkflowDefinition[];
+    /** Lazy-create the per-workflow `workflow.fire:<name>` hook. */
+    ensureFireHook(workflowName: string): Hook<WorkflowFireHookCtx>;
+    /** Get-or-create the in-memory per-workflow instance store. */
+    instanceStore(workflowName: string): Map<string, WorkflowInstance>;
+    /** Fire every workflow that subscribes to this event. */
+    apply(event: EventMessage, envelope: MessageEnvelope, correlationKeyOverride?: string): Promise<void>;
+}

package/dist/plugins/workflows-chain.js

@@ -0,0 +1,203 @@
+/**
+ * Workflow chain runner — the EventPublishing step that drives every
+ * registered workflow whose subscribed events include the current one.
+ *
+ * Self-contained: takes its dependencies (runtime, timer store, effects
+ * factory) as constructor arguments. Both `workflowsPlugin` and the
+ * bundled `ForgeDispatcher` instantiate one of these and call
+ * `apply(event, envelope)` from their respective hook attachment.
+ *
+ * Per-event behaviour:
+ *   1. Look up workflows by subscribed event name.
+ *   2. For each, build a per-fire `FireContext` (load/save/drop the
+ *      correlated instance, schedule timers, emit effects).
+ *   3. Fire the workflow with retry per `workflow.retry`, then push
+ *      `reaction.fired` / `reaction.failed` / `reaction.exhausted` telemetry.
+ *   4. Per-workflow fire hook (`workflow.fire:<name>`) runs before each
+ *      attempt; throws there are logged, not fatal.
+ */
+import { randomUUID } from "node:crypto";
+import { hook } from "@nwire/hooks";
+import { loggerForEnvelope } from "@nwire/logger";
+import { serializeError } from "@nwire/app";
+import { computeBackoff, parseDelay, sleep } from "../helpers/retry-helpers.js";
+export class WorkflowChainRunner {
+    runtime;
+    timerStore;
+    buildEffects;
+    workflows = new Map();
+    workflowsByEvent = new Map();
+    perWorkflowHooks = new Map();
+    /** In-memory per-workflow instance stores, keyed by correlationKey. */
+    workflowInstances = new Map();
+    constructor(runtime, timerStore, buildEffects) {
+        this.runtime = runtime;
+        this.timerStore = timerStore;
+        this.buildEffects = buildEffects;
+    }
+    register(workflow) {
+        if (this.workflows.has(workflow.name)) {
+            throw new Error(`workflowsPlugin: workflow "${workflow.name}" already registered.`);
+        }
+        this.workflows.set(workflow.name, workflow);
+        for (const eventName of workflow.subscribedEvents) {
+            const list = this.workflowsByEvent.get(eventName) ?? [];
+            list.push(workflow);
+            this.workflowsByEvent.set(eventName, list);
+        }
+        this.ensureFireHook(workflow.name);
+    }
+    /** All registered workflow definitions, in registration order. */
+    listWorkflows() {
+        return [...this.workflows.values()];
+    }
+    /** Lazy-create the per-workflow `workflow.fire:<name>` hook. */
+    ensureFireHook(workflowName) {
+        let h = this.perWorkflowHooks.get(workflowName);
+        if (h)
+            return h;
+        h = hook(`workflow.fire:${workflowName}`);
+        this.perWorkflowHooks.set(workflowName, h);
+        return h;
+    }
+    /** Get-or-create the in-memory per-workflow instance store. */
+    instanceStore(workflowName) {
+        let store = this.workflowInstances.get(workflowName);
+        if (!store) {
+            store = new Map();
+            this.workflowInstances.set(workflowName, store);
+        }
+        return store;
+    }
+    /** Fire every workflow that subscribes to this event. */
+    async apply(event, envelope, correlationKeyOverride) {
+        const workflows = this.workflowsByEvent.get(event.eventName);
+        if (!workflows || workflows.length === 0)
+            return;
+        const appName = this.runtime.appName;
+        const log = loggerForEnvelope(this.runtime.logger, envelope).child({
+            event: event.eventName,
+        });
+        const baseEffects = this.buildEffects(envelope);
+        for (const workflow of workflows) {
+            const t0 = performance.now();
+            try {
+                const store = this.instanceStore(workflow.name);
+                const userKey = workflow.correlate?.(event) ?? "__default__";
+                const tenantPrefix = envelope.tenant ? `${envelope.tenant}::` : "";
+                const correlationKey = correlationKeyOverride ?? `${tenantPrefix}${userKey}`;
+                const fireCtx = {
+                    ...baseEffects,
+                    load: (key) => store.get(key),
+                    save: (key, instance) => store.set(key, instance),
+                    drop: (key) => store.delete(key),
+                    correlationKey,
+                    scheduleTimer: async (timerName, delay, payload) => {
+                        await this.timerStore.schedule({
+                            id: randomUUID(),
+                            workflowName: workflow.name,
+                            correlationKey,
+                            timerName,
+                            fireAt: new Date(Date.now() + parseDelay(delay)).toISOString(),
+                            payload,
+                        });
+                    },
+                };
+                const perWorkflowHook = this.perWorkflowHooks.get(workflow.name);
+                if (perWorkflowHook) {
+                    try {
+                        await perWorkflowHook.run({
+                            workflow,
+                            event,
+                            envelope,
+                            correlationKey,
+                        });
+                    }
+                    catch (err) {
+                        log.error(`workflow.fire hook threw`, {
+                            workflow: workflow.name,
+                            error: err?.message,
+                        });
+                    }
+                }
+                const retry = workflow.retry;
+                const maxAttempts = 1 + (retry?.max ?? 0);
+                let attempt = 0;
+                let lastError;
+                let fired = false;
+                let exhausted = false;
+                while (attempt < maxAttempts) {
+                    attempt++;
+                    try {
+                        if (attempt > 1) {
+                            const delay = computeBackoff(retry, attempt - 1);
+                            if (delay > 0)
+                                await sleep(delay);
+                        }
+                        await workflow._fire(event, fireCtx);
+                        fired = true;
+                        break;
+                    }
+                    catch (err) {
+                        lastError = err;
+                        const willRetry = attempt < maxAttempts;
+                        this.runtime.pushTelemetry({
+                            kind: "reaction.failed",
+                            sourceEvent: event.eventName,
+                            error: serializeError(err),
+                            envelope,
+                            appName,
+                            ts: new Date().toISOString(),
+                            workflow: workflow.name,
+                            attempt,
+                            maxAttempts,
+                            willRetry,
+                        });
+                        if (!willRetry && retry) {
+                            this.runtime.pushTelemetry({
+                                kind: "reaction.exhausted",
+                                workflow: workflow.name,
+                                sourceEvent: event.eventName,
+                                attempts: attempt,
+                                error: serializeError(err),
+                                envelope,
+                                appName,
+                                ts: new Date().toISOString(),
+                            });
+                            exhausted = true;
+                        }
+                    }
+                }
+                if (!fired) {
+                    void exhausted;
+                    if (lastError && typeof lastError === "object") {
+                        lastError.__nwireWorkflowEmitted = true;
+                    }
+                    throw lastError;
+                }
+                this.runtime.pushTelemetry({
+                    kind: "reaction.fired",
+                    sourceEvent: event.eventName,
+                    durationMs: performance.now() - t0,
+                    envelope,
+                    appName,
+                    ts: new Date().toISOString(),
+                });
+            }
+            catch (err) {
+                if (!err?.__nwireWorkflowEmitted) {
+                    this.runtime.pushTelemetry({
+                        kind: "reaction.failed",
+                        sourceEvent: event.eventName,
+                        error: serializeError(err),
+                        envelope,
+                        appName,
+                        ts: new Date().toISOString(),
+                        workflow: workflow.name,
+                    });
+                }
+                throw err;
+            }
+        }
+    }
+}