@nwire/wires 0.10.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alex Gefter / 200apps Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,50 @@
+# @nwire/wires
+
+> Transport contract — the abstract base every Nwire transport extends, and the shape foreign hosts implement to plug in.
+
+## What it is
+
+`NwireInterface` is the structural shape every transport satisfies (`http`, `queue`, `mcp`, `graphql`, future `ws`/`grpc`). `InterfaceBuilder` is the abstract base each transport extends.
+
+The verb surface is uniform across transports:
+
+```
+.use(...plugins)             augment the chain
+.wire(binding, handler?, o?) bind an outbound surface
+.from(source)                declare an inbound stream
+.mount(target)               attach this iface to a host
+.run(opts?)         → Lifecycle      serve standalone
+.boot(opts?)        → Booted<T>      build without listening
+```
+
+Plus two internal seams (`.manifest()` for scanner/Studio; `.attach(host)` for host lifecycle) and one DI sugar (`.provide(container)`).
+
+## Install
+
+```bash
+pnpm add @nwire/wires
+```
+
+## Within nwire-app
+
+You usually never import this package directly — `@nwire/http` / `@nwire/queue` / `@nwire/mcp` each ship their own builder that already extends `InterfaceBuilder`. Touch this package only when writing a new transport or a foreign-host adapter.
+
+```ts
+import { endpoint } from "@nwire/endpoint";
+import { http } from "@nwire/http"; // extends InterfaceBuilder
+import { queue } from "@nwire/queue"; // extends InterfaceBuilder
+
+const api = http().wire(getUsers);
+const worker = queue().wire(sendEmail);
+
+await endpoint("app").serve(api).serve(worker).run();
+```
+
+## API
+
+- `NwireInterface` — structural shape `endpoint().serve()` consumes.
+- `InterfaceBuilder<TBinding, TPlugin, TFromSource, TMountTarget, TArtifact>` — abstract base with the six verbs + manifest + attach.
+- `Lifecycle` / `RunOptions` / `Booted` / `BootOptions` / `InterfaceManifest` — return + option types shared across transports.
+- `makeContainerPlugin` / `isContainerPlugin` — sentinel for transports that need to lift containers out of the `.use()` chain.
+- `isNwireInterface` — structural type narrow.
+- Re-exports `HandlerLike` + `HandlerDefinition` from `@nwire/handler` so transport authors have one import.

package/dist/cron/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * `@nwire/wires/cron` — cron binding factory.
+ *
+ *   import { cron } from "@nwire/wires/cron";
+ *
+ *   createInterface().wire(cron("0 *\/15 * * * *"), refreshFeed);
+ *
+ * Adopter (`@nwire/cron`) filters wires by `binding.$adapter === "cron"`
+ * and schedules each handler against the cron expression.
+ */
+import type { Binding } from "../index.js";
+export interface CronBindingOptions {
+    /** Timezone (IANA) the cron expression is evaluated in. Adopter default applies otherwise. */
+    readonly timezone?: string;
+    /** Free-form source tag — Studio and observability group by it. */
+    readonly source?: string;
+    /**
+     * Set true to opt the binding out of the adopter's overlap guard. Default
+     * false — adopters skip overlapping invocations by default.
+     */
+    readonly overlap?: boolean;
+}
+export interface CronBinding extends Binding {
+    readonly $kind: "binding";
+    readonly $adapter: "cron";
+    readonly kind: "cron";
+    readonly schedule: string;
+    readonly timezone?: string;
+    readonly source?: string;
+    readonly overlap?: boolean;
+    /** Chainable source tag — returns a fresh binding. */
+    from(source: string): CronBinding;
+}
+export declare function cron(schedule: string, options?: CronBindingOptions): CronBinding;

package/dist/cron/index.js

@@ -0,0 +1,30 @@
+/**
+ * `@nwire/wires/cron` — cron binding factory.
+ *
+ *   import { cron } from "@nwire/wires/cron";
+ *
+ *   createInterface().wire(cron("0 *\/15 * * * *"), refreshFeed);
+ *
+ * Adopter (`@nwire/cron`) filters wires by `binding.$adapter === "cron"`
+ * and schedules each handler against the cron expression.
+ */
+function buildBinding(schedule, options, source) {
+    const binding = {
+        $kind: "binding",
+        $adapter: "cron",
+        kind: "cron",
+        schedule,
+        ...(options ?? {}),
+        ...(source !== undefined ? { source } : {}),
+    };
+    Object.defineProperty(binding, "from", {
+        value: (next) => buildBinding(schedule, options, next),
+        enumerable: false,
+        writable: false,
+        configurable: true,
+    });
+    return binding;
+}
+export function cron(schedule, options) {
+    return buildBinding(schedule, options, undefined);
+}

package/dist/graphql/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `@nwire/wires/graphql` — GraphQL field binding factories.
+ *
+ *   import { query, mutation, subscription } from "@nwire/wires/graphql";
+ *
+ *   createInterface()
+ *     .wire(query("orders"),     listOrders)
+ *     .wire(mutation("createOrder"), createOrder);
+ *
+ * Thin universal-routing shape — the wire just names which GraphQL
+ * field this handler implements. The adopter (Apollo / Yoga / raw)
+ * decides how to map: build a resolver tree, federate a schema, stitch
+ * a remote endpoint, etc. Schemas live with the typedefs the adopter
+ * loads, not on the binding.
+ *
+ * Bindings carry `$adapter: "graphql"` so the GraphQL adopter filters
+ * via `interface.forAdapter("graphql")`.
+ */
+import type { Binding } from "../index.js";
+export type GraphqlFieldKind = "query" | "mutation" | "subscription";
+export interface GraphqlBindingOptions {
+    /** Optional parent type for fields under custom roots (federated graphs). */
+    readonly typeName?: string;
+    readonly source?: string;
+}
+export interface GraphqlBinding extends Binding {
+    readonly $kind: "binding";
+    readonly $adapter: "graphql";
+    readonly kind: GraphqlFieldKind;
+    readonly field: string;
+    readonly typeName?: string;
+    readonly source?: string;
+    from(source: string): GraphqlBinding;
+}
+export declare function query(field: string, options?: GraphqlBindingOptions): GraphqlBinding;
+export declare function mutation(field: string, options?: GraphqlBindingOptions): GraphqlBinding;
+export declare function subscription(field: string, options?: GraphqlBindingOptions): GraphqlBinding;

package/dist/graphql/index.js

@@ -0,0 +1,44 @@
+/**
+ * `@nwire/wires/graphql` — GraphQL field binding factories.
+ *
+ *   import { query, mutation, subscription } from "@nwire/wires/graphql";
+ *
+ *   createInterface()
+ *     .wire(query("orders"),     listOrders)
+ *     .wire(mutation("createOrder"), createOrder);
+ *
+ * Thin universal-routing shape — the wire just names which GraphQL
+ * field this handler implements. The adopter (Apollo / Yoga / raw)
+ * decides how to map: build a resolver tree, federate a schema, stitch
+ * a remote endpoint, etc. Schemas live with the typedefs the adopter
+ * loads, not on the binding.
+ *
+ * Bindings carry `$adapter: "graphql"` so the GraphQL adopter filters
+ * via `interface.forAdapter("graphql")`.
+ */
+function buildBinding(kind, field, options, source) {
+    const binding = {
+        $kind: "binding",
+        $adapter: "graphql",
+        kind,
+        field,
+        ...(options ?? {}),
+        ...(source !== undefined ? { source } : {}),
+    };
+    Object.defineProperty(binding, "from", {
+        value: (next) => buildBinding(kind, field, options, next),
+        enumerable: false,
+        writable: false,
+        configurable: true,
+    });
+    return binding;
+}
+export function query(field, options) {
+    return buildBinding("query", field, options, undefined);
+}
+export function mutation(field, options) {
+    return buildBinding("mutation", field, options, undefined);
+}
+export function subscription(field, options) {
+    return buildBinding("subscription", field, options, undefined);
+}

package/dist/http/index.d.ts

@@ -0,0 +1,95 @@
+/**
+ * `@nwire/wires/http` — HTTP binding factories.
+ *
+ *   import { post, get, del, put, patch } from "@nwire/wires/http";
+ *
+ *   createInterface()
+ *     .wire(post("/orders", { body: CreateOrder }), placeOrder)
+ *     .wire(get("/orders/:id", { params: OrderParams }), getOrder);
+ *
+ * Bindings carry `$adapter: "http"` so an HTTP adopter filters them via
+ * `interface.forAdapter("http")`. Schemas are zod-shaped; the adopter
+ * parses request data at dispatch time.
+ *
+ * Foreign-import factories (`fromExpress` / `fromKoa` / `fromFastify`)
+ * live in the adopter packages, not here.
+ */
+import type { ZodTypeAny, z } from "zod";
+import type { Binding } from "../index.js";
+export type HttpVerb = "get" | "post" | "put" | "patch" | "delete";
+/** Lifecycle of an exposed operation — surfaces on the OpenAPI doc. */
+export type RouteStatus = "draft" | "active" | "deprecated" | "sunset";
+/**
+ * OpenAPI / contract metadata for one route. The HTTP adopter reads it at
+ * boot to emit the operation id, summary, tags, response shapes, error
+ * shapes, and lifecycle status.
+ */
+export interface RouteOpenApi {
+    readonly operation: string;
+    readonly version?: number;
+    readonly status?: RouteStatus;
+    readonly summary?: string;
+    readonly description?: string;
+    readonly tags?: ReadonlyArray<string>;
+    readonly returns?: ReadonlyArray<any>;
+    readonly errors?: ReadonlyArray<any>;
+}
+/**
+ * Per-route middleware shape — `unknown` at this layer to keep
+ * `@nwire/wires/http` free of a Koa dep. Adopters narrow at consume
+ * time.
+ */
+export type RouteMiddleware = unknown;
+/** Schemas attached to a route binding. */
+export interface RouteSchemas {
+    readonly params?: ZodTypeAny;
+    readonly body?: ZodTypeAny;
+    readonly query?: ZodTypeAny;
+    readonly middleware?: readonly RouteMiddleware[];
+    readonly openapi?: RouteOpenApi;
+}
+type ZodOutput<T> = T extends ZodTypeAny ? z.output<T> : unknown;
+/**
+ * Infer the handler's flat input type from a `RouteSchemas` shape. The
+ * adopter merges params + body + query into a single object the handler
+ * sees — this type mirrors that merge.
+ */
+export type InferRouteInput<S> = (S extends {
+    params?: infer P;
+} ? P extends ZodTypeAny ? ZodOutput<P> : unknown : unknown) & (S extends {
+    query?: infer Q;
+} ? (Q extends ZodTypeAny ? ZodOutput<Q> : unknown) : unknown) & (S extends {
+    body?: infer B;
+} ? (B extends ZodTypeAny ? ZodOutput<B> : unknown) : unknown);
+/**
+ * `RouteBinding` — the binding shape HTTP wires carry. Extends the base
+ * `Binding` contract with HTTP specifics (verb, path, schemas, OpenAPI).
+ * `$adapter` is fixed to `"http"`; an HTTP adopter consumes wires by
+ * that tag.
+ */
+export interface RouteBinding<TInput = unknown> extends Binding {
+    readonly $kind: "binding";
+    readonly $adapter: "http";
+    readonly kind: "route";
+    readonly verb: HttpVerb;
+    readonly path: string;
+    readonly params?: ZodTypeAny;
+    readonly body?: ZodTypeAny;
+    readonly query?: ZodTypeAny;
+    readonly middleware?: readonly RouteMiddleware[];
+    readonly openapi?: RouteOpenApi;
+    readonly source?: string;
+    /**
+     * Chainable source tag — Studio and observability group by it.
+     * Returns a fresh binding; original is unchanged.
+     */
+    from(source: string): RouteBinding<TInput>;
+    /** Phantom — TS inference of the handler's input shape. */
+    readonly __inputType?: TInput;
+}
+export declare function get<S extends RouteSchemas = RouteSchemas>(path: string, schemas?: S): RouteBinding<InferRouteInput<S>>;
+export declare function post<S extends RouteSchemas = RouteSchemas>(path: string, schemas?: S): RouteBinding<InferRouteInput<S>>;
+export declare function put<S extends RouteSchemas = RouteSchemas>(path: string, schemas?: S): RouteBinding<InferRouteInput<S>>;
+export declare function patch<S extends RouteSchemas = RouteSchemas>(path: string, schemas?: S): RouteBinding<InferRouteInput<S>>;
+export declare function del<S extends RouteSchemas = RouteSchemas>(path: string, schemas?: S): RouteBinding<InferRouteInput<S>>;
+export {};

package/dist/http/index.js

@@ -0,0 +1,49 @@
+/**
+ * `@nwire/wires/http` — HTTP binding factories.
+ *
+ *   import { post, get, del, put, patch } from "@nwire/wires/http";
+ *
+ *   createInterface()
+ *     .wire(post("/orders", { body: CreateOrder }), placeOrder)
+ *     .wire(get("/orders/:id", { params: OrderParams }), getOrder);
+ *
+ * Bindings carry `$adapter: "http"` so an HTTP adopter filters them via
+ * `interface.forAdapter("http")`. Schemas are zod-shaped; the adopter
+ * parses request data at dispatch time.
+ *
+ * Foreign-import factories (`fromExpress` / `fromKoa` / `fromFastify`)
+ * live in the adopter packages, not here.
+ */
+function buildBinding(verb, path, schemas, source) {
+    const binding = {
+        $kind: "binding",
+        $adapter: "http",
+        kind: "route",
+        verb,
+        path,
+        ...(schemas ?? {}),
+        ...(source !== undefined ? { source } : {}),
+    };
+    Object.defineProperty(binding, "from", {
+        value: (next) => buildBinding(verb, path, schemas, next),
+        enumerable: false,
+        writable: false,
+        configurable: true,
+    });
+    return binding;
+}
+export function get(path, schemas) {
+    return buildBinding("get", path, schemas, undefined);
+}
+export function post(path, schemas) {
+    return buildBinding("post", path, schemas, undefined);
+}
+export function put(path, schemas) {
+    return buildBinding("put", path, schemas, undefined);
+}
+export function patch(path, schemas) {
+    return buildBinding("patch", path, schemas, undefined);
+}
+export function del(path, schemas) {
+    return buildBinding("delete", path, schemas, undefined);
+}

package/dist/index.d.ts

@@ -0,0 +1,99 @@
+/**
+ * `@nwire/wires` — standalone wire collection + binding factories.
+ *
+ * The Interface owns a list of `{ binding, handler }` pairs (wires) plus
+ * any `provide()`'d ctx builders. Adopters read this list, filter by
+ * `binding.$adapter`, and build their transport runtimes from the matched
+ * wires. The Interface itself has no transport awareness, no lifecycle,
+ * no DI — pure data + context.
+ *
+ *   import { createInterface }   from "@nwire/wires";
+ *   import { post, get }         from "@nwire/wires/http";
+ *   import { queue }             from "@nwire/wires/queue";
+ *
+ *   const api = createInterface()
+ *     .wire(post("/orders"), placeOrder)
+ *     .wire(get("/orders/:id"), getOrder)
+ *     .wire(queue("orders.process"), processOrder);
+ *
+ *   api.forAdapter("http").length;   // 2
+ *   api.forAdapter("queue").length;  // 1
+ *
+ * Multiple interfaces compose via `.merge()`; adopters never see the
+ * boundary.
+ */
+export type { HandlerLike, HandlerDefinition } from "@nwire/handler";
+/**
+ * `Binding` — the descriptor every wire pairs with a handler. Adopters
+ * filter wires by `binding.$adapter` to find what's theirs. Per-adopter
+ * binding shapes (RouteBinding, QueueBinding, etc.) extend this.
+ */
+export interface Binding {
+    /** Discriminant — `"binding"`. */
+    readonly $kind: "binding";
+    /** Adopter tag — every adopter consumes wires whose tag matches. */
+    readonly $adapter: string;
+    /** Free-form subtype within the adopter (`"route"`, `"job"`, `"tool"`, …). */
+    readonly kind?: string;
+}
+/**
+ * `HandlerDef` — the structural shape the wire-collection holds. Kept
+ * deliberately loose at this layer (any function or `HandlerLike` from
+ * `@nwire/handler`); concrete validation happens at the adopter when
+ * dispatch fires.
+ */
+export type HandlerDef = ((input: any, ctx: any) => unknown | Promise<unknown>) | {
+    run: (input: any, ctx: any) => unknown | Promise<unknown>;
+} | {
+    $kind: string;
+};
+/**
+ * `Wire` — `{ binding, handler }`. Optional `app` field tags which App
+ * the wire came from (set by `app.interface.wire()` / `appCompose`),
+ * which adopters use via `containerOf(wire)` to route to the right
+ * container.
+ */
+export interface Wire {
+    readonly binding: Binding;
+    readonly handler: HandlerDef;
+    /** Source app reference (opaque at this layer — endpoint resolves it). */
+    readonly app?: any;
+}
+/**
+ * Per-request ctx builder. Same shape as the legacy `CtxBuilder` from
+ * interface-builder.ts — re-declared here under the new surface for
+ * standalone use without pulling the legacy types.
+ */
+export type WireCtxBuilder<TExtras extends object = object, TRequest = any> = TExtras | ((request: TRequest) => TExtras | Promise<TExtras>);
+/**
+ * `Interface` — the wire collection contract.
+ *
+ *   wires       — every registered wire (read-only snapshot)
+ *   wire(b,h)   — register one wire; returns this for chaining
+ *   merge(other)— append another Interface's wires
+ *   forAdapter  — slice by binding.$adapter; adopters consume their slice
+ *   provide     — accumulate ctx builders adopters apply per request
+ */
+export interface Interface {
+    readonly $kind: "interface";
+    readonly wires: readonly Wire[];
+    wire(binding: Binding, handler: HandlerDef): this;
+    merge(other: Interface): this;
+    forAdapter(kind: string): readonly Wire[];
+    provide<TExtras extends object>(builder: WireCtxBuilder<TExtras>): this;
+    /**
+     * Compose accumulated ctx extras for an incoming request. Adopters
+     * call this per request; the result is merged onto the handler ctx.
+     * Last-write wins on key collision.
+     */
+    composeCtxExtras(request: unknown): Promise<Record<string, unknown>>;
+}
+/**
+ * Construct a new, empty `Interface`. Apps construct one internally and
+ * expose it as `app.interface`; consumers can also build standalone wire
+ * collections that get merged into apps or attached to endpoints
+ * directly.
+ */
+export declare function createInterface(): Interface;
+/** Type narrow — does this value look like a new-shape Interface? */
+export declare function isInterface(x: unknown): x is Interface;

package/dist/index.js

@@ -0,0 +1,72 @@
+/**
+ * `@nwire/wires` — standalone wire collection + binding factories.
+ *
+ * The Interface owns a list of `{ binding, handler }` pairs (wires) plus
+ * any `provide()`'d ctx builders. Adopters read this list, filter by
+ * `binding.$adapter`, and build their transport runtimes from the matched
+ * wires. The Interface itself has no transport awareness, no lifecycle,
+ * no DI — pure data + context.
+ *
+ *   import { createInterface }   from "@nwire/wires";
+ *   import { post, get }         from "@nwire/wires/http";
+ *   import { queue }             from "@nwire/wires/queue";
+ *
+ *   const api = createInterface()
+ *     .wire(post("/orders"), placeOrder)
+ *     .wire(get("/orders/:id"), getOrder)
+ *     .wire(queue("orders.process"), processOrder);
+ *
+ *   api.forAdapter("http").length;   // 2
+ *   api.forAdapter("queue").length;  // 1
+ *
+ * Multiple interfaces compose via `.merge()`; adopters never see the
+ * boundary.
+ */
+/**
+ * Construct a new, empty `Interface`. Apps construct one internally and
+ * expose it as `app.interface`; consumers can also build standalone wire
+ * collections that get merged into apps or attached to endpoints
+ * directly.
+ */
+export function createInterface() {
+    const wires = [];
+    const ctxBuilders = [];
+    const iface = {
+        $kind: "interface",
+        get wires() {
+            return wires;
+        },
+        wire(binding, handler) {
+            wires.push({ binding, handler });
+            return iface;
+        },
+        merge(other) {
+            for (const w of other.wires)
+                wires.push(w);
+            return iface;
+        },
+        forAdapter(kind) {
+            return wires.filter((w) => w.binding.$adapter === kind);
+        },
+        provide(builder) {
+            ctxBuilders.push(builder);
+            return iface;
+        },
+        async composeCtxExtras(request) {
+            const out = {};
+            for (const b of ctxBuilders) {
+                const extras = typeof b === "function" ? await b(request) : b;
+                Object.assign(out, extras);
+            }
+            return out;
+        },
+    };
+    return iface;
+}
+/** Type narrow — does this value look like a new-shape Interface? */
+export function isInterface(x) {
+    return (typeof x === "object" &&
+        x !== null &&
+        x.$kind === "interface" &&
+        Array.isArray(x.wires));
+}

package/dist/interface-builder.d.ts

@@ -0,0 +1,293 @@
+/**
+ * `InterfaceBuilder` — the abstract base every Nwire transport extends.
+ *
+ * Six verbs are universal and form the public surface every transport
+ * supports (HTTP, queue, MCP, GraphQL, WebSocket, CLI, …):
+ *
+ *   .use(...plugins)             augment the chain (middleware/plugins)
+ *   .wire(binding, handler?, o?) bind an outbound surface to a handler
+ *   .from(source)                declare an inbound stream the iface consumes
+ *   .mount(target)               attach this iface to a host (express/koa/…)
+ *   .run(opts?)                  serve standalone — returns a Lifecycle
+ *   .boot(opts?)                 build internals without listening
+ *
+ * Two internal seams that aren't verbs:
+ *
+ *   .manifest()                  pure data describing the wired surface
+ *                                (scanner / Studio / cache consume this)
+ *   .attach(host)                lifecycle hook called by the host endpoint
+ *                                when this interface is mounted on another
+ *
+ * And one DI shortcut kept for ergonomics:
+ *
+ *   .provide(container)          sugar that wires a Container into the chain
+ *                                via the same channel `.use()` uses.
+ *
+ * Each transport refines the generics:
+ *   - `TBinding`  — outbound binding shape (RouteBinding / JobBinding / …)
+ *   - `TPlugin`   — what `.use()` accepts (Koa middleware / plain fn / …)
+ *   - `TFromSource` — what `.from()` accepts (eventDef / remote ref / …)
+ *   - `TMountTarget` — what `.mount()` accepts (Koa app / express / iface)
+ *   - `TArtifact` — what `.boot()` produces (an opaque handle the host owns)
+ *
+ * The base owns the type signatures + manifest plumbing. It implements one
+ * verb concretely — `.provide()` — as a default that delegates to `.use()`.
+ * Transports may override if they need a different DI dispatch shape.
+ */
+import type { HandlerLike } from "@nwire/handler";
+/**
+ * What `.provide()` accepts — either a static extras object, or a builder
+ * function the transport calls per request/job/invocation. The interface
+ * stores it opaquely and applies it during dispatch; how it composes is
+ * the wire's concern, not the transport's.
+ *
+ *   api.provide({ logger: console });
+ *   api.provide((req) => ({ user: req.user, requestId: crypto.randomUUID() }));
+ *   api.provide((req) => ({ ...root.cradle, user: req.user }));   // wire reads container
+ *
+ * The transport never imports `@nwire/container` — what the wire passes
+ * is opaque.
+ */
+export type CtxBuilder<TExtras extends object, TRequest = unknown> = TExtras | ((request: TRequest) => TExtras | Promise<TExtras>);
+/**
+ * Health probe registration — aligned with `@nwire/endpoint`'s `HealthCheck`
+ * so every transport's `attach()` accepts the same shape the endpoint passes.
+ */
+export interface InterfaceHealthCheck {
+    readonly name: string;
+    readonly check: () => Promise<void> | void;
+    readonly timeout?: number;
+    readonly kind?: "readiness" | "liveness";
+}
+/**
+ * Passed by the host (typically `@nwire/endpoint`) to `attach()` when this
+ * interface is being mounted into a larger composition. The host gives
+ * the interface a place to register transport-specific health checks.
+ *
+ * The host does NOT pass a container — DI composition is a wire-layer
+ * concern, threaded through `.provide(builder)` before `.serve()` runs.
+ * Interface contract stays container-agnostic.
+ */
+export interface AttachBindings {
+    /** Register a health check the host reports on `/live` / `/ready`. */
+    addCheck(check: InterfaceHealthCheck): void;
+    /**
+     * The host's primary DI container, when one is available (i.e. the
+     * endpoint was given `.serve(app)` before this interface). Interfaces
+     * that need a container — e.g. for `ctx.resolve(...)` inside handlers
+     * — should fall back to this when no `.provide(container)` was set
+     * on the interface itself. Typed as `unknown` so the interface contract
+     * stays free of a `@nwire/container` dependency.
+     */
+    readonly container?: unknown;
+}
+/**
+ * `NwireInterface` — the structural shape `@nwire/endpoint` looks for when
+ * `.serve(interfaceValue)` is called. Any object exposing `$nwireServable`,
+ * `transport`, and `attach()` satisfies it. `InterfaceBuilder` implements
+ * the shape; foreign hosts can implement it directly to plug in.
+ */
+export interface NwireInterface {
+    readonly $nwireServable: true;
+    readonly transport: string;
+    attach(host: AttachBindings): void;
+}
+/**
+ * `InterfaceManifest` — the data shape `.manifest()` returns. Scanner,
+ * Studio, and the cache all read this; they never reach into the live
+ * builder. Each transport extends with its own concrete shape (RouteEntry
+ * for HTTP, JobEntry for queue, etc.); the base only nails down the
+ * uniform fields.
+ */
+export interface InterfaceManifest {
+    /** Transport id — matches the builder's `transport` field. */
+    readonly transport: string;
+    /** Optional prefix or namespace applied to every wired binding. */
+    readonly prefix?: string;
+    /** Outbound bindings — opaque at this level; transports type their own. */
+    readonly wired: readonly unknown[];
+    /** Inbound sources declared via `.from()` — same opacity. */
+    readonly from?: readonly unknown[];
+    /** Plugins applied via `.use()`. Stored by name when possible. */
+    readonly plugins?: readonly string[];
+}
+/**
+ * Options accepted by `.run()`. Transports refine via their own union.
+ * The base only knows about the universal lifecycle knobs the endpoint
+ * also exposes; transports use the same names so `.run({port: 3000})`
+ * means the same thing on an http interface as on an endpoint.
+ */
+export interface RunOptions {
+    /** Bind port (HTTP/WS/queue admin). Transports may ignore. */
+    readonly port?: number;
+    /** Bind host. Default `"0.0.0.0"` where applicable. */
+    readonly host?: string;
+    /** Drain timeout in ms before the lifecycle force-exits. */
+    readonly shutdownTimeoutMs?: number;
+    /** Override the default signal handlers. Default `true` (install handlers). */
+    readonly installSignalHandlers?: boolean;
+}
+/**
+ * The handle `.run()` returns. Owners call `close()` to drain gracefully.
+ * Mirrors `@nwire/endpoint`'s `Lifecycle` so swapping the runner is
+ * transparent for callers that already use the endpoint pattern.
+ */
+export interface Lifecycle {
+    /** Drain in-flight work + release resources. Idempotent. */
+    close(): Promise<void>;
+    /** Resolved when the lifecycle has finished closing (manual or signal). */
+    readonly closed: Promise<void>;
+}
+/**
+ * Options accepted by `.boot()`. Boot builds internals (validates the
+ * routing table, freezes the middleware chain, opens DI containers) but
+ * does NOT bind a port or start serving traffic. The endpoint uses this
+ * to take ownership of the artifact before deciding when to listen.
+ */
+export interface BootOptions {
+}
+/**
+ * The opaque handle `.boot()` returns. Transports type `value` to their
+ * concrete artifact (a Koa app, a queue worker, an MCP server, …). The
+ * host calls `.serve()` on the result when it's ready to bind.
+ */
+export interface Booted<TArtifact = unknown> {
+    /** The concrete artifact — opaque at the base level. */
+    readonly value: TArtifact;
+    /** Manifest snapshot taken at boot. */
+    readonly manifest: InterfaceManifest;
+    /** Shutdown handle for the booted artifact. */
+    shutdown(): Promise<void>;
+}
+/**
+ * Base class every transport extends.
+ *
+ * Implementing the contract:
+ *
+ *   class HttpInterfaceImpl extends InterfaceBuilder<
+ *     RouteBinding,
+ *     Koa.Middleware,
+ *     RouteBinding,      // `from` source shape (forwarded route)
+ *     Koa | NwireInterface,  // `mount` target shape
+ *     RawHttpHandler     // boot artifact
+ *   > {
+ *     readonly transport = "http" as const;
+ *     use(...mw) { … return this; }
+ *     wire(binding, handler) { … return this; }
+ *     from(src) { … return this; }
+ *     mount(target) { … return this; }
+ *     async run(opts) { … return lifecycle; }
+ *     async boot(opts) { … return booted; }
+ *     manifest() { … return data; }
+ *     attach(host) { … }
+ *   }
+ */
+export declare abstract class InterfaceBuilder<TBinding = unknown, TPlugin = unknown, TFromSource = unknown, TMountTarget = unknown, TArtifact = unknown> implements NwireInterface {
+    readonly $nwireServable: true;
+    /** Transport id — `"http"` / `"queue"` / `"mcp"` / `"graphql"` / … */
+    abstract readonly transport: string;
+    /** Augment the chain with one or more plugins/middleware values. */
+    abstract use(...plugins: TPlugin[]): this;
+    /**
+     * Bind an outbound surface (route / topic / tool / channel) to a handler.
+     * `handler` may be a `HandlerDefinition` (typed + validated) or a bare
+     * async function. Transports may overload to accept per-binding options.
+     */
+    abstract wire(binding: TBinding, handler?: HandlerLike, options?: unknown): this;
+    /**
+     * Declare an inbound stream the interface consumes. Semantically the
+     * opposite of `.wire()` — `.wire()` exposes; `.from()` ingests. Each
+     * transport defines what counts as a source:
+     *
+     *   - HTTP:    a remote route or upstream API to proxy/forward
+     *   - queue:   an event definition or another queue to consume from
+     *   - MCP:     a remote tool list to re-export
+     *   - GraphQL: a remote schema to stitch
+     *
+     * Transports that have no meaningful inbound concept omit `.from()` from
+     * their concrete class signature (the abstract declaration here exists
+     * so the universal verb table is uniform on the type level).
+     */
+    abstract from(source: TFromSource): this;
+    /**
+     * Mount this interface onto an external host. Returns the host (so the
+     * caller can use it), not `this`. Transports type the target shape:
+     *
+     *   - HTTP:    Koa | express.Application | NwireInterface
+     *   - queue:   QueueWorker | NwireInterface
+     *   - MCP:     existing MCP server | NwireInterface
+     *
+     * Use this for interop (mounting on Express / Fastify) or for composing
+     * one interface inside another (HTTP gateway → queue producer).
+     */
+    abstract mount(target: TMountTarget, options?: unknown): unknown;
+    /**
+     * Boot the interface (validate, freeze, build internals) and serve it
+     * standalone. Installs default signal handlers unless opts say
+     * otherwise. Returns a `Lifecycle` the caller can close to drain.
+     *
+     * Use this when the interface is the entire app. For multi-interface
+     * apps, prefer `@nwire/endpoint` which orchestrates several `.boot()`d
+     * interfaces together with full lightship + http-terminator semantics.
+     */
+    abstract run(options?: RunOptions): Promise<Lifecycle>;
+    /**
+     * Build the interface's runnable artifact WITHOUT binding a port. The
+     * host (typically `@nwire/endpoint`) calls this, takes ownership of the
+     * returned `Booted` handle, and decides when to start serving.
+     *
+     * Boot is the "compile + freeze" moment — after `.boot()` returns,
+     * additional `.use()` / `.wire()` calls are not honored on the booted
+     * artifact (the builder still mutates, but a re-boot is required to
+     * pick up changes).
+     */
+    abstract boot(options?: BootOptions): Promise<Booted<TArtifact>>;
+    /**
+     * Pure-data snapshot of the wired surface. Scanner, Studio, and the
+     * cache read this. Calling `.manifest()` does NOT freeze the builder —
+     * the manifest is a copy taken at the call site.
+     */
+    abstract manifest(): InterfaceManifest;
+    /**
+     * Lifecycle hook called by a host that's composing this interface into
+     * a larger app. The host passes its container + a way to register
+     * health checks. Default no-op subclasses override as needed.
+     */
+    attach(_host: AttachBindings): void;
+    /**
+     * Builders accumulated via `.provide()`. Transports apply each per
+     * request/job/invocation, spreading the merged result onto handler ctx.
+     * Last-write wins on key collision.
+     */
+    protected readonly ctxBuilders: CtxBuilder<object>[];
+    /**
+     * Compose ctx extras for an incoming request. Transports call this in
+     * their dispatch loop to build the per-invocation extras object that
+     * gets spread onto handler ctx.
+     *
+     * The interface is agnostic to where the values come from. A wire
+     * builder may close over a container, read req headers, mint a request
+     * id, fetch a tenant — all opaque to the transport.
+     */
+    protected composeCtxExtras(request: unknown): Promise<Record<string, unknown>>;
+    /**
+     * Register a ctx builder applied per request/job/invocation.
+     *
+     * - Static extras: every request gets the same object merged in.
+     * - Builder fn: receives the transport's native request value (`req`,
+     *   `job`, `evt`), returns extras to merge onto ctx.
+     *
+     * Multiple `.provide()` calls compose — each builder runs in
+     * registration order; later writes win on key collision.
+     *
+     *   api.provide({ logger: console });                            // static
+     *   api.provide((req) => ({ user: req.user }));                  // dynamic
+     *   api.provide((req) => ({ ...root.cradle, tenant: req.tenant })); // closes over container
+     *
+     * The interface NEVER imports `@nwire/container`. Whatever the wire
+     * passes is opaque here.
+     */
+    provide<TExtras extends object>(builder: CtxBuilder<TExtras>): this;
+}
+/** Type narrow — does this value look like a Nwire interface? */
+export declare function isNwireInterface(x: unknown): x is NwireInterface;

package/dist/interface-builder.js

@@ -0,0 +1,125 @@
+/**
+ * `InterfaceBuilder` — the abstract base every Nwire transport extends.
+ *
+ * Six verbs are universal and form the public surface every transport
+ * supports (HTTP, queue, MCP, GraphQL, WebSocket, CLI, …):
+ *
+ *   .use(...plugins)             augment the chain (middleware/plugins)
+ *   .wire(binding, handler?, o?) bind an outbound surface to a handler
+ *   .from(source)                declare an inbound stream the iface consumes
+ *   .mount(target)               attach this iface to a host (express/koa/…)
+ *   .run(opts?)                  serve standalone — returns a Lifecycle
+ *   .boot(opts?)                 build internals without listening
+ *
+ * Two internal seams that aren't verbs:
+ *
+ *   .manifest()                  pure data describing the wired surface
+ *                                (scanner / Studio / cache consume this)
+ *   .attach(host)                lifecycle hook called by the host endpoint
+ *                                when this interface is mounted on another
+ *
+ * And one DI shortcut kept for ergonomics:
+ *
+ *   .provide(container)          sugar that wires a Container into the chain
+ *                                via the same channel `.use()` uses.
+ *
+ * Each transport refines the generics:
+ *   - `TBinding`  — outbound binding shape (RouteBinding / JobBinding / …)
+ *   - `TPlugin`   — what `.use()` accepts (Koa middleware / plain fn / …)
+ *   - `TFromSource` — what `.from()` accepts (eventDef / remote ref / …)
+ *   - `TMountTarget` — what `.mount()` accepts (Koa app / express / iface)
+ *   - `TArtifact` — what `.boot()` produces (an opaque handle the host owns)
+ *
+ * The base owns the type signatures + manifest plumbing. It implements one
+ * verb concretely — `.provide()` — as a default that delegates to `.use()`.
+ * Transports may override if they need a different DI dispatch shape.
+ */
+/* ─── The abstract base ─────────────────────────────────────────────────── */
+/**
+ * Base class every transport extends.
+ *
+ * Implementing the contract:
+ *
+ *   class HttpInterfaceImpl extends InterfaceBuilder<
+ *     RouteBinding,
+ *     Koa.Middleware,
+ *     RouteBinding,      // `from` source shape (forwarded route)
+ *     Koa | NwireInterface,  // `mount` target shape
+ *     RawHttpHandler     // boot artifact
+ *   > {
+ *     readonly transport = "http" as const;
+ *     use(...mw) { … return this; }
+ *     wire(binding, handler) { … return this; }
+ *     from(src) { … return this; }
+ *     mount(target) { … return this; }
+ *     async run(opts) { … return lifecycle; }
+ *     async boot(opts) { … return booted; }
+ *     manifest() { … return data; }
+ *     attach(host) { … }
+ *   }
+ */
+export class InterfaceBuilder {
+    $nwireServable = true;
+    /**
+     * Lifecycle hook called by a host that's composing this interface into
+     * a larger app. The host passes its container + a way to register
+     * health checks. Default no-op subclasses override as needed.
+     */
+    attach(_host) {
+        // No-op by default. Transports override when they need to adopt the
+        // host's container or register transport-specific health checks.
+    }
+    /* ─── Per-request ctx provider ─────────────────────────────────────── */
+    /**
+     * Builders accumulated via `.provide()`. Transports apply each per
+     * request/job/invocation, spreading the merged result onto handler ctx.
+     * Last-write wins on key collision.
+     */
+    ctxBuilders = [];
+    /**
+     * Compose ctx extras for an incoming request. Transports call this in
+     * their dispatch loop to build the per-invocation extras object that
+     * gets spread onto handler ctx.
+     *
+     * The interface is agnostic to where the values come from. A wire
+     * builder may close over a container, read req headers, mint a request
+     * id, fetch a tenant — all opaque to the transport.
+     */
+    async composeCtxExtras(request) {
+        const result = {};
+        for (const builder of this.ctxBuilders) {
+            const extras = typeof builder === "function" ? await builder(request) : builder;
+            Object.assign(result, extras);
+        }
+        return result;
+    }
+    /**
+     * Register a ctx builder applied per request/job/invocation.
+     *
+     * - Static extras: every request gets the same object merged in.
+     * - Builder fn: receives the transport's native request value (`req`,
+     *   `job`, `evt`), returns extras to merge onto ctx.
+     *
+     * Multiple `.provide()` calls compose — each builder runs in
+     * registration order; later writes win on key collision.
+     *
+     *   api.provide({ logger: console });                            // static
+     *   api.provide((req) => ({ user: req.user }));                  // dynamic
+     *   api.provide((req) => ({ ...root.cradle, tenant: req.tenant })); // closes over container
+     *
+     * The interface NEVER imports `@nwire/container`. Whatever the wire
+     * passes is opaque here.
+     */
+    provide(builder) {
+        this.ctxBuilders.push(builder);
+        return this;
+    }
+}
+/* ─── Structural type narrows ────────────────────────────────────────── */
+/** Type narrow — does this value look like a Nwire interface? */
+export function isNwireInterface(x) {
+    return (typeof x === "object" &&
+        x !== null &&
+        x.$nwireServable === true &&
+        typeof x.transport === "string");
+}

package/dist/mcp/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * `@nwire/wires/mcp` — MCP binding factories.
+ *
+ *   import { tool, resource } from "@nwire/wires/mcp";
+ *
+ *   createInterface()
+ *     .wire(tool("create-order"), createOrder)
+ *     .wire(resource("orders://{id}"), getOrderResource);
+ *
+ * The `@nwire/mcp` adopter consumes wires by `$adapter === "mcp"` and
+ * registers each binding with the MCP server (`tool` becomes an MCP tool,
+ * `resource` becomes a resource template).
+ */
+import type { ZodTypeAny, z } from "zod";
+import type { Binding } from "../index.js";
+type ZodOutput<T> = T extends ZodTypeAny ? z.output<T> : unknown;
+export interface ToolBindingOptions {
+    /** Schema for the tool's input arguments. */
+    readonly input?: ZodTypeAny;
+    /** Human-readable summary surfaced on tool discovery. */
+    readonly description?: string;
+    readonly source?: string;
+}
+export interface ToolBinding<TInput = unknown> extends Binding {
+    readonly $kind: "binding";
+    readonly $adapter: "mcp";
+    readonly kind: "tool";
+    readonly tool: string;
+    readonly input?: ZodTypeAny;
+    readonly description?: string;
+    readonly source?: string;
+    from(source: string): ToolBinding<TInput>;
+    readonly __inputType?: TInput;
+}
+export declare function tool<O extends ToolBindingOptions = ToolBindingOptions>(toolName: string, options?: O): ToolBinding<O extends {
+    input: infer I;
+} ? (I extends ZodTypeAny ? ZodOutput<I> : unknown) : unknown>;
+export interface ResourceBindingOptions {
+    readonly description?: string;
+    readonly mimeType?: string;
+    readonly source?: string;
+}
+export interface ResourceBinding extends Binding {
+    readonly $kind: "binding";
+    readonly $adapter: "mcp";
+    readonly kind: "resource";
+    readonly uriTemplate: string;
+    readonly description?: string;
+    readonly mimeType?: string;
+    readonly source?: string;
+    from(source: string): ResourceBinding;
+}
+export declare function resource(uriTemplate: string, options?: ResourceBindingOptions): ResourceBinding;
+export {};

package/dist/mcp/index.js

@@ -0,0 +1,54 @@
+/**
+ * `@nwire/wires/mcp` — MCP binding factories.
+ *
+ *   import { tool, resource } from "@nwire/wires/mcp";
+ *
+ *   createInterface()
+ *     .wire(tool("create-order"), createOrder)
+ *     .wire(resource("orders://{id}"), getOrderResource);
+ *
+ * The `@nwire/mcp` adopter consumes wires by `$adapter === "mcp"` and
+ * registers each binding with the MCP server (`tool` becomes an MCP tool,
+ * `resource` becomes a resource template).
+ */
+function buildToolBinding(toolName, options, source) {
+    const binding = {
+        $kind: "binding",
+        $adapter: "mcp",
+        kind: "tool",
+        tool: toolName,
+        ...(options ?? {}),
+        ...(source !== undefined ? { source } : {}),
+    };
+    Object.defineProperty(binding, "from", {
+        value: (next) => buildToolBinding(toolName, options, next),
+        enumerable: false,
+        writable: false,
+        configurable: true,
+    });
+    return binding;
+}
+export function tool(toolName, options) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return buildToolBinding(toolName, options, undefined);
+}
+function buildResourceBinding(uriTemplate, options, source) {
+    const binding = {
+        $kind: "binding",
+        $adapter: "mcp",
+        kind: "resource",
+        uriTemplate,
+        ...(options ?? {}),
+        ...(source !== undefined ? { source } : {}),
+    };
+    Object.defineProperty(binding, "from", {
+        value: (next) => buildResourceBinding(uriTemplate, options, next),
+        enumerable: false,
+        writable: false,
+        configurable: true,
+    });
+    return binding;
+}
+export function resource(uriTemplate, options) {
+    return buildResourceBinding(uriTemplate, options, undefined);
+}

package/dist/queue/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * `@nwire/wires/queue` — queue binding factory.
+ *
+ *   import { queue } from "@nwire/wires/queue";
+ *
+ *   createInterface().wire(queue("orders.process"), processOrder);
+ *
+ * The binding carries `$adapter: "queue"` so a queue adopter
+ * (`@nwire/bullmq`, `@nwire/queue-redis`, …) filters wires via
+ * `interface.forAdapter("queue")`. Adopters interpret the queue-name
+ * field as a topic / channel / queue identifier per their impl.
+ */
+import type { ZodTypeAny, z } from "zod";
+import type { Binding } from "../index.js";
+/** Options accepted by `queue()`. */
+export interface QueueBindingOptions {
+    /** Schema for the message body. The adopter validates at dispatch. */
+    readonly input?: ZodTypeAny;
+    /** Free-form trigger source tag — Studio and observability group by it. */
+    readonly source?: string;
+    /**
+     * Per-binding concurrency hint — the adopter may honor or ignore.
+     * Default left to the adopter.
+     */
+    readonly concurrency?: number;
+}
+export interface QueueBinding<TInput = unknown> extends Binding {
+    readonly $kind: "binding";
+    readonly $adapter: "queue";
+    readonly kind: "queue";
+    readonly queue: string;
+    readonly input?: ZodTypeAny;
+    readonly source?: string;
+    readonly concurrency?: number;
+    /** Chainable source tag — returns a fresh binding. */
+    from(source: string): QueueBinding<TInput>;
+    readonly __inputType?: TInput;
+}
+type ZodOutput<T> = T extends ZodTypeAny ? z.output<T> : unknown;
+export declare function queue<O extends QueueBindingOptions = QueueBindingOptions>(queueName: string, options?: O): QueueBinding<O extends {
+    input: infer I;
+} ? (I extends ZodTypeAny ? ZodOutput<I> : unknown) : unknown>;
+export {};

package/dist/queue/index.js

@@ -0,0 +1,33 @@
+/**
+ * `@nwire/wires/queue` — queue binding factory.
+ *
+ *   import { queue } from "@nwire/wires/queue";
+ *
+ *   createInterface().wire(queue("orders.process"), processOrder);
+ *
+ * The binding carries `$adapter: "queue"` so a queue adopter
+ * (`@nwire/bullmq`, `@nwire/queue-redis`, …) filters wires via
+ * `interface.forAdapter("queue")`. Adopters interpret the queue-name
+ * field as a topic / channel / queue identifier per their impl.
+ */
+function buildBinding(queueName, options, source) {
+    const binding = {
+        $kind: "binding",
+        $adapter: "queue",
+        kind: "queue",
+        queue: queueName,
+        ...(options ?? {}),
+        ...(source !== undefined ? { source } : {}),
+    };
+    Object.defineProperty(binding, "from", {
+        value: (next) => buildBinding(queueName, options, next),
+        enumerable: false,
+        writable: false,
+        configurable: true,
+    });
+    return binding;
+}
+export function queue(queueName, options) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return buildBinding(queueName, options, undefined);
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@nwire/wires",
+  "version": "0.10.0",
+  "description": "Nwire — transport-interface contract. `InterfaceBuilder` is the abstract base every transport (HTTP, queue, MCP, GraphQL, …) extends. Foreign hosts implement it. Six universal verbs (.use / .wire / .from / .mount / .run / .boot) plus manifest + attach seams are typed at this layer so transports stay consistent.",
+  "keywords": [
+    "interface",
+    "nwire",
+    "transport"
+  ],
+  "license": "MIT",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./http": {
+      "import": "./dist/http/index.js",
+      "types": "./dist/http/index.d.ts"
+    },
+    "./queue": {
+      "import": "./dist/queue/index.js",
+      "types": "./dist/queue/index.d.ts"
+    },
+    "./cron": {
+      "import": "./dist/cron/index.js",
+      "types": "./dist/cron/index.d.ts"
+    },
+    "./mcp": {
+      "import": "./dist/mcp/index.js",
+      "types": "./dist/mcp/index.d.ts"
+    },
+    "./graphql": {
+      "import": "./dist/graphql/index.js",
+      "types": "./dist/graphql/index.d.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "zod": "^4.0.0",
+    "@nwire/handler": "0.10.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.9",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "scripts": {
+    "build": "tsc && node ../../scripts/fix-dist-extensions.mjs dist",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit"
+  }
+}