@nwire/forge 0.9.1 → 0.10.0

package/dist/{define-handler.js → primitives/define-handler.js}

@@ -27,12 +27,23 @@
  * the `eventName` + `payload` shape — plain objects pass straight through.
  */
 import { captureSourceLocation } from "@nwire/messages";
+// Forge dispatcher binding name — duplicated here to avoid a runtime →
+// primitives import cycle. Matches `FORGE_DISPATCHER_BINDING` in
+// `runtime/forge-plugin.ts`.
+const FORGE_DISPATCHER_BINDING = "forge.dispatcher";
 export function defineHandler(action, handler) {
-    return {
+    const def = {
         $kind: "handler",
         action,
         handler,
         $source: captureSourceLocation(),
+        name: action.name,
+        input: action.schema,
+        async run(ctx, opts) {
+            const dispatcher = ctx.resolve(FORGE_DISPATCHER_BINDING);
+            const result = await dispatcher.dispatch(action, ctx.input, ctx.envelope, { signal: opts?.signal });
+            return { result };
+        },
     };
+    return def;
 }
-//# sourceMappingURL=define-handler.js.map

package/dist/{define-inbound-webhook.d.ts → primitives/define-inbound-webhook.d.ts}

@@ -15,7 +15,7 @@
  *     },
  *   });
  *
- * Wire-level handlers (`@nwire/http`) mount the route and on each request:
+ * Wire-level handlers (`@nwire/koa`) mount the route and on each request:
  *   1. Run `verifySignature` (deny if invalid)
  *   2. Run `dedupe.keyFrom` and check the inbox (skip if already seen)
  *   3. Parse the payload through `schema`
@@ -79,4 +79,3 @@ export interface InboundWebhookDefinition<TSchema extends ZodTypeAny = ZodTypeAn
     readonly tags?: readonly string[];
 }
 export declare function defineInboundWebhook<TSchema extends ZodTypeAny>(meta: InboundWebhookMeta<TSchema>): InboundWebhookDefinition<TSchema>;
-//# sourceMappingURL=define-inbound-webhook.d.ts.map

package/dist/{define-inbound-webhook.js → primitives/define-inbound-webhook.js}

@@ -15,7 +15,7 @@
  *     },
  *   });
  *
- * Wire-level handlers (`@nwire/http`) mount the route and on each request:
+ * Wire-level handlers (`@nwire/koa`) mount the route and on each request:
  *   1. Run `verifySignature` (deny if invalid)
  *   2. Run `dedupe.keyFrom` and check the inbox (skip if already seen)
  *   3. Parse the payload through `schema`
@@ -39,4 +39,3 @@ export function defineInboundWebhook(meta) {
         tags: meta.tags,
     };
 }
-//# sourceMappingURL=define-inbound-webhook.js.map

package/dist/{define-inbox.d.ts → primitives/define-inbox.d.ts}

@@ -37,4 +37,3 @@ export interface InboxDefinition {
     readonly tags?: readonly string[];
 }
 export declare function defineInbox(meta: InboxMeta): InboxDefinition;
-//# sourceMappingURL=define-inbox.d.ts.map

package/dist/{define-inbox.js → primitives/define-inbox.js}

@@ -28,4 +28,3 @@ export function defineInbox(meta) {
         tags: meta.tags,
     };
 }
-//# sourceMappingURL=define-inbox.js.map

package/dist/{define-outbox.d.ts → primitives/define-outbox.d.ts}

@@ -44,4 +44,3 @@ export interface OutboxDefinition {
     readonly tags?: readonly string[];
 }
 export declare function defineOutbox(meta: OutboxMeta): OutboxDefinition;
-//# sourceMappingURL=define-outbox.d.ts.map

package/dist/{define-outbox.js → primitives/define-outbox.js}

@@ -33,4 +33,3 @@ export function defineOutbox(meta) {
         tags: meta.tags,
     };
 }
-//# sourceMappingURL=define-outbox.js.map

package/dist/{define-projection.d.ts → primitives/define-projection.d.ts}

@@ -55,4 +55,3 @@ export interface ProjectionDefinition<TState = unknown> {
     readonly $source?: SourceLocation;
 }
 export declare function defineProjection<TState>(name: string, options: ProjectionOptions<TState>): ProjectionDefinition<TState>;
-//# sourceMappingURL=define-projection.d.ts.map

package/dist/{define-projection.js → primitives/define-projection.js}

@@ -44,4 +44,3 @@ export function defineProjection(name, options) {
         $source,
     };
 }
-//# sourceMappingURL=define-projection.js.map

package/dist/{define-query.d.ts → primitives/define-query.d.ts}

@@ -32,7 +32,7 @@
 import type { z } from "zod";
 import type { ZodTypeAny, SourceLocation } from "@nwire/messages";
 import type { ProjectionDefinition } from "./define-projection.js";
-import { type PublicMarker } from "./public-marker.js";
+import { type PublicMarker } from "../helpers/public-marker.js";
 /** Studio-aware: declared read-path SLO. */
 export interface QuerySlo {
     /** Declared p95 latency target in milliseconds. */
@@ -107,4 +107,3 @@ export interface QueryDefinition<TState = unknown, TSchema extends ZodTypeAny =
 }
 export declare function defineQuery<TState, TSchema extends ZodTypeAny, TResult>(projection: ProjectionDefinition<TState>, options: QueryOptions<TState, TSchema, TResult>): QueryDefinition<TState, TSchema, TResult>;
 export declare function defineQuery<TSchema extends ZodTypeAny, TResult>(options: QueryHandlerOptions<TSchema, TResult>): QueryDefinition<any, TSchema, TResult>;
-//# sourceMappingURL=define-query.d.ts.map

package/dist/{define-query.js → primitives/define-query.js}

@@ -30,7 +30,7 @@
  * routes wire queries; HTTP POST routes wire actions).
  */
 import { captureSourceLocation } from "@nwire/messages";
-import { markable } from "./public-marker.js";
+import { markable } from "../helpers/public-marker.js";
 export function defineQuery(projectionOrOptions, maybeOptions) {
     const $source = captureSourceLocation();
     // Handler form — first arg is the options object with `handler`.
@@ -63,4 +63,3 @@ export function defineQuery(projectionOrOptions, maybeOptions) {
         $source,
     });
 }
-//# sourceMappingURL=define-query.js.map

package/dist/{define-schema.d.ts → primitives/define-schema.d.ts}

@@ -28,7 +28,7 @@
  *
  * Why it's separate from `defineActor`:
  *   - Studio can render the data model without booting the actor.
- *   - Persistent stores (`@nwire/store-mongo`, `@nwire/store-prisma`) read
+ *   - Persistent stores (`@nwire/mongo`, `@nwire/store-prisma`) read
  *     `indexes` + `unique` to build adapter-level constraints.
  *   - Projections can reference the same schema for view-typing.
  *
@@ -85,4 +85,3 @@ export interface SchemaDefinition<TFields extends Readonly<Record<string, ZodTyp
 export declare function defineSchema<TFields extends Readonly<Record<string, ZodTypeAny>>>(options: SchemaOptions<TFields>): SchemaDefinition<TFields>;
 /** Type narrow — true if `x` is a SchemaDefinition produced by `defineSchema`. */
 export declare function isSchemaDefinition(x: unknown): x is SchemaDefinition;
-//# sourceMappingURL=define-schema.d.ts.map

package/dist/{define-schema.js → primitives/define-schema.js}

@@ -28,7 +28,7 @@
  *
  * Why it's separate from `defineActor`:
  *   - Studio can render the data model without booting the actor.
- *   - Persistent stores (`@nwire/store-mongo`, `@nwire/store-prisma`) read
+ *   - Persistent stores (`@nwire/mongo`, `@nwire/store-prisma`) read
  *     `indexes` + `unique` to build adapter-level constraints.
  *   - Projections can reference the same schema for view-typing.
  *
@@ -69,4 +69,3 @@ export function defineSchema(options) {
 export function isSchemaDefinition(x) {
     return typeof x === "object" && x !== null && x.$kind === "schema";
 }
-//# sourceMappingURL=define-schema.js.map

package/dist/{define-upcaster.d.ts → primitives/define-upcaster.d.ts}

@@ -22,4 +22,3 @@ export declare function applyUpcasters(eventName: string, payload: unknown, upca
     eventName: string;
     payload: unknown;
 };
-//# sourceMappingURL=define-upcaster.d.ts.map

package/dist/{define-upcaster.js → primitives/define-upcaster.js}

@@ -28,4 +28,3 @@ export function applyUpcasters(eventName, payload, upcasters) {
     }
     return { eventName: currentName, payload: currentPayload };
 }
-//# sourceMappingURL=define-upcaster.js.map

package/dist/{define-workflow.d.ts → primitives/define-workflow.d.ts}

@@ -20,8 +20,8 @@ import type { z } from "zod";
 import type { ZodTypeAny, SourceLocation } from "@nwire/messages";
 import type { EventDefinition, EventPayload } from "@nwire/messages";
 import type { ActionDefinition, ActionInput, ActionResult } from "./define-action.js";
-import type { EventMessage } from "./event-message.js";
-import { type PublicMarker } from "./public-marker.js";
+import type { EventMessage } from "../messages/event-message.js";
+import { type PublicMarker } from "../helpers/public-marker.js";
 /**
  * Timer definition produced by `timeout(name, delay)`. Acts like an event
  * for subscription purposes — `on(timer, handler)` registers a handler
@@ -208,4 +208,3 @@ export interface WorkflowInstance {
 export declare function defineWorkflow<TData extends ZodTypeAny>(name: string, closure: (ctx: StatefulWorkflowContext<z.output<TData>>) => void, options: StatefulWorkflowOptions<TData>): WorkflowDefinition;
 export declare function defineWorkflow(name: string, closure: (ctx: StatelessWorkflowContext) => void, options?: StatelessWorkflowOptions): WorkflowDefinition;
 export {};
-//# sourceMappingURL=define-workflow.d.ts.map

package/dist/{define-workflow.js → primitives/define-workflow.js}

@@ -17,8 +17,8 @@
  * Example shapes appear in `docs/concepts/workflow.md`.
  */
 import { captureSourceLocation } from "@nwire/messages";
-import { markable } from "./public-marker.js";
-import { timerEventName } from "./workflow-timer-store.js";
+import { markable } from "../helpers/public-marker.js";
+import { timerEventName } from "../stores/workflow-timer-store.js";
 /**
  * `complete` — framework-emitted pseudo-event that fires when a stateful
  * workflow enters any state marked `final: true`. Exposed on the closure
@@ -376,4 +376,3 @@ function buildFireStateCallables(specs, registrations) {
     }
     return out;
 }
-//# sourceMappingURL=define-workflow.js.map

package/dist/runtime/create-forge-app.d.ts

@@ -0,0 +1,64 @@
+/**
+ * `createForgeApp` — foundation-form composition entry point.
+ *
+ * Wraps `createRuntime() + runtime.registerPlugin(forgePlugin) +
+ * runtime.start/stop` with the forge dispatch verbs added on the returned
+ * app handle. Each verb resolves the `ForgeDispatcher` bound on the
+ * container by `forgePlugin` and delegates.
+ *
+ * Modules are gone in 0.10 — the App is the bounded context. Pass
+ * actors / projections / queries / workflows / external calls / handlers
+ * directly on opts; they register against the dispatcher during plugin
+ * boot (an AppBooting chain step does the registration before any
+ * plugin's boot() runs).
+ */
+import { type Container } from "@nwire/container/awilix";
+import { type PluginDefinition, type Runtime } from "@nwire/app";
+import type { Logger } from "@nwire/logger";
+import type { MessageEnvelope } from "@nwire/envelope";
+import type { z } from "zod";
+import type { ZodTypeAny } from "@nwire/messages";
+import type { ForgeDispatcher } from "./forge-dispatcher.js";
+import type { ActionDefinition, ActionInput, ActionResult } from "../primitives/define-action.js";
+import type { HandlerDefinition as ForgeHandlerDef } from "../primitives/define-handler.js";
+import type { ActorDefinition } from "../primitives/define-actor.js";
+import type { WorkflowDefinition } from "../primitives/define-workflow.js";
+import type { ProjectionDefinition } from "../primitives/define-projection.js";
+import type { QueryDefinition } from "../primitives/define-query.js";
+import type { ExternalCallDefinition } from "../primitives/define-external-call.js";
+import type { EventMessage } from "../messages/event-message.js";
+import type { DispatchOptions } from "./forge-types.js";
+export interface ForgeAppOptions {
+    readonly name: string;
+    readonly plugins?: readonly PluginDefinition[];
+    readonly container?: Container;
+    readonly logger?: Logger;
+    readonly handlers?: readonly ForgeHandlerDef<any>[];
+    readonly actors?: readonly ActorDefinition[];
+    readonly projections?: readonly ProjectionDefinition<any>[];
+    readonly queries?: readonly QueryDefinition<any, any, any>[];
+    readonly workflows?: readonly WorkflowDefinition[];
+    readonly externalCalls?: readonly ExternalCallDefinition<any, any>[];
+}
+export interface ForgeApp {
+    readonly $nwireApp: true;
+    readonly appName: string;
+    readonly runtime: Runtime;
+    readonly container: Container;
+    start(): Promise<void>;
+    stop(reason?: string): Promise<void>;
+    /** Endpoint alias. */
+    boot(): Promise<void>;
+    /** Endpoint alias. */
+    shutdown(): Promise<void>;
+    dispatch<A extends ActionDefinition>(action: A, input: ActionInput<A>, parentEnvelope?: MessageEnvelope, opts?: DispatchOptions): Promise<ActionResult<A>>;
+    publish(events: readonly EventMessage[], parentEnvelope: MessageEnvelope): Promise<void>;
+    applyExternalEvent(eventName: string, payload: unknown, envelope: MessageEnvelope): Promise<void>;
+    query<TResult = unknown>(queryName: string, input: unknown, tenant?: string): Promise<TResult>;
+    executeExternalCall<TRequest extends ZodTypeAny, TResponse extends ZodTypeAny>(def: ExternalCallDefinition<TRequest, TResponse>, request: z.output<TRequest>, envelope?: MessageEnvelope): Promise<z.output<TResponse>>;
+    fireDueTimers(now?: number): Promise<number>;
+    fireDueWorkflowTimers(now?: Date): Promise<number>;
+    dispatcher(): ForgeDispatcher;
+}
+export declare function createForgeApp(options: ForgeAppOptions): ForgeApp;
+export type { Runtime };

package/dist/runtime/create-forge-app.js

@@ -0,0 +1,78 @@
+/**
+ * `createForgeApp` — foundation-form composition entry point.
+ *
+ * Wraps `createRuntime() + runtime.registerPlugin(forgePlugin) +
+ * runtime.start/stop` with the forge dispatch verbs added on the returned
+ * app handle. Each verb resolves the `ForgeDispatcher` bound on the
+ * container by `forgePlugin` and delegates.
+ *
+ * Modules are gone in 0.10 — the App is the bounded context. Pass
+ * actors / projections / queries / workflows / external calls / handlers
+ * directly on opts; they register against the dispatcher during plugin
+ * boot (an AppBooting chain step does the registration before any
+ * plugin's boot() runs).
+ */
+import { createContainer } from "@nwire/container/awilix";
+import { createRuntime } from "@nwire/app";
+import { forgePlugin as defaultForgePlugin, FORGE_DISPATCHER_BINDING, } from "./forge-plugin.js";
+export function createForgeApp(options) {
+    const container = options.container ?? createContainer();
+    const runtime = createRuntime({
+        container,
+        logger: options.logger,
+        appName: options.name,
+    });
+    // Forge plugin first; user plugins after. The user can also pass an
+    // explicit `createForgePlugin(opts)` in their list to control stores.
+    const plugins = ensureForgePlugin(options.plugins ?? []);
+    for (const p of plugins) {
+        runtime.registerPlugin(p);
+    }
+    // Direct registrations land on the dispatcher during AppBooting —
+    // after every plugin's setup ran (so forge's dispatcher is bound)
+    // but before plugin boot queues fire (so domain routes are wired
+    // when downstream plugins' boot work might reach for them).
+    runtime.hooks.AppBooting.use(async (_, next) => {
+        const d = container.resolve(FORGE_DISPATCHER_BINDING);
+        for (const h of options.handlers ?? []) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            d.registerActionHandler(h);
+        }
+        for (const actor of options.actors ?? [])
+            d.registerActor(actor);
+        for (const projection of options.projections ?? [])
+            d.registerProjection(projection);
+        for (const query of options.queries ?? [])
+            d.registerQuery(query);
+        for (const workflow of options.workflows ?? [])
+            d.registerWorkflow(workflow);
+        for (const call of options.externalCalls ?? [])
+            d.registerExternalCall(call);
+        await next();
+    }, { name: "forge.app.register-domain", priority: 1_000_000 });
+    const dispatcher = () => container.resolve(FORGE_DISPATCHER_BINDING);
+    const app = {
+        $nwireApp: true,
+        appName: options.name,
+        runtime,
+        container,
+        start: () => runtime.start(),
+        stop: (reason) => runtime.stop(reason),
+        boot: () => runtime.start(),
+        shutdown: () => runtime.stop(),
+        dispatcher,
+        dispatch: (action, input, parentEnvelope, opts) => dispatcher().dispatch(action, input, parentEnvelope, opts),
+        publish: (events, parentEnvelope) => dispatcher().publish(events, parentEnvelope),
+        applyExternalEvent: (eventName, payload, envelope) => dispatcher().applyExternalEvent(eventName, payload, envelope),
+        query: (name, input, tenant = "") => dispatcher().query(name, input, tenant),
+        executeExternalCall: (def, request, envelope) => dispatcher().executeExternalCall(def, request, envelope),
+        fireDueTimers: (now) => dispatcher().fireDueTimers(now),
+        fireDueWorkflowTimers: (now) => dispatcher().fireDueWorkflowTimers(now),
+    };
+    return app;
+}
+function ensureForgePlugin(plugins) {
+    if (plugins.some((p) => p.name === "forge"))
+        return plugins;
+    return [defaultForgePlugin, ...plugins];
+}

package/dist/runtime/forge-dispatcher.d.ts

@@ -0,0 +1,148 @@
+/**
+ * `ForgeDispatcher` — the CQRS state container that forge layers on top of
+ * the kernel runtime.
+ *
+ * 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 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 { type Runtime } from "@nwire/app";
+import { type Hook } from "@nwire/hooks";
+import { type ZodTypeAny } from "@nwire/messages";
+import { type MessageEnvelope } from "@nwire/envelope";
+import { type DeadLetterSink } from "@nwire/dead-letter";
+import type { EventBus } from "@nwire/bus";
+import type { z } from "zod";
+import type { ActionDefinition, ActionInput, ActionResult } from "../primitives/define-action.js";
+import type { HandlerDefinition } from "../primitives/define-handler.js";
+import type { ActorDefinition } from "../primitives/define-actor.js";
+import type { WorkflowDefinition, WorkflowInstance } from "../primitives/define-workflow.js";
+import type { ProjectionDefinition } from "../primitives/define-projection.js";
+import type { QueryDefinition } from "../primitives/define-query.js";
+import type { ExternalCallDefinition, ExternalCallExecutor } from "../primitives/define-external-call.js";
+import { type ActorStore } from "../stores/actor-store.js";
+import { type ProjectionStore } from "../stores/projection-store.js";
+import { type IdempotencyStore } from "../stores/idempotency-store.js";
+import { type WorkflowTimerStore } from "../stores/workflow-timer-store.js";
+import { type EventMessage } from "../messages/event-message.js";
+import type { DispatchOptions, ActionBeforeHookCtx, ActionAfterHookCtx, ActorTransitionHookCtx, WorkflowFireHookCtx } from "./forge-types.js";
+/** Options that configure forge's dispatch behaviour + persistence seams. */
+export interface ForgeDispatcherOptions {
+    readonly actorStore?: ActorStore;
+    readonly projectionStore?: ProjectionStore;
+    readonly deadLetterSink?: DeadLetterSink;
+    readonly idempotencyStore?: IdempotencyStore;
+    readonly workflowTimerStore?: WorkflowTimerStore;
+    readonly bus?: EventBus;
+    readonly publishToBus?: boolean;
+}
+/** Legacy plugin-supplied actor-transition hook signature — kept for back-compat. */
+export type ActorTransitionListener = (actor: ActorDefinition, key: string, fromState: string, toState: string, event: EventMessage, envelope: MessageEnvelope) => Promise<void> | void;
+export declare class ForgeDispatcher {
+    readonly runtime: Runtime;
+    readonly handlers: Map<string, HandlerDefinition<ZodTypeAny>>;
+    readonly actors: Map<string, ActorDefinition<ZodTypeAny, Readonly<Record<string, import("..").ActorMethod<any>>>>>;
+    readonly workflowsByEvent: Map<string, WorkflowDefinition[]>;
+    /**
+     * Per-workflow instance state — keyed first by workflow name, then by
+     * correlation key. In-memory for now; durable adapters plug in via a
+     * future WorkflowStore contract analogous to ActorStore.
+     */
+    readonly workflowInstances: Map<string, Map<string, WorkflowInstance>>;
+    readonly projections: Map<string, ProjectionDefinition<any>>;
+    readonly projectionsByEvent: Map<string, ProjectionDefinition<any>[]>;
+    readonly queries: Map<string, QueryDefinition<any, any, any>>;
+    readonly externalCalls: Map<string, ExternalCallDefinition<any, any>>;
+    readonly externalCallExecutors: Map<string, ExternalCallExecutor<any, any>>;
+    /**
+     * 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. Observed into
+     * the canonical telemetry stream so each chain step emits `hook.step`.
+     */
+    readonly actionBeforeHooks: Map<string, Hook<ActionBeforeHookCtx>>;
+    /** Per-action `action.after:<name>` hooks. Pre-created identically. */
+    readonly actionAfterHooks: Map<string, Hook<ActionAfterHookCtx>>;
+    /** Per-actor `actor.transition:<name>` hooks. Pre-created at `registerActor()`. */
+    readonly perActorHooks: Map<string, Hook<ActorTransitionHookCtx>>;
+    /** Per-workflow `workflow.fire:<name>` hooks. Pre-created at `registerWorkflow()`. */
+    readonly perWorkflowHooks: Map<string, Hook<WorkflowFireHookCtx>>;
+    /** Legacy plugin-supplied actor-transition listeners — runs after the per-actor hook. */
+    readonly actorTransitionHooks: ActorTransitionListener[];
+    readonly actorStore: ActorStore;
+    readonly projectionStore: ProjectionStore;
+    readonly deadLetterSink: DeadLetterSink;
+    readonly idempotencyStore: IdempotencyStore;
+    readonly workflowTimerStore: WorkflowTimerStore;
+    readonly bus?: EventBus;
+    readonly publishToBus: boolean;
+    /** Known external events — populated by createApp from modules' needs.externalEvents. */
+    readonly externalEventNames: Set<string>;
+    /** Public-event names (visibility: 'public') — populated by createApp from modules' events. */
+    readonly publicEventNames: Set<string>;
+    constructor(runtime: Runtime, options?: ForgeDispatcherOptions);
+    /** Get-or-create the per-workflow instance store. */
+    workflowInstanceStore(workflowName: string): Map<string, WorkflowInstance>;
+    /**
+     * 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.
+     */
+    registerActionHandler(handler: HandlerDefinition<any>): void;
+    registerActor(actor: ActorDefinition): void;
+    registerWorkflow(workflow: WorkflowDefinition): void;
+    registerProjection(projection: ProjectionDefinition<any>): void;
+    registerQuery(query: QueryDefinition<any, any, any>): void;
+    registerExternalCall(def: ExternalCallDefinition<any, any>): void;
+    registerExternalCallExecutor(def: ExternalCallDefinition<any, any>, executor: ExternalCallExecutor<any, any>): void;
+    registerExternalEvent(eventName: string): void;
+    registerPublicEvent(eventName: string): void;
+    registerActorTransitionHook(listener: ActorTransitionListener): void;
+    /** Get-or-create the per-action `action.before:<name>` hook, observed for telemetry. */
+    ensureActionBeforeHook(actionName: string): Hook<ActionBeforeHookCtx>;
+    ensureActionAfterHook(actionName: string): Hook<ActionAfterHookCtx>;
+    ensureActorTransitionHook(actorName: string): Hook<ActorTransitionHookCtx>;
+    ensureWorkflowFireHook(workflowName: string): Hook<WorkflowFireHookCtx>;
+    executeExternalCall<TRequest extends ZodTypeAny, TResponse extends ZodTypeAny>(def: ExternalCallDefinition<TRequest, TResponse>, request: z.output<TRequest>, envelope?: MessageEnvelope): Promise<z.output<TResponse>>;
+    listHandlers(): readonly string[];
+    listActors(): readonly string[];
+    listProjections(): readonly string[];
+    listQueries(): readonly string[];
+    listExternalCalls(): readonly string[];
+    /** Deduplicated list of every registered workflow definition. */
+    listWorkflows(): readonly WorkflowDefinition[];
+    getExternalCall(name: string): ExternalCallDefinition<any, any> | undefined;
+    /** Resolve a handler definition by action name. */
+    findHandler(name: string): HandlerDefinition | undefined;
+    /** Resolve an action by routing name — useful when only the name is known. */
+    findActionByName(name: string): ActionDefinition<ZodTypeAny> | undefined;
+    /** Has a handler been registered for this action name? */
+    hasHandler(name: string): boolean;
+    query<TResult = unknown>(queryName: string, input: unknown, tenant?: string): Promise<TResult>;
+    fireDueTimers(now?: number): Promise<number>;
+    fireDueWorkflowTimers(now?: Date): Promise<number>;
+    dispatch<A extends ActionDefinition>(action: A, input: ActionInput<A>, parentEnvelope?: MessageEnvelope, opts?: DispatchOptions): Promise<ActionResult<A>>;
+    publish(events: readonly EventMessage[], parentEnvelope: MessageEnvelope): Promise<void>;
+    applyExternalEvent(eventName: string, payload: unknown, envelope: MessageEnvelope): Promise<void>;
+    private foldProjections;
+    private applyToActors;
+    private extractKey;
+    private applyEventToActor;
+    private applyEventToActorLocked;
+    private computeTimersForState;
+    private runWorkflows;
+    private buildHandlerContext;
+    private loadActorView;
+    getDeadLetterSink(): DeadLetterSink;
+}