@forinda/kickjs 9.1.0 → 10.0.0

package/dist/context-BGPof8bs.mjs.map

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

package/dist/contributor-runner-BSpshfPN.mjs

@@ -1,12 +0,0 @@
-/**
- * @forinda/kickjs v9.1.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{s as matchesFlagTest}from"./route-flag-sIYXay3q.mjs";function shouldRun(reg,ctx,flags){if(reg.skipWhen===void 0&&reg.onlyWhen===void 0)return!0;let resolved=flags??EMPTY_FLAGS,route=ctx.route;return!(reg.skipWhen!==void 0&&matchesFlagTest(reg.skipWhen,resolved,route)||reg.onlyWhen!==void 0&&!matchesFlagTest(reg.onlyWhen,resolved,route))}const EMPTY_FLAGS=new Map;async function runContributors(options){let{pipeline,ctx,container,flags}=options;for(let reg of pipeline.contributors)shouldRun(reg,ctx,flags)&&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}export{runContributors as t};
-//# sourceMappingURL=contributor-runner-BSpshfPN.mjs.map

package/dist/core-_WNyghl_.mjs

@@ -1,12 +0,0 @@
-/**
- * @forinda/kickjs v9.1.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{l as __require}from"./env-DtJ-6gyL.mjs";import{METADATA}from"./core/interfaces.mjs";import{i as createToken,p as _setAssetResolver}from"./container-ZnfelY_a.mjs";import"./core/logger.mjs";import{c as pushClassMeta,l as pushMethodMeta}from"./metadata-CW4I35nN.mjs";import"./core/decorators.mjs";import"./core/cron.mjs";import"./jobs-dx-MTUUb.mjs";import"./core/cache.mjs";import{n as assertFlagTest}from"./route-flag-sIYXay3q.mjs";import"./contributor-runner-BSpshfPN.mjs";import"reflect-metadata";import{existsSync,readFileSync,readdirSync}from"node:fs";import{isAbsolute,join,resolve,sep}from"node:path";function defineContextDecoratorImpl(spec){if(typeof spec!=`object`||!spec)throw TypeError(`defineContextDecorator: spec must be an object literal. See architecture.md §20.4 for the spec shape.`);if(typeof spec.key!=`string`||spec.key.length===0){let got=typeof spec.key==`string`?`""`:typeof spec.key;throw TypeError(`defineContextDecorator: spec.key must be a non-empty string (got ${got}). Pick a name that matches a key declared on \`ContextMeta\` (or one of the framework keys).`)}if(typeof spec.resolve!=`function`)throw TypeError(`defineContextDecorator(${spec.key}): spec.resolve is required and must be a function (got ${typeof spec.resolve}). Each contributor needs a resolver that produces the value to write into ctx.set(${JSON.stringify(spec.key)}, …).`);if(spec.onError!==void 0&&typeof spec.onError!=`function`)throw TypeError(`defineContextDecorator(${spec.key}): spec.onError must be a function when provided (got ${typeof spec.onError}).`);if(spec.dependsOn!==void 0&&!Array.isArray(spec.dependsOn))throw TypeError(`defineContextDecorator(${spec.key}): spec.dependsOn must be an array when provided (got ${typeof spec.dependsOn}).`);if(spec.requiredParams!==void 0&&!Array.isArray(spec.requiredParams))throw TypeError(`defineContextDecorator(${spec.key}): spec.requiredParams must be an array when provided (got ${typeof spec.requiredParams}).`);if(Array.isArray(spec.requiredParams)&&spec.requiredParams.some(p=>typeof p!=`string`||p.length===0))throw TypeError(`defineContextDecorator(${spec.key}): spec.requiredParams entries must be non-empty strings.`);if(Array.isArray(spec.dependsOn)&&spec.dependsOn.some(dep=>typeof dep!=`string`||dep.length===0))throw TypeError(`defineContextDecorator(${spec.key}): spec.dependsOn entries must be non-empty strings.`);let definedAt=Error().stack,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 spec.skipWhen!==void 0&&assertFlagTest(spec.skipWhen,`contributor '${spec.key}' skipWhen`),spec.onlyWhen!==void 0&&assertFlagTest(spec.onlyWhen,`contributor '${spec.key}' onlyWhen`),Object.freeze({key:spec.key,deps:sharedDeps,dependsOn:sharedDependsOn,optional:sharedOptional,skipWhen:spec.skipWhen,onlyWhen:spec.onlyWhen,beforeValidation:spec.beforeValidation===!0,onError,resolve:(ctx,deps)=>spec.resolve(ctx,deps,frozenParams),definedAt})},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}},sharedRequiredParams=Object.freeze([...spec.requiredParams??[]]),assertRequiredParams=(params,usage)=>{if(sharedRequiredParams.length===0)return;let missing=sharedRequiredParams.filter(name=>params[name]===void 0);if(missing.length!==0)throw TypeError(`defineContextDecorator(${spec.key}): ${usage} is missing required param(s) ${missing.map(m=>`'${m}'`).join(`, `)}. Supply them at the call site — e.g. \`@${spec.key}({ ${missing[0]}: … })\` — or add a default in \`paramDefaults\` if one is genuinely correct for every route.`)};function decoratorOrFactory(...args){if(isDecoratorCall(args)){let[target,propertyKey]=args;assertRequiredParams({...defaults},"bare `@decorator` usage"),applyAsDecorator(defaultRegistration,target,propertyKey);return}let params=mergeParams(args[0]);assertRequiredParams(params,`factory call`);let registration=buildRegistration(params);return(target,propertyKey)=>{applyAsDecorator(registration,target,propertyKey)}}Object.defineProperty(decoratorOrFactory,"name",{value:`ContextDecorator(${spec.key})`,writable:!1,enumerable:!1,configurable:!0});let decorator=Object.assign(decoratorOrFactory,{with:params=>{let merged=mergeParams(params);return assertRequiredParams(merged,"`.with()`"),{registration:buildRegistration(merged)}}});return Object.defineProperty(decorator,"registration",{get(){return assertRequiredParams({...defaults},"`.registration`"),defaultRegistration},enumerable:!0,configurable:!1}),Object.freeze(decorator)}const defineContextDecorator=Object.freeze(Object.assign(defineContextDecoratorImpl,{withParams:()=>spec=>defineContextDecoratorImpl(spec)}));function groupAssetKeys(namespace,paths,opts={}){let strategy=opts.strategy??`auto`;if(strategy===`with-extension`)return{pairs:paths.map(rel=>({rel,key:`${namespace}/${rel}`})),collisionGroupsResolved:0};if(strategy===`strip`)return{pairs:paths.map(rel=>({rel,key:`${namespace}/${stripExt(rel)}`})),collisionGroupsResolved:0};let groups=new Map;for(let rel of paths){let strippedKey=`${namespace}/${stripExt(rel)}`,arr=groups.get(strippedKey);arr?arr.push(rel):groups.set(strippedKey,[rel])}let collisionGroupsResolved=0,keyByRel=new Map;for(let[strippedKey,rels]of groups)if(rels.length===1)keyByRel.set(rels[0],strippedKey);else{collisionGroupsResolved+=1;for(let rel of rels)keyByRel.set(rel,`${namespace}/${rel}`)}return{pairs:paths.map(rel=>({rel,key:keyByRel.get(rel)??`${namespace}/${rel}`})),collisionGroupsResolved}}function stripExt(path){let lastSlash=path.lastIndexOf(`/`),filename=lastSlash>=0?path.slice(lastSlash+1):path,lastDot=filename.lastIndexOf(`.`);return lastDot<=0?path:(lastSlash>=0?path.slice(0,lastSlash+1):``)+filename.slice(0,lastDot)}const ASSET_MANIFEST_VERSION=1,ASSETS=createToken(`kick/assets/Map`);var UnknownAssetError=class extends Error{namespace;key;constructor(namespace,key){super(`Unknown asset '${namespace}/${key}'. Make sure the namespace exists in kick.config.ts assetMap and that the file is present in the source directory.`),this.name=`UnknownAssetError`,this.namespace=namespace,this.key=key}};let manifestCache;function toPosixPath(p){return p.replaceAll(`\\`,`/`)}function resolveAsset(namespace,key){let resolved=loadManifest();if(!resolved)throw new UnknownAssetError(namespace,key);let entry=resolved.manifest.entries[`${namespace}/${key}`];if(!entry)throw new UnknownAssetError(namespace,key);return toPosixPath(isAbsolute(entry)?entry:resolve(resolved.root,entry))}function clearAssetCache(){manifestCache=void 0}function loadManifest(){return process.env.NODE_ENV===`production`?(manifestCache===void 0&&(manifestCache=discoverManifest()),manifestCache):discoverManifest()}function discoverManifest(){let envRoot=process.env.KICK_ASSETS_ROOT;if(envRoot){let fromEnv=readBuiltManifest(envRoot);if(fromEnv)return fromEnv}let cwd=process.cwd(),config=loadConfigSync(cwd);if(process.env.NODE_ENV!==`production`){let fresh=synthesiseDevManifest(cwd,config);if(fresh)return fresh}let configOutDir=config?.build?.outDir;if(configOutDir&&!STANDARD_OUT_DIRS.includes(configOutDir)){let found=readBuiltManifest(resolve(cwd,configOutDir));if(found)return found}for(let candidate of STANDARD_OUT_DIRS){let found=readBuiltManifest(join(cwd,candidate));if(found)return found}return synthesiseDevManifest(cwd,config)}const STANDARD_OUT_DIRS=[`dist`,`build`,`out`];function readBuiltManifest(dir){let path=join(dir,`.kickjs-assets.json`);if(!existsSync(path))return null;try{let raw=readFileSync(path,`utf-8`),parsed=JSON.parse(raw);return parsed.version!==1||!parsed.entries||typeof parsed.entries!=`object`?null:{manifest:parsed,root:resolve(dir)}}catch{return null}}function synthesiseDevManifest(cwd,preloadedConfig){let config=preloadedConfig===void 0?loadConfigSync(cwd):preloadedConfig;if(!config?.assetMap)return null;let entries={};for(let[namespace,entry]of Object.entries(config.assetMap)){if(!entry||typeof entry.src!=`string`)continue;let srcAbs=resolve(cwd,entry.src);if(!existsSync(srcAbs))continue;let collected=[];walkSync(srcAbs,srcAbs,(relPath,absPath)=>{(!entry.glob||matchesGlobLite(relPath,entry.glob,namespace))&&collected.push({rel:relPath,abs:absPath})}),collected.sort((a,b)=>a.rel.localeCompare(b.rel));let{pairs,collisionGroupsResolved}=groupAssetKeys(namespace,collected.map(c=>c.rel),{strategy:entry.keys??`auto`}),absByRel=new Map(collected.map(c=>[c.rel,c.abs]));for(let{rel,key}of pairs){let abs=absByRel.get(rel);abs&&(entries[key]=abs)}collisionGroupsResolved>0&&process.env.NODE_ENV!==`production`&&console.log(`[kickjs/assets] '${namespace}': ${collisionGroupsResolved} basename collision(s) auto-resolved by keeping extensions (set assetMap.${namespace}.keys to 'strip' or 'with-extension' to override).`)}return{manifest:{version:1,entries},root:cwd}}const warnedGlobs=new Set;function matchesGlobLite(relPath,pattern,namespace){if(pattern===`**/*`||pattern===`**`)return!0;let singleExt=/^\*\*\/\*\.(\w+)$/.exec(pattern);if(singleExt)return relPath.endsWith(`.${singleExt[1]}`);let braceExt=/^\*\*\/\*\.\{([^}]+)\}$/.exec(pattern);if(braceExt)return braceExt[1].split(`,`).map(e=>e.trim()).some(ext=>relPath.endsWith(`.${ext}`));let tag=`${namespace}::${pattern}`;return warnedGlobs.has(tag)||(warnedGlobs.add(tag),console.warn(`[kickjs/assets] Dev-mode glob '${pattern}' on '${namespace}' isn't recognised by the lite matcher. Falling back to '**/*'. Run 'kick build:assets' to use the full glob engine.`)),!0}function walkSync(root,dir,onFile){let entries;try{entries=readdirSync(dir,{withFileTypes:!0})}catch{return}for(let entry of entries){if(entry.name===`node_modules`||entry.name.startsWith(`.`))continue;let full=join(dir,entry.name);entry.isDirectory()?walkSync(root,full,onFile):entry.isFile()&&onFile(full.slice(root.length+1).split(sep).join(`/`),full)}}function loadConfigSync(cwd){let jsonPath=join(cwd,`kick.config.json`);if(existsSync(jsonPath))try{return JSON.parse(readFileSync(jsonPath,`utf-8`))}catch{return null}for(let filename of[`kick.config.cjs`,`kick.config.js`]){let path=join(cwd,filename);if(existsSync(path))try{let{createRequire}=__require(`node:module`),mod=createRequire(join(cwd,`package.json`))(path);return mod.default??mod??null}catch{continue}}let snapshotPath=join(cwd,`.kickjs`,`kick.config.json`);if(existsSync(snapshotPath))try{return JSON.parse(readFileSync(snapshotPath,`utf-8`))}catch{return null}return null}const PROMISE_DETECTION_KEYS=new Set([`then`]),PASSTHROUGH_KEYS=new Set([`toString`,`valueOf`,`constructor`,`prototype`,`name`,`length`,`asymmetricMatch`,`nodeType`,Symbol.toPrimitive,Symbol.toStringTag,Symbol.iterator,Symbol.asyncIterator]);function createNamespaceProxy(parts){return new Proxy(function(){},{apply(){if(parts.length<2)throw new UnknownAssetError(parts[0]??``,``);let[namespace,...rest]=parts;return resolveAsset(namespace,rest.join(`/`))},get(t,prop){if(!PROMISE_DETECTION_KEYS.has(prop)){if(PASSTHROUGH_KEYS.has(prop))return Reflect.get(t,prop);if(typeof prop!=`symbol`)return createNamespaceProxy([...parts,prop])}}})}function createAssetProxy(){return new Proxy({},{get(t,prop){if(!PROMISE_DETECTION_KEYS.has(prop)){if(PASSTHROUGH_KEYS.has(prop))return Reflect.get(t,prop);if(typeof prop!=`symbol`)return createNamespaceProxy([prop])}}})}const assets=createAssetProxy();function useAssets(){return assets}_setAssetResolver(resolveAsset);export{clearAssetCache as a,groupAssetKeys as c,assets as i,stripExt as l,ASSET_MANIFEST_VERSION as n,resolveAsset as o,UnknownAssetError as r,useAssets as s,ASSETS as t,defineContextDecorator as u};
-//# sourceMappingURL=core-_WNyghl_.mjs.map

package/dist/disposables-DIXt8ze-.mjs

@@ -1,12 +0,0 @@
-/**
- * @forinda/kickjs v9.1.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
- */
-const disposables=new Set;function registerDisposable(fn){return disposables.add(fn),()=>disposables.delete(fn)}function drainDisposables(){let pending=[...disposables];return disposables.clear(),pending}async function runDisposables(list){await Promise.allSettled(list.map(async fn=>fn()))}async function disposeAll(){await runDisposables(drainDisposables())}export{runDisposables as i,drainDisposables as n,registerDisposable as r,disposeAll as t};
-//# sourceMappingURL=disposables-DIXt8ze-.mjs.map

package/dist/env-DtJ-6gyL.mjs

@@ -1,13 +0,0 @@
-/**
- * @forinda/kickjs v9.1.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{t as Container}from"./container-ZnfelY_a.mjs";import{createRequire}from"node:module";import{existsSync}from"node:fs";import{resolve}from"node:path";import{detectSchema}from"@forinda/kickjs-schema";var __require=createRequire(import.meta.url);let _zod;function getZod(){if(_zod)return _zod;try{_zod=__require(`zod`)}catch{throw Error("@forinda/kickjs: the 'zod' peer dependency is required for baseEnvSchema / defineEnv / loadEnv but is not installed. Install it (`pnpm add zod`), or define your env with a non-Zod schema and call loadEnvFromSchema() instead — @forinda/kickjs-schema supports Valibot, Yup, and any Standard Schema validator without zod.")}return _zod}function isTestRun(){return process.env.NODE_ENV===`test`||!!process.env.VITEST}function envMode(){return isTestRun()?`test`:process.env.NODE_ENV??`development`}const GENERIC_ENV_FILES=[`.env.local`,`.env`];function resolveEnvFiles(){let explicit=process.env.KICKJS_ENV_FILE;if(explicit===`off`||explicit===`none`)return null;if(explicit)return explicit.split(`,`).map(f=>f.trim()).filter(Boolean);let exists=f=>existsSync(resolve(process.cwd(),f)),mode=envMode(),modeFiles=[`.env.${mode}.local`,`.env.${mode}`],found=(mode===`test`&&modeFiles.some(exists)?modeFiles:[...modeFiles,...GENERIC_ENV_FILES]).filter(exists);return found.length>0?found:null}let warnedTestBackfill=!1;function appliedKeys(before,parsed){return Object.keys(parsed).filter(k=>process.env[k]!==before[k])}function tryLoadDotenv(override=!1){let files=resolveEnvFiles();if(files)try{let dotenv=__require(`dotenv`),path=override?files.toReversed():files,usedGeneric=files.some(f=>GENERIC_ENV_FILES.includes(f)),mayWarn=!warnedTestBackfill&&isTestRun()&&usedGeneric,before=mayWarn?{...process.env}:void 0,result=dotenv.config({path,override,quiet:!0});if(mayWarn&&result.parsed){let applied=appliedKeys(before,result.parsed);applied.length>0&&(warnedTestBackfill=!0,console.warn(`[kickjs] test run took ${applied.length} env var(s) from ${files.join(`, `)} (${applied.slice(0,5).join(`, `)}${applied.length>5?`, …`:``}). Create a .env.test to isolate the suite, or set KICKJS_ENV_FILE=off.`))}}catch{}}tryLoadDotenv();function buildBaseEnvSchema(){let z=getZod();return z.object({PORT:z.coerce.number().default(3e3),NODE_ENV:z.enum([`development`,`production`,`test`]).default(`development`),LOG_LEVEL:z.string().default(`info`)})}let _baseEnvSchema;function getBaseEnvSchema(){return _baseEnvSchema||=buildBaseEnvSchema(),_baseEnvSchema}const baseEnvSchema=new Proxy({},{get(_t,prop){let real=getBaseEnvSchema(),value=real[prop];return typeof value==`function`?value.bind(real):value},has(_t,prop){return prop in getBaseEnvSchema()}});let cachedEnv=null,envOverlay=null;function overlaid(env){return envOverlay?{...env,...envOverlay}:env}function resolveEnvKey(key){return envOverlay&&key in envOverlay?envOverlay[key]:cachedEnv?.[key]}let cachedSchema=null;function defineEnv(extend){let base=getBaseEnvSchema(),userSchema=extend(base);return base.extend(userSchema.shape)}function loadEnv(schema){let s=schema??cachedSchema??getBaseEnvSchema();return cachedEnv&&cachedSchema===s?overlaid(cachedEnv):(cachedSchema=s,cachedEnv=s.parse(process.env),Container._envResolver=resolveEnvKey,overlaid(cachedEnv))}function getEnv(key,fallback){return isZodObject(fallback)?(warnedSchemaArg||(warnedSchemaArg=!0,process.emitWarning(`getEnv(key, schema) is deprecated: register the schema once with loadEnv(envSchema); the second argument is now a fallback value.`,`DeprecationWarning`)),loadEnv(fallback)[key]):loadEnv()[key]??fallback}let warnedSchemaArg=!1;function isZodObject(value){return typeof value==`object`&&!!value&&typeof value.safeParse==`function`&&`shape`in value}async function withEnv(overrides,fn){loadEnv();let previous=envOverlay;envOverlay={...previous,...overrides};try{return await fn()}finally{envOverlay=previous}}function reloadEnv(){tryLoadDotenv(!0),cachedEnv=null,cachedSchema&&(typeof cachedSchema.parse==`function`?loadEnv(cachedSchema):loadEnvFromSchema(cachedSchema))}function resetEnvCache(){cachedEnv=null,cachedSchema=null,warnedTestBackfill=!1,Container._envResolver=null}function loadEnvFromSchema(schema){let result=detectSchema(schema).safeParse(process.env);if(!result.success){let details=result.issues.map(i=>`  ${i.path.join(`.`)||`(root)`}: ${i.message}`).join(`
-`);throw Error(`Environment validation failed:\n${details}`)}return cachedEnv=result.data,cachedSchema=schema,Container._envResolver=resolveEnvKey,overlaid(result.data)}export{loadEnvFromSchema as a,withEnv as c,loadEnv as i,__require as l,defineEnv as n,reloadEnv as o,getEnv as r,resetEnvCache as s,baseEnvSchema as t};
-//# sourceMappingURL=env-DtJ-6gyL.mjs.map

package/dist/env-DtJ-6gyL.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"env-DtJ-6gyL.mjs","names":[],"sources":["../src/config/env.ts"],"sourcesContent":["import { existsSync } from 'node:fs'\nimport { resolve } from 'node:path'\nimport type { z } from 'zod'\nimport { detectSchema, type InferSchemaOutput } from '@forinda/kickjs-schema'\nimport { Container } from '../core/container'\nimport type { EnvKey } from '../core/decorators'\n\n/**\n * Lazy `zod` accessor. `zod` is an **optional** peer of\n * `@forinda/kickjs` — only the Zod-based env helpers (`baseEnvSchema`,\n * `defineEnv`, `loadEnv`) need it. Apps that validate env via Valibot /\n * Yup / Standard Schema go through `loadEnvFromSchema` (which only\n * touches the validator-agnostic `detectSchema`) and never load zod.\n *\n * Importing `zod` at module top-level made it a *hard* dependency of\n * the whole framework: `import { anything } from '@forinda/kickjs'`\n * eagerly evaluated this module, so a non-Zod app with no `zod`\n * installed crashed at module load / build time (\"Cannot find module\n * 'zod'\"). Deferring the require to first use keeps the import out of\n * the eager graph.\n */\nlet _zod: typeof import('zod') | undefined\nfunction getZod(): typeof import('zod') {\n  if (_zod) return _zod\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    _zod = require('zod') as typeof import('zod')\n  } catch {\n    throw new Error(\n      \"@forinda/kickjs: the 'zod' peer dependency is required for \" +\n        'baseEnvSchema / defineEnv / loadEnv but is not installed. ' +\n        'Install it (`pnpm add zod`), or define your env with a non-Zod ' +\n        'schema and call loadEnvFromSchema() instead — @forinda/kickjs-schema ' +\n        'supports Valibot, Yup, and any Standard Schema validator without zod.',\n    )\n  }\n  return _zod\n}\n\n/**\n * Lazily load `.env` via dotenv if it is installed in the consumer app.\n * `dotenv` is an **optional peer dependency** of `@forinda/kickjs` —\n * apps that want `.env` file support install it themselves (the CLI\n * generators add it to every scaffolded `package.json`). Apps that\n * inject env via the shell, Docker, or a secret manager can skip it\n * entirely and `process.env` is read as-is.\n *\n * We call `dotenv.config()` directly rather than `require('dotenv/config')`\n * so that a re-evaluation of this module (e.g. Vite SSR full-reload after\n * editing `.env`) can re-read the file. `dotenv/config` is a side-effect\n * shim that CJS caches aggressively, so the second `require` is a no-op\n * and new keys never reach `process.env` — the root cause of the\n * \"DATABASE_URL undefined until restart\" bug on Windows dev.\n *\n * Which file(s) get read is decided by {@link resolveEnvFiles}.\n */\nfunction isTestRun(): boolean {\n  return process.env['NODE_ENV'] === 'test' || !!process.env['VITEST']\n}\n\n/**\n * The mode whose env files apply. A test run is always mode `test`;\n * otherwise `NODE_ENV`, defaulting to the same `development` value\n * `baseEnvSchema` uses.\n *\n * The {@link isTestRun} check has to come FIRST, and the two predicates\n * have to agree. They did not: this read `NODE_ENV ?? (VITEST ? 'test'\n * : 'development')`, so an explicitly-set `NODE_ENV=development` won\n * file selection while `isTestRun()` — which counts `VITEST` on its own\n * — still gated the backfill warning. A vitest run with\n * `NODE_ENV=development` exported (common in a shell profile or a CI\n * image) therefore skipped the `.env.test` sitting right there, loaded\n * the developer's `.env`, and printed a warning telling the user to\n * create the very file it had just ignored. Worst of both: the alarm\n * without the protection.\n *\n * So `VITEST` outranks a non-test `NODE_ENV` for file selection. To run\n * a suite deliberately against another mode's files, name them with\n * `KICKJS_ENV_FILE`, which still bypasses all of this.\n */\nfunction envMode(): string {\n  if (isTestRun()) return 'test'\n  return process.env['NODE_ENV'] ?? 'development'\n}\n\nconst GENERIC_ENV_FILES = ['.env.local', '.env'] as const\n\n/**\n * Which env files dotenv should read, relative to `process.cwd()`, in\n * **highest-precedence-first** order. `null` means \"read nothing\".\n *\n * The cascade follows the convention Vite popularised, where a\n * mode-specific file outranks every generic one:\n *\n * ```\n * .env.[mode].local  >  .env.[mode]  >  .env.local  >  .env\n * ```\n *\n * Vars already present in `process.env` still outrank all of them —\n * that is what `override: false` at the call site buys, and it matches\n * Vite (\"environment variables that already exist … have the highest\n * priority and will not be overwritten by `.env` files\").\n *\n * **Test mode is the one exception, and deliberately so.** When the mode\n * is `test` and a `.env.test` / `.env.test.local` exists, that file is\n * treated as an explicit opt-in to an isolated environment and the\n * generic files are dropped rather than layered under it. Layering is\n * exactly the hole this closes: with `override: false`, every key a test\n * runner forgets to pin is silently backfilled from the developer's\n * `.env`, so a suite can pin its database URL and still reach live\n * development services through the keys it forgot. For `development` and\n * `production` the layering is what people expect and want (shared base\n * plus overrides), and there is no dev-resource-in-a-test failure mode\n * to guard against, so those cascade normally.\n *\n * `KICKJS_ENV_FILE` overrides the decision entirely — a comma-separated\n * list of files (highest precedence first), or `off` to skip dotenv\n * altogether (for apps that inject env via the shell, Docker, or a\n * secret manager).\n */\nfunction resolveEnvFiles(): string[] | null {\n  const explicit = process.env['KICKJS_ENV_FILE']\n  if (explicit === 'off' || explicit === 'none') return null\n  if (explicit) {\n    return explicit\n      .split(',')\n      .map((f) => f.trim())\n      .filter(Boolean)\n  }\n\n  const exists = (f: string): boolean => existsSync(resolve(process.cwd(), f))\n  const mode = envMode()\n  const modeFiles = [`.env.${mode}.local`, `.env.${mode}`]\n\n  // A test-scoped file present = isolate. Without one we still read the\n  // generic files (so an existing project is unchanged) and warn.\n  const isolate = mode === 'test' && modeFiles.some(exists)\n  const chain = isolate ? modeFiles : [...modeFiles, ...GENERIC_ENV_FILES]\n\n  const found = chain.filter(exists)\n  return found.length > 0 ? found : null\n}\n\n/** One-shot guard so the test-backfill warning cannot spam a suite. */\nlet warnedTestBackfill = false\n\n/**\n * Of the keys dotenv parsed out of the files, the ones whose value in\n * `process.env` actually differs from `before` — i.e. the ones dotenv\n * really applied.\n *\n * This distinction is the whole point of the warning. `result.parsed`\n * is everything READ from the files, not everything APPLIED: under\n * `override: false` a key already set by the test runner keeps the\n * runner's value and the file's copy is discarded. Warning about those\n * would name vars the user correctly pinned, which is exactly backwards\n * — the message exists to say which vars leaked IN, and listing pinned\n * ones alongside them makes it untrustworthy noise.\n *\n * Exported for tests only; not re-exported from the package index, so\n * it is not public API.\n */\nexport function appliedKeys(before: NodeJS.ProcessEnv, parsed: Record<string, string>): string[] {\n  return Object.keys(parsed).filter((k) => process.env[k] !== before[k])\n}\n\nfunction tryLoadDotenv(override = false): void {\n  const files = resolveEnvFiles()\n  if (!files) return\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const dotenv = require('dotenv')\n    // `quiet: true` suppresses dotenv 17's tip banner that goes to stdout.\n    // Required for CLI tools whose stdout is parsed by callers (`kick explain\n    // --json`, etc) — the banner would otherwise corrupt the JSON output.\n    //\n    // dotenv resolves array precedence positionally, and the DIRECTION\n    // depends on `override`: with `override: false` the first file to set a\n    // key wins; with `override: true` each file overwrites the last, so the\n    // final one wins. `files` is ordered highest-precedence-first, so the\n    // override path has to reverse it — otherwise a `reloadEnv()` would\n    // silently invert the cascade and let `.env` beat `.env.production`.\n    const path = override ? files.toReversed() : files\n\n    // Isolation is opt-in, and nobody discovers an opt-in. A test run that\n    // read the generic files says so once, on stderr — but only about the\n    // vars it actually pulled in, so snapshot process.env first. Skipped\n    // entirely when no warning could fire, to keep the copy off the boot\n    // path of a normal run.\n    const usedGeneric = files.some((f) => (GENERIC_ENV_FILES as readonly string[]).includes(f))\n    const mayWarn = !warnedTestBackfill && isTestRun() && usedGeneric\n    const before = mayWarn ? { ...process.env } : undefined\n\n    const result = dotenv.config({ path, override, quiet: true })\n\n    if (mayWarn && result.parsed) {\n      const applied = appliedKeys(before!, result.parsed)\n      // Only latch the one-shot guard once something is actually reported;\n      // latching on a run that had nothing to say would swallow the real\n      // warning from a later reload.\n      if (applied.length > 0) {\n        warnedTestBackfill = true\n        console.warn(\n          `[kickjs] test run took ${applied.length} env var(s) from ` +\n            `${files.join(', ')} (${applied.slice(0, 5).join(', ')}` +\n            `${applied.length > 5 ? ', …' : ''}). Create a .env.test to isolate the ` +\n            'suite, or set KICKJS_ENV_FILE=off.',\n        )\n      }\n    }\n  } catch {\n    // dotenv not installed — fall through, env vars must come from\n    // the environment directly. This is a valid deployment style.\n  }\n}\ntryLoadDotenv()\n\n/**\n * Build the base env schema. Memoized so repeated calls reuse one\n * schema instance (matters for the `cachedSchema === s` identity check\n * in {@link loadEnv}). Loads zod lazily via {@link getZod}.\n */\n// Build the concrete base schema. This function is the single source of\n// the *type* of `baseEnvSchema` (via `ReturnType<typeof buildBaseEnvSchema>`)\n// AND its runtime value (via `getBaseEnvSchema`). It is NEVER called at\n// module load — only lazily through `getBaseEnvSchema()` — so referencing\n// its return type stays compile-time-only and pulls no eager zod import.\n// Spelling the type this way (rather than `z.ZodObject<any>`) preserves the\n// precise PORT/NODE_ENV/LOG_LEVEL shape, which `defineEnv` composition and\n// the `kick typegen` `KickEnv` inference depend on.\nfunction buildBaseEnvSchema() {\n  const z = getZod()\n  return z.object({\n    // Server\n    PORT: z.coerce.number().default(3000),\n    NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),\n    LOG_LEVEL: z.string().default('info'),\n  })\n}\n\n/** Precise type of the base env schema — no runtime value, no eager zod. */\nexport type BaseEnvSchema = ReturnType<typeof buildBaseEnvSchema>\n\n/**\n * Memoized base schema. Reuses one instance so the `cachedSchema === s`\n * identity check in {@link loadEnv} holds. Loads zod lazily.\n */\nlet _baseEnvSchema: BaseEnvSchema | undefined\nexport function getBaseEnvSchema(): BaseEnvSchema {\n  if (!_baseEnvSchema) _baseEnvSchema = buildBaseEnvSchema()\n  return _baseEnvSchema\n}\n\n/**\n * Base environment schema with common server variables.\n * Users extend this with their own application-specific vars.\n *\n * Back-compat lazy view over {@link getBaseEnvSchema}: constructing the\n * Proxy does NOT load zod — zod is only required the moment a property\n * (`.extend`, `.parse`, `.shape`, …) is actually accessed. This keeps\n * `import { baseEnvSchema } from '@forinda/kickjs'` zero-cost for apps\n * that don't use the Zod env path, while keeping the precise schema type.\n */\nexport const baseEnvSchema: BaseEnvSchema = new Proxy({} as BaseEnvSchema, {\n  get(_t, prop) {\n    const real = getBaseEnvSchema() as unknown as Record<string | symbol, unknown>\n    const value = real[prop]\n    // Bind methods to the real schema so zod's internal `this` works.\n    return typeof value === 'function' ? (value as (...a: unknown[]) => unknown).bind(real) : value\n  },\n  has(_t, prop) {\n    return prop in (getBaseEnvSchema() as object)\n  },\n}) as BaseEnvSchema\n\n/** Cached env config to avoid re-parsing — keyed by schema reference */\nlet cachedEnv: any = null\n/**\n * Values {@link withEnv} lays over the parsed env while its callback runs.\n * Kept apart from the cache so a re-parse during the callback (a different\n * schema, a reload) can't drop them.\n */\nlet envOverlay: Record<string, unknown> | null = null\n\nfunction overlaid<T>(env: T): T {\n  return envOverlay ? ({ ...(env as object), ...envOverlay } as T) : env\n}\n\n/** What `@Value()` reads: an overlay value first, then the parsed env. */\nfunction resolveEnvKey(key: string): unknown {\n  return envOverlay && key in envOverlay ? envOverlay[key] : cachedEnv?.[key]\n}\nlet cachedSchema: any = null\n\n/**\n * Define a custom env schema. The base schema (`PORT`, `NODE_ENV`,\n * `LOG_LEVEL`) is always merged in, so users never need to remember to\n * extend it themselves — both styles below produce the same result and\n * both surface the base keys in `KickEnv`.\n *\n * Returns a Zod schema that validates `process.env`.\n *\n * @example\n * ```ts\n * // Style A — return a fresh object; base fields are merged automatically\n * export default defineEnv(() =>\n *   z.object({\n *     DATABASE_URL: z.string().url(),\n *     JWT_SECRET: z.string().min(32),\n *   })\n * )\n *\n * // Style B — explicitly extend `base` (still works, identical result)\n * export default defineEnv((base) =>\n *   base.extend({\n *     DATABASE_URL: z.string().url(),\n *   })\n * )\n * ```\n *\n * User-defined keys override base keys when they collide, so a project\n * can re-type `PORT` or tighten `NODE_ENV` without losing the rest of\n * the base shape.\n */\nexport function defineEnv<T extends z.ZodRawShape>(\n  extend: (base: typeof baseEnvSchema) => z.ZodObject<T>,\n): z.ZodObject<typeof baseEnvSchema.shape & T> {\n  const base = getBaseEnvSchema()\n  const userSchema = extend(base as typeof baseEnvSchema)\n  // Always merge the base in. `extend` lets the user's shape override\n  // any colliding base keys, which preserves the escape hatch for\n  // projects that want to re-type `PORT` etc.\n  return base.extend(userSchema.shape) as z.ZodObject<typeof baseEnvSchema.shape & T>\n}\n\n/**\n * Parse and validate `process.env` against a Zod schema. Caches result per schema.\n *\n * **No-arg behaviour is sticky.** The first time `loadEnv(schema)` is called\n * with an extended schema, the cache holds that schema. Subsequent\n * `loadEnv()` calls (no arg) will reuse the cached extended schema rather\n * than falling back to `baseEnvSchema`.\n *\n * Stickiness matters because `ConfigService` and the `@Value()` decorator\n * both read through the no-arg form internally. Without it, resolving\n * either of them after a `loadEnv(extendedSchema)` call would silently\n * downgrade the env to the base shape and drop every user-defined key.\n *\n * To force a re-parse with a different schema, pass the new schema explicitly.\n * To start fresh, call `resetEnvCache()` (full reset) or `reloadEnv()`\n * (re-parse against the same schema after a `.env` file change).\n *\n * **Typing:**\n * - With an explicit schema → returns `z.infer<typeof schema>`.\n * - With no schema and `KickEnv` populated by typegen → returns\n *   `KickEnv` (the project-wide typed env shape).\n * - With no schema and `KickEnv` empty → returns the base `Env`.\n */\nexport function loadEnv<T extends z.ZodObject<any>>(schema: T): z.infer<T>\nexport function loadEnv(): [EnvKey] extends [never] ? Env : KickEnv\nexport function loadEnv<T extends z.ZodObject<any>>(schema?: T): any {\n  // Sticky: when called with no arg, prefer the most recently cached\n  // schema over re-parsing with the base schema.\n  const s = schema ?? cachedSchema ?? getBaseEnvSchema()\n  // Re-parse if schema changed or no cache yet\n  if (cachedEnv && cachedSchema === s) return overlaid(cachedEnv)\n  cachedSchema = s\n  cachedEnv = s.parse(process.env)\n\n  // Register env resolver so @Value() reads validated values\n  Container._envResolver = resolveEnvKey\n\n  return overlaid(cachedEnv)\n}\n\n/**\n * Get a single typed environment variable value, read from the env schema\n * the app registered — the one source of truth, set once with\n * `loadEnv(envSchema)` in `src/env.ts`.\n *\n * - **`getEnv(key)`** returns the parsed value: `getEnv('PORT')` is a number\n *   once `kick typegen` has run.\n * - **`getEnv(key, fallback)`** returns `fallback` when the value is unset\n *   (`undefined` or `null`) — for keys the schema leaves optional.\n *\n * @example\n * ```ts\n * const port = getEnv('PORT') // number\n * const region = getEnv('S3_REGION', 'eu-west-1') // string, never undefined\n * ```\n *\n * A default every caller shares belongs in the schema (`.default(...)`);\n * the fallback is for a value one call site can live without.\n */\nexport function getEnv<K extends EnvKey>(key: K): KickEnv[K]\nexport function getEnv<K extends EnvKey>(\n  key: K,\n  fallback: NonNullable<KickEnv[K]>,\n): NonNullable<KickEnv[K]>\nexport function getEnv(key: string, fallback?: unknown): any {\n  // The old second argument was a schema. Still honoured, so existing calls\n  // keep working, but the schema belongs in one place: loadEnv(envSchema).\n  if (isZodObject(fallback)) {\n    if (!warnedSchemaArg) {\n      warnedSchemaArg = true\n      process.emitWarning(\n        'getEnv(key, schema) is deprecated: register the schema once with loadEnv(envSchema); ' +\n          'the second argument is now a fallback value.',\n        'DeprecationWarning',\n      )\n    }\n    return (loadEnv(fallback) as Record<string, unknown>)[key]\n  }\n  const value = (loadEnv() as Record<string, unknown>)[key]\n  return value ?? fallback\n}\n\nlet warnedSchemaArg = false\n\nfunction isZodObject(value: unknown): value is z.ZodObject<any> {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    typeof (value as { safeParse?: unknown }).safeParse === 'function' &&\n    'shape' in value\n  )\n}\n\n/**\n * Run `fn` with some env values replaced — for tests. The overrides are\n * parsed values (`{ TRUST_PROXY: true }`), laid over the current env for the\n * duration of the call and taken away afterwards, whatever `fn` does.\n * `getEnv`, `ConfigService` and `@Value()` all see them. No `.env` file is\n * read. Not for concurrent use: the env is process-wide.\n */\nexport async function withEnv<T>(\n  overrides: Record<string, unknown>,\n  fn: () => T | Promise<T>,\n): Promise<T> {\n  loadEnv() // registers the resolver @Value() reads through\n  const previous = envOverlay\n  // Nested calls layer: the inner overrides win, the outer ones come back after.\n  envOverlay = { ...previous, ...overrides }\n  try {\n    return await fn()\n  } finally {\n    envOverlay = previous\n  }\n}\n\n/**\n * Reload env from `process.env`. Re-reads `.env` via dotenv (if\n * installed), then re-parses the result against the **same** schema\n * the project registered at startup. Called during HMR rebuild and by\n * `envWatchPlugin` to pick up `.env` file changes mid-session.\n *\n * Crucially, this preserves the registered schema. Wiping it would\n * silently downgrade `ConfigService` and `@Value()` back to the base\n * schema on the next read, so every user-defined key would start\n * resolving as `undefined` after the first `.env` save — which was the\n * original \"config disappears in dev\" bug.\n *\n * If you need to fully forget the schema (e.g. tests that swap schemas\n * between cases), call {@link resetEnvCache} instead.\n */\nexport function reloadEnv(): void {\n  // Re-read the env file(s) into process.env if dotenv is installed.\n  // Routed through the same resolver as boot so a reload can never\n  // disagree with startup about which file is authoritative — the\n  // inline `dotenv.config()` this replaced always read `.env`, so\n  // under a test run it could clobber pinned `.env.test` values with\n  // the developer's own.\n  tryLoadDotenv(true)\n\n  // Drop the parsed snapshot but keep the schema. Re-parse eagerly so\n  // existing consumers (including ConfigService getters and @Value\n  // resolvers that may already hold references to the env state) see\n  // the new values on their very next read instead of having to\n  // re-trigger any cache-population step.\n  cachedEnv = null\n  if (cachedSchema) {\n    if (typeof cachedSchema.parse === 'function') {\n      loadEnv(cachedSchema)\n    } else {\n      loadEnvFromSchema(cachedSchema)\n    }\n  }\n}\n\n/**\n * Fully reset the env cache, including the registered schema. Use this\n * in tests that need to swap schemas between cases — `reloadEnv()`\n * deliberately preserves the schema to avoid the \"user keys vanish on\n * `.env` reload\" footgun.\n */\nexport function resetEnvCache(): void {\n  cachedEnv = null\n  cachedSchema = null\n  // Also re-arm the one-shot backfill warning. This is the \"start fresh\"\n  // hook, and a suite that swaps env between cases should get told each\n  // time it picks up the generic files, not only the first.\n  warnedTestBackfill = false\n  // Drop the resolver too. It closes over `cachedEnv`, so leaving it\n  // installed left `@Value()` reading through a live closure over a\n  // null cache — indistinguishable from \"key not set\" but with no\n  // schema to re-parse against.\n  Container._envResolver = null\n}\n\n/**\n * Schema-agnostic env loader. Accepts any schema supported by\n * `@forinda/kickjs-schema` (Zod, Valibot, Yup, Joi, Standard Schema,\n * KickSchema adapters, or plain validator functions).\n *\n * Unlike `loadEnv()` which uses Zod's `.parse()` and throws a\n * `ZodError`, this function uses `detectSchema().safeParse()` and\n * throws a plain `Error` with structured issue messages on failure.\n *\n * @example\n * ```ts\n * import * as v from 'valibot'\n * import { fromValibot } from '@forinda/kickjs-schema/valibot'\n *\n * const envSchema = fromValibot(v.object({\n *   PORT: v.pipe(v.string(), v.transform(Number)),\n *   NODE_ENV: v.picklist(['development', 'production', 'test']),\n * }))\n *\n * export const env = loadEnvFromSchema(envSchema)\n * ```\n */\n/**\n * Single inferring signature. `TSchema` is inferred from the call site;\n * the conditional return type maps the unknown-input case (TSchema\n * resolves to `unknown` only when the argument is `unknown`-typed\n * because nothing on the value side carried a richer brand) to\n * `Record<string, unknown>` rather than letting `InferSchemaOutput`\n * fall through to `unknown`. The previous two-overload form had the\n * generic overload win for `unknown`-typed inputs (`unknown` is\n * assignable to any `TSchema`), so the documented \"Record\" fallback\n * never actually applied.\n */\nexport function loadEnvFromSchema<TSchema>(\n  schema: TSchema,\n): unknown extends TSchema ? Record<string, unknown> : InferSchemaOutput<TSchema>\nexport function loadEnvFromSchema(schema: unknown): unknown {\n  const wrapped = detectSchema(schema)\n  const result = wrapped.safeParse(process.env)\n  if (!result.success) {\n    const details = result.issues\n      .map((i) => `  ${i.path.join('.') || '(root)'}: ${i.message}`)\n      .join('\\n')\n    throw new Error(`Environment validation failed:\\n${details}`)\n  }\n  cachedEnv = result.data\n  cachedSchema = schema\n  Container._envResolver = resolveEnvKey\n  return overlaid(result.data)\n}\n\n/**\n * Output type of {@link baseEnvSchema}. Hand-written (rather than\n * `z.infer<typeof baseEnvSchema>`) so the type is available without the\n * eager `zod` value import — `baseEnvSchema` is now a lazy Proxy typed\n * as `z.ZodObject<any>`, from which `z.infer` could not recover the\n * precise shape anyway.\n */\nexport type Env = {\n  PORT: number\n  NODE_ENV: 'development' | 'production' | 'test'\n  LOG_LEVEL: string\n}\n"],"mappings":"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"}

package/dist/handler-2OebsoPr.mjs

@@ -1,13 +0,0 @@
-/**
- * @forinda/kickjs v9.1.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{createLogger,describeError}from"./core/logger.mjs";import{HttpException}from"./core/errors.mjs";import{a as createRequestStore,f as unsupportedMediaTypeError,n as applyHandlerResult,o as disposeRequestStore,t as publishMatchedRoute,u as classifyMediaType}from"./runtime-CDz5ayBt.mjs";import{l as requestStore,t as RequestContext}from"./context-BGPof8bs.mjs";import{validate}from"./http/middleware/validate.mjs";import{t as applyUploadConfig}from"./upload-config-d0pisVsK.mjs";var WebRequestShim=class{method;url;headers;body;params={};query={};requestId;file;files;signal;constructor(request,url){this.method=request.method,this.url=url.pathname+url.search,this.signal=request.signal;let headers={};request.headers.forEach((value,key)=>{headers[key]=value}),this.headers=headers;let query={};for(let key of url.searchParams.keys()){let all=url.searchParams.getAll(key);query[key]=all.length>1?all:all[0]}this.query=query}once(event,listener){return event===`close`&&this.signal.addEventListener(`abort`,listener,{once:!0}),this}on(event,listener){return this.once(event,listener)}};const encoder=new TextEncoder;function toBytes(chunk){return chunk instanceof Uint8Array?chunk:encoder.encode(String(chunk))}var WebResponseDriver=class{signal;ready;settled=!1;_status=200;headers=new Headers;_headersSent=!1;writer;resolveReady;constructor(signal){this.signal=signal,this.ready=new Promise(resolve=>{this.resolveReady=resolve})}status(code){return this._status=code,this}json(data){return this.headers.has(`content-type`)||this.headers.set(`content-type`,`application/json; charset=utf-8`),this.finish(JSON.stringify(data))}send(data){return typeof data==`object`&&data&&!(data instanceof Uint8Array)?this.json(data):this.finish(data)}type(contentType){return this.headers.set(`content-type`,contentType),this}setHeader(name,value){if(Array.isArray(value)){this.headers.delete(name);for(let v of value)this.headers.append(name,String(v))}else this.headers.set(name,String(value));return this}render(){throw Error(`ctx.render() is not supported on the web runtime (no view engine).`)}writeHead(statusCode,headers){if(this._status=statusCode,headers)for(let[name,value]of Object.entries(headers))this.setHeader(name,value);return this.startStream(),this}flushHeaders(){return this.startStream(),this}write(chunk){return this.startStream(),this.writer.write(toBytes(chunk)).catch(()=>{}),!0}end(data){return this.writer?(data!==void 0&&this.write(data),this.writer.close().catch(()=>{}),this.writer=void 0,this):this.finish(data)}once(event,listener){return event===`close`&&this.signal&&this.signal.addEventListener(`abort`,listener,{once:!0}),this}get headersSent(){return this._headersSent}finish(body){if(this.settled)return this;this.settled=!0,this._headersSent=!0;let bodyAllowed=this._status!==204&&this._status!==304;return this.resolveReady(new Response(bodyAllowed?body??null:null,{status:this._status,headers:this.headers})),this}startStream(){if(this.writer||this.settled)return;let{readable,writable}=new TransformStream;this.writer=writable.getWriter(),this.settled=!0,this._headersSent=!0,this.signal?.addEventListener(`abort`,()=>{this.writer?.abort().catch(()=>{}),this.writer=void 0},{once:!0}),this.resolveReady(new Response(readable,{status:this._status,headers:this.headers}))}};const log=createLogger(`WebPipeline`),NOOP_NEXT=()=>{},BODY_METHODS=new Set([`POST`,`PUT`,`PATCH`,`DELETE`]);function defaultErrorResponse(err,driver){let status=typeof err?.status==`number`?err.status:typeof err?.statusCode==`number`?err.statusCode:500;if(status>=500){log.error(err,`Unhandled error in web pipeline — ${describeError(err)}`);let stack=err?.stack;driver.status(status).json({error:`Internal Server Error`,...isProduction()?{}:{message:describeError(err),...typeof stack==`string`?{stack:stack.split(`
-`)}:{}}});return}driver.status(status).json({error:err?.message??`Request failed`})}function isProduction(){return typeof process<`u`&&process.env?.NODE_ENV===`production`}function compileWebRoute(entry,hooks){let validator=entry.meta.validation?validate(entry.meta.validation):void 0,upload=entry.meta.upload&&entry.meta.upload.mode!==`none`?entry.meta.upload:null;return async({request,url,params})=>{let req=new WebRequestShim(request,url);req.params=params;let bodyError;if(upload){let form=await request.formData().catch(()=>void 0);if(form){let rawParts=[],fields={};for(let[name,value]of form.entries())typeof value==`string`?fields[name]=value:rawParts.push({fieldname:name,filename:value.name??``,mimetype:value.type||`application/octet-stream`,buffer:new Uint8Array(await value.arrayBuffer())});let{file,files}=applyUploadConfig(rawParts,entry.meta.upload);req.file=file,req.files=files,req.body=fields}}else if(BODY_METHODS.has(request.method)){let raw=request.body===null?``:await request.text().catch(()=>``),kind=classifyMediaType(req.headers[`content-type`]);if(raw!==``&&kind===`unsupported`)bodyError=unsupportedMediaTypeError(req.headers[`content-type`]);else if(raw!==``&&kind!==`multipart`){if(kind===`json`)try{req.body=JSON.parse(raw)}catch(err){bodyError=HttpException.badRequest(err instanceof Error?err.message:`Request body could not be parsed`)}else req.body=kind===`urlencoded`?Object.fromEntries(new URLSearchParams(raw)):raw}}let store=createRequestStore(req.headers[`x-request-id`]);req.requestId=store.requestId;let driver=new WebResponseDriver(request.signal);driver.setHeader(`x-request-id`,store.requestId),publishMatchedRoute(req,entry);let pipeline=requestStore.run(store,async()=>{if(bodyError)throw bodyError;let ctx=new RequestContext(req,driver,NOOP_NEXT,driver);if(entry.earlyContributorRunner&&(await entry.earlyContributorRunner(ctx),driver.settled))return;validator&&await new Promise((resolve,reject)=>{validator(req,void 0,err=>err?reject(err):resolve())});for(let mw of entry.middlewares){let advanced=!1;if(await new Promise((resolve,reject)=>{Promise.resolve(mw(ctx,err=>{advanced=!0,err?reject(err):resolve()})).catch(reject)}),!advanced||driver.settled)return}if(entry.contributorRunner&&await entry.contributorRunner(ctx),driver.settled)return;let result=await entry.handler(ctx);driver.settled||applyHandlerResult(ctx,result)});try{try{await Promise.race([pipeline,driver.ready])}catch(err){driver.settled||(hooks?.onError&&await hooks.onError(err,req,driver),driver.settled||defaultErrorResponse(err,driver))}return driver.settled||driver.status(404).json({error:`Not Found`}),await driver.ready}finally{Promise.resolve(pipeline).catch(()=>{}).then(()=>disposeRequestStore(store))}}}export{WebRequestShim as n,WebResponseDriver as r,compileWebRoute as t};
-//# sourceMappingURL=handler-2OebsoPr.mjs.map

package/dist/handler-2OebsoPr.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"handler-2OebsoPr.mjs","names":[],"sources":["../src/http/web/driver.ts","../src/http/web/handler.ts"],"sourcesContent":["// Web-standard driver pair — the request/response bridge between web\n// primitives (WHATWG Request/Response) and the KickJS RequestContext surface.\n//\n// Deliberately imports NOTHING from node: this module is the edge-safe core\n// shared by the h3 v2 runtime (`runtimes/h3-web.ts`, node bootstrap) and the\n// `@forinda/kickjs/web` fetch entry (edge/Bun/Deno).\n\nimport type { RuntimeResponse } from '../runtime'\n\n/**\n * Presents a web `Request` as the express-shaped `req` object that\n * `RequestContext` (and route validation) reads: plain-object `headers`,\n * assignable `body`/`params`/`query`, and `on/once('close')` bridged from\n * the request's `AbortSignal` — the only EventEmitter surface the context\n * layer uses (`ctx.signal`, SSE close).\n */\nexport class WebRequestShim {\n  readonly method: string\n  readonly url: string\n  /** Lower-cased plain header object (RequestContext indexes it directly). */\n  readonly headers: Record<string, string>\n  body: unknown\n  params: Record<string, string> = {}\n  query: Record<string, unknown> = {}\n  requestId?: string\n  file?: unknown\n  files?: unknown;\n  // Ad-hoc props middleware may set (session, user, ...) — index signature\n  // keeps assignment open like a node req object.\n  [key: string]: unknown\n\n  private readonly signal: AbortSignal\n\n  constructor(request: Request, url: URL) {\n    this.method = request.method\n    // Express-shaped `req.url` is path + search, not the absolute URL.\n    this.url = url.pathname + url.search\n    this.signal = request.signal\n    const headers: Record<string, string> = {}\n    request.headers.forEach((value, key) => {\n      headers[key] = value\n    })\n    this.headers = headers\n    const query: Record<string, unknown> = {}\n    for (const key of url.searchParams.keys()) {\n      const all = url.searchParams.getAll(key)\n      query[key] = all.length > 1 ? all : all[0]\n    }\n    this.query = query\n  }\n\n  /** `req.once('close')` — abort of the underlying request signal. */\n  once(event: string, listener: () => void): this {\n    if (event === 'close') this.signal.addEventListener('abort', listener, { once: true })\n    return this\n  }\n\n  /** `req.on('close')` — same bridge; signals only abort once anyway. */\n  on(event: string, listener: () => void): this {\n    return this.once(event, listener)\n  }\n}\n\nconst encoder = new TextEncoder()\n\nfunction toBytes(chunk: unknown): Uint8Array {\n  if (chunk instanceof Uint8Array) return chunk\n  return encoder.encode(String(chunk))\n}\n\n/**\n * `RuntimeResponse` over a web `Response`.\n *\n * Two modes:\n * - **Buffered** (default): `status/json/send/type/setHeader` record state;\n *   the terminal call resolves {@link ready} with a complete `Response`.\n * - **Streaming**: the first `writeHead`/`flushHeaders`/`write` call switches\n *   to a `TransformStream` and resolves {@link ready} IMMEDIATELY with a\n *   streamed `Response` — SSE works on edge this way; `write` feeds the\n *   writer, `end` closes it.\n *\n * A class so the method table lives on a shared prototype (one allocation\n * per request — same rationale as the Fastify/h3 driver classes).\n */\nexport class WebResponseDriver implements RuntimeResponse {\n  /** Resolves with the final (or streamed) Response. */\n  readonly ready: Promise<Response>\n  /** True once a terminal/streaming action produced the Response. */\n  settled = false\n\n  private _status = 200\n  private readonly headers = new Headers()\n  private _headersSent = false\n  private writer?: WritableStreamDefaultWriter<Uint8Array>\n  private resolveReady!: (response: Response) => void\n\n  constructor(private readonly signal?: AbortSignal) {\n    this.ready = new Promise<Response>((resolve) => {\n      this.resolveReady = resolve\n    })\n  }\n\n  status(code: number): this {\n    this._status = code\n    return this\n  }\n\n  json(data: unknown): this {\n    if (!this.headers.has('content-type'))\n      this.headers.set('content-type', 'application/json; charset=utf-8')\n    return this.finish(JSON.stringify(data))\n  }\n\n  send(data: unknown): this {\n    if (\n      data !== undefined &&\n      data !== null &&\n      typeof data === 'object' &&\n      !(data instanceof Uint8Array)\n    ) {\n      return this.json(data)\n    }\n    return this.finish(data as string | Uint8Array | null | undefined)\n  }\n\n  type(contentType: string): this {\n    this.headers.set('content-type', contentType)\n    return this\n  }\n\n  setHeader(name: string, value: unknown): this {\n    if (Array.isArray(value)) {\n      this.headers.delete(name)\n      for (const v of value) this.headers.append(name, String(v))\n    } else {\n      this.headers.set(name, String(value))\n    }\n    return this\n  }\n\n  render(): never {\n    throw new Error('ctx.render() is not supported on the web runtime (no view engine).')\n  }\n\n  writeHead(statusCode: number, headers?: Record<string, string | number | string[]>): this {\n    this._status = statusCode\n    if (headers) {\n      for (const [name, value] of Object.entries(headers)) this.setHeader(name, value)\n    }\n    this.startStream()\n    return this\n  }\n\n  flushHeaders(): this {\n    this.startStream()\n    return this\n  }\n\n  write(chunk: unknown): boolean {\n    this.startStream()\n    // Fire-and-forget: backpressure is absorbed by the stream's queue. Write\n    // failures (client gone) surface via the abort listener, not here.\n    void this.writer!.write(toBytes(chunk)).catch(() => {})\n    return true\n  }\n\n  end(data?: unknown): this {\n    if (this.writer) {\n      if (data !== undefined) this.write(data)\n      void this.writer.close().catch(() => {})\n      this.writer = undefined\n      return this\n    }\n    return this.finish(data as string | Uint8Array | null | undefined)\n  }\n\n  once(event: string, listener: (...args: unknown[]) => void): this {\n    if (event === 'close' && this.signal)\n      this.signal.addEventListener('abort', listener as () => void, { once: true })\n    return this\n  }\n\n  get headersSent(): boolean {\n    return this._headersSent\n  }\n\n  /** Buffered terminal: build the final Response exactly once. */\n  private finish(body?: string | Uint8Array | null): this {\n    if (this.settled) return this\n    this.settled = true\n    this._headersSent = true\n    // 204/304 must not carry a body per the Response constructor contract.\n    const bodyAllowed = this._status !== 204 && this._status !== 304\n    this.resolveReady(\n      new Response(bodyAllowed ? (body ?? null) : null, {\n        status: this._status,\n        headers: this.headers,\n      }),\n    )\n    return this\n  }\n\n  /** Switch to streaming mode and resolve `ready` with the streamed Response. */\n  private startStream(): void {\n    if (this.writer || this.settled) return\n    const { readable, writable } = new TransformStream<Uint8Array, Uint8Array>()\n    this.writer = writable.getWriter()\n    this.settled = true\n    this._headersSent = true\n    // Abort from the client tears the stream down so the writer stops queueing.\n    this.signal?.addEventListener(\n      'abort',\n      () => {\n        void this.writer?.abort().catch(() => {})\n        this.writer = undefined\n      },\n      { once: true },\n    )\n    this.resolveReady(new Response(readable, { status: this._status, headers: this.headers }))\n  }\n}\n","// Engine-neutral web pipeline: run one KickJS RouteEntry against a WHATWG\n// Request and produce a WHATWG Response. Shared by the h3 v2 runtime\n// (node bootstrap) and the `@forinda/kickjs/web` fetch entry (edge/Bun/Deno).\n// Edge-safe: no node imports beyond the sanctioned ALS request store.\n\nimport { HttpException } from '../../core/errors'\nimport { classifyMediaType, unsupportedMediaTypeError } from '../body-policy'\nimport { RequestContext } from '../context'\nimport { publishMatchedRoute } from '../runtime'\nimport { applyHandlerResult } from '../reply'\nimport { requestStore } from '../request-store'\nimport { createRequestStore, disposeRequestStore } from '../middleware/request-scope'\nimport { validate } from '../middleware/validate'\nimport { applyUploadConfig, type RawUploadPart } from '../middleware/upload-config'\nimport type { RouteEntry, RuntimeResponse } from '../runtime'\nimport { WebRequestShim, WebResponseDriver } from './driver'\nimport { createLogger, describeError } from '../../core/logger'\n\nconst log = createLogger('WebPipeline')\nconst NOOP_NEXT = (): void => {}\nconst BODY_METHODS = new Set(['POST', 'PUT', 'PATCH', 'DELETE'])\n\nexport interface WebRouteInvocation {\n  request: Request\n  url: URL\n  params: Record<string, string>\n}\n\nexport interface WebRouteHooks {\n  /**\n   * Error bridge — receives pipeline rejections (validation failures,\n   * handler throws) with the shim + driver so an engine can dispatch the\n   * framework's connect-style error handler. When absent (or when it\n   * doesn't settle the driver), a minimal JSON error is produced from\n   * `err.status`/`err.statusCode` (500 default).\n   */\n  onError?: (err: unknown, req: WebRequestShim, res: WebResponseDriver) => void | Promise<void>\n}\n\n/**\n * Fallback error shape when no engine error handler settles the response.\n *\n * This path used to be completely silent: a bare\n * `{ error: 'Internal Server Error' }` with no log line anywhere, so a\n * failure that reached here left no trace on either side. It is a\n * last-resort branch, which is exactly when diagnostics matter most.\n */\nfunction defaultErrorResponse(err: unknown, driver: WebResponseDriver): void {\n  const status =\n    typeof (err as { status?: number })?.status === 'number'\n      ? (err as { status: number }).status\n      : typeof (err as { statusCode?: number })?.statusCode === 'number'\n        ? (err as { statusCode: number }).statusCode\n        : 500\n\n  if (status >= 500) {\n    log.error(err, `Unhandled error in web pipeline — ${describeError(err)}`)\n    const stack = (err as Error)?.stack\n    driver.status(status).json({\n      error: 'Internal Server Error',\n      ...(isProduction()\n        ? {}\n        : {\n            message: describeError(err),\n            ...(typeof stack === 'string' ? { stack: stack.split('\\n') } : {}),\n          }),\n    })\n    return\n  }\n\n  driver.status(status).json({ error: (err as Error)?.message ?? 'Request failed' })\n}\n\n/**\n * Read per-call, not at module scope: the web entry is imported once and\n * reused across invocations, and edge runtimes may not expose `process`.\n */\nfunction isProduction(): boolean {\n  return typeof process !== 'undefined' && process.env?.NODE_ENV === 'production'\n}\n\n/**\n * Compile a RouteEntry into a `(invocation) => Promise<Response>` function.\n * Everything derivable at route-build time (validator, upload config) is\n * hoisted here — per-request work is shim + store + pipeline only.\n */\nexport function compileWebRoute(\n  entry: RouteEntry,\n  hooks?: WebRouteHooks,\n): (invocation: WebRouteInvocation) => Promise<Response> {\n  const validator = entry.meta.validation ? validate(entry.meta.validation) : undefined\n  const upload = entry.meta.upload && entry.meta.upload.mode !== 'none' ? entry.meta.upload : null\n\n  return async ({ request, url, params }) => {\n    const req = new WebRequestShim(request, url)\n    req.params = params\n    let bodyError: unknown\n\n    // Body: uploads consume the stream as FormData; everything else parses\n    // by content-type.\n    if (upload) {\n      const form = await request.formData().catch(() => undefined)\n      if (form) {\n        const rawParts: RawUploadPart[] = []\n        const fields: Record<string, unknown> = {}\n        for (const [name, value] of form.entries()) {\n          if (typeof value === 'string') {\n            fields[name] = value\n          } else {\n            rawParts.push({\n              fieldname: name,\n              filename: value.name ?? '',\n              mimetype: value.type || 'application/octet-stream',\n              buffer: new Uint8Array(await value.arrayBuffer()) as unknown as Buffer,\n            })\n          }\n        }\n        const { file, files } = applyUploadConfig(rawParts, entry.meta.upload!)\n        req.file = file\n        req.files = files\n        req.body = fields\n      }\n    } else if (BODY_METHODS.has(request.method)) {\n      // Read once — a Request body is a stream and cannot be consumed twice.\n      // A read that fails (client aborted mid-flight) is treated as an absent\n      // body: there is nobody left to answer, and it is not a malformed one.\n      const raw = request.body === null ? '' : await request.text().catch(() => '')\n\n      // An empty body is ABSENT, not unparseable — the same call the node h3\n      // runtime makes on `content-length: 0`. Distinguishing the two is the\n      // whole point: `.catch(() => undefined)` around the parse could not,\n      // so a malformed payload answered 200 with the handler running against\n      // `undefined` (#605), the defect #586 removed from the node runtime.\n      const kind = classifyMediaType(req.headers['content-type'])\n      if (raw !== '' && kind === 'unsupported') {\n        // Held for the same reason as a parse failure: no driver yet.\n        bodyError = unsupportedMediaTypeError(req.headers['content-type'])\n      } else if (raw !== '' && kind !== 'multipart') {\n        if (kind === 'json') {\n          try {\n            req.body = JSON.parse(raw)\n          } catch (err) {\n            // Held, not thrown: the driver that turns an error into a response\n            // does not exist yet, so throwing here escapes the route entirely\n            // and surfaces as a 500. Rethrown as the pipeline's first act.\n            bodyError = HttpException.badRequest(\n              err instanceof Error ? err.message : 'Request body could not be parsed',\n            )\n          }\n        } else if (kind === 'urlencoded') {\n          req.body = Object.fromEntries(new URLSearchParams(raw))\n        } else {\n          req.body = raw\n        }\n      }\n    }\n\n    const store = createRequestStore(req.headers['x-request-id'])\n    req.requestId = store.requestId\n\n    const driver = new WebResponseDriver(request.signal)\n    driver.setHeader('x-request-id', store.requestId)\n\n    publishMatchedRoute(req, entry)\n\n    const pipeline = requestStore.run(store, async () => {\n      if (bodyError) throw bodyError\n\n      const ctx = new RequestContext(\n        req as never,\n        driver as never,\n        NOOP_NEXT,\n        driver as RuntimeResponse,\n      )\n\n      // `beforeValidation` contributors (#677) — ahead of validation and middleware.\n      if (entry.earlyContributorRunner) {\n        await entry.earlyContributorRunner(ctx)\n        if (driver.settled) return\n      }\n\n      if (validator) {\n        await new Promise<void>((resolve, reject) => {\n          validator(req as never, undefined as never, (err?: unknown) =>\n            err ? reject(err) : resolve(),\n          )\n        })\n      }\n\n      for (const mw of entry.middlewares) {\n        let advanced = false\n        await new Promise<void>((resolve, reject) => {\n          const next = (err?: unknown): void => {\n            advanced = true\n            if (err) reject(err)\n            else resolve()\n          }\n          Promise.resolve(mw(ctx, next)).catch(reject)\n        })\n        if (!advanced || driver.settled) return\n      }\n\n      if (entry.contributorRunner) await entry.contributorRunner(ctx)\n      if (driver.settled) return\n      const result = await entry.handler(ctx)\n      // Return-value handlers (reply.ts): auto-send when nothing was written.\n      // `undefined` falls through to the canonical 404 below.\n      if (!driver.settled) applyHandlerResult(ctx, result)\n    })\n\n    try {\n      // Streaming responses resolve `ready` mid-pipeline (SSE); buffered ones\n      // resolve at the terminal ctx call. Race so both shapes return promptly.\n      try {\n        await Promise.race([pipeline, driver.ready])\n      } catch (err) {\n        if (!driver.settled) {\n          if (hooks?.onError) await hooks.onError(err, req, driver)\n          if (!driver.settled) defaultErrorResponse(err, driver)\n        }\n      }\n      if (!driver.settled) {\n        // Pipeline finished without responding — canonical 404 shape.\n        driver.status(404).json({ error: 'Not Found' })\n      }\n      return await driver.ready\n    } finally {\n      // @PreDestroy teardown. For buffered responses this runs post-response;\n      // for streams it runs when the pipeline (not the stream) completes —\n      // stream lifetime is governed by the client abort signal.\n      void Promise.resolve(pipeline)\n        .catch(() => {})\n        .then(() => disposeRequestStore(store))\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/http/runtimes/h3-web.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"h3-web.d.mts","names":[],"sources":["../../../src/http/runtimes/h3-web.ts"],"mappings":";;;;UAyCU;EACR,GAAG,gBAAgB,cAAc,UAAU,OAAO;EAClD,IAAI,cAAc,UAAU,OAAO;EACnC,OAAO;EACP,MAAM,SAAS,UAAU,QAAQ;;UAEzB;EACR,KAAK;IAAY;MAAY;QAAS,KAAK;QAAiB,KAAK;;;;EACjE,KAAK;EACL;IAAW,SAAS;;;iBASL;;;;;;;;EAQf;;;;;;wBA4Rc,aAAa,UAAS,sBAA2B,YAAY;;;;;iBAiH5D;EACf,SAAS;EACT,UAAU;EACV"}

package/dist/http/runtimes/h3-web.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"h3-web.mjs","names":[],"sources":["../../../src/http/runtimes/h3-web.ts"],"sourcesContent":["// The h3 v2 (web-standards) runtime — `@forinda/kickjs/h3-web`.\n//\n// ADDITIVE runtime: the h3 v1 runtime (`./h3.ts`, `@forinda/kickjs/h3`)\n// stays untouched so existing adopters keep working. This runtime targets h3 >= 2 — the\n// web-standard rebase where `event.req` is a WHATWG Request, handlers\n// return values/Responses, and `app.fetch(request)` is the universal entry.\n//\n// The request pipeline runs through the shared web driver pair\n// (`../web/driver`, `../web/handler`) — the same code path the\n// `@forinda/kickjs/web` edge entry uses, so node bootstrap and edge deploys\n// exercise identical request semantics.\n//\n// Known limitation vs the v1 runtime: no Vite dev-server fall-through —\n// unmatched requests are answered by the kick notFound handler (h3 v2 owns\n// the full request; there is no node `next()` bail-out mid-engine). Use the\n// v1 h3 runtime or Express for Vite-integrated dev setups.\n\nimport type { IncomingMessage, ServerResponse } from 'node:http'\nimport { createRequire } from 'node:module'\n\nimport type {\n  ConnectMiddleware,\n  HttpRuntime,\n  RouteTable,\n  RuntimeAppOptions,\n  UseConnectOptions,\n} from '../runtime'\nimport { compileWebRoute, type WebRouteHooks } from '../web/handler'\nimport { WebRequestShim, WebResponseDriver } from '../web/driver'\nimport { createLogger, describeError } from '../../core/logger'\n\nconst log = createLogger('H3WebRuntime')\n\nconst peerRequire = createRequire(import.meta.url)\n\nconst NOTFOUND_MW = Symbol('kickjs.h3web.notFoundMw')\nconst ERROR_MW = Symbol('kickjs.h3web.errorMw')\nconst ASSEMBLED = Symbol('kickjs.h3web.assembled')\nconst NOOP_NEXT = (): void => {}\n\n// Minimal structural surface of h3 v2 we depend on.\ninterface H3AppLike {\n  on(method: string, path: string, handler: (event: H3EventLike) => unknown): unknown\n  all(path: string, handler: (event: H3EventLike) => unknown): unknown\n  use(...args: unknown[]): unknown\n  fetch(request: Request): Promise<Response>\n}\ninterface H3EventLike {\n  req: Request & { runtime?: { node?: { req: IncomingMessage; res: ServerResponse } } }\n  url: URL\n  context: { params?: Record<string, string> }\n}\n\ninterface H3v2Module {\n  H3: new (config?: unknown) => H3AppLike\n  toNodeHandler: (app: H3AppLike) => (req: IncomingMessage, res: ServerResponse) => void\n  fromNodeHandler: (mw: unknown) => unknown\n}\n\nexport interface H3WebRuntimeOptions {\n  /**\n   * Pre-imported h3 v2 module. Two audiences:\n   * - Edge/worker bundlers with no `createRequire` at runtime:\n   *   `h3WebRuntime({ h3: await import('h3') })`\n   * - Tests running both h3 majors side by side via an npm alias.\n   * Omitted → the peer is loaded via `createRequire` (node bootstrap path).\n   */\n  h3?: unknown\n}\n\n/** Resolve h3 (injected or peer-required) and fail fast unless it is v2. */\nfunction loadH3v2(injected?: unknown): H3v2Module {\n  const mod = injected ?? peerRequire('h3')\n  const m = mod as { __esModule?: boolean; default?: Record<string, unknown> } & Record<\n    string,\n    unknown\n  >\n  const resolved = (m && m.__esModule && m.default\n    ? { ...m.default, ...m }\n    : m) as unknown as H3v2Module\n  if (typeof resolved.H3 !== 'function') {\n    throw new Error(\n      \"@forinda/kickjs: h3WebRuntime() requires h3 v2 (the web-standards line, npm dist-tag 'latest'), \" +\n        'but the installed h3 has no H3 class — that is the v1 line. ' +\n        \"Either `pnpm add h3@latest` for this runtime, or keep h3 v1 and use h3Runtime() from '@forinda/kickjs/h3'.\",\n    )\n  }\n  return resolved\n}\n\n/**\n * Bridge a connect-style terminal middleware (kick's notFound / error\n * handlers) onto the web driver pair, returning the produced Response.\n */\nasync function runConnectTerminal(\n  mw: ConnectMiddleware | undefined,\n  event: H3EventLike,\n  err?: unknown,\n): Promise<Response> {\n  const req = new WebRequestShim(event.req, event.url)\n  const driver = new WebResponseDriver(event.req.signal)\n  if (mw) {\n    if (err !== undefined) {\n      ;(mw as (e: unknown, rq: unknown, rs: unknown, n: () => void) => void)(\n        err,\n        req,\n        driver,\n        NOOP_NEXT,\n      )\n    } else {\n      ;(mw as (rq: unknown, rs: unknown, n: () => void) => void)(req, driver, NOOP_NEXT)\n    }\n  }\n  if (!driver.settled) {\n    if (err !== undefined) {\n      // The configured error handler ran but didn't settle the response\n      // (or there wasn't one). Emitting a bare 500 with no log entry\n      // makes this failure invisible on both sides — log it here, since\n      // by definition nothing downstream will.\n      log.error(err, `h3-web: error handler did not settle the response — ${describeError(err)}`)\n      driver.status(500).json({\n        error: 'Internal Server Error',\n        ...(typeof process !== 'undefined' && process.env?.NODE_ENV === 'production'\n          ? {}\n          : { message: describeError(err) }),\n      })\n    } else {\n      driver.status(404).json({ error: 'Not Found' })\n    }\n  }\n  return driver.ready\n}\n\n// ── Connect middleware on the fetch path ─────────────────────────────────\n//\n// `app.fetch(request)` (edge, Bun, Deno, a serverless function) carries no\n// node req/res, and h3's `fromNodeHandler` throws without one. Connect\n// middleware there runs against the web driver pair instead: one request shim\n// per event (so `req.requestId` set by one middleware is seen by the next) and\n// one header bag per event that is merged into whatever Response comes back.\n// The merge is ours rather than h3's `event.res.headers` because h3 skips\n// prepared headers on non-2xx responses, and a 404/422/500 must still carry\n// helmet's headers and the request id, exactly as on node.\n\ninterface FetchConnectState {\n  req: WebRequestShim\n  headers: Headers\n}\n\nconst FETCH_CONNECT = new WeakMap<object, FetchConnectState>()\n\nfunction fetchConnectState(event: H3EventLike): FetchConnectState {\n  let state = FETCH_CONNECT.get(event)\n  if (!state) {\n    state = { req: new WebRequestShim(event.req, event.url), headers: new Headers() }\n    FETCH_CONNECT.set(event, state)\n  }\n  return state\n}\n\n/**\n * Add the headers connect middleware set to `response`. The response's own\n * headers win — a later `setHeader` overrides an earlier one on node too.\n * Consumed once, so every middleware layer can call it on the way out.\n */\nfunction withConnectHeaders(event: H3EventLike, response: Response): Response {\n  const state = FETCH_CONNECT.get(event)\n  if (!state) return response\n  const missing = [...state.headers].filter(\n    ([name]) => name === 'set-cookie' || !response.headers.has(name),\n  )\n  state.headers = new Headers()\n  if (missing.length === 0) return response\n  try {\n    for (const [name, value] of missing) response.headers.append(name, value)\n    return response\n  } catch {\n    // Immutable headers (a Response from fetch) — rebuild around the body.\n    const headers = new Headers(response.headers)\n    for (const [name, value] of missing) headers.append(name, value)\n    return new Response(response.body, {\n      status: response.status,\n      statusText: response.statusText,\n      headers,\n    })\n  }\n}\n\n/**\n * The node `res` surface connect middleware uses, over the web driver:\n * headers go to the per-event bag, `statusCode`, and `finish`/`close`\n * emitted once the response exists.\n */\nclass FetchConnectResponse extends WebResponseDriver {\n  private code = 200\n  private listeners: Array<[string, (...args: unknown[]) => void]> = []\n\n  constructor(\n    private readonly prepared: Headers,\n    signal: AbortSignal,\n  ) {\n    super(signal)\n  }\n\n  get statusCode(): number {\n    return this.code\n  }\n\n  set statusCode(code: number) {\n    this.status(code)\n  }\n\n  override status(code: number): this {\n    this.code = code\n    return super.status(code)\n  }\n\n  override writeHead(code: number, headers?: Record<string, string | number | string[]>): this {\n    this.code = code\n    return super.writeHead(code, headers)\n  }\n\n  override setHeader(name: string, value: unknown): this {\n    if (Array.isArray(value)) {\n      this.prepared.delete(name)\n      for (const v of value) this.prepared.append(name, String(v))\n    } else {\n      this.prepared.set(name, String(value))\n    }\n    return this\n  }\n\n  getHeader(name: string): string | undefined {\n    return this.prepared.get(name) ?? undefined\n  }\n\n  hasHeader(name: string): boolean {\n    return this.prepared.has(name)\n  }\n\n  removeHeader(name: string): void {\n    this.prepared.delete(name)\n  }\n\n  override once(event: string, listener: (...args: unknown[]) => void): this {\n    this.listeners.push([event, listener])\n    return this\n  }\n\n  on(event: string, listener: (...args: unknown[]) => void): this {\n    return this.once(event, listener)\n  }\n\n  removeListener(event: string, listener: (...args: unknown[]) => void): this {\n    this.listeners = this.listeners.filter(([e, l]) => e !== event || l !== listener)\n    return this\n  }\n\n  off(event: string, listener: (...args: unknown[]) => void): this {\n    return this.removeListener(event, listener)\n  }\n\n  /** The response exists (or the request failed): fire `finish` then `close`. */\n  done(): void {\n    for (const event of ['finish', 'close']) {\n      for (const [e, listener] of this.listeners) if (e === event) listener()\n      this.listeners = this.listeners.filter(([e]) => e !== event)\n    }\n  }\n}\n\nfunction runConnectOnFetch(\n  mw: ConnectMiddleware,\n  event: H3EventLike,\n  next: () => unknown,\n): Promise<unknown> {\n  const state = fetchConnectState(event)\n  const res = new FetchConnectResponse(state.headers, event.req.signal)\n\n  return new Promise((resolve, reject) => {\n    const respond = (response: Response): void => {\n      res.done()\n      resolve(withConnectHeaders(event, response))\n    }\n    const fail = (err: unknown): void => {\n      res.done()\n      reject(err)\n    }\n\n    // The middleware answered itself (`res.end`, `res.json`, `writeHead`).\n    void res.ready.then(respond)\n\n    const connectNext = (err?: unknown): void => {\n      if (err) return fail(err)\n      if (res.settled) return\n      // The route builds its request store from the inbound header; hand it the\n      // id requestScope/requestId settled on so body, logs and header agree.\n      const id = state.req.requestId\n      if (id && event.req.headers.get('x-request-id') !== id) {\n        try {\n          event.req.headers.set('x-request-id', id)\n        } catch {\n          // Immutable request headers on some runtimes — the route mints its own id.\n        }\n      }\n      let downstream: unknown\n      try {\n        // Synchronous, so downstream work starts inside any AsyncLocalStorage\n        // scope this middleware opened (requestScopeMiddleware).\n        downstream = next()\n      } catch (e) {\n        return fail(e)\n      }\n      Promise.resolve(downstream).then((value) => {\n        if (value instanceof Response) return respond(value)\n        res.done()\n        resolve(value)\n      }, fail)\n    }\n\n    try {\n      ;(mw as (rq: unknown, rs: unknown, n: (err?: unknown) => void) => void)(\n        state.req,\n        res,\n        connectNext,\n      )\n    } catch (err) {\n      fail(err)\n    }\n  })\n}\n\n/**\n * Terminal catch-all AFTER all mounted routes: kick's own notFound handler\n * answers unmatched paths (h3 v2's default 404 never fires). rou3 ranks `/**`\n * below every concrete route, so registration time does not matter.\n */\nfunction assembleCatchAll(app: H3AppLike): void {\n  const state = app as unknown as Record<symbol, unknown>\n  if (state[ASSEMBLED]) return\n  state[ASSEMBLED] = true\n  app.all('/**', (event: H3EventLike) => {\n    const mw = state[NOTFOUND_MW] as ConnectMiddleware | undefined\n    return runConnectTerminal(mw, event)\n  })\n}\n\n/**\n * The h3 v2 HTTP runtime. Pass to `bootstrap({ runtime: h3WebRuntime() })`.\n * Requires the h3 v2 peer; fails fast with guidance when v1 is installed.\n */\nexport function h3WebRuntime(options: H3WebRuntimeOptions = {}): HttpRuntime<H3AppLike> {\n  const { H3, toNodeHandler, fromNodeHandler } = loadH3v2(options.h3)\n\n  return {\n    name: 'h3-web',\n\n    createApp(_options: RuntimeAppOptions = {}): H3AppLike {\n      const holder: { app?: H3AppLike } = {}\n      const app = new H3({\n        // Engine-level errors (middleware throws outside the kick pipeline)\n        // dispatch to the kick error handler once setErrorHandler stashes it.\n        onError: (error: unknown, event: H3EventLike) => {\n          const mw = (holder.app as unknown as Record<symbol, ConnectMiddleware | undefined>)?.[\n            ERROR_MW\n          ]\n          return runConnectTerminal(mw, event, error).then((response) =>\n            withConnectHeaders(event, response),\n          )\n        },\n      })\n      holder.app = app\n      return app\n    },\n\n    nodeHandler(app) {\n      assembleCatchAll(app)\n      const listener = toNodeHandler(app)\n      return (req: IncomingMessage, res: ServerResponse, next?: (err?: unknown) => void) => {\n        try {\n          const result = listener(req, res) as unknown\n          if (result && typeof (result as Promise<unknown>).then === 'function') {\n            void (result as Promise<unknown>).catch((err) => next?.(err))\n          }\n        } catch (err) {\n          next?.(err)\n        }\n      }\n    },\n\n    mountRoutes(app, table: RouteTable) {\n      for (const { mountPath, routes } of table) {\n        for (const entry of routes) {\n          const url = joinPath(mountPath, entry.path)\n          const hooks: WebRouteHooks = {\n            onError: async (err, req, driver) => {\n              const mw = (app as unknown as Record<symbol, ConnectMiddleware | undefined>)[ERROR_MW]\n              if (!mw) return\n              ;(mw as (e: unknown, rq: unknown, rs: unknown, n: () => void) => void)(\n                err,\n                req,\n                driver,\n                NOOP_NEXT,\n              )\n            },\n          }\n          const run = compileWebRoute(entry, hooks)\n          app.on(entry.method, url, (event: H3EventLike) =>\n            run({\n              request: event.req,\n              url: event.url,\n              params: event.context.params ?? {},\n            }),\n          )\n        }\n      }\n    },\n\n    useConnect(app, mw: ConnectMiddleware, opts?: UseConnectOptions) {\n      // Behind a node server (toNodeHandler) the event carries node req/res and\n      // h3's own bridge runs the middleware unchanged. Called through\n      // `app.fetch(request)` there is none and fromNodeHandler would throw, so\n      // the middleware runs against the web driver pair instead.\n      const viaNode = fromNodeHandler(mw) as (event: H3EventLike) => unknown\n      const handler = (event: H3EventLike, next: () => unknown) =>\n        event.req.runtime?.node?.res ? viaNode(event) : runConnectOnFetch(mw, event, next)\n      if (opts?.path !== undefined) {\n        // v2 `use` is exact-match; `/**` covers the subtree like v1's prefix.\n        app.use(joinPath(String(opts.path), '/**'), handler)\n      } else {\n        app.use(handler)\n      }\n    },\n\n    serveStatic(app, prefix, dir) {\n      // serve-static bridged like any other connect middleware (node only).\n      const serveStatic = peerRequire('serve-static')\n      this.useConnect(app, serveStatic(dir) as ConnectMiddleware, { path: prefix })\n    },\n\n    setNotFound(app, mw: ConnectMiddleware) {\n      ;(app as unknown as Record<symbol, ConnectMiddleware>)[NOTFOUND_MW] = mw\n      // Here as well as in nodeHandler: an app only ever called through\n      // `app.fetch` never reaches nodeHandler, and would answer h3's own 404.\n      assembleCatchAll(app)\n    },\n\n    setErrorHandler(app, mw: ConnectMiddleware) {\n      ;(app as unknown as Record<symbol, ConnectMiddleware>)[ERROR_MW] = mw\n    },\n\n    capabilities: {\n      render: false,\n      uploads: true,\n      connectMiddleware: true,\n      nativeBodyParsing: true,\n    },\n  }\n}\n\n/**\n * h3-web runtime engine types for the `kick/runtime` typegen augmentation —\n * mirrors {@link import('./h3').H3RuntimeTypes} for the v1 runtime.\n */\nexport interface H3WebRuntimeTypes {\n  request: Request\n  response: Response\n  app: unknown\n}\n\n/** Join a mount prefix and a route path into one URL, collapsing slashes. */\nfunction joinPath(mountPath: string, path: string): string {\n  const a = mountPath.endsWith('/') ? mountPath.slice(0, -1) : mountPath\n  if (path === '/' || path === '') return a === '' ? '/' : a\n  const b = path.startsWith('/') ? path : `/${path}`\n  return `${a}${b}`\n}\n"],"mappings":"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"}

package/dist/jobs-dx-MTUUb.mjs

@@ -1,12 +0,0 @@
-/**
- * @forinda/kickjs v9.1.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 createToken}from"./container-ZnfelY_a.mjs";import{createLogger}from"./core/logger.mjs";import{c as pushClassMeta,n as getClassMetaOrUndefined,t as getClassMeta,u as setClassMeta}from"./metadata-CW4I35nN.mjs";import{Service}from"./core/decorators.mjs";import{r as reportError}from"./observers-CC3sO1BM.mjs";const log=createLogger(`KickJobs`),JOB_META={JOB:`kick/queue/job`,PROCESS:`kick/queue/process`},jobClasses=new Map;function Job(queue){return target=>{Service()(target),setClassMeta(JOB_META.JOB,queue,target),jobClasses.set(target.name,target)}}function Process(jobName){return(target,propertyKey)=>{pushClassMeta(JOB_META.PROCESS,target.constructor,{handlerName:propertyKey,jobName})}}function listJobHandlers(container){let handlers=[];for(let target of jobClasses.values()){if(!container.has(target))continue;let queue=getClassMetaOrUndefined(JOB_META.JOB,target);if(queue===void 0)continue;let processes=getClassMeta(JOB_META.PROCESS,target,[]);processes.length===0&&log.warn(`@Job('${queue}') class ${target.name} has no @Process methods`);for(let process of processes)handlers.push({...process,queue,target})}return handlers}function listJobQueues(container){return[...new Set(listJobHandlers(container).map(h=>h.queue))]}var NoJobHandlerError=class extends Error{queue;jobName;constructor(queue,jobName){super(`No @Process handler for job "${jobName}" on queue "${queue}"`),this.queue=queue,this.jobName=jobName,this.name=`NoJobHandlerError`}};async function runJob(container,queue,job,report={}){let handlers=listJobHandlers(container).filter(h=>h.queue===queue),handler=handlers.find(h=>h.jobName===job.name)??handlers.find(h=>h.jobName===void 0);try{if(!handler)throw new NoJobHandlerError(queue,job.name);let instance=container.resolve(handler.target);return await withJobContext(job,()=>instance[handler.handlerName](job))()}catch(err){throw log.error({err},`Job ${queue}/${job.name} failed`),reportError(err,{source:`job`,context:{queue,job:job.name,id:job.id,...report}}),err}}const JOB_CONTEXT_FIELD=`__kickContext`,jobContextCarriers=new Map;function registerJobContext(carrier){jobContextCarriers.set(carrier.key,carrier)}const isPlainObject=v=>!!v&&typeof v==`object`&&Object.getPrototypeOf(v)===Object.prototype;function stampJobContext(data){if(!isPlainObject(data))return data;let{[JOB_CONTEXT_FIELD]:_untrusted,...rest}=data,context={};for(let[key,carrier]of jobContextCarriers){let value=carrier.capture();value!==void 0&&(context[key]=value)}return Object.keys(context).length>0?{...rest,[JOB_CONTEXT_FIELD]:context}:rest}function withJobContext(job,run){let data=job.data;if(!isPlainObject(data)||!(`__kickContext`in data))return run;let context=data[JOB_CONTEXT_FIELD];if(delete data[JOB_CONTEXT_FIELD],!isPlainObject(context))return run;let wrapped=run;for(let[key,value]of Object.entries(context)){let carrier=jobContextCarriers.get(key);if(!carrier)continue;let inner=wrapped;wrapped=()=>carrier.restore(value,inner)}return wrapped}const JOB_DISPATCHER=createToken(`kick/jobs/Dispatcher`);export{NoJobHandlerError as a,listJobQueues as c,stampJobContext as d,Job as i,registerJobContext as l,JOB_DISPATCHER as n,Process as o,JOB_META as r,listJobHandlers as s,JOB_CONTEXT_FIELD as t,runJob as u};
-//# sourceMappingURL=jobs-dx-MTUUb.mjs.map

package/dist/kv-stores-Ba5_rcz-.mjs

@@ -1,12 +0,0 @@
-/**
- * @forinda/kickjs v9.1.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{n as assertFlagTest,s as matchesFlagTest}from"./route-flag-sIYXay3q.mjs";var LazyMemoryStore=class{windowMs;hits=new Map;constructor(windowMs){this.windowMs=windowMs}async increment(key){let now=Date.now(),entry=this.hits.get(key);if(entry&&entry.reset>now)return entry.hits++,{totalHits:entry.hits,resetTime:new Date(entry.reset)};if(this.hits.size>1e4)for(let[k,e]of this.hits)e.reset<=now&&this.hits.delete(k);let fresh={hits:1,reset:now+this.windowMs};return this.hits.set(key,fresh),{totalHits:1,resetTime:new Date(fresh.reset)}}async decrement(key){let entry=this.hits.get(key);entry&&entry.hits>0&&entry.hits--}async reset(key){this.hits.delete(key)}};function defaultKey(ctx){return ctx.ip??`global`}function rateLimitGuard(options={}){let max=options.max??100,windowMs=options.windowMs??6e4,message=options.message??`Too Many Requests`,statusCode=options.statusCode??429,keyGenerator=options.keyGenerator??defaultKey,sendHeaders=options.headers??!0,store=options.store??new LazyMemoryStore(windowMs),exemptWhen=options.exemptWhen;return exemptWhen!==void 0&&assertFlagTest(exemptWhen,`rateLimitGuard({ exemptWhen })`),async(ctx,next)=>{if(options.skip?.(ctx)||exemptWhen!==void 0&&matchesFlagTest(exemptWhen,ctx.route?.flags,ctx.route))return next();let{totalHits,resetTime}=await store.increment(keyGenerator(ctx)),remaining=Math.max(0,max-totalHits);if(sendHeaders&&(ctx.setHeader(`X-RateLimit-Limit`,String(max)),ctx.setHeader(`X-RateLimit-Remaining`,String(remaining)),ctx.setHeader(`X-RateLimit-Reset`,String(Math.ceil(resetTime.getTime()/1e3)))),totalHits>max){let retryAfter=Math.max(1,Math.ceil((resetTime.getTime()-Date.now())/1e3));sendHeaders&&ctx.setHeader(`Retry-After`,String(retryAfter)),ctx.json({message},statusCode);return}next()}}function kvTtlSeconds(ms){return Math.max(60,Math.ceil(ms/1e3))}var KvRateLimitStore=class{kv;prefix;windowMs;constructor(kv,options){this.kv=kv,this.windowMs=options.windowMs,this.prefix=options.prefix??`rl:`}async increment(key){let now=Date.now(),entry=await this.read(key);if(entry&&entry.reset>now)return entry.hits++,await this.write(key,entry),{totalHits:entry.hits,resetTime:new Date(entry.reset)};let fresh={hits:1,reset:now+this.windowMs};return await this.write(key,fresh),{totalHits:1,resetTime:new Date(fresh.reset)}}async decrement(key){let entry=await this.read(key);entry&&entry.hits>0&&(entry.hits--,await this.write(key,entry))}async reset(key){await this.kv.delete(this.prefix+key)}async read(key){let raw=await this.kv.get(this.prefix+key);if(raw===null)return null;try{return JSON.parse(raw)}catch{return null}}async write(key,entry){await this.kv.put(this.prefix+key,JSON.stringify(entry),{expirationTtl:kvTtlSeconds(Math.max(entry.reset-Date.now(),1e3))})}},KvSessionStore=class{kv;prefix;constructor(kv,options={}){this.kv=kv,this.prefix=options.prefix??`sess:`}async get(sid){let raw=await this.kv.get(this.prefix+sid);if(raw===null)return null;try{return JSON.parse(raw)}catch{return null}}async set(sid,data,maxAge){await this.kv.put(this.prefix+sid,JSON.stringify(data),{expirationTtl:kvTtlSeconds(maxAge)})}async destroy(sid){await this.kv.delete(this.prefix+sid)}async touch(sid,maxAge){let data=await this.get(sid);data!==null&&await this.set(sid,data,maxAge)}};export{KvSessionStore as n,rateLimitGuard as r,KvRateLimitStore as t};
-//# sourceMappingURL=kv-stores-Ba5_rcz-.mjs.map

package/dist/kv-stores-CetFF9N_.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"kv-stores-CetFF9N_.d.mts","names":[],"sources":["../src/core/jobs.ts","../src/http/background.ts","../src/http/reply.ts","../src/http/middleware/rate-limit-guard.ts","../src/http/middleware/kv-stores.ts"],"mappings":";;;;;;;;;cA6Ba;WACX;WACA;;;UAIe;;EAEf;;EAEA;;;;;;;UAQe,QAAQ;EACvB;EACA,MAAM;EACN;;;iBAUc,IAAI,gBAAgB;;iBASpB,QAAQ,mBAAmB;;UAU1B,mBAAmB;EAClC;EACA,QAAQ;;;;;;;iBAQM,gBAAgB;EAAa,IAAI;IAA6B;;iBAgB9D,cAAc;EAAa,IAAI;;;cAKlC,0BAA0B;WAE1B;WACA;EAFX,YACW,eACA;;;;;;;;;;iBAeS,OACpB;EAAa,IAAI;EAA0B,QAAQ;GACnD,eACA,KAAK,SAEL;;AAAA,SAAQ,0BACP;;;;;;UAoBc,kBAAkB;;EAEjC;;EAEA,WAAW;;EAEX,QAAQ,GAAG,OAAO,GAAG,WAAW,IAAI;;;cAIzB;;iBAKG,mBAAmB,GAAG,SAAS,kBAAkB;;;;;;;;iBAcjD,gBAAgB,MAAM,MAAM,OAAO;;UAiClC;EACf,SAAS,gBACP,eACA,cACA,MAAM,MACN,UAAU,0BACT;;;;;;cAOQ,gBAAc,eAAA;;;;;;;;;;;;;;;;;iBC9LX,UAAU,SAAS;;;;;iBAiBb,wBAAwB;;;;;;UAc7B;EACf,WAAW,SAAS;;;;cCvDhB;;;;;;UAOW,MAAM,2BAA2B;YACtC;WACD,QAAQ;WACR,MAAM;;;;;;;;;;;;iBAaD,MAAM,kBAAkB,GAAG,QAAQ,GAAG,MAAM,IAAI,MAAM,GAAG;kBAAzD;MAKJ,KAAA,GAAC,MAAQ,MAAI,WAAW;MAEnB,UAAA,GAAC,MAAQ,MAAI,WAAW;MAEvB,WAAA,GAAC,MAAQ,MAAI,WAAW;MAEpB,iBAAA;;;;;;;;;;;;;;;;KAgBV,qBAAqB,KAAK,eAAc,wBAAwB,MACvE,QAAQ,QAAQ,mDAEf,YAAY,QAAQ,QAAQ;KAG7B,YAAY,KACf,UAAU,oBAAoB,KAC1B,IACA,UAAU,4BAWR;iBAEQ,QAAQ,iBAAiB,SAAS;;;;;;;;;;;;iBAmBlC,mBAAmB,KAAK,gBAAgB;;;UCjGvC;;EAEf;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;;;;;;;;;EAuBA,gBAAgB,KAAK;;EAErB;;;;;;EAMA,QAAQ;;EAER,QAAQ,KAAK;;;;;;;;;;;;;;;;EAgBb,aAAa;;;;;;;;;;;;;;;;;iBA0DC,eAAe,UAAS,wBAA6B;;;;;;;;;;;;;;;;;;;UCxGpD;EACf,IAAI,cAAc;EAClB,IAAI,aAAa,eAAe;IAAY;MAA2B;EACvE,OAAO,cAAc;;UAQN;;EAEf;;EAEA;;;;;;;;;;;;cAaW,4BAA4B;mBAKpB;mBAJF;mBACA;EAEjB,YACmB,IAAI,QACrB,SAAS;EAML,UAAU,cAAc;IAAU;IAAmB,WAAW;;EAahE,UAAU,cAAc;EAQxB,MAAM,cAAc;UAIZ;UAUA;;UAOC;;EAEf;;;;;;;;;;;;cAaW,0BAA0B;mBAIlB;mBAHF;EAEjB,YACmB,IAAI,QACrB,UAAS;EAKL,IAAI,cAAc,QAAQ;EAU1B,IAAI,aAAa,MAAM,aAAa,iBAAiB;EAMrD,QAAQ,cAAc;EAItB,MAAM,aAAa,iBAAiB"}

package/dist/query-DPlkWOw6.mjs

@@ -1,12 +0,0 @@
-/**
- * @forinda/kickjs v9.1.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
- */
-const FILTER_OPERATORS=new Set([`eq`,`neq`,`gt`,`gte`,`lt`,`lte`,`between`,`in`,`contains`,`starts`,`ends`]),BUILTIN_DEFAULTS={maxLimit:100,defaultLimit:20,maxSearchLength:200,defaultPage:1},defaults={...BUILTIN_DEFAULTS};function setQueryParsingDefaults(partial){partial.maxLimit!==void 0&&(defaults.maxLimit=partial.maxLimit),partial.defaultLimit!==void 0&&(defaults.defaultLimit=partial.defaultLimit),partial.maxSearchLength!==void 0&&(defaults.maxSearchLength=partial.maxSearchLength)}function getQueryParsingDefaults(){return{...defaults}}function resetQueryParsingDefaults(){Object.assign(defaults,BUILTIN_DEFAULTS)}function parseFilters(filterParam,allowedFields,options){if(!filterParam)return[];let items=Array.isArray(filterParam)?filterParam:[filterParam],results=[],allowed=allowedFields?new Set(allowedFields):null,onReject=options?.onReject;for(let item of items){let firstColon=item.indexOf(`:`);if(firstColon===-1)continue;let secondColon=item.indexOf(`:`,firstColon+1);if(secondColon===-1)continue;let field=item.slice(0,firstColon),operator=item.slice(firstColon+1,secondColon),value=item.slice(secondColon+1);if(field&&value){if(!FILTER_OPERATORS.has(operator)){onReject?.({kind:`filter`,field,reason:`unknown-operator`});continue}if(allowed&&!allowed.has(field)){onReject?.({kind:`filter`,field,reason:`field-not-allowed`});continue}results.push({field,operator,value})}}return results}function parseSort(sortParam,allowedFields,options){if(!sortParam)return[];let items=Array.isArray(sortParam)?sortParam:[sortParam],results=[],allowed=allowedFields?new Set(allowedFields):null,onReject=options?.onReject;for(let item of items){let lastColon=item.lastIndexOf(`:`);if(lastColon===-1)continue;let field=item.slice(0,lastColon),dir=item.slice(lastColon+1).toLowerCase();if(field&&(dir===`asc`||dir===`desc`)){if(allowed&&!allowed.has(field)){onReject?.({kind:`sort`,field,reason:`field-not-allowed`});continue}results.push({field,direction:dir})}}return results}function parsePagination(params,options){let defaultLimit=options?.defaultLimit??defaults.defaultLimit,maxLimit=options?.maxLimit??defaults.maxLimit,page=typeof params.page==`string`?Number.parseInt(params.page,10):params.page??defaults.defaultPage,limit=typeof params.limit==`string`?Number.parseInt(params.limit,10):params.limit??defaultLimit;return(Number.isNaN(page)||page<1)&&(page=defaults.defaultPage),(Number.isNaN(limit)||limit<1)&&(limit=defaultLimit),limit>maxLimit&&(limit=maxLimit),{page,limit,offset:(page-1)*limit}}function parseSearchQuery(q,options){if(!q)return``;let maxLen=options?.maxSearchLength??defaults.maxSearchLength,trimmed=q.trim();return trimmed.length>maxLen?(options?.onReject?.({kind:`search`,field:`q`,reason:`truncated`}),trimmed.slice(0,maxLen)):trimmed}function normalizeFieldConfig(config){if(config)return`columns`in config&&config.columns&&typeof config.columns==`object`?{filterable:Object.keys(config.columns),sortable:config.sortable?Object.keys(config.sortable):void 0,searchable:void 0}:config}function parseQuery(query,fieldConfig,options){let normalized=normalizeFieldConfig(fieldConfig),rejectOpts=options?.onReject?{onReject:options.onReject}:void 0;return{filters:parseFilters(query.filter,normalized?.filterable,rejectOpts),sort:parseSort(query.sort,normalized?.sortable,rejectOpts),pagination:parsePagination({page:query.page,limit:query.limit},options),search:parseSearchQuery(query.q,options)}}function buildQueryParams(parsed){let params={};return parsed.filters?.length&&(params.filter=parsed.filters.map(f=>`${f.field}:${f.operator}:${f.value}`)),parsed.sort?.length&&(params.sort=parsed.sort.map(s=>`${s.field}:${s.direction}`)),parsed.pagination&&(params.page=parsed.pagination.page,params.limit=parsed.pagination.limit),parsed.search&&(params.q=parsed.search),params}export{parseQuery as a,resetQueryParsingDefaults as c,parsePagination as i,setQueryParsingDefaults as l,getQueryParsingDefaults as n,parseSearchQuery as o,parseFilters as r,parseSort as s,buildQueryParams as t,FILTER_OPERATORS as u};
-//# sourceMappingURL=query-DPlkWOw6.mjs.map

package/dist/route-flag-sIYXay3q.mjs

@@ -1,12 +0,0 @@
-/**
- * @forinda/kickjs v9.1.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{METADATA}from"./core/interfaces.mjs";import{a as getMethodMeta,c as pushClassMeta,l as pushMethodMeta,t as getClassMeta}from"./metadata-CW4I35nN.mjs";const FLAG_UNSET=Symbol(`kick.flagUnset`);function isDecoratorApplication(args){let[target,propertyKey]=args;return typeof propertyKey==`string`||typeof propertyKey==`symbol`||args.length===1&&typeof target==`function`}function defineRouteFlag(name){if(name.startsWith(`!`))throw Error(`defineRouteFlag('${name}'): a flag name cannot start with '!' — that prefix is reserved for negated tests ('!${name.slice(1)}' means "does not carry ${name.slice(1)}"). Rename the flag.`);function apply(value,target,propertyKey){let declaration={name,value};if(propertyKey===void 0){pushClassMeta(METADATA.CLASS_FLAGS,target,declaration);return}pushMethodMeta(METADATA.METHOD_FLAGS,target.constructor,String(propertyKey),declaration)}let flag=(...args)=>{if(isDecoratorApplication(args)){apply(!0,args[0],args[1]);return}let value=args[0];return(target,propertyKey)=>{apply(value,target,propertyKey)}};return Object.defineProperty(flag,"flagName",{value:name,enumerable:!0}),Object.defineProperty(flag,"off",{value:(target,propertyKey)=>{apply(FLAG_UNSET,target,propertyKey)},enumerable:!0}),flag}function resolveRouteFlags(classDeclarations,methodDeclarations,mountDeclarations=[]){let resolved=new Map;for(let{name,value}of[...mountDeclarations,...classDeclarations,...methodDeclarations]){if(value===FLAG_UNSET){resolved.delete(name);continue}resolved.set(name,value)}return resolved}function matchesFlagTest(test,flags,route){let resolved=flags??EMPTY_FLAGS;if(typeof test==`function`)return test({flags:resolved,route});if(typeof test==`string`)return isNegated(test)?!resolved.has(stripNegation(test)):resolved.has(test);if(test.length===0)return!1;let negated=isNegated(test[0]);if(test.some(name=>isNegated(name)!==negated))throw Error(`Route flag test mixes polarities: [${test.map(n=>`'${n}'`).join(`, `)}]. A list is either all names ("carries any of these") or all negated ("carries none of these") — for anything else, pass a predicate.`);return negated?test.every(name=>!resolved.has(stripNegation(name))):test.some(name=>resolved.has(name))}function assertFlagTest(test,site){if(typeof test==`function`||typeof test==`string`||test.length===0)return;let negated=isNegated(test[0]);if(test.some(name=>isNegated(name)!==negated))throw Error(`${site}: route flag test mixes polarities: [${test.map(n=>`'${n}'`).join(`, `)}]. A list is either all names ("carries any of these") or all negated ("carries none of these") — for anything else, pass a predicate.`)}const isNegated=name=>name.startsWith(`!`),stripNegation=name=>name.slice(1),EMPTY_FLAGS=new Map,ROUTE_SLOT=Symbol.for(`kick.route`);function getRouteFlags(controllerClass,handlerName){return resolveRouteFlags(getClassFlagDeclarations(controllerClass),getMethodFlagDeclarations(controllerClass,handlerName),getMountFlagDeclarations(controllerClass))}function getClassFlagDeclarations(controllerClass){return getClassMeta(METADATA.CLASS_FLAGS,controllerClass,[])}function getMethodFlagDeclarations(controllerClass,handlerName){return getMethodMeta(METADATA.METHOD_FLAGS,controllerClass,handlerName,[])}function toFlagDeclarations(flags,site){return flags?(Array.isArray(flags)?flags.map(name=>[name,!0]):Object.entries(flags)).map(([name,value])=>{if(name.startsWith(`!`))throw Error(`${site}: a flag name cannot start with '!' — that prefix is reserved for negated tests, and a declaration has no negative form. Remove the flag instead of declaring '${name}'.`);return{name,value}}):[]}const MOUNT_FLAGS=new WeakMap;function registerMountFlags(controllerClass,declarations){if(declarations.length===0){MOUNT_FLAGS.delete(controllerClass);return}MOUNT_FLAGS.set(controllerClass,[...declarations])}function getMountFlagDeclarations(controllerClass){return MOUNT_FLAGS.get(controllerClass)??[]}export{getMethodFlagDeclarations as a,registerMountFlags as c,getClassFlagDeclarations as i,resolveRouteFlags as l,assertFlagTest as n,getRouteFlags as o,defineRouteFlag as r,matchesFlagTest as s,ROUTE_SLOT as t,toFlagDeclarations as u};
-//# sourceMappingURL=route-flag-sIYXay3q.mjs.map

package/dist/route-policy-B6_toGJW.mjs

@@ -1,12 +0,0 @@
-/**
- * @forinda/kickjs v9.1.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
- */
-const EMPTY=new Map;function compile(path){let source=path.replace(/[.+?^${}()|[\]\\]/g,`\\$&`).replace(/\/:[^/]+/g,`/([^/]+)`).replace(/\*/g,`.*`);return RegExp(`^${source}/?$`)}var RoutePolicyTable=class{byMethod=new Map;add(method,path,flags){if(!flags||flags.size===0)return;let verb=method.toUpperCase(),bucket=this.byMethod.get(verb)??[];bucket.push({pattern:compile(path),flags}),this.byMethod.set(verb,bucket)}lookup(method,pathname){let bucket=this.byMethod.get(method.toUpperCase());if(!bucket)return EMPTY;for(let entry of bucket)if(entry.pattern.test(pathname))return entry.flags;return EMPTY}clear(){this.byMethod.clear()}get size(){let total=0;for(let bucket of this.byMethod.values())total+=bucket.length;return total}};const ROUTE_POLICY_SLOT=Symbol.for(`kick.routePolicy`);function bindRoutePolicy(handler,receive){return Object.defineProperty(handler,ROUTE_POLICY_SLOT,{value:receive,enumerable:!1}),handler}function offerRoutePolicy(handler,table){let receive=handler?.[ROUTE_POLICY_SLOT];typeof receive==`function`&&receive(table)}export{bindRoutePolicy as n,offerRoutePolicy as r,RoutePolicyTable as t};
-//# sourceMappingURL=route-policy-B6_toGJW.mjs.map