@forinda/kickjs 6.6.1 → 6.7.0

package/dist/{views-D_LVXJWs.mjs.map → views-3TYTcdyF.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"views-D_LVXJWs.mjs","names":[],"sources":["../src/core/define-adapter.ts","../src/http/middleware/views.ts"],"sourcesContent":["import type { AppAdapter, AdapterContext } from './adapter'\nimport type { BuildContext } from './define-plugin'\n\n/**\n * Options passed to {@link defineAdapter}. Mirrors {@link DefinePluginOptions}\n * exactly — see `architecture.md` §21.3.4 for the definePlugin/defineAdapter\n * symmetry rationale.\n *\n * The optional `TExtra` generic lets an adapter ship public methods\n * beyond the standard {@link AppAdapter} contract — they're preserved\n * on the returned adapter instance so external callers (tests, peer\n * adapters) can invoke them directly. See `OtelAdapter.applyRedaction`\n * for the canonical use case.\n */\nexport interface DefineAdapterOptions<TConfig, TExtra = unknown> {\n  /**\n   * Stable identity used for logging, `dependsOn` lookups, and `.scoped()`\n   * namespacing. Required for adapters that participate in `dependsOn`\n   * sort — error messages reference adapters by name.\n   */\n  name: string\n  version?: string\n  requires?: { kickjs?: string }\n  defaults?: Partial<TConfig>\n  build(config: TConfig, ctx: BuildContext): Omit<AppAdapter, 'name'> & TExtra\n}\n\n/**\n * Async-config form of an adapter. Identical shape to `PluginAsyncOptions`\n * but resolved during `beforeStart` (the earliest async hook in\n * `AppAdapter`) — meaning `middleware()` and `contributors()` from the inner\n * adapter are **not** picked up. Use the bare/`.scoped()` form when you need\n * those.\n */\nexport interface AdapterAsyncOptions<TConfig> {\n  inject?: ReadonlyArray<unknown>\n  useFactory(...deps: any[]): TConfig | Promise<TConfig>\n}\n\n/**\n * Factory returned by {@link defineAdapter}. Same surface as\n * {@link PluginFactory} (call / `.scoped()` / `.async()`) so adopters learn\n * one mental model for both primitives. Returned instances carry both\n * the standard {@link AppAdapter} contract and any `TExtra` extension\n * methods the `build` function exposed.\n */\nexport interface AdapterFactory<TConfig, TExtra = unknown> {\n  (config?: Partial<TConfig>): AppAdapter & TExtra\n  scoped(scopeName: string, config?: Partial<TConfig>): AppAdapter & TExtra\n  async(opts: AdapterAsyncOptions<TConfig>): AppAdapter\n  readonly definition: Readonly<DefineAdapterOptions<TConfig, TExtra>>\n}\n\nconst mergeConfig = <TConfig>(\n  defaults: Partial<TConfig> = {},\n  overrides: Partial<TConfig> = {},\n): TConfig => ({ ...defaults, ...overrides }) as TConfig\n\nconst composeName = (base: string, scope: string): string => `${base}:${scope}`\n\n/**\n * Build an {@link AppAdapter} factory from a typed definition. See\n * `architecture.md` §21.3.4 for migration guidance — most first-party\n * adapter packages collapse to a single `defineAdapter()` call after this\n * lands.\n *\n * @example\n * ```ts\n * const TenantAdapter = defineAdapter<TenantConfig>({\n *   name: 'TenantAdapter',\n *   defaults: { strategy: 'header', required: true },\n *   build: (config) => ({\n *     middleware: () => [tenantResolverMiddleware(config)],\n *     beforeStart: ({ container }) => registerTenantFactory(container, config),\n *   }),\n * })\n *\n * bootstrap({\n *   adapters: [\n *     TenantAdapter({ strategy: 'subdomain' }),\n *     TenantAdapter.scoped('shard-eu', { headerName: 'x-eu-tenant' }),\n *   ],\n * })\n * ```\n */\nexport function defineAdapter<TConfig = Record<string, unknown>, TExtra = unknown>(\n  options: DefineAdapterOptions<TConfig, TExtra>,\n): AdapterFactory<TConfig, TExtra> {\n  const buildSync = (\n    instanceName: string,\n    scoped: boolean,\n    overrides?: Partial<TConfig>,\n  ): AppAdapter & TExtra => {\n    const config = mergeConfig(options.defaults, overrides)\n    // Mutate `name` on the build result instead of spreading — spread\n    // strips prototype methods when `build()` returns a class instance.\n    // Extension methods declared by the build function (`TExtra`) survive\n    // the mutation since they're own properties on the build result.\n    const built = options.build(config, { name: instanceName, scoped }) as AppAdapter & TExtra\n    ;(built as AppAdapter).name = instanceName\n    return built\n  }\n\n  const buildAsync = (instanceName: string, opts: AdapterAsyncOptions<TConfig>): AppAdapter => {\n    let inner: AppAdapter | undefined\n\n    return {\n      name: instanceName,\n      async beforeStart(ctx: AdapterContext) {\n        const deps = (opts.inject ?? []).map((tok) => ctx.container.resolve(tok as never))\n        const config = await opts.useFactory(...deps)\n        inner = buildSync(instanceName, false, config as Partial<TConfig>)\n        await inner.beforeStart?.(ctx)\n      },\n      async afterStart(ctx: AdapterContext) {\n        await inner?.afterStart?.(ctx)\n      },\n      async shutdown() {\n        await inner?.shutdown?.()\n      },\n      async onHealthCheck() {\n        return (await inner?.onHealthCheck?.()) ?? { name: instanceName, status: 'up' }\n      },\n    }\n  }\n\n  const factory = ((config?: Partial<TConfig>) =>\n    buildSync(options.name, false, config)) as AdapterFactory<TConfig, TExtra>\n\n  factory.scoped = (scopeName: string, config?: Partial<TConfig>) =>\n    buildSync(composeName(options.name, scopeName), true, config)\n\n  factory.async = (opts: AdapterAsyncOptions<TConfig>) => buildAsync(options.name, opts)\n\n  Object.defineProperty(factory, 'definition', { value: Object.freeze({ ...options }) })\n\n  return factory\n}\n","import { resolve } from 'node:path'\nimport { Logger, defineAdapter } from '../../core'\n\nconst log = Logger.for('ViewEngine')\n\nexport interface ViewAdapterOptions {\n  /**\n   * Template engine — pass the engine module or a render function.\n   * Supported engines: ejs, pug, handlebars, nunjucks, or any\n   * Express-compatible engine with a __express property.\n   *\n   * @example\n   * ```ts\n   * import ejs from 'ejs'\n   * ViewAdapter({ engine: ejs, ext: 'ejs' })\n   *\n   * import pug from 'pug'\n   * ViewAdapter({ engine: pug, ext: 'pug' })\n   * ```\n   */\n  engine: any\n\n  /** File extension for templates (e.g., 'ejs', 'pug', 'hbs') */\n  ext: string\n\n  /** Directory containing template files (default: 'src/views') */\n  viewsDir?: string\n\n  /** Default layout template (optional — depends on engine) */\n  layout?: string\n}\n\n/**\n * View/template adapter — pluggable template engine support for KickJS.\n *\n * Registers an Express view engine and sets the views directory.\n * Use `ctx.render()` in controllers to render templates.\n *\n * Migrated to the `defineAdapter()` factory in v4 — call without `new`.\n * The pre-v4 `new ViewAdapter({...})` form is gone; see\n * `docs/guide/migration-v3-to-v4.md` for the rename.\n *\n * @example\n * ```ts\n * import ejs from 'ejs'\n * import { ViewAdapter } from '@forinda/kickjs'\n *\n * bootstrap({\n *   modules,\n *   adapters: [\n *     ViewAdapter({ engine: ejs, ext: 'ejs', viewsDir: 'src/views' }),\n *   ],\n * })\n *\n * // In a controller:\n * @Get('/dashboard')\n * async dashboard(ctx: RequestContext) {\n *   ctx.render('dashboard', { user: currentUser, title: 'Dashboard' })\n * }\n * ```\n */\nexport const ViewAdapter = defineAdapter<ViewAdapterOptions>({\n  name: 'ViewAdapter',\n  build: (options) => ({\n    beforeMount({ app }) {\n      const { engine, ext, viewsDir = 'src/views' } = options\n\n      // Register the engine. Three resolution paths cover every\n      // mainstream template engine + a fall-through for custom ones.\n      if (engine.__express) {\n        // EJS, Pug — have __express method\n        app.engine(ext, engine.__express)\n      } else if (typeof engine.renderFile === 'function') {\n        // Engines with renderFile (nunjucks-style)\n        app.engine(\n          ext,\n          (path: string, opts: any, callback: (err: Error | null, html?: string) => void) => {\n            engine.renderFile(path, opts, callback)\n          },\n        )\n      } else if (typeof engine === 'function') {\n        // Custom render function: (path, options, callback) => void\n        app.engine(ext, engine)\n      } else {\n        log.warn(`Engine for .${ext} does not have __express or renderFile. Trying as-is.`)\n        app.engine(ext, engine)\n      }\n\n      app.set('view engine', ext)\n      app.set('views', resolve(viewsDir))\n\n      log.debug(`View engine: ${ext} (${resolve(viewsDir)})`)\n    },\n  }),\n})\n"],"mappings":";;;;;;;;;;iGAqDA,MAAM,aACJ,SAA6B,CAAC,EAC9B,UAA8B,CAAC,KAClB,CAAE,GAAG,SAAU,GAAG,SAAU,GAErC,aAAe,KAAc,QAA0B,GAAG,KAAK,GAAG,QA2BxE,SAAgB,cACd,QACiC,CACjC,IAAM,WACJ,aACA,OACA,YACwB,CACxB,IAAM,OAAS,YAAY,QAAQ,SAAU,SAAS,EAKhD,MAAQ,QAAQ,MAAM,OAAQ,CAAE,KAAM,aAAc,MAAO,CAAC,EAElE,MADC,OAAsB,KAAO,aACvB,KACT,EAEM,YAAc,aAAsB,OAAmD,CAC3F,IAAI,MAEJ,MAAO,CACL,KAAM,aACN,MAAM,YAAY,IAAqB,CACrC,IAAM,MAAQ,KAAK,QAAU,CAAC,EAAA,CAAG,IAAK,KAAQ,IAAI,UAAU,QAAQ,GAAY,CAAC,EAC3E,OAAS,MAAM,KAAK,WAAW,GAAG,IAAI,EAC5C,MAAQ,UAAU,aAAc,GAAO,MAA0B,EACjE,MAAM,MAAM,cAAc,GAAG,CAC/B,EACA,MAAM,WAAW,IAAqB,CACpC,MAAM,OAAO,aAAa,GAAG,CAC/B,EACA,MAAM,UAAW,CACf,MAAM,OAAO,WAAW,CAC1B,EACA,MAAM,eAAgB,CACpB,OAAQ,MAAM,OAAO,gBAAgB,GAAM,CAAE,KAAM,aAAc,OAAQ,IAAK,CAChF,CACF,CACF,EAEM,SAAY,QAChB,UAAU,QAAQ,KAAM,GAAO,MAAM,GASvC,MAPA,SAAQ,QAAU,UAAmB,SACnC,UAAU,YAAY,QAAQ,KAAM,SAAS,EAAG,GAAM,MAAM,EAE9D,QAAQ,MAAS,MAAuC,WAAW,QAAQ,KAAM,IAAI,EAErF,OAAO,eAAe,QAAS,aAAc,CAAE,MAAO,OAAO,OAAO,CAAE,GAAG,OAAQ,CAAC,CAAE,CAAC,EAE9E,OACT,CCtIA,MAAM,IAAM,OAAO,IAAI,YAAY,EA0DtB,YAAc,cAAkC,CAC3D,KAAM,cACN,MAAQ,UAAa,CACnB,YAAY,CAAE,KAAO,CACnB,GAAM,CAAE,OAAQ,IAAK,SAAW,aAAgB,QAI5C,OAAO,UAET,IAAI,OAAO,IAAK,OAAO,SAAS,EACvB,OAAO,OAAO,YAAe,WAEtC,IAAI,OACF,KACC,KAAc,KAAW,WAAyD,CACjF,OAAO,WAAW,KAAM,KAAM,QAAQ,CACxC,CACF,GACS,OAAO,QAAW,YAI3B,IAAI,KAAK,eAAe,IAAI,sDAAsD,EAFlF,IAAI,OAAO,IAAK,MAAM,GAMxB,IAAI,IAAI,cAAe,GAAG,EAC1B,IAAI,IAAI,QAAS,QAAQ,QAAQ,CAAC,EAElC,IAAI,MAAM,gBAAgB,IAAI,IAAI,QAAQ,QAAQ,EAAE,EAAE,CACxD,CACF,EACF,CAAC"}
+{"version":3,"file":"views-3TYTcdyF.mjs","names":[],"sources":["../src/core/define-adapter.ts","../src/http/middleware/views.ts"],"sourcesContent":["import type { AppAdapter, AdapterContext } from './adapter'\nimport type { BuildContext } from './define-plugin'\n\n/**\n * Options passed to {@link defineAdapter}. Mirrors {@link DefinePluginOptions}\n * exactly — see `architecture.md` §21.3.4 for the definePlugin/defineAdapter\n * symmetry rationale.\n *\n * The optional `TExtra` generic lets an adapter ship public methods\n * beyond the standard {@link AppAdapter} contract — they're preserved\n * on the returned adapter instance so external callers (tests, peer\n * adapters) can invoke them directly. See `OtelAdapter.applyRedaction`\n * for the canonical use case.\n */\nexport interface DefineAdapterOptions<TConfig, TExtra = unknown> {\n  /**\n   * Stable identity used for logging, `dependsOn` lookups, and `.scoped()`\n   * namespacing. Required for adapters that participate in `dependsOn`\n   * sort — error messages reference adapters by name.\n   */\n  name: string\n  version?: string\n  requires?: { kickjs?: string }\n  defaults?: Partial<TConfig>\n  build(config: TConfig, ctx: BuildContext): Omit<AppAdapter, 'name'> & TExtra\n}\n\n/**\n * Async-config form of an adapter. Identical shape to `PluginAsyncOptions`\n * but resolved during `beforeStart` (the earliest async hook in\n * `AppAdapter`) — meaning `middleware()` and `contributors()` from the inner\n * adapter are **not** picked up. Use the bare/`.scoped()` form when you need\n * those.\n */\nexport interface AdapterAsyncOptions<TConfig> {\n  inject?: ReadonlyArray<unknown>\n  useFactory(...deps: any[]): TConfig | Promise<TConfig>\n}\n\n/**\n * Factory returned by {@link defineAdapter}. Same surface as\n * {@link PluginFactory} (call / `.scoped()` / `.async()`) so adopters learn\n * one mental model for both primitives. Returned instances carry both\n * the standard {@link AppAdapter} contract and any `TExtra` extension\n * methods the `build` function exposed.\n */\nexport interface AdapterFactory<TConfig, TExtra = unknown> {\n  (config?: Partial<TConfig>): AppAdapter & TExtra\n  scoped(scopeName: string, config?: Partial<TConfig>): AppAdapter & TExtra\n  async(opts: AdapterAsyncOptions<TConfig>): AppAdapter\n  readonly definition: Readonly<DefineAdapterOptions<TConfig, TExtra>>\n}\n\nconst mergeConfig = <TConfig>(\n  defaults: Partial<TConfig> = {},\n  overrides: Partial<TConfig> = {},\n): TConfig => ({ ...defaults, ...overrides }) as TConfig\n\nconst composeName = (base: string, scope: string): string => `${base}:${scope}`\n\n/**\n * Build an {@link AppAdapter} factory from a typed definition. See\n * `architecture.md` §21.3.4 for migration guidance — most first-party\n * adapter packages collapse to a single `defineAdapter()` call after this\n * lands.\n *\n * @example\n * ```ts\n * const TenantAdapter = defineAdapter<TenantConfig>({\n *   name: 'TenantAdapter',\n *   defaults: { strategy: 'header', required: true },\n *   build: (config) => ({\n *     middleware: () => [tenantResolverMiddleware(config)],\n *     beforeStart: ({ container }) => registerTenantFactory(container, config),\n *   }),\n * })\n *\n * bootstrap({\n *   adapters: [\n *     TenantAdapter({ strategy: 'subdomain' }),\n *     TenantAdapter.scoped('shard-eu', { headerName: 'x-eu-tenant' }),\n *   ],\n * })\n * ```\n */\nexport function defineAdapter<TConfig = Record<string, unknown>, TExtra = unknown>(\n  options: DefineAdapterOptions<TConfig, TExtra>,\n): AdapterFactory<TConfig, TExtra> {\n  const buildSync = (\n    instanceName: string,\n    scoped: boolean,\n    overrides?: Partial<TConfig>,\n  ): AppAdapter & TExtra => {\n    const config = mergeConfig(options.defaults, overrides)\n    // Mutate `name` on the build result instead of spreading — spread\n    // strips prototype methods when `build()` returns a class instance.\n    // Extension methods declared by the build function (`TExtra`) survive\n    // the mutation since they're own properties on the build result.\n    const built = options.build(config, { name: instanceName, scoped }) as AppAdapter & TExtra\n    ;(built as AppAdapter).name = instanceName\n    return built\n  }\n\n  const buildAsync = (instanceName: string, opts: AdapterAsyncOptions<TConfig>): AppAdapter => {\n    let inner: AppAdapter | undefined\n\n    return {\n      name: instanceName,\n      async beforeStart(ctx: AdapterContext) {\n        const deps = (opts.inject ?? []).map((tok) => ctx.container.resolve(tok as never))\n        const config = await opts.useFactory(...deps)\n        inner = buildSync(instanceName, false, config as Partial<TConfig>)\n        await inner.beforeStart?.(ctx)\n      },\n      async afterStart(ctx: AdapterContext) {\n        await inner?.afterStart?.(ctx)\n      },\n      async shutdown() {\n        await inner?.shutdown?.()\n      },\n      async onHealthCheck() {\n        return (await inner?.onHealthCheck?.()) ?? { name: instanceName, status: 'up' }\n      },\n    }\n  }\n\n  const factory = ((config?: Partial<TConfig>) =>\n    buildSync(options.name, false, config)) as AdapterFactory<TConfig, TExtra>\n\n  factory.scoped = (scopeName: string, config?: Partial<TConfig>) =>\n    buildSync(composeName(options.name, scopeName), true, config)\n\n  factory.async = (opts: AdapterAsyncOptions<TConfig>) => buildAsync(options.name, opts)\n\n  Object.defineProperty(factory, 'definition', { value: Object.freeze({ ...options }) })\n\n  return factory\n}\n","import { resolve } from 'node:path'\nimport { Logger, defineAdapter } from '../../core'\n\nconst log = Logger.for('ViewEngine')\n\nexport interface ViewAdapterOptions {\n  /**\n   * Template engine — pass the engine module or a render function.\n   * Supported engines: ejs, pug, handlebars, nunjucks, or any\n   * Express-compatible engine with a __express property.\n   *\n   * @example\n   * ```ts\n   * import ejs from 'ejs'\n   * ViewAdapter({ engine: ejs, ext: 'ejs' })\n   *\n   * import pug from 'pug'\n   * ViewAdapter({ engine: pug, ext: 'pug' })\n   * ```\n   */\n  engine: any\n\n  /** File extension for templates (e.g., 'ejs', 'pug', 'hbs') */\n  ext: string\n\n  /** Directory containing template files (default: 'src/views') */\n  viewsDir?: string\n\n  /** Default layout template (optional — depends on engine) */\n  layout?: string\n}\n\n/**\n * View/template adapter — pluggable template engine support for KickJS.\n *\n * Registers an Express view engine and sets the views directory.\n * Use `ctx.render()` in controllers to render templates.\n *\n * Migrated to the `defineAdapter()` factory in v4 — call without `new`.\n * The pre-v4 `new ViewAdapter({...})` form is gone; see\n * `docs/guide/migration-v3-to-v4.md` for the rename.\n *\n * @example\n * ```ts\n * import ejs from 'ejs'\n * import { ViewAdapter } from '@forinda/kickjs'\n *\n * bootstrap({\n *   modules,\n *   adapters: [\n *     ViewAdapter({ engine: ejs, ext: 'ejs', viewsDir: 'src/views' }),\n *   ],\n * })\n *\n * // In a controller:\n * @Get('/dashboard')\n * async dashboard(ctx: RequestContext) {\n *   ctx.render('dashboard', { user: currentUser, title: 'Dashboard' })\n * }\n * ```\n */\nexport const ViewAdapter = defineAdapter<ViewAdapterOptions>({\n  name: 'ViewAdapter',\n  build: (options) => ({\n    beforeMount({ app }) {\n      const { engine, ext, viewsDir = 'src/views' } = options\n\n      // Register the engine. Three resolution paths cover every\n      // mainstream template engine + a fall-through for custom ones.\n      if (engine.__express) {\n        // EJS, Pug — have __express method\n        app.engine(ext, engine.__express)\n      } else if (typeof engine.renderFile === 'function') {\n        // Engines with renderFile (nunjucks-style)\n        app.engine(\n          ext,\n          (path: string, opts: any, callback: (err: Error | null, html?: string) => void) => {\n            engine.renderFile(path, opts, callback)\n          },\n        )\n      } else if (typeof engine === 'function') {\n        // Custom render function: (path, options, callback) => void\n        app.engine(ext, engine)\n      } else {\n        log.warn(`Engine for .${ext} does not have __express or renderFile. Trying as-is.`)\n        app.engine(ext, engine)\n      }\n\n      app.set('view engine', ext)\n      app.set('views', resolve(viewsDir))\n\n      log.debug(`View engine: ${ext} (${resolve(viewsDir)})`)\n    },\n  }),\n})\n"],"mappings":";;;;;;;;;;iGAqDA,MAAM,aACJ,SAA6B,CAAC,EAC9B,UAA8B,CAAC,KAClB,CAAE,GAAG,SAAU,GAAG,SAAU,GAErC,aAAe,KAAc,QAA0B,GAAG,KAAK,GAAG,QA2BxE,SAAgB,cACd,QACiC,CACjC,IAAM,WACJ,aACA,OACA,YACwB,CACxB,IAAM,OAAS,YAAY,QAAQ,SAAU,SAAS,EAKhD,MAAQ,QAAQ,MAAM,OAAQ,CAAE,KAAM,aAAc,MAAO,CAAC,EAElE,MADC,OAAsB,KAAO,aACvB,KACT,EAEM,YAAc,aAAsB,OAAmD,CAC3F,IAAI,MAEJ,MAAO,CACL,KAAM,aACN,MAAM,YAAY,IAAqB,CACrC,IAAM,MAAQ,KAAK,QAAU,CAAC,EAAA,CAAG,IAAK,KAAQ,IAAI,UAAU,QAAQ,GAAY,CAAC,EAC3E,OAAS,MAAM,KAAK,WAAW,GAAG,IAAI,EAC5C,MAAQ,UAAU,aAAc,GAAO,MAA0B,EACjE,MAAM,MAAM,cAAc,GAAG,CAC/B,EACA,MAAM,WAAW,IAAqB,CACpC,MAAM,OAAO,aAAa,GAAG,CAC/B,EACA,MAAM,UAAW,CACf,MAAM,OAAO,WAAW,CAC1B,EACA,MAAM,eAAgB,CACpB,OAAQ,MAAM,OAAO,gBAAgB,GAAM,CAAE,KAAM,aAAc,OAAQ,IAAK,CAChF,CACF,CACF,EAEM,SAAY,QAChB,UAAU,QAAQ,KAAM,GAAO,MAAM,GASvC,MAPA,SAAQ,QAAU,UAAmB,SACnC,UAAU,YAAY,QAAQ,KAAM,SAAS,EAAG,GAAM,MAAM,EAE9D,QAAQ,MAAS,MAAuC,WAAW,QAAQ,KAAM,IAAI,EAErF,OAAO,eAAe,QAAS,aAAc,CAAE,MAAO,OAAO,OAAO,CAAE,GAAG,OAAQ,CAAC,CAAE,CAAC,EAE9E,OACT,CCtIA,MAAM,IAAM,OAAO,IAAI,YAAY,EA0DtB,YAAc,cAAkC,CAC3D,KAAM,cACN,MAAQ,UAAa,CACnB,YAAY,CAAE,KAAO,CACnB,GAAM,CAAE,OAAQ,IAAK,SAAW,aAAgB,QAI5C,OAAO,UAET,IAAI,OAAO,IAAK,OAAO,SAAS,EACvB,OAAO,OAAO,YAAe,WAEtC,IAAI,OACF,KACC,KAAc,KAAW,WAAyD,CACjF,OAAO,WAAW,KAAM,KAAM,QAAQ,CACxC,CACF,GACS,OAAO,QAAW,YAI3B,IAAI,KAAK,eAAe,IAAI,sDAAsD,EAFlF,IAAI,OAAO,IAAK,MAAM,GAMxB,IAAI,IAAI,cAAe,GAAG,EAC1B,IAAI,IAAI,QAAS,QAAQ,QAAQ,CAAC,EAElC,IAAI,MAAM,gBAAgB,IAAI,IAAI,QAAQ,QAAQ,EAAE,EAAE,CACxD,CACF,EACF,CAAC"}

package/dist/{views-DsfBT1fR.d.mts → views-BBY9_PUV.d.mts}

@@ -1,9 +1,9 @@
 
 import "./index-M6TF75MS.mjs";
-import { f as DepValue, o as ContextDecorator, s as ContextDecoratorSpec, v as MetaValue } from "./app-module-DtoySG6l.mjs";
-import { T as RequestContext, f as HttpRuntime, k as AdapterFactory, m as RouteEntry } from "./adapter-CbMq-NBf.mjs";
-import "./application-zlzYGgKD.mjs";
-import "./bootstrap-Nzgi7K2d.mjs";
+import { S as MetaValue, b as ContextMetaKey, l as ContextDecoratorSpec, m as DepValue, s as ContextDecorator } from "./app-module-DtNJpj0r.mjs";
+import { T as RequestContext, f as HttpRuntime, k as AdapterFactory, m as RouteEntry } from "./adapter-diFqgxGR.mjs";
+import "./application-D_mReBi_.mjs";
+import "./bootstrap-CytCvAnr.mjs";
 import "./cors-BuDU9CpA.mjs";
 import "./csrf-vR23CJas.mjs";
 import "./error-handler-Cr6Yt9as.mjs";
@@ -12,11 +12,11 @@ import "./rate-limit-Dme747JJ.mjs";
 import "./request-id-CVzJ1uHD.mjs";
 import "./request-logger-BU4ulKLp.mjs";
 import "./session-z9iewOXA.mjs";
-import "./spa-DsRUrm69.mjs";
-import "./upload-XVTyQcNN.mjs";
+import "./spa-CCi-hC2M.mjs";
+import "./upload-Wck12jE5.mjs";
 import "./validate-DMYpUnrf.mjs";
-import "./kv-stores-CHowq8VP.mjs";
-import { t as BuildRoutesOptions } from "./router-builder-CMGhEBU2.mjs";
+import "./kv-stores-D2kSUAEP.mjs";
+import { t as BuildRoutesOptions } from "./router-builder-C6E11Grf.mjs";
 import { Express, NextFunction, Request, Response, Router } from "express";
 import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/core/disposables.d.ts
@@ -412,7 +412,7 @@ declare function isClusterPrimary(): boolean;
  * from the spec, and `Ctx` is locked to `RequestContext`.
  */
 interface DefineHttpContextDecoratorWithParams<P extends Record<string, unknown>> {
-  <K extends string, D extends Record<string, DepValue> = Record<string, never>>(spec: ContextDecoratorSpec<K, D, P, RequestContext>): ContextDecorator<K, D, P, RequestContext>;
+  <K extends ContextMetaKey, D extends Record<string, DepValue> = Record<string, never>>(spec: ContextDecoratorSpec<K, D, P, RequestContext>): ContextDecorator<K, D, P, RequestContext>;
 }
 /**
  * Public shape of {@link defineHttpContextDecorator} — the positional
@@ -420,7 +420,7 @@ interface DefineHttpContextDecoratorWithParams<P extends Record<string, unknown>
  * partial-inference for the parameterised case.
  */
 interface DefineHttpContextDecoratorFn {
-  <K extends string, D extends Record<string, DepValue> = Record<string, never>, P extends Record<string, unknown> = Record<string, never>>(spec: ContextDecoratorSpec<K, D, P, RequestContext>): ContextDecorator<K, D, P, RequestContext>;
+  <K extends ContextMetaKey, D extends Record<string, DepValue> = Record<string, never>, P extends Record<string, unknown> = Record<string, never>>(spec: ContextDecoratorSpec<K, D, P, RequestContext>): ContextDecorator<K, D, P, RequestContext>;
   /**
    * Curried entry point. Spell only `P`; `K` and `D` infer from the
    * spec. `Ctx` is locked to `RequestContext`.
@@ -533,7 +533,7 @@ declare function getRequestStore(): RequestStore;
  * }
  * ```
  */
-declare function getRequestValue<K extends string>(key: K): MetaValue<K> | undefined;
+declare function getRequestValue<K extends ContextMetaKey>(key: K): MetaValue<K> | undefined;
 //#endregion
 //#region src/http/middleware/request-scope.d.ts
 /**
@@ -656,4 +656,4 @@ interface ViewAdapterOptions {
 declare const ViewAdapter: AdapterFactory<ViewAdapterOptions, unknown>;
 //#endregion
 export { mountSort as A, FormatKickErrorOptions as B, groupAssetKeys as C, MountCycleError as D, MissingMountDepError as E, CircuitBreaker as F, disposeAll as G, KickErrorInit as H, CircuitBreakerOptions as I, registerDisposable as K, CircuitBreakerState as L, DuplicateContributorError as M, MissingContextValueError as N, MountKind as O, MissingContributorError as P, CircuitBreakerStats as R, GroupAssetKeysResult as S, DuplicateMountNameError as T, formatKickError as U, KickError as V, Disposable as W, ClusterOptions as _, TraceContextOptions as a, AssetKeyStrategy as b, requestScopeMiddleware as c, getRequestValue as d, requestStore as f, defineHttpContextDecorator as g, materializeRouter as h, TraceContext as i, ContributorCycleError as j, MountSortItem as k, RequestStore as l, expressRuntime as m, ViewAdapterOptions as n, parseTraceparent as o, buildRoutes as p, TRACEPARENT_HEADER as r, traceContext as s, ViewAdapter as t, getRequestStore as u, isClusterPrimary as v, stripExt as w, GroupAssetKeysOptions as x, AssetKeyPair as y, CircuitOpenError as z };
-//# sourceMappingURL=views-DsfBT1fR.d.mts.map
+//# sourceMappingURL=views-BBY9_PUV.d.mts.map

package/dist/{views-DsfBT1fR.d.mts.map → views-BBY9_PUV.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"views-DsfBT1fR.d.mts","names":[],"sources":["../src/core/disposables.ts","../src/core/kick-error.ts","../src/core/circuit-breaker.ts","../src/core/context-errors.ts","../src/core/mount-sort.ts","../src/core/asset-keys.ts","../src/http/cluster.ts","../src/http/define-http-context-decorator.ts","../src/http/runtimes/express.ts","../src/http/request-store.ts","../src/http/middleware/request-scope.ts","../src/http/middleware/trace-context.ts","../src/http/middleware/views.ts"],"mappings":"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"}
+{"version":3,"file":"views-BBY9_PUV.d.mts","names":[],"sources":["../src/core/disposables.ts","../src/core/kick-error.ts","../src/core/circuit-breaker.ts","../src/core/context-errors.ts","../src/core/mount-sort.ts","../src/core/asset-keys.ts","../src/http/cluster.ts","../src/http/define-http-context-decorator.ts","../src/http/runtimes/express.ts","../src/http/request-store.ts","../src/http/middleware/request-scope.ts","../src/http/middleware/trace-context.ts","../src/http/middleware/views.ts"],"mappings":"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"}

package/dist/web.d.mts

@@ -1,8 +1,8 @@
 
 import { x as MiddlewareHandler } from "./decorators-Bks7cgBJ.mjs";
-import { d as ContributorRegistrations, r as AppModuleEntry } from "./app-module-DtoySG6l.mjs";
-import { D as SseHandler, b as RuntimeResponse, m as RouteEntry } from "./adapter-CbMq-NBf.mjs";
-import { a as KvSessionStoreOptions, c as InferHandlerResponse, d as isReply, f as reply, i as KvSessionStore, l as Reply, n as KvRateLimitStore, o as RateLimitGuardOptions, r as KvRateLimitStoreOptions, s as rateLimitGuard, t as KvLike } from "./kv-stores-CHowq8VP.mjs";
+import { p as ContributorRegistrations, r as AppModuleEntry } from "./app-module-DtNJpj0r.mjs";
+import { D as SseHandler, b as RuntimeResponse, m as RouteEntry } from "./adapter-diFqgxGR.mjs";
+import { a as KvSessionStoreOptions, c as InferHandlerResponse, d as isReply, f as reply, i as KvSessionStore, l as Reply, n as KvRateLimitStore, o as RateLimitGuardOptions, r as KvRateLimitStoreOptions, s as rateLimitGuard, t as KvLike } from "./kv-stores-D2kSUAEP.mjs";
 //#region src/http/web/driver.d.ts
 /**
  * Presents a web `Request` as the express-shaped `req` object that

package/dist/web.mjs

@@ -1,5 +1,5 @@
 /**
- * @forinda/kickjs v6.6.1
+ * @forinda/kickjs v6.7.0
  *
  * Copyright (c) Felix Orinda
  *
@@ -8,5 +8,5 @@
  *
  * @license MIT
  */
-import{t as Container}from"./container-CSxotdD4.mjs";import{t as MutableModuleRegistry}from"./module-registry-DDdtsQld.mjs";import{normalizePath}from"./core/path.mjs";import{n as assertRouteUnique,r as buildRouteTable,t as _setExternalContributorSources}from"./router-builder-C6Qmb3rB.mjs";import{i as requestStore}from"./context-A-vHOCow.mjs";import{n as isReply,r as reply}from"./reply-Dcq46cVC.mjs";import{n as KvSessionStore,r as rateLimitGuard,t as KvRateLimitStore}from"./kv-stores-CcD6HvGV.mjs";import{n as WebRequestShim,r as WebResponseDriver,t as compileWebRoute}from"./handler-BTz5BPXI.mjs";function createWebApp(options){let h3mod=options.h3;if(typeof h3mod?.H3!=`function`)throw Error(`@forinda/kickjs/web: pass the h3 v2 module — \`createWebApp({ h3: await import("h3"), ... })\`. The installed h3 must be v2 (npm dist-tag 'latest'); v1 has no H3 class.`);let container=Container.getInstance();if(options.env){let env=options.env;Container._envResolver=key=>env[key]}Container._requestStoreProvider=()=>requestStore.getStore()??null;let registry=new MutableModuleRegistry;for(let m of options.modules)registry.mount(m);let modules=registry.entries.map(entry=>{let mod=typeof entry==`function`?new entry:entry;return mod.register?.(container),mod});container.bootstrap();let app=new h3mod.H3,apiPrefix=options.apiPrefix??`/api`,defaultVersion=options.defaultVersion??1,globalMiddleware=options.middleware??[],globalSources=(options.contributors??[]).map(registration=>({source:`global`,registration,label:`createWebApp`})),seenRoutes=new Map;for(let mod of modules){let declaredName=mod.name,moduleLabel=typeof declaredName==`string`&&declaredName.length>0?declaredName:mod.constructor?.name??`module`;_setExternalContributorSources([...(mod.contributors?.()??[]).map(registration=>({source:`module`,registration,label:moduleLabel})),...globalSources]);try{let result=mod.routes();if(!result)continue;let routeSets=Array.isArray(result)?result:[result];for(let route of routeSets){if(!route.controller)throw Error(`@forinda/kickjs/web: module route at '${route.path}' has no controller. Express-style \`router\` mounts are not supported on the web entry.`);let mountPath=`${apiPrefix}/v${route.version??defaultVersion}${normalizePath(route.path)}`;for(let entry of buildRouteTable(route.controller)){let url=joinPath(mountPath,entry.path),owner=`${route.controller.name??`controller`}.${String(entry.meta.handlerName??`?`)}`;assertRouteUnique(seenRoutes,entry.method,url,owner),globalMiddleware.length>0&&(entry.middlewares=[...globalMiddleware,...entry.middlewares]);let run=compileWebRoute(entry);app.on(entry.method,url,event=>run({request:event.req,url:event.url,params:event.context.params??{}}))}}}finally{_setExternalContributorSources([])}}return{fetch:request=>app.fetch(request),h3:app}}function createFetchHandler(build){let app;return{fetch:(request,env={})=>(app??=createWebApp(build(env)),app.fetch(request))}}function joinPath(mountPath,path){let a=mountPath.endsWith(`/`)?mountPath.slice(0,-1):mountPath;return path===`/`||path===``?a===``?`/`:a:`${a}${path.startsWith(`/`)?path:`/${path}`}`}export{KvRateLimitStore,KvSessionStore,WebRequestShim,WebResponseDriver,compileWebRoute,createFetchHandler,createWebApp,isReply,rateLimitGuard,reply};
+import{t as Container}from"./container-CFVAdwXa.mjs";import{t as MutableModuleRegistry}from"./module-registry-cbndPnlY.mjs";import{normalizePath}from"./core/path.mjs";import{n as assertRouteUnique,r as buildRouteTable,t as _setExternalContributorSources}from"./router-builder-DtonR20n.mjs";import{i as requestStore}from"./context-CAN3t2jg.mjs";import{n as isReply,r as reply}from"./reply-Y50qUtDy.mjs";import{n as KvSessionStore,r as rateLimitGuard,t as KvRateLimitStore}from"./kv-stores-VfJbg9Gs.mjs";import{n as WebRequestShim,r as WebResponseDriver,t as compileWebRoute}from"./handler-DcxBY95X.mjs";function createWebApp(options){let h3mod=options.h3;if(typeof h3mod?.H3!=`function`)throw Error(`@forinda/kickjs/web: pass the h3 v2 module — \`createWebApp({ h3: await import("h3"), ... })\`. The installed h3 must be v2 (npm dist-tag 'latest'); v1 has no H3 class.`);let container=Container.getInstance();if(options.env){let env=options.env;Container._envResolver=key=>env[key]}Container._requestStoreProvider=()=>requestStore.getStore()??null;let registry=new MutableModuleRegistry;for(let m of options.modules)registry.mount(m);let modules=registry.entries.map(entry=>{let mod=typeof entry==`function`?new entry:entry;return mod.register?.(container),mod});container.bootstrap();let app=new h3mod.H3,apiPrefix=options.apiPrefix??`/api`,defaultVersion=options.defaultVersion??1,globalMiddleware=options.middleware??[],globalSources=(options.contributors??[]).map(registration=>({source:`global`,registration,label:`createWebApp`})),seenRoutes=new Map;for(let mod of modules){let declaredName=mod.name,moduleLabel=typeof declaredName==`string`&&declaredName.length>0?declaredName:mod.constructor?.name??`module`;_setExternalContributorSources([...(mod.contributors?.()??[]).map(registration=>({source:`module`,registration,label:moduleLabel})),...globalSources]);try{let result=mod.routes();if(!result)continue;let routeSets=Array.isArray(result)?result:[result];for(let route of routeSets){if(!route.controller)throw Error(`@forinda/kickjs/web: module route at '${route.path}' has no controller. Express-style \`router\` mounts are not supported on the web entry.`);let mountPath=`${apiPrefix}/v${route.version??defaultVersion}${normalizePath(route.path)}`;for(let entry of buildRouteTable(route.controller)){let url=joinPath(mountPath,entry.path),owner=`${route.controller.name??`controller`}.${String(entry.meta.handlerName??`?`)}`;assertRouteUnique(seenRoutes,entry.method,url,owner),globalMiddleware.length>0&&(entry.middlewares=[...globalMiddleware,...entry.middlewares]);let run=compileWebRoute(entry);app.on(entry.method,url,event=>run({request:event.req,url:event.url,params:event.context.params??{}}))}}}finally{_setExternalContributorSources([])}}return{fetch:request=>app.fetch(request),h3:app}}function createFetchHandler(build){let app;return{fetch:(request,env={})=>(app??=createWebApp(build(env)),app.fetch(request))}}function joinPath(mountPath,path){let a=mountPath.endsWith(`/`)?mountPath.slice(0,-1):mountPath;return path===`/`||path===``?a===``?`/`:a:`${a}${path.startsWith(`/`)?path:`/${path}`}`}export{KvRateLimitStore,KvSessionStore,WebRequestShim,WebResponseDriver,compileWebRoute,createFetchHandler,createWebApp,isReply,rateLimitGuard,reply};
 //# sourceMappingURL=web.mjs.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forinda/kickjs",
-  "version": "6.6.1",
+  "version": "6.7.0",
   "description": "A production-grade, decorator-driven Node.js framework for TypeScript — runs on Express, Fastify, or h3 (swap the engine in one line).",
   "keywords": [
     "kickjs",
@@ -190,7 +190,7 @@
     "build": "tsdown",
     "dev": "tsdown --watch",
     "test": "vitest run --passWithNoTests",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.typetests.json",
     "clean": "rm -rf dist .wireit"
   }
 }

package/dist/app-module-DtoySG6l.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"app-module-DtoySG6l.d.mts","names":[],"sources":["../src/core/execution-context.ts","../src/core/context-decorator.ts","../src/core/app-module.ts"],"mappings":"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"}

package/dist/bootstrap-Nzgi7K2d.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bootstrap-Nzgi7K2d.d.mts","names":[],"sources":["../src/http/bootstrap.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;iBAqCsB,UAAU,SAAS,qBAAqB,QAAQ"}

package/dist/context-A-vHOCow.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"context-A-vHOCow.mjs","names":[],"sources":["../src/http/request-store.ts","../src/http/context.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks'\nimport type { MetaValue } from '../core/execution-context'\n\n/** Per-request storage for REQUEST-scoped DI and request context propagation */\nexport interface RequestStore {\n  /** Unique request identifier */\n  requestId: string\n  /**\n   * Per-request singleton cache for REQUEST-scoped services. Keys are\n   * heterogeneous (class constructors, `InjectionToken` objects, raw\n   * strings), so the map type stays `Map<any, any>`.\n   */\n  instances: Map<any, any>\n  /**\n   * Per-request key/value bag. Canonical backing store for\n   * `RequestContext.set/get` and the Context Contributor pipeline (#107)\n   * since Phase 3. Anything written here is visible to every concrete\n   * execution context constructed for the same request, regardless of\n   * which middleware/contributor wrote it.\n   *\n   * Keys are constrained to `string` per the locked decision in\n   * `architecture.md` §20.12 (#4); the value type is `unknown` because\n   * the concrete shape at each key is determined by the consumer's\n   * `ContextMeta` augmentation, not by the store itself.\n   *\n   * Prefer the {@link getRequestValue} helper over reaching into this\n   * map directly — it threads the augmented `ContextMeta` shape through\n   * `MetaValue<K>` so consumers get typed reads without an `as` cast.\n   * Writes should flow through `ctx.set(key, value)` or a Context\n   * Contributor's return value — see the `setRequestValue` note below\n   * for why this package intentionally does NOT ship a service-level\n   * write helper.\n   */\n  values: Map<string, unknown>\n  /** Set once {@link disposeRequestStore} has run — guards double-dispose. */\n  disposed?: boolean\n}\n\n/** AsyncLocalStorage instance shared across the framework */\nexport const requestStore = new AsyncLocalStorage<RequestStore>()\n\n/**\n * Get the current request store. Throws if called outside a request context.\n * Used by the Container to resolve REQUEST-scoped dependencies.\n */\nexport function getRequestStore(): RequestStore {\n  const store = requestStore.getStore()\n  if (!store) {\n    throw new Error(\n      'No active request context. REQUEST-scoped services can only be resolved during an HTTP request.',\n    )\n  }\n  return store\n}\n\n/**\n * Read a per-request `ContextMeta`-keyed value from outside a controller\n * (services, repositories, anywhere with no `ctx` reference). Returns\n * the augmented type for the key — `MetaValue<K>` — so consumers get the\n * same static safety as `ctx.get(key)` without holding the context.\n *\n * Returns `undefined` outside an active request frame (background jobs,\n * startup code, tests without `requestScopeMiddleware()`) — the helper\n * is intentionally null-tolerant so calling it from a service that\n * runs in both request and non-request paths doesn't throw.\n *\n * @example\n * ```ts\n * declare module '@forinda/kickjs' {\n *   interface ContextMeta { tenant: { id: string; name: string } }\n * }\n *\n * @Service()\n * class AuditService {\n *   log(action: string) {\n *     const tenant = getRequestValue('tenant')  // typed: { id; name } | undefined\n *     db.audit.insert({ action, tenantId: tenant?.id })\n *   }\n * }\n * ```\n */\nexport function getRequestValue<K extends string>(key: K): MetaValue<K> | undefined {\n  return requestStore.getStore()?.values.get(key) as MetaValue<K> | undefined\n}\n\n// Intentionally NO `setRequestValue` export.\n//\n// Writes are deliberately context-scoped — only the controlled write\n// surfaces should mutate the per-request Map:\n//\n//   1. A Context Contributor's `resolve()` / `onError()` return value\n//      (the runner does `ctx.set(reg.key, value)` on the contributor's\n//      behalf). This is the canonical way to populate a key.\n//   2. A controller / middleware / contributor that holds a\n//      `RequestContext` instance can call `ctx.set(key, value)`\n//      directly. The write is auditable inline at the call site.\n//\n// Letting arbitrary services reach in and mutate the store from\n// anywhere produces \"spooky action at a distance\" — keys appear in\n// the request bag without an obvious source, and tracing which\n// service polluted what becomes a grep exercise. Services that need\n// to publish per-request state should return the value to the caller\n// (controller or contributor) and let *that* layer write it via\n// `ctx.set`. If a future need genuinely requires a service-level\n// write surface, expose a narrow function (`recordTrace`,\n// `markStartTime`) on a service that captures the side effect, not a\n// generic `setRequestValue`.\n","/// <reference types=\"multer\" />\nimport type { Request, NextFunction } from 'express'\nimport type { ActiveRuntime, RuntimeResponse } from './runtime'\nimport { type ExecutionContext, type MetaValue } from '../core/execution-context'\nimport { normalizeProblem, type ProblemDetails, type ValidationError } from '../core/errors'\nimport { MissingContextValueError } from '../core/context-errors'\nimport { requestStore } from './request-store'\nimport {\n  parseQuery,\n  type ParseQueryOptions,\n  type QueryFieldConfig,\n  type PaginatedResponse,\n  type TypedParsedQuery,\n} from './query'\n\n/**\n * Input shape for the typed problem-detail convenience methods on\n * {@link ProblemSender} (`ctx.problem.notFound`, `.badRequest`, etc.) —\n * RFC 9457 details minus the `status`, which each method pre-fills.\n */\ntype ProblemInput = Omit<ProblemDetails, 'status'>\n\n/**\n * Callable response helper for RFC 9457 — Problem Details responses.\n * Returned by `ctx.problem`. Invoke directly for a fully-specified\n * payload, or use the named convenience methods to pre-fill `status` +\n * `title` for the common codes.\n *\n * Each call sets `Content-Type: application/problem+json` and serializes\n * the canonical shape (defaulting `type` to `about:blank` and `title` to\n * the IANA reason phrase per RFC 9457 §3.1.1 / §3.1.4).\n *\n * @example\n * ```ts\n * ctx.problem({\n *   type: 'https://api.example.com/problems/out-of-credit',\n *   status: 403,\n *   detail: 'Your balance is 30, but that costs 50.',\n *   balance: 30,                // extension per §3.2\n * })\n *\n * ctx.problem.notFound({ detail: 'User abc not found' })\n * ctx.problem.validation(zodResult.error.issues)\n * ```\n */\ninterface ProblemSender {\n  (input: ProblemDetails): RuntimeResponse\n  /** 400 Bad Request — RFC 9457. */\n  badRequest(input?: ProblemInput): RuntimeResponse\n  /** 401 Unauthorized — RFC 9457. */\n  unauthorized(input?: ProblemInput): RuntimeResponse\n  /** 403 Forbidden — RFC 9457. */\n  forbidden(input?: ProblemInput): RuntimeResponse\n  /** 404 Not Found — RFC 9457. */\n  notFound(input?: ProblemInput): RuntimeResponse\n  /** 409 Conflict — RFC 9457. */\n  conflict(input?: ProblemInput): RuntimeResponse\n  /** 422 Unprocessable Entity — RFC 9457. */\n  unprocessable(input?: ProblemInput): RuntimeResponse\n  /** 429 Too Many Requests — RFC 9457. */\n  tooManyRequests(input?: ProblemInput): RuntimeResponse\n  /** 500 Internal Server Error — RFC 9457. */\n  internal(input?: ProblemInput): RuntimeResponse\n  /**\n   * 422 with Zod issues serialized into the `errors` extension per\n   * RFC 9457 §3.2's array convention. Pass `error.issues` from a Zod\n   * `safeParse` failure or `error.issues` from a thrown ZodError.\n   */\n  validation(issues: any[], input?: ProblemInput): RuntimeResponse\n}\n\n/**\n * Recursively marks every property of `T` as `readonly`. Preserves\n * `Function`, `Date`, and `RegExp` unchanged, and converts `Map` / `Set`\n * to `ReadonlyMap` / `ReadonlySet` so their mutating methods (`set`,\n * `delete`, `add`, `clear`) are removed from the public surface.\n * Tuples keep their positional element types — only their per-element\n * mutability is locked.\n *\n * Exposed as a utility for adopters who want to opt into compile-time\n * sealing of their own shapes. **No longer applied to\n * `RequestContext.{body,params,query,headers,file,files}`** — that\n * broke TS narrowing / discriminated-union drilldowns on typed request\n * payloads. Runtime read-only enforcement now lives in\n * {@link makeReadOnlyProxy} (dev-only Proxy that warns on writes,\n * no-op in production).\n *\n * Type-only. No runtime cost. `DeepReadonly<any>` is `any` (TS\n * distributes conditional types over `any`).\n */\nexport type DeepReadonly<T> = T extends (...args: never[]) => unknown\n  ? T\n  : T extends Date | RegExp\n    ? T\n    : T extends Map<infer K, infer V>\n      ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>\n      : T extends Set<infer V>\n        ? ReadonlySet<DeepReadonly<V>>\n        : T extends readonly (infer U)[]\n          ? // Distinguish a regular array from a tuple. A regular `T[]` widens\n            // its `length` to `number`; a tuple's `length` is a literal\n            // (e.g. `2`). The literal branch maps over `keyof T` so each\n            // positional slot keeps its own type — `DeepReadonly<[1, 2]>` →\n            // `readonly [1, 2]`, not `readonly (1 | 2)[]`.\n            number extends T['length']\n            ? ReadonlyArray<DeepReadonly<U>>\n            : { readonly [K in keyof T]: DeepReadonly<T[K]> }\n          : T extends object\n            ? { readonly [K in keyof T]: DeepReadonly<T[K]> }\n            : T\n\n/**\n * Re-export the augmentable {@link ContextMeta} registry from core/.\n * Declared in `core/execution-context.ts` so non-HTTP transports\n * (WS/queue/cron, V2) share one declaration site. Apps still augment\n * via the canonical `declare module '@forinda/kickjs'` form.\n */\nexport type { ContextMeta } from '../core/execution-context'\n\n/**\n * Symbol key under which the per-request `AbortController` backing\n * `RequestContext.signal` is cached on the Express `req` object.\n * Shared across every `RequestContext` instance built for the same\n * request (router-builder constructs separate wrappers for\n * middleware, the contributor pipeline, and the main handler — they\n * all need the same signal).\n */\nconst signalControllerKey = Symbol.for('kickjs.requestContext.signalController')\n\n/**\n * Symbol key under which per-target read-only Proxy wrappers are\n * cached on the Express `req` object. Used by {@link makeReadOnlyProxy}\n * so repeat access of `ctx.body` / `ctx.params` / etc. returns the same\n * Proxy instance (cheap, and stable under `===` for adopters comparing\n * values across middleware).\n */\nconst readOnlyProxyCacheKey = Symbol.for('kickjs.requestContext.readOnlyProxyCache')\n\n/**\n * `true` iff `v` is a plain object (`{}` / `Object.create(null)`) or an\n * array — the two shapes JSON.parse / Express body-parser produce and\n * the only ones the read-only Proxy recurses into. Class instances,\n * `Date`, `RegExp`, `Map`, `Set`, `Buffer`, streams, and functions\n * pass through unwrapped so their method dispatch and `instanceof`\n * checks keep working.\n */\nfunction isPlainObjectOrArray(v: unknown): v is object {\n  if (v === null || typeof v !== 'object') return false\n  if (Array.isArray(v)) return true\n  const proto = Object.getPrototypeOf(v)\n  return proto === Object.prototype || proto === null\n}\n\n/**\n * In dev, wrap `target` in a `Proxy` whose `set` / `deleteProperty` /\n * `defineProperty` traps log a warning and otherwise leave the\n * underlying object untouched. A `get` trap recursively wraps nested\n * plain objects and arrays on access, so deep mutations\n * (`ctx.body.user.name = 'x'`, `ctx.files[0].fieldname = 'y'`,\n * `ctx.body.tags.push(...)`) all surface a warning — matching the\n * prior `DeepReadonly<T>` contract at runtime instead of at the type\n * level. In production (`process.env.NODE_ENV === 'production'`) the\n * proxy is bypassed entirely and `target` is returned as-is so the\n * hot path stays zero-cost.\n *\n * Why a Proxy instead of `DeepReadonly<T>` at the type level: the\n * recursive conditional type interfered with TS narrowing (notably\n * discriminated unions on `ctx.body`) and slowed type-checking on\n * deeply-nested Zod-inferred shapes. Compile-time sealing is gone;\n * runtime warning catches the same class of bug during dev and tests.\n *\n * Trap returns `true` so strict-mode call sites (which is all of them\n * — ES modules are strict) don't *throw* on assignment — they just\n * get a warning + the underlying value stays untouched. Adopters\n * discover the violation when the subsequent read returns the\n * original value, not the one they \"set\".\n *\n * Targets are cached per-`req` under {@link readOnlyProxyCacheKey} so\n * (1) repeat getter access returns the same proxy (`ctx.body ===\n * ctx.body`, `ctx.body.user === ctx.body.user`); and (2) cyclic refs\n * (`body.self = body`) terminate via the cache hit on the second\n * visit. Primitives, `null`, and non-plain values pass through.\n */\nfunction makeReadOnlyProxy<T>(target: T, req: object, label: string): T {\n  if (process.env.NODE_ENV === 'production') return target\n  if (!isPlainObjectOrArray(target)) return target\n\n  type Cache = WeakMap<object, unknown>\n  const reqObj = req as Record<symbol, Cache | undefined>\n  let cache = reqObj[readOnlyProxyCacheKey]\n  if (!cache) {\n    cache = new WeakMap()\n    reqObj[readOnlyProxyCacheKey] = cache\n  }\n  const targetObj = target as unknown as object\n  const cached = cache.get(targetObj)\n  if (cached) return cached as T\n\n  const warnWrite = (verb: string, prop: PropertyKey) => {\n    console.warn(\n      `[kickjs] Attempted to ${verb} \\`ctx.${label}.${String(prop)}\\` — ` +\n        `request data is read-only. ` +\n        `Stash computed values via \\`ctx.set('key', value)\\` or a Context Contributor, ` +\n        `or reach \\`ctx.req.${label}\\` if you genuinely need the raw mutable handle.`,\n    )\n  }\n\n  const proxy = new Proxy(targetObj, {\n    get(t, prop, receiver) {\n      const value = Reflect.get(t, prop, receiver)\n      // Recurse only into plain objects / arrays. Functions (incl.\n      // array methods like `.push`) pass through with `receiver` as\n      // their `this`, so internal `this[i] = x` writes still hit the\n      // `set` trap and warn.\n      if (isPlainObjectOrArray(value)) {\n        return makeReadOnlyProxy(value, req, `${label}.${String(prop)}`)\n      }\n      return value\n    },\n    set(_t, prop) {\n      warnWrite('assign', prop)\n      return true\n    },\n    deleteProperty(_t, prop) {\n      warnWrite('delete', prop)\n      return true\n    },\n    defineProperty(_t, prop) {\n      warnWrite('Object.defineProperty on', prop)\n      return true\n    },\n  })\n  cache.set(targetObj, proxy)\n  return proxy as T\n}\n\n/**\n * The shape of a single route entry in `KickRoutes`. Generated by\n * `kick typegen` and consumed via the `Ctx<T>` helper. Each field is\n * `unknown` by default and is filled in as the typegen learns more\n * about the route (URL params from the path, body/query from validation\n * schemas, etc.).\n */\nexport interface RouteShape {\n  params?: unknown\n  body?: unknown\n  query?: unknown\n  response?: unknown\n  /**\n   * Union of context keys `kick typegen` proved are populated for this\n   * route — the keys of every context contributor applied at method or\n   * class level. Drives {@link RequestContext.require} narrowing, so\n   * calling `ctx.require()` for a key this route doesn't carry is a\n   * compile error instead of a request-time throw.\n   *\n   * `string` (the default) means \"not proven\", not \"no keys\". Typegen\n   * emits `string` whenever it cannot see the full picture — a\n   * contributor registered at module / adapter / bootstrap level, or an\n   * unrecognised decorator that might bundle contributors of its own.\n   * Narrowing an unprovable route would produce compile errors for keys\n   * that really are present.\n   */\n  contextKeys?: string\n}\n\n/**\n * Unified request/response abstraction passed to every controller method.\n * Shields handlers from raw Express objects and provides convenience methods.\n *\n * Implements {@link ExecutionContext} so the transport-agnostic Context\n * Contributor pipeline (#107) can run against this concrete HTTP context\n * the same way it will run against future WS / queue / cron contexts.\n */\nexport class RequestContext<\n  TBody = any,\n  TParams = any,\n  TQuery = any,\n  /**\n   * Context keys proven present for this route. Defaults to `string`, so\n   * a handler typed as plain `RequestContext` keeps today's unnarrowed\n   * behaviour — which is also the deliberate escape hatch when typegen's\n   * view is incomplete.\n   */\n  TKeys extends string = string,\n> implements ExecutionContext<TKeys> {\n  /**\n   * Engine-agnostic response driver the response helpers write through. Under\n   * the Express runtime it IS `res` (Express's Response satisfies\n   * {@link RuntimeResponse} structurally); other runtimes pass a thin wrapper\n   * over their native reply as the optional fourth argument.\n   */\n  private readonly _response: RuntimeResponse\n\n  constructor(\n    public readonly req: ActiveRuntime['request'],\n    public readonly res: ActiveRuntime['response'],\n    public readonly next: NextFunction,\n    responseDriver?: RuntimeResponse,\n  ) {\n    // Under the Express runtime `res` IS a RuntimeResponse (structural); other\n    // runtimes pass an explicit driver wrapping their native reply.\n    this._response = responseDriver ?? (res as RuntimeResponse)\n  }\n\n  /**\n   * Memo of the most recent {@link qs} call this request. The query\n   * object is immutable for a request's lifetime, so a repeat call with\n   * the same `(fieldConfig, options)` references returns the cached\n   * parse instead of re-walking the filter/sort strings.\n   */\n  private _qsMemo?: { config: unknown; options: unknown; result: unknown }\n\n  /** Memoized {@link problem} sender — built lazily on first access. */\n  private _problem?: ProblemSender\n\n  /**\n   * Read-side accessor for the per-request metadata map.\n   *\n   * Returns the AsyncLocalStorage map (`requestStore.getStore().values`)\n   * shared with the Context Contributor pipeline when an ALS frame is\n   * active. Returns `null` outside any frame — read-side callers\n   * (`ctx.get`, `ctx.user`, `ctx.tenantId`, `ctx.roles`) treat that as\n   * \"no metadata\" and fall through to their `req.*` defaults. Reads\n   * never throw because outside an ALS frame nobody could have written\n   * via `ctx.set` anyway, so an empty answer is the truthful one.\n   */\n  private metadataReadOnly(): Map<string, any> | null {\n    return (requestStore.getStore()?.values as Map<string, any> | undefined) ?? null\n  }\n\n  /**\n   * Write-side accessor for the per-request metadata map.\n   *\n   * Returns the same map as {@link metadataReadOnly} when an ALS frame\n   * is active. Throws otherwise — writing to a fallback map outside\n   * the ALS frame would silently lose data because other call sites\n   * (downstream contributors, request-logger, etc.) read from the\n   * canonical store and would never see it. Mount\n   * `requestScopeMiddleware()` (Application does this for you in\n   * `'auto'` mode) or wrap your test setup in\n   * `requestStore.run({...}, () => …)` to fix.\n   */\n  private metadataForWrite(): Map<string, any> {\n    const store = requestStore.getStore()\n    if (store) return store.values as Map<string, any>\n    throw new Error(\n      'RequestContext.set called outside an AsyncLocalStorage frame. ' +\n        'Mount requestScopeMiddleware() before constructing RequestContext, ' +\n        'or wrap test setup in requestStore.run({ requestId, instances: new Map(), values: new Map() }, () => ...).',\n    )\n  }\n\n  // ── Request Data ────────────────────────────────────────────────────\n\n  /**\n   * Parsed request body. Wrapped in a dev-only Proxy that warns when\n   * adopters try to mutate Zod-validated payloads in place — compute\n   * new values and stash them via `ctx.set('key', value)` or a Context\n   * Contributor instead. Reach for `ctx.req.body` if you genuinely\n   * need the raw, mutable Express handle (rare).\n   *\n   * In production the Proxy is bypassed and `this.req.body` is\n   * returned as-is — no runtime cost on the hot path.\n   */\n  get body(): TBody {\n    return makeReadOnlyProxy<TBody>(this.req.body, this.req, 'body')\n  }\n\n  /** Path parameters parsed from the route — read-only, see {@link body}. */\n  get params(): TParams {\n    return makeReadOnlyProxy<TParams>(this.req.params as TParams, this.req, 'params')\n  }\n\n  /** Parsed query string — read-only, see {@link body}. */\n  get query(): TQuery {\n    return makeReadOnlyProxy<TQuery>(this.req.query as TQuery, this.req, 'query')\n  }\n\n  /** Inbound HTTP headers — read-only, see {@link body}. */\n  get headers(): Request['headers'] {\n    return makeReadOnlyProxy<Request['headers']>(this.req.headers, this.req, 'headers')\n  }\n\n  get requestId(): string | undefined {\n    return (this.req as any).requestId ?? (this.req.headers['x-request-id'] as string | undefined)\n  }\n\n  /**\n   * `AbortSignal` that fires when the underlying HTTP request is\n   * closed — either because the client disconnected before the\n   * response was sent, or because Node's socket-close event ran\n   * after a normal response. Multiple `RequestContext` wrappers for\n   * the same request (router-builder constructs one per\n   * middleware/contributor pipeline / main handler) share a single\n   * `AbortController` cached on the underlying `req` object, so the\n   * signal is stable across the request lifecycle.\n   *\n   * Thread it through anything that takes an `AbortSignal` so the\n   * work cancels as soon as the client gives up — e.g. a kickjs-db\n   * relational query:\n   *\n   * ```ts\n   * @Get('/:id/full')\n   * async show(ctx: RequestContext) {\n   *   const row = await this.repo.findFullById(ctx.params.id, ctx.signal)\n   *   if (!row) return ctx.notFound()\n   *   ctx.json(row)\n   * }\n   * ```\n   *\n   * The repo passes `signal` to `db.query.<table>.findUnique({ signal })`;\n   * if the client disconnects mid-flight, the in-flight query rejects\n   * with `RelationalQueryCancelledError` instead of consuming the\n   * connection until completion.\n   *\n   * Implementation note — both `req.on('close')` and `res.on('close')`\n   * are wired so the signal aborts regardless of whether the close\n   * event lands on the request stream or the response stream first.\n   * Subsequent fires are no-ops (`AbortController.abort()` is\n   * idempotent).\n   */\n  get signal(): AbortSignal {\n    const req = this.req as Request & { [signalControllerKey]?: AbortController }\n    const cached = req[signalControllerKey]\n    if (cached) return cached.signal\n\n    const ctrl = new AbortController()\n    req[signalControllerKey] = ctrl\n    const abort = () => ctrl.abort('request closed')\n    this.req.once('close', abort)\n    this._response.once('close', abort)\n    return ctrl.signal\n  }\n\n  /** Session data (requires session middleware) */\n  get session(): any {\n    return (this.req as any).session\n  }\n\n  /**\n   * The authenticated user set by AuthAdapter.\n   * Reads from the per-request metadata store first (`ctx.set('user', ...)`),\n   * then falls back to `req.user` (set directly by AuthAdapter middleware).\n   *\n   * Extend the `AuthUser` interface via module augmentation in `@forinda/kickjs-auth`\n   * to get full typing.\n   *\n   * @example\n   * ```ts\n   * @Get('/me')\n   * @Authenticated()\n   * getProfile(ctx: RequestContext) {\n   *   const user = ctx.user\n   *   if (!user) return ctx.notFound()\n   *   return ctx.json({ user })\n   * }\n   * ```\n   */\n  get user(): MetaValue<'user', Record<string, any>> | undefined {\n    return this.metadataReadOnly()?.get('user') ?? (this.req as any).user\n  }\n\n  /**\n   * Tenant identifier for multi-tenant apps. Reads `user.tenantId` —\n   * populated either by `AuthAdapter.testMode({ tenantId })`, a tenant\n   * resolver middleware, or manually on the strategy's `mapPayload`.\n   *\n   * Augment `AuthUser` (or `ContextMeta['user']`) to widen the return\n   * type if your user shape guarantees a non-`string | undefined` id.\n   */\n  get tenantId(): string | undefined {\n    const u = this.user as Record<string, any> | undefined\n    return u?.tenantId\n  }\n\n  /**\n   * Effective role list for the current user. Prefers `user.tenantRoles`\n   * (populated by `AuthAdapterOptions.roleResolver` under a tenant) and\n   * falls back to `user.roles`. Returns an empty array when the user is\n   * absent or the shape has neither field.\n   */\n  get roles(): string[] {\n    const u = this.user as Record<string, any> | undefined\n    return u?.tenantRoles ?? u?.roles ?? []\n  }\n\n  // ── Query String Parsing ───────────────────────────────────────────\n\n  /**\n   * Parse the request query string into structured filters, sort, pagination, and search.\n   * Pass the result to an ORM query builder adapter (Drizzle, Prisma, Sequelize, etc.).\n   *\n   * Generic over the field config: when passed an inline literal (or\n   * `as const`), `filters[].field` and `sort[].field` are narrowed to\n   * the exact whitelisted field names. Pass nothing or a non-literal\n   * config and you get the loose `string` fallback.\n   *\n   * @param fieldConfig - Optional whitelist for filterable, sortable, and searchable fields\n   * @param options - Limits (`maxLimit`, `defaultLimit`, `maxSearchLength`) and an\n   *   `onReject` hook. By default a rejected/over-broad field is logged via\n   *   `console.warn` with the request id; pass an explicit `onReject` to override\n   *   (e.g. throw to return a 400), or `onReject: () => {}` to silence.\n   *\n   * @example\n   * ```ts\n   * @Get('/')\n   * async list(ctx: RequestContext) {\n   *   const parsed = ctx.qs({\n   *     filterable: ['status', 'priority'],\n   *     sortable: ['createdAt', 'title'],\n   *   } as const)\n   *   parsed.filters[0].field // typed as 'status' | 'priority'\n   *   parsed.sort[0].field    // typed as 'createdAt' | 'title'\n   * }\n   * ```\n   */\n  qs<TConfig extends QueryFieldConfig | undefined = undefined>(\n    fieldConfig?: TConfig,\n    options?: ParseQueryOptions,\n  ): TypedParsedQuery<TConfig> {\n    // Cheap per-request memo — repeat calls with the same args (the\n    // common controller pattern) skip re-parsing. `req.query` is fixed\n    // for the request's lifetime, so caching is always sound.\n    const memo = this._qsMemo\n    if (memo && memo.config === fieldConfig && memo.options === options) {\n      return memo.result as TypedParsedQuery<TConfig>\n    }\n    const effective: ParseQueryOptions = {\n      ...options,\n      onReject:\n        options?.onReject ??\n        ((rejection) => {\n          const id = this.requestId ? `[${this.requestId}] ` : ''\n          console.warn(\n            `${id}query ${rejection.kind} '${rejection.field}' rejected (${rejection.reason})`,\n          )\n        }),\n    }\n    const result = parseQuery<TConfig>(\n      this.req.query as Record<string, any>,\n      fieldConfig,\n      effective,\n    )\n    this._qsMemo = { config: fieldConfig, options, result }\n    return result\n  }\n\n  // ── File Uploads ────────────────────────────────────────────────────\n\n  /**\n   * Single uploaded file (requires `@FileUpload({ mode: 'single' })`).\n   * Wrapped in a dev-only Proxy that warns on mutation — see {@link body}.\n   * File metadata is set by the upload middleware and shouldn't be\n   * mutated downstream.\n   */\n  get file(): Express.Multer.File | undefined {\n    const f = this.req.file\n    return f ? makeReadOnlyProxy<Express.Multer.File>(f, this.req, 'file') : undefined\n  }\n\n  /**\n   * Array of uploaded files (requires `@FileUpload({ mode: 'array' })`).\n   * The array (and each entry in dev) is wrapped in a read-only Proxy\n   * that warns on `push`/`pop` and per-file mutation. Use\n   * `ctx.req.files` if you genuinely need the mutable Express handle.\n   */\n  get files(): Express.Multer.File[] | undefined {\n    // multer's `Request['files']` is a union — array (mode: 'array' /\n    // 'any') or `{ [fieldname]: File[] }` (mode: 'fields'). The\n    // `@FileUpload({ mode: 'array' })` decorator only sets the array\n    // shape, but `Request['files']` is the broad union. Narrow back to\n    // `File[]` here for the common-case getter; adopters using\n    // `mode: 'fields'` can read `ctx.req.files` directly for the\n    // dictionary shape.\n    const f = this.req.files\n    if (!Array.isArray(f)) return undefined\n    return makeReadOnlyProxy<Express.Multer.File[]>(f, this.req, 'files')\n  }\n\n  // ── Metadata Store ──────────────────────────────────────────────────\n\n  /**\n   * Read a value from the per-request metadata store.\n   *\n   * When `ContextMeta` has been augmented with a matching key, the return\n   * type is inferred automatically. For ad-hoc keys, pass a generic:\n   * `ctx.get<MyType>('custom')`.\n   */\n  get<K extends string>(key: K): MetaValue<K> | undefined {\n    return this.metadataReadOnly()?.get(key) as MetaValue<K> | undefined\n  }\n\n  /**\n   * Read a value that a contributor is expected to have produced, and\n   * throw {@link MissingContextValueError} when it hasn't.\n   *\n   * Use this instead of `ctx.get(key)!` anywhere the value is a\n   * precondition rather than an optional extra — permissions, tenants,\n   * the resolved subject of the route. The non-null assertion compiles\n   * whether or not the producing contributor is actually applied to the\n   * route, so a dropped `@LoadTenant` turns into `undefined` flowing\n   * silently into an auth check. `require()` fails loudly at that point\n   * instead, naming the key.\n   *\n   * ```ts\n   * // before — compiles even if @OperatorPerm was never applied\n   * const perm = ctx.get('operatorPerm')!\n   *\n   * // after — throws MissingContextValueError naming the key + route\n   * const perm = ctx.require('operatorPerm')\n   * ```\n   *\n   * When `TKeys` is narrowed — which it is for a handler typed as\n   * `Ctx<KickRoutes…>`, from typegen's per-route `contextKeys` — asking\n   * for a key the route doesn't carry is a compile error, so a dropped\n   * decorator fails the build. `TKeys` stays `string` (no narrowing) for\n   * a plain `RequestContext` and for any route typegen couldn't prove\n   * complete; there this is a runtime guarantee only.\n   * See `architecture.md` §20.14.\n   *\n   * `null` counts as present; only `undefined` (or a missing entry)\n   * throws. A contributor that deliberately resolves to `null` is\n   * expressing \"looked, found nothing\", which is a real value — which\n   * is why the return type is `Exclude<…, undefined>` and NOT\n   * `NonNullable<…>`. The latter would strip `null` from the type while\n   * the runtime still hands it back, so a caller would be told a value\n   * is non-null and then get `null`.\n   */\n  require<K extends TKeys>(key: K): Exclude<MetaValue<K>, undefined> {\n    const value = this.metadataReadOnly()?.get(key)\n    if (value === undefined) {\n      throw new MissingContextValueError(key, this.routeLabel())\n    }\n    return value as Exclude<MetaValue<K>, undefined>\n  }\n\n  /**\n   * Best-effort `\"GET /path\"` label for error messages. Runtime-agnostic:\n   * express/fastify requests and web-standard `Request` all expose\n   * `method` + `url`, but none of them are guaranteed here, so every\n   * access is defensive and the whole thing is optional.\n   */\n  private routeLabel(): string | undefined {\n    const req = this.req as { method?: unknown; url?: unknown } | undefined\n    const method = typeof req?.method === 'string' ? req.method : undefined\n    const url = typeof req?.url === 'string' ? req.url : undefined\n    if (method && url) return `${method} ${url}`\n    return method ?? url\n  }\n\n  /**\n   * Write a value to the per-request metadata store. Throws when no\n   * AsyncLocalStorage frame is active — see {@link metadataForWrite}\n   * for why a silent fallback is the wrong default.\n   */\n  set<K extends string>(key: K, value: MetaValue<K>): void {\n    this.metadataForWrite().set(key, value)\n  }\n\n  // ── Response Helpers ────────────────────────────────────────────────\n\n  /**\n   * Set a response header. Runtime-neutral — works on every engine and on\n   * the web/edge entry. No-op guards are the runtime's job (headers set\n   * after the response settles are ignored or throw per engine).\n   */\n  setHeader(name: string, value: string | number | readonly string[]): this {\n    this._response.setHeader(name, value)\n    return this\n  }\n\n  json(data: any, status = 200) {\n    return this._response.status(status).json(data)\n  }\n\n  created(data: any) {\n    return this._response.status(201).json(data)\n  }\n\n  noContent() {\n    return this._response.status(204).end()\n  }\n\n  /**\n   * @deprecated Prefer {@link ProblemSender.notFound | ctx.problem.notFound()},\n   * which emits an RFC 9457 — Problem Details response. This helper stays\n   * for backward compatibility and will not be removed.\n   */\n  notFound(message = 'Not Found') {\n    return this._response.status(404).json({ message })\n  }\n\n  /**\n   * @deprecated Prefer {@link ProblemSender.badRequest | ctx.problem.badRequest()},\n   * which emits an RFC 9457 — Problem Details response. This helper stays\n   * for backward compatibility and will not be removed.\n   */\n  badRequest(message: string) {\n    return this._response.status(400).json({ message })\n  }\n\n  // ── RFC 9457 Problem Details ───────────────────────────────────────\n\n  /**\n   * RFC 9457 — Problem Details for HTTP APIs response helper.\n   * https://datatracker.ietf.org/doc/html/rfc9457\n   *\n   * `ctx.problem(...)` sends a canonical problem-detail response with\n   * `Content-Type: application/problem+json`. The convenience methods\n   * (`ctx.problem.notFound`, `.badRequest`, etc.) pre-fill `status` +\n   * `title` for the common codes.\n   *\n   * `type` defaults to `about:blank` (§3.1.1); `title` defaults to the\n   * IANA reason phrase for `status` (§3.1.4). Extension members per §3.2\n   * pass through unchanged.\n   *\n   * @example\n   * ```ts\n   * ctx.problem({\n   *   type: 'https://api.example.com/problems/out-of-credit',\n   *   status: 403,\n   *   detail: 'Your balance is 30, but that costs 50.',\n   *   instance: `/account/${ctx.user.id}/messages/${ctx.params.id}`,\n   *   balance: 30,\n   * })\n   *\n   * ctx.problem.notFound({ detail: 'User abc not found' })\n   * ctx.problem.validation(zodResult.error.issues)\n   * ```\n   *\n   * @see {@link ProblemException} for the exception-throwing equivalent\n   * (use it from services where `ctx` isn't in scope).\n   */\n  get problem(): ProblemSender {\n    // Memoized — building the sender allocates ~10 closures, so pay that only\n    // on the first access per context instead of per `ctx.problem.*` call.\n    if (this._problem) return this._problem\n    const send = (input: ProblemDetails): RuntimeResponse => this.sendProblem(input)\n    send.badRequest = (input: ProblemInput = {}): RuntimeResponse =>\n      this.sendProblem({ status: 400, ...input })\n    send.unauthorized = (input: ProblemInput = {}): RuntimeResponse =>\n      this.sendProblem({ status: 401, ...input })\n    send.forbidden = (input: ProblemInput = {}): RuntimeResponse =>\n      this.sendProblem({ status: 403, ...input })\n    send.notFound = (input: ProblemInput = {}): RuntimeResponse =>\n      this.sendProblem({ status: 404, ...input })\n    send.conflict = (input: ProblemInput = {}): RuntimeResponse =>\n      this.sendProblem({ status: 409, ...input })\n    send.unprocessable = (input: ProblemInput = {}): RuntimeResponse =>\n      this.sendProblem({ status: 422, ...input })\n    send.tooManyRequests = (input: ProblemInput = {}): RuntimeResponse =>\n      this.sendProblem({ status: 429, ...input })\n    send.internal = (input: ProblemInput = {}): RuntimeResponse =>\n      this.sendProblem({ status: 500, ...input })\n    send.validation = (issues: any[], input: ProblemInput = {}): RuntimeResponse => {\n      const errors: ValidationError[] = (issues || []).map((issue: any) => ({\n        field: issue.path?.join?.('.') ?? '',\n        message: issue.message ?? '',\n        code: issue.code,\n      }))\n      return this.sendProblem({\n        status: 422,\n        detail: issues?.[0]?.message,\n        ...input,\n        errors,\n      })\n    }\n    this._problem = send as ProblemSender\n    return this._problem\n  }\n\n  private sendProblem(input: ProblemDetails): RuntimeResponse {\n    const body = normalizeProblem(input)\n    this._response.setHeader('Content-Type', 'application/problem+json')\n    return this._response.status(body.status).json(body)\n  }\n\n  /**\n   * Send an HTML response.\n   *\n   * Passes the full MIME type rather than the `'html'` shorthand. The\n   * shorthand is an Express affordance — `res.type()` runs it through a MIME\n   * lookup — but the Fastify and h3 drivers forward the string to their own\n   * `type()` / `setHeader()` verbatim, so `'html'` reached the wire as a\n   * malformed `Content-Type: html` on those engines. Fastify 5.10 started\n   * normalising that invalid value to `text/plain`, which is what surfaced it.\n   *\n   * Express produces `text/html; charset=utf-8` for `.type('html')`, so\n   * spelling it out here is byte-identical there and correct everywhere else.\n   */\n  html(content: string, status = 200) {\n    return this._response.status(status).type('text/html; charset=utf-8').send(content)\n  }\n\n  download(buffer: Buffer, filename: string, contentType = 'application/octet-stream') {\n    this._response.setHeader('Content-Disposition', `attachment; filename=\"${filename}\"`)\n    this._response.setHeader('Content-Type', contentType)\n    return this._response.send(buffer)\n  }\n\n  /**\n   * Render a template using the registered view engine (EJS, Pug, Handlebars, etc.).\n   * Requires a ViewAdapter to be configured in bootstrap().\n   *\n   * @param template - Template name (without extension, relative to viewsDir)\n   * @param data - Data to pass to the template\n   *\n   * @example\n   * ```ts\n   * ctx.render('dashboard', { user, title: 'Dashboard' })\n   * ctx.render('emails/welcome', { name: 'Alice' })\n   * ```\n   */\n  render(template: string, data: Record<string, any> = {}) {\n    return this._response.render(template, data)\n  }\n\n  /**\n   * Parse query params and return a standardized paginated response.\n   * Calls `ctx.qs()` internally, then wraps your data with pagination meta.\n   *\n   * @param fetcher - Async function that receives ParsedQuery and returns `{ data, total }`\n   * @param fieldConfig - Optional whitelist for filterable, sortable, searchable fields\n   *\n   * @example\n   * ```ts\n   * @Get('/')\n   * async list(ctx: RequestContext) {\n   *   return ctx.paginate(\n   *     async (parsed) => {\n   *       const data = await db.select().from(users)\n   *         .where(query.where).limit(parsed.pagination.limit)\n   *         .offset(parsed.pagination.offset).all()\n   *       const total = await db.select({ count: count() }).from(users).get()\n   *       return { data, total: total?.count ?? 0 }\n   *     },\n   *     { filterable: ['name', 'role'], sortable: ['createdAt'] },\n   *   )\n   * }\n   * ```\n   */\n  async paginate<T, TConfig extends QueryFieldConfig | undefined = undefined>(\n    fetcher: (parsed: TypedParsedQuery<TConfig>) => Promise<{ data: T[]; total: number }>,\n    fieldConfig?: TConfig,\n  ) {\n    const parsed = this.qs<TConfig>(fieldConfig)\n    const { data, total } = await fetcher(parsed)\n    const { page, limit } = parsed.pagination\n    const totalPages = Math.ceil(total / limit) || 1\n\n    const response: PaginatedResponse<T> = {\n      data,\n      meta: {\n        page,\n        limit,\n        total,\n        totalPages,\n        hasNext: page < totalPages,\n        hasPrev: page > 1,\n      },\n    }\n\n    return this.json(response)\n  }\n\n  // ── Server-Sent Events ──────────────────────────────────────────────\n\n  /**\n   * Start an SSE (Server-Sent Events) stream.\n   * Sets the correct headers and returns helpers to send events.\n   *\n   * Pass a payload type to get typed sends — and `return sse` from the\n   * handler so `kick typegen` carries the event type into\n   * `KickRoutes.Api`, where `@forinda/kickjs-client`'s `api.stream()`\n   * picks it up (the returned handler is ignored at runtime — the\n   * response is already streaming).\n   *\n   * @example\n   * ```ts\n   * interface Tick { time: string }\n   *\n   * @Get('/events')\n   * async stream(ctx: RequestContext) {\n   *   const sse = ctx.sse<Tick>()\n   *\n   *   const interval = setInterval(() => {\n   *     sse.send({ time: new Date().toISOString() }, 'tick')\n   *   }, 1000)\n   *\n   *   sse.onClose(() => clearInterval(interval))\n   *   return sse // typed as SseHandler<Tick> → response inference\n   * }\n   * ```\n   */\n  sse<T = unknown>(): SseHandler<T> {\n    this._response.writeHead(200, {\n      'Content-Type': 'text/event-stream',\n      'Cache-Control': 'no-cache',\n      Connection: 'keep-alive',\n      'X-Accel-Buffering': 'no',\n    })\n    this._response.flushHeaders()\n\n    const closeCallbacks: Array<() => void> = []\n\n    this.req.on('close', () => {\n      for (const cb of closeCallbacks) cb()\n    })\n\n    return {\n      /** Send an SSE event with optional event name and id */\n      send: (data: T, event?: string, id?: string) => {\n        if (id) this._response.write(`id: ${id}\\n`)\n        if (event) this._response.write(`event: ${event}\\n`)\n        this._response.write(`data: ${JSON.stringify(data)}\\n\\n`)\n      },\n      /** Send a comment (keeps connection alive) */\n      comment: (text: string) => {\n        this._response.write(`: ${text}\\n\\n`)\n      },\n      /** Register a callback when the client disconnects */\n      onClose: (fn: () => void) => {\n        closeCallbacks.push(fn)\n      },\n      /** End the SSE stream */\n      close: () => {\n        this._response.end()\n      },\n    }\n  }\n}\n\n/**\n * The handle {@link RequestContext.sse} returns. The optional phantom\n * `__sse` property carries the event payload type STRUCTURALLY — never set\n * at runtime — so `kick typegen`'s response inference (handler `return sse`)\n * flows it into `KickRoutes.Api`, and `@forinda/kickjs-client` detects SSE\n * routes without importing any server types.\n */\nexport interface SseHandler<T = unknown> {\n  /** Phantom event-payload type marker — never assigned at runtime. */\n  readonly __sse?: T\n  /** Send an SSE event with optional event name and id. */\n  send(data: T, event?: string, id?: string): void\n  /** Send a comment line (keeps the connection alive through proxies). */\n  comment(text: string): void\n  /** Register a callback for client disconnect. */\n  onClose(fn: () => void): void\n  /** End the SSE stream. */\n  close(): void\n}\n\n/**\n * Short alias for `RequestContext` parameterised by a route shape.\n *\n * Use with `kick typegen`'s generated `KickRoutes` namespace for\n * fully-typed `ctx.params`, `ctx.body`, and `ctx.query`. Metadata\n * typing (`ctx.get()`, `ctx.set()`, `ctx.user`) comes from\n * `ContextMeta` augmentation and works on all `RequestContext` instances.\n *\n * @example\n * ```ts\n * @Get('/:id')\n * getUser(ctx: Ctx<KickRoutes.UserController['getUser']>) {\n *   ctx.params.id      // typed from RouteShape\n *   ctx.body           // typed from RouteShape\n *   ctx.user           // typed from ContextMeta\n *   ctx.get('tenant')  // typed from ContextMeta\n * }\n * ```\n */\nexport type Ctx<TRoute extends RouteShape = RouteShape> = RequestContext<\n  TRoute extends { body: infer B } ? B : any,\n  TRoute extends { params: infer P } ? P : any,\n  TRoute extends { query: infer Q } ? Q : any,\n  // Falls back to `string` (no narrowing) whenever typegen couldn't prove\n  // the route's full contributor set — see `RouteShape.contextKeys`.\n  TRoute extends { contextKeys: infer K } ? (K extends string ? K : string) : string\n>\n\n/**\n * Global ambient registry of typed routes, populated by `kick typegen`.\n *\n * Interfaces inside `KickRoutes` correspond to controller classes (each\n * property one route method, conforming to `RouteShape`) — plus the\n * reserved `KickRoutes.Api`: a flat `'METHOD /mounted/path'` map over the\n * same shapes, consumed by `@forinda/kickjs-client`. Don't name a\n * controller class `Api` — it would declaration-merge into that map.\n *\n * Empty by default — declarations come from `.kickjs/types/kick__routes.ts`\n * generated alongside the rest of the typegen output.\n */\ndeclare global {\n  // eslint-disable-next-line @typescript-eslint/no-namespace\n  namespace KickRoutes {}\n}\n"],"mappings":"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"}

package/dist/core-OXbl534_.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"core-OXbl534_.mjs","names":[],"sources":["../src/core/context-decorator.ts","../src/core/asset-keys.ts","../src/core/assets.ts"],"sourcesContent":["import 'reflect-metadata'\nimport { METADATA, type Constructor, type MaybePromise } from './interfaces'\nimport { pushClassMeta, pushMethodMeta } from './metadata'\nimport type { InjectionToken } from './token'\nimport type { ContextKeys, ContextMeta, ExecutionContext, MetaValue } from './execution-context'\n\n/**\n * String-literal union of every known context key — the union of the\n * keys declared on {@link ContextKeys} (key-only registry) and\n * {@link ContextMeta} (value-type registry). Resolves to `string` when\n * the project hasn't augmented either yet (so a first-day project keeps\n * compiling), and narrows to the concrete keys once the\n * `declare module '@forinda/kickjs' { interface ContextKeys/ContextMeta { ... } }`\n * blocks land.\n *\n * Used as the element type of `dependsOn`, so a typo like\n * `dependsOn: ['tenent']` becomes a TS error instead of a boot-time\n * `MissingContributorError`.\n *\n * Unioning BOTH registries is deliberate: it means adding a value type\n * via `ContextMeta` automatically makes that key a valid `dependsOn`\n * target, and you can register a dependsOn-able key in `ContextKeys`\n * without being forced to give it a value type. (Before the split,\n * `dependsOn` was keyed off `ContextMeta` alone, so augmenting\n * `ContextMeta` for some keys broke `dependsOn` for every key you\n * hadn't added there.)\n */\ntype KnownContextKey = keyof ContextMeta | keyof ContextKeys\nexport type ContextMetaKey = [KnownContextKey] extends [never] ? string : KnownContextKey & string\n\n/**\n * What a single `deps` entry is allowed to be — the runtime calls\n * `container.resolve(value)`, which accepts an injection token brand\n * or a constructor (decorated class). Anything else (a string literal,\n * an array, a plain object) silently fails at boot when the runner\n * tries to resolve it; constraining at the type level surfaces the\n * mistake in the editor instead.\n */\nexport type DepValue = InjectionToken<unknown> | Constructor<unknown>\n\n/**\n * Maps a `deps` declaration object to its resolved-instance shape.\n *\n * `deps: { db: DB_TOKEN, cache: CacheService }` produces\n * `{ db: Db, cache: CacheService }` — the runner resolves each value\n * against the DI container and hands the result to `resolve()`.\n */\nexport type ResolvedDeps<D extends Record<string, DepValue>> = {\n  [K in keyof D]: D[K] extends InjectionToken<infer T>\n    ? T\n    : D[K] extends Constructor<infer T>\n      ? T\n      : never\n}\n\n/**\n * Keys of `T` that are declared required (i.e. not `?`-optional).\n */\ntype RequiredParamKeys<T> = {\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  [K in keyof T]-?: {} extends Pick<T, K> ? never : K\n}[keyof T]\n\n/**\n * Params a call site MUST supply: the required keys of `P` that\n * `paramDefaults` (type `PD`) doesn't already provide.\n *\n * The `string extends keyof P` guard short-circuits the index-signature\n * case — `P` defaults to `Record<string, never>` for the overwhelmingly\n * common zero-params contributor, and a mapped type over `string` would\n * otherwise report \"every key is required\" and break `@Foo` for every\n * existing decorator in the wild.\n */\nexport type MissingParamKeys<P, PD> = string extends keyof P\n  ? never\n  : Exclude<RequiredParamKeys<P>, keyof PD>\n\n/**\n * The argument type for a call site (`@Foo({...})`, `.with({...})`).\n *\n * `Partial<P>` when every required field has a default, so adopters keep\n * overriding just the fields they care about. Otherwise `Partial<P>`\n * intersected with the undefaulted required fields, making those\n * mandatory at each call site.\n */\nexport type CallSiteParams<P, PD> = [MissingParamKeys<P, PD>] extends [never]\n  ? Partial<P>\n  : Partial<P> & Pick<P, MissingParamKeys<P, PD> & keyof P>\n\n/**\n * Spec passed to {@link defineContextDecorator}. Describes one entry in\n * the per-request contributor pipeline.\n *\n * @typeParam K   - The {@link ContextMeta} key this contributor populates.\n * @typeParam D   - DI dependency declaration shape (see {@link ResolvedDeps}).\n * @typeParam Ctx - Concrete execution-context type. Defaults to the abstract\n *                  {@link ExecutionContext}; HTTP contributors typically\n *                  default to `RequestContext` at the call site.\n * @typeParam PD  - Inferred from `paramDefaults`. Drives which params each\n *                  call site is required to supply — see {@link CallSiteParams}.\n *                  Never spell this by hand.\n */\nexport interface ContextDecoratorSpec<\n  K extends string = string,\n  D extends Record<string, DepValue> = Record<string, never>,\n  P extends Record<string, unknown> = Record<string, never>,\n  Ctx extends ExecutionContext = ExecutionContext,\n  PD extends Partial<P> = Partial<P>,\n> {\n  /** ContextMeta key the resolved value is written to. */\n  key: K\n  /**\n   * DI dependencies resolved by the runner before `resolve()` runs.\n   * Map entry keys become property names on the resolved-deps argument\n   * passed to `resolve()`.\n   */\n  deps?: D\n  /**\n   * Other contributor keys that must populate before this one runs.\n   * Enforced via topo-sort at startup; missing deps and cycles fail boot.\n   *\n   * Typed against {@link ContextMetaKey} — the union of `keyof ContextMeta`\n   * and `keyof ContextKeys` — once the project augments either, so\n   * `dependsOn: ['tenent']` (typo) is a TS error, not a boot-time\n   * `MissingContributorError`. Falls back to plain `string[]` when both\n   * registries are empty (no augmentation yet) so first-day projects keep\n   * compiling. Cast escape hatch: `dependsOn: ['custom-key' as ContextMetaKey]`.\n   */\n  dependsOn?: readonly ContextMetaKey[]\n  /**\n   * If `true`, a thrown `resolve` skips the contributor instead of\n   * forwarding to the request error handler. The key is left unset\n   * and downstream consumers see `ctx.get(key) === undefined`.\n   */\n  optional?: boolean\n  /**\n   * Default per-call params merged with the call-site params; call-site\n   * wins. When omitted, params default to `{}` and the resolver\n   * receives an empty object — back-compat with today's zero-arg\n   * decorators.\n   *\n   * Param shape is intentionally unconstrained: plain data, functions,\n   * and closures are all valid. Adopters who want runtime validation\n   * should perform it inside `resolve()` — keeps the framework\n   * validator-agnostic so projects can plug Zod / Valibot / hand-rolled\n   * checks without the framework caring.\n   *\n   * **Required fields are enforced at the call site.** A required field\n   * of `P` that has no entry here must be supplied wherever the\n   * decorator is applied — `@Foo({ action: 'audit:read' })`. The bare\n   * `@Foo` form and `.registration` stop type-checking for such a\n   * decorator, because neither can supply the value.\n   *\n   * This exists so nobody has to invent a meaningless default just to\n   * satisfy the type (`action: 'settings:read'` on a permission\n   * contributor every call site overrides anyway). A default that is\n   * never correct is worse than no default: forget the argument at one\n   * call site and the route silently gates on the placeholder instead\n   * of failing to compile.\n   *\n   * Omit this entirely for the common zero-params case — `P` defaults\n   * to `Record<string, never>`, which requires nothing.\n   */\n  paramDefaults?: PD\n  /**\n   * Runtime mirror of the compile-time requirement above: param names\n   * that must be present after merging call-site params over\n   * `paramDefaults`. A missing one throws `TypeError` at the point of\n   * use (decoration time for `@Foo`, call time for `@Foo({...})` /\n   * `.with({...})`), naming the decorator and the field.\n   *\n   * The type-level check already covers TypeScript call sites, so this\n   * is for the paths types can't reach: plain-JS adopters, `as any`\n   * escapes, and params assembled dynamically. Optional — list only\n   * fields whose absence is a correctness bug rather than a default.\n   */\n  requiredParams?: readonly (keyof P & string)[]\n  /**\n   * Hook invoked when `resolve()` throws and `optional` is `false`.\n   * Returning a value writes it to `ctx.set(key, …)`; returning\n   * `undefined` / `void` skips. Throwing inside the hook forwards\n   * the new error to the request error handler.\n   *\n   * Async-permitted by design — adopters frequently want to\n   * `await auditService.log(err)` or `await cache.fallback(...)`.\n   *\n   * The third `params` argument carries the resolved per-call params\n   * (call-site overrides merged on top of `paramDefaults`).\n   */\n  onError?: (err: unknown, ctx: Ctx, params: P) => MaybePromise<MetaValue<K> | undefined | void>\n  /**\n   * Compute and return the value to write into `ctx.set(key, …)`.\n   *\n   * The third `params` argument carries the resolved per-call params\n   * (call-site overrides merged on top of `paramDefaults`). When the\n   * decorator is applied zero-arg (`@Foo`), `params` equals\n   * `paramDefaults` (or `{}` if defaults are omitted). When applied as\n   * a factory (`@Foo({ ... })`), the call-site object is merged on top.\n   */\n  resolve: (ctx: Ctx, deps: ResolvedDeps<D>, params: P) => MaybePromise<MetaValue<K>>\n}\n\n/**\n * Internal, normalised registration produced by {@link defineContextDecorator}.\n *\n * Frozen and shared by every use site of the decorator (method, class,\n * module, adapter, global). The pipeline builder dedupes by `key` using\n * the precedence rule defined in §20.4 of `architecture.md`.\n */\nexport interface ContributorRegistration<\n  K extends string = string,\n  D extends Record<string, DepValue> = Record<string, never>,\n  Ctx extends ExecutionContext = ExecutionContext,\n> {\n  readonly key: K\n  readonly deps: D\n  readonly dependsOn: readonly ContextMetaKey[]\n  readonly optional: boolean\n  /**\n   * Per-call params from the spec are baked into the closure at\n   * decorator-construction time, so the runner-facing `onError`\n   * exposes only `(err, ctx)`.\n   */\n  readonly onError?: (err: unknown, ctx: Ctx) => MaybePromise<MetaValue<K> | undefined | void>\n  /**\n   * Per-call params from the spec are baked into the closure at\n   * decorator-construction time, so the runner-facing `resolve`\n   * exposes only `(ctx, deps)`. Adopters who write their own\n   * registrations (without `defineContextDecorator`) match this\n   * shape directly — params are an implementation detail of the\n   * decorator factory, not of the runtime pipeline.\n   */\n  readonly resolve: (ctx: Ctx, deps: ResolvedDeps<D>) => MaybePromise<MetaValue<K>>\n  /**\n   * Stack snapshot captured the moment the decorator was defined.\n   * Used by the contributor-pipeline builder to point boot-time\n   * errors (`MissingContributorError`, `ContributorCycleError`,\n   * `DuplicateContributorError`) at the adopter file that declared\n   * the broken contributor — instead of forcing them to grep for\n   * the key string.\n   *\n   * Optional because adopters who hand-roll a `ContributorRegistration`\n   * (without `defineContextDecorator`) may not have a useful stack to\n   * attach. Format is the raw `Error.stack` string; consumers slice\n   * the first non-framework frame for display.\n   */\n  readonly definedAt?: string\n}\n\n/**\n * Type-erased registration shape used in the public collection slots\n * (`AppModule.contributors?()`, `AppAdapter.contributors?()`,\n * `KickPlugin.contributors?()`, `bootstrap({ contributors })`).\n *\n * The narrow `ContributorRegistration` carries a `Ctx` parameter so\n * `resolve(ctx, deps)` is typed at the *definition* site, but `Ctx`\n * sits in a contravariant position on `resolve` — meaning a\n * `ContributorRegistration<…, RequestContext>` is *not* assignable to\n * `ContributorRegistration<…, ExecutionContext>` even though every\n * `RequestContext` is-a `ExecutionContext`. That's TS-sound but\n * useless: the runner only ever calls a contributor with the same\n * concrete ctx the route mounts under, so an HTTP-typed contributor\n * never sees a non-HTTP ctx. Erasing `Ctx` to `any` in the collection\n * type lets adopters store contributors typed against `RequestContext`\n * (or any future transport-specific ctx) in the same array without\n * casting.\n */\nexport type AnyContributorRegistration = ContributorRegistration<\n  string,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  any\n>\n\n/** Convenience alias for `AnyContributorRegistration[]` collections. */\nexport type ContributorRegistrations =\n  | AnyContributorRegistration[]\n  | readonly AnyContributorRegistration[]\n\n/**\n * The decorator function returned by either a zero-arg\n * {@link ContextDecorator} application or a factory call. Overloaded\n * to satisfy both class and method decorator shapes — adopters apply\n * the same decorator to either site without TS rejecting the call.\n */\nexport interface ContextDecoratorTarget {\n  /** Class decorator usage. */\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n  (target: Function): void\n  /** Method decorator usage. */\n  (target: object, propertyKey: string | symbol, descriptor?: PropertyDescriptor): void\n}\n\n/**\n * The value returned by {@link defineContextDecorator}.\n *\n * Resolves to one of two shapes depending on whether every required\n * field of `P` has a `paramDefaults` entry:\n *\n * - {@link ContextDecoratorWithDefaults} — the classic shape. Usable\n *   bare (`@Foo`), as a factory (`@Foo({...})`), via `.with(params)`,\n *   and via `.registration`.\n * - {@link ContextDecoratorRequiringParams} — when `P` has required\n *   fields `paramDefaults` doesn't cover. Only the factory and\n *   `.with(params)` forms exist, because the others have no way to\n *   supply the missing values. Applying such a decorator bare is a\n *   compile error rather than a silent `undefined` at request time.\n *\n * `PD` is inferred from the spec's `paramDefaults`; the default here\n * (`Partial<P>`) keeps hand-written `ContextDecorator<K, D, P>`\n * annotations resolving to the permissive shape as before.\n */\nexport type ContextDecorator<\n  K extends string = string,\n  D extends Record<string, DepValue> = Record<string, never>,\n  P extends Record<string, unknown> = Record<string, never>,\n  Ctx extends ExecutionContext = ExecutionContext,\n  PD = Partial<P>,\n> = [MissingParamKeys<P, PD>] extends [never]\n  ? ContextDecoratorWithDefaults<K, D, P, Ctx>\n  : ContextDecoratorRequiringParams<K, D, P, Ctx, PD>\n\n/**\n * Decorator whose params are fully defaulted (or which takes none).\n * Callable as a class or method decorator directly, as a factory, or\n * via `.with(params)` / `.registration` at non-decorator registration\n * sites.\n */\nexport interface ContextDecoratorWithDefaults<\n  K extends string = string,\n  D extends Record<string, DepValue> = Record<string, never>,\n  P extends Record<string, unknown> = Record<string, never>,\n  Ctx extends ExecutionContext = ExecutionContext,\n> {\n  /**\n   * Class decorator usage with `paramDefaults` — `@Foo class C {}`.\n   * The class constructor is a `Function`, so this overload only\n   * matches actual classes (not plain object literals — which\n   * fall through to the factory overload below).\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n  (target: Function): void\n  /**\n   * Method decorator usage with `paramDefaults` — `@Foo` over a\n   * method. The required `propertyKey` distinguishes this from the\n   * factory overload's single-object-arg call shape.\n   */\n  (target: object, propertyKey: string | symbol, descriptor?: PropertyDescriptor): void\n  /**\n   * Zero-arg factory usage — `@Foo()` returns a decorator with\n   * `paramDefaults` applied. Equivalent in behaviour to the bare\n   * `@Foo` form, exposed here so adopters who prefer \"always call the\n   * factory\" don't need an `as any` cast.\n   */\n  (): ContextDecoratorTarget\n  /**\n   * Factory usage — `@Foo({ ... })` returns the actual decorator with\n   * call-site params merged onto `paramDefaults`. Matches a single\n   * params object; plain objects don't satisfy the `Function` /\n   * 2-arg-minimum constraints above, so TS picks this overload.\n   *\n   * Accepts `Partial<P>` so adopters can override only the fields\n   * they care about — anything missing falls back to `paramDefaults`\n   * at runtime. Inside `resolve()`, `params` is the fully merged\n   * `P`, never a `Partial<P>`.\n   *\n   * The returned decorator is overloaded for class AND method usage —\n   * `@Foo({...}) class C {}` and `@Foo({...}) m() {}` both type-check.\n   */\n  (params: Partial<P>): ContextDecoratorTarget\n  /**\n   * Bare registration — uses `paramDefaults` only. Use this at non-\n   * decorator registration sites (module / adapter / bootstrap) when\n   * the call site doesn't need to override params.\n   */\n  readonly registration: ContributorRegistration<K, D, Ctx>\n  /**\n   * Build a registration with call-site params merged onto\n   * `paramDefaults`. Use this at non-decorator registration sites\n   * when the call site DOES want to override params:\n   *\n   * ```ts\n   * bootstrap({\n   *   contributors: [LoadTenant.with({ source: 'subdomain' }).registration],\n   * })\n   * ```\n   *\n   * `Partial<P>` for the same reason as the factory overload — the\n   * runtime merges with `paramDefaults`, so adopters only specify\n   * fields they want to override.\n   */\n  with(params: Partial<P>): { readonly registration: ContributorRegistration<K, D, Ctx> }\n}\n\n/**\n * Decorator with at least one required param that `paramDefaults`\n * doesn't cover. Deliberately narrower than\n * {@link ContextDecoratorWithDefaults}: the bare `@Foo` form, the\n * zero-arg `@Foo()` form, and the `.registration` accessor are all\n * absent, because none of them can supply the missing value.\n *\n * ```ts\n * const OperatorPerm = defineContextDecorator.withParams<{ action: string }>()({\n *   key: 'operatorPerm',\n *   resolve: (ctx, _deps, { action }) => check(ctx, action),\n * })\n *\n * class Ops {\n *   @OperatorPerm                     // ✗ compile error — `action` missing\n *   @Get('/a')\n *   a(ctx: RequestContext) {}\n *\n *   @OperatorPerm({ action: 'read' }) // ✓\n *   @Get('/b')\n *   b(ctx: RequestContext) {}\n * }\n * ```\n *\n * If you want the bare form back, give `action` a default in\n * `paramDefaults` — but only when the default is genuinely correct for\n * an undecorated route, which for a permission string it usually isn't.\n */\nexport interface ContextDecoratorRequiringParams<\n  K extends string = string,\n  D extends Record<string, DepValue> = Record<string, never>,\n  P extends Record<string, unknown> = Record<string, never>,\n  Ctx extends ExecutionContext = ExecutionContext,\n  PD = Partial<P>,\n> {\n  /**\n   * Factory usage — the only decorator form available here. The\n   * argument type carries every required field `paramDefaults` didn't\n   * provide, so omitting one is a compile error at this call site.\n   */\n  (params: CallSiteParams<P, PD>): ContextDecoratorTarget\n  /**\n   * Build a registration for non-decorator registration sites. Same\n   * required-field rule as the factory form.\n   */\n  with(params: CallSiteParams<P, PD>): {\n    readonly registration: ContributorRegistration<K, D, Ctx>\n  }\n}\n\n/**\n * Curried params-first helper for {@link defineContextDecorator}.\n *\n * Solves the partial-inference problem: TS generics are positional, so\n * the moment an adopter wants to specify the per-call params shape\n * `P`, they're forced to spell `K` and `D` by hand — losing the\n * automatic `deps` inference that drives the `(ctx, deps, params) =>`\n * resolver signature:\n *\n * ```ts\n * // ❌ Positional generics — must repeat the deps type, and `D` no\n * // longer flows from `spec.deps` into `resolve(ctx, deps, ...)`.\n * defineContextDecorator<'tenant', { repo: typeof TENANT_REPO }, MyParams>({\n *   key: 'tenant',\n *   deps: { repo: TENANT_REPO },\n *   resolve: (ctx, { repo }, params) => ...,\n * })\n *\n * // ✅ Curried form — only `P` is spelled; `K`, `D`, `Ctx` infer.\n * defineContextDecorator.withParams<MyParams>()({\n *   key: 'tenant',\n *   deps: { repo: TENANT_REPO },     // D inferred\n *   resolve: (ctx, { repo }, params) => ..., // deps + params both typed\n * })\n * ```\n *\n * Use this whenever the contributor takes call-site params; use the\n * positional form when there are no params (the common case).\n */\nexport interface DefineContextDecoratorWithParams<P extends Record<string, unknown>> {\n  <\n    K extends string,\n    D extends Record<string, DepValue> = Record<string, never>,\n    Ctx extends ExecutionContext = ExecutionContext,\n    // Inferred from `spec.paramDefaults`. The `Record<never, never>`\n    // default (NOT `Partial<P>`) is what makes an omitted `paramDefaults`\n    // mean \"nothing is defaulted\" — so every required field of `P` lands\n    // on the call site. `Partial<P>` here would make `keyof PD` cover all\n    // of `P` and silently defeat the whole check.\n    PD extends Partial<P> = Record<never, never>,\n  >(\n    spec: ContextDecoratorSpec<K, D, P, Ctx, PD>,\n  ): ContextDecorator<K, D, P, Ctx, PD>\n}\n\n/**\n * The public shape of {@link defineContextDecorator}. Combines the\n * original positional-generic call signature with the curried\n * `.withParams<P>()` helper that fixes partial-inference for the\n * parameterised case.\n */\nexport interface DefineContextDecoratorFn {\n  <\n    K extends string,\n    D extends Record<string, DepValue> = Record<string, never>,\n    P extends Record<string, unknown> = Record<string, never>,\n    Ctx extends ExecutionContext = ExecutionContext,\n    PD extends Partial<P> = Record<never, never>,\n  >(\n    spec: ContextDecoratorSpec<K, D, P, Ctx, PD>,\n  ): ContextDecorator<K, D, P, Ctx, PD>\n\n  /**\n   * Curried entry point. Spell only the per-call params shape `P`;\n   * `K`, `D`, and `Ctx` are inferred from the spec passed to the\n   * returned function. See {@link DefineContextDecoratorWithParams}\n   * for the rationale.\n   */\n  withParams<P extends Record<string, unknown>>(): DefineContextDecoratorWithParams<P>\n}\n\n/**\n * Define a typed context contributor.\n *\n * The returned function works as a method or class decorator:\n *\n * ```ts\n * const LoadTenant = defineContextDecorator({\n *   key: 'tenant',\n *   deps: { tenants: TenantsRepo },\n *   resolve: (ctx, { tenants }) => tenants.findByHost(ctx.requestId),\n * })\n *\n * @LoadTenant\n * @Get('/me')\n * me(ctx: RequestContext) {\n *   ctx.get('tenant')   // typed via ContextMeta\n * }\n * ```\n *\n * For non-decorator registration (module/adapter/bootstrap), pass\n * `LoadTenant.registration` into the appropriate contributors list.\n *\n * Boot-time validation: a missing `resolve`, an empty `key`, or a\n * non-array `dependsOn` throws `TypeError` here at definition time\n * (typically module-load) rather than waiting for the first request.\n * See `architecture.md` §20 for the full pipeline plan.\n *\n * **Parameterised contributors:** TS generics are positional, so to\n * specify `P` (the per-call params shape) with this signature you\n * also have to spell `K` and `D` — which loses automatic `deps`\n * inference. Use {@link DefineContextDecoratorFn.withParams} instead:\n * `defineContextDecorator.withParams<MyParams>()(spec)`.\n */\nfunction defineContextDecoratorImpl<\n  K extends string,\n  D extends Record<string, DepValue> = Record<string, never>,\n  P extends Record<string, unknown> = Record<string, never>,\n  Ctx extends ExecutionContext = ExecutionContext,\n  PD extends Partial<P> = Record<never, never>,\n>(spec: ContextDecoratorSpec<K, D, P, Ctx, PD>): ContextDecorator<K, D, P, Ctx, PD> {\n  // ---- Boot-time validation --------------------------------------\n  // Surface mistakes the moment `defineContextDecorator` is called\n  // (typically module-load time) instead of letting them ride to\n  // request time as cryptic ContextMeta misses or container failures.\n  // Cheap, ~15 lines, catches a whole class of definition-time bugs.\n  if (spec === null || typeof spec !== 'object') {\n    throw new TypeError(\n      'defineContextDecorator: spec must be an object literal. ' +\n        'See architecture.md §20.4 for the spec shape.',\n    )\n  }\n  if (typeof spec.key !== 'string' || spec.key.length === 0) {\n    const got = typeof spec.key === 'string' ? '\"\"' : typeof spec.key\n    throw new TypeError(\n      `defineContextDecorator: spec.key must be a non-empty string (got ${got}). ` +\n        'Pick a name that matches a key declared on `ContextMeta` (or one of the framework keys).',\n    )\n  }\n  if (typeof spec.resolve !== 'function') {\n    throw new TypeError(\n      `defineContextDecorator(${spec.key}): spec.resolve is required and must be a function ` +\n        `(got ${typeof spec.resolve}). Each contributor needs a resolver that produces ` +\n        `the value to write into ctx.set(${JSON.stringify(spec.key)}, …).`,\n    )\n  }\n  if (spec.onError !== undefined && typeof spec.onError !== 'function') {\n    throw new TypeError(\n      `defineContextDecorator(${spec.key}): spec.onError must be a function when provided ` +\n        `(got ${typeof spec.onError}).`,\n    )\n  }\n  if (spec.dependsOn !== undefined && !Array.isArray(spec.dependsOn)) {\n    throw new TypeError(\n      `defineContextDecorator(${spec.key}): spec.dependsOn must be an array when provided ` +\n        `(got ${typeof spec.dependsOn}).`,\n    )\n  }\n  if (spec.requiredParams !== undefined && !Array.isArray(spec.requiredParams)) {\n    throw new TypeError(\n      `defineContextDecorator(${spec.key}): spec.requiredParams must be an array when provided ` +\n        `(got ${typeof spec.requiredParams}).`,\n    )\n  }\n  if (\n    Array.isArray(spec.requiredParams) &&\n    spec.requiredParams.some((p) => typeof p !== 'string' || p.length === 0)\n  ) {\n    throw new TypeError(\n      `defineContextDecorator(${spec.key}): spec.requiredParams entries must be non-empty strings.`,\n    )\n  }\n  if (\n    Array.isArray(spec.dependsOn) &&\n    spec.dependsOn.some((dep) => typeof dep !== 'string' || dep.length === 0)\n  ) {\n    // TS narrows dependsOn to `readonly ContextMetaKey[]` for typed\n    // adopters, but JS callers (and TS callers who erase via `as any`)\n    // can still slip through with `[42]` or `['']`. Surface it at\n    // definition time as a TypeError instead of riding to first\n    // request as a `MissingContributorError` on a phantom key.\n    throw new TypeError(\n      `defineContextDecorator(${spec.key}): spec.dependsOn entries must be non-empty strings.`,\n    )\n  }\n\n  // Source-location capture. `new Error().stack` here records the\n  // adopter's call site so boot-time errors (cycles, missing deps,\n  // duplicate keys) can point at the file that declared the broken\n  // decorator. Bad boot errors are why frameworks get abandoned —\n  // a single stack frame turns \"what's a 'tenent'?\" into \"edit\n  // src/contributors/tenant.ts line 42\".\n  const definedAt = new Error().stack\n\n  // Snapshot + freeze paramDefaults so callers can't mutate the spec\n  // object post-definition and shift the merged params under our feet.\n  // Same immutability boundary applied to `deps` and `dependsOn`.\n  const defaults = Object.freeze({\n    ...(spec.paramDefaults ?? ({} as Partial<P>)),\n  }) as Readonly<Partial<P>>\n\n  // Shared deps + dependsOn — frozen once and reused across every\n  // registration produced by this decorator (one per call site).\n  // `Object.freeze` is shallow — the values inside (DI tokens,\n  // constructors) are intentionally untouched; freezing them would\n  // prevent the container from doing legitimate per-instance\n  // bookkeeping.\n  //\n  // The `({} as D)` cast: `spec.deps` is optional (`deps?: D`), so\n  // the fallback to `{}` is required. When `D` defaults to\n  // `Record<string, never>`, the cast is sound (`{}` matches). When\n  // `D` is non-empty AND adopter omitted `deps`, the cast is unsound\n  // — but the runner errors loudly the moment it tries to resolve a\n  // missing dep, so the mistake surfaces at first request rather\n  // than producing wrong-but-silent behaviour. The alternative\n  // (forcing `deps` non-optional in the spec) would break ergonomics\n  // for the common zero-deps case.\n  const sharedDeps = Object.freeze({ ...(spec.deps ?? ({} as D)) }) as D\n  const sharedDependsOn = Object.freeze([...(spec.dependsOn ?? [])])\n  const sharedOptional = spec.optional ?? false\n\n  /**\n   * Build a frozen registration that closes over a specific\n   * resolved-params object. The runner sees a normal\n   * `(ctx, deps) => value` registration — params are baked into the\n   * closure, invisible to the pipeline.\n   */\n  const buildRegistration = (params: P): ContributorRegistration<K, D, Ctx> => {\n    // Shallow-freeze the captured params so a misbehaving `resolve()` /\n    // `onError()` can't mutate the closure and bleed into later\n    // requests through the same registration. Adopters who really need\n    // mutable per-request state should write to `ctx.set(...)` from\n    // inside the resolver instead of mutating params.\n    const frozenParams = Object.freeze({ ...params }) as P\n    const onError: ContributorRegistration<K, D, Ctx>['onError'] = spec.onError\n      ? (err: unknown, ctx: Ctx) => spec.onError!(err, ctx, frozenParams)\n      : undefined\n    const resolve: ContributorRegistration<K, D, Ctx>['resolve'] = (\n      ctx: Ctx,\n      deps: ResolvedDeps<D>,\n    ) => spec.resolve(ctx, deps, frozenParams)\n    return Object.freeze({\n      key: spec.key,\n      deps: sharedDeps,\n      dependsOn: sharedDependsOn,\n      optional: sharedOptional,\n      onError,\n      resolve,\n      definedAt,\n    })\n  }\n\n  // Default-params registration — used for zero-arg decorator\n  // applications and for the `.registration` accessor. Cloning\n  // `defaults` so the closure can't be mutated through the spec.\n  const defaultRegistration = buildRegistration({ ...defaults } as P)\n\n  /**\n   * Decide whether the decorator was called as a decorator\n   * (`@Foo` / `@Foo(target, key)`) or as a factory\n   * (`@Foo()` / `@Foo({...})`).\n   *\n   * - Class decorator: `(target)` where target is a constructor function.\n   * - Method decorator: `(target, propertyKey, descriptor?)` where\n   *   target is a prototype object and propertyKey is a string/symbol.\n   * - Factory (defaults): `()` — adopter wrote `@Foo()` (rare; usually\n   *   they write the bare `@Foo`). Returns a decorator using\n   *   `paramDefaults`.\n   * - Factory (params): `(params)` where params is a plain object.\n   *\n   * The legacy decorators that ship with KickJS (`@Get('/path')`,\n   * `@Cron('* * * *')`, etc.) use the same heuristic, so adopters\n   * already know to pass plain object literals as factory args.\n   */\n  const isDecoratorCall = (args: unknown[]): boolean => {\n    // Zero args is a factory call (`@Foo()`), not a direct decorator\n    // application — TS never invokes a decorator with zero args.\n    if (args.length === 0) return false\n    if (args.length >= 2) return true\n    const first = args[0]\n    // Functions are class constructors at decoration time.\n    if (typeof first === 'function') return true\n    // Anything else (plain object, undefined, primitive) → factory call.\n    return false\n  }\n\n  const applyAsDecorator = (\n    registration: ContributorRegistration<K, D, Ctx>,\n    target: object,\n    propertyKey?: string | symbol,\n  ): void => {\n    if (propertyKey === undefined) {\n      // Class decorator — `target` is the constructor.\n      pushClassMeta(METADATA.CLASS_CONTRIBUTORS, target, registration)\n    } else {\n      // Method decorator — `target` is the prototype; we write to its\n      // constructor so reads can use the controller class as the\n      // lookup key, matching the convention used by @Middleware and\n      // consumed by router-builder.ts.\n      const constructor = (target as { constructor: object }).constructor\n      pushMethodMeta(METADATA.METHOD_CONTRIBUTORS, constructor, String(propertyKey), registration)\n    }\n  }\n\n  /**\n   * `true` for `{...}` and `Object.create(null)`. Rejects every\n   * built-in subclass (Map / Set / Date / Error / RegExp / Promise),\n   * adopter classes, and arrays.\n   */\n  const isPlainObject = (value: object): boolean => {\n    const proto = Object.getPrototypeOf(value)\n    return proto === Object.prototype || proto === null\n  }\n\n  /**\n   * Merge call-site `Partial<P>` over `paramDefaults`. Strict guard:\n   * accepts only **plain object literals** (or `Object.create(null)`).\n   * Reject everything else with a descriptive `TypeError`.\n   *\n   * Why strict? Object spread copies enumerable own properties only.\n   * `{ ...new Date() }` and `{ ...new Map([...])}` both produce `{}`\n   * — the params silently drop. Catching this at the boundary\n   * surfaces the mistake instead of routing the request with empty\n   * config. Adopters who genuinely need a class-instance shape can\n   * destructure it themselves: `Foo({ ...new MyParams() })`.\n   */\n  const mergeParams = (override: unknown): P => {\n    if (override === undefined) return { ...defaults } as P\n    if (\n      override === null ||\n      typeof override !== 'object' ||\n      Array.isArray(override) ||\n      !isPlainObject(override)\n    ) {\n      const got =\n        override === null\n          ? 'null'\n          : Array.isArray(override)\n            ? 'array'\n            : typeof override === 'object'\n              ? `instance of ${(override as object).constructor?.name ?? 'unknown class'}`\n              : typeof override\n      throw new TypeError(\n        `defineContextDecorator(${spec.key}): factory call requires a plain object literal, got ${got}. ` +\n          `Class instances and built-ins (Map, Date, etc) silently spread to empty objects — ` +\n          `call the decorator with a spread object literal instead, e.g. ` +\n          `\\`MyDecorator({ ...someInstance })\\`.`,\n      )\n    }\n    return { ...defaults, ...(override as Partial<P>) } as P\n  }\n\n  const sharedRequiredParams = Object.freeze([...(spec.requiredParams ?? [])])\n\n  /**\n   * Runtime half of the required-params guarantee. The type system\n   * already stops TS call sites from omitting a required field, so this\n   * catches what types can't see: plain-JS adopters, `as any`, and\n   * params built dynamically.\n   *\n   * `usage` names the form that failed so the message points at the fix\n   * — a bare `@Foo` on a decorator with required params needs to become\n   * `@Foo({ ... })`, which is a different edit from a factory call that\n   * merely forgot one field.\n   */\n  const assertRequiredParams = (params: P, usage: string): void => {\n    if (sharedRequiredParams.length === 0) return\n    const missing = sharedRequiredParams.filter(\n      (name) => (params as Record<string, unknown>)[name] === undefined,\n    )\n    if (missing.length === 0) return\n    throw new TypeError(\n      `defineContextDecorator(${spec.key}): ${usage} is missing required param(s) ` +\n        `${missing.map((m) => `'${m}'`).join(', ')}. ` +\n        `Supply them at the call site — e.g. \\`@${spec.key}({ ${missing[0]}: … })\\` — or ` +\n        `add a default in \\`paramDefaults\\` if one is genuinely correct for every route.`,\n    )\n  }\n\n  // Overloaded function signatures so `decoratorOrFactory`'s type\n  // matches `ContextDecorator`'s call shapes directly — no\n  // `as unknown as` double-cast needed. The implementation signature\n  // (`...args: unknown[]`) is hidden from callers; only the four\n  // declared overloads are reachable.\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n  function decoratorOrFactory(target: Function): void\n  function decoratorOrFactory(\n    target: object,\n    propertyKey: string | symbol,\n    descriptor?: PropertyDescriptor,\n  ): void\n  function decoratorOrFactory(): ContextDecoratorTarget\n  function decoratorOrFactory(params: Partial<P>): ContextDecoratorTarget\n  function decoratorOrFactory(...args: unknown[]): unknown {\n    if (isDecoratorCall(args)) {\n      const [target, propertyKey] = args as [\n        object,\n        string | symbol | undefined,\n        PropertyDescriptor?,\n      ]\n      // Bare `@Foo` — nothing can supply params here, so a required one\n      // that isn't defaulted is a decoration-time (module-load) failure\n      // rather than an undefined riding into the resolver.\n      assertRequiredParams({ ...defaults } as P, 'bare `@decorator` usage')\n      applyAsDecorator(defaultRegistration, target, propertyKey)\n      return undefined\n    }\n    // Factory call — capture merged params and return a decorator.\n    const params = mergeParams(args[0])\n    assertRequiredParams(params, 'factory call')\n    const registration = buildRegistration(params)\n    return (target: object, propertyKey?: string | symbol) => {\n      applyAsDecorator(registration, target, propertyKey)\n    }\n  }\n\n  // Set a meaningful `.name` so `console.log(LoadTenant)` and stack\n  // traces show `[Function: ContextDecorator(tenant)]` instead of\n  // `[Function: decoratorOrFactory]`. Function.name is configurable\n  // by default, so this works on the existing function reference.\n  Object.defineProperty(decoratorOrFactory, 'name', {\n    value: `ContextDecorator(${spec.key})`,\n    writable: false,\n    enumerable: false,\n    configurable: true,\n  })\n\n  // `Object.assign` returns the intersection type, so the decorator\n  // gets `.registration` + `.with` properties typed without the\n  // previous `as unknown as ContextDecorator<...>` double cast.\n  // Properties go on via assign (writable + enumerable defaults),\n  // then `Object.freeze` locks the shape so adopters can't mutate\n  // `decorator.registration = …` post-construction.\n  const decorator = Object.assign(decoratorOrFactory, {\n    with: (params: Partial<P>) => {\n      const merged = mergeParams(params)\n      assertRequiredParams(merged, '`.with()`')\n      return { registration: buildRegistration(merged) }\n    },\n  })\n\n  // `.registration` is a getter, not a plain property, so that reading it\n  // on a decorator with undefaulted required params throws instead of\n  // handing back a registration whose resolver will see `undefined`.\n  // (`Object.assign` would have copied the value and lost the check.)\n  Object.defineProperty(decorator, 'registration', {\n    get() {\n      assertRequiredParams({ ...defaults } as P, '`.registration`')\n      return defaultRegistration\n    },\n    enumerable: true,\n    configurable: false,\n  })\n\n  // `ContextDecorator` is a conditional type (permissive vs required-params\n  // shape), and TS can't evaluate a conditional whose input generics are\n  // still unresolved — so the assignment can't be checked structurally\n  // here regardless of how `decorator` is built. The cast is the price of\n  // the call-site guarantee; the two branches differ only in which call\n  // forms they expose, and every one of them is implemented above.\n  return Object.freeze(decorator) as unknown as ContextDecorator<K, D, P, Ctx, PD>\n}\n\n/**\n * Public export — the positional-generic implementation plus the\n * curried `.withParams<P>()` helper attached as a method. Adopters\n * pick whichever form fits the call site:\n *\n * - **Positional** — `defineContextDecorator(spec)` when there are\n *   no per-call params (the common case). `K`, `D`, `Ctx` infer.\n * - **Curried** — `defineContextDecorator.withParams<P>()(spec)`\n *   when the contributor takes params; spell only `P`, the rest\n *   still infer.\n *\n * Frozen so adopters can't reassign `.withParams` at runtime.\n */\nexport const defineContextDecorator: DefineContextDecoratorFn = Object.freeze(\n  Object.assign(defineContextDecoratorImpl, {\n    withParams: <P extends Record<string, unknown>>(): DefineContextDecoratorWithParams<P> => {\n      return <\n        K extends string,\n        D extends Record<string, DepValue> = Record<string, never>,\n        Ctx extends ExecutionContext = ExecutionContext,\n        PD extends Partial<P> = Record<never, never>,\n      >(\n        spec: ContextDecoratorSpec<K, D, P, Ctx, PD>,\n      ): ContextDecorator<K, D, P, Ctx, PD> => defineContextDecoratorImpl<K, D, P, Ctx, PD>(spec)\n    },\n  }),\n) as DefineContextDecoratorFn\n","// Shared asset-key strategy — used by the build pipeline, the\n// runtime dev resolver, and the typegen emitter so all three layers\n// agree on what the manifest looks like.\n//\n// Three strategies:\n//\n//   - `'strip'` — drop the final extension. `pages/index.pug` →\n//     `pages/index`. Best for namespaces where every basename is\n//     unique (mail templates, pdf invoices). Shortest autocomplete.\n//\n//   - `'with-extension'` — keep the extension. `pages/index.pug` →\n//     `pages/index.pug`. Required when extension siblings coexist.\n//\n//   - `'auto'` (default) — strip when safe, keep extensions when not.\n//     The grouping pass collects files by stripped basename; groups\n//     of one keep the stripped key, groups of more than one keep the\n//     full path. Backward compatible for projects with no\n//     extension-siblings; lossless for projects that have them.\n//\n// The function returns the path / key pairs in walk order (input\n// order preserved) so callers can iterate without re-sorting. Sort\n// in the caller if a stable manifest order is needed.\n\nexport type AssetKeyStrategy = 'auto' | 'strip' | 'with-extension'\n\nexport interface AssetKeyPair {\n  /** Source-relative path the file was discovered at. */\n  rel: string\n  /** Final logical key for the manifest, including the namespace prefix. */\n  key: string\n}\n\nexport interface GroupAssetKeysOptions {\n  /**\n   * Strategy applied to this namespace. Default `'auto'`.\n   *\n   * Adopters override per-namespace via `assetMap.<ns>.keys` in\n   * kick.config.ts when they want uniform behaviour (e.g. always\n   * include the extension regardless of collisions).\n   */\n  strategy?: AssetKeyStrategy\n}\n\nexport interface GroupAssetKeysResult {\n  pairs: AssetKeyPair[]\n  /**\n   * Number of collision groups resolved by keeping extensions.\n   * Surfaces as an informational log (\"auto-resolved N collisions\")\n   * so adopters know whether they're relying on auto-mode or not.\n   * Always 0 for `'strip'` (overwrites) and `'with-extension'`\n   * (extensions always preserved, no collision possible).\n   */\n  collisionGroupsResolved: number\n}\n\n/**\n * Compute final manifest keys for a namespace's discovered paths,\n * given the chosen strategy. Pure function — no fs / config / globals\n * involved.\n *\n * @param namespace assetMap key — e.g. `'mails'`, `'pages'`.\n * @param paths source-relative file paths (POSIX separators) discovered\n *              under the namespace's `src` directory.\n * @param opts grouping options.\n */\nexport function groupAssetKeys(\n  namespace: string,\n  paths: readonly string[],\n  opts: GroupAssetKeysOptions = {},\n): GroupAssetKeysResult {\n  const strategy = opts.strategy ?? 'auto'\n\n  if (strategy === 'with-extension') {\n    return {\n      pairs: paths.map((rel) => ({ rel, key: `${namespace}/${rel}` })),\n      collisionGroupsResolved: 0,\n    }\n  }\n\n  if (strategy === 'strip') {\n    // Strict strip — last-walk-order wins on collision; no\n    // collision tracking here because the docs document this as the\n    // adopter's choice. The caller (build / runtime / typegen) can\n    // still warn if it wants; this function just shapes keys.\n    return {\n      pairs: paths.map((rel) => ({ rel, key: `${namespace}/${stripExt(rel)}` })),\n      collisionGroupsResolved: 0,\n    }\n  }\n\n  // strategy === 'auto' — group by stripped basename, keep\n  // extensions only on collision groups.\n  const groups = new Map<string, string[]>()\n  for (const rel of paths) {\n    const strippedKey = `${namespace}/${stripExt(rel)}`\n    const arr = groups.get(strippedKey)\n    if (arr) {\n      arr.push(rel)\n    } else {\n      groups.set(strippedKey, [rel])\n    }\n  }\n\n  let collisionGroupsResolved = 0\n  // Build a per-rel decision table so we preserve input ordering in\n  // the output (manifest writers rely on stable ordering).\n  const keyByRel = new Map<string, string>()\n  for (const [strippedKey, rels] of groups) {\n    if (rels.length === 1) {\n      keyByRel.set(rels[0], strippedKey)\n    } else {\n      collisionGroupsResolved += 1\n      for (const rel of rels) {\n        keyByRel.set(rel, `${namespace}/${rel}`)\n      }\n    }\n  }\n\n  return {\n    pairs: paths.map((rel) => ({\n      rel,\n      key: keyByRel.get(rel) ?? `${namespace}/${rel}`,\n    })),\n    collisionGroupsResolved,\n  }\n}\n\n/** Strip the final extension from a path. `'mails/welcome.ejs'` → `'mails/welcome'`. */\nexport function stripExt(path: string): string {\n  // Inline the logic instead of importing extname so this module\n  // stays usable in pure-browser contexts. Same algorithm: find the\n  // last dot AFTER the last separator, slice up to it.\n  const lastSlash = path.lastIndexOf('/')\n  const filename = lastSlash >= 0 ? path.slice(lastSlash + 1) : path\n  const lastDot = filename.lastIndexOf('.')\n  if (lastDot <= 0) return path // no ext, or hidden file like `.env`\n  const dirPart = lastSlash >= 0 ? path.slice(0, lastSlash + 1) : ''\n  return dirPart + filename.slice(0, lastDot)\n}\n","/**\n * Asset manager runtime (assets-plan.md PR 3).\n *\n * Three accessor surfaces over one resolver engine:\n *\n * - `assets.x.y()`        — Proxy ambient, autocomplete-friendly default.\n * - `useAssets()`         — hook returning the same Proxy; mockable per-call.\n * - `resolveAsset(ns, k)` — string resolver for dynamic dispatch.\n *\n * Resolution path:\n *\n * 1. Load the build-time manifest (`<outDir>/.kickjs-assets.json`)\n *    when present. Manifest existence = \"we're running from a built\n *    dist\". Fast path; mapped paths returned verbatim.\n * 2. Otherwise (dev / test) walk the assetMap src directories from\n *    `kick.config.{json,js,cjs}` and synthesise the same manifest\n *    shape in memory. First call pays the walk cost; subsequent\n *    calls hit the cache.\n * 3. `KICK_ASSETS_ROOT` env var overrides everything — the resolver\n *    treats the path as the manifest directory and skips discovery.\n *\n * @module @forinda/kickjs/core/assets\n */\n\nimport { existsSync, readFileSync, readdirSync } from 'node:fs'\nimport { isAbsolute, join, resolve, sep } from 'node:path'\nimport { createToken, type InjectionToken } from './token'\nimport { groupAssetKeys } from './asset-keys'\n\nexport const ASSET_MANIFEST_VERSION = 1 as const\n\ninterface AssetManifest {\n  version: typeof ASSET_MANIFEST_VERSION\n  entries: Record<string, string>\n}\n\ninterface ResolvedManifest {\n  manifest: AssetManifest\n  root: string\n}\n\n/**\n * Augmentable interface — `kick typegen` (assets-plan.md PR 4) emits\n * a `declare global` augmentation listing every namespace + key for\n * the project's `assetMap`. Adopters who haven't run typegen yet\n * still get a runtime-correct Proxy; only typed autocomplete waits\n * on the augmentation.\n */\nexport interface KickAssets {}\n\n/**\n * DI token for the `assets` Proxy. Adopter code that wants to\n * receive assets via constructor injection registers via\n * `container.registerInstance(ASSETS, useAssets())` in `bootstrap()`\n * and injects with `@Inject(ASSETS)`.\n */\nexport const ASSETS: InjectionToken<KickAssets> = createToken<KickAssets>('kick/assets/Map')\n\nexport class UnknownAssetError extends Error {\n  readonly namespace: string\n  readonly key: string\n  constructor(namespace: string, key: string) {\n    super(\n      `Unknown asset '${namespace}/${key}'. ` +\n        `Make sure the namespace exists in kick.config.ts assetMap and that the file is present in the source directory.`,\n    )\n    this.name = 'UnknownAssetError'\n    this.namespace = namespace\n    this.key = key\n  }\n}\n\nlet manifestCache: ResolvedManifest | null | undefined = undefined\n\n/**\n * Convert a filesystem path to its posix (forward-slash) form. The\n * asset manifest and the public `resolveAsset` / `assets.x.y()` /\n * `useAssets()` contract returns posix paths on every platform so\n * adopters can:\n *\n * - pass the result to `express.static` / `res.sendFile` / `ejs.renderFile`\n *   without worrying about Windows vs. posix separators\n * - splice the path into URLs (`href`, `src`, CDN keys) without\n *   replacing `\\` with `/` by hand\n * - compare two paths from `resolveAsset` for equality on any host\n *\n * Node's `fs.*` and Express's path-handling APIs accept either\n * separator on Windows, so this normalisation is safe — the only\n * adopter code it could break is something explicitly parsing\n * Windows backslashes back out of the result, which would already be\n * brittle.\n */\nfunction toPosixPath(p: string): string {\n  return p.replaceAll('\\\\', '/')\n}\n\nexport function resolveAsset(namespace: string, key: string): string {\n  const resolved = loadManifest()\n  if (!resolved) {\n    throw new UnknownAssetError(namespace, key)\n  }\n  const entry = resolved.manifest.entries[`${namespace}/${key}`]\n  if (!entry) {\n    throw new UnknownAssetError(namespace, key)\n  }\n  const abs = isAbsolute(entry) ? entry : resolve(resolved.root, entry)\n  return toPosixPath(abs)\n}\n\n/** Reset the manifest cache. Tests use this; production code shouldn't need it. */\nexport function clearAssetCache(): void {\n  manifestCache = undefined\n}\n\nfunction loadManifest(): ResolvedManifest | null {\n  // In development we deliberately skip the cache so adding or removing\n  // a template file (e.g. dropping `welcome-back.ejs` into\n  // `src/templates/mails/`) takes effect without a server restart. The\n  // synthesise-dev-manifest path walks ~10 files; the cost is negligible\n  // compared to the user-visible surprise of \"I added a file but\n  // assets.x.y() throws\". Production keeps the cache because the built\n  // manifest under `dist/.kickjs-assets.json` doesn't change at runtime.\n  if (process.env.NODE_ENV !== 'production') {\n    return discoverManifest()\n  }\n  if (manifestCache !== undefined) return manifestCache\n  manifestCache = discoverManifest()\n  return manifestCache\n}\n\nfunction discoverManifest(): ResolvedManifest | null {\n  // `KICK_ASSETS_ROOT` is an explicit, deliberate override — it wins in\n  // both dev and prod.\n  const envRoot = process.env.KICK_ASSETS_ROOT\n  if (envRoot) {\n    const fromEnv = readBuiltManifest(envRoot)\n    if (fromEnv) return fromEnv\n  }\n\n  const cwd = process.cwd()\n  const config = loadConfigSync(cwd)\n\n  // In dev, prefer a live walk of the source tree over any built\n  // manifest left on disk by an earlier `kick build`. Otherwise a stale\n  // `dist/.kickjs-assets.json` shadows the live `src/` tree: a freshly\n  // added template file would resolve to the old map (or throw\n  // UnknownAssetError) until the next rebuild — exactly the surprise the\n  // cache-skip in `loadManifest` exists to avoid. `synthesiseDevManifest`\n  // returns null only when there's no `assetMap` config at all, in which\n  // case we fall through to the built-manifest probes below.\n  if (process.env.NODE_ENV !== 'production') {\n    const fresh = synthesiseDevManifest(cwd, config)\n    if (fresh) return fresh\n  }\n\n  // Honour `kick.config.build.outDir` BEFORE the standard probe list\n  // so adopters with non-default Vite outputs (e.g. `output/`,\n  // `target/`, anything else) don't have to set KICK_ASSETS_ROOT\n  // every time. Cached config load — same loader the dev fallback\n  // uses. Skip when outDir matches one of the standard candidates;\n  // it'd be probed redundantly otherwise.\n  const configOutDir = config?.build?.outDir\n  if (configOutDir && !(STANDARD_OUT_DIRS as readonly string[]).includes(configOutDir)) {\n    const found = readBuiltManifest(resolve(cwd, configOutDir))\n    if (found) return found\n  }\n\n  for (const candidate of STANDARD_OUT_DIRS) {\n    const found = readBuiltManifest(join(cwd, candidate))\n    if (found) return found\n  }\n\n  return synthesiseDevManifest(cwd, config)\n}\n\nconst STANDARD_OUT_DIRS = ['dist', 'build', 'out'] as const\n\nfunction readBuiltManifest(dir: string): ResolvedManifest | null {\n  const path = join(dir, '.kickjs-assets.json')\n  if (!existsSync(path)) return null\n  try {\n    const raw = readFileSync(path, 'utf-8')\n    const parsed = JSON.parse(raw) as Partial<AssetManifest>\n    if (parsed.version !== ASSET_MANIFEST_VERSION) return null\n    if (!parsed.entries || typeof parsed.entries !== 'object') return null\n    return { manifest: parsed as AssetManifest, root: resolve(dir) }\n  } catch {\n    return null\n  }\n}\n\ninterface AssetMapConfigShape {\n  assetMap?: Record<\n    string,\n    {\n      src: string\n      dest?: string\n      glob?: string\n      keys?: 'auto' | 'strip' | 'with-extension'\n    }\n  >\n  build?: { outDir?: string }\n}\n\nfunction synthesiseDevManifest(\n  cwd: string,\n  preloadedConfig?: AssetMapConfigShape | null,\n): ResolvedManifest | null {\n  const config = preloadedConfig === undefined ? loadConfigSync(cwd) : preloadedConfig\n  if (!config?.assetMap) return null\n\n  const entries: Record<string, string> = {}\n  // Walk order is filesystem-dependent on Linux/macOS, so we collect\n  // every match per-namespace first, then sort + feed `groupAssetKeys`\n  // for stable manifest output. Build pipeline does the same — both\n  // layers agree on the resulting key set.\n  for (const [namespace, entry] of Object.entries(config.assetMap)) {\n    if (!entry || typeof entry.src !== 'string') continue\n    const srcAbs = resolve(cwd, entry.src)\n    if (!existsSync(srcAbs)) continue\n\n    const collected: Array<{ rel: string; abs: string }> = []\n    walkSync(srcAbs, srcAbs, (relPath, absPath) => {\n      if (entry.glob && !matchesGlobLite(relPath, entry.glob, namespace)) return\n      collected.push({ rel: relPath, abs: absPath })\n    })\n    collected.sort((a, b) => a.rel.localeCompare(b.rel))\n\n    const { pairs, collisionGroupsResolved } = groupAssetKeys(\n      namespace,\n      collected.map((c) => c.rel),\n      { strategy: entry.keys ?? 'auto' },\n    )\n    const absByRel = new Map(collected.map((c) => [c.rel, c.abs]))\n    for (const { rel, key } of pairs) {\n      const abs = absByRel.get(rel)\n      if (abs) entries[key] = abs\n    }\n    if (collisionGroupsResolved > 0 && process.env.NODE_ENV !== 'production') {\n      // Dev-only nudge — production runs read the build manifest where\n      // the collision was already resolved at build time.\n      console.log(\n        `[kickjs/assets] '${namespace}': ${collisionGroupsResolved} basename collision(s) auto-resolved by keeping extensions ` +\n          `(set assetMap.${namespace}.keys to 'strip' or 'with-extension' to override).`,\n      )\n    }\n  }\n\n  return { manifest: { version: ASSET_MANIFEST_VERSION, entries }, root: cwd }\n}\n\nconst warnedGlobs = new Set<string>()\n\n/**\n * Tiny glob matcher used only by dev manifest synthesis. Covers the\n * common assetMap glob patterns (`**\\/*`, `**\\/*.ext`,\n * `**\\/*.{a,b}`). Anything exotic prints a one-time warning + falls\n * through to `**\\/*` semantics rather than silently dropping files.\n *\n * The build pipeline (`packages/cli/src/asset-manager/build.ts`) uses\n * the full `glob` package; adopters who hit the dev-mode warning\n * should run `kick build:assets` to produce a real manifest.\n */\nfunction matchesGlobLite(relPath: string, pattern: string, namespace: string): boolean {\n  if (pattern === '**/*' || pattern === '**') return true\n  const singleExt = /^\\*\\*\\/\\*\\.(\\w+)$/.exec(pattern)\n  if (singleExt) return relPath.endsWith(`.${singleExt[1]}`)\n  const braceExt = /^\\*\\*\\/\\*\\.\\{([^}]+)\\}$/.exec(pattern)\n  if (braceExt) {\n    const exts = braceExt[1].split(',').map((e) => e.trim())\n    return exts.some((ext) => relPath.endsWith(`.${ext}`))\n  }\n  const tag = `${namespace}::${pattern}`\n  if (!warnedGlobs.has(tag)) {\n    warnedGlobs.add(tag)\n    console.warn(\n      `[kickjs/assets] Dev-mode glob '${pattern}' on '${namespace}' isn't recognised by the lite matcher. ` +\n        `Falling back to '**/*'. Run 'kick build:assets' to use the full glob engine.`,\n    )\n  }\n  return true\n}\n\nfunction walkSync(root: string, dir: string, onFile: (rel: string, abs: string) => void): void {\n  let entries\n  try {\n    entries = readdirSync(dir, { withFileTypes: true })\n  } catch {\n    return\n  }\n  for (const entry of entries) {\n    if (entry.name === 'node_modules' || entry.name.startsWith('.')) continue\n    const full = join(dir, entry.name)\n    if (entry.isDirectory()) {\n      walkSync(root, full, onFile)\n    } else if (entry.isFile()) {\n      const rel = full\n        .slice(root.length + 1)\n        .split(sep)\n        .join('/')\n      onFile(rel, full)\n    }\n  }\n}\n\n/**\n * Sync `kick.config.{json,cjs,js}` loader for dev manifest\n * synthesis. Avoids dynamic `import()` (would force every assets\n * lookup to be async). TypeScript configs (`kick.config.ts`) are\n * skipped here — adopters who use them should run `kick build:assets`\n * to produce a real manifest the resolver can read.\n */\nfunction loadConfigSync(cwd: string): AssetMapConfigShape | null {\n  const jsonPath = join(cwd, 'kick.config.json')\n  if (existsSync(jsonPath)) {\n    try {\n      return JSON.parse(readFileSync(jsonPath, 'utf-8')) as AssetMapConfigShape\n    } catch {\n      return null\n    }\n  }\n  for (const filename of ['kick.config.cjs', 'kick.config.js']) {\n    const path = join(cwd, filename)\n    if (!existsSync(path)) continue\n    try {\n      // eslint-disable-next-line @typescript-eslint/no-require-imports\n      const { createRequire } = require('node:module') as typeof import('node:module')\n      const req = createRequire(join(cwd, 'package.json'))\n      const mod = req(path) as { default?: AssetMapConfigShape } & AssetMapConfigShape\n      return mod.default ?? mod ?? null\n    } catch {\n      continue\n    }\n  }\n\n  // Fallback: the CLI snapshot of a transpiled `kick.config.ts`. We\n  // can't transpile TS synchronously on the asset hot path, so the CLI\n  // (`loadKickConfig`) mirrors the JSON-serialisable `assetMap` +\n  // `build.outDir` into `.kickjs/kick.config.json` whenever it loads a\n  // `.ts`/`.js` config. This is what makes `assets.x.y()` resolve in\n  // dev for `.ts`-config projects before the first production build.\n  const snapshotPath = join(cwd, '.kickjs', 'kick.config.json')\n  if (existsSync(snapshotPath)) {\n    try {\n      return JSON.parse(readFileSync(snapshotPath, 'utf-8')) as AssetMapConfigShape\n    } catch {\n      return null\n    }\n  }\n  return null\n}\n\n/**\n * Keys we MUST return `undefined` for: returning anything truthy\n * here causes Promise resolution to treat the Proxy as a thenable\n * and `await` it (resolving to whatever `then.call(...)` produces).\n * Two-element list deliberately — every other coercion-related key\n * goes through {@link PASSTHROUGH_KEYS} below so `String(assets)`,\n * template literals, and `util.inspect` keep working.\n */\nconst PROMISE_DETECTION_KEYS: ReadonlySet<string | symbol> = new Set<string | symbol>(['then'])\n\n/**\n * Keys we let fall through to the proxy target (a function-shaped\n * object). The default `Object.prototype` implementations of\n * `toString` / `valueOf` etc. are correct for these — returning\n * `undefined` here would break `String(assets)` and template\n * literals (`${assets}`) because `Symbol.toPrimitive` falling through\n * to a missing `toString` throws. Adopters that hit `assets.toString`\n * get `'function () {}'` back, which is fine — the contract is\n * \"asset access returns paths\"; everything else is incidental.\n */\nconst PASSTHROUGH_KEYS: ReadonlySet<string | symbol> = new Set<string | symbol>([\n  'toString',\n  'valueOf',\n  'constructor',\n  'prototype',\n  'name',\n  'length',\n  'asymmetricMatch',\n  'nodeType',\n  Symbol.toPrimitive,\n  Symbol.toStringTag,\n  Symbol.iterator,\n  Symbol.asyncIterator,\n])\n\nfunction createNamespaceProxy(parts: readonly string[]): unknown {\n  const target = function () {} as unknown as Record<string, unknown>\n  return new Proxy(target, {\n    apply() {\n      if (parts.length < 2) {\n        throw new UnknownAssetError(parts[0] ?? '', '')\n      }\n      const [namespace, ...rest] = parts\n      return resolveAsset(namespace, rest.join('/'))\n    },\n    get(t, prop) {\n      if (PROMISE_DETECTION_KEYS.has(prop)) return undefined\n      if (PASSTHROUGH_KEYS.has(prop)) return Reflect.get(t, prop)\n      if (typeof prop === 'symbol') return undefined\n      return createNamespaceProxy([...parts, prop])\n    },\n  })\n}\n\nfunction createAssetProxy(): KickAssets {\n  return new Proxy({} as Record<string, unknown>, {\n    get(t, prop) {\n      if (PROMISE_DETECTION_KEYS.has(prop)) return undefined\n      if (PASSTHROUGH_KEYS.has(prop)) return Reflect.get(t, prop)\n      if (typeof prop === 'symbol') return undefined\n      return createNamespaceProxy([prop])\n    },\n  }) as unknown as KickAssets\n}\n\n/**\n * Variant A — the ambient Proxy. Default accessor for static call\n * sites where the namespace + key are literals known at compile time.\n *\n * @example\n * ```ts\n * import { assets } from '@forinda/kickjs'\n * const path = assets.mails.welcome()\n * ```\n */\nexport const assets: KickAssets = createAssetProxy()\n\n/**\n * Variant B — the hook accessor. Returns the same Proxy as `assets`;\n * factory shape exists for testability + DI. Mock via\n * `vi.mock('@forinda/kickjs', () => ({ useAssets: () => fakeAssets }))`.\n *\n * @example\n * ```ts\n * import { useAssets } from '@forinda/kickjs'\n * class MailService {\n *   private assets = useAssets()\n *   send(name: string) {\n *     return ejs.renderFile(this.assets.mails[name](), {})\n *   }\n * }\n * ```\n */\nexport function useAssets(): KickAssets {\n  return assets\n}\n\n// Install this module's resolver into the container's asset slot — the\n// container deliberately avoids importing this file (edge purity; see\n// asset-resolver-slot.ts). Runs at module scope so any node app that loads\n// the asset manager gets full @Asset injection.\nimport { _setAssetResolver } from './asset-resolver-slot'\n_setAssetResolver(resolveAsset)\n"],"mappings":"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"}