@nwire/app 0.9.2 → 0.10.0

package/dist/runtime/runtime.js

@@ -0,0 +1,642 @@
+/**
+ * Runtime — Container, dispatch hook, FrameworkHooks registry, telemetry
+ * stream, plugin lifecycle. The dispatch hook composes user middleware
+ * via `runtime.use(...)` around an inner pinned step that calls the
+ * registered handler. Plugins materialise additional FrameworkHooks
+ * slots via `runtime.defineHook(name)` and TS module augmentation.
+ */
+import { createContainer } from "@nwire/container/awilix";
+import { hook } from "@nwire/hooks";
+import { NoopLogger } from "@nwire/logger";
+import { seedEnvelope, deriveEnvelope } from "@nwire/envelope";
+import { createFrameworkHooks, isBuiltInHook } from "./framework-hooks.js";
+export function serializeError(err) {
+    if (err instanceof Error) {
+        const out = {
+            name: err.name,
+            message: err.message,
+            stack: err.stack,
+        };
+        for (const k of Object.keys(err)) {
+            if (k === "name" || k === "message" || k === "stack")
+                continue;
+            out[k] = err[k];
+        }
+        return out;
+    }
+    return { name: "NonError", message: String(err) };
+}
+export class Runtime {
+    container;
+    _logger;
+    appName;
+    /**
+     * Public accessor — external dispatchers compose runtimes and need the
+     * logger; test-kit harness extensions also swap it in for tap capture.
+     */
+    get logger() {
+        return this._logger;
+    }
+    set logger(value) {
+        this._logger = value;
+    }
+    /** Public accessor — external dispatchers register middleware via this hook. */
+    get dispatchHook$() {
+        return this.dispatchHook;
+    }
+    /**
+     * Dispatch substrate. Subclasses register their pinned `handler` step at
+     * priority `-Infinity` and call `dispatchHook.run(ctx)` from their own
+     * `dispatch` method. The tap forwards every chain step to the canonical
+     * telemetry stream.
+     */
+    dispatchHook;
+    userMiddlewareCount = 0;
+    /**
+     * Per-runtime framework-hook registry. Built-in slots (App*, Plugin*,
+     * Wire*) are pre-instantiated; plugins augment the `FrameworkHooks`
+     * interface and materialise their slots via `defineHook(name)`.
+     */
+    hooks;
+    telemetryListeners = [];
+    /**
+     * Handler registry — keyed by `handler.name`. Populated via
+     * `registerHandler(handler)` so consumers can dispatch by name:
+     * `runtime.execute("orders.place", input)`. Adapters (HTTP, queue, MCP)
+     * also iterate this for their own wire / tool tables.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    handlers = new Map();
+    /**
+     * Per-event subscriber registry — keyed by `event.name`. Subscribers
+     * attach via `runtime.subscribe(event, fn)` and fire on `runtime.emit(
+     * event, payload)`. Foundation calls this out as the broadcast verb
+     * distinct from telemetry-push (`runtime.pushTelemetry(record)`).
+     */
+    eventListeners = new Map();
+    /**
+     * Registered plugins (one entry per `registerPlugin(def)` call). Each
+     * carries the captured boot/dispose closures the setup contributed.
+     * Boot fires in FIFO order at `start()`; dispose fires in LIFO order
+     * at `stop()`.
+     */
+    plugins = [];
+    /**
+     * Lifecycle state machine. Both `start()` and `stop()` are idempotent
+     * and in-flight-shared: a second call while the first is still pending
+     * returns the same Promise; a second call after completion is a no-op.
+     */
+    lifecycle = "idle";
+    startPromise;
+    stopPromise;
+    constructor(options = {}) {
+        this.container = options.container ?? createContainer();
+        this._logger = options.logger ?? new NoopLogger();
+        this.appName = options.appName ?? "app";
+        this.hooks = createFrameworkHooks();
+        for (const h of Object.values(this.hooks)) {
+            this.observe(h);
+        }
+        this.dispatchHook = hook("runtime.dispatch");
+        this.observe(this.dispatchHook);
+    }
+    /**
+     * Materialise a slot on `runtime.hooks` for a plugin-defined framework
+     * hook. Idempotent — calling twice with the same name returns the same
+     * Hook. The slot is automatically observed for telemetry.
+     *
+     * Pair this with TS module augmentation:
+     *
+     *   declare module "@nwire/app" {
+     *     interface FrameworkHooks {
+     *       MyEvent: Hook<{ tenant: string }>;
+     *     }
+     *   }
+     *
+     *   const h = runtime.defineHook<{ tenant: string }>("MyEvent");
+     */
+    defineHook(name) {
+        const reg = this.hooks;
+        const existing = reg[name];
+        if (existing)
+            return existing;
+        const h = hook(`runtime.${name}`);
+        reg[name] = h;
+        this.observe(h);
+        return h;
+    }
+    /**
+     * Register a dispatch middleware. Outermost first — the order you call
+     * `use()` is the order layers wrap (first `use` is the outermost layer).
+     * Middlewares run once per dispatch, outside the retry loop.
+     *
+     * Each user middleware gets a distinct negative priority so the chain
+     * order matches registration order; the pinned subclass-owned "handler"
+     * step at `-Infinity` stays strictly innermost.
+     */
+    use(middleware) {
+        const priority = -this.userMiddlewareCount;
+        this.userMiddlewareCount += 1;
+        this.dispatchHook.use(async (hctx, next) => {
+            hctx.result = await middleware(async () => {
+                await next();
+                return hctx.result;
+            }, hctx.action, hctx.input, hctx.ctx);
+        }, { name: middleware.name || `middleware#${this.userMiddlewareCount}`, priority });
+    }
+    /**
+     * Wire a hook's per-step tap into the canonical telemetry stream. After
+     * this call, every `.use()` / `.on()` step on the hook emits a
+     * `kind: "hook.step"` record through `runtime.onTelemetry`, the same way
+     * the built-in `runtime.dispatch` hook does.
+     *
+     * The framework calls this for every framework hook in the registry;
+     * plugin authors can call it on their own hooks if they want their
+     * extension points surfaced in Studio / dev-logger / OTel for free.
+     */
+    observe(hk) {
+        hk.tap((obs) => {
+            this.pushTelemetry({
+                kind: "hook.step",
+                hookName: obs.hookName,
+                hookId: obs.hookId,
+                runId: obs.runId,
+                parentRunId: obs.parentRunId,
+                stepId: obs.stepId,
+                stepKind: obs.stepKind,
+                stepName: obs.stepName,
+                phase: obs.phase,
+                durationMs: obs.durationMs,
+                error: obs.error ? serializeError(obs.error) : undefined,
+                appName: this.appName,
+                ts: new Date().toISOString(),
+            });
+        });
+    }
+    /**
+     * Subscribe to the canonical telemetry stream. Returns an unsubscribe.
+     * Throwing in a listener is caught and logged; never breaks dispatch.
+     */
+    onTelemetry(listener) {
+        this.telemetryListeners.push(listener);
+        return () => this.offTelemetry(listener);
+    }
+    offTelemetry(listener) {
+        const i = this.telemetryListeners.indexOf(listener);
+        if (i >= 0)
+            this.telemetryListeners.splice(i, 1);
+    }
+    /**
+     * Push a record onto the telemetry stream. Accepts `unknown` so
+     * subclass-widened records (CQRS kinds in forge) don't need cast
+     * gymnastics — listeners narrow with `switch (rec.kind)`.
+     *
+     * Public so external dispatchers (forge's ForgeDispatcher composed
+     * around a Runtime instance) can push records without subclassing.
+     * Misuse risk is low: callers who own a Runtime are by definition
+     * inside the trust boundary.
+     *
+     * Renamed from `emit` to free that name for the canonical event-
+     * broadcast verb (see `Runtime.emit(event, payload, envelope?)`).
+     */
+    pushTelemetry(record) {
+        if (this.telemetryListeners.length === 0)
+            return;
+        for (const listener of this.telemetryListeners) {
+            try {
+                listener(record);
+            }
+            catch (err) {
+                // Best-effort — don't let a bad listener break dispatch.
+                // eslint-disable-next-line no-console
+                console.error("Runtime.onTelemetry listener threw:", err);
+            }
+        }
+    }
+    getContainer() {
+        return this.container;
+    }
+    /** Current lifecycle phase. */
+    get state() {
+        return this.lifecycle;
+    }
+    // ─── Plugin registration + lifecycle ───────────────────────────────
+    /**
+     * Register a plugin. The setup closure runs synchronously now —
+     * `bind()` calls land on the container immediately; `boot()` /
+     * `dispose()` calls accumulate queues that fire at `start()` /
+     * `stop()`. Returns the registered entry for callers that want it
+     * (rare — most consumers just discard).
+     *
+     * Plugin re-registration with the same `name` throws. Plugin setup
+     * may NOT await — async work belongs in `boot()`.
+     */
+    registerPlugin(plugin) {
+        if (this.lifecycle !== "idle") {
+            throw new Error(`Runtime.registerPlugin: cannot register "${plugin.name}" — runtime is "${this.lifecycle}".`);
+        }
+        if (this.plugins.some((p) => p.name === plugin.name)) {
+            throw new Error(`Runtime.registerPlugin: plugin "${plugin.name}" already registered.`);
+        }
+        const boots = [];
+        const disposes = [];
+        const runtime = this;
+        const ctx = {
+            container: this.container,
+            runtime,
+            hooks: this.hooks,
+            bind: (name, factory, opts) => {
+                this.container.register(name, factory, opts);
+            },
+            boot: (fn) => {
+                boots.push(fn);
+            },
+            dispose: (fn) => {
+                disposes.push(fn);
+            },
+            defineHook: (name) => this.defineHook(name),
+        };
+        // The setup closure must be synchronous; we deliberately ignore any
+        // returned Promise — plugin authors put async work in boot().
+        plugin.setup(ctx);
+        const entry = {
+            name: plugin.name,
+            boots,
+            disposes,
+        };
+        this.plugins.push(entry);
+        return entry;
+    }
+    /**
+     * Two-phase boot. Idempotent + in-flight-shared.
+     *
+     *   1. Fire `PluginRegistered` for each registered plugin (observable).
+     *   2. Fire `AppRegistering` chain (vetoable via skip-next).
+     *   3. Fire `AppBooting` chain (vetoable via skip-next).
+     *   4. For each plugin in registration order:
+     *        - fire `PluginBooting` chain (vetoable)
+     *        - await every queued `boot()` fn for that plugin
+     *        - fire `PluginBooted` (observable)
+     *   5. Run container health checks; fail-fast if any throw.
+     *   6. Fire `AppBooted` + `AppReady` (observable).
+     */
+    start() {
+        if (this.startPromise)
+            return this.startPromise;
+        if (this.lifecycle === "running")
+            return Promise.resolve();
+        if (this.lifecycle !== "idle") {
+            return Promise.reject(new Error(`Runtime.start: cannot start from lifecycle state "${this.lifecycle}".`));
+        }
+        this.lifecycle = "starting";
+        const appName = this.appName;
+        const hooks = this.hooks;
+        this.startPromise = (async () => {
+            try {
+                for (const p of this.plugins) {
+                    await hooks.PluginRegistered.run({ appName, pluginName: p.name, kind: "plugin" });
+                }
+                const registering = await hooks.AppRegistering.runDetailed({ appName });
+                if (registering.outcome === "failed")
+                    throw registering.error;
+                if (registering.outcome !== "completed") {
+                    throw new Error(`Runtime.start("${appName}"): AppRegistering vetoed by chain step.`);
+                }
+                const booting = await hooks.AppBooting.runDetailed({ appName });
+                if (booting.outcome === "failed")
+                    throw booting.error;
+                if (booting.outcome !== "completed") {
+                    throw new Error(`Runtime.start("${appName}"): AppBooting vetoed by chain step.`);
+                }
+                for (const p of this.plugins) {
+                    const pre = await hooks.PluginBooting.runDetailed({
+                        appName,
+                        pluginName: p.name,
+                        kind: "plugin",
+                    });
+                    if (pre.outcome === "failed")
+                        throw pre.error;
+                    if (pre.outcome !== "completed") {
+                        throw new Error(`Runtime.start("${appName}"): plugin "${p.name}" boot vetoed by chain step.`);
+                    }
+                    const startedAt = performance.now();
+                    for (const fn of p.boots) {
+                        await fn();
+                    }
+                    await hooks.PluginBooted.run({
+                        appName,
+                        pluginName: p.name,
+                        durationMs: performance.now() - startedAt,
+                        kind: "plugin",
+                    });
+                }
+                // Fail-fast container health gate — every `bind(name, _, { check })`
+                // registered a probe; runChecks returns the failing ones.
+                const checks = await this.container.runChecks();
+                const failed = checks.filter((c) => !c.ok);
+                if (failed.length > 0) {
+                    const summary = failed
+                        .map((c) => `${c.name}: ${c.error?.message ?? "check failed"}`)
+                        .join("; ");
+                    throw new Error(`Runtime.start("${appName}"): container check(s) failed — ${summary}`);
+                }
+                await hooks.AppBooted.run({ appName, bootedAt: new Date().toISOString() });
+                await hooks.AppReady.run({ appName, readyAt: new Date().toISOString() });
+                this.lifecycle = "running";
+            }
+            catch (err) {
+                this.lifecycle = "idle";
+                this.startPromise = undefined;
+                throw err;
+            }
+        })();
+        return this.startPromise;
+    }
+    /**
+     * Graceful shutdown. Idempotent + in-flight-shared.
+     *
+     *   1. Fire `AppShuttingDown` chain (vetoable via skip-next).
+     *   2. For each plugin in REVERSE registration order:
+     *        - fire `PluginShuttingDown` (chain — refusal skips that
+     *          plugin's dispose so downstream plugins still clean up)
+     *        - run every queued `dispose()` fn in reverse, errors isolated
+     *        - fire `PluginShutdown` (observable)
+     *   3. `container.dispose()` — runs every bind({ dispose }) in LIFO.
+     *   4. Fire `AppShutdown` (observable).
+     */
+    stop(reason) {
+        if (this.stopPromise)
+            return this.stopPromise;
+        if (this.lifecycle === "stopped")
+            return Promise.resolve();
+        if (this.lifecycle !== "running") {
+            return Promise.reject(new Error(`Runtime.stop: cannot stop from lifecycle state "${this.lifecycle}".`));
+        }
+        this.lifecycle = "stopping";
+        const appName = this.appName;
+        const hooks = this.hooks;
+        this.stopPromise = (async () => {
+            const errors = [];
+            const shuttingDown = await hooks.AppShuttingDown.runDetailed({ appName, reason });
+            if (shuttingDown.outcome !== "completed") {
+                // Either a veto (skip-next) or a chain step threw. In both cases
+                // the caller (endpoint) escalates with a hard-timeout SIGKILL.
+                this.lifecycle = "running";
+                this.stopPromise = undefined;
+                if (shuttingDown.outcome === "failed")
+                    throw shuttingDown.error;
+                throw new Error(`Runtime.stop("${appName}"): AppShuttingDown vetoed by chain step.`);
+            }
+            for (let i = this.plugins.length - 1; i >= 0; i--) {
+                const p = this.plugins[i];
+                const pre = await hooks.PluginShuttingDown.runDetailed({
+                    appName,
+                    pluginName: p.name,
+                    kind: "plugin",
+                });
+                if (pre.outcome !== "completed") {
+                    // Skip this plugin's dispose; siblings still run.
+                    // eslint-disable-next-line no-console
+                    console.warn(`Runtime.stop("${appName}"): PluginShuttingDown vetoed for "${p.name}" — skipping dispose.`);
+                    continue;
+                }
+                const startedAt = performance.now();
+                for (let j = p.disposes.length - 1; j >= 0; j--) {
+                    try {
+                        await p.disposes[j]();
+                    }
+                    catch (err) {
+                        errors.push(err);
+                        // eslint-disable-next-line no-console
+                        console.error(`Runtime.stop("${appName}"): plugin "${p.name}" dispose threw:`, err);
+                    }
+                }
+                await hooks.PluginShutdown.run({
+                    appName,
+                    pluginName: p.name,
+                    durationMs: performance.now() - startedAt,
+                    kind: "plugin",
+                });
+            }
+            try {
+                await this.container.dispose();
+            }
+            catch (err) {
+                errors.push(err);
+                // eslint-disable-next-line no-console
+                console.error(`Runtime.stop("${appName}"): container.dispose threw:`, err);
+            }
+            await hooks.AppShutdown.run({ appName });
+            this.lifecycle = "stopped";
+            if (errors.length > 0) {
+                throw errors[0];
+            }
+        })();
+        return this.stopPromise;
+    }
+    // ─── Canonical dispatch verbs ──────────────────────────────────────
+    /**
+     * Register a handler so it can be executed by string name. Stamps the
+     * handler into the runtime's registry and into the container under the
+     * key `handler:<name>` so middleware that needs to resolve it can.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    registerHandler(handler) {
+        if (this.handlers.has(handler.name)) {
+            throw new Error(`Runtime.registerHandler: "${handler.name}" already registered.`);
+        }
+        this.handlers.set(handler.name, handler);
+    }
+    /**
+     * Look up a handler by name; throws if not registered.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getHandler(name) {
+        const h = this.handlers.get(name);
+        if (!h)
+            throw new Error(`Runtime: no handler registered with name "${name}".`);
+        return h;
+    }
+    /** All registered handler names — used by adapters to build wire tables. */
+    listHandlers() {
+        return [...this.handlers.keys()];
+    }
+    /**
+     * Canonical sync dispatch verb. Validates input via the handler's input
+     * schema, mints a child envelope (or seeds one when no parent is given),
+     * builds a per-request scope on the container, threads the result
+     * through the handler's `.use()` chain (and `.on()` listeners), then
+     * disposes the scope. Returns the handler's `ctx.result`.
+     *
+     * `handler` may be a `HandlerDefinition` reference (preferred) or a
+     * string name registered via `registerHandler()`.
+     */
+    async execute(handler, input, envelopePartial, extras) {
+        // Resolve string names eagerly. HandlerDefinition references and plain
+        // functions both flow through unchanged — the dispatcher below picks
+        // the path based on shape.
+        const target = typeof handler === "string" ? this.getHandler(handler) : handler;
+        // Envelope inheritance: when called from inside a handler chain, the
+        // parent envelope threads through so correlationId stays linked and
+        // causationId records what triggered this dispatch. When called from
+        // an entry point (HTTP adopter, queue subscriber) with no parent, the
+        // envelope is seeded fresh — either from explicit overrides or a fully
+        // new chain.
+        const envelope = envelopePartial?.parent
+            ? deriveEnvelope(envelopePartial.parent, {
+                tenant: envelopePartial.tenant,
+                userId: envelopePartial.userId,
+                user: envelopePartial.user,
+            })
+            : seedEnvelope({
+                tenant: envelopePartial?.tenant,
+                userId: envelopePartial?.userId,
+                user: envelopePartial?.user,
+                causationId: envelopePartial?.causationId,
+                correlationId: envelopePartial?.correlationId,
+            });
+        const scope = this.container.createScope();
+        const signal = envelopePartial?.signal ?? new AbortController().signal;
+        // The handler chain expects a ctx with at least `input` on it. We also
+        // expose envelope + the three verbs bound to this runtime, threaded
+        // with this envelope as the parent so child dispatches inherit the
+        // correlation chain automatically. Transport-specific `extras` (e.g.
+        // koa kctx, logger) land on the same ctx so plain http handlers and
+        // forge handlers see one shape.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const ctx = {
+            ...(extras ?? {}),
+            input,
+            envelope,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            execute: (h, i, partial) => this.execute(h, i, { ...partial, parent: envelope }),
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            enqueue: (h, i, partial) => this.enqueue(h, i, { ...partial, parent: envelope }),
+            emit: (event, payload, partial) => this.emit(event, payload, { ...partial, parent: envelope }),
+            resolve: (name) => scope.resolve(name),
+            scope,
+        };
+        try {
+            if (typeof target === "function" && !("$kind" in target)) {
+                // Plain function path — the wire holds a bare `(input, ctx) => ...`
+                // value. No hook chain to run; call directly with the unified ctx so
+                // plain handlers see the same surface as defineHandler ones (the
+                // three verbs, envelope, scope, transport extras).
+                return (await target(input, ctx));
+            }
+            // HandlerDefinition path — runs the hook chain (telemetry, .use()
+            // middleware, terminal step that validates + calls the handler body).
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const def = target;
+            const out = await def.run(ctx, { signal });
+            return out.result;
+        }
+        finally {
+            await scope.dispose();
+        }
+    }
+    /**
+     * Fire-and-forget dispatch. Default implementation: `setImmediate` →
+     * `execute`. Queue-adapter installation can override this to enqueue
+     * onto an external queue (BullMQ, SQS, etc.). Errors are pushed onto
+     * the telemetry stream as `kind: "enqueue.failed"` — the caller has
+     * already returned.
+     */
+    enqueue(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    handler, input, envelopePartial) {
+        const name = typeof handler === "string" ? handler : handler.name;
+        setImmediate(() => {
+            void this.execute(handler, input, envelopePartial).catch((err) => {
+                this.pushTelemetry({
+                    kind: "enqueue.failed",
+                    handler: name,
+                    error: serializeError(err),
+                    appName: this.appName,
+                    ts: new Date().toISOString(),
+                });
+            });
+        });
+        return Promise.resolve();
+    }
+    /**
+     * Subscribe to an event. Returns an unsubscribe. Listeners are stored
+     * per `event.name` and fire in registration order via `Promise.allSettled`
+     * when `emit(event, ...)` is called. Throwing listeners are captured in
+     * telemetry but do not break sibling listeners.
+     */
+    subscribe(event, listener) {
+        let set = this.eventListeners.get(event.name);
+        if (!set) {
+            set = new Set();
+            this.eventListeners.set(event.name, set);
+        }
+        set.add(listener);
+        return () => {
+            this.eventListeners.get(event.name)?.delete(listener);
+        };
+    }
+    /**
+     * Broadcast an event to its subscribers. Validates payload against the
+     * event's schema, mints a child envelope, fires every registered
+     * subscriber in parallel (allSettled), and records a `kind:
+     * "event.emitted"` telemetry record. Subscriber throws are captured
+     * but do not propagate to the caller.
+     */
+    async emit(event, payload, envelopePartial) {
+        const validated = event.schema.parse(payload);
+        const envelope = envelopePartial?.parent
+            ? deriveEnvelope(envelopePartial.parent, {
+                tenant: envelopePartial.tenant,
+                userId: envelopePartial.userId,
+                user: envelopePartial.user,
+            })
+            : seedEnvelope({
+                tenant: envelopePartial?.tenant,
+                userId: envelopePartial?.userId,
+                user: envelopePartial?.user,
+                causationId: envelopePartial?.causationId,
+                correlationId: envelopePartial?.correlationId,
+            });
+        const startedAt = performance.now();
+        const subs = this.eventListeners.get(event.name);
+        if (subs && subs.size > 0) {
+            // Wrap in async so a SYNC throw inside fn() rejects the wrapper
+            // rather than escaping the .map(). allSettled then captures it.
+            const results = await Promise.allSettled([...subs].map(async (fn) => fn(validated, envelope)));
+            for (const r of results) {
+                if (r.status === "rejected") {
+                    this.pushTelemetry({
+                        kind: "event.listener.failed",
+                        event: event.name,
+                        envelope,
+                        error: serializeError(r.reason),
+                        appName: this.appName,
+                        ts: new Date().toISOString(),
+                    });
+                }
+            }
+        }
+        this.pushTelemetry({
+            kind: "event.emitted",
+            event: event.name,
+            payload: validated,
+            envelope,
+            durationMs: performance.now() - startedAt,
+            subscriberCount: subs?.size ?? 0,
+            appName: this.appName,
+            ts: new Date().toISOString(),
+        });
+    }
+}
+/**
+ * Canonical factory for a Runtime. Matches the foundation-doc shape
+ * (`createRuntime(opts)`) so consumer code stays uniform across
+ * primitives — `createContainer()`, `createInterface()`, `createApp()`,
+ * `createRuntime()`. The `new Runtime(opts)` form remains available for
+ * subclasses + tests that need to override protected members.
+ */
+export function createRuntime(options = {}) {
+    return new Runtime(options);
+}
+export { isBuiltInHook };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nwire/app",
-  "version": "0.9.2",
+  "version": "0.10.0",
   "description": "Nwire — managed Container with plugin lifecycle, framework events, and DI hooks. Composes modules + plugins, boots in order, exposes a Container, fires framework events at every lifecycle transition.",
   "keywords": [
     "app",
@@ -29,10 +29,13 @@
     "access": "public"
   },
   "dependencies": {
-    "@nwire/container": "0.9.2",
-    "@nwire/hooks": "0.9.2",
-    "@nwire/logger": "0.9.2",
-    "@nwire/messages": "0.9.2"
+    "@nwire/container": "0.10.0",
+    "@nwire/envelope": "0.10.0",
+    "@nwire/handler": "0.10.0",
+    "@nwire/hooks": "0.10.0",
+    "@nwire/wires": "0.10.0",
+    "@nwire/logger": "0.10.0",
+    "@nwire/messages": "0.10.0"
   },
   "devDependencies": {
     "@types/node": "^22.19.9",

package/dist/__tests__/create-app.test.d.ts

@@ -1,6 +0,0 @@
-/**
- * Contract tests for the generic `createApp` — plugins + container +
- * framework events, no forge concepts.
- */
-export {};
-//# sourceMappingURL=create-app.test.d.ts.map

package/dist/__tests__/create-app.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-app.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/create-app.test.ts"],"names":[],"mappings":"AAAA;;;GAGG"}