@forinda/kickjs 5.4.0 → 5.6.0

package/dist/context-CIoXqpAX.mjs

@@ -1,12 +0,0 @@
-/**
- * @forinda/kickjs v5.4.0
- *
- * Copyright (c) Felix Orinda
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @license MIT
- */
-import{i as parseQuery}from"./query-B7n5isk_.mjs";import{AsyncLocalStorage}from"node:async_hooks";const requestStore=new AsyncLocalStorage;function getRequestStore(){let store=requestStore.getStore();if(!store)throw Error(`No active request context. REQUEST-scoped services can only be resolved during an HTTP request.`);return store}function getRequestValue(key){return requestStore.getStore()?.values.get(key)}var RequestContext=class{constructor(req,res,next){this.req=req,this.res=res,this.next=next}metadataReadOnly(){return requestStore.getStore()?.values??null}metadataForWrite(){let store=requestStore.getStore();if(store)return store.values;throw Error(`RequestContext.set called outside an AsyncLocalStorage frame. Mount requestScopeMiddleware() before constructing RequestContext, or wrap test setup in requestStore.run({ requestId, instances: new Map(), values: new Map() }, () => ...).`)}get body(){return this.req.body}get params(){return this.req.params}get query(){return this.req.query}get headers(){return this.req.headers}get requestId(){return this.req.requestId??this.req.headers[`x-request-id`]}get session(){return this.req.session}get user(){return this.metadataReadOnly()?.get(`user`)??this.req.user}get tenantId(){return this.user?.tenantId}get roles(){let u=this.user;return u?.tenantRoles??u?.roles??[]}qs(fieldConfig){return parseQuery(this.req.query,fieldConfig)}get file(){return this.req.file}get files(){let f=this.req.files;return Array.isArray(f)?f:void 0}get(key){return this.metadataReadOnly()?.get(key)}set(key,value){this.metadataForWrite().set(key,value)}json(data,status=200){return this.res.status(status).json(data)}created(data){return this.res.status(201).json(data)}noContent(){return this.res.status(204).end()}notFound(message=`Not Found`){return this.res.status(404).json({message})}badRequest(message){return this.res.status(400).json({message})}html(content,status=200){return this.res.status(status).type(`html`).send(content)}download(buffer,filename,contentType=`application/octet-stream`){return this.res.setHeader(`Content-Disposition`,`attachment; filename="${filename}"`),this.res.setHeader(`Content-Type`,contentType),this.res.send(buffer)}render(template,data={}){return this.res.render(template,data)}async paginate(fetcher,fieldConfig){let parsed=this.qs(fieldConfig),{data,total}=await fetcher(parsed),{page,limit}=parsed.pagination,totalPages=Math.ceil(total/limit)||1,response={data,meta:{page,limit,total,totalPages,hasNext:page<totalPages,hasPrev:page>1}};return this.json(response)}sse(){this.res.writeHead(200,{"Content-Type":`text/event-stream`,"Cache-Control":`no-cache`,Connection:`keep-alive`,"X-Accel-Buffering":`no`}),this.res.flushHeaders();let closeCallbacks=[];return this.req.on(`close`,()=>{for(let cb of closeCallbacks)cb()}),{send:(data,event,id)=>{id&&this.res.write(`id: ${id}\n`),event&&this.res.write(`event: ${event}\n`),this.res.write(`data: ${JSON.stringify(data)}\n\n`)},comment:text=>{this.res.write(`: ${text}\n\n`)},onClose:fn=>{closeCallbacks.push(fn)},close:()=>{this.res.end()}}}};export{requestStore as i,getRequestStore as n,getRequestValue as r,RequestContext as t};
-//# sourceMappingURL=context-CIoXqpAX.mjs.map

package/dist/context-CIoXqpAX.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"context-CIoXqpAX.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}\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, Response, NextFunction } from 'express'\nimport { type ContextMeta, type ExecutionContext, type MetaValue } from '../core/execution-context'\nimport { requestStore } from './request-store'\nimport {\n  parseQuery,\n  type QueryFieldConfig,\n  type PaginatedResponse,\n  type TypedParsedQuery,\n} from './query'\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 * Used to seal typed request data (`body`, `params`, `query`) so\n * adopters can't mutate Zod-validated payloads in place — the contract\n * is \"compute new values, stash via `ctx.set`\", not \"edit the request\n * bag\".\n *\n * Type-only. No runtime cost. `DeepReadonly<any>` is `any` (TS\n * distributes conditional types over `any`), so adopters who haven't\n * typed their `Ctx` get no protection but no breakage either.\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 * 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\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<TBody = any, TParams = any, TQuery = any> implements ExecutionContext {\n  constructor(\n    public readonly req: Request,\n    public readonly res: Response,\n    public readonly next: NextFunction,\n  ) {}\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. Returned as `DeepReadonly<TBody>` so adopters\n   * can't mutate Zod-validated payloads in place — compute new values\n   * and stash them via `ctx.set('key', value)` or a Context Contributor\n   * instead. Reach for `ctx.req.body` if you genuinely need the raw,\n   * mutable Express handle (rare).\n   */\n  get body(): DeepReadonly<TBody> {\n    return this.req.body as DeepReadonly<TBody>\n  }\n\n  /** Path parameters parsed from the route — read-only, see {@link body}. */\n  get params(): DeepReadonly<TParams> {\n    return this.req.params as DeepReadonly<TParams>\n  }\n\n  /** Parsed query string — read-only, see {@link body}. */\n  get query(): DeepReadonly<TQuery> {\n    return this.req.query as DeepReadonly<TQuery>\n  }\n\n  /** Inbound HTTP headers — read-only, see {@link body}. */\n  get headers(): Readonly<Request['headers']> {\n    return 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  /** 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   *\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  ): TypedParsedQuery<TConfig> {\n    return parseQuery<TConfig>(this.req.query as Record<string, any>, fieldConfig)\n  }\n\n  // ── File Uploads ────────────────────────────────────────────────────\n\n  /**\n   * Single uploaded file (requires `@FileUpload({ mode: 'single' })`).\n   * Returned as `DeepReadonly<Express.Multer.File>` — file metadata is\n   * set by the upload middleware and shouldn't be mutated downstream.\n   */\n  get file(): DeepReadonly<Express.Multer.File> | undefined {\n    return this.req.file\n  }\n\n  /**\n   * Array of uploaded files (requires `@FileUpload({ mode: 'array' })`).\n   * Returns a `ReadonlyArray<DeepReadonly<Express.Multer.File>>` — both\n   * the list (`push`/`pop`) and each file's fields (`size`, `originalname`,\n   * etc.) are locked. Use `ctx.req.files` if you genuinely need the\n   * mutable Express handle.\n   */\n  get files(): ReadonlyArray<DeepReadonly<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    return Array.isArray(f) ? f : undefined\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   * 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  json(data: any, status = 200) {\n    return this.res.status(status).json(data)\n  }\n\n  created(data: any) {\n    return this.res.status(201).json(data)\n  }\n\n  noContent() {\n    return this.res.status(204).end()\n  }\n\n  notFound(message = 'Not Found') {\n    return this.res.status(404).json({ message })\n  }\n\n  badRequest(message: string) {\n    return this.res.status(400).json({ message })\n  }\n\n  html(content: string, status = 200) {\n    return this.res.status(status).type('html').send(content)\n  }\n\n  download(buffer: Buffer, filename: string, contentType = 'application/octet-stream') {\n    this.res.setHeader('Content-Disposition', `attachment; filename=\"${filename}\"`)\n    this.res.setHeader('Content-Type', contentType)\n    return this.res.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.res.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   * @example\n   * ```ts\n   * @Get('/events')\n   * async stream(ctx: RequestContext) {\n   *   const sse = ctx.sse()\n   *\n   *   const interval = setInterval(() => {\n   *     sse.send({ time: new Date().toISOString() }, 'tick')\n   *   }, 1000)\n   *\n   *   sse.onClose(() => clearInterval(interval))\n   * }\n   * ```\n   */\n  sse() {\n    this.res.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.res.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: any, event?: string, id?: string) => {\n        if (id) this.res.write(`id: ${id}\\n`)\n        if (event) this.res.write(`event: ${event}\\n`)\n        this.res.write(`data: ${JSON.stringify(data)}\\n\\n`)\n      },\n      /** Send a comment (keeps connection alive) */\n      comment: (text: string) => {\n        this.res.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.res.end()\n      },\n    }\n  }\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>\n\n/**\n * Global ambient registry of typed routes, populated by `kick typegen`.\n *\n * Each interface inside `KickRoutes` corresponds to a controller class;\n * each property is one route method on that controller. The values\n * conform to `RouteShape`.\n *\n * Empty by default — declarations come from `.kickjs/types/routes.d.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-BQZyB8Wv.mjs

@@ -1,12 +0,0 @@
-/**
- * @forinda/kickjs v5.4.0
- *
- * Copyright (c) Felix Orinda
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @license MIT
- */
-import"./container-DArhTDQQ.mjs";import{METADATA}from"./core/interfaces.mjs";import"./core/logger.mjs";import{c as pushClassMeta,l as pushMethodMeta}from"./metadata-Dn6kNT82.mjs";import"./core/decorators.mjs";import"./core/cron.mjs";import"./core/cache.mjs";import"reflect-metadata";var CircuitOpenError=class extends Error{constructor(breakerName){super(`Circuit breaker "${breakerName}" is open — request rejected`),this.breakerName=breakerName,this.name=`CircuitOpenError`}},CircuitBreaker=class{state=`closed`;failures=0;successes=0;halfOpenAttempts=0;lastFailure;openedAt;failureThreshold;resetTimeout;halfOpenMax;constructor(name,options){this.name=name,this.failureThreshold=options.failureThreshold,this.resetTimeout=options.resetTimeout,this.halfOpenMax=options.halfOpenMax??1}async execute(fn){if(this.maybeTransitionToHalfOpen(),this.state===`open`||this.state===`half_open`&&this.halfOpenAttempts>=this.halfOpenMax)throw new CircuitOpenError(this.name);this.state===`half_open`&&this.halfOpenAttempts++;try{let result=await fn();return this.onSuccess(),result}catch(error){throw this.onFailure(),error}}getState(){return this.maybeTransitionToHalfOpen(),this.state}getStats(){return this.maybeTransitionToHalfOpen(),{failures:this.failures,successes:this.successes,state:this.state,...this.lastFailure?{lastFailure:this.lastFailure}:{}}}reset(){this.state=`closed`,this.failures=0,this.successes=0,this.halfOpenAttempts=0,this.lastFailure=void 0,this.openedAt=void 0}onSuccess(){this.state===`half_open`&&(this.state=`closed`,this.failures=0,this.halfOpenAttempts=0,this.openedAt=void 0),this.successes++}onFailure(){this.failures++,this.lastFailure=new Date,this.state===`half_open`?(this.state=`open`,this.openedAt=Date.now(),this.halfOpenAttempts=0):this.state===`closed`&&this.failures>=this.failureThreshold&&(this.state=`open`,this.openedAt=Date.now())}maybeTransitionToHalfOpen(){this.state===`open`&&this.openedAt!=null&&Date.now()-this.openedAt>=this.resetTimeout&&(this.state=`half_open`,this.halfOpenAttempts=0)}};function defineContextDecorator(spec){let defaults=Object.freeze({...spec.paramDefaults??{}}),sharedDeps=Object.freeze({...spec.deps??{}}),sharedDependsOn=Object.freeze([...spec.dependsOn??[]]),sharedOptional=spec.optional??!1,buildRegistration=params=>{let frozenParams=Object.freeze({...params}),onError=spec.onError?(err,ctx)=>spec.onError(err,ctx,frozenParams):void 0;return Object.freeze({key:spec.key,deps:sharedDeps,dependsOn:sharedDependsOn,optional:sharedOptional,onError,resolve:(ctx,deps)=>spec.resolve(ctx,deps,frozenParams)})},defaultRegistration=buildRegistration({...defaults}),isDecoratorCall=args=>args.length===0?!1:args.length>=2||typeof args[0]==`function`,applyAsDecorator=(registration,target,propertyKey)=>{if(propertyKey===void 0)pushClassMeta(METADATA.CLASS_CONTRIBUTORS,target,registration);else{let constructor=target.constructor;pushMethodMeta(METADATA.METHOD_CONTRIBUTORS,constructor,String(propertyKey),registration)}},isPlainObject=value=>{let proto=Object.getPrototypeOf(value);return proto===Object.prototype||proto===null},mergeParams=override=>{if(override===void 0)return{...defaults};if(typeof override!=`object`||!override||Array.isArray(override)||!isPlainObject(override)){let got=override===null?`null`:Array.isArray(override)?`array`:typeof override==`object`?`instance of ${override.constructor?.name??`unknown class`}`:typeof override;throw TypeError(`defineContextDecorator(${spec.key}): factory call requires a plain object literal, got ${got}. Class instances and built-ins (Map, Date, etc) silently spread to empty objects — call the decorator with a spread object literal instead, e.g. \`MyDecorator({ ...someInstance })\`.`)}return{...defaults,...override}};function decoratorOrFactory(...args){if(isDecoratorCall(args)){let[target,propertyKey]=args;applyAsDecorator(defaultRegistration,target,propertyKey);return}let registration=buildRegistration(mergeParams(args[0]));return(target,propertyKey)=>{applyAsDecorator(registration,target,propertyKey)}}return Object.defineProperty(decoratorOrFactory,`registration`,{value:defaultRegistration,writable:!1,enumerable:!0,configurable:!1}),Object.defineProperty(decoratorOrFactory,`with`,{value:params=>({registration:buildRegistration(mergeParams(params))}),writable:!1,enumerable:!0,configurable:!1}),decoratorOrFactory}var MissingContributorError=class extends Error{key;dependent;route;constructor(key,dependent,route){let where=route?` on route ${route}`:``;super(`Missing context contributor '${key}' required by '${dependent}'${where}`),this.name=`MissingContributorError`,this.key=key,this.dependent=dependent,this.route=route}},ContributorCycleError=class extends Error{cycle;route;constructor(cycle,route){let where=route?` on route ${route}`:``;super(`Cycle in context contributors${where}: ${cycle.join(` → `)}`),this.name=`ContributorCycleError`,this.cycle=Object.freeze([...cycle]),this.route=route}},DuplicateContributorError=class extends Error{key;sources;constructor(key,sources){super(`Duplicate context contributor for key '${key}' at the same precedence level. Sources: ${sources.join(`, `)}`),this.name=`DuplicateContributorError`,this.key=key,this.sources=Object.freeze([...sources])}};const PRECEDENCE_ORDER=[`method`,`class`,`module`,`adapter`,`global`];function buildPipeline(sources,options={}){let route=options.route,bySource=new Map;for(let src of PRECEDENCE_ORDER)bySource.set(src,[]);for(let entry of sources)bySource.get(entry.source).push(entry);let winners=new Map;for(let src of PRECEDENCE_ORDER){let rows=bySource.get(src),keysAtThisLevel=new Map;for(let row of rows){let key=row.registration.key,existing=keysAtThisLevel.get(key)??[];existing.push(row),keysAtThisLevel.set(key,existing)}for(let[key,rowsForKey]of keysAtThisLevel){if(rowsForKey.length>1)throw new DuplicateContributorError(key,rowsForKey.map((r,i)=>r.label??`${src}#${i}`));winners.has(key)||winners.set(key,rowsForKey[0])}}let survivors=[...winners.values()].map(r=>r.registration),allKeys=new Set(survivors.map(r=>r.key));for(let reg of survivors)for(let dep of reg.dependsOn)if(!allKeys.has(dep))throw new MissingContributorError(dep,reg.key,route);let sorted=topoSort(survivors,route);return Object.freeze({contributors:Object.freeze(sorted),keys:allKeys})}function topoSort(registrations,route){let indegree=new Map,dependents=new Map,byKey=new Map;for(let reg of registrations)indegree.set(reg.key,reg.dependsOn.length),byKey.set(reg.key,reg);for(let reg of registrations)for(let dep of reg.dependsOn){let list=dependents.get(dep)??[];list.push(reg),dependents.set(dep,list)}let queue=[];for(let reg of registrations)indegree.get(reg.key)===0&&queue.push(reg);let sorted=[];for(;queue.length>0;){let node=queue.shift();sorted.push(node);for(let dependent of dependents.get(node.key)??[]){let next=(indegree.get(dependent.key)??0)-1;indegree.set(dependent.key,next),next===0&&queue.push(dependent)}}if(sorted.length!==registrations.length)throw new ContributorCycleError(reconstructCycle$1(registrations.filter(r=>(indegree.get(r.key)??0)>0),byKey),route);return sorted}function reconstructCycle$1(residual,byKey){let residualKeys=new Set(residual.map(r=>r.key)),start=residual[0].key,path=[start],seen=new Set([start]),cursor=start;for(;;){let nextDep=byKey.get(cursor).dependsOn.find(d=>residualKeys.has(d));if(nextDep===void 0)break;if(seen.has(nextDep)){let cycleStart=path.indexOf(nextDep);return[...path.slice(cycleStart),nextDep]}path.push(nextDep),seen.add(nextDep),cursor=nextDep}return path}async function runContributors(options){let{pipeline,ctx,container}=options;for(let reg of pipeline.contributors)await runOne(reg,ctx,container)}async function runOne(reg,ctx,container){let value;try{let deps=resolveDeps(reg,container);value=await reg.resolve(ctx,deps)}catch(err){if(reg.optional)return;if(reg.onError){let replacement=await reg.onError(err,ctx);if(replacement===void 0)return;ctx.set(reg.key,replacement);return}throw err}ctx.set(reg.key,value)}function resolveDeps(reg,container){let out={};for(let[key,token]of Object.entries(reg.deps))out[key]=container.resolve(token);return out}var DuplicateMountNameError=class extends Error{kind;mountName;constructor(kind,mountName){super(`Duplicate ${kind} name '${mountName}' — every ${kind} must declare a unique name`),this.name=`DuplicateMountNameError`,this.kind=kind,this.mountName=mountName}},MissingMountDepError=class extends Error{kind;missing;dependent;constructor(kind,missing,dependent){super(`Missing ${kind} dependency '${missing}' required by '${dependent}' — is the ${kind} installed and named correctly?`),this.name=`MissingMountDepError`,this.kind=kind,this.missing=missing,this.dependent=dependent}},MountCycleError=class extends Error{kind;cycle;constructor(kind,cycle){super(`Cycle in ${kind} dependsOn declarations: ${cycle.join(` → `)}`),this.name=`MountCycleError`,this.kind=kind,this.cycle=Object.freeze([...cycle])}};function mountSort(items,kind){let byName=new Map;for(let item of items){if(byName.has(item.name))throw new DuplicateMountNameError(kind,item.name);byName.set(item.name,item)}let indegree=new Map,dependents=new Map;for(let item of items)indegree.set(item.name,item.dependsOn?.length??0);for(let item of items)for(let dep of item.dependsOn??[]){if(!byName.has(dep))throw new MissingMountDepError(kind,dep,item.name);let list=dependents.get(dep)??[];list.push(item),dependents.set(dep,list)}let queue=[];for(let item of items)indegree.get(item.name)===0&&queue.push(item);let sorted=[];for(;queue.length>0;){let node=queue.shift();sorted.push(node);for(let dependent of dependents.get(node.name)??[]){let next=(indegree.get(dependent.name)??0)-1;indegree.set(dependent.name,next),next===0&&queue.push(dependent)}}if(sorted.length!==items.length)throw new MountCycleError(kind,reconstructCycle(items.filter(it=>(indegree.get(it.name)??0)>0),byName));return sorted}function reconstructCycle(residual,byName){let residualNames=new Set(residual.map(r=>r.name)),start=residual[0].name,path=[start],seen=new Set([start]),cursor=start;for(;;){let nextDep=byName.get(cursor).dependsOn?.find(d=>residualNames.has(d));if(nextDep===void 0)break;if(seen.has(nextDep)){let cycleStart=path.indexOf(nextDep);return[...path.slice(cycleStart),nextDep]}path.push(nextDep),seen.add(nextDep),cursor=nextDep}return path}const mergeConfig$1=(defaults={},overrides={})=>({...defaults,...overrides}),composeName$1=(base,scope)=>`${base}:${scope}`;function definePlugin(options){let buildSync=(instanceName,scoped,overrides)=>{let config=mergeConfig$1(options.defaults,overrides),built=options.build(config,{name:instanceName,scoped});return built.name=instanceName,built},buildAsync=(instanceName,opts)=>{let inner,ensureInner=async container=>{if(inner)return inner;let deps=(opts.inject??[]).map(tok=>container.resolve(tok));return inner=buildSync(instanceName,!1,await opts.useFactory(...deps)),inner};return{name:instanceName,async onReady(container){let built=await ensureInner(container);built.register?.(container),await built.onReady?.(container)},async shutdown(){await inner?.shutdown?.()}}},factory=(config=>buildSync(options.name,!1,config));return factory.scoped=(scopeName,config)=>buildSync(composeName$1(options.name,scopeName),!0,config),factory.async=opts=>buildAsync(options.name,opts),Object.defineProperty(factory,`definition`,{value:Object.freeze({...options})}),factory}const mergeConfig=(defaults={},overrides={})=>({...defaults,...overrides}),composeName=(base,scope)=>`${base}:${scope}`;function defineAdapter(options){let buildSync=(instanceName,scoped,overrides)=>{let config=mergeConfig(options.defaults,overrides),built=options.build(config,{name:instanceName,scoped});return built.name=instanceName,built},buildAsync=(instanceName,opts)=>{let inner;return{name:instanceName,async beforeStart(ctx){let deps=(opts.inject??[]).map(tok=>ctx.container.resolve(tok));inner=buildSync(instanceName,!1,await opts.useFactory(...deps)),await inner.beforeStart?.(ctx)},async afterStart(ctx){await inner?.afterStart?.(ctx)},async shutdown(){await inner?.shutdown?.()},async onHealthCheck(){return await inner?.onHealthCheck?.()??{name:instanceName,status:`up`}}}},factory=(config=>buildSync(options.name,!1,config));return factory.scoped=(scopeName,config)=>buildSync(composeName(options.name,scopeName),!0,config),factory.async=opts=>buildAsync(options.name,opts),Object.defineProperty(factory,`definition`,{value:Object.freeze({...options})}),factory}function defineAugmentation(name,meta){}export{MissingMountDepError as a,runContributors as c,DuplicateContributorError as d,MissingContributorError as f,CircuitOpenError as h,DuplicateMountNameError as i,buildPipeline as l,CircuitBreaker as m,defineAdapter as n,MountCycleError as o,defineContextDecorator as p,definePlugin as r,mountSort as s,defineAugmentation as t,ContributorCycleError as u};
-//# sourceMappingURL=core-BQZyB8Wv.mjs.map

package/dist/core-BQZyB8Wv.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"core-BQZyB8Wv.mjs","names":["reconstructCycle","mergeConfig","composeName"],"sources":["../src/core/circuit-breaker.ts","../src/core/context-decorator.ts","../src/core/context-errors.ts","../src/core/contributor-pipeline.ts","../src/core/contributor-runner.ts","../src/core/mount-sort.ts","../src/core/define-plugin.ts","../src/core/define-adapter.ts","../src/core/augmentation.ts"],"sourcesContent":["/**\n * Circuit Breaker pattern for external service calls.\n *\n * Protects your application from cascading failures when downstream\n * services are unhealthy by short-circuiting requests after a\n * configurable failure threshold.\n *\n * @example\n * ```ts\n * const breaker = new CircuitBreaker('payment-api', {\n *   failureThreshold: 5,\n *   resetTimeout: 30_000,\n * })\n *\n * const result = await breaker.execute(() => fetch('https://payment.example.com/charge'))\n * ```\n */\n\nexport type CircuitBreakerState = 'closed' | 'open' | 'half_open'\n\nexport interface CircuitBreakerOptions {\n  /** Number of consecutive failures before the circuit opens. */\n  failureThreshold: number\n  /** Milliseconds to wait before transitioning from OPEN to HALF_OPEN. */\n  resetTimeout: number\n  /** Max requests allowed in HALF_OPEN state before deciding (default 1). */\n  halfOpenMax?: number\n}\n\nexport interface CircuitBreakerStats {\n  failures: number\n  successes: number\n  state: CircuitBreakerState\n  lastFailure?: Date\n}\n\n/**\n * Error thrown when the circuit is open and calls are being rejected.\n */\nexport class CircuitOpenError extends Error {\n  constructor(public readonly breakerName: string) {\n    super(`Circuit breaker \"${breakerName}\" is open — request rejected`)\n    this.name = 'CircuitOpenError'\n  }\n}\n\nexport class CircuitBreaker {\n  private state: CircuitBreakerState = 'closed'\n  private failures = 0\n  private successes = 0\n  private halfOpenAttempts = 0\n  private lastFailure?: Date\n  private openedAt?: number\n\n  private readonly failureThreshold: number\n  private readonly resetTimeout: number\n  private readonly halfOpenMax: number\n\n  constructor(\n    public readonly name: string,\n    options: CircuitBreakerOptions,\n  ) {\n    this.failureThreshold = options.failureThreshold\n    this.resetTimeout = options.resetTimeout\n    this.halfOpenMax = options.halfOpenMax ?? 1\n  }\n\n  /**\n   * Execute an async function through the circuit breaker.\n   * Throws `CircuitOpenError` if the circuit is open.\n   */\n  async execute<T>(fn: () => Promise<T>): Promise<T> {\n    this.maybeTransitionToHalfOpen()\n\n    if (this.state === 'open') {\n      throw new CircuitOpenError(this.name)\n    }\n\n    if (this.state === 'half_open' && this.halfOpenAttempts >= this.halfOpenMax) {\n      throw new CircuitOpenError(this.name)\n    }\n\n    if (this.state === 'half_open') {\n      this.halfOpenAttempts++\n    }\n\n    try {\n      const result = await fn()\n      this.onSuccess()\n      return result\n    } catch (error) {\n      this.onFailure()\n      throw error\n    }\n  }\n\n  /** Returns the current circuit state. */\n  getState(): CircuitBreakerState {\n    this.maybeTransitionToHalfOpen()\n    return this.state\n  }\n\n  /** Returns current statistics. */\n  getStats(): CircuitBreakerStats {\n    this.maybeTransitionToHalfOpen()\n    return {\n      failures: this.failures,\n      successes: this.successes,\n      state: this.state,\n      ...(this.lastFailure ? { lastFailure: this.lastFailure } : {}),\n    }\n  }\n\n  /** Manually reset the circuit breaker to CLOSED state. */\n  reset(): void {\n    this.state = 'closed'\n    this.failures = 0\n    this.successes = 0\n    this.halfOpenAttempts = 0\n    this.lastFailure = undefined\n    this.openedAt = undefined\n  }\n\n  private onSuccess(): void {\n    if (this.state === 'half_open') {\n      // Recovery confirmed — close the circuit\n      this.state = 'closed'\n      this.failures = 0\n      this.halfOpenAttempts = 0\n      this.openedAt = undefined\n    }\n    this.successes++\n  }\n\n  private onFailure(): void {\n    this.failures++\n    this.lastFailure = new Date()\n\n    if (this.state === 'half_open') {\n      // Recovery failed — re-open\n      this.state = 'open'\n      this.openedAt = Date.now()\n      this.halfOpenAttempts = 0\n    } else if (this.state === 'closed' && this.failures >= this.failureThreshold) {\n      this.state = 'open'\n      this.openedAt = Date.now()\n    }\n  }\n\n  private maybeTransitionToHalfOpen(): void {\n    if (this.state === 'open' && this.openedAt != null) {\n      if (Date.now() - this.openedAt >= this.resetTimeout) {\n        this.state = 'half_open'\n        this.halfOpenAttempts = 0\n      }\n    }\n  }\n}\n","import 'reflect-metadata'\nimport { METADATA, type Constructor, type MaybePromise } from './interfaces'\nimport { pushClassMeta, pushMethodMeta } from './metadata'\nimport type { InjectionToken } from './token'\nimport type { ContextMeta, ExecutionContext, MetaValue } from './execution-context'\n\n/**\n * String-literal union of every key declared on the augmentable\n * {@link ContextMeta} interface. Resolves to `string` when the\n * project hasn't augmented `ContextMeta` yet (so a first-day project\n * keeps compiling), and narrows to the concrete keys once the\n * `declare module '@forinda/kickjs' { interface 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 */\nexport type ContextMetaKey = keyof ContextMeta extends never ? string : keyof ContextMeta & 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 * 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 */\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> {\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 `keyof ContextMeta` once the project augments it — so\n   * `dependsOn: ['tenent']` (typo) is a TS error, not a boot-time\n   * `MissingContributorError`. Falls back to plain `string[]` when the\n   * registry is empty (no augmentation yet) so first-day projects keep\n   * compiling. Cast-as-any escape hatch:\n   * `dependsOn: ['custom-key' as keyof ContextMeta]`.\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-field caveat.** The factory call signature accepts\n   * `Partial<P>` so adopters can override only the fields they care\n   * about. If your `P` declares a *required* field that isn't in\n   * `paramDefaults`, the merged runtime value can be missing that\n   * field even though TypeScript types `params` as `P` inside\n   * `resolve()`. Mitigate by either:\n   *\n   * 1. Marking the field optional in `P` and `if`-checking inside\n   *    `resolve()`, or\n   * 2. Providing a default for every required field in\n   *    `paramDefaults`.\n   *\n   * The framework can't enforce option 2 at compile time without\n   * giving up the back-compat that lets `paramDefaults` be omitted\n   * entirely for `P = Record<string, never>`.\n   */\n  paramDefaults?: Partial<P>\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\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}. Callable as\n * either a class or method decorator (with `paramDefaults` applied),\n * as a factory (`@Foo({...})` returning a per-site decorator), or\n * via `.with(params)` for non-decorator registration sites (module\n * hooks, adapter hooks, bootstrap option). `.registration` exposes\n * the underlying frozen {@link ContributorRegistration} for the\n * default-params case.\n */\nexport interface 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> {\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 * 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 * **No runtime behaviour is wired in Phase 1.** This factory only writes\n * metadata; the topo-sort, runner, and HTTP integration land in later\n * phases. See `architecture.md` §20 for the full pipeline plan.\n */\nexport function defineContextDecorator<\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>(spec: ContextDecoratorSpec<K, D, P, Ctx>): ContextDecorator<K, D, P, Ctx> {\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  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    })\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  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      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    const registration = buildRegistration(params)\n    return (target: object, propertyKey?: string | symbol) => {\n      applyAsDecorator(registration, target, propertyKey)\n    }\n  }\n\n  Object.defineProperty(decoratorOrFactory, 'registration', {\n    value: defaultRegistration,\n    writable: false,\n    enumerable: true,\n    configurable: false,\n  })\n\n  Object.defineProperty(decoratorOrFactory, 'with', {\n    value: (params: Partial<P>) => ({\n      registration: buildRegistration(mergeParams(params)),\n    }),\n    writable: false,\n    enumerable: true,\n    configurable: false,\n  })\n\n  return decoratorOrFactory as unknown as ContextDecorator<K, D, P, Ctx>\n}\n","/**\n * Errors thrown by the Context Contributor pipeline.\n *\n * All three are startup-time errors raised during pipeline build (topo-sort\n * + validation), not per-request — a misconfigured app fails to boot rather\n * than fails a request. Per the locked design in `architecture.md` §20.4,\n * the pipeline is validated once when each route is mounted and the\n * resolved order is cached on the route.\n */\n\n/**\n * A contributor declared `dependsOn: ['<key>']` but no other contributor\n * (at any precedence level) produces that key for the same route.\n *\n * @example\n * ```text\n * MissingContributorError: Missing context contributor 'tenant' required by 'project' on route GET /projects/:id\n * ```\n */\nexport class MissingContributorError extends Error {\n  readonly key: string\n  readonly dependent: string\n  readonly route?: string\n\n  constructor(key: string, dependent: string, route?: string) {\n    const where = route ? ` on route ${route}` : ''\n    super(`Missing context contributor '${key}' required by '${dependent}'${where}`)\n    this.name = 'MissingContributorError'\n    this.key = key\n    this.dependent = dependent\n    this.route = route\n  }\n}\n\n/**\n * Topo-sort detected a cycle in `dependsOn` declarations. The `cycle` field\n * lists the keys in the order they form the loop, with the first key\n * repeated at the end so the path reads naturally.\n *\n * @example\n * ```text\n * ContributorCycleError: Cycle in context contributors on route GET /projects/:id: tenant → project → tenant\n * ```\n */\nexport class ContributorCycleError extends Error {\n  readonly cycle: readonly string[]\n  readonly route?: string\n\n  constructor(cycle: readonly string[], route?: string) {\n    const where = route ? ` on route ${route}` : ''\n    super(`Cycle in context contributors${where}: ${cycle.join(' → ')}`)\n    this.name = 'ContributorCycleError'\n    this.cycle = Object.freeze([...cycle])\n    this.route = route\n  }\n}\n\n/**\n * Two contributors at the same precedence level both produce the same key\n * for the same route. Precedence resolution (method > class > module >\n * adapter > global, per architecture.md §20.4) silently drops\n * lower-precedence duplicates; this error fires only when ties occur\n * within a single level — e.g., two method-level decorators declaring\n * `key: 'tenant'`.\n *\n * `sources` is best-effort identifying labels for each conflicting\n * registration (typically the decorator's call site or registering\n * module/adapter name).\n *\n * @example\n * ```text\n * DuplicateContributorError: Duplicate context contributor for key 'tenant' at the same precedence level. Sources: LoadTenantFromHeader, LoadTenantFromSubdomain\n * ```\n */\nexport class DuplicateContributorError extends Error {\n  readonly key: string\n  readonly sources: readonly string[]\n\n  constructor(key: string, sources: readonly string[]) {\n    super(\n      `Duplicate context contributor for key '${key}' at the same precedence level. ` +\n        `Sources: ${sources.join(', ')}`,\n    )\n    this.name = 'DuplicateContributorError'\n    this.key = key\n    this.sources = Object.freeze([...sources])\n  }\n}\n","import type { AnyContributorRegistration } from './context-decorator'\nimport {\n  ContributorCycleError,\n  DuplicateContributorError,\n  MissingContributorError,\n} from './context-errors'\n\n/**\n * Where a contributor was registered, ordered by precedence\n * (lower index wins). Mirrors `architecture.md` §20.4.\n *\n * Levels (highest → lowest precedence):\n * - `'method'` — `@LoadX` on a controller method.\n * - `'class'`  — `@LoadX` on a controller class.\n * - `'module'` — returned by `AppModule.contributors?()`. Per-module scope.\n * - `'adapter'` — returned by `AppAdapter.contributors?()`. Cross-cutting, applies\n *   to every module's routes.\n * - `'global'` — `ApplicationOptions.contributors`. App-wide default.\n */\nexport type ContributorSource = 'method' | 'class' | 'module' | 'adapter' | 'global'\n\n/** Precedence-ranked source list. Index = precedence; method (0) wins ties. */\nconst PRECEDENCE_ORDER: readonly ContributorSource[] = [\n  'method',\n  'class',\n  'module',\n  'adapter',\n  'global',\n]\n\n/**\n * Input row to {@link buildPipeline}. Pairs a registration with its origin\n * so dedup can apply the precedence rule and diagnostic errors can name\n * the offending site.\n *\n * `registration` is the type-erased {@link AnyContributorRegistration}\n * — the runner doesn't care about each registration's narrow `D` /\n * `Ctx` shape, and adopters frequently mix HTTP / transport-agnostic\n * contributors in the same `externalSources` / `contributors()`\n * array. The narrow generics from `defineContextDecorator` survive\n * at the *definition* site (where `resolve` is typed); they're erased\n * here so collections compose without `as any` casts.\n */\nexport interface SourcedRegistration {\n  registration: AnyContributorRegistration\n  source: ContributorSource\n  /** Human label surfaced in DuplicateContributorError messages. */\n  label?: string\n}\n\n/**\n * Resolved, validated, topo-sorted pipeline ready for execution.\n *\n * `contributors` is in execution order — every entry's `dependsOn`\n * keys appear earlier. `keys` is the set of all keys this pipeline\n * produces; the runner uses it for fast existence checks and the\n * builder uses it for missing-dep validation.\n */\nexport interface ContributorPipeline {\n  readonly contributors: readonly AnyContributorRegistration[]\n  readonly keys: ReadonlySet<string>\n}\n\nexport interface BuildPipelineOptions {\n  /** Optional route identifier surfaced in diagnostic errors (e.g., 'GET /projects/:id'). */\n  route?: string\n}\n\n/**\n * Build, validate, and topo-sort a contributor pipeline.\n *\n * Pipeline:\n *\n * 1. Group sources by precedence (method > class > module > adapter > global).\n * 2. Within each precedence level, two contributors with the same `key`\n *    raise {@link DuplicateContributorError}.\n * 3. Across levels, the highest-precedence contributor wins each key\n *    (lower-precedence duplicates are silently dropped — that is the\n *    documented override mechanism, not an error).\n * 4. Every key referenced by `dependsOn` must be produced by the\n *    surviving set, otherwise {@link MissingContributorError}.\n * 5. Kahn's algorithm topo-sorts the survivors. Any nodes left after\n *    the queue drains form a cycle → {@link ContributorCycleError}\n *    with a reconstructed path.\n *\n * Pure function — no DI, no I/O. Safe to call once at startup per\n * route and cache the result.\n */\nexport function buildPipeline(\n  sources: readonly SourcedRegistration[],\n  options: BuildPipelineOptions = {},\n): ContributorPipeline {\n  const route = options.route\n\n  // Step 1: group by source.\n  const bySource = new Map<ContributorSource, SourcedRegistration[]>()\n  for (const src of PRECEDENCE_ORDER) bySource.set(src, [])\n  for (const entry of sources) bySource.get(entry.source)!.push(entry)\n\n  // Step 2 + 3: dedup with precedence. We walk highest precedence first,\n  // claim its keys, and drop lower-precedence rows that conflict.\n  const winners = new Map<string, SourcedRegistration>()\n  for (const src of PRECEDENCE_ORDER) {\n    const rows = bySource.get(src)!\n    const keysAtThisLevel = new Map<string, SourcedRegistration[]>()\n    for (const row of rows) {\n      const key = row.registration.key\n      const existing = keysAtThisLevel.get(key) ?? []\n      existing.push(row)\n      keysAtThisLevel.set(key, existing)\n    }\n    for (const [key, rowsForKey] of keysAtThisLevel) {\n      if (rowsForKey.length > 1) {\n        const labels = rowsForKey.map((r, i) => r.label ?? `${src}#${i}`)\n        throw new DuplicateContributorError(key, labels)\n      }\n      if (!winners.has(key)) winners.set(key, rowsForKey[0])\n    }\n  }\n\n  const survivors = [...winners.values()].map((r) => r.registration)\n  const allKeys = new Set(survivors.map((r) => r.key))\n\n  // Step 4: dependsOn validation.\n  for (const reg of survivors) {\n    for (const dep of reg.dependsOn) {\n      if (!allKeys.has(dep)) {\n        throw new MissingContributorError(dep, reg.key, route)\n      }\n    }\n  }\n\n  // Step 5: Kahn topo-sort.\n  const sorted = topoSort(survivors, route)\n\n  return Object.freeze({\n    contributors: Object.freeze(sorted),\n    keys: allKeys,\n  })\n}\n\n/**\n * Kahn's algorithm with deterministic ordering on ties.\n *\n * Nodes with no remaining incoming edges enter the queue in input\n * order. Cycles surface as nodes still present after the queue\n * drains; we reconstruct one cycle path for diagnostics.\n */\nfunction topoSort(\n  registrations: readonly AnyContributorRegistration[],\n  route: string | undefined,\n): AnyContributorRegistration[] {\n  // indegree[key] = number of unresolved dependsOn entries for key\n  const indegree = new Map<string, number>()\n  // dependents[depKey] = list of registrations that depend on depKey\n  const dependents = new Map<string, AnyContributorRegistration[]>()\n  const byKey = new Map<string, AnyContributorRegistration>()\n\n  for (const reg of registrations) {\n    indegree.set(reg.key, reg.dependsOn.length)\n    byKey.set(reg.key, reg)\n  }\n  for (const reg of registrations) {\n    for (const dep of reg.dependsOn) {\n      const list = dependents.get(dep) ?? []\n      list.push(reg)\n      dependents.set(dep, list)\n    }\n  }\n\n  // Initial queue: registrations with zero indegree, preserving input order.\n  const queue: AnyContributorRegistration[] = []\n  for (const reg of registrations) {\n    if (indegree.get(reg.key) === 0) queue.push(reg)\n  }\n\n  const sorted: AnyContributorRegistration[] = []\n  while (queue.length > 0) {\n    const node = queue.shift()!\n    sorted.push(node)\n    for (const dependent of dependents.get(node.key) ?? []) {\n      const next = (indegree.get(dependent.key) ?? 0) - 1\n      indegree.set(dependent.key, next)\n      if (next === 0) queue.push(dependent)\n    }\n  }\n\n  if (sorted.length !== registrations.length) {\n    const remaining = registrations.filter((r) => (indegree.get(r.key) ?? 0) > 0)\n    throw new ContributorCycleError(reconstructCycle(remaining, byKey), route)\n  }\n\n  return sorted\n}\n\n/**\n * Reconstruct one cycle path from the residual graph.\n *\n * Walks from any remaining node, following its first dependency that's\n * still in the residual set, until we revisit a node. The path returned\n * starts and ends with the same key so the message reads naturally:\n * `tenant → project → tenant`.\n */\nfunction reconstructCycle(\n  residual: readonly AnyContributorRegistration[],\n  byKey: ReadonlyMap<string, AnyContributorRegistration>,\n): string[] {\n  const residualKeys = new Set(residual.map((r) => r.key))\n  const start = residual[0].key\n  const path: string[] = [start]\n  const seen = new Set<string>([start])\n  let cursor: string = start\n\n  while (true) {\n    const reg = byKey.get(cursor)!\n    const nextDep = reg.dependsOn.find((d) => residualKeys.has(d))\n    if (nextDep === undefined) break\n    if (seen.has(nextDep)) {\n      // Trim the prefix that isn't part of the cycle.\n      const cycleStart = path.indexOf(nextDep)\n      return [...path.slice(cycleStart), nextDep]\n    }\n    path.push(nextDep)\n    seen.add(nextDep)\n    cursor = nextDep\n  }\n\n  // Fallback — couldn't reconstruct a strict cycle, return what we walked.\n  return path\n}\n","import type { Container } from './container'\nimport type { ContributorRegistration } from './context-decorator'\nimport type { ExecutionContext } from './execution-context'\nimport type { ContributorPipeline } from './contributor-pipeline'\n\nexport interface RunContributorsOptions {\n  /** Pre-built, validated, topo-sorted pipeline. */\n  pipeline: ContributorPipeline\n  /** The execution context contributors read from and write into. */\n  ctx: ExecutionContext\n  /** DI container used to resolve declared `deps`. */\n  container: Container\n}\n\n/**\n * Execute a built {@link ContributorPipeline} against an {@link ExecutionContext}.\n *\n * Sequential — one contributor at a time, in the topo order chosen at\n * pipeline-build time. Per `architecture.md` §20.10, V1 does not run\n * contributors in parallel even within the same topo level; that is a\n * V2 follow-up gated on profiling.\n *\n * ## Error matrix (architecture.md §20.9)\n *\n * | resolve outcome | optional | onError defined | runner behaviour                                 |\n * |-----------------|----------|-----------------|--------------------------------------------------|\n * | throws          | true     | —               | skip; `ctx.get(key)` remains undefined           |\n * | throws          | false    | yes             | call hook; returned value (if any) stored        |\n * | throws          | false    | no              | propagate the original error                     |\n * | hook throws     | —        | yes             | propagate the new error                          |\n * | hook returns    | —        | yes             | undefined/void → skip; value → `ctx.set(key, v)` |\n * | resolves        | —        | —               | `ctx.set(key, value)`                            |\n *\n * Container.resolve() throwing while building `deps` is treated as a\n * resolve-side throw and flows through the same matrix — adopters who\n * need different behaviour for missing-DI vs. data-lookup failures can\n * wrap the container access inside their own `resolve()`.\n */\nexport async function runContributors(options: RunContributorsOptions): Promise<void> {\n  const { pipeline, ctx, container } = options\n\n  for (const reg of pipeline.contributors) {\n    await runOne(reg, ctx, container)\n  }\n}\n\nasync function runOne(\n  reg: ContributorRegistration,\n  ctx: ExecutionContext,\n  container: Container,\n): Promise<void> {\n  let value: unknown\n  try {\n    const deps = resolveDeps(reg, container)\n    value = await reg.resolve(ctx, deps)\n  } catch (err) {\n    if (reg.optional) return\n    if (reg.onError) {\n      // Hook throws are unconditionally propagated — there is no\n      // second-chance hook. Returning undefined/void from the hook\n      // means \"skip\"; returning a value means \"use this instead\".\n      const replacement = await reg.onError(err, ctx)\n      if (replacement === undefined) return\n      ctx.set(reg.key, replacement as never)\n      return\n    }\n    throw err\n  }\n  ctx.set(reg.key, value as never)\n}\n\n/**\n * Resolve a contributor's declared dependencies through the container,\n * preserving the property names from the spec so `resolve(ctx, deps)`\n * receives exactly the shape the user wrote.\n *\n * Empty `deps` produces an empty object — `resolve()` always sees an\n * object, never `undefined`.\n */\nfunction resolveDeps(reg: ContributorRegistration, container: Container): Record<string, unknown> {\n  const out: Record<string, unknown> = {}\n  for (const [key, token] of Object.entries(reg.deps)) {\n    out[key] = container.resolve(token as never)\n  }\n  return out\n}\n","/**\n * Topological sort for plugins and adapters with `dependsOn` declarations.\n *\n * Mirrors the algorithm used by the Context Contributor pipeline\n * (`contributor-pipeline.ts:topoSort`) but operates on a name-keyed\n * `MountSortItem` shape rather than a `ContributorRegistration`. Kept\n * standalone instead of factored generic so that:\n *\n * 1. The contributor pipeline doesn't need refactoring (risk reduction).\n * 2. The error classes can carry plugin/adapter-specific diagnostic\n *    fields (`kind`, `dependent`) without bending the contributor types.\n */\n\n/**\n * A plugin or adapter that participates in dependency-ordered mounting.\n * Both `KickPlugin` and `AppAdapter` satisfy this shape via their `name`\n * and `dependsOn` fields.\n */\nexport interface MountSortItem {\n  /** Unique mount name within the plugin/adapter set being sorted. */\n  name: string\n  /**\n   * Other plugin/adapter names that must mount before this one. Cycles\n   * and missing names fail at boot — same fail-fast contract as the\n   * Context Contributor pipeline (architecture.md §20.4).\n   */\n  dependsOn?: readonly string[]\n}\n\n/** What kind of mount set the sort is operating on — surfaces in error messages. */\nexport type MountKind = 'plugin' | 'adapter'\n\n/**\n * Two items in the same mount set declared the same `name`. Plugin/adapter\n * names must be unique so `dependsOn` references resolve unambiguously.\n */\nexport class DuplicateMountNameError extends Error {\n  readonly kind: MountKind\n  readonly mountName: string\n\n  constructor(kind: MountKind, mountName: string) {\n    super(`Duplicate ${kind} name '${mountName}' — every ${kind} must declare a unique name`)\n    this.name = 'DuplicateMountNameError'\n    this.kind = kind\n    this.mountName = mountName\n  }\n}\n\n/**\n * A `dependsOn` entry references a plugin/adapter that isn't in the\n * current set. The dependency might not be installed, might be misspelled,\n * or might live in a different mount set (plugin referencing an adapter,\n * or vice versa — they sort independently).\n */\nexport class MissingMountDepError extends Error {\n  readonly kind: MountKind\n  readonly missing: string\n  readonly dependent: string\n\n  constructor(kind: MountKind, missing: string, dependent: string) {\n    super(\n      `Missing ${kind} dependency '${missing}' required by '${dependent}' — ` +\n        `is the ${kind} installed and named correctly?`,\n    )\n    this.name = 'MissingMountDepError'\n    this.kind = kind\n    this.missing = missing\n    this.dependent = dependent\n  }\n}\n\n/**\n * The `dependsOn` declarations form a cycle. Boot fails so the cycle\n * can't poison live traffic. The `cycle` field reports one path through\n * the offending nodes for diagnostics — formatted `A → B → C → A`.\n */\nexport class MountCycleError extends Error {\n  readonly kind: MountKind\n  readonly cycle: readonly string[]\n\n  constructor(kind: MountKind, cycle: readonly string[]) {\n    super(`Cycle in ${kind} dependsOn declarations: ${cycle.join(' → ')}`)\n    this.name = 'MountCycleError'\n    this.kind = kind\n    this.cycle = Object.freeze([...cycle])\n  }\n}\n\n/**\n * Topologically sort `items` so every item with `dependsOn: ['X']` mounts\n * after `X`. Items without `dependsOn` keep their input order via Kahn's\n * algorithm with a FIFO queue seeded in input order — preserves the\n * historical \"plugins/adapters mount in declaration order\" behaviour for\n * any set that doesn't use `dependsOn`.\n *\n * @param items - mountable items, e.g. plugins or adapters\n * @param kind - 'plugin' | 'adapter', used in error messages\n * @returns a new array in valid mount order\n * @throws {DuplicateMountNameError} two items share a name\n * @throws {MissingMountDepError} a `dependsOn` references an unknown name\n * @throws {MountCycleError} the dep graph contains a cycle\n */\nexport function mountSort<T extends MountSortItem>(items: readonly T[], kind: MountKind): T[] {\n  const byName = new Map<string, T>()\n  for (const item of items) {\n    if (byName.has(item.name)) {\n      throw new DuplicateMountNameError(kind, item.name)\n    }\n    byName.set(item.name, item)\n  }\n\n  // indegree[name] = number of unresolved deps for that item\n  const indegree = new Map<string, number>()\n  // dependents[depName] = items that depend on depName\n  const dependents = new Map<string, T[]>()\n\n  for (const item of items) {\n    indegree.set(item.name, item.dependsOn?.length ?? 0)\n  }\n  for (const item of items) {\n    for (const dep of item.dependsOn ?? []) {\n      if (!byName.has(dep)) {\n        throw new MissingMountDepError(kind, dep, item.name)\n      }\n      const list = dependents.get(dep) ?? []\n      list.push(item)\n      dependents.set(dep, list)\n    }\n  }\n\n  // Initial queue: items with zero indegree, preserving input order.\n  const queue: T[] = []\n  for (const item of items) {\n    if (indegree.get(item.name) === 0) queue.push(item)\n  }\n\n  const sorted: T[] = []\n  while (queue.length > 0) {\n    const node = queue.shift()!\n    sorted.push(node)\n    for (const dependent of dependents.get(node.name) ?? []) {\n      const next = (indegree.get(dependent.name) ?? 0) - 1\n      indegree.set(dependent.name, next)\n      if (next === 0) queue.push(dependent)\n    }\n  }\n\n  if (sorted.length !== items.length) {\n    const remaining = items.filter((it) => (indegree.get(it.name) ?? 0) > 0)\n    throw new MountCycleError(kind, reconstructCycle(remaining, byName))\n  }\n\n  return sorted\n}\n\n/**\n * Walk the residual graph to find one cycle path for diagnostics.\n * Starts from the first remaining node and follows the first dep that's\n * still in the residual set until we revisit a node. Returns a path\n * starting and ending with the same name so the message reads naturally\n * (`A → B → C → A`).\n */\nfunction reconstructCycle<T extends MountSortItem>(\n  residual: readonly T[],\n  byName: ReadonlyMap<string, T>,\n): string[] {\n  const residualNames = new Set(residual.map((r) => r.name))\n  const start = residual[0].name\n  const path: string[] = [start]\n  const seen = new Set<string>([start])\n  let cursor = start\n\n  while (true) {\n    const item = byName.get(cursor)!\n    const nextDep = item.dependsOn?.find((d) => residualNames.has(d))\n    if (nextDep === undefined) break\n    if (seen.has(nextDep)) {\n      const cycleStart = path.indexOf(nextDep)\n      return [...path.slice(cycleStart), nextDep]\n    }\n    path.push(nextDep)\n    seen.add(nextDep)\n    cursor = nextDep\n  }\n\n  return path\n}\n","import type { Container } from './container'\nimport type { KickPlugin } from './plugin'\n\n/**\n * Options passed to {@link definePlugin}. Mirrors the spec in\n * `architecture.md` §21.3.1 + §21.2.2 (Phase A \"lite\").\n */\nexport interface DefinePluginOptions<TConfig> {\n  /** Stable identity used for logging, `dependsOn` lookups, and `.scoped()` namespacing. */\n  name: string\n\n  /** Optional plugin version — surfaced to DevTools and `kick add` compatibility checks (Phase B). */\n  version?: string\n\n  /**\n   * Peer-version ranges this plugin needs from the framework or other\n   * plugins. Recorded as metadata; runtime enforcement lands in §21.4.4.\n   */\n  requires?: { kickjs?: string }\n\n  /** Default config merged under any caller overrides. */\n  defaults?: Partial<TConfig>\n\n  /** Builds the underlying {@link KickPlugin} from the resolved config. */\n  build(config: TConfig, ctx: BuildContext): Omit<KickPlugin, 'name'>\n}\n\n/**\n * Hook context handed to a plugin/adapter `build` function. `name` is the\n * resolved instance name (the bare definition name for the bare call,\n * or `${defName}:${scope}` for `.scoped()`). `scoped` is the discriminator\n * authors use to namespace DI tokens or resource keys.\n */\nexport interface BuildContext {\n  name: string\n  scoped: boolean\n}\n\n/**\n * Async-config form of a plugin or adapter — `inject` lists DI tokens to\n * resolve from the container, then `useFactory` produces the config.\n *\n * Plugins resolve this lazily inside `onReady`, so any module/adapter/\n * middleware/contributor a plugin contributes via `build` is **not\n * available** when `.async()` is used. Use the bare/`.scoped()` form for\n * plugins that need to register modules or middleware.\n */\nexport interface PluginAsyncOptions<TConfig> {\n  inject?: ReadonlyArray<unknown>\n  useFactory(...deps: any[]): TConfig | Promise<TConfig>\n}\n\n/**\n * Factory returned by {@link definePlugin}. Callable form is the singleton\n * (`AuthPlugin(config)`); `.scoped()` and `.async()` are the multi-instance\n * and deferred-config forms.\n */\nexport interface PluginFactory<TConfig> {\n  (config?: Partial<TConfig>): KickPlugin\n  scoped(scopeName: string, config?: Partial<TConfig>): KickPlugin\n  async(opts: PluginAsyncOptions<TConfig>): KickPlugin\n  /** Read-only access to the original definition — useful for DevTools introspection. */\n  readonly definition: Readonly<DefinePluginOptions<TConfig>>\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 a {@link KickPlugin} factory from a typed definition. See\n * `architecture.md` §21.2.2 for the design rationale.\n *\n * @example\n * ```ts\n * const FlagsPlugin = definePlugin<FlagsConfig>({\n *   name: 'FlagsPlugin',\n *   defaults: { defaultTtl: 60_000 },\n *   build(config) {\n *     return {\n *       register(container) {\n *         container.registerInstance(FLAGS, makeProvider(config))\n *       },\n *     }\n *   },\n * })\n *\n * bootstrap({ plugins: [FlagsPlugin({ provider: launchDarkly })] })\n * ```\n */\nexport function definePlugin<TConfig = Record<string, unknown>>(\n  options: DefinePluginOptions<TConfig>,\n): PluginFactory<TConfig> {\n  const buildSync = (\n    instanceName: string,\n    scoped: boolean,\n    overrides?: Partial<TConfig>,\n  ): KickPlugin => {\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    const built = options.build(config, { name: instanceName, scoped }) as KickPlugin\n    built.name = instanceName\n    return built\n  }\n\n  const buildAsync = (instanceName: string, opts: PluginAsyncOptions<TConfig>): KickPlugin => {\n    let inner: KickPlugin | undefined\n\n    const ensureInner = async (container: Container): Promise<KickPlugin> => {\n      if (inner) return inner\n      const deps = (opts.inject ?? []).map((tok) => container.resolve(tok as never))\n      const config = await opts.useFactory(...deps)\n      inner = buildSync(instanceName, false, config as Partial<TConfig>)\n      return inner\n    }\n\n    return {\n      name: instanceName,\n      async onReady(container: Container) {\n        const built = await ensureInner(container)\n        // Run the inner plugin's register() now that we have the config —\n        // late but better than never; `.async()` plugins skip the early\n        // module/middleware contribution surface by design.\n        built.register?.(container)\n        await built.onReady?.(container)\n      },\n      async shutdown() {\n        await inner?.shutdown?.()\n      },\n    }\n  }\n\n  const factory = ((config?: Partial<TConfig>) =>\n    buildSync(options.name, false, config)) as PluginFactory<TConfig>\n\n  factory.scoped = (scopeName: string, config?: Partial<TConfig>) =>\n    buildSync(composeName(options.name, scopeName), true, config)\n\n  factory.async = (opts: PluginAsyncOptions<TConfig>) => buildAsync(options.name, opts)\n\n  Object.defineProperty(factory, 'definition', { value: Object.freeze({ ...options }) })\n\n  return factory\n}\n","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","/**\n * Augmentation registry — runtime no-op + the canonical\n * `KickJsPluginRegistry` interface that `kick typegen` augments.\n *\n * See `architecture.md` §21.2.1 (typegen for `dependsOn`) and §21.3.3\n * (standardized augmentation registry) for the design rationale.\n *\n * @module @forinda/kickjs/core/augmentation\n */\n\n/**\n * Marker interface that lists every plugin/adapter in the project. The\n * keys are the literal `name` field passed to `defineAdapter` /\n * `definePlugin` (or declared on a `class implements AppAdapter`); the\n * values are the kind tag (`'plugin' | 'adapter'`).\n *\n * The framework ships this empty. `kick typegen` augments it from\n * source so `keyof KickJsPluginRegistry` resolves to a string-literal\n * union of every name in scope — and therefore so do `dependsOn`\n * declarations on plugins/adapters.\n */\nexport interface KickJsPluginRegistry {}\n\n/**\n * Resolves to a string-literal union of every registered plugin/adapter\n * name when the project's typegen has populated `KickJsPluginRegistry`,\n * or to `string` when the registry is empty (no typegen pass yet).\n *\n * Falling back to `string` keeps fresh projects compiling — the typegen\n * narrowing is a progressive enhancement, not a hard prerequisite.\n */\nexport type KickJsPluginName = keyof KickJsPluginRegistry extends never\n  ? string\n  : keyof KickJsPluginRegistry & string\n\n/**\n * Metadata attached to a `defineAugmentation` call. The fields are\n * documentation-only — `kick typegen` surfaces them in the generated\n * `.kickjs/types/augmentations.d.ts` so adopters can browse every\n * augmentable interface from one place.\n *\n * `description` and `example` may both be multi-line — typegen preserves\n * line breaks when rendering them as JSDoc. There is no upper limit on\n * the example size; entire shape definitions or worked snippets are fine.\n */\nexport interface AugmentationMeta {\n  /**\n   * Free-form description of what the augmentation customises. May be\n   * multi-line — newlines are preserved in the generated JSDoc.\n   */\n  description?: string\n  /**\n   * TS snippet showing a typical shape. May be multi-line; rendered\n   * inside a fenced code block in the generated catalogue. Use this\n   * for anything from `'{ foo: string }'` up to a full interface body\n   * — typegen no longer flattens newlines.\n   */\n  example?: string\n}\n\n/**\n * Advertise an augmentable interface so `kick typegen` can list it in\n * `.kickjs/types/augmentations.d.ts` for project-wide discovery.\n *\n * **This function is a runtime AND type-level no-op.** It does NOT\n * augment the interface for TypeScript. The actual augmentation is\n * the `declare module` block — `defineAugmentation` only adds an\n * entry to the typegen catalogue so other contributors / adopters\n * can find the interface and know its expected shape.\n *\n * Both calls are needed:\n *\n * ```ts\n * import { defineAugmentation } from '@forinda/kickjs'\n *\n * // (1) The actual TS augmentation — what `ctx.get('tenant')` reads.\n * declare module '@forinda/kickjs' {\n *   interface ContextMeta {\n *     tenant: { id: string; name: string }\n *   }\n * }\n *\n * // (2) Catalogue entry — what `kick typegen` lists in\n * //     `.kickjs/types/augmentations.d.ts` for browseability.\n * defineAugmentation('ContextMeta', {\n *   description: 'Tenant resolved from x-tenant-id by TenantAdapter',\n *   example: `{\n *     tenant: {\n *       id: string\n *       name: string\n *       plan: 'free' | 'pro' | 'enterprise'\n *       featureFlags: Record<string, boolean>\n *     }\n *   }`,\n * })\n * ```\n *\n * Skip `defineAugmentation` if you don't care about the catalogue — the\n * `declare module` block alone is enough for runtime + type behaviour.\n */\nexport function defineAugmentation(name: string, meta?: AugmentationMeta): void {\n  // No-op at runtime — `kick typegen` discovers the call statically and\n  // emits the augmentation catalogue. Touch the args so esbuild / tsc\n  // don't drop the call as dead code under aggressive minification\n  // (the marker has to survive the build for static scanners that look\n  // at compiled output, e.g. third-party tools).\n  void name\n  void meta\n}\n"],"mappings":"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"}

package/dist/index-DvZfBNIf.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-DvZfBNIf.d.mts","names":[],"sources":["../src/core/metadata.ts","../src/core/circuit-breaker.ts","../src/core/context-errors.ts","../src/core/contributor-pipeline.ts","../src/core/contributor-runner.ts","../src/core/mount-sort.ts","../src/core/define-plugin.ts","../src/core/define-adapter.ts","../src/core/asset-keys.ts"],"mappings":"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"}

package/dist/plugin-DF8Xfv9Z.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"plugin-DF8Xfv9Z.d.mts","names":[],"sources":["../src/core/plugin.ts"],"mappings":";;;;;;;;AA0DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAAiB,UAAA;;EAEf,IAAA;;;;;;;;;;;;;;;;;;;EAoBA,SAAA,YAAqB,gBAAA;;;;;EAMrB,QAAA,EAAU,SAAA,EAAW,SAAA;;;;;EAMrB,OAAA,KAAY,cAAA;;;;;EAMZ,QAAA,KAAa,UAAA;;;;;EAMb,UAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgCA,YAAA,KAAiB,wBAAA;;;;;EAMjB,OAAA,EAAS,SAAA,EAAW,SAAA,UAAmB,OAAA;;;;;EAMvC,QAAA,YAAoB,OAAA;;;;;;;;;;;;;EAcpB,UAAA,eAAyB,OAAA;;;;;;EAOzB,YAAA;AAAA"}