@nwire/forge 0.9.2 → 0.10.1

package/README.md

@@ -1,194 +1,172 @@
 # @nwire/forge
 
-> The framework's domain primitives — actions, actors, events, workflows, projections, modules, plugins, and the runtime that fires them.
-
-Forge composes the lower packages (`@nwire/messages`, `@nwire/handler`,
-`@nwire/app`) into one ergonomic surface. You can drop down to any of
-them when you want a narrower import; forge stays the default for app code.
+> Domain primitives: actions, actors, events, workflows, projections.
+> Plus the runtime that fires them.
 
 ```bash
 pnpm add @nwire/forge zod
 ```
 
-## 5-minute tour
-
-Two primitives carry most of an app: `defineSchema` declares the data shape +
-lifecycle, `defineActor` (closure form) declares the methods + transitions
-against it. Everything else (`defineAction`, `defineModule`, `createApp`)
-plugs in around them.
+## Quick tour
 
-### 1. Declare the data + lifecycle with `defineSchema`
+### 1. Define an action
 
 ```ts
+import { defineAction } from "@nwire/forge";
 import { z } from "zod";
-import { defineSchema } from "@nwire/forge";
-
-export const SubmissionData = defineSchema({
-  name: "submission",
-  key: "submissionId",
-  fields: {
-    submissionId: z.string(),
-    studentId: z.string(),
-    answer: z.string(),
-    verdict: z.string().optional(),
-    gradedAt: z.string().datetime().optional(),
-  },
-  states: {
-    submitted: { initial: true },
-    "under-review": {},
-    graded: { final: true },
-  },
+
+export const placeOrder = defineAction({
+  name: "orders.place",
+  schema: z.object({
+    customerId: z.string(),
+    items: z.array(z.object({ sku: z.string(), qty: z.number().int().positive() })),
+  }),
+});
+```
+
+An action is a typed contract — a name + zod schema. The runtime
+validates input on every dispatch.
+
+### 2. Define a handler
+
+```ts
+import { defineHandler } from "@nwire/forge";
+
+export const placeOrderHandler = defineHandler(placeOrder, async (input, ctx) => {
+  const orders = ctx.resolve<OrderRepo>("orders");
+  return orders.create(input);
+});
+```
+
+`(input, ctx)` is the canonical handler shape. `ctx` carries:
+
+- `resolve<T>(name)` — pull bindings from the container
+- `envelope` — tenant, user, correlation, causation
+- `dispatch(action, input)` — fire other actions
+- `enqueue(queueName, payload)` — defer work to a queue
+- `emit(event, payload)` — emit a domain event
+
+### 3. Wire it into an App
+
+```ts
+import { createApp } from "@nwire/app";
+import { createForgePlugin } from "@nwire/forge";
+import { post } from "@nwire/wires/http";
+
+const app = createApp({
+  appName: "orders",
+  plugins: [createForgePlugin({})],
+  handlers: [placeOrderHandler],
+});
+
+// HTTP route dispatches the same handler
+app.wire(post("/orders", { body: placeOrder.schema }), placeOrderHandler);
+```
+
+`createForgePlugin({})` installs the dispatcher; handlers passed in
+`createApp({ handlers })` register on it at boot.
+
+### 4. Dispatch from anywhere
+
+```ts
+const dispatcher = app.container.resolve<ForgeDispatcher>("forge.dispatcher");
+
+await dispatcher.dispatch(placeOrder, {
+  customerId: "c-1",
+  items: [{ sku: "WIDGET", qty: 2 }],
 });
 ```
 
-The schema is the single source of truth for the data model and the set of
-valid lifecycle states — Studio renders it, persistent stores (`@nwire/store-mongo`,
-`@nwire/store-prisma`) read `storage.indexes` / `storage.unique` from it, and
-`defineActor` borrows `key` + `initial` + the state names off it.
+The runtime validates input, opens an envelope, runs middleware, fires
+`action.before` hooks, executes the handler, runs `action.after` hooks,
+and surfaces telemetry. HTTP and queue adopters route through the same
+path so dispatch semantics never differ by transport.
 
-### 2. Bind methods + transitions with `defineActor` (closure form)
+## Actors
 
 ```ts
 import { defineActor } from "@nwire/forge";
-import { SubmissionData } from "./submission.schema";
-import { SubmissionWasFlagged, SubmissionWasGraded } from "./events";
-
-export const Submission = defineActor(
-  SubmissionData,
-  ({ data, id, validate, recordThat, when, methods, states }) => {
-    const { underReview, graded } = states;
-
-    // Methods enforce invariants and `recordThat` the events. They don't
-    // mutate state directly — `when(...)` below folds the recorded events
-    // into state.
-    const flag = (input: { reason: string }) => {
-      validate(input, [(i) => i.reason.length > 0 || "reason required"]);
-      recordThat(SubmissionWasFlagged({ submissionId: id, reason: input.reason }));
-    };
-    const grade = (input: { verdict: string }) => {
-      recordThat(SubmissionWasGraded({ submissionId: id, verdict: input.verdict }));
-    };
-
-    when(SubmissionWasFlagged, (_e, { assign }) => {
-      assign({}); // no field changes — state move only
-      return underReview; // transition: submitted → under-review
-    });
-    when(SubmissionWasGraded, (e, { assign }) => {
-      assign({ verdict: e.verdict, gradedAt: new Date().toISOString() });
-      return graded; // transition into the final state
-    });
-
-    return methods({ flag, grade });
+
+export const subscription = defineActor({
+  name: "subscription",
+  schema: z.object({
+    id: z.string(),
+    plan: z.enum(["free", "pro"]),
+    status: z.enum(["active", "past_due", "suspended"]),
+  }),
+  methods: {
+    suspend: ({ self }) => ({ ...self, status: "suspended" }),
+    activate: ({ self }) => ({ ...self, status: "active" }),
   },
-);
+});
 ```
 
-The closure runs once at define time (to capture transitions + method names)
-and again per `ctx.use(Submission, id)` call (to bind methods over the live
-`data`). `recordThat` collects events the runtime publishes after the method
-returns; `when` is the matching fold — methods never write to state directly,
-so the actor's history is always the event log.
+Actors carry state, version, and OCC. Methods receive the current state
+and return the next state — pure transitions. The dispatcher persists
+through an `ActorStore` adapter.
 
-> See: [write paths (actor xor direct-DB)](https://nwire.dev/concepts/write-paths) — a handler picks one path per write; never both.
+## Workflows
 
-**Object form vs. closure form** — both exist. Use the closure form when you
-want typed `states.<name>` refs, want methods and folds in the same file, and
-want invariants on the input shape (`validate(...)`); use the object form
-(`defineActor(name, { schema, key, initial, states, methods })`) when the
-state machine is the whole story and you don't need per-method input
-validation.
+```ts
+import { defineWorkflow } from "@nwire/forge";
+
+export const paymentRenewal = defineWorkflow({
+  name: "payment.renewal",
+  on: { event: chargeFailed },
+  steps: {
+    holdGrace: async (ctx) => {
+      await ctx.schedule(suspendSubscription, { in: "48h" });
+    },
+  },
+});
+```
+
+Workflows react to events. `ctx.schedule(...)` arms timers, `ctx.dispatch(...)`
+fires actions; state persists between hops via the actor store.
 
-### 3. Wire it into a module + app
+## Projections
 
 ```ts
-import { defineAction, defineModule, createApp, AppBooted, ActionCompleted } from "@nwire/forge";
-import { z } from "zod";
+import { defineProjection } from "@nwire/forge";
 
-export const flagSubmission = defineAction({
-  name: "submissions.flag",
-  schema: z.object({ submissionId: z.string(), reason: z.string() }),
-  emits: [SubmissionWasFlagged],
-  handler: async (input, { use }) => {
-    const sub = await use(Submission, input.submissionId);
-    sub.flag({ reason: input.reason }); // recorded event(s) published by runtime
+export const queueDashboard = defineProjection({
+  name: "queue.dashboard",
+  on: { event: postSubmitted },
+  apply: async (state, event) => {
+    state.pending.push({ id: event.payload.postId, submittedAt: event.envelope.ts });
   },
 });
+```
 
-export const submissions = defineModule("submissions", {
-  events: [SubmissionWasFlagged, SubmissionWasGraded],
-  actors: [Submission],
-  actions: [flagSubmission.public()],
-});
+Projections build read models from events. Domain code reads them via
+`ctx.resolve<ProjectionStore>("projection.queue.dashboard")`.
 
-const app = createApp({ modules: [submissions] });
-app.bus.on(AppBooted, ({ appName }) => console.log("booted:", appName));
-app.bus.on(ActionCompleted, ({ action }) => console.log("ran:", action.name));
+## Plugin options
 
-await app.start();
-await app.runtime.dispatch(flagSubmission, { submissionId: "s-1", reason: "off-topic" });
+`createForgePlugin({...})` accepts:
+
+```ts
+createForgePlugin({
+  workflows: [paymentRenewal],
+  projections: [queueDashboard],
+  queries: [listPending, queueTotals],
+  actors: [subscription],
+  externalCalls: [chargeStripe],
+});
 ```
 
 ## Surface
 
-### Domain primitives
-
-| Export                                                                                        | Role                                                         |
-| --------------------------------------------------------------------------------------------- | ------------------------------------------------------------ |
-| `defineAction`                                                                                | User-visible command — validated input, emits events         |
-| `defineEvent`                                                                                 | Past-tense fact (re-exported from `@nwire/messages`)         |
-| `defineHandler`                                                                               | Operation primitive — transport-agnostic                     |
-| `defineActor`                                                                                 | Aggregate with state, methods, optional state machine        |
-| `defineSchema`                                                                                | Data shape + lifecycle states + storage hints                |
-| `defineProjection`                                                                            | Read-model fold over events                                  |
-| `defineQuery`                                                                                 | Projection-backed read function                              |
-| `defineWorkflow`                                                                              | Reaction + saga unified — stateless or stateful              |
-| `defineModule`                                                                                | Bundle of actors + actions + events + projections + queries  |
-| `defineApp`                                                                                   | App declaration (multi-wire instantiation)                   |
-| `createApp`                                                                                   | App runtime — boots modules, owns the bus and runtime        |
-| `definePlugin`                                                                                | Forge-richer plugin: middleware + actor hooks + before/after |
-| `defineResource`                                                                              | Public response shape (field allowlist + OpenAPI schema)     |
-| `defineError`                                                                                 | Typed throwable with status code                             |
-| `defineMiddleware` / `defineHook` / `pipe`                                                    | Reusable resolver chain pieces                               |
-| `defineCron` / `defineInbox` / `defineOutbox` / `defineExternalCall` / `defineInboundWebhook` | Orchestrator primitives                                      |
-| `runCli(app, argv)`                                                                           | Argv dispatcher — operator CLI without HTTP                  |
-
-### Framework events
-
-Forge re-exports the app-lifecycle events from `@nwire/app`
-(`AppRegistering` / `AppBooting` / `AppBooted` / `AppReady` /
-`AppShuttingDown` / `AppShutdown`, `PluginRegistered` …, `WireMounting` …)
-and adds its own forge-local events:
-
-| Event                    | Mode        | When                                                  |
-| ------------------------ | ----------- | ----------------------------------------------------- |
-| `ActionDispatching`      | series-bail | Before handler runs. Return `false` to short-circuit. |
-| `ActionCompleted`        | parallel    | After handler returns successfully.                   |
-| `ActionFailed`           | parallel    | After handler throws.                                 |
-| `EventRecording`         | series-bail | Before an event is appended to the store.             |
-| `EventRecorded`          | parallel    | After append succeeds.                                |
-| `builtInFrameworkEvents` | —           | Catalog of every built-in (lifecycle + forge-local).  |
-
-### Re-exports
-
-- `MessageEnvelope`, `seedEnvelope`, `deriveEnvelope` from `@nwire/envelope`
-- `Logger` contract + `NoopLogger` / `ConsoleLogger` from `@nwire/logger`
-- `DeadLetterSink` + `InMemoryDeadLetterSink` from `@nwire/dead-letter`
-
-## Picking the right entry point
-
-| You want…                               | Import from       |
-| --------------------------------------- | ----------------- |
-| Full framework DX in one import         | `@nwire/forge`    |
-| Just operations (handlers / middleware) | `@nwire/handler`  |
-| Just lifecycle + plugins                | `@nwire/app`      |
-| Just events + envelope                  | `@nwire/messages` |
+- **Primitives** — `defineAction`, `defineActor`, `defineEvent`,
+  `defineWorkflow`, `defineProjection`, `defineQuery`, `defineHandler`
+- **Plugin** — `createForgePlugin(options)`
+- **Dispatcher** — `ForgeDispatcher` (resolved as `"forge.dispatcher"`)
+- **Helpers** — `eventFactory`, `defineResource`, `NotFound`,
+  `defineUpcaster`, response builders
 
 ## Related
 
-- `@nwire/endpoint` — wraps the runtime in a process (graceful shutdown, probes).
-- `@nwire/http` — HTTP transport over the runtime.
-- `@nwire/hooks` — the dispatch substrate that powers `runtime.use(...)` and every framework event.
-
-## Status
-
-v0.x — public surface is stable; `createApp` will extract to `@nwire/app` in a follow-up phase but imports won't change (re-exports preserved).
+- [`@nwire/app`](../core-app) — `createApp`, plugin lifecycle, runtime
+- [`@nwire/handler`](../core-handler) — handler contract + error envelope
+- [`@nwire/messages`](../core-messages) — typed envelope + zod helpers
+- [`@nwire/koa`](../nwire-koa) — HTTP adopter that routes through the dispatcher

package/dist/foundation.d.ts

@@ -1,14 +1 @@
-/**
- * `@nwire/forge` — Nwire framework primitives.
- *
- * Public surface domain code uses: `defineAction`, `defineEvent`,
- * `defineHandler`, `defineActor`, `defineProjection`, `defineQuery`,
- * `defineWorkflow`, `defineModule`, `defineApp`, `definePlugin`,
- * `createApp`, `eventFactory`, the runtime, and the InMemory store defaults.
- *
- * `MessageEnvelope` and its constructors are re-exported from `@nwire/envelope`
- * so consumers don't need to import that package separately.
- */
-export { seedEnvelope, deriveEnvelope, type MessageEnvelope, type SeedEnvelopeInput, } from "@nwire/envelope";
 export * from "./index.js";
-//# sourceMappingURL=foundation.d.ts.map

package/dist/foundation.js

@@ -1,14 +1,3 @@
-/**
- * `@nwire/forge` — Nwire framework primitives.
- *
- * Public surface domain code uses: `defineAction`, `defineEvent`,
- * `defineHandler`, `defineActor`, `defineProjection`, `defineQuery`,
- * `defineWorkflow`, `defineModule`, `defineApp`, `definePlugin`,
- * `createApp`, `eventFactory`, the runtime, and the InMemory store defaults.
- *
- * `MessageEnvelope` and its constructors are re-exported from `@nwire/envelope`
- * so consumers don't need to import that package separately.
- */
-export { seedEnvelope, deriveEnvelope, } from "@nwire/envelope";
+// Legacy entry alias — package.json + downstream aliases reference
+// `foundation`. Real surface lives in `./index`.
 export * from "./index.js";
-//# sourceMappingURL=foundation.js.map

package/dist/framework-events.d.ts

@@ -1,58 +1,55 @@
 /**
- * Framework events — re-exports of app-layer events + forge-specific events.
+ * Forge framework-hook augmentation.
  *
- * The generic infrastructure (`defineFrameworkEvent` +
- * `FrameworkEventDefinition`) and the app-lifecycle events (App* / Plugin* /
- * Wire*) live in `@nwire/app`; this module re-exports them so consumers
- * pulling from forge get one import line.
+ * Action-specific and event-recording slots are added to the kernel's
+ * `FrameworkHooks` registry via TS module augmentation. Slots are
+ * materialised at runtime by `Runtime.defineHook(...)` calls in forge's
+ * `Runtime` constructor; once materialised, plugin code accesses them via:
  *
- * The action-specific events (`ActionDispatching` / `ActionCompleted` /
- * `ActionFailed`) and event-recording events (`EventRecording` /
- * `EventRecorded`) are defined here because their payload types reference
- * forge-specific types (`ActionDefinition`, `HandlerContext`) and the
- * domain-event bus forge owns.
- */
-import { type FrameworkEventDefinition } from "@nwire/app";
-import type { ActionDefinition } from "./define-action.js";
-import type { HandlerContext } from "./define-handler.js";
-export { defineFrameworkEvent, AppRegistering, AppBooting, AppBooted, AppReady, AppShuttingDown, AppShutdown, PluginRegistered, PluginBooting, PluginBooted, PluginShuttingDown, PluginShutdown, WireMounting, WireMounted, WireUnmounted, builtInLifecycleEvents, type FrameworkEventDefinition, type FrameworkEventMode, } from "@nwire/app";
-/**
- * Fired before a dispatch reaches the handler. Interceptable: return
- * `false` to silently prevent execution, throw to fail with a specific
- * error, or mutate `payload.input` to transform what the handler sees.
- */
-export declare const ActionDispatching: FrameworkEventDefinition<{
-    readonly action: ActionDefinition;
-    readonly input: unknown;
-    readonly ctx: HandlerContext;
-}>;
-/** Fired after a handler returns successfully. Observable; runs in parallel. */
-export declare const ActionCompleted: FrameworkEventDefinition<{
-    readonly action: ActionDefinition;
-    readonly input: unknown;
-    readonly result: unknown;
-    readonly durationMs: number;
-}>;
-/** Fired after a handler throws. Observable; runs in parallel. */
-export declare const ActionFailed: FrameworkEventDefinition<{
-    readonly action: ActionDefinition;
-    readonly input: unknown;
-    readonly error: unknown;
-    readonly durationMs: number;
-}>;
-/**
- * Fired before an event is persisted. Interceptable: return false to drop
- * the event (rarely useful in practice — events represent facts that
- * already happened). Throw to fail the dispatch that produced this event.
+ *   runtime.hooks.ActionDispatching.use(async (p, next) => …);  // veto-able
+ *   runtime.hooks.ActionCompleted.on(({ action, result }) => …);
+ *
+ * App-lifecycle slots (App*, Plugin*, Wire*) live in `@nwire/app` and
+ * are pre-instantiated on every Runtime; this file only adds forge's
+ * domain-specific slots.
  */
-export declare const EventRecording: FrameworkEventDefinition<{
-    readonly eventName: string;
-    readonly payload: unknown;
-}>;
-/** Fired after an event is persisted + workflows have been notified. */
-export declare const EventRecorded: FrameworkEventDefinition<{
-    readonly eventName: string;
-    readonly payload: unknown;
-}>;
-export declare const builtInFrameworkEvents: readonly FrameworkEventDefinition<unknown>[];
-//# sourceMappingURL=framework-events.d.ts.map
+import type { Hook } from "@nwire/hooks";
+import type { ActionDefinition } from "./primitives/define-action.js";
+import type { HandlerContext } from "./primitives/define-handler.js";
+declare module "@nwire/app" {
+    interface FrameworkHooks {
+        /** Fired before a dispatch reaches the handler. Veto by skipping next(). */
+        ActionDispatching: Hook<{
+            readonly action: ActionDefinition;
+            readonly input: unknown;
+            readonly ctx: HandlerContext;
+        }>;
+        /** Fired after a handler returns successfully. Observe via .on(). */
+        ActionCompleted: Hook<{
+            readonly action: ActionDefinition;
+            readonly input: unknown;
+            readonly result: unknown;
+            readonly durationMs: number;
+        }>;
+        /** Fired after a handler throws. Observe via .on(). */
+        ActionFailed: Hook<{
+            readonly action: ActionDefinition;
+            readonly input: unknown;
+            readonly error: unknown;
+            readonly durationMs: number;
+        }>;
+        /** Fired before an event is persisted. Veto by skipping next() (rare). */
+        EventRecording: Hook<{
+            readonly eventName: string;
+            readonly payload: unknown;
+        }>;
+        /** Fired after an event is persisted + workflows notified. Observe via .on(). */
+        EventRecorded: Hook<{
+            readonly eventName: string;
+            readonly payload: unknown;
+        }>;
+    }
+}
+/** Forge-specific framework-hook slot names — used by Runtime to materialise. */
+export declare const forgeFrameworkSlots: readonly ["ActionDispatching", "ActionCompleted", "ActionFailed", "EventRecording", "EventRecorded"];
+export type ForgeFrameworkSlot = (typeof forgeFrameworkSlots)[number];

package/dist/framework-events.js

@@ -1,70 +1,23 @@
 /**
- * Framework events — re-exports of app-layer events + forge-specific events.
+ * Forge framework-hook augmentation.
  *
- * The generic infrastructure (`defineFrameworkEvent` +
- * `FrameworkEventDefinition`) and the app-lifecycle events (App* / Plugin* /
- * Wire*) live in `@nwire/app`; this module re-exports them so consumers
- * pulling from forge get one import line.
+ * Action-specific and event-recording slots are added to the kernel's
+ * `FrameworkHooks` registry via TS module augmentation. Slots are
+ * materialised at runtime by `Runtime.defineHook(...)` calls in forge's
+ * `Runtime` constructor; once materialised, plugin code accesses them via:
  *
- * The action-specific events (`ActionDispatching` / `ActionCompleted` /
- * `ActionFailed`) and event-recording events (`EventRecording` /
- * `EventRecorded`) are defined here because their payload types reference
- * forge-specific types (`ActionDefinition`, `HandlerContext`) and the
- * domain-event bus forge owns.
- */
-import { defineFrameworkEvent } from "@nwire/app";
-// ─── Re-exports from @nwire/app ────────────────────────────────────
-export { defineFrameworkEvent, AppRegistering, AppBooting, AppBooted, AppReady, AppShuttingDown, AppShutdown, PluginRegistered, PluginBooting, PluginBooted, PluginShuttingDown, PluginShutdown, WireMounting, WireMounted, WireUnmounted, builtInLifecycleEvents, } from "@nwire/app";
-// ─── Action dispatch (forge-local — depends on ActionDefinition) ───
-/**
- * Fired before a dispatch reaches the handler. Interceptable: return
- * `false` to silently prevent execution, throw to fail with a specific
- * error, or mutate `payload.input` to transform what the handler sees.
- */
-export const ActionDispatching = defineFrameworkEvent("nwire.action.dispatching", "series-bail");
-/** Fired after a handler returns successfully. Observable; runs in parallel. */
-export const ActionCompleted = defineFrameworkEvent("nwire.action.completed", "parallel");
-/** Fired after a handler throws. Observable; runs in parallel. */
-export const ActionFailed = defineFrameworkEvent("nwire.action.failed", "parallel");
-// ─── Event recording (forge-local — about the domain event bus) ────
-/**
- * Fired before an event is persisted. Interceptable: return false to drop
- * the event (rarely useful in practice — events represent facts that
- * already happened). Throw to fail the dispatch that produced this event.
- */
-export const EventRecording = defineFrameworkEvent("nwire.event.recording", "series-bail");
-/** Fired after an event is persisted + workflows have been notified. */
-export const EventRecorded = defineFrameworkEvent("nwire.event.recorded", "parallel");
-// ─── Catalog ────────────────────────────────────────────────────
-/**
- * Every built-in framework event — union of app-lifecycle (from @nwire/app)
- * and forge-specific (action + event-recording). Studio reads this list to
- * render the "what can I hook into?" page.
+ *   runtime.hooks.ActionDispatching.use(async (p, next) => …);  // veto-able
+ *   runtime.hooks.ActionCompleted.on(({ action, result }) => …);
+ *
+ * App-lifecycle slots (App*, Plugin*, Wire*) live in `@nwire/app` and
+ * are pre-instantiated on every Runtime; this file only adds forge's
+ * domain-specific slots.
  */
-import { AppRegistering, AppBooting, AppBooted, AppReady, AppShuttingDown, AppShutdown, PluginRegistered, PluginBooting, PluginBooted, PluginShuttingDown, PluginShutdown, WireMounting, WireMounted, WireUnmounted, } from "@nwire/app";
-// Explicit annotation pins the type to the exported alias `FrameworkEventDefinition`
-// so the .d.ts emit stays portable (no transitive type leakage through the
-// `as const` array literal).
-export const builtInFrameworkEvents = [
-    AppRegistering,
-    AppBooting,
-    AppBooted,
-    AppReady,
-    AppShuttingDown,
-    AppShutdown,
-    PluginRegistered,
-    PluginBooting,
-    PluginBooted,
-    PluginShuttingDown,
-    PluginShutdown,
-    WireMounting,
-    WireMounted,
-    WireUnmounted,
-    ActionDispatching,
-    ActionCompleted,
-    ActionFailed,
-    EventRecording,
-    EventRecorded,
+/** Forge-specific framework-hook slot names — used by Runtime to materialise. */
+export const forgeFrameworkSlots = [
+    "ActionDispatching",
+    "ActionCompleted",
+    "ActionFailed",
+    "EventRecording",
+    "EventRecorded",
 ];
-void {};
-//# sourceMappingURL=framework-events.js.map

package/dist/{cli-runner.d.ts → helpers/cli-runner.d.ts}

@@ -12,7 +12,7 @@
  *
  *   #!/usr/bin/env node
  *   import { runCli } from '@nwire/forge'
- *   import { boot } from './app/boot.js'
+ *   import { boot } from './app/boot'
  *
  *   const app = await boot()           // returns { learnflow: App }
  *   const exitCode = await runCli(app.learnflow, process.argv.slice(2))
@@ -33,7 +33,7 @@
  * Wire-mode invariance: same domain handlers run in HTTP, queue, and CLI.
  * The CLI doesn't know about HTTP routes; it dispatches via the runtime.
  */
-import type { App } from "./create-app.js";
+import type { ForgeApp as App } from "../runtime/create-forge-app.js";
 export interface RunCliOptions {
     /**
      * Override stdout/stderr — useful for tests. Defaults to console.log /
@@ -43,4 +43,3 @@ export interface RunCliOptions {
     readonly stderr?: (line: string) => void;
 }
 export declare function runCli(app: App, argv: readonly string[], options?: RunCliOptions): Promise<number>;
-//# sourceMappingURL=cli-runner.d.ts.map