@mlx-node/server 0.0.8 → 0.0.10

package/dist/model-work-coordinator.js

@@ -1,3 +1,25 @@
+/**
+ * Render a thrown value for {@link ModelLoadRecord.error}.
+ *
+ * Deliberately avoids `String(unknown)`: a rejection carrying a plain object
+ * would render as the useless `[object Object]` in the one field a supervisor
+ * reads to find out why the model would not load.
+ */
+function describeLoadFailure(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === 'string')
+        return error;
+    if (error == null)
+        return 'unknown error';
+    try {
+        return JSON.stringify(error) ?? 'unknown error';
+    }
+    catch {
+        // Circular structure, or a `toJSON` that throws.
+        return 'unknown error';
+    }
+}
 /**
  * Process-local gate for native MLX work.
  *
@@ -9,16 +31,67 @@
  */
 export class ModelWorkCoordinator {
     activeReaders = 0;
-    writerActive = false;
-    waitingWriters = 0;
+    writerHeld = false;
+    queuedWriters = 0;
     readerWaiters = [];
     writerWaiters = [];
-    async withModelLoad(fn) {
+    /**
+     * Most recent settled load bracket. Retained here because the coordinator
+     * is the ONE place that brackets every load: a `resolveModel` failure in
+     * `/v1/messages` becomes a 500 and is otherwise dropped on the floor, so a
+     * supervisor polling `/health` afterwards had no way to learn what went
+     * wrong. See {@link ModelLoadRecord} for the "successful no-op overwrites
+     * an earlier failure" caveat.
+     */
+    lastLoadRecord = null;
+    /** Read-only: `true` while a load holds the exclusive writer slot. */
+    get writerActive() {
+        return this.writerHeld;
+    }
+    /** Read-only: loads parked in `acquireWrite()` waiting for the slot. */
+    get waitingWriters() {
+        return this.queuedWriters;
+    }
+    /** Read-only: outcome of the most recent settled load bracket, or `null`. */
+    get lastLoad() {
+        return this.lastLoadRecord;
+    }
+    /**
+     * Record a settled bracket. Called from the `finally` of both load
+     * wrappers so a throw is captured just as reliably as a success.
+     */
+    recordLoad(label, startedAt, error, ok) {
+        this.lastLoadRecord = {
+            label: label ?? null,
+            startedAt,
+            finishedAt: Date.now(),
+            ok,
+            error: ok ? null : describeLoadFailure(error),
+        };
+    }
+    /**
+     * @param label Optional identifier (normally the model name) stamped into
+     *   {@link lastLoad} so `/health` can name what was being loaded.
+     */
+    async withModelLoad(fn, label) {
         await this.acquireWrite();
+        // Measured from lock acquisition, not from arrival: `startedAt` is meant
+        // to answer "how long has the actual materialization been running",
+        // which is what a supervisor deciding whether to wait needs.
+        const startedAt = Date.now();
+        let ok = false;
+        let failure;
         try {
-            return await fn();
+            const result = await fn();
+            ok = true;
+            return result;
+        }
+        catch (err) {
+            failure = err;
+            throw err;
         }
         finally {
+            this.recordLoad(label, startedAt, failure, ok);
             this.releaseWrite();
         }
     }
@@ -35,25 +108,33 @@ export class ModelWorkCoordinator {
      * 60-second cold-load does not look like 60 seconds of own work for
      * every concurrent request.
      */
-    async withModelLoadInstrumented(fn) {
+    async withModelLoadInstrumented(fn, label) {
         // `owner` MUST be decided synchronously, before any await, so the
         // signal reflects coordinator state at arrival rather than after
         // any peer transition. The wait/own split is measured around the
         // actual phase boundaries (lock acquisition, fn completion) so the
         // two intervals partition cleanly instead of both reporting total
         // elapsed time — see `ModelLoadOutcome` for the contract.
-        const owner = !this.writerActive && this.waitingWriters === 0;
+        const owner = !this.writerHeld && this.queuedWriters === 0;
         const arrivedAt = Date.now();
         await this.acquireWrite();
         const lockAcquiredAt = Date.now();
+        let ok = false;
+        let failure;
         try {
             const result = await fn();
+            ok = true;
             const fnDoneAt = Date.now();
             const waitMs = Math.max(0, lockAcquiredAt - arrivedAt);
             const ownMs = Math.max(0, fnDoneAt - lockAcquiredAt);
             return { result, owner, waitMs, ownMs };
         }
+        catch (err) {
+            failure = err;
+            throw err;
+        }
         finally {
+            this.recordLoad(label, lockAcquiredAt, failure, ok);
             this.releaseWrite();
         }
     }
@@ -67,7 +148,7 @@ export class ModelWorkCoordinator {
         }
     }
     acquireRead() {
-        if (!this.writerActive && this.waitingWriters === 0) {
+        if (!this.writerHeld && this.queuedWriters === 0) {
             this.activeReaders += 1;
             return Promise.resolve();
         }
@@ -79,16 +160,16 @@ export class ModelWorkCoordinator {
         });
     }
     acquireWrite() {
-        this.waitingWriters += 1;
-        if (!this.writerActive && this.activeReaders === 0) {
-            this.waitingWriters -= 1;
-            this.writerActive = true;
+        this.queuedWriters += 1;
+        if (!this.writerHeld && this.activeReaders === 0) {
+            this.queuedWriters -= 1;
+            this.writerHeld = true;
             return Promise.resolve();
         }
         return new Promise((resolve) => {
             this.writerWaiters.push(() => {
-                this.waitingWriters -= 1;
-                this.writerActive = true;
+                this.queuedWriters -= 1;
+                this.writerHeld = true;
                 resolve();
             });
         });
@@ -101,17 +182,17 @@ export class ModelWorkCoordinator {
             this.drain();
     }
     releaseWrite() {
-        this.writerActive = false;
+        this.writerHeld = false;
         this.drain();
     }
     drain() {
-        if (this.writerActive)
+        if (this.writerHeld)
             return;
         if (this.activeReaders === 0 && this.writerWaiters.length > 0) {
             this.writerWaiters.shift()?.();
             return;
         }
-        if (this.waitingWriters === 0 && this.readerWaiters.length > 0) {
+        if (this.queuedWriters === 0 && this.readerWaiters.length > 0) {
             const readers = this.readerWaiters.splice(0);
             for (const resolve of readers)
                 resolve();

package/dist/router.d.ts

@@ -2,8 +2,41 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { ResponseStore } from '@mlx-node/core';
 import type { PublicModelEntry } from './handler.js';
+import { type ServerHealth } from './health.js';
 import type { IdleSweeper } from './idle-sweeper.js';
 import type { ModelWorkCoordinator } from './model-work-coordinator.js';
 import type { ModelRegistry } from './registry.js';
-export declare function routeRequest(req: IncomingMessage, res: ServerResponse, registry: ModelRegistry, store: ResponseStore | null, responseRetentionSec?: number, idleSweeper?: IdleSweeper | null, resolveModel?: (name: string) => Promise<void>, listModels?: () => PublicModelEntry[], modelWorkCoordinator?: ModelWorkCoordinator): Promise<void>;
+/**
+ * The request's pathname, parsed against a CONSTANT base.
+ *
+ * Never against `Host`. That header is attacker-controlled text on every
+ * request — `Host: [` makes `new URL()` throw `ERR_INVALID_URL`, and a throw
+ * from an async request listener is an unhandled rejection, which under Node's
+ * default `--unhandled-rejections=throw` takes the whole process down. One
+ * malformed byte from any client that can reach the socket was enough to end
+ * inference. A pathname does not depend on the authority anyway, so a fixed
+ * base is both safer and equivalent: an absolute-form request URI
+ * (`GET http://host/v1/models HTTP/1.1`, legal in HTTP/1.1) still wins over
+ * the base and yields the same path it always did.
+ *
+ * `req.url` itself is guarded too, for the same reason rather than a known
+ * input: this function's contract is that no request can make it throw.
+ */
+export declare function requestPathname(req: IncomingMessage): string;
+/**
+ * Trailing options bag. Added as an object rather than two more positional
+ * parameters — `routeRequest` already carries nine, and the two knobs here
+ * are unrelated to each other.
+ */
+export interface RouteExtras {
+    /** Builds the `/health` body. Omitted ⇒ the legacy constant `{ status: 'ok' }`. */
+    health?: () => ServerHealth;
+    /**
+     * Whether the caller presented a valid token. Only consulted by `/health`,
+     * which is the one route reachable without one. `true` when no token is
+     * configured at all, so an unprotected server keeps serving the full body.
+     */
+    authenticated?: boolean;
+}
+export declare function routeRequest(req: IncomingMessage, res: ServerResponse, registry: ModelRegistry, store: ResponseStore | null, responseRetentionSec?: number, idleSweeper?: IdleSweeper | null, resolveModel?: (name: string) => Promise<void>, listModels?: () => PublicModelEntry[], modelWorkCoordinator?: ModelWorkCoordinator, extras?: RouteExtras): Promise<void>;
 //# sourceMappingURL=router.d.ts.map

package/dist/router.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"AAAA,6CAA6C;AAE7C,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAapD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAyBnD,wBAAsB,YAAY,CAChC,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,EACnB,QAAQ,EAAE,aAAa,EACvB,KAAK,EAAE,aAAa,GAAG,IAAI,EAC3B,oBAAoB,CAAC,EAAE,MAAM,EAC7B,WAAW,CAAC,EAAE,WAAW,GAAG,IAAI,EAChC,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,EAC9C,UAAU,CAAC,EAAE,MAAM,gBAAgB,EAAE,EACrC,oBAAoB,CAAC,EAAE,oBAAoB,GAC1C,OAAO,CAAC,IAAI,CAAC,CAwGf"}
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"AAAA,6CAA6C;AAE7C,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAapD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAmB,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAOnD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,eAAe,GAAG,MAAM,CAS5D;AAoBD;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,mFAAmF;IACnF,MAAM,CAAC,EAAE,MAAM,YAAY,CAAC;IAC5B;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,wBAAsB,YAAY,CAChC,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,EACnB,QAAQ,EAAE,aAAa,EACvB,KAAK,EAAE,aAAa,GAAG,IAAI,EAC3B,oBAAoB,CAAC,EAAE,MAAM,EAC7B,WAAW,CAAC,EAAE,WAAW,GAAG,IAAI,EAChC,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,EAC9C,UAAU,CAAC,EAAE,MAAM,gBAAgB,EAAE,EACrC,oBAAoB,CAAC,EAAE,oBAAoB,EAC3C,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,IAAI,CAAC,CAuHf"}

package/dist/router.js

@@ -4,8 +4,36 @@ import { handleCreateMessage } from './endpoints/messages.js';
 import { handleListModels } from './endpoints/models.js';
 import { handleCreateResponse } from './endpoints/responses.js';
 import { sendAnthropicBadRequest, sendAnthropicMethodNotAllowed, sendBadRequest, sendMethodNotAllowed, sendNotFound, } from './errors.js';
+import { toMinimalHealth } from './health.js';
 /** Max request body size (10 MB). */
 const MAX_BODY_BYTES = 10 * 1024 * 1024;
+/**
+ * The request's pathname, parsed against a CONSTANT base.
+ *
+ * Never against `Host`. That header is attacker-controlled text on every
+ * request — `Host: [` makes `new URL()` throw `ERR_INVALID_URL`, and a throw
+ * from an async request listener is an unhandled rejection, which under Node's
+ * default `--unhandled-rejections=throw` takes the whole process down. One
+ * malformed byte from any client that can reach the socket was enough to end
+ * inference. A pathname does not depend on the authority anyway, so a fixed
+ * base is both safer and equivalent: an absolute-form request URI
+ * (`GET http://host/v1/models HTTP/1.1`, legal in HTTP/1.1) still wins over
+ * the base and yields the same path it always did.
+ *
+ * `req.url` itself is guarded too, for the same reason rather than a known
+ * input: this function's contract is that no request can make it throw.
+ */
+export function requestPathname(req) {
+    const raw = req.url ?? '/';
+    try {
+        return new URL(raw, 'http://localhost').pathname;
+    }
+    catch {
+        const cut = raw.search(/[?#]/);
+        const path = cut === -1 ? raw : raw.slice(0, cut);
+        return path.startsWith('/') ? path : '/';
+    }
+}
 function readBody(req) {
     return new Promise((resolve, reject) => {
         const chunks = [];
@@ -23,9 +51,8 @@ function readBody(req) {
         req.on('error', reject);
     });
 }
-export async function routeRequest(req, res, registry, store, responseRetentionSec, idleSweeper, resolveModel, listModels, modelWorkCoordinator) {
-    const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
-    const path = url.pathname;
+export async function routeRequest(req, res, registry, store, responseRetentionSec, idleSweeper, resolveModel, listModels, modelWorkCoordinator, extras) {
+    const path = requestPathname(req);
     if (path === '/v1/models') {
         if (req.method !== 'GET') {
             sendMethodNotAllowed(res, 'GET');
@@ -49,7 +76,7 @@ export async function routeRequest(req, res, registry, store, responseRetentionS
             sendBadRequest(res, msg);
             return;
         }
-        await handleCreateResponse(res, body, registry, store, req, responseRetentionSec, idleSweeper, modelWorkCoordinator);
+        await handleCreateResponse(res, body, registry, store, req, responseRetentionSec, idleSweeper, modelWorkCoordinator, resolveModel);
         return;
     }
     if (path === '/v1/messages/count_tokens') {
@@ -89,8 +116,23 @@ export async function routeRequest(req, res, registry, store, responseRetentionS
         return;
     }
     if (path === '/health' || path === '/v1/health') {
+        // Deliberately NOT bracketed by `idleSweeper.beginRequest/endRequest`
+        // and free of any native call: a supervisor polling on an interval must
+        // not keep pushing the drain timer out, nor touch the MLX allocator.
+        // Every field is read from plain JavaScript state.
+        const health = extras?.health?.();
+        if (health === undefined) {
+            // No reporter wired (a bare `createHandler` mounted by hand): keep the
+            // historical constant so existing consumers are unaffected.
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ status: 'ok' }));
+            return;
+        }
+        // Unauthenticated pollers get liveness only. `models.resident` leaks
+        // project names and local paths, so it stays behind the token.
+        const body = extras?.authenticated === false ? toMinimalHealth(health) : health;
         res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ status: 'ok' }));
+        res.end(JSON.stringify(body));
         return;
     }
     // Liveness probe at `/`. Claude Code issues `HEAD /` before its first

package/dist/server.d.ts

@@ -2,6 +2,9 @@
 import type { Server } from 'node:http';
 import { ResponseStore } from '@mlx-node/core';
 import type { PublicModelEntry } from './handler.js';
+import { type ServerHealth } from './health.js';
+import { type LoadModelOptions } from './load-model.js';
+import { ModelWorkCoordinator } from './model-work-coordinator.js';
 import { ModelRegistry } from './registry.js';
 /**
  * Parse a positive integer seconds value; returns undefined for unset/invalid so caller can apply its own default.
@@ -26,6 +29,33 @@ export declare function parseEnvSeconds(name: string): number | undefined;
  * Exported for unit tests.
  */
 export declare function parseEnvPositiveInt(name: string): number | undefined;
+/**
+ * Resolve the effective auth token from an explicit value plus the env
+ * fallback.
+ *
+ * Exported because `createInferenceHost` has to answer "is this server going
+ * to be protected?" BEFORE it binds, in order to refuse a non-loopback bind
+ * that would serve anonymously. Two independent copies of this rule would
+ * drift, and the direction it would drift is a host that refuses to start
+ * while `MLX_SERVER_AUTH_TOKEN` is sitting right there in the environment.
+ *
+ * An empty env var means "not set". An accidental `MLX_SERVER_AUTH_TOKEN=` in
+ * a launcher script must not enable auth with an empty secret that every
+ * credential-less request would then fail against.
+ *
+ * An empty EXPLICIT token is a different case and is rejected outright, for the
+ * same reason {@link normalizePositiveIntConfig} rejects a bogus explicit knob:
+ * somebody asked for a token and supplied nothing, which is
+ * `--auth-token "$TOKEN"` with `TOKEN` unset. Returning `''` made the bind
+ * guard read "auth is configured" and allow `0.0.0.0`, while the comparator
+ * accepted an empty `x-api-key` because both strings were empty — a wildcard
+ * bind published under a credential anyone can guess. Quietly downgrading to
+ * "no auth" instead would be fail-open in the other direction: on loopback it
+ * hands back the unauthenticated, wildcard-CORS server the operator was
+ * explicitly trying not to start. Throwing is the only answer that is wrong in
+ * neither bind mode, and it happens before anything binds or loads.
+ */
+export declare function resolveAuthToken(explicit: string | undefined): string | undefined;
 export interface ServerConfig {
     /** Port to listen on (default: 8080). */
     port?: number;
@@ -35,8 +65,26 @@ export interface ServerConfig {
     storePath?: string;
     /** Disable response storage entirely (default: false). */
     disableStore?: boolean;
-    /** Enable CORS headers (default: true). */
+    /**
+     * Enable CORS headers.
+     *
+     * Default: `true` when no `authToken` is in effect (historical behaviour),
+     * `false` once one is. An explicit value always wins. See
+     * {@link ServerConfig.authToken}.
+     */
     cors?: boolean;
+    /**
+     * Shared secret required on every route except `/health` and `/v1/health`.
+     *
+     * Default: `process.env.MLX_SERVER_AUTH_TOKEN`, or `undefined` (no auth)
+     * when that is unset or empty. `undefined` is byte-for-byte identical to
+     * the pre-auth behaviour. An explicit `''` is rejected rather than treated as
+     * either — see {@link resolveAuthToken}.
+     *
+     * Accepted as `x-api-key: <token>` or `authorization: Bearer <token>`.
+     * Setting it also flips the `cors` default to `false`.
+     */
+    authToken?: string;
     /**
      * Retention for persisted response rows, in seconds. Stamped as `expires_at`
      * on each committed response; controls how long `previous_response_id`
@@ -88,14 +136,80 @@ export interface ServerConfig {
      */
     listModels?: () => PublicModelEntry[];
 }
+/** Options for {@link ServerInstance.close}. */
+export interface CloseOptions {
+    /**
+     * Grace period, in milliseconds, before still-open connections are
+     * destroyed. Default: {@link DEFAULT_CLOSE_TIMEOUT_MS} (5000).
+     *
+     * Only the FIRST `close()` call's value is honoured — later calls receive
+     * the memoized promise of the first, so their timeout is ignored.
+     */
+    timeoutMs?: number;
+}
+/** Outcome of {@link ServerInstance.close}. */
+export interface CloseResult {
+    /** `true` when the grace period expired and connections were destroyed. */
+    forced: boolean;
+    /** SSE streams open at the moment of the forced destroy. `0` when not forced. */
+    streamsAborted: number;
+    /** Wall-clock duration of the shutdown. */
+    durationMs: number;
+}
 export interface ServerInstance {
     server: Server;
     /** Register models before or after starting. */
     registry: ModelRegistry;
     /** Null when disabled. */
     store: ResponseStore | null;
-    /** Graceful shutdown. */
-    close(): Promise<void>;
+    /**
+     * Coordinates process-wide MLX work: model loads take the exclusive writer
+     * slot, inference takes shared reader slots. Exposed so callers can compose
+     * their own brackets (or read `writerActive` / `lastLoad` for diagnostics).
+     * Prefer {@link loadModel} for the common load case — it also handles the
+     * drain suspension, which is easy to get wrong.
+     */
+    readonly modelWork: ModelWorkCoordinator;
+    /**
+     * Current readiness snapshot — the same body an authenticated
+     * `GET /health` returns. Pure JavaScript state; no native calls.
+     */
+    health(): ServerHealth;
+    /**
+     * Bounded, idempotent shutdown.
+     *
+     * Stops accepting new connections, drops idle (keep-alive) ones
+     * immediately, then waits up to `timeoutMs` for the rest to finish. On
+     * expiry every remaining connection is destroyed, which fires the same
+     * `res.on('close')` path a client disconnect fires — so in-flight SSE
+     * generations are cancelled through `@mlx-node/lm` down to the native
+     * `ChatStreamHandle`.
+     *
+     * Idempotent: the promise is memoized, so repeated calls return the same
+     * promise and the same result. In particular a second call does NOT
+     * reject with `ERR_SERVER_NOT_RUNNING`.
+     *
+     * RESIDUAL: `ResponseStore` has no `close()` (it is a Rust-side handle),
+     * so the SQLite connection is released by process exit, not here. A
+     * long-lived process that creates and closes many servers will hold one
+     * store handle per server.
+     */
+    close(opts?: CloseOptions): Promise<CloseResult>;
+    /**
+     * Load a model out-of-band and register it, with idle drains suspended and
+     * inference excluded for the entire operation — including the wait for the
+     * coordinator's writer lock.
+     *
+     * This is the safe way to swap the resident model on a server that is
+     * already serving. Hand-rolling the two brackets in the wrong order races
+     * the process-wide Metal allocator; see `load-model.ts` for the full
+     * rationale.
+     *
+     * Rejects with the underlying error if `load()` throws; both brackets
+     * unwind cleanly, and `health().lastLoad` records the failure under
+     * `opts.name`.
+     */
+    loadModel(opts: LoadModelOptions): Promise<void>;
     /**
      * Run `fn` with the idle-drain timer suspended for the duration of
      * an unbracketed, allocator-heavy operation — most commonly a hot

package/dist/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,0HAA0H;AAI1H,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAIxC,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAIrD,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAgB9C;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAOhE;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAOpE;AAuBD,MAAM,WAAW,YAAY;IAC3B,yCAAyC;IACzC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kDAAkD;IAClD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,6EAA6E;IAC7E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0DAA0D;IAC1D,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,2CAA2C;IAC3C,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;;;;;OAOG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;;;;;OASG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B;;;;;;;;;;;;;OAaG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,gBAAgB,EAAE,CAAC;CACvC;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,gDAAgD;IAChD,QAAQ,EAAE,aAAa,CAAC;IACxB,0BAA0B;IAC1B,KAAK,EAAE,aAAa,GAAG,IAAI,CAAC;IAC5B,yBAAyB;IACzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,mBAAmB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACzD,mBAAmB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;IACvC;;;;;;;;OAQG;IACH,aAAa,IAAI,MAAM,IAAI,CAAC;CAC7B;AAED;;;;;;;;;GASG;AACH,wBAAsB,YAAY,CAAC,MAAM,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,CAAC,CA8FjF"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"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"}