@nwire/app 0.9.2 → 0.10.1

package/README.md

@@ -1,116 +1,102 @@
 # @nwire/app
 
-> Plugin primitive, framework-event bus, and the lifecycle event catalog every app fires.
-
-The "app" layer of the sealed architecture. Ships `definePlugin`, the
-typed `FrameworkEventBus`, and the built-in lifecycle events. The
-composition root (`createApp`) currently lives in `@nwire/forge` and
-re-exports everything here so a single import line keeps working.
+> The composition root. `createApp`, `appCompose`, `definePlugin`,
+> runtime, framework events.
 
 ```bash
 pnpm add @nwire/app
 ```
 
-## Quick example
+## Quick start
 
 ```ts
-import {
-  FrameworkEventBus,
-  AppBooted,
-  PluginBooting,
-  defineFrameworkEvent,
-  definePlugin,
-} from "@nwire/app";
-import { NoopLogger } from "@nwire/logger";
-
-const bus = new FrameworkEventBus(new NoopLogger());
-
-bus.on(AppBooted, ({ appName, bootedAt }) => {
-  console.log(`${appName} booted at ${bootedAt}`);
-});
+import { createApp } from "@nwire/app";
+import { post } from "@nwire/wires/http";
+import { z } from "zod";
 
-// A series-bail handler can veto by returning `false`.
-bus.on(PluginBooting, ({ pluginName }) => {
-  if (pluginName === "broken") return false;
-});
+const app = createApp({ appName: "api" });
 
-// User-defined framework event — same machinery.
-const TenantSwitched = defineFrameworkEvent<{ tenantId: string }>(
-  "app.tenant-switched",
-  "parallel",
+app.wire(
+  post("/hello", { body: z.object({ name: z.string() }) }),
+  async (input) => ({ message: `Hello, ${input.name}!` }),
 );
-bus.on(TenantSwitched, ({ tenantId }) => console.log("→", tenantId));
-await bus.fire(TenantSwitched, { tenantId: "acme" });
-
-// definePlugin — narrow primitive (no forge-specific knowledge).
-export const tracing = definePlugin("tracing", ({ provide, on, boot }) => {
-  provide("tracer", {
-    boot: () => createTracer(),
-    shutdown: (t) => t.shutdown(),
-  });
-  on(AppBooted, ({ appName }) => console.log(`tracing live on ${appName}`));
-  boot(async () => {
-    /* warm-up */
+```
+
+`createApp` builds an **App** — a bounded context with its container,
+plugins, and wires. The App is the unit you `endpoint().mount()` later.
+
+## Plugins
+
+`definePlugin(name, setup)` declares an installable plugin. Plugins
+receive a `PluginContext` with `bind` (register on the container) and
+`dispose` (run on shutdown):
+
+```ts
+import { definePlugin } from "@nwire/app";
+
+const todoStorePlugin = () =>
+  definePlugin("todo-store", ({ bind, dispose }) => {
+    const store = new TodoStore();
+    bind("todos", store);
+    dispose(async () => store.close());
   });
+
+const app = createApp({
+  appName: "todo",
+  plugins: [todoStorePlugin()],
 });
 ```
 
-## Surface
+The runtime boots plugins in declaration order and disposes them in
+reverse on shutdown.
 
-| Export                                                                                          | Role                                                                      |
-| ----------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------- |
-| `FrameworkEventBus`                                                                             | Typed dispatcher; one per app instance.                                   |
-| `defineFrameworkEvent`                                                                          | Declare a typed event + its dispatch mode.                                |
-| `definePlugin(name, setup)`                                                                     | Narrow plugin: `provide` / `on` / `boot` / `shutdown`.                    |
-| `isAppPlugin(x)`                                                                                | Type guard for `definePlugin` output.                                     |
-| `AppRegistering` (series-bail)                                                                  | Before provider boot — vetoable.                                          |
-| `AppBooting` (series-bail)                                                                      | After provider boot, before plugin boot — vetoable.                       |
-| `AppBooted` (parallel)                                                                          | All plugins booted.                                                       |
-| `AppReady` (parallel)                                                                           | Wire mounted, K8s `/ready` flipped.                                       |
-| `AppShuttingDown` (series-bail)                                                                 | Vetoable shutdown signal.                                                 |
-| `AppShutdown` (parallel)                                                                        | Everything torn down.                                                     |
-| `PluginRegistered` / `PluginBooting` / `PluginBooted` / `PluginShuttingDown` / `PluginShutdown` | Per-plugin lifecycle, all carry an optional `kind: "plugin" \| "module"`. |
-| `WireMounting` (series-bail) / `WireMounted` / `WireUnmounted`                                  | Transport mount lifecycle, fired by `@nwire/endpoint`.                    |
-| `builtInLifecycleEvents`                                                                        | Array of every built-in above — useful for observability adapters.        |
-
-### Dispatch modes (tense convention)
-
-| Mode          | Tense   | Semantics                                                     |
-| ------------- | ------- | ------------------------------------------------------------- |
-| `series-bail` | `*-ing` | Sequential await. Return `false` to short-circuit.            |
-| `series`      | (rare)  | Sequential await. Throw stops the chain.                      |
-| `parallel`    | `*-ed`  | `Promise.allSettled`; one failing handler logs but continues. |
-
-`FrameworkEventBus.fire()` returns `false` only when a `series-bail`
-handler vetoed; `true` otherwise.
-
-### Module-as-plugin
-
-Modules participate in the same plugin lifecycle. `PluginRegistered` /
-`PluginBooting` / `PluginBooted` payloads carry an optional
-`kind: "plugin" | "module"` field so Studio + observability adapters
-render each with the right affordance.
-
-## When to reach for which `definePlugin`
-
-| You need…                                | Use            |
-| ---------------------------------------- | -------------- |
-| Bind a DB / cache / SDK to the container | `@nwire/app`   |
-| React to lifecycle events                | `@nwire/app`   |
-| Intercept every action dispatch          | `@nwire/forge` |
-| Hook actor transitions                   | `@nwire/forge` |
-| `before("action.x", ...)` sugar          | `@nwire/forge` |
-
-`@nwire/forge`'s richer `definePlugin` is a superset — both shapes
-coexist in the same plugin list and the runtime dispatches each through
-the right wiring path.
+## Multi-app composition
 
-## Related
+Apps don't have to be the whole process. `appCompose(...apps)` merges
+several Apps into one — each keeps its own container and plugins;
+adopters see the merged wire collection but routes back to the source
+app's container per dispatch.
 
-- `@nwire/forge` — wraps this package and adds the action/actor primitives.
-- `@nwire/hooks` — the dispatch substrate; `FrameworkEventBus` adopts a per-event hook lazily so `listHooks()` and `nwire scan` see every framework event.
-- `@nwire/endpoint` — fires `WireMounting` / `WireMounted` / `WireUnmounted` on this bus.
+```ts
+import { appCompose, createApp } from "@nwire/app";
 
-## Status
+const ordersApp = createApp({ appName: "orders" /* ... */ });
+const inventoryApp = createApp({ appName: "inventory" /* ... */ });
+
+const monolith = appCompose(ordersApp, inventoryApp);
+await endpoint("monolith", { port: 3000 })
+  .use(httpKoa())
+  .mount(monolith)
+  .run();
+```
+
+## Framework events
+
+The runtime fires typed events at lifecycle transitions —
+`AppBooting`, `AppBooted`, `PluginBooting`, `PluginBooted`,
+`AppStopping`, `AppStopped`. Subscribe via the App's `FrameworkEventBus`
+or register a `FrameworkEventBus` hook from a plugin.
+
+```ts
+import { AppBooted } from "@nwire/app";
+
+app.frameworkBus.on(AppBooted, ({ appName, bootedAt }) => {
+  console.log(`${appName} booted at ${bootedAt}`);
+});
+```
+
+## Surface
+
+- `createApp(opts)` — builds an App
+- `appCompose(...apps)` — merges Apps for monolith composition
+- `definePlugin(name, setup)` — plugin factory
+- `App`, `CreateAppOptions`, `PluginContext`, `PluginDefinition` — core types
+- `Runtime`, `createRuntime` — the per-App runtime
+- `FrameworkEventBus`, lifecycle events — `AppBooting`, `AppBooted`, etc.
+
+## Related
 
-v0.x — `definePlugin` closure shape, framework-event catalog, and dispatch modes are locked. `createApp` extraction from forge is a follow-up; imports won't change.
+- [`@nwire/endpoint`](../core-endpoint) — mounts the App under adopters
+- [`@nwire/wires`](../core-wires) — binding helpers used by `app.wire`
+- [`@nwire/container`](../core-container) — DI binding the App owns
+- [`@nwire/forge`](../core-forge) — `createForgePlugin` for actions/workflows

package/dist/app.d.ts

@@ -1,27 +1,10 @@
 /**
- * `@nwire/app` — managed Container with plugin lifecycle and framework events.
- *
- * The "app" layer of the sealed architecture. Composes modules + plugins,
- * boots them in order, exposes a Container, and fires framework events at
- * every lifecycle transition.
- *
- * What it ships:
- *
- *   - `defineFrameworkEvent<TPayload>(name, mode)` — declare a typed
- *     lifecycle event (`series-bail` / `parallel` / `series` dispatch).
- *   - `FrameworkEventBus` — the dispatcher; one per app instance.
- *   - `definePlugin(name, setup)` — the only extension primitive.
- *   - `App*` events (`AppRegistering` / `AppBooting` / `AppBooted` /
- *     `AppReady` / `AppShuttingDown` / `AppShutdown`) plus their plugin
- *     counterparts (`PluginRegistered` / `PluginBooting` / `PluginBooted`).
- *
- * `createApp` (the composition root) currently lives in `@nwire/forge`; it
- * will move here in a follow-up. Forge re-exports the framework-event types
- * so consumers don't need to update imports.
+ * `@nwire/app` — composition root. `createApp` constructs a Runtime, runs
+ * plugin setup, and drives start/stop. `createRuntime` exposes the raw
+ * substrate for advanced cases.
  */
-export { defineFrameworkEvent, AppRegistering, AppBooting, AppBooted, AppReady, AppShuttingDown, AppShutdown, PluginRegistered, PluginBooting, PluginBooted, PluginShuttingDown, PluginShutdown, WireMounting, WireMounted, WireUnmounted, builtInLifecycleEvents, type FrameworkEventDefinition, type FrameworkEventMode, } from "./framework-events.js";
-export { FrameworkEventBus, type FrameworkEventHandler, type FrameworkEventObserver, type FrameworkEventObservation, } from "./framework-event-bus.js";
-export { definePlugin, isAppPlugin, type AppPluginContext, type AppPluginDefinition, type BindingLifecycle, } from "./define-plugin.js";
+export { Runtime, createRuntime, serializeError, type DispatchHookCtx, type DispatchMiddleware, type HookStepTelemetry, type RuntimeOptions, type SerializedError, type Telemetry, type TelemetryListener, type FrameworkHooks, type PluginKind, type PluginDefinition, type PluginContext, } from "./runtime/index.js";
+export { definePlugin, isPlugin } from "./define-plugin.js";
 export { createApp, type App, type CreateAppOptions } from "./create-app.js";
-export { Runtime, serializeError, type DispatchHookCtx, type DispatchMiddleware, type HookStepTelemetry, type LifecycleTelemetry, type RuntimeOptions, type SerializedError, type Telemetry, type TelemetryListener, } from "./runtime.js";
-//# sourceMappingURL=app.d.ts.map
+export { appCompose, containerOf, type AppComposeOptions, type CollisionPolicy, } from "./compose-app.js";
+export type { HandlerBaseCtx, Ctx } from "@nwire/handler";

package/dist/app.js

@@ -1,27 +1,9 @@
 /**
- * `@nwire/app` — managed Container with plugin lifecycle and framework events.
- *
- * The "app" layer of the sealed architecture. Composes modules + plugins,
- * boots them in order, exposes a Container, and fires framework events at
- * every lifecycle transition.
- *
- * What it ships:
- *
- *   - `defineFrameworkEvent<TPayload>(name, mode)` — declare a typed
- *     lifecycle event (`series-bail` / `parallel` / `series` dispatch).
- *   - `FrameworkEventBus` — the dispatcher; one per app instance.
- *   - `definePlugin(name, setup)` — the only extension primitive.
- *   - `App*` events (`AppRegistering` / `AppBooting` / `AppBooted` /
- *     `AppReady` / `AppShuttingDown` / `AppShutdown`) plus their plugin
- *     counterparts (`PluginRegistered` / `PluginBooting` / `PluginBooted`).
- *
- * `createApp` (the composition root) currently lives in `@nwire/forge`; it
- * will move here in a follow-up. Forge re-exports the framework-event types
- * so consumers don't need to update imports.
+ * `@nwire/app` — composition root. `createApp` constructs a Runtime, runs
+ * plugin setup, and drives start/stop. `createRuntime` exposes the raw
+ * substrate for advanced cases.
  */
-export { defineFrameworkEvent, AppRegistering, AppBooting, AppBooted, AppReady, AppShuttingDown, AppShutdown, PluginRegistered, PluginBooting, PluginBooted, PluginShuttingDown, PluginShutdown, WireMounting, WireMounted, WireUnmounted, builtInLifecycleEvents, } from "./framework-events.js";
-export { FrameworkEventBus, } from "./framework-event-bus.js";
-export { definePlugin, isAppPlugin, } from "./define-plugin.js";
+export { Runtime, createRuntime, serializeError, } from "./runtime/index.js";
+export { definePlugin, isPlugin } from "./define-plugin.js";
 export { createApp } from "./create-app.js";
-export { Runtime, serializeError, } from "./runtime.js";
-//# sourceMappingURL=app.js.map
+export { appCompose, containerOf, } from "./compose-app.js";

package/dist/compose-app.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `appCompose(...apps)` — multi-app composition.
+ *
+ * Takes one-or-more `App` values and returns ONE composite App whose
+ * `interface` merges every child's wires (tagged by the source app), and
+ * whose `containerOf(wire)` resolver routes each wire back to its source
+ * app's container.
+ *
+ *   const orders  = createApp({ appName: "orders", ... }).wire(post("/orders"), placeOrder);
+ *   const billing = createApp({ appName: "billing", ... }).wire(post("/invoices"), createInvoice);
+ *
+ *   const composite = appCompose(orders, billing);
+ *
+ *   // composite is itself an App: endpoint.use(adopter).mount(composite).run()
+ *
+ * Optional third-arg overload — pass `{ onCollision }` as the last arg
+ * to override the default collision policy (throw on duplicate
+ * `(adapter, key)` pairs across child apps).
+ */
+import { type Wire } from "@nwire/wires";
+import type { App } from "./create-app.js";
+export type CollisionPolicy = "throw" | "first" | "last";
+export interface AppComposeOptions {
+    readonly onCollision?: CollisionPolicy;
+}
+export declare function appCompose(...args: [...App[], AppComposeOptions]): App;
+export declare function appCompose(...apps: App[]): App;
+/**
+ * `containerOf(wire)` — resolves a wire to its source app's container.
+ * Endpoint adopters call this when building per-request scopes so the
+ * resolve path lands in the right app. For wires that came in via
+ * `app.wire()` (not through `appCompose`) the wire carries no source
+ * reference, and adopters fall back to the endpoint's default container.
+ */
+export declare function containerOf(wire: Wire): any | undefined;

package/dist/compose-app.js

@@ -0,0 +1,138 @@
+/**
+ * `appCompose(...apps)` — multi-app composition.
+ *
+ * Takes one-or-more `App` values and returns ONE composite App whose
+ * `interface` merges every child's wires (tagged by the source app), and
+ * whose `containerOf(wire)` resolver routes each wire back to its source
+ * app's container.
+ *
+ *   const orders  = createApp({ appName: "orders", ... }).wire(post("/orders"), placeOrder);
+ *   const billing = createApp({ appName: "billing", ... }).wire(post("/invoices"), createInvoice);
+ *
+ *   const composite = appCompose(orders, billing);
+ *
+ *   // composite is itself an App: endpoint.use(adopter).mount(composite).run()
+ *
+ * Optional third-arg overload — pass `{ onCollision }` as the last arg
+ * to override the default collision policy (throw on duplicate
+ * `(adapter, key)` pairs across child apps).
+ */
+import { createInterface } from "@nwire/wires";
+/**
+ * Derive a stable key for collision detection from a wire's binding.
+ * Different adopters expose different identifying fields (path / queue /
+ * schedule / tool / field); the composer reads them generically.
+ */
+function bindingKey(wire) {
+    const b = wire.binding;
+    const adapter = b.$adapter;
+    // Pick the most-distinctive field per known adapter kind.
+    const id = b.path ??
+        b.queue ??
+        b.schedule ??
+        b.tool ??
+        b.field ??
+        b.uriTemplate ??
+        "?";
+    const verb = b.verb ?? "";
+    return `${adapter}:${verb ? `${verb}:` : ""}${id}`;
+}
+function isComposeOptions(x) {
+    return (typeof x === "object" &&
+        x !== null &&
+        !("interface" in x) &&
+        "onCollision" in x);
+}
+export function appCompose(...args) {
+    // Trailing options arg?
+    const last = args.length > 0 ? args[args.length - 1] : undefined;
+    const options = last && isComposeOptions(last) ? last : {};
+    const apps = (last && isComposeOptions(last) ? args.slice(0, -1) : args);
+    if (apps.length === 0) {
+        throw new Error("appCompose: at least one app is required");
+    }
+    if (apps.length === 1)
+        return apps[0];
+    const policy = options.onCollision ?? "throw";
+    const mergedInterface = createInterface();
+    const seen = new Map();
+    for (const childApp of apps) {
+        for (const wire of childApp.interface.wires) {
+            const key = bindingKey(wire);
+            const prior = seen.get(key);
+            if (prior && prior !== childApp) {
+                if (policy === "throw") {
+                    throw new Error(`appCompose: wire collision on "${key}" — first registered by app "${prior.appName}", colliding from app "${childApp.appName}". ` +
+                        `Pass { onCollision: "first" | "last" } to override.`);
+                }
+                if (policy === "first")
+                    continue;
+            }
+            // Tag the wire with its source app so containerOf can route correctly.
+            mergedInterface.wire(wire.binding, wire.handler);
+            // Stash the source-app reference on the last appended wire.
+            const appended = mergedInterface.wires[mergedInterface.wires.length - 1];
+            appended.app = childApp;
+            seen.set(key, childApp);
+        }
+    }
+    // The composite presents as an App. It re-uses the FIRST child's
+    // runtime / container / start / stop / etc. — the composite is for
+    // wire surface, not for runtime fan-out. Multi-runtime composition is
+    // not supported in 0.10; if you want it, mount each app under its own
+    // endpoint instead.
+    const head = apps[0];
+    const compositeName = apps.map((a) => a.appName).join("+");
+    const composite = {
+        $nwireApp: true,
+        $kind: "app",
+        appName: compositeName,
+        name: compositeName,
+        container: head.container,
+        runtime: head.runtime,
+        interface: mergedInterface,
+        plugins: apps.flatMap((a) => a.plugins),
+        wire(binding, handler) {
+            mergedInterface.wire(binding, handler);
+            return composite;
+        },
+        provide(builder) {
+            mergedInterface.provide(builder);
+            return composite;
+        },
+        async start() {
+            for (const a of apps)
+                await a.start();
+        },
+        async stop(reason) {
+            for (const a of [...apps].reverse())
+                await a.stop(reason);
+        },
+        boot() {
+            return composite.start();
+        },
+        shutdown() {
+            return composite.stop();
+        },
+        async dispatchFrameworkEvent(slot, payload) {
+            for (const a of apps) {
+                const ok = await a.dispatchFrameworkEvent(slot, payload);
+                if (!ok)
+                    return false;
+            }
+            return true;
+        },
+    };
+    return composite;
+}
+/**
+ * `containerOf(wire)` — resolves a wire to its source app's container.
+ * Endpoint adopters call this when building per-request scopes so the
+ * resolve path lands in the right app. For wires that came in via
+ * `app.wire()` (not through `appCompose`) the wire carries no source
+ * reference, and adopters fall back to the endpoint's default container.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function containerOf(wire) {
+    return wire.app?.container;
+}

package/dist/create-app.d.ts

@@ -1,87 +1,59 @@
 /**
- * `createApp` — generic plugin-lifecycle composition root.
- *
- * Boots a Container + a FrameworkEventBus with the supplied plugins.
- * Lightweight: no forge concepts (no Runtime, no actors, no workflows,
- * no module dep graph). For the full forge experience use `createApp`
- * from `@nwire/forge`, which composes on top of this primitive.
- *
- * What this does, in order, during `start()`:
- *
- *   1. Register every plugin synchronously — `setup(ctx)` runs; bindings
- *      declared via `ctx.provide()` are collected; framework subscriptions
- *      via `ctx.on()` are wired on the bus; boot/shutdown callbacks are
- *      captured into ordered lists.
- *   2. Fire `AppRegistering` (series-bail). A vetoing subscriber aborts.
- *   3. Boot every provided binding: call `lifecycle.boot()`, register the
- *      value on the container under its declared name. Failures abort.
- *   4. Fire `AppBooting` (series-bail). A vetoing subscriber aborts.
- *   5. Run each plugin's accumulated `boot` callbacks in registration order.
- *   6. Fire `AppBooted` (parallel).
- *
- * `stop(reason?)`:
- *
- *   1. Fire `AppShuttingDown` (series-bail).
- *   2. Run plugin `shutdown` callbacks in REVERSE registration order.
- *   3. Call `lifecycle.shutdown(value)` on each provided binding (reverse).
- *   4. Fire `AppShutdown` (parallel).
- *
- * The returned `App` satisfies `AppServable` from `@nwire/endpoint`, so
- * `endpoint("api").serve(app).run()` works without any glue.
+ * `createApp` — composition root. Constructs a Runtime, registers
+ * plugins, and exposes the lifecycle the runtime owns.
  */
-import { type Container } from "@nwire/container";
+import { type Container } from "@nwire/container/awilix";
 import { type Logger } from "@nwire/logger";
-import { FrameworkEventBus } from "./framework-event-bus.js";
-import { type AppPluginDefinition } from "./define-plugin.js";
+import { type Binding, type HandlerDef, type Interface, type WireCtxBuilder } from "@nwire/wires";
+import { type PluginDefinition, type Runtime } from "./runtime/index.js";
 export interface CreateAppOptions {
-    /** App name — surfaces in framework-event payloads + dev logger output. */
+    /** App name — surfaces in framework-hook payloads + dev logger output. */
     readonly appName: string;
-    /** Plugin definitions to register. */
-    readonly plugins?: readonly AppPluginDefinition[];
+    /** Plugins. Setup runs synchronously at construction. */
+    readonly plugins?: readonly PluginDefinition[];
+    /**
+     * Handlers — registered on the runtime at construction so any plugin
+     * (forge, queue, …) can pick them up during boot. Each handler must
+     * satisfy the structural shape `runtime.registerHandler` accepts
+     * (`name`, `input`, `run(ctx, opts?)` returning `{ result }`).
+     */
+    readonly handlers?: readonly any[];
     /** Override the container — defaults to a fresh `createContainer()`. */
     readonly container?: Container;
-    /** Override the framework-event bus — defaults to a fresh `FrameworkEventBus`. */
-    readonly bus?: FrameworkEventBus;
-    /** Logger for plugin lifecycle messages + framework-event errors. */
+    /** Override the runtime — defaults to a fresh `createRuntime({...})`. */
+    readonly runtime?: Runtime;
+    /** Logger override. */
     readonly logger?: Logger;
 }
-/**
- * App handle — structurally `AppServable` for `@nwire/endpoint`. The
- * `runtime` field is `undefined` here (no forge); `@nwire/forge`'s richer
- * createApp returns the same shape with `runtime` populated.
- */
 export interface App {
     readonly $nwireApp: true;
+    readonly $kind: "app";
     readonly appName: string;
+    /** Alias for appName — foundation-spec name field. */
+    readonly name: string;
     readonly container: Container;
-    readonly bus: FrameworkEventBus;
-    readonly plugins: readonly AppPluginDefinition[];
+    readonly runtime: Runtime;
+    /**
+     * Wire collection — the same shape as `createInterface()` standalone.
+     * Adopters consume `app.interface.forAdapter(kind)`; foundation-form
+     * apps wire bindings via `app.wire(b, h)` sugar.
+     */
+    readonly interface: Interface;
+    readonly plugins: readonly PluginDefinition[];
+    /** Sugar for `app.interface.wire(b, h)`. Returns the app for chaining. */
+    wire(binding: Binding, handler: HandlerDef): this;
+    /** Sugar for `app.interface.provide(builder)`. Returns the app for chaining. */
+    provide<TExtras extends object>(builder: WireCtxBuilder<TExtras>): this;
     start(): Promise<void>;
     stop(reason?: string): Promise<void>;
-    /** AppServable conformance — alias for `start()`. */
+    /** Endpoint alias. */
     boot(): Promise<void>;
-    /** AppServable conformance — alias for `stop()`. */
+    /** Endpoint alias. */
     shutdown(): Promise<void>;
     /**
-     * Dispatch a framework lifecycle event on the app's bus by name. The
-     * endpoint uses this to fire `nwire.wire.mounting / .mounted / .unmounted`
-     * and `nwire.app.ready` at the right serve-loop points. Returns `false`
-     * when a series-bail subscriber prevented; `true` otherwise.
+     * Run a built-in framework hook by registry-slot name. Resolves `false`
+     * when a chain step vetoed (skipped `next()` or threw); `true` otherwise.
      */
-    dispatchFrameworkEvent(eventName: string, payload: unknown): Promise<boolean>;
+    dispatchFrameworkEvent(slot: string, payload: unknown): Promise<boolean>;
 }
-/**
- * Build a generic Nwire app from plugin definitions. No forge concepts —
- * use `@nwire/forge`'s `createApp` for the rich CQRS / actor / workflow
- * surface.
- *
- *   const app = createApp({
- *     appName: "users",
- *     plugins: [authPlugin, dbPlugin],
- *   });
- *   await app.start();
- *   // app.container.cradle.db is now resolvable
- *   await app.stop();
- */
 export declare function createApp(options: CreateAppOptions): App;
-//# sourceMappingURL=create-app.d.ts.map