@silkweave/nestjs 1.9.0 → 1.10.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 $ tsdown
-ℹ tsdown v0.21.8 powered by rolldown v1.0.0-rc.15
+ℹ tsdown v0.21.10 powered by rolldown v1.0.0-rc.17
 ℹ config file: /Users/atomic/projects/silkweave/silkweave/packages/nestjs/tsdown.config.ts 
 ℹ entry: src/index.ts
 ℹ tsconfig: tsconfig.json
@@ -9,9 +9,9 @@ $ tsdown
 See more at https://tsdown.dev/options/dependencies#deps-onlybundle
 Detected dependencies in bundle:
 - rxjs
-ℹ build/index.mjs        336.69 kB │ gzip: 48.97 kB
-ℹ build/index.mjs.map    574.23 kB │ gzip: 86.16 kB
-ℹ build/index.d.mts.map    2.82 kB │ gzip:  1.03 kB
-ℹ build/index.d.mts       14.64 kB │ gzip:  4.94 kB
-ℹ 4 files, total: 928.38 kB
-✔ Build complete in 815ms
+ℹ build/index.mjs        337.92 kB │ gzip: 49.52 kB
+ℹ build/index.mjs.map    576.49 kB │ gzip: 87.36 kB
+ℹ build/index.d.mts.map    2.98 kB │ gzip:  1.07 kB
+ℹ build/index.d.mts       15.96 kB │ gzip:  5.58 kB
+ℹ 4 files, total: 933.34 kB
+✔ Build complete in 1110ms

package/.turbo/turbo-check.log

@@ -1,4 +1,3 @@
 $ pnpm lint && pnpm typecheck
 $ eslint
-[ELIFECYCLE] Command failed.
-[ELIFECYCLE] Command failed.
+$ tsc --noEmit

package/.turbo/turbo-lint.log

@@ -0,0 +1,2 @@
+
+$ eslint

package/.turbo/turbo-prepack.log

@@ -0,0 +1,19 @@
+
+$ pnpm clean && pnpm build
+$ rimraf build
+$ tsdown
+ℹ tsdown v0.21.10 powered by rolldown v1.0.0-rc.17
+ℹ config file: /Users/atomic/projects/silkweave/silkweave/packages/nestjs/tsdown.config.ts 
+ℹ entry: src/index.ts
+ℹ tsconfig: tsconfig.json
+ℹ Build start
+ℹ Hint: consider adding deps.onlyBundle option to avoid unintended bundling of dependencies, or set deps.onlyBundle: false to disable this hint.
+See more at https://tsdown.dev/options/dependencies#deps-onlybundle
+Detected dependencies in bundle:
+- rxjs
+ℹ build/index.mjs        337.92 kB │ gzip: 49.52 kB
+ℹ build/index.mjs.map    576.49 kB │ gzip: 87.36 kB
+ℹ build/index.d.mts.map    2.98 kB │ gzip:  1.07 kB
+ℹ build/index.d.mts       15.96 kB │ gzip:  5.58 kB
+ℹ 4 files, total: 933.34 kB
+✔ Build complete in 828ms

package/README.md

@@ -1,6 +1,6 @@
 # @silkweave/nestjs
 
-NestJS adapter for [Silkweave](https://github.com/silkweave/silkweave). Define actions as method decorators on Nest providers, then expose them simultaneously over REST, tRPC, and MCP Streamable HTTP — all mounted on the running Nest HTTP server so Nest middleware, guards, and lifecycle hooks stay coherent.
+NestJS adapter for [Silkweave](https://github.com/silkweave/silkweave). Define actions as method decorators on Nest providers, then expose them simultaneously over REST, tRPC, and MCP Streamable HTTP - all mounted on the running Nest HTTP server so Nest middleware, guards, and lifecycle hooks stay coherent.
 
 ## Install
 
@@ -73,7 +73,7 @@ import { UserActions } from './users.actions.js'
       adapters: [
         rest({ basePath: '/api' }),
         trpc({ basePath: '/trpc' }),
-        mcp({ basePath: '/' })
+        mcp({ basePath: '/mcp' })
       ]
     })
   ],
@@ -109,11 +109,12 @@ The `users.list` and `users.get` actions are now reachable via:
 | `name` | `string` | kebab-cased method name | Override the action name. Joined with the class prefix via `.` |
 | `description` | `string` | *required* | Human-readable summary. Used as MCP tool description |
 | `input` | `z.ZodObject` | *required* | Zod object schema for the action's input |
-| `output` | `z.ZodObject` | — | Optional output schema (used by tRPC type inference) |
+| `output` | `z.ZodObject` | - | Optional output schema (used by tRPC type inference) |
+| `chunk` | `z.ZodType` | - | Schema for chunks yielded by a streaming (`async function*`) method. **Required** when the method is an async generator |
 | `kind` | `'query' \| 'mutation'` | `'mutation'` | `'query'` → GET in REST, `.query()` in tRPC. `'mutation'` → POST / `.mutation()` |
 | `transports` | `('rest' \| 'trpc' \| 'mcp')[]` | all | Allowlist of transports that expose this action |
-| `isEnabled` | `(ctx) => boolean` | — | Dynamic gate (AND-combined with `transports`) |
-| `toolResult` | `(response, ctx) => CallToolResult` | — | Custom MCP `CallToolResult` formatter |
+| `isEnabled` | `(ctx) => boolean` | - | Dynamic gate (AND-combined with `transports`) |
+| `toolResult` | `(response, ctx) => CallToolResult` | - | Custom MCP `CallToolResult` formatter |
 
 ### `@Actions(prefix?)` (class decorator)
 
@@ -137,15 +138,15 @@ Maps actions to REST routes on the Nest HTTP server.
 
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
-| `basePath` | `string` | `'/'` | URL prefix joined to each action's path |
-| `auth` | `AuthConfig` | — | `@silkweave/auth` bearer-token config |
+| `basePath` | `string` | `'/api'` | URL prefix joined to each action's path |
+| `auth` | `AuthConfig` | - | `@silkweave/auth` bearer-token config |
 
 Routes follow `{basePath}/{action-name-with-slashes}` where dots in action names become slashes:
 
 - `users.list` (query) → `GET /api/users/list`
 - `users.ban` (mutation) → `POST /api/users/ban`
 
-Input is parsed from `req.query` (queries) or `req.body` (mutations) and validated against the action's Zod schema; validation failures return HTTP 400 with the Zod issues.
+Each action is registered as an individual route on Nest's HTTP adapter (not a sub-app). Input is parsed from `req.query` (queries) or `req.body` (mutations) and validated against the action's Zod schema; validation failures return HTTP 400 with the Zod issues.
 
 ### `trpc(options?)`
 
@@ -154,25 +155,45 @@ Mounts a tRPC HTTP handler built from `@silkweave/trpc`'s `buildRouter`.
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
 | `basePath` | `string` | `'/trpc'` | URL prefix the tRPC handler listens on |
-| `auth` | `AuthConfig` | — | `@silkweave/auth` bearer-token config |
+| `auth` | `AuthConfig` | - | `@silkweave/auth` bearer-token config |
 
-Action names with dots (e.g. `users.list`) collapse to camelCase procedure keys (`usersList`) — flat router in v1.
+Action names with dots (e.g. `users.list`) collapse to camelCase procedure keys (`usersList`) - flat router in v1.
+
+**Streaming.** An `@Action` method declared as an `async function*` (with a `chunk` schema) is registered as a tRPC **subscription** that streams each yielded chunk over SSE - exactly like a standalone `createAction({ chunk, run: async function*(){…} })`. `@UseGuards()` guards still run before the first chunk. This is what `useChat` + `@silkweave/ai`'s `silkweaveTransport()` consume.
+
+```ts
+@Action({
+  description: 'Stream a countdown',
+  input: z.object({ from: z.number().int() }),
+  chunk: z.object({ n: z.number().int() })
+})
+async *countdown(input: { from: number }) {
+  for (let n = input.from; n >= 0; n -= 1) {
+    await new Promise((r) => setTimeout(r, 200))
+    yield { n }
+  }
+}
+```
+
+Declaring an async-generator method without a `chunk` schema throws at discovery time - the schema is required for typegen/tRPC to expose the subscription.
 
 ### `mcp(options?)`
 
-Mounts MCP Streamable HTTP at `{basePath}/mcp`, plus optional OAuth routes when `auth.provider` is set. Reuses `@silkweave/mcp`'s `createMcpExpressHandler`.
+Mounts the MCP Streamable HTTP transport directly at `basePath`, with sideload (`{basePath}/resource/:id`), well-known auth metadata (`{basePath}/.well-known/...`), and the OAuth proxy routes (`{basePath}/authorize`, `/token`, `/register`, `/auth/callback`) namespaced under the same prefix. Composes the handler primitives from `@silkweave/mcp` - no Express sub-app.
 
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
-| `basePath` | `string` | `'/'` | Mount point for the MCP sub-app |
-| `auth` | `AuthConfig` | — | Bearer-token / OAuth 2.1 config |
-| `cors` | `CorsOptions \| boolean` | `true` | CORS config (see `@silkweave/mcp`) |
+| `basePath` | `string` | `'/mcp'` | URL prefix; the MCP transport endpoint is at this exact path |
+| `auth` | `AuthConfig` | - | Bearer-token / OAuth 2.1 config |
+| `cors` | `CorsOptions \| boolean` | `true` | CORS config |
+| `sideloadResources` | `boolean` | `true` | Mount `{basePath}/resource/:id` |
+| `resourceDir` | `string` | `'resources'` | Directory the sideload route reads from |
 
 ## Guards & DI
 
 Native NestJS `@UseGuards()` and `@UseInterceptors()` on `@Action` methods run for every HTTP-backed transport. Guards receive an `ExecutionContext` with the HTTP request in `switchToHttp().getRequest()`. The `Reflector` is also wired up so guards can read custom metadata.
 
-Action methods are normal Nest provider methods — inject services via the constructor as usual.
+Action methods are normal Nest provider methods - inject services via the constructor as usual.
 
 ```ts
 @Injectable()

package/build/index.d.mts

@@ -1,87 +1,106 @@
-import { CreateMcpExpressHandlerOptions } from "@silkweave/mcp";
-import { CanActivate, DynamicModule, OnApplicationBootstrap, OnApplicationShutdown, OnModuleInit, Type } from "@nestjs/common";
+import { CanActivate, DynamicModule, MiddlewareConsumer, NestModule, Type } from "@nestjs/common";
 import { AuthConfig } from "@silkweave/auth";
-import { Action as Action$1, ActionKind, AdapterGenerator, Silkweave, SilkweaveContext, SilkweaveOptions } from "@silkweave/core";
+import { Action as Action$1, ActionKind, SilkweaveContext, SilkweaveOptions } from "@silkweave/core";
 import z$1 from "zod/v4";
 import { InferTrpcRouter } from "@silkweave/trpc";
+import { TypegenFormat } from "@silkweave/typegen";
 import { DiscoveryService, HttpAdapterHost, MetadataScanner, ModuleRef, Reflector } from "@nestjs/core";
+import { CorsOptions } from "cors";
 
 //#region src/lib/types.d.ts
 /**
- * A Silkweave NestJS adapter. Each transport (REST, tRPC, MCP) implements this
- * shape: given a Nest `HttpAdapterHost`, it (a) immediately mounts a
- * placeholder middleware slot on Nest's running HTTP server during
- * `OnModuleInit` — which is critical because Nest installs its 404 catch-all
- * later in `init()`, before `OnApplicationBootstrap` fires; routes registered
- * after the catch-all are unreachable — and (b) returns a core
- * `AdapterGenerator` whose `start(actions)` populates that slot with the real
- * handler.
- *
- * Adapters mount onto Nest's HTTP server instead of owning their own, so Nest
- * middleware, lifecycle hooks, and request scoping remain coherent.
+ * Context passed to a Nest Silkweave adapter when `SilkweaveModule` wires it
+ * up. Adapters register their routes directly on `httpAdapter` (no
+ * placeholder middleware, no `silkweave()` builder), so they only fire
+ * `register()` once and own the rest of their lifecycle implicitly through
+ * Nest.
+ */
+interface NestAdapterRegisterContext {
+  /** Nest's underlying HTTP adapter (Express or Fastify). */
+  httpAdapter: NonNullable<HttpAdapterHost['httpAdapter']>;
+  /** Identity the adapter surfaces to clients (e.g. MCP server name). */
+  silkweaveOptions: SilkweaveOptions;
+  /** Per-adapter context - already forked with `{ adapter: adapter.name, ...userContext }`. */
+  baseContext: SilkweaveContext;
+  /** Actions filtered to those enabled on this adapter. */
+  actions: Action$1[];
+}
+/**
+ * A Silkweave Nest adapter. Each transport (REST, tRPC, MCP) implements this
+ * shape. `register()` is called from `SilkweaveModule.configure()` - which
+ * runs *before* Nest's controller routes are mapped - so adapter routes
+ * always sit ahead of any catch-all controllers in the framework's request
+ * pipeline.
  */
 interface NestSilkweaveAdapter {
-  /** Adapter discriminator — set on the silkweave context as `ctx.get('adapter')`. */
-  readonly name: 'rest' | 'trpc' | 'mcp';
+  /** Adapter discriminator - set on the silkweave context as `ctx.get('adapter')`. */
+  readonly name: 'rest' | 'trpc' | 'mcp' | 'typegen';
   /**
-   * Reserve the adapter's route prefix on the Nest HTTP server *now* (before
-   * Nest's 404 catch-all is installed) and return the core `AdapterGenerator`
-   * that will populate the slot during `silkweave().start()`.
+   * When `true`, the adapter receives every discovered action regardless of
+   * each action's `transports` allowlist / `isEnabled` gate. Used by
+   * non-runtime adapters like `typegen()` that emit types for the entire
+   * action surface.
    */
-  install(host: HttpAdapterHost): AdapterGenerator;
+  readonly allActions?: boolean;
+  /** Register this adapter's routes on Nest's HTTP server. */
+  register(ctx: NestAdapterRegisterContext): void;
 }
 interface SilkweaveModuleOptions {
-  /** Identity for the silkweave instance — surfaced to MCP clients, OpenAPI, etc. */
+  /** Identity for the silkweave instance - surfaced to MCP clients, OpenAPI, etc. */
   silkweave: SilkweaveOptions;
   /** Adapters to mount. Examples: `rest()`, `trpc()`, `mcp()`. */
   adapters: NestSilkweaveAdapter[];
-  /** Initial context keys (equivalent to chaining `.set(key, value)` on the builder). */
+  /** Initial context keys merged into every adapter's `baseContext`. */
   context?: Record<string, unknown>;
 }
 declare const SILKWEAVE_MODULE_OPTIONS = "__silkweave_module_options__";
 //#endregion
 //#region src/adapter/mcp.d.ts
-interface McpAdapterOptions extends Omit<CreateMcpExpressHandlerOptions, 'auth'> {
-  /** URL prefix at which the MCP sub-app is mounted. Default `'/'` — the MCP transport then lives at `/mcp`, OAuth routes at `/authorize`, etc. */
+interface McpAdapterOptions {
+  /** URL prefix the MCP namespace lives under - the transport itself is at this exact path. Default `'/mcp'`. */
   basePath?: string;
-  /** Optional bearer-token / OAuth auth applied to MCP requests. Same shape as `@silkweave/mcp`'s `http()` auth. */
+  /** Optional bearer-token / OAuth 2.1 config. */
   auth?: AuthConfig;
+  /** CORS configuration. `false` to disable, `true`/omitted for permissive defaults, or a `CorsOptions` object. */
+  cors?: CorsOptions | boolean;
+  /** Mount the sideload resource route at `${basePath}/resource/:id`. Default `true`. */
+  sideloadResources?: boolean;
+  /** Directory the sideload route reads from. Default `'resources'`. */
+  resourceDir?: string;
 }
 /**
- * MCP Streamable HTTP adapter for `@silkweave/nestjs`. Builds the same Express
- * sub-app that `@silkweave/mcp`'s `http()` adapter uses internally (via
- * `createMcpExpressHandler`) and mounts it on Nest's running HTTP server at
- * the configured base path.
+ * MCP adapter for `@silkweave/nestjs`. Registers the MCP Streamable HTTP
+ * transport, sideload, well-known and OAuth routes individually on Nest's
+ * HTTP adapter at the configured `basePath` (default `/mcp`):
  *
- * Routes provided by the mounted sub-app:
- * - `POST /mcp`, `GET /mcp`, `DELETE /mcp` — MCP Streamable HTTP transport
- * - `GET /resource/:id` — sideload resources (large MCP responses)
- * - `GET /.well-known/oauth-protected-resource` (when `auth.resourceUrl`/`auth.authorizationServers` set)
- * - `GET /authorize`, `POST /token`, `POST /register`, `GET /auth/callback` (when `auth.provider` set)
+ * - `POST/GET/DELETE ${basePath}` - Streamable HTTP transport
+ * - `GET ${basePath}/resource/:id` - sideload (`sideloadResources` opt-out)
+ * - `GET ${basePath}/.well-known/oauth-protected-resource` - RFC 9728 metadata (when `auth.resourceUrl`/`auth.authorizationServers` set)
+ * - `GET ${basePath}/authorize`, `POST ${basePath}/token`, `POST ${basePath}/register`, `GET ${basePath}${callbackPath}` (when `auth.provider` set)
  *
- * Note: this adapter mounts an Express sub-app. On `@nestjs/platform-fastify`,
- * register `@fastify/express` before this adapter so Nest can serve Express
- * middleware.
+ * Each route is a real Nest-level route - they show up in
+ * `RoutesResolver`'s log and there is no sub-app or middleware-slot
+ * indirection.
  */
 declare function mcp(options?: McpAdapterOptions): NestSilkweaveAdapter;
 //#endregion
 //#region src/adapter/rest.d.ts
 interface RestAdapterOptions {
-  /** URL prefix at which the REST routes are mounted. e.g. `'/api'` → `POST /api/users/list`. Default: `'/'`. */
+  /** URL prefix joined to each action's path. e.g. `'/api'` → `POST /api/users/list`. Default: `'/api'`. */
   basePath?: string;
   /** Optional bearer-token auth applied to every REST action. */
   auth?: AuthConfig;
 }
 /**
- * REST adapter for `@silkweave/nestjs`. Mounts each discovered `@Action` as a
- * route on Nest's running HTTP server:
+ * REST adapter for `@silkweave/nestjs`. Registers each discovered `@Action`
+ * as an individual route on Nest's HTTP adapter:
  *
- * - `kind: 'query'` → `GET ${basePath}/${actionName-with-slashes}` (input read from query string)
- * - `kind: 'mutation'` → `POST ${basePath}/${actionName-with-slashes}` (input read from JSON body)
+ * - `kind: 'query'` → `GET ${basePath}/${actionName-with-slashes}` (input from query string)
+ * - `kind: 'mutation'` → `POST ${basePath}/${actionName-with-slashes}` (input from JSON body)
  *
- * Works on `@nestjs/platform-express` out of the box. For
- * `@nestjs/platform-fastify`, register `@fastify/express` before this adapter
- * so Nest can serve Express-style middleware.
+ * Routes show up in Nest's `RoutesResolver` logger and are eligible for
+ * `@nestjs/swagger` scanning. Works on `@nestjs/platform-express` out of the
+ * box. For `@nestjs/platform-fastify`, register `@fastify/express` first.
  */
 declare function rest(options?: RestAdapterOptions): NestSilkweaveAdapter;
 //#endregion
@@ -94,23 +113,51 @@ interface TrpcAdapterOptions {
 }
 /**
  * tRPC adapter for `@silkweave/nestjs`. Builds a tRPC router from discovered
- * `@Action` methods via `@silkweave/trpc`'s `buildRouter` and mounts the
- * resulting `createExpressMiddleware()` at the configured base path on Nest's
- * underlying HTTP server.
+ * `@Action` methods and mounts the resulting express middleware at
+ * `basePath` on Nest's HTTP adapter.
  *
  * Action names with dots (e.g. `users.list` from `@Actions('users')`) collapse
- * to camelCase procedure keys (`usersList`) for v1 — flat router only.
+ * to camelCase procedure keys (`usersList`).
  *
  * Works on `@nestjs/platform-express`. On `@nestjs/platform-fastify`, register
- * `@fastify/express` first so Nest can mount Express-style middleware.
+ * `@fastify/express` first so Nest can serve Express-style middleware.
  */
 declare function trpc(options?: TrpcAdapterOptions): NestSilkweaveAdapter;
 //#endregion
+//#region src/adapter/typegen.d.ts
+interface TypegenAdapterOptions {
+  /** Output file path for the generated `.d.ts` file. Resolved against `process.cwd()`. Parent directories are created automatically. */
+  path: string;
+  /**
+   * What to emit (default `'all'`):
+   * - `'interfaces'` - `{Name}Input` / `{Name}Output` interfaces per action
+   * - `'trpc-router'` - `AppRouter` type alias for `createTRPCClient<AppRouter>()`
+   * - `'all'` - both
+   */
+  format?: TypegenFormat;
+  /**
+   * Whether to write the file at all. Default: `process.env.NODE_ENV !== 'production'`.
+   * Server processes generally shouldn't write to disk in production deploys -
+   * leave it on the default unless you know you want otherwise.
+   */
+  enabled?: boolean;
+}
+/**
+ * Typegen adapter for `@silkweave/nestjs`. Discovers every `@Action`-decorated
+ * method (regardless of `transports` filtering) and writes a single `.d.ts`
+ * file with REST input/output interfaces and/or a tRPC `AppRouter` type alias.
+ *
+ * Designed for the monorepo pattern where the server (this app) is the source
+ * of truth for types and consumer apps import from `path` - e.g.
+ * `path: '../app/src/types/silkweave.ts'`.
+ */
+declare function typegen(options: TypegenAdapterOptions): NestSilkweaveAdapter;
+//#endregion
 //#region src/lib/metadata.d.ts
 declare const ACTION_METADATA = "__silkweave_action__";
 declare const ACTIONS_METADATA = "__silkweave_actions__";
 type Transport = 'rest' | 'trpc' | 'mcp';
-interface ActionMetadata<I extends object = object, O extends object = object> {
+interface ActionMetadata<I extends object = object, O extends object = object, C = unknown> {
   /** Action name. Defaults to the kebab-cased method name. */
   name?: string;
   /** Human-readable description. Becomes the MCP tool description and REST OpenAPI summary. */
@@ -123,6 +170,13 @@ interface ActionMetadata<I extends object = object, O extends object = object> {
   output?: z$1.ZodType<O> & {
     shape: Record<string, z$1.ZodTypeAny>;
   };
+  /**
+   * Zod schema for individual chunks yielded by a streaming (async-generator)
+   * action method. Required when the decorated method is an `async function*`.
+   * Mirrors `Action.chunk` in @silkweave/core; typegen/trpc use it to expose
+   * the action as a tRPC subscription.
+   */
+  chunk?: z$1.ZodType<C>;
   /** `'query'` (GET in REST, `.query()` in tRPC) or `'mutation'` (POST in REST, `.mutation()` in tRPC). Default: `'mutation'`. */
   kind?: ActionKind;
   /** Allowlist of transports that should expose this action. Default: all registered transports. */
@@ -179,7 +233,7 @@ declare const ACTION_RESPONSE_KEY = "__silkweave_response__";
  * }
  * ```
  */
-declare function Action<I extends object = object, O extends object = object>(options: ActionMetadata<I, O>): MethodDecorator;
+declare function Action<I extends object = object, O extends object = object, C = unknown>(options: ActionMetadata<I, O, C>): MethodDecorator;
 //#endregion
 //#region src/decorator/actions.d.ts
 /**
@@ -187,7 +241,7 @@ declare function Action<I extends object = object, O extends object = object>(op
  * prefix. The prefix is joined to each method's action name with a dot
  * (e.g. `@Actions('users')` + method `list` → action name `users.list`).
  *
- * The class itself remains a normal Nest provider — add `@Injectable()`
+ * The class itself remains a normal Nest provider - add `@Injectable()`
  * separately so it can be resolved by the DI container.
  *
  * Accepts either a prefix string (shorthand) or a full options object:
@@ -253,17 +307,16 @@ declare function runGuards(guards: GuardRef[], moduleRef: ModuleRef, reflector:
 /**
  * Root module for `@silkweave/nestjs`.
  *
- * Discovers every `@Action`-decorated method across the Nest app via
- * `DiscoveryService`, builds core `Action` objects from them, and mounts the
- * configured adapters (`rest()`, `trpc()`, `mcp()`) onto Nest's running HTTP
- * server during `OnApplicationBootstrap`.
+ * Discovers every `@Action`-decorated method via `DiscoveryService` and
+ * registers the configured adapters (`rest()`, `trpc()`, `mcp()`) directly on
+ * Nest's HTTP adapter inside `configure()`. Because `configure()` runs during
+ * `registerModules` - before Nest's `registerRouter()` step - Silkweave's
+ * routes always sit ahead of every controller in the Express stack. There is
+ * no slot middleware, no race with Nest's 404 catch-all, and every route
+ * shows up in Nest's `RoutesResolver` logger.
  *
  * @example
  * ```ts
- * import { Module } from '@nestjs/common'
- * import { SilkweaveModule, rest, trpc, mcp } from '@silkweave/nestjs'
- * import { UsersModule } from './users.module.js'
- *
  * @Module({
  *   imports: [
  *     SilkweaveModule.forRoot({
@@ -273,43 +326,20 @@ declare function runGuards(guards: GuardRef[], moduleRef: ModuleRef, reflector:
  *         trpc({ basePath: '/trpc' }),
  *         mcp({ basePath: '/mcp' })
  *       ]
- *     }),
- *     UsersModule
+ *     })
  *   ]
  * })
  * export class AppModule {}
  * ```
  */
-declare class SilkweaveModule {
-  static forRoot(options: SilkweaveModuleOptions): DynamicModule;
-}
-//#endregion
-//#region src/lib/silkweave.service.d.ts
-/**
- * Coordinates the Nest lifecycle for `@silkweave/nestjs`:
- *
- * - `onModuleInit`: each configured adapter calls `install(host)` to reserve a
- *   placeholder middleware slot at its base path. This must happen here, not
- *   in `onApplicationBootstrap`, because Nest installs its 404 catch-all later
- *   during `init()` — routes registered after the catch-all are unreachable.
- *
- * - `onApplicationBootstrap`: discovers every `@Action` method, then drives the
- *   standard `silkweave().adapter(...).actions(...).start()` flow, which calls
- *   each adapter's `start(actions)` to populate the slot reserved earlier.
- */
-declare class SilkweaveService implements OnModuleInit, OnApplicationBootstrap, OnApplicationShutdown {
+declare class SilkweaveModule implements NestModule {
   private readonly options;
   private readonly discovery;
   private readonly httpAdapterHost;
-  private builder?;
-  private readonly generators;
   constructor(options: SilkweaveModuleOptions, discovery: ActionDiscovery, httpAdapterHost: HttpAdapterHost);
-  onModuleInit(): void;
-  onApplicationBootstrap(): Promise<void>;
-  onApplicationShutdown(): Promise<void>;
-  /** Access the underlying silkweave builder once bootstrap has completed. */
-  getBuilder(): Silkweave | undefined;
+  static forRoot(options: SilkweaveModuleOptions): DynamicModule;
+  configure(_consumer: MiddlewareConsumer): void;
 }
 //#endregion
-export { ACTIONS_METADATA, ACTION_METADATA, ACTION_RESPONSE_KEY, Action, ActionDiscovery, ActionMetadata, Actions, type ActionsClassMetadata, AnyActionMetadata, type InferTrpcRouter, McpAdapterOptions, NestSilkweaveAdapter, RestAdapterOptions, ResultToolResult, SILKWEAVE_MODULE_OPTIONS, SilkweaveModule, SilkweaveModuleOptions, SilkweaveService, type Transport, TrpcAdapterOptions, buildIsEnabled, collectGuards, mcp, rest, runGuards, trpc };
+export { ACTIONS_METADATA, ACTION_METADATA, ACTION_RESPONSE_KEY, Action, ActionDiscovery, ActionMetadata, Actions, type ActionsClassMetadata, AnyActionMetadata, type InferTrpcRouter, McpAdapterOptions, NestAdapterRegisterContext, NestSilkweaveAdapter, RestAdapterOptions, ResultToolResult, SILKWEAVE_MODULE_OPTIONS, SilkweaveModule, SilkweaveModuleOptions, type Transport, TrpcAdapterOptions, TypegenAdapterOptions, buildIsEnabled, collectGuards, mcp, rest, runGuards, trpc, typegen };
 //# sourceMappingURL=index.d.mts.map

package/build/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/lib/types.ts","../src/adapter/mcp.ts","../src/adapter/rest.ts","../src/adapter/trpc.ts","../src/lib/metadata.ts","../src/decorator/action.ts","../src/decorator/actions.ts","../src/lib/discovery.ts","../src/lib/filter.ts","../src/lib/guards.ts","../src/lib/silkweave.module.ts","../src/lib/silkweave.service.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/lib/types.ts","../src/adapter/mcp.ts","../src/adapter/rest.ts","../src/adapter/trpc.ts","../src/adapter/typegen.ts","../src/lib/metadata.ts","../src/decorator/action.ts","../src/decorator/actions.ts","../src/lib/discovery.ts","../src/lib/filter.ts","../src/lib/guards.ts","../src/lib/silkweave.module.ts"],"mappings":"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"}