@mlx-node/server 0.0.0

package/dist/server.js

@@ -0,0 +1,158 @@
+/** Full HTTP server lifecycle: wires up the handler and periodically sweeps expired `ResponseStore` rows and sessions. */
+import { mkdir } from 'node:fs/promises';
+import { createServer as httpCreateServer } from 'node:http';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { ResponseStore } from '@mlx-node/core';
+import { createHandler } from './handler.js';
+import { ModelRegistry } from './registry.js';
+/** Cleanup interval for expired responses (ms). */
+const CLEANUP_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+/**
+ * Default retention for persisted response rows in SQLite, in seconds.
+ *
+ * Decoupled from the in-memory `SessionRegistry` TTL (30 min) so a client
+ * sending `previous_response_id` after the warm KV cache has been evicted
+ * can still cold-replay from disk via `reconstructMessagesFromChain` +
+ * `ChatSession.startFromHistory`. 7 days trades disk for continuity at the
+ * cost of a one-time prefill on recovery.
+ */
+const DEFAULT_RESPONSE_RETENTION_SECONDS = 7 * 24 * 60 * 60; // 7 days
+/**
+ * Parse a positive integer seconds value; returns undefined for unset/invalid so caller can apply its own default.
+ *
+ * Non-integer positive values (e.g. `"1.5"`) are rejected rather than
+ * silently truncated — a typo like `"1.5"` meant as `"15"` would otherwise
+ * be accepted as 1 second, expiring persisted response rows almost
+ * immediately and breaking `previous_response_id` continuity. We prefer
+ * falling through to the caller's default over crashing on startup so a
+ * config-template typo in a Dockerfile / CI manifest does not take the
+ * service down.
+ *
+ * Exported for unit tests.
+ */
+export function parseEnvSeconds(name) {
+    const raw = process.env[name];
+    if (raw == null || raw === '')
+        return undefined;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return undefined;
+    if (!Number.isInteger(parsed))
+        return undefined;
+    return parsed;
+}
+/**
+ * Parse a positive integer count from env; shares the reject-unset-or-invalid
+ * semantics used by {@link parseEnvSeconds} (including the non-integer
+ * reject) so callers can fall back to their own default when the var is
+ * missing or malformed.
+ *
+ * Exported for unit tests.
+ */
+export function parseEnvPositiveInt(name) {
+    const raw = process.env[name];
+    if (raw == null || raw === '')
+        return undefined;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return undefined;
+    if (!Number.isInteger(parsed))
+        return undefined;
+    return parsed;
+}
+/**
+ * Validate a caller-supplied positive-integer config knob.
+ *
+ * Mirrors the reject-invalid semantics of {@link parseEnvPositiveInt} /
+ * {@link parseEnvSeconds} but fails fast with a descriptive error when
+ * the caller explicitly passes a bogus value. Silent coercion would hide
+ * a config bug that can take the model offline (e.g. a
+ * `maxQueueDepthPerModel: 0` makes `queuedCount >= limit` true for every
+ * request, immediately returning HTTP 429; a `responseRetentionSec: 0`
+ * stamps `expires_at = now` on every row and the next cleanup sweep
+ * deletes it). `undefined` falls through so the env/default path still
+ * applies.
+ */
+function normalizePositiveIntConfig(value, name) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'number' || !Number.isFinite(value) || !Number.isInteger(value) || value <= 0) {
+        throw new Error(`${name} must be a positive integer; received ${String(value)}`);
+    }
+    return value;
+}
+/**
+ * Start an MLX-Node HTTP server exposing `POST /v1/responses`,
+ * `POST /v1/messages`, and `GET /v1/models`.
+ *
+ * @example
+ * ```typescript
+ * const { registry, close } = await createServer({ port: 8080 });
+ * registry.register('qwen3.5-3b', await Qwen35Model.load('./models/qwen3.5-3b'));
+ * ```
+ */
+export async function createServer(config) {
+    const port = config?.port ?? 8080;
+    const host = config?.host ?? '127.0.0.1';
+    const cors = config?.cors ?? true;
+    const disableStore = config?.disableStore ?? false;
+    // Validate caller-supplied numeric knobs BEFORE consulting env fallbacks
+    // so a bogus explicit value surfaces as a descriptive error instead of
+    // silently falling through to env / default. See
+    // `normalizePositiveIntConfig` for the failure modes we're guarding.
+    const configRetentionSec = normalizePositiveIntConfig(config?.responseRetentionSec, 'responseRetentionSec');
+    const responseRetentionSec = configRetentionSec ?? parseEnvSeconds('MLX_RESPONSE_RETENTION_SECONDS') ?? DEFAULT_RESPONSE_RETENTION_SECONDS;
+    // Opt-in queue-depth cap; resolved exactly once at server construction
+    // so the registry (and its per-model `SessionRegistry` instances
+    // allocated on `register()`) all share a single effective value.
+    const configMaxQueueDepth = normalizePositiveIntConfig(config?.maxQueueDepthPerModel, 'maxQueueDepthPerModel');
+    const maxQueueDepthPerModel = configMaxQueueDepth ?? parseEnvPositiveInt('MLX_MAX_QUEUE_DEPTH_PER_MODEL');
+    const registry = new ModelRegistry({ maxQueueDepth: maxQueueDepthPerModel });
+    let store = null;
+    if (!disableStore) {
+        const storePath = config?.storePath ?? join(homedir(), '.mlx-node', 'responses.db');
+        const storeDir = join(storePath, '..');
+        await mkdir(storeDir, { recursive: true });
+        store = await ResponseStore.open(storePath);
+    }
+    // Always schedule the sweep — sessions need TTL sweeps even without a store.
+    const cleanupTimer = setInterval(() => {
+        if (store) {
+            store.cleanupExpired().catch(() => { });
+        }
+        for (const sessReg of registry.listSessionRegistries()) {
+            sessReg.sweep();
+        }
+    }, CLEANUP_INTERVAL_MS);
+    cleanupTimer.unref();
+    const handler = createHandler(registry, { cors, store, responseRetentionSec });
+    const server = httpCreateServer(handler);
+    await new Promise((resolve, reject) => {
+        const onError = (err) => {
+            server.removeListener('error', onError);
+            reject(err);
+        };
+        server.on('error', onError);
+        server.listen(port, host, () => {
+            server.removeListener('error', onError);
+            resolve();
+        });
+    });
+    return {
+        server,
+        registry,
+        store,
+        async close() {
+            clearInterval(cleanupTimer);
+            await new Promise((resolve, reject) => {
+                server.close((err) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve();
+                });
+            });
+        },
+    };
+}

package/dist/session-registry.d.ts

@@ -0,0 +1,297 @@
+/**
+ * SessionRegistry -- per-model cache holding AT MOST one live
+ * `ChatSession` whose native KV state is currently valid.
+ *
+ * Design notes:
+ *
+ *   - **One registry per model.** Composed alongside each registered
+ *     `ServableModel` in `ModelRegistry`. Sessions are keyed purely
+ *     by response id — no secondary keying on model name because the
+ *     registry is already scoped per model.
+ *
+ *   - **Single-warm-session invariant.** `ChatSession<M>` is a thin
+ *     JS wrapper — it does NOT own any native KV cache. The cache
+ *     lives on the underlying `SessionCapableModel` (one shared
+ *     `cached_token_history` / `caches` vector per model instance).
+ *     Any call that runs a turn overwrites that shared native state,
+ *     silently invalidating every other `ChatSession` wrapper
+ *     pointing at the same model. Caching multiple wrappers per
+ *     model is therefore an illusion: at most ONE matches real
+ *     native state (whichever ran most recently). To prevent
+ *     cross-session corruption this registry holds at most ONE
+ *     entry — both `getOrCreate` and `adopt` clear the map before
+ *     returning or inserting.
+ *
+ *   - **Lease semantics on hit.** Clear-on-hit also gives single-
+ *     flight lease semantics: two overlapping requests referencing
+ *     the same `previous_response_id` cannot share the same live
+ *     `ChatSession`. The first wins the cleared entry; the second
+ *     finds the map empty and cold-replays from `ResponseStore` on
+ *     a fresh session. Without this, the second would hit
+ *     `ChatSession`'s single-flight "concurrent send() not allowed"
+ *     guard.
+ *
+ *   - **Instructions / prefix-state change also misses.** Each entry
+ *     records the `instructions` string used to adopt it.
+ *     `getOrCreate` compares the caller's `requestedInstructions`
+ *     against the cached value; mismatch forces cold replay so the
+ *     new prefix state is re-primed instead of silently reusing a
+ *     stale warmed prompt. The OpenAI `instructions` field and the
+ *     Anthropic `system` field both flow through the same parameter
+ *     — the registry does not care which is which.
+ *
+ *   - **Cache miss fallback.** On a miss (eviction, interleaved turn
+ *     on a different chain, restart, lease-on-hit) the endpoint
+ *     layer reconstructs the conversation from the `ResponseStore`
+ *     history, primes a fresh `ChatSession` via `primeHistory()`,
+ *     and resumes through `startFromHistory()` /
+ *     `startFromHistoryStream()`. That pair dispatches one
+ *     `chatSessionStart*` call that rebuilds the full KV cache and
+ *     atomically appends the new user turn, so cold replay is
+ *     indistinguishable from a hot hit.
+ *
+ *   - **TTL.** Default 1800 seconds mirrors `RESPONSE_TTL_SECONDS`
+ *     in `packages/server/src/endpoints/responses.ts` so the cached
+ *     entry ages out alongside its stored response metadata. With
+ *     at most one entry there is no LRU bookkeeping — just a single
+ *     expiry check on lookup.
+ *
+ *   - **Thread safety.** Node.js is single-threaded within one
+ *     event-loop tick, so the internal `Map` is safe against
+ *     concurrent mutation by design. `sweep()` can be scheduled
+ *     via `setInterval` without colliding with in-flight calls.
+ *
+ *   - **Per-model execution mutex.** A dispatch that spans multiple
+ *     awaits (map -> prefill -> decode -> persist -> adopt) is NOT
+ *     atomic from the registry's POV. Two requests against the
+ *     same model would both receive a `ChatSession` pointing at
+ *     the same native model; even though the lease-on-hit clear
+ *     prevents sharing one `ChatSession` object, the native KV
+ *     cache is a single mutable resource and two parallel
+ *     `primeHistory()` / `send*()` calls would race. Whichever
+ *     finished last would win `adopt()`, poisoning the hot path
+ *     for every subsequent chained turn.
+ *
+ *     `withExclusive(fn)` serializes every per-model dispatch via
+ *     a FIFO `execLock` chain. `/v1/responses` and `/v1/messages`
+ *     wrap the full `getOrCreate -> run -> adopt/drop` span in one
+ *     `withExclusive` so at most one request holds the model at a
+ *     time. A weaker epoch-token scheme would let the losing
+ *     `adopt()` no-op but the native KV would already be wrong.
+ */
+import { ChatSession, type SessionCapableModel } from '@mlx-node/lm';
+/** Constructor options for {@link SessionRegistry}. */
+export interface SessionRegistryOptions {
+    /** The model that every session in this registry wraps. Single-model per registry. */
+    model: SessionCapableModel;
+    /** TTL in seconds before an unused session is evicted. Default: 1800 (30 min). */
+    ttlSec?: number;
+    /**
+     * Maximum number of requests that may be WAITING for the
+     * per-model execution mutex at the same time (the in-flight holder
+     * does NOT count toward this). When set and the cap is exceeded at
+     * `withExclusive` entry, the call throws {@link QueueFullError}
+     * synchronously so the endpoint layer can emit HTTP 429 and the
+     * client can retry later.
+     *
+     * Default: `undefined` (unbounded — current behaviour). Opt-in per
+     * {@link ServerConfig.maxQueueDepthPerModel} or the
+     * `MLX_MAX_QUEUE_DEPTH_PER_MODEL` env var.
+     */
+    maxQueueDepth?: number;
+}
+/**
+ * Thrown synchronously by {@link SessionRegistry.withExclusive} when
+ * the per-model queue cap (`maxQueueDepth`) is exceeded. The error is
+ * raised BEFORE awaiting the previous lock holder so endpoint handlers
+ * can reliably catch it without racing the chain.
+ */
+export declare class QueueFullError extends Error {
+    readonly queuedCount: number;
+    readonly limit: number;
+    constructor(queuedCount: number, limit: number);
+}
+/**
+ * Result of {@link SessionRegistry.getOrCreate}. `hit` reflects whether
+ * the call consumed a live warm entry (single-use lease) or returned a
+ * fresh `ChatSession` on a miss. The endpoint layer uses `hit` to
+ * classify the per-request session-cache status emitted to clients via
+ * the `X-Session-Cache` observability header.
+ */
+export interface SessionLookupResult {
+    session: ChatSession<SessionCapableModel>;
+    hit: boolean;
+}
+export declare class SessionRegistry {
+    private readonly model;
+    private readonly ttlSec;
+    private readonly maxQueueDepth;
+    /**
+     * Number of callers that are currently WAITING for the per-model
+     * execution mutex — i.e. have entered `withExclusive` but have not
+     * yet started running their closure. The caller that is actively
+     * running inside `fn()` is NOT counted here, so a cap of
+     * `maxQueueDepth = N` means "1 running + up to N waiting".
+     *
+     * Mutated strictly inside `withExclusive`: the admitting caller is
+     * counted as a waiter ONLY when the execution chain is already
+     * non-idle (i.e. some earlier caller still holds the mutex). The
+     * first caller into an idle chain is admitted directly as the
+     * runner slot and never contributes to `queuedCount`. Waiters
+     * decrement exactly once as they transition from waiting to
+     * running (after `await prev`). The counter is intentionally
+     * NEVER touched on cap-reject paths (the caller never queued) so
+     * the cap check is stable across concurrent entries, and runner-
+     * slot admissions leave it alone so a synchronous burst
+     * (e.g. `Promise.all([fn, fn])`) does not spuriously bill the
+     * runner-slot caller against the waiter cap.
+     */
+    private queuedCount;
+    /**
+     * Holds AT MOST ONE entry under the single-warm invariant (see the
+     * module-level rustdoc). `getOrCreate` and `adopt` both clear the
+     * map as part of their contract so a later lookup cannot hand out
+     * a wrapper whose assumed native state has been overwritten by a
+     * turn on another cached entry.
+     */
+    private readonly entries;
+    /**
+     * Shared sentinel representing "the execution chain is idle" — a
+     * pre-resolved promise. `execLock` starts at this value and is
+     * reset to it whenever the last holder releases without a
+     * successor chained behind it. `withExclusive` uses reference
+     * equality against this sentinel (`execLock === initialLock`) to
+     * tell "I am the runner slot on an idle chain" apart from "I am a
+     * waiter behind someone else", which is how the burst
+     * (`Promise.all([fn, fn])`) admission bug is avoided.
+     */
+    private readonly initialLock;
+    /**
+     * Tail of the per-model execution FIFO. Every `withExclusive` call
+     * captures this value as its predecessor, then overwrites it with
+     * its own pending promise so the next waiter chains after it. The
+     * chain is resolved only when the current holder's `fn` has
+     * settled (success or failure), guaranteeing that at most one
+     * dispatch runs through this registry's native model at a time.
+     * Initialized to `initialLock` so the first caller proceeds
+     * without waiting AND is recognised as the runner slot (no waiter
+     * increment). When a holder releases as the current chain tail it
+     * restores `execLock` to `initialLock` so the next burst starts
+     * cleanly from the idle state.
+     */
+    private execLock;
+    constructor(opts: SessionRegistryOptions);
+    /**
+     * Number of requests currently WAITING to acquire the per-model
+     * execution mutex. Does NOT include the one actively running inside
+     * `fn`. Primarily for tests and diagnostics.
+     */
+    get queueDepth(): number;
+    /** Number of sessions currently cached. Primarily for tests and diagnostics. Always 0 or 1. */
+    get size(): number;
+    /**
+     * Look up or allocate a session for the given previous response id.
+     * Always returns a `SessionLookupResult` and always leaves the cache
+     * empty after return (single-warm invariant).
+     *
+     * On a null id, missing key, expired entry, or prefix-state
+     * mismatch: clear and return `{ session: new ChatSession(model), hit: false }`.
+     * The caller primes / cold-replays from the `ResponseStore` and
+     * re-adopts after the turn commits.
+     *
+     * On a hit: the entry is removed and its live session is returned
+     * alongside `hit: true`. Overlapping requests against the same
+     * `previous_response_id` cannot share the same live `ChatSession` —
+     * the first wins, the second misses and cold-replays.
+     *
+     * `requestedInstructions` is the caller's prefix/system state
+     * (OpenAI `instructions`, Anthropic `system`, or `null`); byte-for-
+     * byte mismatch against the cached entry forces cold replay so
+     * the new prefix is re-primed.
+     *
+     * The `hit` flag drives the `X-Session-Cache` observability header
+     * emitted by both `/v1/responses` and `/v1/messages`: when the caller
+     * supplied a `previous_response_id`, `hit === true` yields `hit` and
+     * `hit === false` yields `cold_replay` (the endpoint then rebuilds
+     * from the `ResponseStore` on a fresh session). Requests with no
+     * `previous_response_id` (or the stateless `/v1/messages` endpoint,
+     * which always passes `null`) yield `fresh` regardless of this flag.
+     */
+    getOrCreate(previousResponseId: string | null, requestedInstructions: string | null): SessionLookupResult;
+    /**
+     * Insert a session under a newly allocated response id. Clears the
+     * map before inserting to keep the single-warm invariant explicit
+     * regardless of caller ordering.
+     *
+     * `instructions` is the prefix/system state used for this turn;
+     * stored on the entry and compared on the next `getOrCreate` to
+     * detect prefix changes that must force a cold replay.
+     */
+    adopt(responseId: string, session: ChatSession<SessionCapableModel>, instructions: string | null): void;
+    /**
+     * Remove a session by response id. No-op if the key is not present.
+     */
+    drop(responseId: string): void;
+    /**
+     * Walk the map and drop the entry if its TTL has expired.
+     * Intended for periodic cleanup via `setInterval`. Under the
+     * single-warm invariant the map holds at most one entry.
+     */
+    sweep(): void;
+    /** Empty the registry. Useful at shutdown and in tests. */
+    clear(): void;
+    /**
+     * Serialize `fn` against every other dispatch through this
+     * registry's model. The caller must hold the lock across the
+     * entire per-model dispatch span — `getOrCreate` ->
+     * `primeHistory`/`send*` -> `adopt`/`drop`. Without it, two
+     * concurrent `primeHistory()` / `send*()` calls would race on
+     * the single mutable native KV cache and whichever finished last
+     * would corrupt the other's chain.
+     *
+     * FIFO chaining via a rolling `execLock` promise: each caller
+     * captures the current tail, publishes a fresh pending promise as
+     * the new tail, awaits the old tail, then runs `fn`. The
+     * `finally` releases regardless of whether `fn` threw.
+     *
+     * **Admission control.** When `maxQueueDepth` is configured and the
+     * current number of waiters (`queuedCount`, excluding the active
+     * holder) is already at or above the cap, the call throws
+     * {@link QueueFullError} synchronously — SYNCHRONOUSLY from the
+     * caller's perspective, not merely before `await prev`. The wrapper
+     * is deliberately NOT declared `async` so the admission gate
+     * throws on the caller's stack frame, letting endpoint handlers
+     * wrap the call site in a plain try/catch without racing promise
+     * microtasks. On acceptance the async body takes over via the
+     * returned `Promise<T>`.
+     *
+     * The cap is "waiters-only" — a cap of N permits one running
+     * dispatch plus N queued ones, rejecting the (N+1)th waiter. The
+     * default (undefined) preserves the original unbounded behaviour.
+     *
+     * **Runner-slot admission.** Whether a given caller counts as the
+     * runner slot or as a waiter is decided up front by comparing
+     * `execLock` against the idle sentinel `initialLock`. If they are
+     * identical, nobody is currently in-flight and this caller wins
+     * the runner slot: it is not counted against the waiter cap and
+     * never touches `queuedCount`. Otherwise it is a waiter and the
+     * normal cap check / increment / decrement cycle applies. This is
+     * what keeps a synchronous burst such as `Promise.all([fn, fn])`
+     * admissible under `maxQueueDepth = 1` — Call 1 is the runner,
+     * Call 2 is the one allowed waiter, Call 3 would throw.
+     */
+    withExclusive<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * Async tail of {@link withExclusive}. Kept separate so the public
+     * wrapper stays a plain (non-async) function whose admission-gate
+     * throw lands on the caller's stack synchronously. This helper
+     * owns the post-acceptance bookkeeping: awaiting the predecessor
+     * lock, transitioning from waiter to holder (`queuedCount`
+     * decrement for waiters only), running `fn`, releasing the FIFO
+     * tail, and resetting the chain to `initialLock` when this caller
+     * is still the tail (so a future burst admits its first entry as
+     * a runner-slot rather than as a waiter).
+     */
+    private _runExclusive;
+}
+//# sourceMappingURL=session-registry.d.ts.map

package/dist/session-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-registry.d.ts","sourceRoot":"","sources":["../src/session-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AAEH,OAAO,EAAE,WAAW,EAAE,KAAK,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAErE,uDAAuD;AACvD,MAAM,WAAW,sBAAsB;IACrC,sFAAsF;IACtF,KAAK,EAAE,mBAAmB,CAAC;IAC3B,kFAAkF;IAClF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;;OAWG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;GAKG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACvC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;gBAEX,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;CAM/C;AAED;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,WAAW,CAAC,mBAAmB,CAAC,CAAC;IAC1C,GAAG,EAAE,OAAO,CAAC;CACd;AAqBD,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAsB;IAC5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqB;IACnD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,CAAC,WAAW,CAAK;IACxB;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwC;IAChE;;;;;;;;;OASG;IACH,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAoC;IAChE;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,QAAQ,CAAmC;gBAEvC,IAAI,EAAE,sBAAsB;IAMxC;;;;OAIG;IACH,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,+FAA+F;IAC/F,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,WAAW,CAAC,kBAAkB,EAAE,MAAM,GAAG,IAAI,EAAE,qBAAqB,EAAE,MAAM,GAAG,IAAI,GAAG,mBAAmB;IAiCzG;;;;;;;;OAQG;IACH,KAAK,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,CAAC,mBAAmB,CAAC,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IASvG;;OAEG;IACH,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAI9B;;;;OAIG;IACH,KAAK,IAAI,IAAI;IASb,2DAA2D;IAC3D,KAAK,IAAI,IAAI;IAIb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;IACH,aAAa,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IA8BlD;;;;;;;;;;OAUG;YACW,aAAa;CAiD5B"}