@forinda/kickjs 8.2.0 → 8.3.0

package/dist/application-NjKJPm9r.d.mts

@@ -1,495 +0,0 @@
-
-import { t as Container } from "./container-Dpvd66Yt.mjs";
-import { m as ContributorRegistrations, r as AppModuleEntry } from "./app-module-DoM8RNZ9.mjs";
-import { b as RuntimeCapabilities, f as HttpRuntime, lt as KickPlugin, r as AppAdapter, s as ActiveRuntime, ut as ModuleRegistry, x as RuntimeResponse } from "./adapter-BxXGuLnW.mjs";
-import http from "node:http";
-import { Express, RequestHandler } from "express";
-//#region src/http/application.d.ts
-/**
- * A middleware entry in the declarative pipeline.
- * Can be a bare handler or an object with path scoping.
- */
-type MiddlewareEntry = RequestHandler | {
-  path: string;
-  handler: RequestHandler;
-};
-/** Options for {@link Application.shutdown}. */
-interface ShutdownOptions {
-  /**
-   * Close the HTTP server and drain in-flight requests. Default `true`.
-   *
-   * Set `false` for a dev HMR rebuild, where the server is shared across
-   * reloads — adapters, plugins, and disposables are still torn down, which is
-   * the part a reload needs.
-   */
-  closeServer?: boolean;
-}
-interface ApplicationOptions {
-  /**
-   * Feature modules to load. Accepts both class form
-   * (`SomeModule extends AppModule`, instantiated via `new`) and
-   * instance form (output of {@link defineModule}'s factory call,
-   * e.g. `TasksModule({ scope: 'admin' })`) — the loader discriminates
-   * and either `new`-s the class or uses the instance directly.
-   *
-   * Static path — for conditional / dynamic registration, use the
-   * {@link ApplicationOptions.setup} callback instead.
-   */
-  modules: AppModuleEntry[];
-  /**
-   * Imperative module registration callback. Receives a
-   * {@link ModuleRegistry} you call `.mount(module)` on to register
-   * modules conditionally — based on env flags, runtime config, a
-   * tenant list, etc. Runs after every plugin's `setup()` hook and
-   * after the static `modules: [...]` array is collected.
-   *
-   * @example
-   * ```ts
-   * bootstrap({
-   *   modules: [HelloModule()],
-   *   setup(registry) {
-   *     if (env.ENABLE_ADMIN) registry.mount(AdminModule())
-   *   },
-   * })
-   * ```
-   */
-  setup?(registry: ModuleRegistry): void;
-  /** Adapters that hook into the lifecycle (DB, Redis, Swagger, etc.) */
-  adapters?: AppAdapter[];
-  /** Server port (falls back to PORT env var, then 3000) */
-  port?: number;
-  /** Global API prefix (default: '/api'). Pass `''` to mount at the root. */
-  apiPrefix?: string;
-  /**
-   * Default API version (default: 1) — routes become /{prefix}/v{version}/{path}.
-   *
-   * `false` opts out of URL versioning: routes mount at /{prefix}/{path}.
-   * A module can still version itself by setting `version` on its
-   * `ModuleRoutes` — the per-mount value always wins over this default, in
-   * either direction.
-   */
-  defaultVersion?: number | false;
-  /**
-   * Global middleware pipeline. Declared in order.
-   * Replaces the hardcoded middleware stack — you control exactly what runs.
-   *
-   * @example
-   * ```ts
-   * bootstrap({
-   *   modules,
-   *   middlewares: [
-   *     helmet(),
-   *     cors(),
-   *     compression(),
-   *     morgan('dev'),
-   *     express.json({ limit: '1mb' }),
-   *   ],
-   * })
-   * ```
-   *
-   * If omitted, a sensible default is applied:
-   *   requestId(), express.json({ limit: '100kb' })
-   */
-  middlewares?: MiddlewareEntry[];
-  /** Plugins that bundle modules, adapters, middleware, and DI bindings */
-  plugins?: KickPlugin[];
-  /**
-   * Global Context Contributors (#107) that apply to every route in the
-   * application. Merge into the per-route pipeline at the `'global'`
-   * precedence level — they lose to module, adapter, class, and method
-   * contributors with the same key, providing app-wide defaults that any
-   * narrower scope can override.
-   *
-   * @example
-   * ```ts
-   * const StartedAt = defineContextDecorator({
-   *   key: 'requestStartedAt',
-   *   resolve: () => Date.now(),
-   * })
-   *
-   * bootstrap({
-   *   modules,
-   *   contributors: [StartedAt.registration],
-   * })
-   * ```
-   */
-  contributors?: ContributorRegistrations;
-  /**
-   * Backing store strategy for {@link RequestContext} `set/get` and the
-   * Context Contributor pipeline (#107).
-   *
-   * - `'auto'` (default) — Application mounts {@link requestScopeMiddleware}
-   *   automatically before any user middleware. If the user-supplied
-   *   `middleware` list already includes `requestScopeMiddleware()`,
-   *   detection skips the auto-mount so adopters can control its position.
-   * - `'manual'` — Application never mounts the wrapper. The Context
-   *   Contributor pipeline still runs on every route — the runner is
-   *   inserted by `router-builder` regardless of ALS state. What
-   *   degrades without an ALS frame is the *backing store*:
-   *   REQUEST-scoped DI throws (no `requestStore.getStore()` to read
-   *   from) and `RequestContext.set/get` throws. Use `'manual'` only when you
-   *   genuinely intend to wrap requests in your own ALS frame (rare —
-   *   multi-tenant adapters used to do this; post-Phase 3 they share
-   *   the framework's frame instead).
-   */
-  contextStore?: 'auto' | 'manual';
-  /**
-   * Controls whether KickJS registers process-level handlers at bootstrap.
-   *
-   * - `'auto'` (default) — register `uncaughtException` /
-   *   `unhandledRejection` loggers AND `SIGINT` / `SIGTERM` →
-   *   `app.shutdown()` → `process.exit(0)`.
-   * - `'errors-only'` — register the error loggers; skip the signal
-   *   handlers. Use this when you have your own shutdown choreographer
-   *   (OpenTelemetry SDK, Sentry, custom orchestrator) that calls
-   *   `app.shutdown()` itself and you don't want two listeners racing
-   *   to call `process.exit`.
-   * - `'manual'` — skip everything. Adopter is responsible for both
-   *   error logging and signal-driven shutdown.
-   *
-   * Background: many observability SDKs install their own SIGTERM
-   * handler to flush spans/metrics before the process exits. Two
-   * separate handlers calling `process.exit(0)` race each other and
-   * can truncate the in-flight flush. Setting this to `'errors-only'`
-   * or `'manual'` lets the SDK own the lifecycle while still letting
-   * KickJS surface uncaught exceptions / rejections via the logger.
-   *
-   * The dev mode auto-detect (`__kickjs_httpServer` set by the Vite
-   * plugin) suppresses signal registration regardless of this option,
-   * since Vite owns the lifecycle in development.
-   */
-  processHooks?: 'auto' | 'errors-only' | 'manual';
-  /**
-   * The HTTP engine driver. Defaults to {@link expressRuntime} — Express stays
-   * the zero-config default, so existing apps are unaffected.
-   *
-   * Any `HttpRuntime` is accepted — pass `fastifyRuntime()` (from
-   * `@forinda/kickjs/fastify`) or a custom engine driver. Defaults to
-   * {@link expressRuntime}. The engine-native escape hatches
-   * (`getRuntimeApp()`, `AdapterContext.app`) follow the active runtime via the
-   * registry (`ActiveRuntime`, spec §4.3b) — Express by default, or the augmented
-   * engine once the `kick/runtime` typegen output is present.
-   */
-  /**
-   * Mount the built-in `GET /health/live` and `GET /health/ready`.
-   *
-   * On by default. Set `false` to take them over completely — supply your own
-   * module at `/health` and nothing collides. The built-in is registered last,
-   * so an app module claiming the same path already wins without this.
-   *
-   * They mount as an ordinary module, which means they sit inside the
-   * middleware chain: whatever guards the rest of the app guards these too.
-   * Exempt the path if your orchestrator must reach them unauthenticated.
-   */
-  health?: boolean;
-  runtime?: HttpRuntime;
-  /** Express `trust proxy` setting */
-  trustProxy?: boolean | number | string | ((ip: string, hopIndex: number) => boolean);
-  /** Maximum JSON body size (only used when middleware is not provided) */
-  jsonLimit?: string | number;
-  /**
-   * Print the route table on startup. Default: `false`. Set to `true`
-   * to log a per-controller summary (method counts + mount paths) once
-   * the app has mounted. Emitted at `info` level, so it is still subject
-   * to `LOG_LEVEL` filtering (visible at the default `info`; hidden at
-   * `warn`/`error`/`silent`).
-   */
-  logRouteTable?: boolean;
-  /**
-   * @deprecated Use {@link ApplicationOptions.logRouteTable}. Kept as an
-   * alias for back-compat; `logRouteTable` wins when both are set.
-   */
-  logRoutesTable?: boolean;
-  /**
-   * Maximum time (ms) to wait for graceful shutdown before forcing exit.
-   * Default: 30000 (30 seconds). Set to 0 to disable forced exit.
-   */
-  shutdownTimeout?: number;
-  /**
-   * Enable cluster mode for multi-core utilization.
-   *
-   * When enabled, the primary process forks worker processes that share the
-   * same port via Node's built-in `cluster` module (OS load balancing).
-   *
-   * - `true` — use all available CPU cores
-   * - `{ workers: N }` — use exactly N workers
-   *
-   * Workers are auto-restarted on crash. SIGTERM/SIGINT on the primary is
-   * forwarded to all workers.
-   *
-   * @example
-   * ```ts
-   * bootstrap({ modules, cluster: true })
-   * bootstrap({ modules, cluster: { workers: 4 } })
-   * ```
-   */
-  cluster?: boolean | {
-    workers?: number;
-  };
-  /**
-   * Custom 404 handler for unmatched routes. When omitted, the built-in
-   * handler returns `{ message: 'Not Found' }` with status 404.
-   *
-   * Connect-**shaped**, not Express-**semantic** — see {@link onError} for the
-   * per-runtime table. The same two caveats apply: `next()` is inert on
-   * Fastify and h3, and Express-only request members (`req.originalUrl`,
-   * `req.path`, `req.ip`) are `undefined` there, so read `req.url`.
-   *
-   * @example
-   * ```ts
-   * bootstrap({
-   *   modules,
-   *   onNotFound: (req, res) => {
-   *     // `req.originalUrl` is Express-only — use `req.url` for portability.
-   *     res.status(404).json({ error: 'Route not found', path: req.url })
-   *   },
-   * })
-   * ```
-   */
-  onNotFound?: (req: any, res: RuntimeResponse, next: (err?: unknown) => void) => void;
-  /**
-   * Custom global error handler, receiving `(err, req, res, next)`. When
-   * omitted, the built-in handler formats ZodError, HttpException, and
-   * unexpected errors.
-   *
-   * The shape is connect-style, but it is NOT "the standard Express error
-   * handler" on every engine — what you actually receive differs, and the
-   * differences bite:
-   *
-   * | | `req` | `res` | `next` |
-   * | --- | --- | --- | --- |
-   * | Express | native `Request` | native `Response` | real `next` |
-   * | Fastify | `request.raw` | reply driver | **no-op** |
-   * | h3 | `event.node.req` | response driver | no-op (or dev fall-through) |
-   *
-   * Two consequences worth knowing before you write one:
-   *
-   * - **`next(err)` does nothing on Fastify and h3.** It is a no-op function
-   *   there, so delegating to the default handler silently drops the error.
-   *   Send a response yourself rather than passing it on.
-   * - **Express-only request members are `undefined` elsewhere.**
-   *   `req.originalUrl`, `req.path`, and `req.ip` do not exist on the raw node
-   *   request — use `req.url` and the `x-forwarded-*` headers, or reach for
-   *   `ctx.ip` in a contributor / guard where a `RequestContext` is available.
-   *
-   * `res` is typed {@link RuntimeResponse} because that is what every engine
-   * genuinely provides: `status`, `json`, `send`, `setHeader`, `render`,
-   * `writeHead`, `end`. Express's own `Response` satisfies it.
-   *
-   * @example
-   * ```ts
-   * bootstrap({
-   *   modules,
-   *   onError: (err, req, res) => {
-   *     logger.error(err, `${req.method} ${req.url}`) // not `originalUrl`
-   *     res.status(err.status ?? 500).json({ error: err.message })
-   *   },
-   * })
-   * ```
-   */
-  onError?: (err: any, req: any, res: RuntimeResponse, next: (err?: unknown) => void) => void;
-  /**
-   * Security defaults applied automatically unless opted out.
-   *
-   * When not specified, secure defaults are applied:
-   * - Helmet security headers are auto-injected
-   * - JSON body limit defaults to 1MB
-   *
-   * @example
-   * ```ts
-   * bootstrap({
-   *   modules,
-   *   security: {
-   *     helmet: false,     // disable auto-helmet
-   *   },
-   * })
-   * ```
-   */
-  security?: {
-    /** Auto-inject helmet security headers. Default: true */
-    helmet?: boolean;
-  };
-}
-declare class Application {
-  private readonly options;
-  private app;
-  /** The HTTP engine driver. Defaults to {@link expressRuntime}. */
-  private readonly runtime;
-  private container;
-  private httpServer;
-  private readonly adapters;
-  /**
-   * Flags of every mounted route, for middleware that runs before routing and
-   * therefore cannot read `ctx.route` (the connect-style rate limiter). Handed
-   * to middleware that declares the slot — see `core/route-policy.ts`.
-   */
-  private readonly routePolicy;
-  private readonly plugins;
-  /**
-   * Snapshot of every module-level Context Contributor registration
-   * captured during `setup()`. The registrations themselves are
-   * frozen by `defineContextDecorator`, so storing references is
-   * safe — they outlive the module instances they came from.
-   *
-   * Used by {@link getContributors} so DevTools and adopter tooling
-   * can render the module-level contributors alongside the adapter /
-   * plugin / global ones. Populated once per `setup()` call; cleared
-   * at the start of each invocation so a re-setup (test harnesses,
-   * dev-server restarts) doesn't accumulate stale entries.
-   */
-  private _moduleContributors;
-  /** Number of HTTP requests currently being processed */
-  private _inFlightRequests;
-  /** Whether the application is draining (shutting down gracefully) */
-  private _draining;
-  /** Whether shutdown has already been initiated (prevents double-shutdown) */
-  private _shutdownInitiated;
-  /** Resolvers waiting for in-flight requests to reach zero */
-  private _drainResolvers;
-  constructor(options: ApplicationOptions);
-  /** Whether the application is currently draining in-flight requests */
-  get isDraining(): boolean;
-  /** Number of HTTP requests currently being processed */
-  get inFlightRequests(): number;
-  /** Get the DI container instance */
-  getContainer(): Container;
-  /**
-   * Express request handler — delegates to the internal Express app.
-   *
-   * Used by the Vite dev-server plugin to route requests through KickJS:
-   * ```ts
-   * const mod = await ssrLoadModule('virtual:kickjs/app')
-   * mod.app.handle(req, res, next)
-   * ```
-   *
-   * Also works as a standard Node.js request handler for production:
-   * ```ts
-   * http.createServer(app.handle.bind(app))
-   * ```
-   */
-  handle(req: http.IncomingMessage, res: http.ServerResponse, next?: (err?: any) => void): void;
-  /**
-   * Full setup pipeline:
-   * 1. Adapter beforeMount hooks (early routes — docs, health)
-   * 2. Adapter middleware (phase: beforeGlobal)
-   * 3. Global middleware (user-declared or defaults)
-   * 4. Adapter middleware (phase: afterGlobal)
-   * 5. Module registration + DI bootstrap
-   * 6. Adapter middleware (phase: beforeRoutes)
-   * 7. Module route mounting
-   * 8. Adapter middleware (phase: afterRoutes)
-   * 9. Error handlers (notFound + global)
-   * 10. Adapter beforeStart hooks
-   */
-  /** Build the adapter context object (shared across all hooks) */
-  private adapterCtx;
-  /**
-   * The engine-agnostic HTTP surface handed to adapters as `ctx.http`. Each
-   * call routes through the active runtime over the current `this.app`, so an
-   * adapter written against this works under any runtime.
-   */
-  private adapterHttp;
-  /** Call an adapter hook, awaiting async hooks and catching errors */
-  private callHook;
-  setup(): Promise<void>;
-  /** Register modules and DI without starting the HTTP server (used by kick tinker) */
-  registerOnly(): Promise<void>;
-  /**
-   * Start the HTTP server.
-   *
-   * In **dev mode** (Vite plugin active): reuses `globalThis.__kickjs_httpServer`
-   * created by Vite. Adapters (WsAdapter, Socket.IO, etc.) receive the real
-   * `http.Server` through `afterStart({ server })` — zero adapter changes needed.
-   *
-   * In **production**: creates its own `http.Server` and binds to the port.
-   */
-  start(): Promise<void>;
-  /** HMR rebuild: swap Express handler without restarting the server */
-  rebuild(): Promise<void>;
-  /**
-   * Graceful shutdown with request draining.
-   *
-   * 1. Stops accepting new connections (server.close())
-   * 2. Waits for in-flight requests to complete (up to shutdownTimeout)
-   * 3. Calls adapter.shutdown() for all registered adapters
-   * 4. Force-closes after timeout
-   *
-   * Safe to call multiple times — subsequent calls return the same promise.
-   */
-  shutdown(options?: ShutdownOptions): Promise<void>;
-  /**
-   * The engine-native app instance, typed from the active runtime
-   * ({@link ActiveRuntime} — Express by default). Prefer this over
-   * {@link getExpressApp}; under a non-Express runtime the type follows the
-   * augmented registry.
-   */
-  getRuntimeApp(): ActiveRuntime['app'];
-  /**
-   * The active HTTP runtime's identity + capabilities — `name` is `'express'`
-   * (default), `'fastify'`, or `'h3'`; `capabilities` reports what the engine
-   * supports (render / uploads / connectMiddleware / nativeBodyParsing).
-   * Surfaced by DevTools and the VS Code extension so tooling can show which
-   * engine the app is running on. Cheap, side-effect free.
-   */
-  getActiveRuntime(): {
-    name: string;
-    capabilities: RuntimeCapabilities;
-  };
-  /** @deprecated Use {@link getRuntimeApp}. Returns the engine-native app. */
-  getExpressApp(): Express;
-  /** Get registered adapters — used by DevToolsAdapter for peer discovery */
-  getAdapters(): AppAdapter[];
-  /**
-   * Get registered plugins — used by DevToolsAdapter for topology
-   * introspection (architecture.md §23). Read-only; returns the
-   * already-sorted plugin list (post-`dependsOn` topo-sort).
-   */
-  getPlugins(): readonly KickPlugin[];
-  /**
-   * Snapshot of every Context Contributor reachable from this app —
-   * walks **four** registration sites: adapters, plugins, modules,
-   * and the bootstrap `contributors` option. The devtools Topology
-   * tab consumes this for the Contributors panel; tests + adopters
-   * can call it for diagnostics.
-   *
-   * Per-route (method/class-decorator) registrations are NOT included
-   * here — they live on the route registry rather than on any of
-   * the four collection sites this method walks. A future RPC will
-   * surface them separately.
-   *
-   * Result shape stays minimal — `{ key, source, label, dependsOn }`
-   * — so we don't leak `resolve` closures or other internal fields.
-   * `source` matches the five-level precedence union from
-   * `ContributorSource` (minus `'method'` / `'class'` which require
-   * the per-route walk noted above).
-   */
-  getContributors(): ReadonlyArray<{
-    key: string;
-    source: 'module' | 'adapter' | 'plugin' | 'global';
-    label: string;
-    dependsOn: readonly string[];
-  }>;
-  getHttpServer(): http.Server | null;
-  /**
-   * Decide whether {@link Application} should auto-mount the
-   * {@link requestScopeMiddleware} ALS wrapper.
-   *
-   * Returns `false` when:
-   * - `contextStore: 'manual'` was set (caller manages ALS frames), or
-   * - the user-supplied `middleware` list already includes a
-   *   `requestScopeMiddleware()` (detected via the symbol marker stamped
-   *   in `middleware/request-scope.ts`).
-   *
-   * Otherwise `true` — preserves the historical default of "always wrap
-   * requests in an ALS frame" so existing apps see no behavior change.
-   */
-  private shouldAutoMountRequestScope;
-  private collectAdapterMiddleware;
-  private mountMiddlewareList;
-  private mountMiddlewareEntry;
-  /** Middleware that tracks in-flight requests for graceful draining */
-  private requestTrackingMiddleware;
-}
-//#endregion
-export { ShutdownOptions as i, ApplicationOptions as n, MiddlewareEntry as r, Application as t };
-//# sourceMappingURL=application-NjKJPm9r.d.mts.map

package/dist/application-NjKJPm9r.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"application-NjKJPm9r.d.mts","names":[],"sources":["../src/http/application.ts"],"mappings":";;;;;;;;;;;KA4DY,kBAAkB;EAAmB;EAAc,SAAS;;;UAGvD;;;;;;;;EAQf;;UAGe;;;;;;;;;;;EAWf,SAAS;;;;;;;;;;;;;;;;;;EAmBT,OAAO,UAAU;;EAEjB,WAAW;;EAEX;;EAEA;;;;;;;;;EASA;;;;;;;;;;;;;;;;;;;;;;EAuBA,cAAc;;EAGd,UAAU;;;;;;;;;;;;;;;;;;;;;EAsBV,eAAe;;;;;;;;;;;;;;;;;;;EAoBf;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BA;;;;;;;;;;;;;;;;;;;;;;;EAwBA;EAEA,UAAU;;EAGV,2CAA2C,YAAY;;EAEvD;;;;;;;;EAQA;;;;;EAKA;;;;;EAKA;;;;;;;;;;;;;;;;;;;EAoBA;IAAsB;;;;;;;;;;;;;;;;;;;;;;EAsBtB,cAAc,UAAU,KAAK,iBAAiB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0CrD,WAAW,UAAU,UAAU,KAAK,iBAAiB,OAAO;;;;;;;;;;;;;;;;;;EAmB5D;;IAEE;;;cAwHS;mBA0CkB;UAzCrB;;mBAES;UACT;UACA;mBACS;;;;;;mBAMA;mBAEA;;;;;;;;;;;;;UAcT;;UAMA;;UAEA;;UAEA;;UAEA;EAER,YAA6B,SAAS;;MAyClC;;MAKA;;EAKJ,gBAAgB;;;;;;;;;;;;;;;EAkBhB,OAAO,KAAK,KAAK,iBAAiB,KAAK,KAAK,gBAAgB,QAAQ;;;;;;;;;;;;;;;UAuB5D;;;;;;UAiBA;;UA0BM;EAeR,SAAS;;EA4YT,gBAAgB;;;;;;;;;;EAahB,SAAS;;EA0ET,WAAW;;;;;;;;;;;EA8CX,SAAS,UAAS,kBAAuB;;;;;;;EAuJ/C,iBAAiB;;;;;;;;EAWjB;IAAsB;IAAc,cAAc;;;EAKlD,iBAAiB;;EAKjB,eAAe;;;;;;EASf,uBAAuB;;;;;;;;;;;;;;;;;;;EAsBvB,mBAAmB;IACjB;IACA;IACA;IACA;;EA6CF,iBAAiB,KAAK;;;;;;;;;;;;;;UAmBd;UAWA;UAmBA;UAUA;;UASA"}

package/dist/application-blu78Mlf.mjs

@@ -1,12 +0,0 @@
-/**
- * @forinda/kickjs v8.2.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{i as createToken,n as tokenName,s as moduleRouteMissingControllerError,t as Container}from"./container-BnkQIDQF.mjs";import{Logger,createLogger}from"./core/logger.mjs";import{t as getClassMeta}from"./metadata-DRRQ0p_l.mjs";import{Controller,Get}from"./core/decorators.mjs";import{t as MutableModuleRegistry}from"./module-registry-C7yEmbZ8.mjs";import{i as runDisposables,n as drainDisposables,r as registerDisposable,t as disposeAll}from"./disposables-lWieeJLG.mjs";import{buildMountPath,joinPaths}from"./core/path.mjs";import"./core-w7s4ntck.mjs";import{n as assertRouteUnique,r as buildRouteTable,t as _setExternalContributorSources}from"./router-builder-HeSJZ2QG.mjs";import{r as offerRoutePolicy,t as RoutePolicyTable}from"./route-policy-D5lQltyg.mjs";import{c as requestScopeMiddleware,d as rejectUnsupportedBody,i as reply,l as EXPRESS_JSON_TYPES,n as applyHandlerResult,s as isRequestScopeMiddleware,t as publishMatchedRoute}from"./runtime-B3fCMmZW.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-GJc8Pf2d.mjs";import{t as __decorate}from"./decorate-CpBbxrvT.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";const mergeConfig=(defaults={},overrides={})=>({...defaults,...overrides}),composeName=(base,scope)=>`${base}:${scope}`;function defineModule(options){if(typeof options!=`object`||!options)throw TypeError(`defineModule: options must be an object literal. See architecture.md §21 for the spec shape.`);if(typeof options.name!=`string`||options.name.length===0){let got=typeof options.name==`string`?`""`:typeof options.name;throw TypeError(`defineModule: options.name must be a non-empty string (got ${got}). Module names appear in diagnostics and \`.scoped()\` namespacing — anonymous modules make cycle / missing-dep errors hard to localize.`)}if(typeof options.build!=`function`)throw TypeError(`defineModule(${options.name}): options.build is required and must be a function (got ${typeof options.build}). The build function returns the AppModule shape — register() / routes() / contributors() — wired with the resolved config.`);let buildSync=(instanceName,scoped,overrides)=>{let config=mergeConfig(options.defaults,overrides),built=options.build(config,{name:instanceName,scoped});return Object.defineProperty(built,"__moduleName",{value:instanceName,enumerable:!1,writable:!1,configurable:!1}),built},factory=(config=>buildSync(options.name,!1,config));return factory.scoped=(scopeName,config)=>buildSync(composeName(options.name,scopeName),!0,config),Object.defineProperty(factory,"definition",{value:Object.freeze({...options}),writable:!1,enumerable:!0,configurable:!1}),factory}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 __decorateMetadata(k,v){if(typeof Reflect==`object`&&typeof Reflect.metadata==`function`)return Reflect.metadata(k,v)}const HEALTH_PROBE=createToken(`kick/Health/probe`);let HealthController=class{probe;constructor(probe){this.probe=probe}live(){return this.probe.isDraining()?reply(503,{status:`draining`,uptime:process.uptime()}):reply(200,{status:`ok`,uptime:process.uptime()})}async ready(){if(this.probe.isDraining())return reply(503,{status:`draining`,checks:[]});let checks=await this.probe.checks(),healthy=checks.every(c=>c.status===`up`);return reply(healthy?200:503,{status:healthy?`ready`:`degraded`,checks})}};__decorate([Get(`/live`),__decorateMetadata(`design:type`,Function),__decorateMetadata(`design:paramtypes`,[]),__decorateMetadata(`design:returntype`,void 0)],HealthController.prototype,`live`,null),__decorate([Get(`/ready`),__decorateMetadata(`design:type`,Function),__decorateMetadata(`design:paramtypes`,[]),__decorateMetadata(`design:returntype`,Promise)],HealthController.prototype,`ready`,null),HealthController=__decorate([Controller(),__decorateMetadata(`design:paramtypes`,[Object])],HealthController);const healthModule=defineModule({name:`HealthModule`,build:()=>({register(container){container.registerFactory(HealthController,()=>{let probe=container.resolve(HEALTH_PROBE);return new HealthController(probe)})},routes(){return{path:`/health`,controller:HealthController,version:!1,prefix:!1}}})});function materializeRouter(entries){let router=Router();for(let entry of entries){let method=entry.method.toLowerCase(),handlers=[];handlers.push((req,_res,next)=>{publishMatchedRoute(req,entry),next()}),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`);function isModuleFactory(entry){return typeof entry==`function`&&`definition`in entry&&typeof entry.scoped==`function`}function isConfigurable(factory){return factory.definition?.defaults!=null}function toAppModule(entry){if(typeof entry!=`function`)return entry;if(isModuleFactory(entry)){if(isConfigurable(entry)){let name=entry.definition?.name||entry.name||`<anonymous>`;throw TypeError(`bootstrap: module \`${name}\` takes configuration, so it must be invoked.\n  Write \`${name}()\` for its defaults, or \`${name}({ … })\` to configure it.\n  Passing it bare would have silently selected the defaults.`)}return entry()}let name=entry.name||`<anonymous>`;if(!isConstructible(entry))throw TypeError(`bootstrap: module entry \`${name}\` is a function, but not a module class and not a defineModule() factory (no \`definition\`).\n  A defineModule() module is passed as \`${name}\` or \`${name}()\`; a class must implement AppModule.`);let mod=new entry;if(typeof mod?.routes!=`function`)throw TypeError(`bootstrap: module entry \`${name}\` constructed, but the result does not implement AppModule — \`routes()\` is missing.\n  A module class needs \`routes()\`; a defineModule() module is passed as \`${name}\` or \`${name}()\`.`);return mod}function isConstructible(fn){try{return Reflect.construct(String,[],fn),!0}catch{return!1}}var Application=class{options;app;runtime;container;httpServer=null;adapters;routePolicy=new RoutePolicyTable;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.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`}`)}let declaredHelmet=(this.options.middlewares??[]).some(entry=>typeof entry==`function`&&Symbol.for(`kick/http/helmet`)in entry);if(this.options.security?.helmet!==!1&&!declaredHelmet)try{let{helmet:helmetFn}=await import(`./http/middleware/helmet.mjs`);this.runtime.useConnect(this.app,helmetFn())}catch{}let userMiddlewares=this.options.middlewares;if(userMiddlewares)for(let entry of userMiddlewares)this.mountMiddlewareEntry(entry);else if(this.runtime.useConnect(this.app,requestId()),!this.runtime.capabilities.nativeBodyParsing){let limit=this.options.jsonLimit??`1mb`;this.runtime.useConnect(this.app,express.json({limit,type:[...EXPRESS_JSON_TYPES]})),this.runtime.useConnect(this.app,express.urlencoded({extended:!0,limit})),this.runtime.useConnect(this.app,express.text({limit,type:`text/*`})),this.runtime.useConnect(this.app,rejectUnsupportedBody())}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),this.options.health!==!1&&(this.container.registerInstance(HEALTH_PROBE,{isDraining:()=>this._draining,checks:async()=>{let withCheck=this.adapters.filter(a=>a.onHealthCheck);return(await Promise.allSettled(withCheck.map(a=>a.onHealthCheck()))).map((c,i)=>c.status===`fulfilled`?c.value:{name:withCheck[i].name??`unknown`,status:`down`})}}),moduleRegistry.mount(healthModule()));let modules=moduleRegistry.entries.map(entry=>{let mod=toAppModule(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,mountedPaths=[];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 version=route.version??defaultVersion,mountPath=buildMountPath(route.prefix===!1?``:apiPrefix,version,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??`?`)}`,fullPath=joinPaths(mountPath,entry.path);assertRouteUnique(seenRoutes,entry.method,fullPath,owner),mountedPaths.push({method:entry.method,path:fullPath}),this.routePolicy.add(entry.method,fullPath,entry.meta.flags)}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);for(let entry of this.options.middlewares??[])offerRoutePolicy(typeof entry==`function`?entry:entry.handler,this.routePolicy);for(let adapter of this.adapters)for(let mw of adapter.middleware?.()??[])offerRoutePolicy(mw.handler,this.routePolicy);this.runtime.setNotFound(this.app,this.options.onNotFound??notFoundHandler(mountedPaths)),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(options={}){let closeServer=options.closeServer??!0;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(closeServer&&this.httpServer&&this.httpServer.close(()=>{}),closeServer&&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 hookTimeoutMs=closeServer?timeoutMs:Math.min(timeoutMs,5e3),timeBoxed=(label,run)=>{let hook=(async()=>run())();return hookTimeoutMs<=0?hook:new Promise((resolve,reject)=>{let t=setTimeout(()=>{log.warn(`${label} did not finish shutting down within ${hookTimeoutMs}ms — continuing without it. Its resources may still be held.`),resolve(void 0)},hookTimeoutMs);t.unref(),hook.then(value=>{clearTimeout(t),resolve(value)},err=>{clearTimeout(t),reject(err)})})},wasListening=this.httpServer?.listening===!0,results=await Promise.allSettled([...this.plugins.map(plugin=>timeBoxed(`Plugin '${plugin.name}'`,()=>plugin.shutdown?.())),...this.adapters.map(adapter=>timeBoxed(`Adapter '${adapter.name}'`,()=>adapter.shutdown?.()))]);!closeServer&&wasListening&&this.httpServer?.listening===!1&&log.error("An adapter or plugin closed the shared HTTP server during an HMR reload. The dev server is now unreachable and will not rebind until you restart it. Close only what you own: socket.io's `io.close()` closes the HTTP server passed to its constructor — on a reload, disconnect the sockets instead.");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??[];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()}}};export{HEALTH_PROBE as a,DuplicateMountNameError as c,mountSort as d,defineModule as f,materializeRouter as i,MissingMountDepError as l,buildRoutes as n,HealthController as o,expressRuntime as r,healthModule as s,Application as t,MountCycleError as u};
-//# sourceMappingURL=application-blu78Mlf.mjs.map