@silkweave/nestjs 2.0.0 → 2.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@silkweave/nestjs",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "Silkweave NestJS Adapter",
   "repository": {
     "type": "git",
@@ -8,12 +8,23 @@
     "directory": "packages/nestjs"
   },
   "type": "module",
-  "main": "build/index.mjs",
+  "main": "./build/index.mjs",
+  "types": "./build/index.d.mts",
+  "files": [
+    "build"
+  ],
+  "exports": {
+    ".": {
+      "@silkweave/source": "./src/index.ts",
+      "types": "./build/index.d.mts",
+      "default": "./build/index.mjs"
+    }
+  },
   "peerDependencies": {
     "@nestjs/common": "^10.0.0 || ^11.0.0",
     "@nestjs/core": "^10.0.0 || ^11.0.0",
     "@nestjs/swagger": "^7.0.0 || ^8.0.0 || ^11.0.0",
-    "class-validator": "^0.14.0"
+    "class-validator": "^0.14.0 || ^0.15.0"
   },
   "peerDependenciesMeta": {
     "@nestjs/swagger": {
@@ -27,9 +38,9 @@
     "cors": "^2.8.6",
     "express": "^5.2.1",
     "zod": "^3.25.0",
-    "@silkweave/auth": "2.0.0",
-    "@silkweave/core": "2.0.0",
-    "@silkweave/mcp": "2.0.0"
+    "@silkweave/core": "2.2.0",
+    "@silkweave/auth": "2.2.0",
+    "@silkweave/mcp": "2.2.0"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
@@ -56,9 +67,5 @@
     "typecheck": "tsc --noEmit",
     "lint": "eslint",
     "check": "pnpm lint && pnpm typecheck"
-  },
-  "exports": {
-    ".": "./build/index.mjs"
-  },
-  "types": "./build/index.d.ts"
+  }
 }

package/.turbo/turbo-build.log

@@ -1,16 +0,0 @@
-$ 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        339.14 kB │ gzip: 49.99 kB
-ℹ build/index.mjs.map    579.22 kB │ gzip: 88.28 kB
-ℹ build/index.d.mts.map    3.06 kB │ gzip:  1.10 kB
-ℹ build/index.d.mts       17.08 kB │ gzip:  6.02 kB
-ℹ 4 files, total: 938.50 kB
-✔ Build complete in 1034ms

package/.turbo/turbo-check.log

@@ -1,3 +0,0 @@
-$ pnpm lint && pnpm typecheck
-$ eslint
-$ tsc --noEmit

package/.turbo/turbo-lint.log

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

package/.turbo/turbo-prepack.log

@@ -1,18 +0,0 @@
-$ 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        344.18 kB │ gzip: 51.78 kB
-ℹ build/index.mjs.map    589.05 kB │ gzip: 91.22 kB
-ℹ build/index.d.mts.map    3.45 kB │ gzip:  1.22 kB
-ℹ build/index.d.mts       20.10 kB │ gzip:  6.89 kB
-ℹ 4 files, total: 956.79 kB
-✔ Build complete in 822ms

package/eslint.config.mjs

@@ -1,93 +0,0 @@
-import eslint from '@eslint/js'
-import stylistic from '@stylistic/eslint-plugin'
-import { defineConfig } from 'eslint/config'
-import tseslint from 'typescript-eslint'
-
-export default defineConfig(eslint.configs.recommended, tseslint.configs.recommendedTypeChecked, tseslint.configs.stylisticTypeChecked, {
-  languageOptions: {
-    parserOptions: {
-      project: 'tsconfig.json',
-      tsconfigRootDir: import.meta.dirname
-    }
-  },
-  plugins: { '@stylistic': stylistic },
-  rules: {
-    '@stylistic/space-in-parens': ['error'],
-    '@stylistic/comma-spacing': ['error'],
-    '@stylistic/no-multi-spaces': ['error'],
-    '@stylistic/no-trailing-spaces': ['error'],
-    '@stylistic/no-whitespace-before-property': ['error'],
-    '@stylistic/array-bracket-newline': ['error', 'consistent'],
-    '@stylistic/array-bracket-spacing': ['error'],
-    '@stylistic/arrow-spacing': ['error'],
-    '@stylistic/arrow-parens': ['error', 'always'],
-    '@stylistic/block-spacing': ['error', 'always'],
-    '@stylistic/brace-style': ['error', '1tbs', { 'allowSingleLine': true }],
-    '@stylistic/comma-dangle': ['error', 'never'],
-    '@stylistic/key-spacing': ['error'],
-    '@stylistic/keyword-spacing': ['error'],
-    '@stylistic/member-delimiter-style': ['error', { 'multiline': { 'delimiter': 'none' } }],
-    '@stylistic/no-extra-semi': ['error'],
-    '@stylistic/indent': ['error', 2],
-    '@stylistic/no-multiple-empty-lines': ['error', { 'max': 1, 'maxEOF': 0, 'maxBOF': 0 }],
-    '@stylistic/object-curly-spacing': ['error', 'always'],
-    '@stylistic/quotes': ['error', 'single'],
-    '@stylistic/semi': ['error', 'never'],
-    '@stylistic/space-before-blocks': ['error', 'always'],
-    '@stylistic/space-before-function-paren': ['error', { 'anonymous': 'always', 'named': 'never', 'asyncArrow': 'always' }],
-    '@typescript-eslint/adjacent-overload-signatures': 'error',
-    '@typescript-eslint/array-type': 'off',
-    '@typescript-eslint/await-thenable': 'error',
-    '@typescript-eslint/ban-types': 'off',
-    '@typescript-eslint/consistent-type-assertions': 'off',
-    '@typescript-eslint/explicit-function-return-type': 'off',
-    '@typescript-eslint/explicit-member-accessibility': 'off',
-    '@typescript-eslint/no-angle-bracket-type-assertion': 'off',
-    '@typescript-eslint/no-empty-function': 'off',
-    '@typescript-eslint/no-empty-interface': 'off',
-    '@typescript-eslint/no-extra-non-null-assertion': 'error',
-    '@typescript-eslint/no-floating-promises': 'off',
-    '@typescript-eslint/no-misused-new': 'error',
-    '@typescript-eslint/no-misused-promises': 'off',
-    '@typescript-eslint/no-namespace': 'off',
-    '@typescript-eslint/no-non-null-asserted-optional-chain': 'error',
-    '@typescript-eslint/no-non-null-assertion': 'off',
-    '@typescript-eslint/no-object-literal-type-assertion': 'off',
-    '@typescript-eslint/no-parameter-properties': 'off',
-    '@typescript-eslint/no-shadow': 'error',
-    '@typescript-eslint/no-triple-slash-reference': 'off',
-    '@typescript-eslint/no-unused-vars': ['error', {
-      'args': 'all',
-      'argsIgnorePattern': '^_',
-      'caughtErrors': 'all',
-      'caughtErrorsIgnorePattern': '^_',
-      'destructuredArrayIgnorePattern': '^_',
-      'varsIgnorePattern': '^_',
-      'ignoreRestSiblings': true
-    }],
-    '@typescript-eslint/no-use-before-define': 'off',
-    '@typescript-eslint/no-var-requires': 'off',
-    '@typescript-eslint/prefer-for-of': 'error',
-    '@typescript-eslint/prefer-interface': 'off',
-    '@typescript-eslint/prefer-nullish-coalescing': 'off',
-    '@typescript-eslint/prefer-optional-chain': 'error',
-    '@typescript-eslint/return-await': 'error',
-    '@typescript-eslint/unified-signatures': 'error',
-    '@typescript-eslint/no-unsafe-return': 'off',
-    '@typescript-eslint/no-redundant-type-constituents': 'off',
-    '@typescript-eslint/no-unsafe-member-access': 'off',
-    '@typescript-eslint/no-unsafe-call': 'off',
-    '@typescript-eslint/no-unsafe-argument': 'off',
-    '@typescript-eslint/dot-notation': 'off',
-    '@typescript-eslint/prefer-regexp-exec': 'off',
-    '@typescript-eslint/require-await': 'off',
-    '@typescript-eslint/only-throw-error': 'error',
-    '@typescript-eslint/no-base-to-string': 'off',
-    '@typescript-eslint/restrict-template-expressions': 'off'
-  }
-}, {
-  files: ['eslint.config.mjs'],
-  extends: [tseslint.configs.disableTypeChecked]
-}, {
-  ignores: ['build', 'tsdown.config.ts', 'scratch']
-})

package/src/adapter/mcp.ts

@@ -1,102 +0,0 @@
-import { AuthConfig } from '@silkweave/auth'
-import {
-  authMiddleware,
-  mcpCors,
-  mcpTransport,
-  oauthRoutes,
-  protectedResourceMetadata,
-  sideloadResource
-} from '@silkweave/mcp'
-import { type CorsOptions } from 'cors'
-import express, { type RequestHandler } from 'express'
-import type { NestAdapterRegisterContext, NestSilkweaveAdapter } from '../lib/types.js'
-
-export 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 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
-}
-
-function compose(...handlers: RequestHandler[]): RequestHandler {
-  return (req, res, next) => {
-    let i = 0
-    const dispatch: () => void = () => {
-      const h = handlers[i++]
-      if (!h) { return next() }
-      h(req, res, (err) => err ? next(err) : dispatch())
-    }
-    dispatch()
-  }
-}
-
-/**
- * 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`):
- *
- * - `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)
- *
- * 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.
- */
-export function mcp(options: McpAdapterOptions = {}): NestSilkweaveAdapter {
-  return {
-    name: 'mcp',
-    register({ httpAdapter, silkweaveOptions, baseContext, actions }: NestAdapterRegisterContext): void {
-      const basePath = (options.basePath ?? '/mcp').replace(/\/$/, '')
-      if (!basePath) { throw new Error('@silkweave/nestjs mcp(): basePath cannot be empty or "/" - pick a path like "/mcp".') }
-
-      const adapter = httpAdapter as unknown as {
-        get: (path: string, ...h: RequestHandler[]) => unknown
-        post: (path: string, ...h: RequestHandler[]) => unknown
-        delete: (path: string, ...h: RequestHandler[]) => unknown
-      }
-
-      const corsHandler = mcpCors(options.cors ?? true)
-      const auth = options.auth
-      const guard = auth ? authMiddleware(auth, baseContext) : null
-      const prefix = (...handlers: (RequestHandler | null)[]): RequestHandler[] =>
-        handlers.filter((h): h is RequestHandler => Boolean(h))
-
-      // Public auth-discovery / OAuth routes - registered first so they're
-      // never inadvertently guarded by the auth middleware.
-      if (auth?.authorizationServers?.length && auth.resourceUrl) {
-        adapter.get(
-          `${basePath}/.well-known/oauth-protected-resource`,
-          ...prefix(corsHandler, protectedResourceMetadata(auth))
-        )
-      }
-      if (auth?.provider) {
-        const oauth = oauthRoutes(auth)
-        adapter.get(`${basePath}/.well-known/oauth-authorization-server`, ...prefix(corsHandler, oauth.wellKnownAuthServer))
-        adapter.get(`${basePath}/authorize`, ...prefix(corsHandler, oauth.authorize))
-        adapter.get(`${basePath}${oauth.callbackPath}`, ...prefix(corsHandler, oauth.callback))
-        adapter.post(`${basePath}/token`, ...prefix(corsHandler, ...oauth.token))
-        adapter.post(`${basePath}/register`, ...prefix(corsHandler, ...oauth.register))
-      }
-
-      // Protected routes - wrapped with auth middleware (when configured).
-      const protect = guard ? (h: RequestHandler) => compose(guard, h) : (h: RequestHandler) => h
-
-      if (options.sideloadResources !== false) {
-        adapter.get(`${basePath}/resource/:id`, ...prefix(corsHandler, protect(sideloadResource({ resourceDir: options.resourceDir }))))
-      }
-
-      const transport = mcpTransport(silkweaveOptions, baseContext, actions)
-      adapter.post(basePath, ...prefix(corsHandler, express.json(), protect(transport.post)))
-      adapter.get(basePath, ...prefix(corsHandler, protect(transport.stream)))
-      adapter.delete(basePath, ...prefix(corsHandler, protect(transport.stream)))
-    }
-  }
-}

package/src/decorator/mcp.ts

@@ -1,39 +0,0 @@
-import { SetMetadata } from '@nestjs/common'
-import { MCP_METADATA, type McpMetadata } from '../lib/metadata.js'
-
-/**
- * Method decorator that exposes an existing NestJS controller route as an MCP
- * tool. It is **additive** - the route keeps serving HTTP exactly as before;
- * `@Mcp()` just opts the method into MCP discovery.
- *
- * The tool's name, description, and input schema are reflected from the
- * method's own metadata:
- * - **fields** from the parameter decorators (`@Param`/`@Query`/`@Body`) - a
- *   `@Param('id')` becomes an `id` field; a whole-DTO `@Body() dto: CreateDto`
- *   is flattened to its properties,
- * - **types/constraints/descriptions** from `@nestjs/swagger`
- *   (`@ApiParam`/`@ApiQuery`/`@ApiProperty`/`@ApiOperation`) and, when present,
- *   `class-validator` decorators on the DTOs,
- * - optionally refined by an OpenAPI document passed to `SilkweaveModule`.
- *
- * On a tool call the input is split back into the method's positional arguments
- * and the method is invoked directly (with `@UseGuards` guards applied first).
- *
- * @example
- * ```ts
- * @Controller('sessions/:sessionId/channels')
- * export class ChannelsController {
- *   @Get(':channelId')
- *   @ApiOperation({ summary: 'Get a specific channel by ID' })
- *   @ApiParam({ name: 'sessionId', description: 'Session ID' })
- *   @ApiParam({ name: 'channelId', description: 'Channel ID' })
- *   @Mcp()
- *   findOne(@Param('sessionId') sessionId: string, @Param('channelId') channelId: string) {
- *     return this.service.get(sessionId, channelId)
- *   }
- * }
- * ```
- */
-export function Mcp(options: McpMetadata = {}): MethodDecorator {
-  return SetMetadata(MCP_METADATA, options)
-}

package/src/index.ts

@@ -1,10 +0,0 @@
-export * from './adapter/mcp.js'
-export * from './decorator/mcp.js'
-export * from './lib/controllerDiscovery.js'
-export * from './lib/guards.js'
-export * from './lib/metadata.js'
-export * from './lib/rebind.js'
-export * from './lib/silkweave.module.js'
-export * from './lib/types.js'
-export * from './lib/reflect/openapi.js'
-export * from './lib/reflect/schema.js'

package/src/lib/controllerDiscovery.ts

@@ -1,201 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import { Injectable, type Type } from '@nestjs/common'
-import { DiscoveryService, MetadataScanner, ModuleRef, Reflector } from '@nestjs/core'
-import { createAction, type Action, type SilkweaveContext } from '@silkweave/core'
-import { z } from 'zod/v4'
-import { collectGuards, runGuards } from './guards.js'
-import { MCP_METADATA, type McpMetadata } from './metadata.js'
-import { invokeRebound, specialBinding, type Binding } from './rebind.js'
-import { buildOpenApiLookup, openApiFields, type OpenApiDocument, type OpenApiLookup } from './reflect/openapi.js'
-import { PARAMTYPE, type ParamSlot, readParamSlots } from './reflect/params.js'
-import { reflectRoute } from './reflect/route.js'
-import { type FieldDesc, fieldToZod, mergeField, reflectDtoFields } from './reflect/schema.js'
-import { reflectOperation } from './reflect/swagger.js'
-
-interface DiscoveredMcp {
-  instance: object
-  classRef: Type<unknown>
-  method: (...args: unknown[]) => unknown
-  methodName: string
-  meta: McpMetadata
-}
-
-interface BuiltInput {
-  shape: Record<string, z.ZodType>
-  bindings: Binding[]
-}
-
-@Injectable()
-export class ControllerDiscovery {
-  constructor(
-    private readonly discovery: DiscoveryService,
-    private readonly scanner: MetadataScanner,
-    private readonly reflector: Reflector,
-    private readonly moduleRef: ModuleRef
-  ) { }
-
-  /**
-   * Walk every Nest provider/controller, find methods annotated with `@Mcp`,
-   * and build a core `Action` per method whose input schema is reflected from
-   * the route + parameter decorators (+ optional OpenAPI document) and whose
-   * `run` re-binds the validated input back into the method's positional
-   * arguments (with `@UseGuards` guards applied first).
-   */
-  discover(openapi?: OpenApiDocument): Action[] {
-    const lookup = openapi ? buildOpenApiLookup(openapi) : undefined
-    const discovered: DiscoveredMcp[] = []
-    for (const wrapper of this.discovery.getProviders().concat(this.discovery.getControllers())) {
-      const { instance } = wrapper
-      if (!instance || typeof instance !== 'object') { continue }
-      const proto = Object.getPrototypeOf(instance) as object | null
-      if (!proto) { continue }
-      const classRef = instance.constructor as Type<unknown>
-      for (const methodName of this.scanner.getAllMethodNames(proto)) {
-        const method = (proto as Record<string, unknown>)[methodName] as ((...args: unknown[]) => unknown) | undefined
-        if (typeof method !== 'function') { continue }
-        const meta = this.reflector.get<McpMetadata>(MCP_METADATA, method)
-        if (!meta) { continue }
-        discovered.push({ instance, classRef, method, methodName, meta })
-      }
-    }
-    return discovered.map((d) => this.toAction(d, lookup))
-  }
-
-  private toAction(d: DiscoveredMcp, lookup: OpenApiLookup | undefined): Action {
-    const proto = Object.getPrototypeOf(d.instance) as object
-    const route = reflectRoute(d.classRef, d.method)
-    const slots = readParamSlots(d.classRef, d.methodName, proto)
-    const operation = reflectOperation(d.method)
-    const docFields = lookup ? openApiFields(lookup, route.method, route.openapiPath) : {}
-
-    const { shape, bindings } = this.buildInput(d, route.pathParams, slots, operation.params, docFields)
-
-    const base = d.classRef.name.replace(/Controller$/, '')
-    const name = d.meta.name ?? `${base}.${d.methodName}`
-    const description = d.meta.description ?? operation.description ?? `${d.methodName} (${route.method} /${route.path})`
-    const applyParamPipes = d.meta.pipes !== 'skip'
-
-    const guards = collectGuards(this.reflector, d.classRef, d.method)
-    const { moduleRef, reflector } = this
-    const classRef = d.classRef
-    const method = d.method
-    const instance = d.instance
-
-    const applyGuards = async (context: SilkweaveContext): Promise<void> => {
-      if (guards.length === 0) { return }
-      const request = context.getOptional<unknown>('request')
-      const response = context.getOptional<unknown>('response') ?? null
-      const hasRequest = request != null
-      const guardRequest = hasRequest ? request : { headers: {}, params: {}, query: {} }
-      await runGuards(guards, moduleRef, reflector, classRef, method, guardRequest, response, hasRequest ? 'http' : 'rpc')
-    }
-
-    return createAction({
-      name,
-      description,
-      input: z.object(shape),
-      // Only the MCP adapter exposes `@Mcp` methods; a future `@Trpc` decorator
-      // would tag its own actions for the tRPC adapter.
-      isEnabled: (ctx) => ctx.getOptional<string>('adapter') === 'mcp',
-      run: async (input: object, context: SilkweaveContext): Promise<object> => {
-        await applyGuards(context)
-        const request = context.getOptional<{ headers?: Record<string, unknown> }>('request')
-        const result = await invokeRebound(method, instance, input as Record<string, unknown>, bindings, request, applyParamPipes)
-        return (result ?? {})
-      }
-    }) as Action
-  }
-
-  /** Build the merged Zod input shape and the per-argument re-bind plan. */
-  private buildInput(
-    d: DiscoveredMcp,
-    pathParams: string[],
-    slots: ReturnType<typeof readParamSlots>,
-    operationParams: Record<string, FieldDesc>,
-    docFields: Record<string, FieldDesc>
-  ): BuiltInput {
-    const proto = Object.getPrototypeOf(d.instance) as object
-    const designTypes = (Reflect.getMetadata('design:paramtypes', proto, d.methodName) as unknown[] | undefined) ?? []
-    const fields: Record<string, FieldDesc> = {}
-    const maxIndex = slots.reduce((m, s) => Math.max(m, s.index), -1)
-    const bindings: Binding[] = Array.from({ length: maxIndex + 1 }, () => ({ kind: 'missing' as const }))
-
-    const addField = (name: string, desc: FieldDesc): void => {
-      fields[name] = name in fields ? mergeField(fields[name], desc) : desc
-    }
-
-    for (const slot of slots) {
-      const { binding, fields: contributed } = contributeSlot(slot, pathParams, designTypes)
-      bindings[slot.index] = binding
-      for (const [name, desc] of Object.entries(contributed)) { addField(name, desc) }
-    }
-
-    // Layer operation-level (`@ApiParam`/`@ApiQuery`) then OpenAPI-document
-    // metadata over the structural fields (later sources win per field).
-    for (const [name, desc] of Object.entries(operationParams)) {
-      if (name in fields) { fields[name] = mergeField(fields[name], desc) }
-    }
-    for (const [name, desc] of Object.entries(docFields)) {
-      if (name in fields) { fields[name] = mergeField(fields[name], desc) }
-    }
-
-    const shape: Record<string, z.ZodType> = {}
-    for (const [name, desc] of Object.entries(fields)) { shape[name] = fieldToZod(desc) }
-    // `@Mcp({ input })` raw-shape override wins per field.
-    Object.assign(shape, d.meta.input ?? {})
-
-    return { shape, bindings }
-  }
-}
-
-function designTypeAt(designTypes: unknown[], index: number): FieldDesc {
-  const ctor = designTypes[index]
-  if (ctor === String) { return { type: 'string' } }
-  if (ctor === Number) { return { type: 'number' } }
-  if (ctor === Boolean) { return { type: 'boolean' } }
-  return {}
-}
-
-interface SlotContribution {
-  binding: Binding
-  /** Input fields this slot contributes, keyed by field name. */
-  fields: Record<string, FieldDesc>
-}
-
-/** A `@Param('id')` scalar or a bare `@Param()` covering all path params. */
-function paramContribution(slot: ParamSlot, pathParams: string[]): SlotContribution {
-  if (slot.data) {
-    return {
-      binding: { kind: 'value', field: slot.data, source: 'path', metatype: slot.designType, pipes: slot.pipes },
-      fields: { [slot.data]: { type: 'string', required: true } }
-    }
-  }
-  const fields: Record<string, FieldDesc> = {}
-  for (const p of pathParams) { fields[p] = { type: 'string', required: true } }
-  return { binding: { kind: 'params', fields: pathParams }, fields }
-}
-
-/** A `@Query('x')`/`@Body('x')` scalar or a whole-DTO `@Query()`/`@Body()`. */
-function bodyOrQueryContribution(slot: ParamSlot, source: 'query' | 'body', requiredScalar: boolean, designTypes: unknown[]): SlotContribution {
-  if (slot.data) {
-    return {
-      binding: { kind: 'value', field: slot.data, source, metatype: slot.designType, pipes: slot.pipes },
-      fields: { [slot.data]: mergeField(designTypeAt(designTypes, slot.index), { required: requiredScalar }) }
-    }
-  }
-  const dtoFields = reflectDtoFields(slot.designType)
-  return {
-    binding: { kind: 'object', source, fields: Object.keys(dtoFields), metatype: slot.designType, pipes: slot.pipes },
-    fields: dtoFields
-  }
-}
-
-/** Map one parameter slot to its input-field contribution and re-bind instruction. */
-function contributeSlot(slot: ParamSlot, pathParams: string[], designTypes: unknown[]): SlotContribution {
-  switch (slot.paramtype) {
-    case PARAMTYPE.PARAM: return paramContribution(slot, pathParams)
-    case PARAMTYPE.QUERY: return bodyOrQueryContribution(slot, 'query', false, designTypes)
-    case PARAMTYPE.BODY: return bodyOrQueryContribution(slot, 'body', true, designTypes)
-    default: return { binding: specialBinding(slot.paramtype, slot.data) ?? { kind: 'missing' }, fields: {} }
-  }
-}

package/src/lib/executionContext.ts

@@ -1,76 +0,0 @@
-import type { ArgumentsHost, ContextType, ExecutionContext, Type } from '@nestjs/common'
-
-/** Subset of `HttpArgumentsHost` we need - re-declared inline to avoid deep `@nestjs/common/interfaces` imports. */
-interface HttpHost {
-  getRequest<T = unknown>(): T
-  getResponse<T = unknown>(): T
-  getNext<T = unknown>(): T
-}
-
-interface RpcHost {
-  getData<T = unknown>(): T
-  getContext<T = unknown>(): T
-}
-
-interface WsHost {
-  getClient<T = unknown>(): T
-  getData<T = unknown>(): T
-  getPattern(): string
-}
-
-/**
- * Minimal `ExecutionContext` impl Nest guards can consume. We only need
- * `switchToHttp()` to work for our HTTP-backed transports; the RPC/WS shims are
- * stubbed so guards that introspect type can still call them without crashing.
- */
-export class SilkweaveExecutionContext implements ExecutionContext, ArgumentsHost {
-  constructor(
-    private readonly args: unknown[],
-    private readonly classRef: Type<unknown>,
-    private readonly handler: (...handlerArgs: unknown[]) => unknown,
-    private readonly contextType = 'http'
-  ) { }
-
-  getType<T extends string = ContextType>(): T {
-    return this.contextType as T
-  }
-
-  getClass<T = unknown>(): Type<T> {
-    return this.classRef as Type<T>
-  }
-
-  getHandler(): (...handlerArgs: unknown[]) => unknown {
-    return this.handler
-  }
-
-  getArgs<T extends unknown[] = unknown[]>(): T {
-    return this.args as T
-  }
-
-  getArgByIndex<T = unknown>(index: number): T {
-    return this.args[index] as T
-  }
-
-  switchToHttp(): HttpHost {
-    return {
-      getRequest: <T = unknown>(): T => this.args[0] as T,
-      getResponse: <T = unknown>(): T => this.args[1] as T,
-      getNext: <T = unknown>(): T => this.args[2] as T
-    }
-  }
-
-  switchToRpc(): RpcHost {
-    return {
-      getData: <T = unknown>(): T => this.args[0] as T,
-      getContext: <T = unknown>(): T => this.args[1] as T
-    }
-  }
-
-  switchToWs(): WsHost {
-    return {
-      getClient: <T = unknown>(): T => this.args[0] as T,
-      getData: <T = unknown>(): T => this.args[1] as T,
-      getPattern: (): string => ''
-    }
-  }
-}