@silkweave/nestjs 1.9.0

package/.turbo/turbo-build.log

@@ -0,0 +1,17 @@
+$ tsdown
+ℹ tsdown v0.21.8 powered by rolldown v1.0.0-rc.15
+ℹ config file: /Users/atomic/projects/silkweave/silkweave/packages/nestjs/tsdown.config.ts 
+ℹ entry: src/index.ts
+ℹ tsconfig: tsconfig.json
+ℹ Build start
+ℹ Cleaning 4 files
+ℹ 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        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

package/.turbo/turbo-check.log

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

package/README.md

@@ -0,0 +1,210 @@
+# @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.
+
+## Install
+
+```bash
+pnpm add @silkweave/core @silkweave/nestjs @nestjs/common @nestjs/core @nestjs/platform-express reflect-metadata
+```
+
+> NestJS dev workflows need decorator-aware transforms. Recommend `@swc-node/register` (`node --import @swc-node/register/esm-register src/main.ts`) or the standard `nest start` CLI; plain `tsx` doesn't emit decorator metadata.
+
+## Usage
+
+```ts
+// users.actions.ts
+import { Injectable, UseGuards } from '@nestjs/common'
+import { type SilkweaveContext } from '@silkweave/core'
+import { Action, Actions } from '@silkweave/nestjs'
+import z from 'zod/v4'
+import { AdminGuard } from './admin.guard.js'
+
+const ListInput = z.object({ activeOnly: z.coerce.boolean().optional() })
+const GetInput = z.object({ id: z.string() })
+const BanInput = z.object({ id: z.string(), reason: z.string() })
+
+@Injectable()
+@Actions('users')
+export class UserActions {
+  constructor(private readonly db: DbService) {}
+
+  @Action({
+    description: 'List users',
+    input: ListInput,
+    kind: 'query'
+  })
+  list(input: z.infer<typeof ListInput>, _ctx: SilkweaveContext) {
+    return this.db.listUsers(input.activeOnly)
+  }
+
+  @Action({
+    description: 'Get a single user by ID',
+    input: GetInput,
+    kind: 'query'
+  })
+  get(input: z.infer<typeof GetInput>) {
+    return this.db.getUser(input.id)
+  }
+
+  @UseGuards(AdminGuard)
+  @Action({
+    description: 'Ban a user',
+    input: BanInput,
+    transports: ['rest', 'trpc']   // exclude from MCP tools
+  })
+  ban(input: z.infer<typeof BanInput>) {
+    return this.db.banUser(input.id, input.reason)
+  }
+}
+```
+
+```ts
+// app.module.ts
+import { Module } from '@nestjs/common'
+import { mcp, rest, SilkweaveModule, trpc } from '@silkweave/nestjs'
+import { AdminGuard } from './admin.guard.js'
+import { UserActions } from './users.actions.js'
+
+@Module({
+  imports: [
+    SilkweaveModule.forRoot({
+      silkweave: { name: 'my-app', description: 'My App', version: '1.0.0' },
+      adapters: [
+        rest({ basePath: '/api' }),
+        trpc({ basePath: '/trpc' }),
+        mcp({ basePath: '/' })
+      ]
+    })
+  ],
+  providers: [AdminGuard, UserActions]
+})
+export class AppModule {}
+```
+
+```ts
+// main.ts
+import 'reflect-metadata'
+import { NestFactory } from '@nestjs/core'
+import { AppModule } from './app.module.js'
+
+const app = await NestFactory.create(AppModule)
+await app.listen(8080)
+```
+
+The `users.list` and `users.get` actions are now reachable via:
+
+- **REST:** `GET /api/users/list?activeOnly=true` and `GET /api/users/get?id=1`
+- **tRPC:** `client.usersList.query({ activeOnly: true })` and `client.usersGet.query({ id: '1' })`
+- **MCP:** tools `UsersList` and `UsersGet`
+
+`users.ban` skips MCP per its `transports: ['rest', 'trpc']` and is guarded by `@UseGuards(AdminGuard)` on every transport that has an HTTP request.
+
+## Decorators
+
+### `@Action(options)` (method decorator)
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `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) |
+| `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 |
+
+### `@Actions(prefix?)` (class decorator)
+
+Groups a class's actions under a common prefix. Joined to method-level names with a dot.
+
+```ts
+@Actions('users')
+class UserActions {
+  @Action({ ... }) list(...) {}    // action name: 'users.list'
+  @Action({ name: 'top' }) ... {}  // action name: 'users.top'
+}
+```
+
+Accepts either a string (shorthand) or `{ prefix, transports }` for a class-wide transport default.
+
+## Adapters
+
+### `rest(options?)`
+
+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 |
+
+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.
+
+### `trpc(options?)`
+
+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 |
+
+Action names with dots (e.g. `users.list`) collapse to camelCase procedure keys (`usersList`) — flat router in v1.
+
+### `mcp(options?)`
+
+Mounts MCP Streamable HTTP at `{basePath}/mcp`, plus optional OAuth routes when `auth.provider` is set. Reuses `@silkweave/mcp`'s `createMcpExpressHandler`.
+
+| 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`) |
+
+## 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.
+
+```ts
+@Injectable()
+class MyActions {
+  constructor(
+    private readonly db: DbService,
+    private readonly cache: CacheService
+  ) {}
+
+  @UseGuards(AuthGuard, RateLimitGuard)
+  @Action({ description: '...', input: z.object({...}) })
+  async myAction(input, ctx) {
+    return this.db.query(...)
+  }
+}
+```
+
+## Action name → transport path
+
+| Action name | REST path | tRPC procedure | MCP tool |
+|-------------|-----------|----------------|----------|
+| `hello` | `/hello` | `hello` | `Hello` |
+| `users.list` | `/users/list` | `usersList` | `UsersList` |
+| `posts.get-by-id` | `/posts/get-by-id` | `postsGetById` | `PostsGetById` |
+
+## Notes
+
+- **Lifecycle:** adapters mount their route slots in `OnModuleInit` (before Nest's 404 catch-all is installed) and populate the handlers in `OnApplicationBootstrap` after `@Action` discovery.
+- **Express only by default.** `@nestjs/platform-fastify` requires `@fastify/express` registered upfront so Nest can serve Express-style middleware (used by all three adapters internally).
+- **Query coercion for REST queries:** request query strings are always strings; use `z.coerce.boolean()` / `z.coerce.number()` in your Zod schemas for queries.
+- **`reflect-metadata`** must be imported once at the top of your entry file (typical Nest requirement).
+
+## License
+
+ISC. See [LICENSE](./LICENSE).

package/build/index.d.mts

@@ -0,0 +1,315 @@
+import { CreateMcpExpressHandlerOptions } from "@silkweave/mcp";
+import { CanActivate, DynamicModule, OnApplicationBootstrap, OnApplicationShutdown, OnModuleInit, Type } from "@nestjs/common";
+import { AuthConfig } from "@silkweave/auth";
+import { Action as Action$1, ActionKind, AdapterGenerator, Silkweave, SilkweaveContext, SilkweaveOptions } from "@silkweave/core";
+import z$1 from "zod/v4";
+import { InferTrpcRouter } from "@silkweave/trpc";
+import { DiscoveryService, HttpAdapterHost, MetadataScanner, ModuleRef, Reflector } from "@nestjs/core";
+
+//#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.
+ */
+interface NestSilkweaveAdapter {
+  /** Adapter discriminator — set on the silkweave context as `ctx.get('adapter')`. */
+  readonly name: 'rest' | 'trpc' | 'mcp';
+  /**
+   * 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()`.
+   */
+  install(host: HttpAdapterHost): AdapterGenerator;
+}
+interface SilkweaveModuleOptions {
+  /** 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). */
+  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. */
+  basePath?: string;
+  /** Optional bearer-token / OAuth auth applied to MCP requests. Same shape as `@silkweave/mcp`'s `http()` auth. */
+  auth?: AuthConfig;
+}
+/**
+ * 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.
+ *
+ * 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)
+ *
+ * Note: this adapter mounts an Express sub-app. On `@nestjs/platform-fastify`,
+ * register `@fastify/express` before this adapter so Nest can serve Express
+ * middleware.
+ */
+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: `'/'`. */
+  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:
+ *
+ * - `kind: 'query'` → `GET ${basePath}/${actionName-with-slashes}` (input read from query string)
+ * - `kind: 'mutation'` → `POST ${basePath}/${actionName-with-slashes}` (input read 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.
+ */
+declare function rest(options?: RestAdapterOptions): NestSilkweaveAdapter;
+//#endregion
+//#region src/adapter/trpc.d.ts
+interface TrpcAdapterOptions {
+  /** URL prefix at which the tRPC handler is mounted. Default `'/trpc'`. */
+  basePath?: string;
+  /** Optional bearer-token auth applied to every tRPC procedure. */
+  auth?: AuthConfig;
+}
+/**
+ * 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 names with dots (e.g. `users.list` from `@Actions('users')`) collapse
+ * to camelCase procedure keys (`usersList`) for v1 — flat router only.
+ *
+ * Works on `@nestjs/platform-express`. On `@nestjs/platform-fastify`, register
+ * `@fastify/express` first so Nest can mount Express-style middleware.
+ */
+declare function trpc(options?: TrpcAdapterOptions): 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> {
+  /** Action name. Defaults to the kebab-cased method name. */
+  name?: string;
+  /** Human-readable description. Becomes the MCP tool description and REST OpenAPI summary. */
+  description: string;
+  /** Zod object schema for the action's input. */
+  input: z$1.ZodType<I> & {
+    shape: Record<string, z$1.ZodTypeAny>;
+  };
+  /** Optional Zod object schema for the action's output (used by tRPC type inference). */
+  output?: z$1.ZodType<O> & {
+    shape: Record<string, z$1.ZodTypeAny>;
+  };
+  /** `'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. */
+  transports?: Transport[];
+  /** Dynamic enable check (in addition to `transports`). AND-combined with the transports filter. */
+  isEnabled?: (context: SilkweaveContext) => boolean;
+  /** Custom MCP `CallToolResult` formatter. See `@silkweave/mcp`'s `smartToolResult`. */
+  toolResult?: Action$1<I, O>['toolResult'];
+  /** CLI positional-argument keys (unused for HTTP-only adapters, kept for parity with `createAction`). */
+  args?: (keyof I)[];
+  /** Custom MCP tool name override. If unset, derived from action name as PascalCase. */
+  mcpToolName?: string;
+}
+interface ActionsClassMetadata {
+  /** Prefix joined to the method-level action name with a dot. e.g. `Actions('users')` + method `list` → `users.list`. */
+  prefix?: string;
+  /** Class-level transports allowlist. Method-level `transports` overrides; otherwise inherits this. */
+  transports?: Transport[];
+}
+interface ResultToolResult<O extends object = object> {
+  toolResult?: Action$1<object, O>['toolResult'];
+}
+type AnyActionMetadata = ActionMetadata<object, object> & ResultToolResult<object>;
+declare const ACTION_RESPONSE_KEY = "__silkweave_response__";
+//#endregion
+//#region src/decorator/action.d.ts
+/**
+ * Method decorator that registers a Silkweave action.
+ *
+ * The decorated method becomes an Action and is exposed via every adapter
+ * configured on `SilkweaveModule` (REST/tRPC/MCP), unless `transports` is
+ * provided to restrict it.
+ *
+ * The method receives `(input, context)` where `input` is the parsed Zod input
+ * and `context` is the `SilkweaveContext` (with `logger`, `request`, optional
+ * `auth`). The class instance is a normal Nest provider, so other services can
+ * be injected via the constructor.
+ *
+ * @example
+ * ```ts
+ * @Injectable()
+ * @Actions('users')
+ * export class UserActions {
+ *   constructor(private db: DbService) {}
+ *
+ *   @Action({
+ *     description: 'List users',
+ *     input: z.object({ limit: z.number().optional() }),
+ *     kind: 'query'
+ *   })
+ *   list(input: { limit?: number }, ctx: SilkweaveContext) {
+ *     return this.db.listUsers(input.limit)
+ *   }
+ * }
+ * ```
+ */
+declare function Action<I extends object = object, O extends object = object>(options: ActionMetadata<I, O>): MethodDecorator;
+//#endregion
+//#region src/decorator/actions.d.ts
+/**
+ * Class decorator that groups a provider's `@Action` methods under a common
+ * 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()`
+ * separately so it can be resolved by the DI container.
+ *
+ * Accepts either a prefix string (shorthand) or a full options object:
+ * ```ts
+ * @Actions('users')
+ * @Actions({ prefix: 'users', transports: ['rest', 'trpc'] })
+ * ```
+ */
+declare function Actions(prefixOrOptions?: string | ActionsClassMetadata): ClassDecorator;
+//#endregion
+//#region src/lib/discovery.d.ts
+declare class ActionDiscovery {
+  private readonly discovery;
+  private readonly scanner;
+  private readonly reflector;
+  private readonly moduleRef;
+  constructor(discovery: DiscoveryService, scanner: MetadataScanner, reflector: Reflector, moduleRef: ModuleRef);
+  /**
+   * Walk every Nest provider, find methods annotated with `@Action`, and build
+   * a list of core `Action` objects ready to feed into `silkweave().actions()`.
+   *
+   * Action invocation is wrapped to (a) run `@UseGuards` guards declared on the
+   * method or its class against the incoming HTTP request (read from
+   * `ctx.get('request')`) and (b) bind `this` to the resolved Nest provider so
+   * DI-injected dependencies remain available.
+   */
+  discover(): Action$1[];
+  private toAction;
+}
+//#endregion
+//#region src/lib/filter.d.ts
+/**
+ * Compile a `transports` allowlist + optional user `isEnabled` into a single
+ * `(ctx) => boolean` callback compatible with `Action.isEnabled`.
+ *
+ * - If `transports` is omitted, the action runs on every adapter.
+ * - If `transports` is set, the action is gated on `ctx.get<string>('adapter')`
+ *   matching one of the listed transports. Each adapter in `@silkweave/nestjs`
+ *   forks its context with `{ adapter: 'rest' | 'trpc' | 'mcp' }`.
+ * - If both `transports` and `userIsEnabled` are set, they are AND-combined.
+ */
+declare function buildIsEnabled(transports: Transport[] | undefined, userIsEnabled: ((ctx: SilkweaveContext) => boolean) | undefined): ((ctx: SilkweaveContext) => boolean) | undefined;
+//#endregion
+//#region src/lib/guards.d.ts
+type GuardRef = Type<CanActivate> | CanActivate;
+/**
+ * Read `@UseGuards(...)` metadata for both the method and its class and merge
+ * the two lists. Method-level guards run AFTER class-level guards (matching
+ * Nest's own behavior).
+ */
+declare function collectGuards(reflector: Reflector, classRef: Type<unknown>, handler: (...args: unknown[]) => unknown): GuardRef[];
+/**
+ * Run the configured guards against an HTTP request. Throws `ForbiddenException`
+ * if any guard rejects, mirroring Nest's HTTP request-pipeline behavior.
+ *
+ * Pass `null` for `response` when running on top of a tRPC or MCP request that
+ * doesn't surface a raw response object; guards that introspect the response
+ * will receive `null`.
+ */
+declare function runGuards(guards: GuardRef[], moduleRef: ModuleRef, reflector: Reflector, classRef: Type<unknown>, handler: (...args: unknown[]) => unknown, request: unknown, response: unknown): Promise<void>;
+//#endregion
+//#region src/lib/silkweave.module.d.ts
+/**
+ * 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`.
+ *
+ * @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({
+ *       silkweave: { name: 'app', description: 'My App', version: '1.0.0' },
+ *       adapters: [
+ *         rest({ basePath: '/api' }),
+ *         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 {
+  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;
+}
+//#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 };
+//# sourceMappingURL=index.d.mts.map

package/build/index.d.mts.map

@@ -0,0 +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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"}