@nwire/forge 0.9.1 → 0.10.0

package/dist/{runtime.js → runtime/forge-dispatcher.js}

@@ -1,60 +1,45 @@
 /**
- * Runtime — the framework's dispatch + apply pipeline.
+ * `ForgeDispatcher` — the CQRS state container that forge layers on top of
+ * the kernel runtime.
  *
- * Responsibilities:
- *   1. Register actions, actors, handlers, and `when` reactions.
- *   2. `dispatch(action, input, envelope?)` — runs the action's handler,
- *      collects returned events, atomically: applies them to actors, runs
- *      reactions, schedules new timers, cancels old timers.
- *   3. `publish(events, envelope)` — runs the apply-actors-and-reactions step
- *      for events produced outside a handler (rare; mostly internal).
- *   4. `request(action, input)` — invoked from inside a handler to call
- *      another action with a derived child envelope. Returns the inner
- *      handler's result.
+ * Stage 1 of the forge-as-plugin refactor: pull all the registries, stores,
+ * and per-domain hook maps out of `forge.Runtime` into a single composable
+ * object. `forge.Runtime` keeps its public methods (`dispatch`, `publish`,
+ * `registerHandler`, etc.) and reads from this dispatcher; Stage 2 moves
+ * the methods here too and ships a `forgePlugin` that constructs a
+ * dispatcher and binds it into the container — at which point
+ * `forge.Runtime` disappears entirely and any `kernel.Runtime` becomes
+ * forge-capable by installing the plugin.
  *
- * The runtime owns commit atomicity:
- *   - All actor state changes from one event-publish either ALL persist or
- *     NONE persist (in-memory is naturally atomic; persistent stores rely
- *     on the adapter's transaction primitives).
- *   - Events fan out to actors first, then workflow reactions, then
- *     projections.
+ * The dispatcher holds a reference to its kernel `Runtime` so per-domain
+ * hooks can be created via `runtime.observe(h)` and telemetry pushed via
+ * `runtime.emit(rec)` without subclassing.
  */
+import { randomUUID } from "node:crypto";
+import { serializeError } from "@nwire/app";
 import { hook } from "@nwire/hooks";
-import { Runtime as RuntimeBase, serializeError, } from "@nwire/app";
 import { isValidated, markValidated } from "@nwire/messages";
 import { seedEnvelope, deriveEnvelope } from "@nwire/envelope";
-import { InMemoryWorkflowTimerStore, timerEventName, } from "./workflow-timer-store.js";
-import { randomUUID } from "node:crypto";
-import { InMemoryActorStore, createInitialInstance, ActorVersionConflictError, } from "./actor-store.js";
-import { normalizeEventReturn } from "./event-message.js";
-import { InMemoryProjectionStore } from "./projection-store.js";
-import { InMemoryIdempotencyStore } from "./idempotency-store.js";
 import { loggerForEnvelope } from "@nwire/logger";
-import { InMemoryDeadLetterSink, buildDeadLetterEntry, } from "@nwire/dead-letter";
-import { ActionDispatching, ActionCompleted, ActionFailed, builtInFrameworkEvents, } from "./framework-events.js";
-export class Runtime extends RuntimeBase {
+import { buildDeadLetterEntry, InMemoryDeadLetterSink } from "@nwire/dead-letter";
+import { sleep, computeBackoff, parseDelay } from "../helpers/retry-helpers.js";
+import { InMemoryActorStore, createInitialInstance, ActorVersionConflictError, } from "../stores/actor-store.js";
+import { InMemoryProjectionStore } from "../stores/projection-store.js";
+import { InMemoryIdempotencyStore } from "../stores/idempotency-store.js";
+import { InMemoryWorkflowTimerStore, timerEventName, } from "../stores/workflow-timer-store.js";
+import { normalizeEventReturn } from "../messages/event-message.js";
+export class ForgeDispatcher {
+    runtime;
+    // ─── Domain registries ──────────────────────────────────────────────
     handlers = new Map();
     actors = new Map();
-    /**
-     * Workflows keyed by event name. Built from each registered workflow's
-     * `subscribedEvents`. On publish, every workflow listening to an event
-     * gets `_fire`d with runtime-bound effects.
-     */
     workflowsByEvent = new Map();
     /**
      * Per-workflow instance state — keyed first by workflow name, then by
-     * correlation key. In-memory for slice 1; future adapters (Mongo, Redis)
-     * plug in via a WorkflowStore contract analogous to ActorStore.
+     * correlation key. In-memory for now; durable adapters plug in via a
+     * future WorkflowStore contract analogous to ActorStore.
      */
     workflowInstances = new Map();
-    workflowInstanceStore(workflowName) {
-        let store = this.workflowInstances.get(workflowName);
-        if (!store) {
-            store = new Map();
-            this.workflowInstances.set(workflowName, store);
-        }
-        return store;
-    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     projections = new Map();
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -65,187 +50,85 @@ export class Runtime extends RuntimeBase {
     externalCalls = new Map();
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     externalCallExecutors = new Map();
-    actorStore;
-    projectionStore;
-    deadLetterSink;
+    // ─── Per-domain hooks ───────────────────────────────────────────────
     /**
      * Per-action `action.before:<name>` hooks. Pre-created at
      * `registerHandler()` so they show up in `listHooks()` + scan + Studio
-     * even before any plugin's `before(name, …)` sugar runs. Adopted into
-     * the canonical telemetry stream so each chain step emits `hook.step`
-     * observations.
+     * even before any plugin's `before(name, …)` sugar runs. Observed into
+     * the canonical telemetry stream so each chain step emits `hook.step`.
      */
     actionBeforeHooks = new Map();
     /** Per-action `action.after:<name>` hooks. Pre-created identically. */
     actionAfterHooks = new Map();
-    /**
-     * Per-actor `actor.transition:<name>` hooks. Pre-created at
-     * `registerActor()` time. Adopted into the canonical telemetry stream
-     * so each chain step emits `hook.step` observations — same model as
-     * `actionBeforeHooks` / `actionAfterHooks`.
-     */
+    /** Per-actor `actor.transition:<name>` hooks. Pre-created at `registerActor()`. */
     perActorHooks = new Map();
-    /** Per-workflow `workflow.fire:<name>` hooks. Pre-created at registration. */
+    /** Per-workflow `workflow.fire:<name>` hooks. Pre-created at `registerWorkflow()`. */
     perWorkflowHooks = new Map();
+    /** Legacy plugin-supplied actor-transition listeners — runs after the per-actor hook. */
     actorTransitionHooks = [];
+    // ─── Persistence + cross-service seams ───────────────────────────────
+    actorStore;
+    projectionStore;
+    deadLetterSink;
+    idempotencyStore;
+    workflowTimerStore;
     bus;
     publishToBus;
-    /** Known external events — set by createApp from modules' needs.externalEvents. */
+    // ─── Module-derived metadata ────────────────────────────────────────
+    /** Known external events — populated by createApp from modules' needs.externalEvents. */
     externalEventNames = new Set();
-    /** Public-event names (visibility: 'public') — set by createApp from modules' events. */
+    /** Public-event names (visibility: 'public') — populated by createApp from modules' events. */
     publicEventNames = new Set();
-    /** Saga timer store (default in-memory; pluggable via RuntimeOptions). */
-    workflowTimerStore;
-    /** Envelope-level dedup table — see RuntimeOptions.idempotencyStore. */
-    idempotencyStore;
-    constructor(options = {}) {
-        // Container / logger / appName / frameworkEvents / dispatchHook / use /
-        // adoptHook / onTelemetry / offTelemetry / emit / getContainer are all
-        // owned by the base. Forge layers the CQRS engine on top.
-        super({
-            container: options.container,
-            logger: options.logger,
-            appName: options.appName,
-            events: builtInFrameworkEvents,
-        });
+    constructor(runtime, options = {}) {
+        this.runtime = runtime;
         this.actorStore = options.actorStore ?? new InMemoryActorStore();
         this.projectionStore = options.projectionStore ?? new InMemoryProjectionStore();
         this.deadLetterSink = options.deadLetterSink ?? new InMemoryDeadLetterSink();
+        this.idempotencyStore = options.idempotencyStore ?? new InMemoryIdempotencyStore();
+        this.workflowTimerStore = options.workflowTimerStore ?? new InMemoryWorkflowTimerStore();
         this.bus = options.bus;
         this.publishToBus = options.publishToBus ?? false;
-        this.workflowTimerStore = options.workflowTimerStore ?? new InMemoryWorkflowTimerStore();
-        this.idempotencyStore = options.idempotencyStore ?? new InMemoryIdempotencyStore();
-        // Pin the innermost dispatch step that calls forge's per-action retry +
-        // handler-invocation + event-publishing closure. priority `-Infinity`
-        // keeps user `runtime.use()` middleware strictly outside it.
-        this.dispatchHook.use(async (hctx, next) => {
-            hctx.result = await hctx.coreFn();
-            await next();
-        }, { name: "handler", priority: -Infinity });
     }
-    /**
-     * Tap into the canonical telemetry stream — narrowed to forge's widened
-     * `Telemetry` union. Delegates to the base `Runtime.onTelemetry` but
-     * locks the listener's record type to forge's CQRS-aware shape so
-     * `rec.kind === "event.published"` narrowing works for consumers.
-     */
-    onTelemetry(listener) {
-        return super.onTelemetry(listener);
-    }
-    offTelemetry(listener) {
-        super.offTelemetry(listener);
+    /** Get-or-create the per-workflow instance store. */
+    workflowInstanceStore(workflowName) {
+        let store = this.workflowInstances.get(workflowName);
+        if (!store) {
+            store = new Map();
+            this.workflowInstances.set(workflowName, store);
+        }
+        return store;
     }
+    // ─── Registration ──────────────────────────────────────────────────
     /**
-     * Register a dispatch middleware. Narrows the base `use(middleware)` to
-     * forge's tightened `DispatchMiddleware` shape so middleware authors
-     * see typed `action: ActionDefinition` / `ctx: HandlerContext`. The base
-     * runtime sees its `unknown`-typed shape; the cast is safe — every call
-     * site we control hands the same `(action, input, ctx)` triple forge's
-     * dispatcher pushes through `dispatchHook.run(...)`.
+     * Register a forge action handler (ActionDefinition + handler closure).
+     * Distinct from kernel.Runtime.registerHandler, which registers the
+     * canonical @nwire/handler HandlerDefinition. Forge actions carry
+     * retry + event-publishing metadata that the bare kernel doesn't know
+     * how to apply.
      */
-    use(middleware) {
-        super.use(middleware);
-    }
-    /** Internal — createApp registers known external event names. */
-    registerExternalEvent(eventName) {
-        this.externalEventNames.add(eventName);
-    }
-    /** Internal — createApp registers public event names (visibility: 'public'). */
-    registerPublicEvent(eventName) {
-        this.publicEventNames.add(eventName);
-    }
-    /** Internal — createApp registers actor-transition hooks from plugins. */
-    registerActorTransitionHook(hook) {
-        this.actorTransitionHooks.push(hook);
-    }
-    // ─── Registration ────────────────────────────────────────────────
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    registerHandler(handler) {
+    registerActionHandler(handler) {
         const name = handler.action.name;
         if (this.handlers.has(name)) {
             throw new Error(`Runtime: handler for action "${name}" already registered.`);
         }
         this.handlers.set(name, handler);
-        // Pre-create the per-action observation hooks so `listHooks()` + scan +
-        // Studio show every action's before/after extension points whether or
-        // not a plugin has subscribed yet. Lazy-on-first-subscribe would hide
-        // them from static introspection.
         this.ensureActionBeforeHook(name);
         this.ensureActionAfterHook(name);
     }
-    /**
-     * Get (or lazily create + adopt) the per-action `action.before:<name>`
-     * hook. Plugin authors normally reach this via `plugin.before(name, …)`;
-     * this method is also public so test code + custom orchestrators can
-     * register chain steps or taps directly.
-     */
-    ensureActionBeforeHook(actionName) {
-        let h = this.actionBeforeHooks.get(actionName);
-        if (h)
-            return h;
-        h = hook(`action.before:${actionName}`);
-        this.actionBeforeHooks.set(actionName, h);
-        this.adoptHook(h);
-        return h;
-    }
-    /** Get (or lazily create + adopt) the per-action `action.after:<name>` hook. */
-    ensureActionAfterHook(actionName) {
-        let h = this.actionAfterHooks.get(actionName);
-        if (h)
-            return h;
-        h = hook(`action.after:${actionName}`);
-        this.actionAfterHooks.set(actionName, h);
-        this.adoptHook(h);
-        return h;
-    }
-    /**
-     * Get (or lazily create + adopt) the per-actor `actor.transition:<name>`
-     * hook. Plugin authors reach this via `runtime.ensureActorTransitionHook(name)`
-     * to attach chain steps or taps; the dispatcher runs the hook after the
-     * actor's state has been saved.
-     */
-    ensureActorTransitionHook(actorName) {
-        let h = this.perActorHooks.get(actorName);
-        if (h)
-            return h;
-        h = hook(`actor.transition:${actorName}`);
-        this.perActorHooks.set(actorName, h);
-        this.adoptHook(h);
-        return h;
-    }
-    /**
-     * Get (or lazily create + adopt) the per-workflow `workflow.fire:<name>`
-     * hook. Runs around every workflow invocation triggered by a subscribed
-     * event — see `runWorkflows`.
-     */
-    ensureWorkflowFireHook(workflowName) {
-        let h = this.perWorkflowHooks.get(workflowName);
-        if (h)
-            return h;
-        h = hook(`workflow.fire:${workflowName}`);
-        this.perWorkflowHooks.set(workflowName, h);
-        this.adoptHook(h);
-        return h;
-    }
     registerActor(actor) {
         if (this.actors.has(actor.name)) {
             throw new Error(`Runtime: actor "${actor.name}" already registered.`);
         }
         this.actors.set(actor.name, actor);
-        // Pre-create the observation hook so scan + listHooks() + Studio see
-        // every actor's transition extension point even before any plugin
-        // subscribes.
         this.ensureActorTransitionHook(actor.name);
     }
-    /** Internal — createApp registers each module's workflows. */
     registerWorkflow(workflow) {
         for (const eventName of workflow.subscribedEvents) {
             const list = this.workflowsByEvent.get(eventName) ?? [];
             list.push(workflow);
             this.workflowsByEvent.set(eventName, list);
         }
-        // Same eager-creation rationale as registerActor — surface workflow
-        // fire extension points statically.
         this.ensureWorkflowFireHook(workflow.name);
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -267,11 +150,6 @@ export class Runtime extends RuntimeBase {
         }
         this.queries.set(query.name, query);
     }
-    /**
-     * Register an external-call declaration. Modules announce their external
-     * calls so Studio + the static graph see them; wires (adapters) call
-     * `registerExternalCallExecutor` to provide the transport.
-     */
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     registerExternalCall(def) {
         if (this.externalCalls.has(def.name)) {
@@ -279,24 +157,68 @@ export class Runtime extends RuntimeBase {
         }
         this.externalCalls.set(def.name, def);
     }
-    /**
-     * Bind an executor (HTTP client / SDK wrapper / test mock) to a declared
-     * external call. Lookup is by `def.name`. Called by wires/adapters at
-     * boot. Idempotent: re-registering replaces the executor (useful for
-     * swapping mocks in tests).
-     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     registerExternalCallExecutor(def, executor) {
         this.externalCallExecutors.set(def.name, executor);
     }
+    registerExternalEvent(eventName) {
+        this.externalEventNames.add(eventName);
+    }
+    registerPublicEvent(eventName) {
+        this.publicEventNames.add(eventName);
+    }
+    registerActorTransitionHook(listener) {
+        this.actorTransitionHooks.push(listener);
+    }
+    // ─── Per-domain hook factories ─────────────────────────────────────
+    /** Get-or-create the per-action `action.before:<name>` hook, observed for telemetry. */
+    ensureActionBeforeHook(actionName) {
+        let h = this.actionBeforeHooks.get(actionName);
+        if (h)
+            return h;
+        h = hook(`action.before:${actionName}`);
+        this.actionBeforeHooks.set(actionName, h);
+        this.runtime.observe(h);
+        return h;
+    }
+    ensureActionAfterHook(actionName) {
+        let h = this.actionAfterHooks.get(actionName);
+        if (h)
+            return h;
+        h = hook(`action.after:${actionName}`);
+        this.actionAfterHooks.set(actionName, h);
+        this.runtime.observe(h);
+        return h;
+    }
+    ensureActorTransitionHook(actorName) {
+        let h = this.perActorHooks.get(actorName);
+        if (h)
+            return h;
+        h = hook(`actor.transition:${actorName}`);
+        this.perActorHooks.set(actorName, h);
+        this.runtime.observe(h);
+        return h;
+    }
+    ensureWorkflowFireHook(workflowName) {
+        let h = this.perWorkflowHooks.get(workflowName);
+        if (h)
+            return h;
+        h = hook(`workflow.fire:${workflowName}`);
+        this.perWorkflowHooks.set(workflowName, h);
+        this.runtime.observe(h);
+        return h;
+    }
+    // ─── External calls ────────────────────────────────────────────────
     async executeExternalCall(def, request, envelope) {
         const validated = def.request.parse(request);
         const executor = this.externalCallExecutors.get(def.name);
         const idempotencyKey = def.idempotencyKey?.(validated);
         const target = `${def.target.provider}/${def.target.endpoint}`;
+        const appName = this.runtime.appName;
         if (!executor) {
             const err = new Error(`Runtime.externalCall: no executor registered for "${def.name}". ` +
                 `Wires/adapters must call runtime.registerExternalCallExecutor() at boot.`);
-            this.emit({
+            this.runtime.pushTelemetry({
                 kind: "external.call.failed",
                 call: def.name,
                 target,
@@ -304,7 +226,7 @@ export class Runtime extends RuntimeBase {
                 willRetry: false,
                 error: serializeError(err),
                 envelope,
-                appName: this.appName,
+                appName,
                 ts: new Date().toISOString(),
             });
             throw err;
@@ -315,13 +237,13 @@ export class Runtime extends RuntimeBase {
         let lastError;
         while (attempt < maxAttempts) {
             attempt++;
-            this.emit({
+            this.runtime.pushTelemetry({
                 kind: "external.call.started",
                 call: def.name,
                 target,
                 idempotencyKey,
                 envelope,
-                appName: this.appName,
+                appName,
                 ts: new Date().toISOString(),
             });
             const t0 = performance.now();
@@ -333,21 +255,21 @@ export class Runtime extends RuntimeBase {
                 }
                 const raw = await executor(validated, { idempotencyKey, attempt });
                 const response = def.response ? def.response.parse(raw) : raw;
-                this.emit({
+                this.runtime.pushTelemetry({
                     kind: "external.call.completed",
                     call: def.name,
                     target,
                     durationMs: performance.now() - t0,
                     idempotencyKey,
                     envelope,
-                    appName: this.appName,
+                    appName,
                     ts: new Date().toISOString(),
                 });
                 return response;
             }
             catch (err) {
                 lastError = err;
-                this.emit({
+                this.runtime.pushTelemetry({
                     kind: "external.call.failed",
                     call: def.name,
                     target,
@@ -355,14 +277,55 @@ export class Runtime extends RuntimeBase {
                     willRetry: attempt < maxAttempts,
                     error: serializeError(err),
                     envelope,
-                    appName: this.appName,
+                    appName,
                     ts: new Date().toISOString(),
                 });
             }
         }
         throw lastError;
     }
-    // ─── Query execution ─────────────────────────────────────────────
+    // ─── Introspection ──────────────────────────────────────────────────
+    listHandlers() {
+        return [...this.handlers.keys()];
+    }
+    listActors() {
+        return [...this.actors.keys()];
+    }
+    listProjections() {
+        return [...this.projections.keys()];
+    }
+    listQueries() {
+        return [...this.queries.keys()];
+    }
+    listExternalCalls() {
+        return [...this.externalCalls.keys()];
+    }
+    /** Deduplicated list of every registered workflow definition. */
+    listWorkflows() {
+        const seen = new Set();
+        for (const list of this.workflowsByEvent.values()) {
+            for (const w of list)
+                seen.add(w);
+        }
+        return [...seen];
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getExternalCall(name) {
+        return this.externalCalls.get(name);
+    }
+    /** Resolve a handler definition by action name. */
+    findHandler(name) {
+        return this.handlers.get(name);
+    }
+    /** Resolve an action by routing name — useful when only the name is known. */
+    findActionByName(name) {
+        return this.handlers.get(name)?.action;
+    }
+    /** Has a handler been registered for this action name? */
+    hasHandler(name) {
+        return this.handlers.has(name);
+    }
+    // ─── Query execution ────────────────────────────────────────────────
     async query(queryName, input, tenant = "") {
         const query = this.queries.get(queryName);
         if (!query) {
@@ -370,19 +333,17 @@ export class Runtime extends RuntimeBase {
         }
         const t0 = performance.now();
         const validated = isValidated(input) ? input : markValidated(query.schema.parse(input));
+        const container = this.runtime.getContainer();
+        const appName = this.runtime.appName;
         let result;
         if (query.projection && query.execute) {
-            // Projection form — load state, hand it to `execute`.
             const state = (await this.projectionStore.load(query.projection.name, tenant)) ??
                 query.projection.initial();
             result = (await query.execute(state, validated));
         }
         else if (query.handler) {
-            // Handler form — no projection, hand a QueryContext (DI + tenant +
-            // signal) to the user's reader. Lets queries read from any source
-            // (Postgres, Redis, search) without a projection layer.
             result = (await query.handler(validated, {
-                resolve: (name) => this.container.resolve(name),
+                resolve: (name) => container.resolve(name),
                 tenant,
             }));
         }
@@ -390,59 +351,21 @@ export class Runtime extends RuntimeBase {
             throw new Error(`Runtime: query "${queryName}" has neither projection+execute nor a handler — ` +
                 `the runtime cannot route the call. defineQuery must be given one or the other.`);
         }
-        this.emit({
+        this.runtime.pushTelemetry({
             kind: "query.executed",
             query: queryName,
             input: validated,
             durationMs: performance.now() - t0,
             tenant,
-            appName: this.appName,
+            appName,
             ts: new Date().toISOString(),
         });
         return result;
     }
-    // ─── Introspection ───────────────────────────────────────────────
-    getActorStore() {
-        return this.actorStore;
-    }
-    getProjectionStore() {
-        return this.projectionStore;
-    }
-    listHandlers() {
-        return [...this.handlers.keys()];
-    }
-    listActors() {
-        return [...this.actors.keys()];
-    }
-    listProjections() {
-        return [...this.projections.keys()];
-    }
-    listQueries() {
-        return [...this.queries.keys()];
-    }
-    listExternalCalls() {
-        return [...this.externalCalls.keys()];
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    getExternalCall(name) {
-        return this.externalCalls.get(name);
-    }
-    // ─── Timer firing (durable scheduler primitive) ──────────────────
-    /**
-     * Walk every registered actor's instances; for each `activeTimers[name]`
-     * with `fireAt <= now`, dispatch the timer's action. Removes fired timers
-     * from the instance's `activeTimers` map.
-     *
-     * Returns the count of timers that fired. Idempotent: a timer's `fireAt`
-     * is not bumped, so a second call after `now` advances will not re-fire
-     * the same timer (it was removed).
-     *
-     * For tests: pass `now` to fast-forward (`runtime.fireDueTimers(Date.now() + 3 * 86400_000)`).
-     * For production: a transport (BullMQ, polling worker) calls this on an
-     * interval; see `startTimerScheduler(app, intervalMs)` in `create-app.ts`.
-     */
+    // ─── Timer firing ──────────────────────────────────────────────────
     async fireDueTimers(now = Date.now()) {
         let fired = 0;
+        const appName = this.runtime.appName;
         for (const actor of this.actors.values()) {
             const instances = await this.actorStore.listInstances(actor.name);
             for (const instance of instances) {
@@ -454,30 +377,18 @@ export class Runtime extends RuntimeBase {
                 }
                 if (due.length === 0)
                     continue;
-                // Remove fired timers BEFORE dispatching, so handlers that
-                // re-enter `fireDueTimers` (rare but possible) don't see them.
                 const remainingTimers = {};
                 for (const [name, handle] of Object.entries(instance.activeTimers)) {
                     if (handle.fireAt > now)
                         remainingTimers[name] = handle;
                 }
-                await this.actorStore.save({
-                    ...instance,
-                    activeTimers: remainingTimers,
-                });
-                // Dispatch each fired timer's action in the actor's tenant
-                // scope so the handler chain stays inside the right partition.
-                const tenantEnvelope = seedEnvelope({
-                    tenant: instance.tenant || undefined,
-                });
+                await this.actorStore.save({ ...instance, activeTimers: remainingTimers });
+                const tenantEnvelope = seedEnvelope({ tenant: instance.tenant || undefined });
                 for (const [timerName, handle] of due) {
                     const action = this.findActionByName(handle.action);
-                    if (!action) {
-                        // Action not registered — skip gracefully; the timer
-                        // fired but its target is gone.
+                    if (!action)
                         continue;
-                    }
-                    this.emit({
+                    this.runtime.pushTelemetry({
                         kind: "timer.fired",
                         actor: actor.name,
                         key: instance.key,
@@ -485,7 +396,7 @@ export class Runtime extends RuntimeBase {
                         action: handle.action,
                         lateByMs: Math.max(0, now - handle.fireAt),
                         tenant: instance.tenant,
-                        appName: this.appName,
+                        appName,
                         ts: new Date().toISOString(),
                     });
                     await this.dispatch(action, handle.input, tenantEnvelope);
@@ -495,100 +406,48 @@ export class Runtime extends RuntimeBase {
         }
         return fired;
     }
-    /**
-     * Resolve an action definition by its routing name. Used by execute/send
-     * to support the callable form `execute(myAction(input))` — the
-     * `CommandMessage` carries only the name; the runtime looks up the actual
-     * action from the registered handler map.
-     */
-    findActionByName(name) {
-        const handler = this.handlers.get(name);
-        return handler?.action;
-    }
-    /**
-     * Drain every due saga timer from the workflow timer store and route
-     * each as a synthetic event back into the originating workflow. The
-     * store removes drained timers atomically (see `WorkflowTimerStore`
-     * contract); calling `fireDueWorkflowTimers` twice with the same `now`
-     * MUST be a no-op the second time.
-     *
-     * Returns the count of timers fired.
-     *
-     * Tests: pass `now` to fast-forward
-     * (`runtime.fireDueWorkflowTimers(new Date(Date.now() + 8 * 86400_000))`).
-     * Production: the same polling loop that calls `fireDueTimers` calls
-     * this — they share the timer tick infrastructure.
-     */
     async fireDueWorkflowTimers(now = new Date()) {
         let fired = 0;
         const envelope = seedEnvelope({});
         for await (const timer of this.workflowTimerStore.drainDue(now)) {
-            // Synthesize an event so the standard `runWorkflows` path handles
-            // routing. The event name is the canonical timer name; the payload
-            // carries through what `schedule()` was called with.
-            //
-            // Critical: the timer record carries the originating saga's
-            // `correlationKey`. We must thread it through so the workflow loads
-            // the right instance (the one that scheduled the timer) — not a
-            // fresh "__default__" instance. The synthetic timer event has no
-            // shape the user's `correlate()` map can recognize.
             const eventName = timerEventName(timer.workflowName, timer.timerName);
             await this.runWorkflows({ eventName, payload: timer.payload }, envelope, timer.correlationKey);
             fired++;
         }
         return fired;
     }
-    // ─── Dispatch ────────────────────────────────────────────────────
-    /**
-     * Run an action through its handler, then atomically apply returned events.
-     * Returns the handler's raw return value (events) for callers that want it.
-     */
+    // ─── Dispatch ──────────────────────────────────────────────────────
     async dispatch(action, input, parentEnvelope, opts) {
         const handler = this.handlers.get(action.name);
         if (!handler) {
             throw new Error(`Runtime: no handler registered for action "${action.name}".`);
         }
+        const appName = this.runtime.appName;
         const envelope = parentEnvelope ? deriveEnvelope(parentEnvelope) : seedEnvelope({});
-        // Skip re-parse if a trust boundary already validated this input
-        // (HTTP `parseAndValidate`, queue worker consume, bus inbound).
-        // Untrusted call sites (raw object from application code) hit the
-        // parse path because the brand is missing. The brand is dropped by
-        // serialization, structural copy, and primitive coercion — so it
-        // never produces a false "trust me."
         const validated = isValidated(input) ? input : markValidated(action.schema.parse(input));
-        const log = loggerForEnvelope(this.logger, envelope);
-        // Caller-side cancellation: every dispatch carries an AbortSignal on
-        // ctx. When the caller doesn't supply one, we mint a never-aborted
-        // controller so handler code can call `ctx.signal.throwIfAborted()`
-        // unconditionally — existing handlers behave identically.
+        const log = loggerForEnvelope(this.runtime.logger, envelope);
         const signal = opts?.signal ?? new AbortController().signal;
         const ctx = this.buildHandlerContext(envelope, log, signal);
-        this.emit({
+        this.runtime.pushTelemetry({
             kind: "action.dispatched",
             action: action.name,
             input: validated,
             envelope,
-            appName: this.appName,
+            appName,
             ts: new Date().toISOString(),
         });
         const startedAt = performance.now();
-        // Framework event: ActionDispatching — interceptable. A subscriber
-        // returning `false` cleanly cancels the dispatch (no throw, no events,
-        // empty handler return). Throwing from a subscriber fails the dispatch
-        // as if the handler itself threw.
-        const dispatchAllowed = await this.frameworkEvents.fire(ActionDispatching, {
+        const dispatchResult = await this.runtime.hooks.ActionDispatching.runDetailed({
             action,
             input: validated,
             ctx,
         });
-        if (!dispatchAllowed) {
+        if (dispatchResult.outcome === "failed") {
+            throw dispatchResult.error;
+        }
+        if (dispatchResult.outcome !== "completed") {
             return undefined;
         }
-        // Per-action `action.before:<name>` hook. Mirrors the ActionDispatching
-        // veto semantics but routes through a named hook so the chain is visible
-        // in `listHooks()`, scan, and Studio. Chain steps registered via the
-        // `plugin.before(name, …)` sugar set `vetoed = true` when their handler
-        // returns false; that cleanly cancels the dispatch with no events.
         const beforeHook = this.actionBeforeHooks.get(action.name);
         if (beforeHook) {
             const beforeCtx = { action, input: validated, ctx };
@@ -597,10 +456,6 @@ export class Runtime extends RuntimeBase {
                 return undefined;
             }
         }
-        // Core: retry loop + handler invocation + event publishing.
-        // Returns the raw handler return for the dispatcher to type-cast. The
-        // return union mirrors `HandlerReturn` — plain records (e.g. `{ userId }`)
-        // surface here untouched so the dispatcher can hand them back to callers.
         const core = async () => {
             const retry = action.retry;
             const maxAttempts = 1 + (retry?.max ?? 0);
@@ -608,12 +463,6 @@ export class Runtime extends RuntimeBase {
             let lastError;
             while (attempt < maxAttempts) {
                 attempt++;
-                // Caller already gave up — skip remaining retries (and the DLQ
-                // entry that would follow exhaustion). The original error still
-                // surfaces to whatever is `await`ing the dispatch, but we don't
-                // spend retry budget on a result no one will read. We re-throw
-                // outside the inner try so the catch's failed/DLQ telemetry does
-                // not fire for the skipped attempts.
                 if (attempt > 1 && signal.aborted) {
                     log.warn(`abort observed between attempts; skipping retries`, {
                         action: action.name,
@@ -641,20 +490,15 @@ export class Runtime extends RuntimeBase {
                         await this.publish(events, envelope);
                     }
                     const durationMs = performance.now() - startedAt;
-                    this.emit({
+                    this.runtime.pushTelemetry({
                         kind: "action.completed",
                         action: action.name,
                         durationMs,
                         emittedEvents: events.map((e) => e.eventName),
                         envelope,
-                        appName: this.appName,
+                        appName,
                         ts: new Date().toISOString(),
                     });
-                    // Per-action `action.after:<name>` hook. Observation-only —
-                    // chain steps registered by `plugin.after(name, …)` see the
-                    // result + durationMs but can't undo. Awaited so `hook.step`
-                    // taps land in telemetry before the action returns, the way
-                    // the dispatch hook's taps already do.
                     const afterHook = this.actionAfterHooks.get(action.name);
                     if (afterHook) {
                         try {
@@ -672,9 +516,7 @@ export class Runtime extends RuntimeBase {
                             });
                         }
                     }
-                    // Framework event: ActionCompleted (parallel, observable).
-                    // Don't await — observers shouldn't block the response path.
-                    void this.frameworkEvents.fire(ActionCompleted, {
+                    void this.runtime.hooks.ActionCompleted.run({
                         action,
                         input: validated,
                         result: rawResult ?? undefined,
@@ -690,7 +532,7 @@ export class Runtime extends RuntimeBase {
                         maxAttempts,
                         error: err?.message,
                     });
-                    this.emit({
+                    this.runtime.pushTelemetry({
                         kind: "action.failed",
                         action: action.name,
                         attempt,
@@ -698,14 +540,11 @@ export class Runtime extends RuntimeBase {
                         willRetry: attempt < maxAttempts,
                         error: serializeError(err),
                         envelope,
-                        appName: this.appName,
+                        appName,
                         ts: new Date().toISOString(),
                     });
                     if (attempt >= maxAttempts) {
-                        // Final failure — fire ActionFailed exactly once (not per
-                        // retry attempt; the observable view is "this dispatch failed",
-                        // not "the n-th attempt threw"). Parallel + non-awaited.
-                        void this.frameworkEvents.fire(ActionFailed, {
+                        void this.runtime.hooks.ActionFailed.run({
                             action,
                             input: validated,
                             error: err,
@@ -714,122 +553,80 @@ export class Runtime extends RuntimeBase {
                     }
                 }
             }
-            // All attempts failed → dead-letter and re-raise.
             const entry = buildDeadLetterEntry(action.name, validated, envelope, attempt, lastError);
             await this.deadLetterSink.record(entry);
             log.error(`dead-lettered after ${attempt} attempts`, {
                 action: action.name,
                 error: entry.lastError.message,
             });
-            this.emit({
+            this.runtime.pushTelemetry({
                 kind: "dlq.recorded",
                 action: action.name,
                 attempts: attempt,
                 error: serializeError(lastError),
                 envelope,
-                appName: this.appName,
+                appName,
                 ts: new Date().toISOString(),
             });
             throw lastError;
         };
-        // Run through the dispatch hook. Every user-registered middleware sits
-        // outside the pinned "handler" chain step (-Infinity); the hook calls
-        // `coreFn` in that innermost step and writes the result back on hctx.
-        // Taps fire per step into runtime.onTelemetry as `kind: "hook.step"`.
         const hctx = { action, input: validated, ctx, coreFn: core };
-        await this.dispatchHook.run(hctx);
+        await this.runtime.dispatchHook$.run(hctx);
         return hctx.result;
     }
-    /**
-     * Apply a batch of events: route to actors (state transitions + assigns +
-     * timer scheduling), fold projections, then fire workflows. Used internally
-     * by `dispatch` and exposed for tests and rare external publishes.
-     */
+    // ─── Publish + applyExternalEvent ──────────────────────────────────
     async publish(events, parentEnvelope) {
+        const appName = this.runtime.appName;
         for (let i = 0; i < events.length; i++) {
             const event = events[i];
-            // Envelope-level idempotency: short-circuit when we've already
-            // applied this exact `messageId`. The dedup key is the PARENT
-            // envelope's id — that's the identity a queue/bus driver carries
-            // through verbatim on redelivery, and the identity a caller
-            // can pin to make two publish() calls share a fate. When more than
-            // one event ships under the same parent envelope we tag the
-            // dedup key with the event index so each one applies on the
-            // first delivery and dedups on the second.
             const dedupKey = events.length === 1 ? parentEnvelope.messageId : `${parentEnvelope.messageId}#${i}`;
             const childEnvelope = deriveEnvelope(parentEnvelope);
             if (await this.idempotencyStore.seen(dedupKey)) {
-                this.emit({
+                this.runtime.pushTelemetry({
                     kind: "event.deduped",
                     event,
                     envelope: childEnvelope,
                     source: "in-process",
-                    appName: this.appName,
+                    appName,
                     ts: new Date().toISOString(),
                 });
                 continue;
             }
             await this.idempotencyStore.record(dedupKey);
-            // Ordering: actors → projections → workflows.
-            //   - actors first: state must be coherent before observers see it.
-            //   - projections second: workflows often read state via queries
-            //     (`ctx.request(query, ...)`), and chained dispatches via
-            //     `ctx.request(action, ...)` will themselves fold projections —
-            //     we must avoid stale reads, so projections fold before any
-            //     workflow-triggered chain begins.
-            //   - workflows last. Workflows produced events (translator pattern)
-            //     publish recursively through this same method, so the full
-            //     pipeline applies to derived events too.
             await this.applyToActors(event, childEnvelope);
             await this.foldProjections(event, childEnvelope);
             await this.runWorkflows(event, childEnvelope);
-            // Telemetry tap — emit `event.published` after committed apply.
-            this.emit({
+            this.runtime.pushTelemetry({
                 kind: "event.published",
                 event,
                 envelope: childEnvelope,
                 source: "in-process",
-                appName: this.appName,
+                appName,
                 ts: new Date().toISOString(),
             });
-            // Cross-service fan-out: send public events to the bus AFTER the
-            // in-process apply succeeded. Subscribers in other services will
-            // call `applyExternalEvent` on their own runtime. Internal events
-            // (visibility: 'internal') stay in-process — explicit gate.
             if (this.publishToBus && this.bus && this.publicEventNames.has(event.eventName)) {
                 await this.bus.publish({
                     eventName: event.eventName,
                     payload: event.payload,
                     envelope: childEnvelope,
-                    origin: this.appName,
+                    origin: appName,
                 });
             }
         }
     }
-    /**
-     * Apply an event that arrived from the cross-service bus. Same pipeline
-     * as `publish` (actors → projections → workflows) but does NOT re-publish
-     * to the bus — avoids fan-out loops between services. The runtime tracks
-     * which event names it declared as external (via createApp's wiring of
-     * modules' `needs.externalEvents`); calls for other names throw to catch
-     * misconfigured subscriptions early.
-     */
     async applyExternalEvent(eventName, payload, envelope) {
         if (!this.externalEventNames.has(eventName)) {
             throw new Error(`Runtime.applyExternalEvent: "${eventName}" was not declared in any module's needs.externalEvents.`);
         }
+        const appName = this.runtime.appName;
         const event = { eventName, payload };
-        // Bus inbound dedup mirrors the in-process publish path: a queue
-        // redrive or bus replay carries the same `envelope.messageId`,
-        // so an identical second delivery short-circuits without touching
-        // actor or projection state.
         if (await this.idempotencyStore.seen(envelope.messageId)) {
-            this.emit({
+            this.runtime.pushTelemetry({
                 kind: "event.deduped",
                 event,
                 envelope,
                 source: "external",
-                appName: this.appName,
+                appName,
                 ts: new Date().toISOString(),
             });
             return;
@@ -838,20 +635,22 @@ export class Runtime extends RuntimeBase {
         await this.applyToActors(event, envelope);
         await this.foldProjections(event, envelope);
         await this.runWorkflows(event, envelope);
-        this.emit({
+        this.runtime.pushTelemetry({
             kind: "event.published",
             event,
             envelope,
             source: "external",
-            appName: this.appName,
+            appName,
             ts: new Date().toISOString(),
         });
     }
+    // ─── Projection folding ────────────────────────────────────────────
     async foldProjections(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)
@@ -861,24 +660,19 @@ export class Runtime extends RuntimeBase {
                 const current = (await this.projectionStore.load(projection.name, tenant)) ?? projection.initial();
                 const next = reducer(current, event.payload);
                 await this.projectionStore.save(projection.name, next, tenant);
-                this.emit({
+                this.runtime.pushTelemetry({
                     kind: "projection.folded",
                     projection: projection.name,
                     event: event.eventName,
                     tenant,
                     durationMs: performance.now() - t0,
                     envelope,
-                    appName: this.appName,
+                    appName,
                     ts: new Date().toISOString(),
                 });
             }
             catch (err) {
-                // Fold failed — surface a first-class telemetry record so
-                // observability can alarm on projection drift directly (gap 4).
-                // We re-throw so the surrounding apply path still fails fast;
-                // the only behavior change is that consumers no longer have to
-                // deduce drift from missing `projection.folded` records.
-                this.emit({
+                this.runtime.pushTelemetry({
                     kind: "projection.failed",
                     projection: projection.name,
                     event: event.eventName,
@@ -886,14 +680,14 @@ export class Runtime extends RuntimeBase {
                     durationMs: performance.now() - t0,
                     error: serializeError(err),
                     envelope,
-                    appName: this.appName,
+                    appName,
                     ts: new Date().toISOString(),
                 });
                 throw err;
             }
         }
     }
-    // ─── Internal: actor dispatch ────────────────────────────────────
+    // ─── Actor dispatch (internal) ─────────────────────────────────────
     async applyToActors(event, envelope) {
         const tenant = envelope.tenant ?? "";
         for (const actor of this.actors.values()) {
@@ -901,10 +695,8 @@ export class Runtime extends RuntimeBase {
             if (!reactionsForEvent || reactionsForEvent.length === 0)
                 continue;
             const key = this.extractKey(event, actor);
-            if (key === undefined || key === null) {
-                // Event doesn't carry this actor's key — not addressed to it.
+            if (key === undefined || key === null)
                 continue;
-            }
             await this.applyEventToActor(actor, String(key), tenant, event, reactionsForEvent, envelope);
         }
     }
@@ -915,12 +707,6 @@ export class Runtime extends RuntimeBase {
         return payload[actor.key];
     }
     async applyEventToActor(actor, key, tenant, event, candidateReactions, envelope) {
-        // Per-(actor, key, tenant) lock around the load → reduce → save
-        // window. Without it, two concurrent dispatches racing for the same
-        // actor key both observe the same pre-state and the second save
-        // wins — silent invariant loss. Production adapters (Mongo, SQL)
-        // should treat lockKey as a no-op and rely on row-level locks; the
-        // in-memory store needs it explicitly.
         const release = (await this.actorStore.lockKey?.(actor.name, key, tenant)) ?? (() => { });
         try {
             await this.applyEventToActorLocked(actor, key, tenant, event, candidateReactions, envelope);
@@ -930,23 +716,17 @@ export class Runtime extends RuntimeBase {
         }
     }
     async applyEventToActorLocked(actor, key, tenant, event, candidateReactions, envelope) {
+        const appName = this.runtime.appName;
         const maxOccRetries = 3;
         for (let occAttempt = 0; occAttempt < maxOccRetries; occAttempt++) {
             const existing = await this.actorStore.load(actor.name, key, tenant);
             const instance = existing ?? createInitialInstance(actor, key, tenant);
             const matching = candidateReactions.find((c) => c.state === instance.state);
-            if (!matching) {
-                // Actor is in a state that doesn't react to this event — silently
-                // skip. (Future: dead-letter / log; surfacing here is too noisy for
-                // events that fan out to many actors, only some of which match.)
+            if (!matching)
                 return;
-            }
             const stateConfig = actor.states[instance.state];
-            if (stateConfig?.final) {
-                // Defensive: a final state shouldn't have entries in eventIndex,
-                // but guard anyway.
+            if (stateConfig?.final)
                 return;
-            }
             const partial = matching.reaction.assign
                 ? matching.reaction.assign(instance.data, event.payload)
                 : {};
@@ -956,14 +736,9 @@ export class Runtime extends RuntimeBase {
             if (!nextStateConfig) {
                 throw new Error(`Runtime: actor "${actor.name}" reaction targets undeclared state "${nextStateName}" from "${instance.state}".`);
             }
-            // Schema validation on save — invalid partial → throw, atomically
-            // skip persistence, re-raise to caller.
             const validated = actor.schema.parse(nextData);
             const stateChanged = nextStateName !== instance.state;
             const isNewActor = !existing;
-            // Timers are owned by a state, not the actor. Compute them on:
-            //   - state change (cancel old, schedule new), or
-            //   - actor creation (born into a state — schedule its timers).
             const nextTimers = stateChanged || isNewActor
                 ? this.computeTimersForState(actor, nextStateName, key)
                 : instance.activeTimers;
@@ -980,13 +755,12 @@ export class Runtime extends RuntimeBase {
                 await this.actorStore.save(nextInstance, { expectedVersion: instance.version });
             }
             catch (err) {
-                if (err instanceof ActorVersionConflictError && occAttempt < maxOccRetries - 1) {
+                if (err instanceof ActorVersionConflictError && occAttempt < maxOccRetries - 1)
                     continue;
-                }
                 throw err;
             }
             if (stateChanged) {
-                this.emit({
+                this.runtime.pushTelemetry({
                     kind: "actor.transitioned",
                     actor: actor.name,
                     key,
@@ -995,22 +769,15 @@ export class Runtime extends RuntimeBase {
                     to: nextStateName,
                     triggeringEvent: event.eventName,
                     envelope,
-                    appName: this.appName,
+                    appName,
                     ts: new Date().toISOString(),
                 });
             }
-            // Fire actor-transition hooks (registered by plugins). Hooks run AFTER
-            // the save so they observe committed state. Errors propagate — plugins
-            // are infrastructure; we want loud failures, not silent skips.
             if (this.actorTransitionHooks.length > 0 && stateChanged) {
-                for (const hook of this.actorTransitionHooks) {
-                    await hook(actor, key, instance.state, nextStateName, event, envelope);
+                for (const hookFn of this.actorTransitionHooks) {
+                    await hookFn(actor, key, instance.state, nextStateName, event, envelope);
                 }
             }
-            // Per-actor `actor.transition:<name>` hook — named, observable in
-            // listHooks(), tap-able by plugins via runtime.ensureActorTransitionHook.
-            // Runs only on actual transitions (state changed) so observers don't
-            // see no-op events.
             if (stateChanged) {
                 const perActorHook = this.perActorHooks.get(actor.name);
                 if (perActorHook) {
@@ -1025,7 +792,7 @@ export class Runtime extends RuntimeBase {
                         });
                     }
                     catch (err) {
-                        loggerForEnvelope(this.logger, envelope).error(`actor.transition hook threw`, {
+                        loggerForEnvelope(this.runtime.logger, envelope).error(`actor.transition hook threw`, {
                             actor: actor.name,
                             error: err?.message,
                         });
@@ -1039,6 +806,7 @@ export class Runtime extends RuntimeBase {
         const stateConfig = actor.states[stateName];
         if (!stateConfig?.after)
             return {};
+        const appName = this.runtime.appName;
         const now = Date.now();
         const timers = {};
         for (const [timerName, spec] of Object.entries(stateConfig.after)) {
@@ -1054,7 +822,7 @@ export class Runtime extends RuntimeBase {
                 input,
             };
             timers[timerName] = handle;
-            this.emit({
+            this.runtime.pushTelemetry({
                 kind: "timer.scheduled",
                 actor: actor.name,
                 key: actorKey,
@@ -1062,34 +830,19 @@ export class Runtime extends RuntimeBase {
                 action,
                 fireAt: handle.fireAt,
                 tenant: "",
-                appName: this.appName,
+                appName,
                 ts: new Date().toISOString(),
             });
         }
         return timers;
     }
-    // ─── Internal: workflows ─────────────────────────────────────────
-    /**
-     * Fire every workflow subscribed to `event`. Each workflow receives a
-     * runtime-bound effects bag: `send`/`enqueue` go through `dispatch` for
-     * retry + telemetry parity with action handlers; `publish` goes back
-     * through `this.publish` so derived events flow through the full
-     * actors → projections → workflows pipeline (translator pattern).
-     *
-     * Telemetry emits as `workflow.fired` / `workflow.failed`.
-     */
-    async runWorkflows(event, envelope, 
-    /**
-     * Optional override for correlationKey. Used by `fireDueWorkflowTimers`
-     * to route a synthetic timer event back to the saga instance that
-     * scheduled it — `workflow.correlate(event)` can't determine the key
-     * from a synthetic timer payload alone.
-     */
-    correlationKeyOverride) {
+    // ─── Workflows (internal) ──────────────────────────────────────────
+    async runWorkflows(event, envelope, correlationKeyOverride) {
         const workflows = this.workflowsByEvent.get(event.eventName);
         if (!workflows || workflows.length === 0)
             return;
-        const log = loggerForEnvelope(this.logger, envelope).child({
+        const appName = this.runtime.appName;
+        const log = loggerForEnvelope(this.runtime.logger, envelope).child({
             event: event.eventName,
         });
         const handlerCtx = this.buildHandlerContext(envelope, log);
@@ -1109,11 +862,6 @@ export class Runtime extends RuntimeBase {
             const t0 = performance.now();
             try {
                 const store = this.workflowInstanceStore(workflow.name);
-                // Workflow correlation MUST include the tenant axis. Without it,
-                // two tenants with the same business key (e.g. subscriptionId)
-                // share a saga instance — the second tenant's PaymentFailed sees
-                // the first tenant's state. The override path (from timer fires)
-                // already carries tenant context; only derive when no override.
                 const userKey = workflow.correlate?.(event) ?? "__default__";
                 const tenantPrefix = envelope.tenant ? `${envelope.tenant}::` : "";
                 const correlationKey = correlationKeyOverride ?? `${tenantPrefix}${userKey}`;
@@ -1134,12 +882,6 @@ export class Runtime extends RuntimeBase {
                         });
                     },
                 };
-                // Per-workflow `workflow.fire:<name>` hook — observation-only.
-                // Runs BEFORE the saga fires so chain steps see input + context;
-                // failures here are logged, never block the saga. Chain steps
-                // intending to gate workflow execution should subscribe to the
-                // `WorkflowFiring` framework event (future surface) — the hook
-                // is for telemetry + drift detection.
                 const perWorkflowHook = this.perWorkflowHooks.get(workflow.name);
                 if (perWorkflowHook) {
                     try {
@@ -1157,14 +899,6 @@ export class Runtime extends RuntimeBase {
                         });
                     }
                 }
-                // Honor the workflow's retry policy around `_fire`. Without a
-                // declared policy, the historical contract holds: one attempt,
-                // failure emits `reaction.failed` and re-raises. With a policy,
-                // we retry per the same back-off math the action dispatch loop
-                // uses; each failure emits `reaction.failed` with attempt info,
-                // and the FINAL failure additionally emits `reaction.exhausted`
-                // so alarms can fire on saga death distinctly from transient
-                // drift.
                 const retry = workflow.retry;
                 const maxAttempts = 1 + (retry?.max ?? 0);
                 let attempt = 0;
@@ -1186,12 +920,12 @@ export class Runtime extends RuntimeBase {
                     catch (err) {
                         lastError = err;
                         const willRetry = attempt < maxAttempts;
-                        this.emit({
+                        this.runtime.pushTelemetry({
                             kind: "reaction.failed",
                             sourceEvent: event.eventName,
                             error: serializeError(err),
                             envelope,
-                            appName: this.appName,
+                            appName,
                             ts: new Date().toISOString(),
                             workflow: workflow.name,
                             attempt,
@@ -1199,19 +933,14 @@ export class Runtime extends RuntimeBase {
                             willRetry,
                         });
                         if (!willRetry && retry) {
-                            // Only fire `reaction.exhausted` when retry was actually
-                            // declared — otherwise a one-shot failure (no policy) is
-                            // semantically just "the saga threw," not "the saga
-                            // burned through its retry budget." Alarms should target
-                            // the policy-aware signal.
-                            this.emit({
+                            this.runtime.pushTelemetry({
                                 kind: "reaction.exhausted",
                                 workflow: workflow.name,
                                 sourceEvent: event.eventName,
                                 attempts: attempt,
                                 error: serializeError(err),
                                 envelope,
-                                appName: this.appName,
+                                appName,
                                 ts: new Date().toISOString(),
                             });
                             exhausted = true;
@@ -1219,38 +948,29 @@ export class Runtime extends RuntimeBase {
                     }
                 }
                 if (!fired) {
-                    // Mark so the outer catch knows the loop already emitted
-                    // `reaction.failed` for this failure — avoids double-emit.
-                    // `exhausted` is unused for marking; the loop emits one
-                    // `reaction.failed` per attempt regardless of policy.
                     void exhausted;
                     if (lastError && typeof lastError === "object") {
                         lastError.__nwireWorkflowEmitted = true;
                     }
                     throw lastError;
                 }
-                this.emit({
+                this.runtime.pushTelemetry({
                     kind: "reaction.fired",
                     sourceEvent: event.eventName,
                     durationMs: performance.now() - t0,
                     envelope,
-                    appName: this.appName,
+                    appName,
                     ts: new Date().toISOString(),
                 });
             }
             catch (err) {
-                // The retry loop above already emitted `reaction.failed` for
-                // every saga-body failure. If we see one tagged with the
-                // internal marker, the loop owns the telemetry — skip the
-                // duplicate emission here. Anything untagged (correlate() throws,
-                // hook bug, etc.) lands as a single bare `reaction.failed`.
                 if (!err?.__nwireWorkflowEmitted) {
-                    this.emit({
+                    this.runtime.pushTelemetry({
                         kind: "reaction.failed",
                         sourceEvent: event.eventName,
                         error: serializeError(err),
                         envelope,
-                        appName: this.appName,
+                        appName,
                         ts: new Date().toISOString(),
                         workflow: workflow.name,
                     });
@@ -1259,22 +979,19 @@ export class Runtime extends RuntimeBase {
             }
         }
     }
-    // ─── Internal: handler context ───────────────────────────────────
+    // ─── Handler context (internal) ────────────────────────────────────
     buildHandlerContext(envelope, log, signal) {
         const self = this;
-        const logger = log ?? loggerForEnvelope(self.logger, envelope);
-        // Child dispatches inherit the parent's signal so a caller-side abort
-        // travels through every nested `ctx.request(...)`. The runtime never
-        // mutates the incoming signal — handlers observe; the wire owns the
-        // controller.
+        const container = this.runtime.getContainer();
+        const logger = log ?? loggerForEnvelope(this.runtime.logger, envelope);
         const ctxSignal = signal ?? new AbortController().signal;
         const ctx = {
-            container: self.container,
+            container,
             envelope,
             logger,
             signal: ctxSignal,
             resolve(name) {
-                return self.container.resolve(name);
+                return container.resolve(name);
             },
             get requestId() {
                 return envelope.messageId;
@@ -1289,8 +1006,6 @@ export class Runtime extends RuntimeBase {
                 return self.query(queryDef.name, input, envelope.tenant ?? "");
             },
             async send(action, input) {
-                // For now, send is identical to request but result is ignored.
-                // Real fire-and-forget arrives with the queue transport.
                 await self.dispatch(action, input, envelope, { signal: ctxSignal });
             },
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -1303,16 +1018,13 @@ export class Runtime extends RuntimeBase {
         };
         return ctx;
     }
-    // ─── Internal: actor view (ctx.use) ──────────────────────────────
+    // ─── Actor view (ctx.use) ──────────────────────────────────────────
     async loadActorView(actor, id, envelope) {
         if (!this.actors.has(actor.name)) {
             throw new Error(`Runtime.use: actor "${actor.name}" is not registered. ` +
                 `Add it to a module's manifest.actors and pass that module to createApp.`);
         }
         const loaded = await this.actorStore.load(actor.name, id, envelope.tenant ?? "");
-        // Virgin instance — let `create` methods bootstrap a new actor.
-        // The bootstrap event flows through the actor's `on` transitions and
-        // populates state for subsequent dispatches.
         const instance = loaded ?? {
             name: actor.name,
             key: id,
@@ -1328,8 +1040,6 @@ export class Runtime extends RuntimeBase {
             key: instance.key,
             stateName: instance.state,
         };
-        // Closure-form actor: bind methods via the closure binder. recordThat
-        // calls accumulate events; we publish them after each method call.
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const closureBinder = actor.closureBinder;
         if (closureBinder) {
@@ -1337,8 +1047,6 @@ export class Runtime extends RuntimeBase {
             for (const [methodName, fn] of Object.entries(bound.methods)) {
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 view[methodName] = async (...args) => {
-                    // Re-bind for the live state at call time (the actor may have been
-                    // updated since the view was created).
                     const fresh = await this.actorStore.load(actor.name, id, envelope.tenant ?? "");
                     const liveData = fresh?.data ?? instance.data;
                     const localBound = closureBinder(liveData, instance.key);
@@ -1347,7 +1055,6 @@ export class Runtime extends RuntimeBase {
                         throw new Error(`Actor "${actor.name}" has no method "${methodName}".`);
                     }
                     const result = localFn(...args);
-                    // Publish recorded events through the runtime pipeline.
                     if (localBound.recorded.length > 0) {
                         const messages = localBound.recorded.map((r) => ({
                             eventName: r.eventName,
@@ -1361,7 +1068,6 @@ export class Runtime extends RuntimeBase {
             }
             return view;
         }
-        // Classic / schema-bound-object form: methods are (state, ...args) => event.
         const methods = actor.methods ?? {};
         for (const [methodName, fn] of Object.entries(methods)) {
             const method = fn;
@@ -1370,42 +1076,7 @@ export class Runtime extends RuntimeBase {
         }
         return view;
     }
-    /** Test/inspection seam — read what's in the DLQ. */
     getDeadLetterSink() {
         return this.deadLetterSink;
     }
 }
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function computeBackoff(retry, attemptIndex) {
-    if (!retry)
-        return 0;
-    const base = retry.baseDelayMs ?? 100;
-    const cap = retry.maxDelayMs ?? 30_000;
-    if (retry.backoff === "fixed")
-        return Math.min(base, cap);
-    // Exponential default — 2^(attempt-1) * base, capped.
-    return Math.min(Math.floor(Math.pow(2, attemptIndex - 1) * base), cap);
-}
-/**
- * Parse a delay string like '3d', '90s', '4h' into milliseconds.
- * Supports: ms, s, m, h, d. Numbers without units treated as milliseconds.
- */
-export function parseDelay(value) {
-    const match = /^(\d+(?:\.\d+)?)(ms|s|m|h|d)?$/.exec(value);
-    if (!match) {
-        throw new Error(`Runtime: cannot parse delay "${value}". Expected '3d', '90s', '4h', '500ms'.`);
-    }
-    const n = Number(match[1]);
-    const unit = match[2] ?? "ms";
-    const multipliers = {
-        ms: 1,
-        s: 1000,
-        m: 60_000,
-        h: 3_600_000,
-        d: 86_400_000,
-    };
-    return n * (multipliers[unit] ?? 1);
-}
-//# sourceMappingURL=runtime.js.map