@forinda/kickjs 6.5.0 → 6.5.1

package/dist/{adapter-CEt1MEdF.d.mts → adapter-CbMq-NBf.d.mts}

@@ -1,13 +1,14 @@
 
-import { i as Constructor, o as MaybePromise } from "./interfaces-CayXPOAf.mjs";
-import { s as InjectionToken, t as Container } from "./container-iED1swkd.mjs";
-import { g as FileUploadConfig, k as RouteDefinition, x as MiddlewareHandler } from "./decorators-wEJBqXHg.mjs";
-import { _ as ExecutionContext, a as AnyContributorRegistration, d as ContributorRegistrations, r as AppModuleEntry, t as AppModule, v as MetaValue } from "./app-module-BSpHKlhE.mjs";
-import { i as ProblemDetails } from "./errors-n0H96eEz.mjs";
-import { S as QueryFieldConfig, T as TypedParsedQuery, t as ParseQueryOptions } from "./index-BtWJ9SLP.mjs";
+import { i as Constructor, o as MaybePromise } from "./interfaces-BTTBdkvG.mjs";
+import { s as InjectionToken, t as Container } from "./container-BW_MlgLj.mjs";
+import { g as FileUploadConfig, k as RouteDefinition, x as MiddlewareHandler } from "./decorators-Bks7cgBJ.mjs";
+import { _ as ExecutionContext, a as AnyContributorRegistration, d as ContributorRegistrations, r as AppModuleEntry, t as AppModule, v as MetaValue } from "./app-module-DtoySG6l.mjs";
+import "./cache-C0qL0NSD.mjs";
+import { i as ProblemDetails } from "./errors-By6UueCm.mjs";
+import { S as QueryFieldConfig, T as TypedParsedQuery, t as ParseQueryOptions } from "./index-BfT5KZ-M.mjs";
+import "reflect-metadata";
 import http, { IncomingMessage, ServerResponse } from "node:http";
 import { ErrorRequestHandler, Express as Express$1, NextFunction, Request, RequestHandler, Response } from "express";
-
 //#region src/core/introspect.d.ts
 /**
  * Per-primitive introspection snapshot — the JSON shape an adapter or
@@ -688,81 +689,6 @@ declare class ModuleList extends Array<AppModuleEntry> {
  */
 declare function defineModules(...initial: AppModuleEntry[]): ModuleList;
 //#endregion
-//#region src/core/disposables.d.ts
-/**
- * Registry for framework-owned resources that hold timers or other handles
- * outside the adapter/plugin lifecycle — e.g. the in-memory session and
- * rate-limit stores' cleanup intervals. `Application.shutdown()` drains it so
- * startup and shutdown stay symmetric even for resources created lazily by
- * middleware factories.
- *
- * Intervals are `.unref()`'d so they never wedge process exit — this registry
- * exists for IN-PROCESS teardown (test suites, HMR, multi-app hosts) where
- * each un-disposed store would otherwise leak a live interval + backing Map
- * per app instance.
- */
-type Disposable = () => void | Promise<void>;
-/** Register a cleanup callback. Returns an unregister function. */
-declare function registerDisposable(fn: Disposable): () => void;
-/** Run and clear all registered disposables. Errors are swallowed per-entry. */
-declare function disposeAll(): Promise<void>;
-//#endregion
-//#region src/core/kick-error.d.ts
-/**
- * Structured framework error with code, cause, and actionable fix hint.
- *
- * The goal is "the developer who hits this knows what to do next." A
- * cryptic `Error('No binding found for: UserService')` becomes a
- * multi-line explanation pointing at the likely cause, the exact code
- * change to apply, and a docs link.
- *
- * `.message` carries the full multi-line plain-text body so Node's
- * default `Error.toString()` and unhandled-exception printing still
- * surface the helpful version. Call {@link formatKickError} to render a
- * colorized version for terminals.
- *
- * Per-error factories live in `kick-errors.ts` — those are the public
- * entry points framework code uses. `KickError` is exported so adopters
- * can build their own structured errors using the same shape.
- */
-interface KickErrorInit {
-  /** Short stable identifier (e.g. `KICK001`, `NO_PROVIDER`). */
-  code: string;
-  /** One-line headline. */
-  summary: string;
-  /** Multi-line explanation of why this happened. */
-  cause?: string;
-  /** Multi-line actionable fix — show exact code if possible. */
-  fix?: string;
-  /** Absolute URL to the docs page that covers this error. */
-  docsUrl?: string;
-  /** Arbitrary structured fields for log consumers / debug tooling. */
-  context?: Record<string, unknown>;
-}
-declare class KickError extends Error {
-  readonly code: string;
-  readonly summary: string;
-  readonly cause?: string;
-  readonly fix?: string;
-  readonly docsUrl?: string;
-  readonly context?: Record<string, unknown>;
-  constructor(init: KickErrorInit);
-}
-interface FormatKickErrorOptions {
-  /**
-   * Render ANSI colour codes. Defaults to TTY detection (`NO_COLOR` /
-   * `FORCE_COLOR` env vars honoured). Pass `false` for log files,
-   * structured loggers, or HTTP response bodies.
-   */
-  color?: boolean;
-}
-/**
- * Render a {@link KickErrorInit} (or {@link KickError} instance) into a
- * multi-line human-readable string. Identical layout regardless of
- * colour — the colour flag only toggles ANSI codes.
- */
-declare function formatKickError(err: KickErrorInit | KickError, options?: FormatKickErrorOptions): string;
-//#endregion
 //#region src/core/metadata.d.ts
 /**
  * Typed utilities for reflect-metadata operations.
@@ -803,181 +729,6 @@ declare function setInMetaRecord<V>(key: MetaKey, target: object, recKey: string
 /** Get a Record from class metadata (returns empty object if absent) */
 declare function getMetaRecord<V>(key: MetaKey, target: object): Record<string | number, V>;
 //#endregion
-//#region src/core/circuit-breaker.d.ts
-/**
- * Circuit Breaker pattern for external service calls.
- *
- * Protects your application from cascading failures when downstream
- * services are unhealthy by short-circuiting requests after a
- * configurable failure threshold.
- *
- * @example
- * ```ts
- * const breaker = new CircuitBreaker('payment-api', {
- *   failureThreshold: 5,
- *   resetTimeout: 30_000,
- * })
- *
- * const result = await breaker.execute(() => fetch('https://payment.example.com/charge'))
- * ```
- */
-type CircuitBreakerState = 'closed' | 'open' | 'half_open';
-interface CircuitBreakerOptions {
-  /** Number of consecutive failures before the circuit opens. */
-  failureThreshold: number;
-  /** Milliseconds to wait before transitioning from OPEN to HALF_OPEN. */
-  resetTimeout: number;
-  /** Max requests allowed in HALF_OPEN state before deciding (default 1). */
-  halfOpenMax?: number;
-}
-interface CircuitBreakerStats {
-  failures: number;
-  successes: number;
-  state: CircuitBreakerState;
-  lastFailure?: Date;
-}
-/**
- * Error thrown when the circuit is open and calls are being rejected.
- */
-declare class CircuitOpenError extends Error {
-  readonly breakerName: string;
-  constructor(breakerName: string);
-}
-declare class CircuitBreaker {
-  readonly name: string;
-  private state;
-  private failures;
-  private successes;
-  private halfOpenAttempts;
-  private lastFailure?;
-  private openedAt?;
-  private readonly failureThreshold;
-  private readonly resetTimeout;
-  private readonly halfOpenMax;
-  constructor(name: string, options: CircuitBreakerOptions);
-  /**
-   * Execute an async function through the circuit breaker.
-   * Throws `CircuitOpenError` if the circuit is open.
-   */
-  execute<T>(fn: () => Promise<T>): Promise<T>;
-  /** Returns the current circuit state. */
-  getState(): CircuitBreakerState;
-  /** Returns current statistics. */
-  getStats(): CircuitBreakerStats;
-  /** Manually reset the circuit breaker to CLOSED state. */
-  reset(): void;
-  private onSuccess;
-  private onFailure;
-  private maybeTransitionToHalfOpen;
-}
-//#endregion
-//#region src/core/context-errors.d.ts
-/**
- * Errors thrown by the Context Contributor pipeline.
- *
- * `MissingContributorError`, `ContributorCycleError`, and
- * `DuplicateContributorError` are startup-time errors raised during
- * pipeline build (topo-sort + validation), not per-request — a
- * misconfigured app fails to boot rather than fails a request. Per the
- * locked design in `architecture.md` §20.4, the pipeline is validated
- * once when each route is mounted and the resolved order is cached on
- * the route.
- *
- * `MissingContextValueError` is the one request-time error here: it is
- * raised by `ctx.require(key)` when a value a handler declared it needs
- * is absent. See its doc comment for why that case can't be caught at
- * startup today.
- */
-/**
- * A contributor declared `dependsOn: ['<key>']` but no other contributor
- * (at any precedence level) produces that key for the same route.
- *
- * @example
- * ```text
- * MissingContributorError: Missing context contributor 'tenant' required by 'project' on route GET /projects/:id
- *     declared at src/contributors/load-project.ts:42:18
- * ```
- */
-declare class MissingContributorError extends Error {
-  readonly key: string;
-  readonly dependent: string;
-  readonly route?: string;
-  readonly dependentDefinedAt?: string;
-  constructor(key: string, dependent: string, route?: string, dependentDefinedAt?: string);
-}
-/**
- * `ctx.require(key)` found no value under `key` in the per-request
- * metadata store.
- *
- * Thrown at request time, by design. `ctx.get(key)` returns
- * `T | undefined` for every key, so the usual workaround is a
- * non-null assertion — `ctx.get('tenant')!` — which compiles whether or
- * not the route actually carries the contributor that produces it. On
- * an authorization value that is the worst possible thing to leave
- * untypeable: dropping the decorator produces no diagnostic anywhere,
- * and the handler reads `undefined` as though it were a real value.
- *
- * `ctx.require()` converts that silent hole into a loud, named failure
- * that points at the missing contributor.
- *
- * A handler typed with a generated route type (`Ctx<KickRoutes…>`) also
- * gets compile-time narrowing, so a dropped decorator fails `tsc` rather
- * than reaching this error at all. This error remains the backstop for
- * routes typegen couldn't prove (module/adapter/bootstrap registrations),
- * handlers typed as plain `RequestContext`, and contributors that ran but
- * resolved to `undefined`. See `architecture.md` §20.14.
- *
- * @example
- * ```text
- * MissingContextValueError: No context value for 'tenantPerm' on GET /projects/:id
- *     Nothing wrote this key before the handler ran. Either the contributor
- *     that produces it isn't applied to this route, or it ran and resolved
- *     to undefined (check `optional: true` contributors).
- * ```
- */
-declare class MissingContextValueError extends Error {
-  readonly key: string;
-  readonly route?: string;
-  constructor(key: string, route?: string);
-}
-/**
- * Topo-sort detected a cycle in `dependsOn` declarations. The `cycle` field
- * lists the keys in the order they form the loop, with the first key
- * repeated at the end so the path reads naturally.
- *
- * @example
- * ```text
- * ContributorCycleError: Cycle in context contributors on route GET /projects/:id: tenant → project → tenant
- * ```
- */
-declare class ContributorCycleError extends Error {
-  readonly cycle: readonly string[];
-  readonly route?: string;
-  constructor(cycle: readonly string[], route?: string);
-}
-/**
- * Two contributors at the same precedence level both produce the same key
- * for the same route. Precedence resolution (method > class > module >
- * adapter > global, per architecture.md §20.4) silently drops
- * lower-precedence duplicates; this error fires only when ties occur
- * within a single level — e.g., two method-level decorators declaring
- * `key: 'tenant'`.
- *
- * `sources` is best-effort identifying labels for each conflicting
- * registration (typically the decorator's call site or registering
- * module/adapter name).
- *
- * @example
- * ```text
- * DuplicateContributorError: Duplicate context contributor for key 'tenant' at the same precedence level. Sources: LoadTenantFromHeader, LoadTenantFromSubdomain
- * ```
- */
-declare class DuplicateContributorError extends Error {
-  readonly key: string;
-  readonly sources: readonly string[];
-  constructor(key: string, sources: readonly string[]);
-}
-//#endregion
 //#region src/core/contributor-pipeline.d.ts
 /**
  * Where a contributor was registered, ordered by precedence
@@ -1084,83 +835,6 @@ interface RunContributorsOptions {
  */
 declare function runContributors(options: RunContributorsOptions): Promise<void>;
 //#endregion
-//#region src/core/mount-sort.d.ts
-/**
- * Topological sort for plugins and adapters with `dependsOn` declarations.
- *
- * Mirrors the algorithm used by the Context Contributor pipeline
- * (`contributor-pipeline.ts:topoSort`) but operates on a name-keyed
- * `MountSortItem` shape rather than a `ContributorRegistration`. Kept
- * standalone instead of factored generic so that:
- *
- * 1. The contributor pipeline doesn't need refactoring (risk reduction).
- * 2. The error classes can carry plugin/adapter-specific diagnostic
- *    fields (`kind`, `dependent`) without bending the contributor types.
- */
-/**
- * A plugin or adapter that participates in dependency-ordered mounting.
- * Both `KickPlugin` and `AppAdapter` satisfy this shape via their `name`
- * and `dependsOn` fields.
- */
-interface MountSortItem {
-  /** Unique mount name within the plugin/adapter set being sorted. */
-  name: string;
-  /**
-   * Other plugin/adapter names that must mount before this one. Cycles
-   * and missing names fail at boot — same fail-fast contract as the
-   * Context Contributor pipeline (architecture.md §20.4).
-   */
-  dependsOn?: readonly string[];
-}
-/** What kind of mount set the sort is operating on — surfaces in error messages. */
-type MountKind = 'plugin' | 'adapter';
-/**
- * Two items in the same mount set declared the same `name`. Plugin/adapter
- * names must be unique so `dependsOn` references resolve unambiguously.
- */
-declare class DuplicateMountNameError extends Error {
-  readonly kind: MountKind;
-  readonly mountName: string;
-  constructor(kind: MountKind, mountName: string);
-}
-/**
- * A `dependsOn` entry references a plugin/adapter that isn't in the
- * current set. The dependency might not be installed, might be misspelled,
- * or might live in a different mount set (plugin referencing an adapter,
- * or vice versa — they sort independently).
- */
-declare class MissingMountDepError extends Error {
-  readonly kind: MountKind;
-  readonly missing: string;
-  readonly dependent: string;
-  constructor(kind: MountKind, missing: string, dependent: string);
-}
-/**
- * The `dependsOn` declarations form a cycle. Boot fails so the cycle
- * can't poison live traffic. The `cycle` field reports one path through
- * the offending nodes for diagnostics — formatted `A → B → C → A`.
- */
-declare class MountCycleError extends Error {
-  readonly kind: MountKind;
-  readonly cycle: readonly string[];
-  constructor(kind: MountKind, cycle: readonly string[]);
-}
-/**
- * Topologically sort `items` so every item with `dependsOn: ['X']` mounts
- * after `X`. Items without `dependsOn` keep their input order via Kahn's
- * algorithm with a FIFO queue seeded in input order — preserves the
- * historical "plugins/adapters mount in declaration order" behaviour for
- * any set that doesn't use `dependsOn`.
- *
- * @param items - mountable items, e.g. plugins or adapters
- * @param kind - 'plugin' | 'adapter', used in error messages
- * @returns a new array in valid mount order
- * @throws {DuplicateMountNameError} two items share a name
- * @throws {MissingMountDepError} a `dependsOn` references an unknown name
- * @throws {MountCycleError} the dep graph contains a cycle
- */
-declare function mountSort<T extends MountSortItem>(items: readonly T[], kind: MountKind): T[];
-//#endregion
 //#region src/core/define-adapter.d.ts
 /**
  * Options passed to {@link defineAdapter}. Mirrors {@link DefinePluginOptions}
@@ -1238,49 +912,6 @@ interface AdapterFactory<TConfig, TExtra = unknown> {
  */
 declare function defineAdapter<TConfig = Record<string, unknown>, TExtra = unknown>(options: DefineAdapterOptions<TConfig, TExtra>): AdapterFactory<TConfig, TExtra>;
 //#endregion
-//#region src/core/asset-keys.d.ts
-type AssetKeyStrategy = 'auto' | 'strip' | 'with-extension';
-interface AssetKeyPair {
-  /** Source-relative path the file was discovered at. */
-  rel: string;
-  /** Final logical key for the manifest, including the namespace prefix. */
-  key: string;
-}
-interface GroupAssetKeysOptions {
-  /**
-   * Strategy applied to this namespace. Default `'auto'`.
-   *
-   * Adopters override per-namespace via `assetMap.<ns>.keys` in
-   * kick.config.ts when they want uniform behaviour (e.g. always
-   * include the extension regardless of collisions).
-   */
-  strategy?: AssetKeyStrategy;
-}
-interface GroupAssetKeysResult {
-  pairs: AssetKeyPair[];
-  /**
-   * Number of collision groups resolved by keeping extensions.
-   * Surfaces as an informational log ("auto-resolved N collisions")
-   * so adopters know whether they're relying on auto-mode or not.
-   * Always 0 for `'strip'` (overwrites) and `'with-extension'`
-   * (extensions always preserved, no collision possible).
-   */
-  collisionGroupsResolved: number;
-}
-/**
- * Compute final manifest keys for a namespace's discovered paths,
- * given the chosen strategy. Pure function — no fs / config / globals
- * involved.
- *
- * @param namespace assetMap key — e.g. `'mails'`, `'pages'`.
- * @param paths source-relative file paths (POSIX separators) discovered
- *              under the namespace's `src` directory.
- * @param opts grouping options.
- */
-declare function groupAssetKeys(namespace: string, paths: readonly string[], opts?: GroupAssetKeysOptions): GroupAssetKeysResult;
-/** Strip the final extension from a path. `'mails/welcome.ejs'` → `'mails/welcome'`. */
-declare function stripExt(path: string): string;
-//#endregion
 //#region src/http/context.d.ts
 /**
  * Input shape for the typed problem-detail convenience methods on
@@ -1355,7 +986,7 @@ interface ProblemSender {
  * Type-only. No runtime cost. `DeepReadonly<any>` is `any` (TS
  * distributes conditional types over `any`).
  */
-type DeepReadonly<T> = T extends ((...args: never[]) => unknown) ? T : T extends Date | RegExp ? T : T extends Map<infer K, infer V> ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>> : T extends Set<infer V> ? ReadonlySet<DeepReadonly<V>> : T extends readonly (infer U)[] ? number extends T['length'] ? ReadonlyArray<DeepReadonly<U>> : { readonly [K in keyof T]: DeepReadonly<T[K]> } : T extends object ? { readonly [K in keyof T]: DeepReadonly<T[K]> } : T;
+type DeepReadonly<T> = T extends ((...args: never[]) => unknown) ? T : T extends Date | RegExp ? T : T extends Map<infer K, infer V> ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>> : T extends Set<infer V> ? ReadonlySet<DeepReadonly<V>> : T extends readonly (infer U)[] ? number extends T['length'] ? ReadonlyArray<DeepReadonly<U>> : { readonly [K in keyof T]: DeepReadonly<T[K]>; } : T extends object ? { readonly [K in keyof T]: DeepReadonly<T[K]>; } : T;
 /**
  * The shape of a single route entry in `KickRoutes`. Generated by
  * `kick typegen` and consumed via the `Ctx<T>` helper. Each field is
@@ -1690,6 +1321,19 @@ TKeys extends string = string> implements ExecutionContext<TKeys> {
    */
   get problem(): ProblemSender;
   private sendProblem;
+  /**
+   * Send an HTML response.
+   *
+   * Passes the full MIME type rather than the `'html'` shorthand. The
+   * shorthand is an Express affordance — `res.type()` runs it through a MIME
+   * lookup — but the Fastify and h3 drivers forward the string to their own
+   * `type()` / `setHeader()` verbatim, so `'html'` reached the wire as a
+   * malformed `Content-Type: html` on those engines. Fastify 5.10 started
+   * normalising that invalid value to `text/plain`, which is what surfaced it.
+   *
+   * Express produces `text/html; charset=utf-8` for `.type('html')`, so
+   * spelling it out here is byte-identical there and correct everywhere else.
+   */
   html(content: string, status?: number): RuntimeResponse;
   download(buffer: Buffer, filename: string, contentType?: string): RuntimeResponse;
   /**
@@ -1824,7 +1468,7 @@ type Ctx<TRoute extends RouteShape = RouteShape> = RequestContext<TRoute extends
  */
 declare global {
   namespace KickRoutes {}
-} //# sourceMappingURL=context.d.ts.map
+}
 //#endregion
 //#region src/http/runtime.d.ts
 /** HTTP verbs the router emits. Mirrors the decorator surface (@Get/@Post/...). */
@@ -2279,5 +1923,5 @@ interface AppAdapter {
 /** Constructor type for AppAdapter classes */
 type AppAdapterClass = new () => AppAdapter;
 //#endregion
-export { MissingContextValueError as $, GroupAssetKeysOptions as A, defineModule as At, MountCycleError as B, KickJsPluginName as Bt, Ctx as C, Disposable as Ct, SseHandler as D, defineModules as Dt, RouteShape as E, ModuleList as Et, AdapterFactory as F, definePlugin as Ft, runContributors as G, IntrospectionSnapshot as Gt, MountSortItem as H, defineAugmentation as Ht, DefineAdapterOptions as I, KickPlugin as It, ContributorSource as J, BuildPipelineOptions as K, defineAdapter as L, ModuleRegistry as Lt, groupAssetKeys as M, DefinePluginOptions as Mt, stripExt as N, PluginAsyncOptions as Nt, AssetKeyPair as O, DefineModuleOptions as Ot, AdapterAsyncOptions as P, PluginFactory as Pt, DuplicateContributorError as Q, DuplicateMountNameError as R, MutableModuleRegistry as Rt, UseConnectOptions as S, formatKickError as St, RequestContext as T, registerDisposable as Tt, mountSort as U, IntrospectFn as Ut, MountKind as V, KickJsPluginRegistry as Vt, RunContributorsOptions as W, IntrospectionKind as Wt, buildPipeline as X, SourcedRegistration as Y, ContributorCycleError as Z, RouteTable as _, setInMetaRecord as _t, MiddlewarePath as a, CircuitOpenError as at, RuntimeResponse as b, KickError as bt, AdapterHttp as c, getMetaMap as ct, ExpressRuntimeTypes as d, getMethodMetaOrUndefined as dt, MissingContributorError as et, HttpRuntime as f, hasClassMeta as ft, RouteMethod as g, setInMetaMap as gt, RouteMeta as h, setClassMeta as ht, AppAdapterClass as i, CircuitBreakerStats as it, GroupAssetKeysResult as j, BuildContext as jt, AssetKeyStrategy as k, ModuleFactory as kt, ConnectMiddleware as l, getMetaRecord as lt, RouteEntry as m, pushMethodMeta as mt, AdapterMiddleware as n, CircuitBreakerOptions as nt, MiddlewarePhase as o, getClassMeta as ot, KickRuntimeRegister as p, pushClassMeta as pt, ContributorPipeline as q, AppAdapter as r, CircuitBreakerState as rt, ActiveRuntime as s, getClassMetaOrUndefined as st, AdapterContext as t, CircuitBreaker as tt, CtxHandler as u, getMethodMeta as ut, RuntimeAppOptions as v, setMethodMeta as vt, DeepReadonly as w, disposeAll as wt, RuntimeTypeMap as x, KickErrorInit as xt, RuntimeCapabilities as y, FormatKickErrorOptions as yt, MissingMountDepError as z, AugmentationMeta as zt };
-//# sourceMappingURL=adapter-CEt1MEdF.d.mts.map
+export { defineModules as $, DefineAdapterOptions as A, getClassMetaOrUndefined as B, Ctx as C, SseHandler as D, RouteShape as E, ContributorPipeline as F, hasClassMeta as G, getMetaRecord as H, ContributorSource as I, setClassMeta as J, pushClassMeta as K, SourcedRegistration as L, RunContributorsOptions as M, runContributors as N, AdapterAsyncOptions as O, BuildPipelineOptions as P, ModuleList as Q, buildPipeline as R, UseConnectOptions as S, RequestContext as T, getMethodMeta as U, getMetaMap as V, getMethodMetaOrUndefined as W, setInMetaRecord as X, setInMetaMap as Y, setMethodMeta as Z, RouteTable as _, IntrospectionSnapshot as _t, MiddlewarePath as a, PluginAsyncOptions as at, RuntimeResponse as b, AdapterHttp as c, KickPlugin as ct, ExpressRuntimeTypes as d, AugmentationMeta as dt, DefineModuleOptions as et, HttpRuntime as f, KickJsPluginName as ft, RouteMethod as g, IntrospectionKind as gt, RouteMeta as h, IntrospectFn as ht, AppAdapterClass as i, DefinePluginOptions as it, defineAdapter as j, AdapterFactory as k, ConnectMiddleware as l, ModuleRegistry as lt, RouteEntry as m, defineAugmentation as mt, AdapterMiddleware as n, defineModule as nt, MiddlewarePhase as o, PluginFactory as ot, KickRuntimeRegister as p, KickJsPluginRegistry as pt, pushMethodMeta as q, AppAdapter as r, BuildContext as rt, ActiveRuntime as s, definePlugin as st, AdapterContext as t, ModuleFactory as tt, CtxHandler as u, MutableModuleRegistry as ut, RuntimeAppOptions as v, DeepReadonly as w, RuntimeTypeMap as x, RuntimeCapabilities as y, getClassMeta as z };
+//# sourceMappingURL=adapter-CbMq-NBf.d.mts.map

package/dist/adapter-CbMq-NBf.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-CbMq-NBf.d.mts","names":[],"sources":["../src/core/introspect.ts","../src/core/augmentation.ts","../src/core/module-registry.ts","../src/core/plugin.ts","../src/core/define-plugin.ts","../src/core/define-module.ts","../src/core/define-modules.ts","../src/core/metadata.ts","../src/core/contributor-pipeline.ts","../src/core/contributor-runner.ts","../src/core/define-adapter.ts","../src/http/context.ts","../src/http/runtime.ts","../src/core/adapter.ts"],"mappings":"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"}

package/dist/{app-module-BSpHKlhE.d.mts → app-module-DtoySG6l.d.mts}

@@ -1,6 +1,7 @@
 
-import { i as Constructor, o as MaybePromise } from "./interfaces-CayXPOAf.mjs";
-import { s as InjectionToken, t as Container } from "./container-iED1swkd.mjs";
+import { i as Constructor, o as MaybePromise } from "./interfaces-BTTBdkvG.mjs";
+import { s as InjectionToken, t as Container } from "./container-BW_MlgLj.mjs";
+import "reflect-metadata";
 //#region src/core/execution-context.d.ts
 /**
  * Transport-agnostic execution context primitives.
@@ -157,11 +158,11 @@ type DepValue = InjectionToken<unknown> | Constructor<unknown>;
  * `{ db: Db, cache: CacheService }` — the runner resolves each value
  * against the DI container and hands the result to `resolve()`.
  */
-type ResolvedDeps<D extends Record<string, DepValue>> = { [K in keyof D]: D[K] extends InjectionToken<infer T> ? T : D[K] extends Constructor<infer T> ? T : never };
+type ResolvedDeps<D extends Record<string, DepValue>> = { [K in keyof D]: D[K] extends InjectionToken<infer T> ? T : D[K] extends Constructor<infer T> ? T : never; };
 /**
  * Keys of `T` that are declared required (i.e. not `?`-optional).
  */
-type RequiredParamKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? never : K }[keyof T];
+type RequiredParamKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? never : K; }[keyof T];
 /**
  * Params a call site MUST supply: the required keys of `P` that
  * `paramDefaults` (type `PD`) doesn't already provide.
@@ -643,4 +644,4 @@ type AppModuleClass = new () => AppModule;
 type AppModuleEntry = AppModuleClass | AppModule;
 //#endregion
 export { ExecutionContext as _, AnyContributorRegistration as a, ContextDecoratorTarget as c, ContributorRegistrations as d, DepValue as f, ContextMeta as g, ContextKeys as h, ModuleRoutes as i, ContextMetaKey as l, defineContextDecorator as m, AppModuleClass as n, ContextDecorator as o, ResolvedDeps as p, AppModuleEntry as r, ContextDecoratorSpec as s, AppModule as t, ContributorRegistration as u, MetaValue as v };
-//# sourceMappingURL=app-module-BSpHKlhE.d.mts.map
+//# sourceMappingURL=app-module-DtoySG6l.d.mts.map

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

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

package/dist/application-Cl0JlmNY.mjs

@@ -0,0 +1,12 @@
+/**
+ * @forinda/kickjs v6.5.1
+ *
+ * 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{n as tokenName,s as moduleRouteMissingControllerError,t as Container}from"./container-C7kmdVwh.mjs";import{Logger,createLogger}from"./core/logger.mjs";import{t as getClassMeta}from"./metadata-DUBbuHqY.mjs";import{t as MutableModuleRegistry}from"./module-registry-aIt66if2.mjs";import{i as runDisposables,n as drainDisposables,r as registerDisposable,t as disposeAll}from"./disposables-D46xX96x.mjs";import{joinPaths,normalizePath}from"./core/path.mjs";import"./core-CLmwVWlw.mjs";import{n as assertRouteUnique,r as buildRouteTable,t as _setExternalContributorSources}from"./router-builder-BbgVXuy3.mjs";import{requestId}from"./http/middleware/request-id.mjs";import{errorHandler,notFoundHandler}from"./http/middleware/error-handler.mjs";import{i as requestStore,t as RequestContext}from"./context-DQaUwwQM.mjs";import{o as isRequestScopeMiddleware,s as requestScopeMiddleware,t as applyHandlerResult}from"./reply-C1ljl6xS.mjs";import{validate}from"./http/middleware/validate.mjs";import{buildUploadMiddleware}from"./http/middleware/upload.mjs";import http from"node:http";import express,{Router}from"express";var DuplicateMountNameError=class extends Error{kind;mountName;constructor(kind,mountName){super(`Duplicate ${kind} name '${mountName}' — every ${kind} must declare a unique name`),this.name=`DuplicateMountNameError`,this.kind=kind,this.mountName=mountName}},MissingMountDepError=class extends Error{kind;missing;dependent;constructor(kind,missing,dependent){super(`Missing ${kind} dependency '${missing}' required by '${dependent}' — is the ${kind} installed and named correctly?`),this.name=`MissingMountDepError`,this.kind=kind,this.missing=missing,this.dependent=dependent}},MountCycleError=class extends Error{kind;cycle;constructor(kind,cycle){super(`Cycle in ${kind} dependsOn declarations: ${cycle.join(` → `)}`),this.name=`MountCycleError`,this.kind=kind,this.cycle=Object.freeze([...cycle])}};function mountSort(items,kind){let byName=new Map;for(let item of items){if(byName.has(item.name))throw new DuplicateMountNameError(kind,item.name);byName.set(item.name,item)}let indegree=new Map,dependents=new Map;for(let item of items)indegree.set(item.name,item.dependsOn?.length??0);for(let item of items)for(let dep of item.dependsOn??[]){if(!byName.has(dep))throw new MissingMountDepError(kind,dep,item.name);let list=dependents.get(dep)??[];list.push(item),dependents.set(dep,list)}let queue=[];for(let item of items)indegree.get(item.name)===0&&queue.push(item);let sorted=[];for(;queue.length>0;){let node=queue.shift();sorted.push(node);for(let dependent of dependents.get(node.name)??[]){let next=(indegree.get(dependent.name)??0)-1;indegree.set(dependent.name,next),next===0&&queue.push(dependent)}}if(sorted.length!==items.length)throw new MountCycleError(kind,reconstructCycle(items.filter(it=>(indegree.get(it.name)??0)>0),byName));return sorted}function reconstructCycle(residual,byName){let residualNames=new Set(residual.map(r=>r.name)),start=residual[0].name,path=[start],seen=new Set([start]),cursor=start;for(;;){let nextDep=byName.get(cursor).dependsOn?.find(d=>residualNames.has(d));if(nextDep===void 0)break;if(seen.has(nextDep)){let cycleStart=path.indexOf(nextDep);return[...path.slice(cycleStart),nextDep]}path.push(nextDep),seen.add(nextDep),cursor=nextDep}return path}function materializeRouter(entries){let router=Router();for(let entry of entries){let method=entry.method.toLowerCase(),handlers=[];entry.meta.validation&&handlers.push(validate(entry.meta.validation)),entry.meta.upload&&handlers.push(buildUploadMiddleware(entry.meta.upload));for(let mw of entry.middlewares)handlers.push((req,res,next)=>{let ctx=new RequestContext(req,res,next);Promise.resolve(mw(ctx,next)).catch(next)});if(entry.contributorRunner){let run=entry.contributorRunner;handlers.push(async(req,res,next)=>{let ctx=new RequestContext(req,res,next);try{await run(ctx),next()}catch(err){next(err)}})}handlers.push(async(req,res,next)=>{let ctx=new RequestContext(req,res,next);try{let result=await entry.handler(ctx);res.headersSent||applyHandlerResult(ctx,result)}catch(err){next(err)}}),router[method](entry.path,...handlers)}return router}function buildRoutes(controllerClass,options={}){return materializeRouter(buildRouteTable(controllerClass,options))}function expressRuntime(){return{name:`express`,createApp(options={}){let app=express();return app.disable(`x-powered-by`),app.set(`trust proxy`,options.trustProxy??!1),app},nodeHandler(app){return(req,res,next)=>{next?app(req,res,next):app(req,res)}},mountRoutes(app,table){for(let{mountPath,routes}of table)app.use(mountPath,materializeRouter(routes))},useConnect(app,mw,opts={}){opts.path===void 0?app.use(mw):app.use(opts.path,mw)},serveStatic(app,prefix,dir){app.use(prefix,express.static(dir))},setNotFound(app,mw){app.use(mw)},setErrorHandler(app,mw){app.use(mw)},capabilities:{render:!0,uploads:!0,connectMiddleware:!0,nativeBodyParsing:!1}}}const log=createLogger(`Application`);var Application=class{options;app;runtime;container;httpServer=null;adapters;plugins;_moduleContributors=[];_inFlightRequests=0;_draining=!1;_shutdownInitiated=!1;_drainResolvers=[];constructor(options){this.options=options,this.runtime=options.runtime??expressRuntime(),this.app=this.runtime.createApp({trustProxy:options.trustProxy}),this.container=Container.getInstance(),this.plugins=mountSort(options.plugins??[],`plugin`);let allAdapters=[...this.plugins.flatMap(p=>p.adapters?.()??[]),...options.adapters??[]],anonAdapterCount=0,namedAdapters=allAdapters.map(adapter=>{if(!adapter.name){let ctorName=adapter.constructor?.name,fallback=ctorName&&ctorName!==`Object`?ctorName:`AnonymousAdapter#${anonAdapterCount++}`;return Object.assign(adapter,{name:fallback})}return adapter});this.adapters=mountSort(namedAdapters,`adapter`),Container._requestStoreProvider=()=>requestStore.getStore()??null}get isDraining(){return this._draining}get inFlightRequests(){return this._inFlightRequests}getContainer(){return this.container}handle(req,res,next){let handler=this.runtime.nodeHandler(this.app);next?handler(req,res,next):handler(req,res)}adapterCtx(server){let env=process.env.NODE_ENV??`development`;return{http:this.adapterHttp(),app:this.app,container:this.container,server,env,isProduction:env===`production`}}adapterHttp(){return{route:(method,path,handler)=>{let entry={method,path,middlewares:[],contributorRunner:null,handler,meta:{}};this.runtime.mountRoutes(this.app,[{mountPath:`/`,routes:[entry]}])},mount:(prefix,routes)=>{this.runtime.mountRoutes(this.app,[{mountPath:prefix,routes}])},serveStatic:(prefix,dir)=>{this.runtime.serveStatic(this.app,prefix,dir)},use:(mw,opts)=>{this.runtime.useConnect(this.app,mw,opts)}}}async callHook(hook,ctx){if(hook)try{let result=hook(ctx);result&&typeof result.then==`function`&&await result}catch(err){log.error(err,`Adapter hook failed`)}}async setup(){log.debug(`Bootstrapping application...`),this._moduleContributors=[];let adapterMw=this.collectAdapterMiddleware();this.app.__kickApp=this;let ctx=this.adapterCtx();for(let adapter of this.adapters)await this.callHook(adapter.beforeMount?.bind(adapter),ctx);this.runtime.useConnect(this.app,this.requestTrackingMiddleware()),this.mountHealthEndpoints(),this.shouldAutoMountRequestScope()&&this.runtime.useConnect(this.app,requestScopeMiddleware()),this.mountMiddlewareList(adapterMw.beforeGlobal);for(let plugin of this.plugins)plugin.register?.(this.container);for(let plugin of this.plugins)try{let mw=plugin.middleware?.()??[];for(let handler of mw)this.runtime.useConnect(this.app,handler)}catch(err){log.error(err,`Plugin middleware failed: ${plugin.name??`unknown`}`)}if(this.options.security?.helmet!==!1)try{let{helmet:helmetFn}=await import(`./http/middleware/helmet.mjs`);this.runtime.useConnect(this.app,helmetFn())}catch{}let userMiddlewares=this.options.middlewares??this.options.middleware;if(userMiddlewares)for(let entry of userMiddlewares)this.mountMiddlewareEntry(entry);else this.runtime.useConnect(this.app,requestId()),this.runtime.capabilities.nativeBodyParsing||this.runtime.useConnect(this.app,express.json({limit:this.options.jsonLimit??`1mb`}));this.mountMiddlewareList(adapterMw.afterGlobal);let moduleRegistry=new MutableModuleRegistry;for(let plugin of this.plugins){for(let m of plugin.modules?.()??[])moduleRegistry.mount(m);plugin.setup?.(moduleRegistry)}for(let m of this.options.modules)moduleRegistry.mount(m);this.options.setup?.(moduleRegistry);let modules=moduleRegistry.entries.map(entry=>{let mod=typeof entry==`function`?new entry:entry;return mod.register?.(this.container),mod});this.container.bootstrap(),this.container.has(Logger)||this.container.registerInstance(Logger,new Logger),this.mountMiddlewareList(adapterMw.beforeRoutes);let apiPrefix=this.options.apiPrefix??`/api`,defaultVersion=this.options.defaultVersion??1,shouldLogRoutes=this.options.logRouteTable??this.options.logRoutesTable??!1,mountedRoutes=[],adapterSources=[];for(let adapter of this.adapters){let adapterContribs=adapter.contributors?.()??[],adapterLabel=adapter.name??adapter.constructor.name??`adapter`;for(let registration of adapterContribs)adapterSources.push({source:`adapter`,registration,label:adapterLabel})}for(let plugin of this.plugins){let pluginContribs=plugin.contributors?.()??[],pluginLabel=plugin.name??plugin.constructor?.name??`plugin`;for(let registration of pluginContribs)adapterSources.push({source:`adapter`,registration,label:pluginLabel})}let globalSources=(this.options.contributors??[]).map(registration=>({source:`global`,registration,label:`bootstrap`}));this._moduleContributors=[];let seenRoutes=new Map;for(let mod of modules){let declaredName=mod.name,ctorName=mod.constructor?.name,moduleLabel=typeof declaredName==`string`&&declaredName.length>0?declaredName:ctorName&&ctorName!==`Object`?ctorName:`module`,moduleSources=(mod.contributors?.()??[]).map(registration=>({source:`module`,registration,label:moduleLabel}));for(let src of moduleSources)this._moduleContributors.push({registration:src.registration,label:moduleLabel});_setExternalContributorSources([...moduleSources,...adapterSources,...globalSources]);try{let result=mod.routes();if(!result)continue;let routeSets=Array.isArray(result)?result:[result];for(let route of routeSets){let mountPath=`${apiPrefix}/v${route.version??defaultVersion}${normalizePath(route.path)}`;if(route.router)this.runtime.useConnect(this.app,route.router,{path:mountPath});else if(route.controller){let routeTable=buildRouteTable(route.controller),ctrl=route.controller.name??`controller`;for(let entry of routeTable){let owner=`${ctrl}.${String(entry.meta.handlerName??`?`)}`;assertRouteUnique(seenRoutes,entry.method,joinPaths(mountPath,entry.path),owner)}this.runtime.mountRoutes(this.app,[{mountPath,routes:routeTable}])}else throw moduleRouteMissingControllerError(mountPath);if(route.controller){for(let adapter of this.adapters)try{adapter.onRouteMount?.(route.controller,mountPath)}catch(err){log.error(err,`adapter.onRouteMount() failed for ${mountPath}`)}shouldLogRoutes&&mountedRoutes.push({controller:route.controller,mountPath})}}}finally{_setExternalContributorSources([])}}if(shouldLogRoutes&&mountedRoutes.length>0){let methodOrder=[`GET`,`POST`,`PUT`,`PATCH`,`DELETE`,`HEAD`,`OPTIONS`],methodRank=m=>{let i=methodOrder.indexOf(m);return i===-1?99:i},totalRoutes=0;log.info(`Routes:`);for(let{controller,mountPath}of mountedRoutes){let defs=getClassMeta(METADATA.ROUTES,controller,[]);if(defs.length===0)continue;let counts={};for(let def of defs){let m=def.method.toUpperCase();counts[m]=(counts[m]||0)+1}totalRoutes+=defs.length;let methods=Object.entries(counts).toSorted(([a],[b])=>methodRank(a)-methodRank(b)).map(([m,n])=>`${n} ${m}`).join(`, `),name=controller.name||`Controller`;log.info(`  ${name.padEnd(30)} ${mountPath.padEnd(25)} ${defs.length} routes (${methods})`)}log.info(`  Total: ${totalRoutes} routes`)}this.mountMiddlewareList(adapterMw.afterRoutes);for(let adapter of this.adapters)await this.callHook(adapter.beforeStart?.bind(adapter),ctx);this.runtime.setNotFound(this.app,this.options.onNotFound??notFoundHandler()),this.runtime.setErrorHandler(this.app,this.options.onError??errorHandler())}async registerOnly(){await this.setup()}async start(){await this.setup();let g=globalThis;if(g.__kickjs_httpServer){this.httpServer=g.__kickjs_httpServer,log.debug(`Attached to Vite dev server`),g.__kickjs_app_shutdown=()=>this.shutdown();for(let adapter of this.adapters){let ctx=this.adapterCtx(this.httpServer);await this.callHook(adapter.afterStart?.bind(adapter),ctx)}for(let plugin of this.plugins)await plugin.onReady?.(this.container);return}let port=this.options.port??parseInt(process.env.PORT||`3000`,10);this.httpServer=http.createServer(this.runtime.nodeHandler(this.app)),this.httpServer.on(`error`,err=>{throw err.code===`EADDRINUSE`&&(log.error(`Port ${port} is already in use. Kill the existing process or use a different port:\n  PORT=${port+1} kick dev\n  lsof -i :${port}   # find what's using it\n  kill <PID>          # stop it`),process.exit(1)),err}),await new Promise((resolve,reject)=>{this.httpServer.listen(port,async()=>{try{log.info(`Server running on http://localhost:${port}`);for(let adapter of this.adapters){let afterCtx=this.adapterCtx(this.httpServer);await this.callHook(adapter.afterStart?.bind(adapter),afterCtx)}for(let plugin of this.plugins)await plugin.onReady?.(this.container);resolve()}catch(err){reject(err)}})})}async rebuild(){let prevApp=this.app,prevContainer=this.container,staleDisposables=drainDisposables();try{Container.reset(),this.container=Container.getInstance(),this.app=this.runtime.createApp({trustProxy:this.options.trustProxy}),await this.setup()}catch(err){log.error(err,`HMR rebuild failed, keeping previous app`),await runDisposables(drainDisposables());for(let d of staleDisposables)registerDisposable(d);this.app=prevApp,this.container=prevContainer;return}await runDisposables(staleDisposables),this.httpServer&&(this.httpServer.removeAllListeners(`request`),this.httpServer.on(`request`,this.runtime.nodeHandler(this.app)),log.debug(`HMR: app rebuilt and swapped`))}async shutdown(){if(this._shutdownInitiated){log.debug(`Shutdown already in progress, skipping duplicate call`);return}this._shutdownInitiated=!0,this._draining=!0,log.debug(`Shutting down — draining in-flight requests...`);let timeoutMs=this.options.shutdownTimeout??3e4,timer,forceExitPromise=timeoutMs>0?new Promise(resolve=>{timer=setTimeout(()=>resolve(`timeout`),timeoutMs),timer.unref()}):new Promise(()=>{});try{if(this.httpServer&&this.httpServer.close(()=>{}),this._inFlightRequests>0){log.debug(`Waiting for ${this._inFlightRequests} in-flight request(s) to complete...`);let drainPromise=new Promise(resolve=>{this._drainResolvers.push(()=>resolve(`drained`))});await Promise.race([drainPromise,forceExitPromise])===`timeout`?log.warn(`Shutdown timeout (${timeoutMs}ms) reached with ${this._inFlightRequests} request(s) still in-flight, forcing shutdown`):log.debug(`All in-flight requests completed`)}let results=await Promise.allSettled([...this.plugins.map(plugin=>Promise.resolve(plugin.shutdown?.())),...this.adapters.map(adapter=>Promise.resolve(adapter.shutdown?.()))]);for(let result of results)result.status===`rejected`&&log.error({err:result.reason},`Adapter shutdown failed`);await disposeAll(),this.container.flushChanges()}finally{timer&&clearTimeout(timer)}}getRuntimeApp(){return this.app}getActiveRuntime(){return{name:this.runtime.name,capabilities:this.runtime.capabilities}}getExpressApp(){return this.app}getAdapters(){return this.adapters}getPlugins(){return this.plugins}getContributors(){let out=[],ingest=(list,source,label)=>{if(list)for(let reg of list){let r=reg;if(r.key===void 0||r.key===null)continue;let key=typeof r.key==`string`?r.key:tokenName(r.key);out.push({key,source,label,dependsOn:Array.isArray(r.dependsOn)?r.dependsOn:[]})}};for(let adapter of this.adapters)ingest(adapter.contributors?.(),`adapter`,adapter.name??`adapter`);for(let plugin of this.plugins)ingest(plugin.contributors?.(),`plugin`,plugin.name??`plugin`);for(let{registration,label}of this._moduleContributors)ingest([registration],`module`,label);return ingest(this.options.contributors,`global`,`bootstrap`),out}getHttpServer(){return this.httpServer}shouldAutoMountRequestScope(){if(this.options.contextStore===`manual`)return!1;let userEntries=this.options.middlewares??this.options.middleware??[];for(let entry of userEntries)if(isRequestScopeMiddleware(typeof entry==`function`?entry:entry.handler))return!1;return!0}collectAdapterMiddleware(){let result={beforeGlobal:[],afterGlobal:[],beforeRoutes:[],afterRoutes:[]};for(let adapter of this.adapters){let entries=adapter.middleware?.()??[];for(let entry of entries)result[entry.phase??`afterGlobal`].push(entry)}return result}mountMiddlewareList(entries){for(let entry of entries){if(entry.path===void 0){this.runtime.useConnect(this.app,entry.handler);continue}this.runtime.useConnect(this.app,entry.handler,{path:entry.path})}}mountMiddlewareEntry(entry){typeof entry==`function`?this.runtime.useConnect(this.app,entry):this.runtime.useConnect(this.app,entry.handler,{path:entry.path})}requestTrackingMiddleware(){return(_req,res,next)=>{this._inFlightRequests++;let onFinish=()=>{if(res.removeListener(`finish`,onFinish),res.removeListener(`close`,onFinish),this._inFlightRequests--,this._draining&&this._inFlightRequests===0){for(let resolve of this._drainResolvers)resolve();this._drainResolvers=[]}};res.on(`finish`,onFinish),res.on(`close`,onFinish),next()}}mountHealthEndpoints(){let http=this.adapterHttp();http.route(`GET`,`/health/live`,ctx=>{this._draining?ctx.res.status(503).json({status:`draining`,uptime:process.uptime()}):ctx.json({status:`ok`,uptime:process.uptime()})}),http.route(`GET`,`/health/ready`,async ctx=>{if(this._draining){ctx.res.status(503).json({status:`draining`,checks:[]});return}let adaptersWithHealth=this.adapters.filter(a=>a.onHealthCheck),results=(await Promise.allSettled(adaptersWithHealth.map(a=>a.onHealthCheck()))).map((c,i)=>c.status===`fulfilled`?c.value:{name:adaptersWithHealth[i].name??`unknown`,status:`down`}),healthy=results.every(r=>r.status===`up`);ctx.res.status(healthy?200:503).json({status:healthy?`ready`:`degraded`,checks:results})})}};export{DuplicateMountNameError as a,mountSort as c,materializeRouter as i,buildRoutes as n,MissingMountDepError as o,expressRuntime as r,MountCycleError as s,Application as t};
+//# sourceMappingURL=application-Cl0JlmNY.mjs.map