@dunx/http 3.2.1 → 3.3.1

package/dist/internal.js

@@ -1,16 +1,16 @@
 // @bun
+import"./chunk-bg0dr54z.js";
 import {
-  HIDDEN,
-  PUBLIC,
-  ROLES,
-  buildContext,
-  defaultStatusFor,
+  defaultStatusFor2,
+  ROLES2,
+  PUBLIC2,
+  HIDDEN2,
+  joinPath2,
+  discoverRoutes2,
+  isGateway2,
   discoverGateway,
-  discoverRoutes,
-  isGateway,
-  joinPath
-} from "./chunk-3nbj06q8.js";
-import"./chunk-sz4pvqxy.js";
+  buildContext2
+} from "./chunk-8939brh2.js";
 // src/inspect.ts
 import {
   classOf,
@@ -31,7 +31,7 @@ var validatesIn = (options) => {
   };
 };
 var rolesIn = (route) => {
-  const roles = route.meta?.get(ROLES.id);
+  const roles = route.meta?.get(ROLES2.id);
   if (roles === undefined || roles === null)
     return null;
   return (Array.isArray(roles) ? roles : [roles]).map(String);
@@ -42,16 +42,16 @@ var nodeFor = (route, module) => ({
   controller: route.controller,
   handler: route.handlerName,
   module,
-  public: route.meta?.get(PUBLIC.id) === true,
+  public: route.meta?.get(PUBLIC2.id) === true,
   roles: rolesIn(route),
   guards: (route.guards ?? []).map((guard) => guard.name),
-  hidden: route.meta?.get(HIDDEN.id) === true,
+  hidden: route.meta?.get(HIDDEN2.id) === true,
   validates: validatesIn(route.options),
   status: route.options?.status ?? null,
   responses: Object.keys(route.options?.response ?? {}).map(Number)
 });
 var routesOf = (root) => collectModules(root).flatMap((module) => readControllers(module).flatMap((controller) => {
-  return discoverRoutes(inertInstance(controller)).map((route) => nodeFor(route, module.name));
+  return discoverRoutes2(inertInstance(controller)).map((route) => nodeFor(route, module.name));
 }));
 var gatewayFor = (ctor, module) => {
   const { name, path, handlers } = discoverGateway(inertInstance(ctor));
@@ -67,16 +67,16 @@ var gatewayFor = (ctor, module) => {
     }))
   };
 };
-var gatewaysOf = (root) => collectModules(root).flatMap((module) => (module.options.providers ?? []).map((entry) => classOf(entry)?.ctor).filter((ctor) => ctor !== undefined).filter(isGateway).map((ctor) => gatewayFor(ctor, module.name)));
+var gatewaysOf = (root) => collectModules(root).flatMap((module) => (module.options.providers ?? []).map((entry) => classOf(entry)?.ctor).filter((ctor) => ctor !== undefined).filter(isGateway2).map((ctor) => gatewayFor(ctor, module.name)));
 // src/server/html.ts
 var embedJson = (value) => JSON.stringify(value).replaceAll("<", "\\u003c");
 export {
-  buildContext,
-  defaultStatusFor,
-  discoverRoutes,
+  buildContext2 as buildContext,
+  defaultStatusFor2 as defaultStatusFor,
+  discoverRoutes2 as discoverRoutes,
   embedJson,
   gatewaysOf,
-  isGateway,
-  joinPath,
+  isGateway2 as isGateway,
+  joinPath2 as joinPath,
   routesOf
 };

package/dist/server/application.d.ts

@@ -1,106 +1,11 @@
 import type { BunRequest } from 'bun';
-import { ShutdownAware, type App, type AppOptions, type Ctor, type InjectionToken, type ModuleRef, type ShutdownHookOptions, type ShutdownSignal } from '@dunx/core';
+import { ShutdownAware, type App, type Ctor, type InjectionToken, type ModuleRef } from '@dunx/core';
 import { type DiscoveredRoute } from '../route/discover.js';
 import type { WebSocketRuntime } from '../ws/adapter.js';
-import type { SocketLoggingOptions } from '../ws/logging.js';
-import type { SocketMiddleware } from '../ws/middleware.js';
-import type { PubSubRelay, RelayOptions } from '../ws/relay.js';
-import type { SocketOptions } from '../ws/socket.js';
 import type { CorsOptions } from './cors.js';
-import { type ErrorHandler } from './errors.js';
 import type { Middleware } from './middleware.js';
-import { type RequestLoggingOptions } from './request-logging.js';
 import { type AppSettings } from './settings.js';
-export interface HttpOptions extends AppOptions {
-    readonly port?: number;
-    /**
-     * Prefixes every discovered route, the same thing {@link HttpApp.setGlobalPrefix}
-     * does. Both exist: the method is what NestJS offers and what a script reaches
-     * for, the field is what an `HttpOptionsProvider` can answer from validated
-     * config. A later `setGlobalPrefix` call still wins, because it happens after.
-     *
-     * Explicitly `| undefined`, unlike the rest: a suite running one fixture both
-     * prefixed and unprefixed passes a variable here, and under
-     * `exactOptionalPropertyTypes` that would otherwise need a conditional spread.
-     * "No prefix" and "absent" mean the same thing. `@dunx/testing` relies on it.
-     */
-    readonly prefix?: string | undefined;
-    /** Mounts an `OPTIONS` preflight per path, as {@link HttpApp.enableCors} does. */
-    readonly cors?: CorsOptions;
-    /** `app.set('trust proxy', ...)` as a field. */
-    readonly trustProxy?: boolean;
-    /**
-     * Calls `enableShutdownHooks` at construction. `true` takes the default signals;
-     * an object names them and tunes the force-exit.
-     */
-    readonly shutdownHooks?: boolean | {
-        readonly signals?: readonly ShutdownSignal[];
-        readonly options?: ShutdownHookOptions;
-    };
-    /** Resolved from the container, so middleware can inject(). */
-    readonly middleware?: readonly Ctor<Middleware>[];
-    /**
-     * Replaces the default mapper. Prefer an `ErrorFilter` class over a bare
-     * `ErrorMapper`: a class is resolved from the container and can inject.
-     */
-    readonly onError?: ErrorHandler;
-    /**
-     * One structured entry per request, on by default and outermost, so a request
-     * a guard rejected is still logged with the status it got.
-     * See {@link RequestLoggingMiddleware}.
-     */
-    readonly requestLogging?: boolean | RequestLoggingOptions;
-    /**
-     * Count requests and time them per route, readable through
-     * {@link RequestMetrics}. Off by default; `+35.2 ns` per request when
-     * `requestLogging` is on, because the entry it already builds shares the
-     * timing. With `requestLogging: false` a `MetricsMiddleware` pays for its own
-     * `.then` instead, at +175.9 ns.
-     */
-    readonly metrics?: boolean;
-    /**
-     * One entry at `listen()` naming every route and gateway served. On by default,
-     * and switched separately from `requestLogging`: one is per process, the other
-     * per request. `@dunx/testing` defaults it off.
-     */
-    readonly bootLogging?: boolean;
-    /** Bun's `websocket` options, plus where a throwing handler goes. Server-wide;
-     * gateways themselves are declared in `@Module({ providers })`. */
-    readonly websocket?: SocketOptions;
-    /**
-     * The socket half of `middleware`. Each entry wraps every dispatched gateway
-     * handler; `socketLogging`'s runs outermost, ahead of anything here.
-     */
-    readonly socketMiddleware?: readonly Ctor<SocketMiddleware>[];
-    /**
-     * One structured entry per socket frame, on by default at `debug` - a gateway
-     * can take a frame per connection per tick, so it writes nothing until an app
-     * lowers its level. See {@link SocketLoggingMiddleware}.
-     */
-    readonly socketLogging?: boolean | SocketLoggingOptions;
-    /**
-     * Multi-node websocket fan-out. Absent means `PubSub` publishes to this process
-     * only. Anything with `publish` and `subscribe` fits; one that has to come out
-     * of the container goes through `app.get(PubSub).relayThrough(...)` instead.
-     */
-    readonly relay?: PubSubRelay;
-    /** The broker channel the relay carries frames on. @default 'dunx:ws' */
-    readonly relayChannel?: string;
-    /**
-     * How hard to retry a failed subscribe. Bounded, doubling, on an unref'd timer,
-     * so a broker that never returns cannot hold the process open.
-     */
-    readonly relayResubscribe?: RelayOptions['resubscribe'];
-    /**
-     * What an unmatched path looks like to global middleware. `'guarded'` gives the
-     * miss no route metadata, so a global guard refuses it and a prober cannot tell
-     * a 404 from a 401. `'public'` reports it as `@Public()` for a conventional 404.
-     * Either way `UNMATCHED` is set, which no real route sets.
-     *
-     * @default 'guarded'
-     */
-    readonly notFound?: 'guarded' | 'public';
-}
+import type { HttpOptions } from './options.js';
 /**
  * Everything below `listen()` configures the route table, built once when the
  * server binds. Calling any of them afterwards throws.
@@ -118,6 +23,8 @@ export interface HttpApp extends App {
     clientIp(req: BunRequest): string | undefined;
     /** Every gateway path this app upgrades on, exactly as mounted. */
     readonly gatewayPaths: readonly string[];
+    /** The gateway port's own url, `undefined` unless `gatewayPort` split them. */
+    readonly gatewayUrl: string | undefined;
     listen(port?: number): Promise<string>;
 }
 export declare class HttpApplication extends ShutdownAware implements HttpApp {
@@ -137,6 +44,8 @@ export declare class HttpApplication extends ShutdownAware implements HttpApp {
     /** The one `Bun.serve` call. A gateway's upgrade is a native `GET` route in the
      * same table, so Bun's router matches it and no `fetch` handler is needed. */
     listen(port?: number): Promise<string>;
+    /** The gateway port's own url, when `gatewayPort` split them. */
+    get gatewayUrl(): string | undefined;
     /** Public so an operator can start draining without committing to a shutdown,
      * which is what a readiness probe wants during a rolling deploy. */
     drain(): Promise<void>;

package/dist/server/binding.d.ts

@@ -0,0 +1,67 @@
+import type { Server } from 'bun';
+import type { SocketData } from '../ws/socket.js';
+import type { WebSocketRuntime } from '../ws/adapter.js';
+import type { RouteHandler } from './middleware.js';
+import { type BunRoutes } from './routes.js';
+/** What `listen()` computes and hands the binding, once the table is final. */
+export interface BindingPlan {
+    readonly port: number;
+    readonly routes: BunRoutes;
+    readonly fetch: RouteHandler;
+    readonly websocket: WebSocketRuntime | undefined;
+}
+/** The protocol settings, fixed at construction. `undefined` leaves Bun's own
+ * default in place rather than restating it. */
+export interface BindingProtocols {
+    readonly http2?: boolean | undefined;
+    readonly http1?: boolean | undefined;
+    /**
+     * A port of its own for the gateways. When set, the upgrade routes are not
+     * merged into the main table and a second `Bun.serve` takes them.
+     */
+    readonly gatewayPort?: number | undefined;
+}
+/**
+ * The two per-server counters a metrics reader wants, summed across however
+ * many servers are bound. `Server` satisfies it on its own, which is what an
+ * unsplit app hands over.
+ */
+export interface ServerGauges {
+    readonly pendingRequests: number;
+    readonly pendingWebSockets: number;
+}
+export interface Bound {
+    readonly main: Server<SocketData>;
+    /** The server that owns the sockets, which is what `PubSub` publishes on. */
+    readonly sockets: Server<SocketData>;
+    readonly gauges: ServerGauges;
+}
+/**
+ * The one or two `Bun.serve` instances an app binds.
+ *
+ * One is the normal shape: a gateway's upgrade is a native `GET` route in the
+ * same table, so Bun's router matches it and nothing else is needed.
+ *
+ * Two exist for `gatewayPort`. A websocket upgrade is an HTTP/1.1 request, so a
+ * server with `http1: false` can serve HTTP/2 routes or gateways and never both;
+ * splitting the ports is what lets one app do both. The gateway server takes no
+ * protocol overrides, because refusing HTTP/1.x there is the thing being avoided.
+ *
+ * Both servers come from one container, which is the reason this is a second
+ * `Bun.serve` rather than a second `HttpFactory.create`: a second app would build
+ * a second container, and the gateways would inject different singletons than the
+ * controllers.
+ */
+export declare class ServerBinding {
+    #private;
+    constructor(protocols: BindingProtocols);
+    bind(plan: BindingPlan): Bound;
+    get gatewayUrl(): string | undefined;
+    /**
+     * `force` is for the server that owns the sockets: a graceful stop waits for
+     * open connections, and a WebSocket never closes itself, so those clients see
+     * a 1006. Under a split the routes server holds none and stops gracefully, so
+     * an in-flight request there finishes rather than being cut off.
+     */
+    stop(force: boolean): Promise<void>;
+}

package/dist/server/factory.d.ts

@@ -1,6 +1,8 @@
 import { type ModuleRef } from '@dunx/core';
-import { type HttpApp, type HttpOptions } from './application.js';
-export type { HttpApp, HttpOptions } from './application.js';
+import { type HttpApp } from './application.js';
+import type { HttpOptions } from './options.js';
+export type { HttpApp } from './application.js';
+export type { HttpOptions } from './options.js';
 export declare class HttpFactory {
     #private;
     /**

package/dist/server/metrics.d.ts

@@ -1,5 +1,6 @@
 import { type HistogramSnapshot } from '@dunx/core';
-import type { BunRequest, Server } from 'bun';
+import type { BunRequest } from 'bun';
+import type { ServerGauges } from './binding.js';
 import type { RouteContext } from './context.js';
 import type { Middleware, Next } from './middleware.js';
 /** Every path Bun matched nothing for, collapsed into one series. */
@@ -53,8 +54,12 @@ export declare class RequestMetrics {
      * reflecting a deploy three days ago; who calls this is the app's decision.
      */
     reset(): void;
-    /** Internal: `listen()` hands the bound server to the resolved singleton. */
-    attach(server: Server<unknown>): void;
+    /**
+     * Internal: `listen()` hands the bound server's counters to the resolved
+     * singleton. Structural, so an app serving from two ports can hand over the
+     * sum rather than one server's half of it.
+     */
+    attach(server: ServerGauges): void;
 }
 /**
  * Whether `MetricsMiddleware` is the thing doing the observing.

package/dist/server/options-provider.d.ts

@@ -1,5 +1,5 @@
 import type { Ctor } from '@dunx/core';
-import type { HttpOptions } from './application.js';
+import type { HttpOptions } from './options.js';
 import type { SocketLoggingOptions } from '../ws/logging.js';
 import type { SocketMiddleware } from '../ws/middleware.js';
 import type { PubSubRelay, RelayOptions } from '../ws/relay.js';
@@ -86,6 +86,19 @@ export declare abstract class HttpOptionsProvider {
     /** Multi-node websocket fan-out. Absent publishes to this process only. */
     get relay(): PubSubRelay | undefined;
     get relayResubscribe(): RelayOptions['resubscribe'];
+    /**
+     * Serve HTTP/2 alongside HTTP/1.1 on the same port. `undefined` rather than
+     * `false` so an absent answer leaves Bun's own default in place instead of
+     * restating it. See {@link HttpOptions.http2}.
+     */
+    get http2(): boolean | undefined;
+    /** See {@link HttpOptions.http1}. `false` disables every gateway. */
+    get http1(): boolean | undefined;
+    /**
+     * A port of its own for the gateways, which is what makes `http1: false`
+     * usable with one. See {@link HttpOptions.gatewayPort}.
+     */
+    get gatewayPort(): number | undefined;
 }
 /**
  * The base itself, bound when no module bound a subclass. Concrete because the

package/dist/server/options.d.ts

@@ -0,0 +1,141 @@
+import type { AppOptions, Ctor, ShutdownHookOptions, ShutdownSignal } from '@dunx/core';
+import type { SocketLoggingOptions } from '../ws/logging.js';
+import type { SocketMiddleware } from '../ws/middleware.js';
+import type { PubSubRelay, RelayOptions } from '../ws/relay.js';
+import type { SocketOptions } from '../ws/socket.js';
+import type { CorsOptions } from './cors.js';
+import type { ErrorHandler } from './errors.js';
+import type { Middleware } from './middleware.js';
+import type { RequestLoggingOptions } from './request-logging.js';
+/**
+ * Every setting `HttpFactory.create` takes. Here rather than in
+ * `application.ts` so that file is the class it is named for.
+ *
+ * Each field has a twin on {@link HttpOptionsProvider}, which is the same
+ * settings answered from the container instead. The argument wins field by
+ * field; see `resolveHttpOptions`.
+ */
+export interface HttpOptions extends AppOptions {
+    readonly port?: number;
+    /**
+     * Prefixes every discovered route, the same thing {@link HttpApp.setGlobalPrefix}
+     * does. Both exist: the method is what NestJS offers and what a script reaches
+     * for, the field is what an `HttpOptionsProvider` can answer from validated
+     * config. A later `setGlobalPrefix` call still wins, because it happens after.
+     *
+     * Explicitly `| undefined`, unlike the rest: a suite running one fixture both
+     * prefixed and unprefixed passes a variable here, and under
+     * `exactOptionalPropertyTypes` that would otherwise need a conditional spread.
+     * "No prefix" and "absent" mean the same thing. `@dunx/testing` relies on it.
+     */
+    readonly prefix?: string | undefined;
+    /** Mounts an `OPTIONS` preflight per path, as {@link HttpApp.enableCors} does. */
+    readonly cors?: CorsOptions;
+    /** `app.set('trust proxy', ...)` as a field. */
+    readonly trustProxy?: boolean;
+    /**
+     * Calls `enableShutdownHooks` at construction. `true` takes the default signals;
+     * an object names them and tunes the force-exit.
+     */
+    readonly shutdownHooks?: boolean | {
+        readonly signals?: readonly ShutdownSignal[];
+        readonly options?: ShutdownHookOptions;
+    };
+    /** Resolved from the container, so middleware can inject(). */
+    readonly middleware?: readonly Ctor<Middleware>[];
+    /**
+     * Replaces the default mapper. Prefer an `ErrorFilter` class over a bare
+     * `ErrorMapper`: a class is resolved from the container and can inject.
+     */
+    readonly onError?: ErrorHandler;
+    /**
+     * One structured entry per request, on by default and outermost, so a request
+     * a guard rejected is still logged with the status it got.
+     * See {@link RequestLoggingMiddleware}.
+     */
+    readonly requestLogging?: boolean | RequestLoggingOptions;
+    /**
+     * Count requests and time them per route, readable through
+     * {@link RequestMetrics}. Off by default; `+35.2 ns` per request when
+     * `requestLogging` is on, because the entry it already builds shares the
+     * timing. With `requestLogging: false` a `MetricsMiddleware` pays for its own
+     * `.then` instead, at +175.9 ns.
+     */
+    readonly metrics?: boolean;
+    /**
+     * One entry at `listen()` naming every route and gateway served. On by default,
+     * and switched separately from `requestLogging`: one is per process, the other
+     * per request. `@dunx/testing` defaults it off.
+     */
+    readonly bootLogging?: boolean;
+    /** Bun's `websocket` options, plus where a throwing handler goes. Server-wide;
+     * gateways themselves are declared in `@Module({ providers })`. */
+    readonly websocket?: SocketOptions;
+    /**
+     * The socket half of `middleware`. Each entry wraps every dispatched gateway
+     * handler; `socketLogging`'s runs outermost, ahead of anything here.
+     */
+    readonly socketMiddleware?: readonly Ctor<SocketMiddleware>[];
+    /**
+     * One structured entry per socket frame, on by default at `debug` - a gateway
+     * can take a frame per connection per tick, so it writes nothing until an app
+     * lowers its level. See {@link SocketLoggingMiddleware}.
+     */
+    readonly socketLogging?: boolean | SocketLoggingOptions;
+    /**
+     * Multi-node websocket fan-out. Absent means `PubSub` publishes to this process
+     * only. Anything with `publish` and `subscribe` fits; one that has to come out
+     * of the container goes through `app.get(PubSub).relayThrough(...)` instead.
+     */
+    readonly relay?: PubSubRelay;
+    /** The broker channel the relay carries frames on. @default 'dunx:ws' */
+    readonly relayChannel?: string;
+    /**
+     * How hard to retry a failed subscribe. Bounded, doubling, on an unref'd timer,
+     * so a broker that never returns cannot hold the process open.
+     */
+    readonly relayResubscribe?: RelayOptions['resubscribe'];
+    /**
+     * What an unmatched path looks like to global middleware. `'guarded'` gives the
+     * miss no route metadata, so a global guard refuses it and a prober cannot tell
+     * a 404 from a 401. `'public'` reports it as `@Public()` for a conventional 404.
+     * Either way `UNMATCHED` is set, which no real route sets.
+     *
+     * @default 'public'
+     */
+    readonly notFound?: 'guarded' | 'public';
+    /**
+     * Serve HTTP/2 on the same port, through the same routes and the same
+     * `fetch` fallback. Without TLS that is h2c: a client opening with the HTTP/2
+     * preface gets HTTP/2 and everyone else gets HTTP/1.1, which is what a proxy
+     * in front of the app speaks. Bun marks the option experimental.
+     *
+     * Gateways are unaffected and keep working, because a websocket upgrade is an
+     * HTTP/1.1 request and Bun serves both protocols on the one socket. There is
+     * no websocket over HTTP/2.
+     *
+     * @default false
+     */
+    readonly http2?: boolean;
+    /**
+     * Serve HTTP/1.1. `false` alongside `http2` refuses HTTP/1.x with a 505, which
+     * **disables every gateway**: a websocket upgrade is an HTTP/1.1 request, so
+     * nothing can connect to one. Only for a port that is HTTP/2 or nothing.
+     *
+     * @default true
+     */
+    readonly http1?: boolean;
+    /**
+     * A port of its own for the gateways. The routes keep {@link port} and the
+     * upgrades move here, on a second `Bun.serve` that takes no protocol
+     * overrides, so it speaks HTTP/1.1 whatever the main port is set to.
+     *
+     * This is what makes `http2` with `http1: false` usable: a websocket upgrade
+     * is an HTTP/1.1 request, so one port serves HTTP/2-only routes or gateways
+     * and never both. The pair without a `gatewayPort` is a boot error.
+     *
+     * `0` takes any free port and is the one value that does not warn when no
+     * gateway is declared. See docs/guide/19-deployment.md.
+     */
+    readonly gatewayPort?: number;
+}

package/dist/ws/socket.d.ts

@@ -42,4 +42,20 @@ export type SocketOptions = Readonly<Pick<WebSocketHandler<SocketData>, 'backpre
      * nothing replaced it.
      */
     readonly onError?: SocketErrorHandler;
+    /**
+     * What a binary frame arrives as: `'nodebuffer'` (Bun's default),
+     * `'arraybuffer'`, `'uint8array'` or `'blob'`. Bun 1.4.1 added `'blob'` and
+     * accepts all four on a server socket.
+     *
+     * Not one of the `Pick`ed keys above, because Bun does not take it as a handler
+     * option - it is a mutable property on each `ServerWebSocket`. Declaring it
+     * here and assigning it as each connection opens is what makes it a
+     * server-wide setting rather than a line in every gateway's `@OnOpen`. The type
+     * is read off the socket, so the accepted values cannot drift from the runtime.
+     *
+     * It changes what `message` and the ping/pong payloads are at run time. Bun
+     * types them as the default's, so a gateway that sets this narrows the value
+     * itself.
+     */
+    readonly binaryType?: Socket['binaryType'];
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dunx/http",
-  "version": "3.2.1",
+  "version": "3.3.1",
   "description": "Bun.serve adapter for the dunx framework: controllers, middleware and WebSocket gateways",
   "keywords": [
     "bun",
@@ -65,8 +65,8 @@
     "@opentelemetry/sdk-trace-node": "2.11.0"
   },
   "peerDependencies": {
-    "@dunx/core": "^3.2.1",
-    "@types/bun": ">=1.3.0"
+    "@dunx/core": "^3.3.1",
+    "@types/bun": ">=1.4.1"
   },
   "peerDependenciesMeta": {
     "@types/bun": {
@@ -74,6 +74,6 @@
     }
   },
   "engines": {
-    "bun": ">=1.4.0"
+    "bun": ">=1.4.1"
   }
 }

package/dist/chunk-sz4pvqxy.js

@@ -1,108 +0,0 @@
-// @bun
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __name = (target, name) => {
-  Object.defineProperty(target, "name", {
-    value: name,
-    enumerable: false,
-    configurable: true
-  });
-  return target;
-};
-var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __defNormalProp = (obj, key, value) => (key in obj) ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
-var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
-var __expectFn = (fn) => fn !== undefined && typeof fn !== "function" ? __typeError("Function expected") : fn;
-var __decoratorContext = (kind, name, done, metadata, fns) => ({
-  kind: __decoratorStrings[kind],
-  name,
-  metadata,
-  addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null))
-});
-var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
-var __runInitializers = (array, flags, self, value) => {
-  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length;i < n; i++)
-    flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
-  return value;
-};
-var __decorateElement = (array, flags, name, decorators, target, extra) => {
-  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
-  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
-  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
-  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : {
-    get [name]() {
-      return __privateGet(this, extra);
-    },
-    set [name](x) {
-      __privateSet(this, extra, x);
-    }
-  }, name));
-  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
-  for (var i = decorators.length - 1;i >= 0; i--) {
-    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
-    if (k) {
-      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => (name in x) };
-      if (k ^ 3)
-        access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
-      if (k > 2)
-        access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
-    }
-    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? undefined : { get: desc.get, set: desc.set } : target, ctx);
-    done._ = 1;
-    if (k ^ 4 || it === undefined)
-      __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
-    else if (typeof it !== "object" || it === null)
-      __typeError("Object expected");
-    else
-      __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
-  }
-  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
-};
-
-// src/server/status.ts
-var HttpStatusCode = Object.freeze({
-  OK: 200,
-  CREATED: 201,
-  ACCEPTED: 202,
-  NO_CONTENT: 204,
-  MOVED_PERMANENTLY: 301,
-  FOUND: 302,
-  NOT_MODIFIED: 304,
-  TEMPORARY_REDIRECT: 307,
-  PERMANENT_REDIRECT: 308,
-  BAD_REQUEST: 400,
-  UNAUTHORIZED: 401,
-  PAYMENT_REQUIRED: 402,
-  FORBIDDEN: 403,
-  NOT_FOUND: 404,
-  METHOD_NOT_ALLOWED: 405,
-  NOT_ACCEPTABLE: 406,
-  REQUEST_TIMEOUT: 408,
-  CONFLICT: 409,
-  GONE: 410,
-  PRECONDITION_FAILED: 412,
-  PAYLOAD_TOO_LARGE: 413,
-  URI_TOO_LONG: 414,
-  UNSUPPORTED_MEDIA_TYPE: 415,
-  IM_A_TEAPOT: 418,
-  UNPROCESSABLE_ENTITY: 422,
-  TOO_MANY_REQUESTS: 429,
-  INTERNAL_SERVER_ERROR: 500,
-  NOT_IMPLEMENTED: 501,
-  BAD_GATEWAY: 502,
-  SERVICE_UNAVAILABLE: 503,
-  GATEWAY_TIMEOUT: 504
-});
-
-export { __privateGet, __privateAdd, __decoratorStart, __decoratorMetadata, __runInitializers, __decorateElement, HttpStatusCode };