litedbmodel 2.0.2 → 2.2.0

package/dist/scp/connection-routing.js

@@ -0,0 +1,394 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — the **connection routing + config contract** (Phase C / #87).
+ *
+ * This module is the **API REFERENCE** for Phase C — the 4 native ports (rust #88 / go #89 / py #90
+ * / php #91) mirror THIS contract exactly (config field names + defaults, the connection-registry
+ * shape, `withWriter` semantics, and the `connectionFor(intent)` resolution ORDER). It builds ON the
+ * Phase A {@link import('./exec-context').ExecutionContext} seam and the Phase A/B owned-connection
+ * transaction runtime; it does NOT re-implement the seam — it supplies the pieces
+ * {@link import('./exec-context').PooledAsyncContext.connectionFor} uses to complete its resolution.
+ *
+ * ## The `connectionFor(intent)` resolution order (design §3, v1 `DBModel.ts:313` parity)
+ *
+ * A statement's connection is resolved in THIS priority (first match wins):
+ *   1. **active tx connection** — inside a transaction, always the tx-owned connection (Phase A).
+ *   2. **writer scope / writer-sticky** — inside {@link withWriter}, or within `writerStickyDuration`
+ *      after a transaction (read-your-writes), a READ goes to the WRITER pool (Phase C — here).
+ *   3. **read=reader / write=writer** — otherwise a read goes to the reader pool, a write to the
+ *      writer pool (reader/writer separation; single-pool config ⇒ reader === writer, Phase C).
+ *   4. **named-DB routing** — the target pool is selected by `intent.db` (the connection NAME carried
+ *      by the bundle/model metadata) against the {@link ConnectionRegistry}; absent ⇒ the DEFAULT
+ *      connection. Named-DB selection happens FIRST (it picks WHICH connection's reader/writer split
+ *      steps 2-3 then apply to), so the order above is really: pick the named connection, then within
+ *      it apply tx-pin / writer-sticky / reader-writer. (Phase C, decorator-free — the routing key is
+ *      config + bundle/model metadata; decorator wiring is Phase F.)
+ *
+ * ## Backward-compat (the hard constraint)
+ *
+ * Single DB, `reader === writer` (one pool), empty config, unnamed connection ⇒ BYTE-IDENTICAL to the
+ * Phase A/B single-pool behavior. A {@link ConnectionRegistry} built from ONE pool routes every
+ * intent to that ONE pool, and the writer-sticky clock only ever diverts to a pool that is the SAME
+ * object — so nothing observable changes. The existing `new PooledAsyncContext(pool)` /
+ * `new PooledAsyncContext(pool, middleware)` constructors keep working unchanged.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WriterStickyClock = exports.ConnectionRegistryBuilder = exports.ConnectionRegistry = exports.DEFAULT_CONNECTION = void 0;
+exports.resolveConnectionConfig = resolveConnectionConfig;
+exports.sessionStatements = sessionStatements;
+exports.singlePoolPair = singlePoolPair;
+exports.readerWriterPair = readerWriterPair;
+exports.inWriterScope = inWriterScope;
+exports.withWriter = withWriter;
+exports.resolvePool = resolvePool;
+exports.sessionResetStatements = sessionResetStatements;
+exports.configuredPool = configuredPool;
+exports.buildRoutingConfig = buildRoutingConfig;
+/** Apply the C3 defaults (queryTimeout=0, keepAlive=false, minPool=0, maxPool=10). */
+function resolveConnectionConfig(config = {}) {
+    return {
+        driver: config.driver ?? 'postgres',
+        ...(config.host !== undefined ? { host: config.host } : {}),
+        ...(config.port !== undefined ? { port: config.port } : {}),
+        ...(config.database !== undefined ? { database: config.database } : {}),
+        ...(config.user !== undefined ? { user: config.user } : {}),
+        ...(config.password !== undefined ? { password: config.password } : {}),
+        queryTimeout: config.queryTimeout ?? 0,
+        keepAlive: config.keepAlive ?? false,
+        keepAliveInitialDelayMillis: config.keepAliveInitialDelayMillis ?? 10000,
+        minPool: config.minPool ?? 0,
+        maxPool: config.maxPool ?? 10,
+        ...(config.searchPath !== undefined ? { searchPath: config.searchPath } : {}),
+        ...(config.charset !== undefined ? { charset: config.charset } : {}),
+    };
+}
+/**
+ * The SESSION statements a connection must run at checkout to honor a {@link ResolvedConnectionConfig}
+ * (issued once per acquired connection, in order). This is the per-dialect mapping the port agents
+ * mirror; it is pure (no connection contact) so it is testable in isolation:
+ *
+ *   - **statement timeout** (`queryTimeout` > 0): PG `SET statement_timeout = <ms>`; MySQL
+ *     `SET SESSION max_execution_time = <ms>` (both server-side, ms).
+ *   - **searchPath**: PG `SET search_path TO <path>`; MySQL has no schema search path ⇒ ignored.
+ *   - **charset**: MySQL `SET NAMES <charset>`; PG `SET client_encoding TO <charset>`.
+ *
+ * A key with no value emits nothing (⇒ empty array for an all-default config ⇒ the session is
+ * untouched, backward-compatible). sqlite has no server session ⇒ empty.
+ */
+function sessionStatements(config) {
+    const out = [];
+    const dialect = config.driver;
+    if (dialect === 'sqlite')
+        return out;
+    if (config.queryTimeout > 0) {
+        out.push(dialect === 'postgres'
+            ? `SET statement_timeout = ${config.queryTimeout}`
+            : `SET SESSION max_execution_time = ${config.queryTimeout}`);
+    }
+    if (config.searchPath !== undefined && dialect === 'postgres') {
+        out.push(`SET search_path TO ${config.searchPath}`);
+    }
+    if (config.charset !== undefined) {
+        out.push(dialect === 'mysql' ? `SET NAMES ${config.charset}` : `SET client_encoding TO ${config.charset}`);
+    }
+    return out;
+}
+/** Build a {@link ReaderWriterPools} where reader === writer (single-pool, backward-compat). */
+function singlePoolPair(pool) {
+    return { reader: pool, writer: pool };
+}
+/** Build a {@link ReaderWriterPools} from a distinct reader + writer pool (reader/writer separation). */
+function readerWriterPair(reader, writer) {
+    return { reader, writer };
+}
+// ── The connection registry (C2) — name → reader/writer pools ──────────────────
+/** The reserved name of the DEFAULT (unnamed) connection. An `intent.db` of `undefined` uses this. */
+exports.DEFAULT_CONNECTION = 'default';
+/**
+ * The multi-DB connection registry (C2): a map from a connection NAME → its {@link ReaderWriterPools}.
+ * `connectionFor(intent)` selects the pair by `intent.db` (the connection name the bundle/model
+ * metadata carries — decorator-free, from config + metadata; decorator wiring is Phase F), falling
+ * back to {@link DEFAULT_CONNECTION} when unnamed. Selecting a name that was never registered is a
+ * LOUD error (a real wiring bug — never a silent default fallback, which would run a query on the
+ * wrong DB; mirrors the V0 cross-DB relation registry's loud-fail policy).
+ *
+ * A single-DB deployment registers exactly one connection under {@link DEFAULT_CONNECTION} with
+ * `reader === writer` ⇒ every intent routes to that one pool ⇒ byte-identical to Phase A/B.
+ */
+class ConnectionRegistry {
+    /** name → reader/writer pools. */
+    connections;
+    constructor(connections) {
+        this.connections = new Map(connections);
+    }
+    /**
+     * Build a registry from ONE pool as the default connection (reader === writer). This is the
+     * backward-compat path: {@link import('./exec-context').PooledAsyncContext} built from a single
+     * pool wraps it here so its `connectionFor` routes every intent to that one pool.
+     */
+    static singleDefault(pool) {
+        return new ConnectionRegistry(new Map([[exports.DEFAULT_CONNECTION, singlePoolPair(pool)]]));
+    }
+    /** Fluent builder: start from a default connection's pools, then `.add(name, pools)` more. */
+    static fromDefault(pools) {
+        return new ConnectionRegistryBuilder().add(exports.DEFAULT_CONNECTION, pools);
+    }
+    /** The reader/writer pair for `name` (or {@link DEFAULT_CONNECTION} when `undefined`). Loud on a missing name. */
+    pairFor(name) {
+        const key = name ?? exports.DEFAULT_CONNECTION;
+        const pair = this.connections.get(key);
+        if (pair === undefined) {
+            const known = [...this.connections.keys()].map((k) => `'${k}'`).join(', ');
+            throw new Error(`scp connection routing: no connection registered under name '${key}' ` +
+                `(known: ${known || '<none>'}). Register it via setConfig/ConnectionRegistry, or drop the ` +
+                `connection tag on the bundle/model.`);
+        }
+        return pair;
+    }
+    /** The registered connection names (for diagnostics / `closeAllPools`). */
+    names() {
+        return [...this.connections.keys()];
+    }
+    /** Every DISTINCT pool object across all connections (a shared reader===writer counts once). */
+    distinctPools() {
+        const seen = new Set();
+        for (const pair of this.connections.values()) {
+            seen.add(pair.reader);
+            seen.add(pair.writer);
+        }
+        return [...seen];
+    }
+}
+exports.ConnectionRegistry = ConnectionRegistry;
+/** Incremental {@link ConnectionRegistry} builder (name → pools). */
+class ConnectionRegistryBuilder {
+    connections = new Map();
+    /** Register `name` → its reader/writer pools (chainable). Re-adding a name overwrites it. */
+    add(name, pools) {
+        this.connections.set(name, pools);
+        return this;
+    }
+    /** Finalize into an immutable {@link ConnectionRegistry}. */
+    build() {
+        if (this.connections.size === 0) {
+            throw new Error('scp connection routing: ConnectionRegistry must have at least the default connection');
+        }
+        return new ConnectionRegistry(this.connections);
+    }
+}
+exports.ConnectionRegistryBuilder = ConnectionRegistryBuilder;
+// ── Writer-sticky + withWriter (C1) ────────────────────────────────────────────
+const node_async_hooks_1 = require("node:async_hooks");
+/** Ambient "route reads to the writer" marker (mirror v1 `withWriter` writer context). */
+const writerScopeStore = new node_async_hooks_1.AsyncLocalStorage();
+/** True if the current async scope is inside a {@link withWriter} scope. */
+function inWriterScope() {
+    return writerScopeStore.getStore() === true;
+}
+/**
+ * Run `fn` with reads pinned to the WRITER pool (mirror v1 `DBModel.withWriter`): every read `fn`
+ * issues resolves the writer pool (read-your-writes without replication lag), and — because this ALSO
+ * enters a {@link import('./tx-options').withReadOnly} scope — ANY write inside `fn` throws
+ * {@link import('../types').WriteInReadOnlyContextError}. Nested `withWriter` is idempotent (already
+ * in a writer scope ⇒ just run `fn`). Inside a transaction the tx-owned connection already wins in
+ * `connectionFor`, so a `withWriter` there is a no-op on routing (matches v1 :2941).
+ *
+ * @param fn the read-your-writes scope body.
+ */
+function withWriter(fn) {
+    if (inWriterScope())
+        return fn();
+    // Enter BOTH the writer-routing marker and the read-only (write-reject) marker — v1's single
+    // writerContext is both. `withReadOnly` (tx-options) owns the write-reject half.
+    return writerScopeStore.run(true, () => withReadOnlyAsync(fn));
+}
+/**
+ * A writer-sticky CLOCK (C1, read-your-writes; v1 `_shouldUseWriterSticky` :344 + `_lastTransactionTime`).
+ * After a transaction (or a bare write) COMMITs, reads within `stickyDurationMs` route to the WRITER
+ * pool so a just-committed row is visible despite reader-replica lag. The ctx owns ONE clock instance;
+ * the tx runtime `.mark()`s it on every successful write/commit; `connectionFor` reads `.isSticky()`.
+ *
+ * `useWriterAfterTransaction=false` disables it entirely (`.isSticky()` always false). A single-pool
+ * deployment (reader === writer) is unaffected by stickiness — the diverted pool is the same object.
+ */
+class WriterStickyClock {
+    lastWriteAt = 0;
+    enabled;
+    stickyDurationMs;
+    /** Injectable clock (tests advance it); defaults to `Date.now`. */
+    now;
+    constructor(opts = {}) {
+        this.enabled = opts.useWriterAfterTransaction ?? true;
+        this.stickyDurationMs = opts.writerStickyDuration ?? 5000;
+        this.now = opts.now ?? Date.now;
+    }
+    /** Record that a write/commit just happened (the tx runtime calls this on success). */
+    mark() {
+        if (this.enabled)
+            this.lastWriteAt = this.now();
+    }
+    /** Is a read currently sticky-to-writer (within `writerStickyDuration` of the last write)? */
+    isSticky() {
+        if (!this.enabled || this.lastWriteAt === 0)
+            return false;
+        return this.now() - this.lastWriteAt < this.stickyDurationMs;
+    }
+    /** Reset the clock (e.g. between tests / on `closeAllPools`). */
+    reset() {
+        this.lastWriteAt = 0;
+    }
+}
+exports.WriterStickyClock = WriterStickyClock;
+// ── The core resolution (steps 2-4) — the ONE routing function the ports mirror ─
+/**
+ * Resolve WHICH pool serves a statement given its {@link import('./exec-context').StatementIntent}
+ * and the routing config — the completion of `connectionFor`'s steps 2-4 (step 1, the tx-pin, is
+ * handled by the ctx BEFORE calling this, since only the ctx holds the ALS pin). The order:
+ *
+ *   1. **named-DB** (`intent.db`) selects the {@link ReaderWriterPools} pair (loud on unknown name).
+ *   2. within that pair: a WRITE ⇒ the writer pool.
+ *   3. a READ in a {@link withWriter} scope OR within writer-sticky ⇒ the writer pool (read-your-writes).
+ *   4. otherwise a READ ⇒ the reader pool.
+ *
+ * Single-pool (reader === writer) ⇒ every branch returns the same pool (backward-compat).
+ */
+function resolvePool(intent, routing) {
+    const pair = routing.registry.pairFor(intent.db);
+    if (intent.write)
+        return pair.writer; // writes always to the writer
+    if (inWriterScope() || routing.sticky.isSticky())
+        return pair.writer; // read-your-writes
+    return pair.reader; // plain read → reader
+}
+// ── Session-config pool wrapper (C3) — apply queryTimeout/searchPath/charset ───
+/**
+ * The RESET statements that undo {@link sessionStatements} on release (per dialect), so a session
+ * knob (`statement_timeout` / `search_path` / `client_encoding` / `max_execution_time` / charset)
+ * set for THIS configured connection does NOT leak to the next caller that draws the SAME underlying
+ * pooled connection — pg/mysql2 do NOT auto-reset session state on release. `RESET`/`SET … DEFAULT`
+ * restores the server default. Only the knobs `config` actually set are reset (an all-default config
+ * ⇒ nothing to reset).
+ */
+function sessionResetStatements(config) {
+    const out = [];
+    const dialect = config.driver;
+    if (dialect === 'sqlite')
+        return out;
+    if (config.queryTimeout > 0) {
+        out.push(dialect === 'postgres' ? 'RESET statement_timeout' : 'SET SESSION max_execution_time = DEFAULT');
+    }
+    if (config.searchPath !== undefined && dialect === 'postgres')
+        out.push('RESET search_path');
+    if (config.charset !== undefined)
+        out.push(dialect === 'mysql' ? 'SET NAMES DEFAULT' : 'RESET client_encoding');
+    return out;
+}
+/**
+ * Wrap an {@link AsyncConnectionPool} so every acquired connection first runs the
+ * {@link sessionStatements} for `config` (statement timeout / search_path / charset) and, on release,
+ * runs {@link sessionResetStatements} to restore the server defaults (so a pooled connection never
+ * leaks THIS config's session state to the next caller — pg/mysql2 don't auto-reset on release). A
+ * config with no session knobs (all defaults) ⇒ ZERO extra statements ⇒ the wrapper is a transparent
+ * passthrough (backward-compat). This is where C3's `queryTimeout`/`searchPath`/`charset` become REAL
+ * per-server effects — the acquired connection carries them for the statement(s) that run on it.
+ *
+ * If a session statement itself fails (e.g. an invalid search_path), the connection is released back
+ * as DESTROYED so a mis-configured connection never re-enters the pool. On release, if a statement
+ * ERRORED (the connection is possibly aborted — e.g. a fired statement timeout), the reset is SKIPPED
+ * and the connection is DESTROYED (a poisoned connection must not re-enter the pool anyway).
+ */
+function configuredPool(pool, config) {
+    const session = sessionStatements(config);
+    if (session.length === 0)
+        return pool; // no knobs set ⇒ transparent passthrough (byte-identical)
+    const reset = sessionResetStatements(config);
+    return {
+        async acquire() {
+            const conn = await pool.acquire();
+            try {
+                for (const stmt of session)
+                    await conn.run(stmt, []);
+            }
+            catch (e) {
+                await pool.release(conn, true); // a failed session setup poisons the connection — drop it
+                throw e;
+            }
+            return conn;
+        },
+        async release(conn, destroy) {
+            // A destroyed (poisoned/aborted) connection is dropped — no point resetting it, and a reset on
+            // an aborted-by-timeout connection would itself fail. A CLEAN connection is reset to defaults.
+            if (destroy === true) {
+                await pool.release(conn, true);
+                return;
+            }
+            try {
+                for (const stmt of reset)
+                    await conn.run(stmt, []);
+            }
+            catch {
+                await pool.release(conn, true); // reset failed ⇒ connection state unknown ⇒ drop it
+                return;
+            }
+            await pool.release(conn, false);
+        },
+    };
+}
+/**
+ * The C3 `setConfig` result: the {@link RoutingConfig} a {@link import('./exec-context').PooledAsyncContext}
+ * runs on, plus a `close()` that shuts every constructed pool ({@link closeAllPools}). Build it from
+ * one or more {@link ConnectionSetup}s (the one named `default`, or the first unnamed, is the default
+ * connection).
+ *
+ * For each setup: resolve the config, CALL its {@link PoolFactory} to construct the pool(s) — so
+ * `minPool`/`maxPool`/`keepAlive`/`keepAliveInitialDelayMillis` are applied at `new Pool()` /
+ * `createPool()` time (the config is the SOLE source of the cap) — then wrap each pool with
+ * {@link configuredPool} so the SESSION knobs (queryTimeout/searchPath/charset) apply on checkout.
+ */
+function buildRoutingConfig(setups, stickyOpts = {}) {
+    if (setups.length === 0)
+        throw new Error('scp setConfig: at least one connection setup is required');
+    const builder = new ConnectionRegistryBuilder();
+    const closers = [];
+    for (const s of setups) {
+        const resolved = resolveConnectionConfig(s.config);
+        // CONSTRUCT the reader pool from the resolved config (sizing/keepAlive land at `new Pool()`).
+        const readerBuilt = s.poolFactory(resolved, 'reader');
+        closers.push(readerBuilt.close);
+        const reader = configuredPool(readerBuilt.pool, resolved);
+        let pair;
+        if (s.separateWriter === true) {
+            const writerBuilt = s.poolFactory(resolved, 'writer');
+            closers.push(writerBuilt.close);
+            pair = readerWriterPair(reader, configuredPool(writerBuilt.pool, resolved));
+        }
+        else {
+            pair = singlePoolPair(reader); // reader === writer (one constructed pool)
+        }
+        builder.add(s.name ?? exports.DEFAULT_CONNECTION, pair);
+    }
+    const routing = { registry: builder.build(), sticky: new WriterStickyClock(stickyOpts) };
+    return { routing, close: () => closeRouting(closers) };
+}
+/** Close every DISTINCT pool closer (deduped by identity), tolerating individual failures. */
+async function closeRouting(closers) {
+    const seen = new Set();
+    for (const c of closers) {
+        if (seen.has(c))
+            continue;
+        seen.add(c);
+        await c().catch(() => undefined);
+    }
+}
+// ── read-only async scope (bridge to tx-options withReadOnly for the async body) ─
+const tx_options_1 = require("./tx-options");
+/**
+ * Run an ASYNC `fn` inside the tx-options read-only scope. `withReadOnly` is generic over its body's
+ * return, so an async body's Promise is carried through the ALS run correctly (the marker stays set
+ * across the awaits inside `fn` because ALS spans the async chain). Kept here so {@link withWriter}
+ * composes the write-reject half without exec-context needing to know about it.
+ */
+function withReadOnlyAsync(fn) {
+    return (0, tx_options_1.withReadOnly)(fn);
+}
+//# sourceMappingURL=connection-routing.js.map

package/dist/scp/connection-routing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-routing.js","sourceRoot":"","sources":["../../src/scp/connection-routing.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;;;AAmEH,0DAgBC;AAeD,8CAkBC;AAgBD,wCAEC;AAGD,4CAEC;AAkGD,sCAEC;AAYD,gCAKC;AAqED,kCAKC;AAYD,wDAUC;AAgBD,wCA+BC;AAuDD,gDAyBC;AA7ZD,sFAAsF;AACtF,SAAgB,uBAAuB,CAAC,SAA2B,EAAE;IACnE,OAAO;QACL,MAAM,EAAE,MAAM,CAAC,MAAM,IAAI,UAAU;QACnC,GAAG,CAAC,MAAM,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC3D,GAAG,CAAC,MAAM,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC3D,GAAG,CAAC,MAAM,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACvE,GAAG,CAAC,MAAM,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC3D,GAAG,CAAC,MAAM,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACvE,YAAY,EAAE,MAAM,CAAC,YAAY,IAAI,CAAC;QACtC,SAAS,EAAE,MAAM,CAAC,SAAS,IAAI,KAAK;QACpC,2BAA2B,EAAE,MAAM,CAAC,2BAA2B,IAAI,KAAK;QACxE,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,CAAC;QAC5B,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,EAAE;QAC7B,GAAG,CAAC,MAAM,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC7E,GAAG,CAAC,MAAM,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACrE,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,iBAAiB,CAAC,MAAgC;IAChE,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC;IAC9B,IAAI,OAAO,KAAK,QAAQ;QAAE,OAAO,GAAG,CAAC;IACrC,IAAI,MAAM,CAAC,YAAY,GAAG,CAAC,EAAE,CAAC;QAC5B,GAAG,CAAC,IAAI,CACN,OAAO,KAAK,UAAU;YACpB,CAAC,CAAC,2BAA2B,MAAM,CAAC,YAAY,EAAE;YAClD,CAAC,CAAC,oCAAoC,MAAM,CAAC,YAAY,EAAE,CAC9D,CAAC;IACJ,CAAC;IACD,IAAI,MAAM,CAAC,UAAU,KAAK,SAAS,IAAI,OAAO,KAAK,UAAU,EAAE,CAAC;QAC9D,GAAG,CAAC,IAAI,CAAC,sBAAsB,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC;IACtD,CAAC;IACD,IAAI,MAAM,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;QACjC,GAAG,CAAC,IAAI,CAAC,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,aAAa,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,0BAA0B,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;IAC7G,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAeD,gGAAgG;AAChG,SAAgB,cAAc,CAAC,IAAyB;IACtD,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;AACxC,CAAC;AAED,yGAAyG;AACzG,SAAgB,gBAAgB,CAAC,MAA2B,EAAE,MAA2B;IACvF,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;AAC5B,CAAC;AAED,kFAAkF;AAElF,sGAAsG;AACzF,QAAA,kBAAkB,GAAG,SAAS,CAAC;AAE5C;;;;;;;;;;GAUG;AACH,MAAa,kBAAkB;IAC7B,kCAAkC;IACjB,WAAW,CAAiC;IAE7D,YAAY,WAAmD;QAC7D,IAAI,CAAC,WAAW,GAAG,IAAI,GAAG,CAAC,WAAW,CAAC,CAAC;IAC1C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,aAAa,CAAC,IAAyB;QAC5C,OAAO,IAAI,kBAAkB,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,0BAAkB,EAAE,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACvF,CAAC;IAED,8FAA8F;IAC9F,MAAM,CAAC,WAAW,CAAC,KAAwB;QACzC,OAAO,IAAI,yBAAyB,EAAE,CAAC,GAAG,CAAC,0BAAkB,EAAE,KAAK,CAAC,CAAC;IACxE,CAAC;IAED,kHAAkH;IAClH,OAAO,CAAC,IAAwB;QAC9B,MAAM,GAAG,GAAG,IAAI,IAAI,0BAAkB,CAAC;QACvC,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACvC,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,MAAM,KAAK,GAAG,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC3E,MAAM,IAAI,KAAK,CACb,gEAAgE,GAAG,IAAI;gBACrE,WAAW,KAAK,IAAI,QAAQ,+DAA+D;gBAC3F,qCAAqC,CACxC,CAAC;QACJ,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,2EAA2E;IAC3E,KAAK;QACH,OAAO,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC;IACtC,CAAC;IAED,gGAAgG;IAChG,aAAa;QACX,MAAM,IAAI,GAAG,IAAI,GAAG,EAAuB,CAAC;QAC5C,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC;YAC7C,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACtB,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACxB,CAAC;QACD,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC;IACnB,CAAC;CACF;AAnDD,gDAmDC;AAED,qEAAqE;AACrE,MAAa,yBAAyB;IACnB,WAAW,GAAG,IAAI,GAAG,EAA6B,CAAC;IAEpE,6FAA6F;IAC7F,GAAG,CAAC,IAAY,EAAE,KAAwB;QACxC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAClC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,6DAA6D;IAC7D,KAAK;QACH,IAAI,IAAI,CAAC,WAAW,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;YAChC,MAAM,IAAI,KAAK,CAAC,sFAAsF,CAAC,CAAC;QAC1G,CAAC;QACD,OAAO,IAAI,kBAAkB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAClD,CAAC;CACF;AAhBD,8DAgBC;AAED,kFAAkF;AAElF,uDAAqD;AAErD,0FAA0F;AAC1F,MAAM,gBAAgB,GAAG,IAAI,oCAAiB,EAAQ,CAAC;AAEvD,4EAA4E;AAC5E,SAAgB,aAAa;IAC3B,OAAO,gBAAgB,CAAC,QAAQ,EAAE,KAAK,IAAI,CAAC;AAC9C,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,UAAU,CAAI,EAAoB;IAChD,IAAI,aAAa,EAAE;QAAE,OAAO,EAAE,EAAE,CAAC;IACjC,6FAA6F;IAC7F,iFAAiF;IACjF,OAAO,gBAAgB,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC,CAAC;AACjE,CAAC;AAED;;;;;;;;GAQG;AACH,MAAa,iBAAiB;IACpB,WAAW,GAAG,CAAC,CAAC;IACP,OAAO,CAAU;IACjB,gBAAgB,CAAS;IAC1C,mEAAmE;IAClD,GAAG,CAAe;IAEnC,YAAY,OAAmG,EAAE;QAC/G,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,yBAAyB,IAAI,IAAI,CAAC;QACtD,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,oBAAoB,IAAI,IAAI,CAAC;QAC1D,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC;IAClC,CAAC;IAED,uFAAuF;IACvF,IAAI;QACF,IAAI,IAAI,CAAC,OAAO;YAAE,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAClD,CAAC;IAED,8FAA8F;IAC9F,QAAQ;QACN,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,WAAW,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;QAC1D,OAAO,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,gBAAgB,CAAC;IAC/D,CAAC;IAED,iEAAiE;IACjE,KAAK;QACH,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC;IACvB,CAAC;CACF;AA5BD,8CA4BC;AAgBD,mFAAmF;AAEnF;;;;;;;;;;;GAWG;AACH,SAAgB,WAAW,CAAC,MAAyD,EAAE,OAAsB;IAC3G,MAAM,IAAI,GAAG,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IACjD,IAAI,MAAM,CAAC,KAAK;QAAE,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,8BAA8B;IACpE,IAAI,aAAa,EAAE,IAAI,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE;QAAE,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,mBAAmB;IACzF,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,sBAAsB;AAC5C,CAAC;AAED,kFAAkF;AAElF;;;;;;;GAOG;AACH,SAAgB,sBAAsB,CAAC,MAAgC;IACrE,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC;IAC9B,IAAI,OAAO,KAAK,QAAQ;QAAE,OAAO,GAAG,CAAC;IACrC,IAAI,MAAM,CAAC,YAAY,GAAG,CAAC,EAAE,CAAC;QAC5B,GAAG,CAAC,IAAI,CAAC,OAAO,KAAK,UAAU,CAAC,CAAC,CAAC,yBAAyB,CAAC,CAAC,CAAC,0CAA0C,CAAC,CAAC;IAC5G,CAAC;IACD,IAAI,MAAM,CAAC,UAAU,KAAK,SAAS,IAAI,OAAO,KAAK,UAAU;QAAE,GAAG,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;IAC7F,IAAI,MAAM,CAAC,OAAO,KAAK,SAAS;QAAE,GAAG,CAAC,IAAI,CAAC,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,uBAAuB,CAAC,CAAC;IAChH,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,cAAc,CAAC,IAAyB,EAAE,MAAgC;IACxF,MAAM,OAAO,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAC1C,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC,CAAC,0DAA0D;IACjG,MAAM,KAAK,GAAG,sBAAsB,CAAC,MAAM,CAAC,CAAC;IAC7C,OAAO;QACL,KAAK,CAAC,OAAO;YACX,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC;YAClC,IAAI,CAAC;gBACH,KAAK,MAAM,IAAI,IAAI,OAAO;oBAAE,MAAM,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YACvD,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,0DAA0D;gBAC1F,MAAM,CAAC,CAAC;YACV,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;QACD,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO;YACzB,+FAA+F;YAC/F,+FAA+F;YAC/F,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;gBACrB,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;gBAC/B,OAAO;YACT,CAAC;YACD,IAAI,CAAC;gBACH,KAAK,MAAM,IAAI,IAAI,KAAK;oBAAE,MAAM,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YACrD,CAAC;YAAC,MAAM,CAAC;gBACP,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,oDAAoD;gBACpF,OAAO;YACT,CAAC;YACD,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAClC,CAAC;KACF,CAAC;AACJ,CAAC;AA4CD;;;;;;;;;;GAUG;AACH,SAAgB,kBAAkB,CAChC,MAAkC,EAClC,aAAqF,EAAE;IAEvF,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,0DAA0D,CAAC,CAAC;IACrG,MAAM,OAAO,GAAG,IAAI,yBAAyB,EAAE,CAAC;IAChD,MAAM,OAAO,GAAiB,EAAE,CAAC;IACjC,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;QACvB,MAAM,QAAQ,GAAG,uBAAuB,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QACnD,8FAA8F;QAC9F,MAAM,WAAW,GAAG,CAAC,CAAC,WAAW,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;QACtD,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QAChC,MAAM,MAAM,GAAG,cAAc,CAAC,WAAW,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QAC1D,IAAI,IAAuB,CAAC;QAC5B,IAAI,CAAC,CAAC,cAAc,KAAK,IAAI,EAAE,CAAC;YAC9B,MAAM,WAAW,GAAG,CAAC,CAAC,WAAW,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;YACtD,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;YAChC,IAAI,GAAG,gBAAgB,CAAC,MAAM,EAAE,cAAc,CAAC,WAAW,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;QAC9E,CAAC;aAAM,CAAC;YACN,IAAI,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,2CAA2C;QAC5E,CAAC;QACD,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,IAAI,0BAAkB,EAAE,IAAI,CAAC,CAAC;IAClD,CAAC;IACD,MAAM,OAAO,GAAkB,EAAE,QAAQ,EAAE,OAAO,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,IAAI,iBAAiB,CAAC,UAAU,CAAC,EAAE,CAAC;IACxG,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,YAAY,CAAC,OAAO,CAAC,EAAE,CAAC;AACzD,CAAC;AAED,8FAA8F;AAC9F,KAAK,UAAU,YAAY,CAAC,OAA8B;IACxD,MAAM,IAAI,GAAG,IAAI,GAAG,EAAc,CAAC;IACnC,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;QACxB,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;YAAE,SAAS;QAC1B,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACZ,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;IACnC,CAAC;AACH,CAAC;AAED,oFAAoF;AAEpF,6CAA4C;AAE5C;;;;;GAKG;AACH,SAAS,iBAAiB,CAAI,EAAoB;IAChD,OAAO,IAAA,yBAAY,EAAC,EAAE,CAAC,CAAC;AAC1B,CAAC"}

package/dist/scp/dbmodel-runtime.d.ts

@@ -0,0 +1,101 @@
+/**
+ * litedbmodel v2 SCP — the DBModel ActiveRecord ↔ SCP RUNTIME bridge (Phase F-2, epic #74, issue #105).
+ *
+ * The runtime glue that puts `DBModel`'s pooled execution on the Phase A-E substrate
+ * (`exec-context.ts` / `connection-routing.ts` / `middleware.ts` / `tx-options.ts`). It owns two
+ * concerns:
+ *
+ *  1. **Connection wiring** ({@link buildContextFromConfig}) — a v1 `DBConfig` (+ `writerConfig` /
+ *     writer-sticky options) → a {@link PooledAsyncContext} over REAL pg / mysql2 pools (via
+ *     `pgPoolFactory` / `mysqlPoolFactory` + `buildRoutingConfig`) and a `close()`. This is the C3
+ *     `setConfig → ConnectionRegistry → pool` path. Every statement DBModel issues — a v1-built SELECT
+ *     as much as a compiled write bundle — goes through this ONE ctx, so routing, middleware and an
+ *     ambient transaction pin apply uniformly.
+ *
+ *  2. **Write execution** ({@link executeWriteAsync}) — run a compiled write bundle's transaction plan
+ *     on the writer through the SCP tx runtime (write=tx guard).
+ *
+ * There is NO runtime read-compile here. A read whose SHAPE is fixed is declared on the `@behavior` /
+ * `@leaf` authoring surface and lowered by `bc generate`; a read whose shape is only known per request
+ * (`find({where:{age:{gt:x}}})`) runs the v1 imperative builder — compile-free — and reaches the DB
+ * through the SAME ctx seam via `DBModel.execute`.
+ *
+ * The public API + README code are UNCHANGED: `DBModel`'s method signatures / return shapes are
+ * identical; this module is an INTERNAL execution substrate.
+ */
+import 'reflect-metadata';
+import { type PoolCloser } from './connection-routing';
+import { PooledAsyncContext } from './exec-context';
+import type { SqlBundle } from './write-bundle';
+import { type TransactionResult } from './makesql/tx';
+import type { TransactionOptions } from './tx-options';
+import { compileCreateBundle, compileUpdateBundle, compileDeleteBundle, type ModelClassLike, type DeriveColumnsOptions } from './decorator-adapter';
+import type { Scope } from 'behavior-contracts/runtime';
+import type { DialectName } from './dialect';
+/** A v1 `DBConfig`-shaped input (host/port/database/user/password + pool sizing + keepAlive). */
+export interface RuntimeDbConfig {
+    readonly host?: string;
+    readonly port?: number;
+    readonly database?: string;
+    readonly user?: string;
+    readonly password?: string;
+    readonly max?: number;
+    readonly keepAlive?: boolean;
+    readonly keepAliveInitialDelayMillis?: number;
+    readonly driver?: 'postgres' | 'mysql' | 'sqlite';
+}
+/** Options for {@link buildContextFromConfig} — reader/writer split + writer-sticky (C3 / v1 parity). */
+export interface RuntimeContextOptions {
+    /** A distinct WRITER connection config (reader/writer replica split). Absent ⇒ reader === writer. */
+    readonly writerConfig?: RuntimeDbConfig;
+    /** Keep routing to the writer for `writerStickyDuration` after a committed tx (read-your-writes). */
+    readonly useWriterAfterTransaction?: boolean;
+    /** The writer-sticky window in ms (default 5000). */
+    readonly writerStickyDuration?: number;
+}
+/** The assembled runtime context: the routed ctx, the dialect, and a closer. */
+export interface RuntimeContext {
+    /**
+     * The Phase A-E execution context (routing + middleware + tx-pinning) over real pools. This IS the
+     * async read/write seam every statement funnels through — a v1-built SELECT via `DBModel.execute`,
+     * a compiled write bundle via {@link executeWriteAsync}, and a generated read module via
+     * `bindAsync(leafHandlersAsync({ execAsync: ctx, dialect }))`.
+     */
+    readonly ctx: PooledAsyncContext;
+    /** The compiled SQL dialect (`postgres` / `mysql`). */
+    readonly dialect: DialectName;
+    /** Shut every constructed pool (v1 `closeAllPools`). */
+    readonly close: PoolCloser;
+}
+/**
+ * Build a Phase A-E {@link PooledAsyncContext} + reader executor from a v1 `DBConfig` (the
+ * `setConfig → ConnectionRegistry → pool` wiring). Constructs a REAL pg / mysql2 pool via
+ * `buildRoutingConfig` + the driver pool factory (sizing/keepAlive applied at pool construction), wires
+ * the default connection, and — when `writerConfig` is present — a distinct writer pool (reader/writer
+ * replica split). The writer-sticky clock is armed per `useWriterAfterTransaction` / `writerStickyDuration`.
+ *
+ * `sqlite` is NOT routed here (it keeps the v1 in-proc path). Throws for an unsupported driver.
+ */
+export declare function buildContextFromConfig(config: RuntimeDbConfig, options?: RuntimeContextOptions): RuntimeContext;
+/** The current SCP-runtime generation; a cached runtime built at an older generation is stale (#182). */
+export declare function scpRuntimeGeneration(): number;
+/**
+ * Close every pool set {@link buildContextFromConfig} has constructed — including runtimes their owner
+ * discarded without closing. Part of the v1 `closeAllPools()` teardown, alongside the per-driver caches.
+ * Bumps {@link scpRuntimeGeneration} so `DBModel`'s cached runtimes rebuild instead of reusing a now-closed
+ * pool (#182).
+ */
+export declare function closeAllScpRuntimes(): Promise<void>;
+/** Run a write bundle's transaction plan on the writer through the SCP tx runtime (write=tx guard). */
+export declare function executeWriteAsync(bundle: SqlBundle, input: Scope, ctx: RuntimeContext, options?: TransactionOptions): Promise<TransactionResult>;
+/**
+ * Render a v1-built raw SQL string (with `?` placeholders) to the ctx dialect's placeholder form for
+ * the escape-hatch seam path: `postgres` renumbers `?`→`$N` (string-literal-aware, via the SAME
+ * `renderPlaceholders` the makesql render uses); `mysql` keeps `?`. v1's DBHandler did this `?`→`$N`
+ * conversion on the imperative path — the SCP seam passes SQL verbatim to the driver, so the raw path
+ * must renumber here to stay byte-equivalent. Phase F-2 (#105).
+ */
+export declare function renderRawSql(sql: string, dialect: DialectName): string;
+export { compileCreateBundle, compileUpdateBundle, compileDeleteBundle };
+export type { ModelClassLike, DeriveColumnsOptions };
+//# sourceMappingURL=dbmodel-runtime.d.ts.map

package/dist/scp/dbmodel-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dbmodel-runtime.d.ts","sourceRoot":"","sources":["../../src/scp/dbmodel-runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,kBAAkB,CAAC;AAC1B,OAAO,EAEL,KAAK,UAAU,EAIhB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAKpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAA2B,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAC/E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,KAAK,cAAc,EACnB,KAAK,oBAAoB,EAC1B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAI7C,iGAAiG;AACjG,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,2BAA2B,CAAC,EAAE,MAAM,CAAC;IAC9C,QAAQ,CAAC,MAAM,CAAC,EAAE,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAC;CACnD;AAED,yGAAyG;AACzG,MAAM,WAAW,qBAAqB;IACpC,qGAAqG;IACrG,QAAQ,CAAC,YAAY,CAAC,EAAE,eAAe,CAAC;IACxC,qGAAqG;IACrG,QAAQ,CAAC,yBAAyB,CAAC,EAAE,OAAO,CAAC;IAC7C,qDAAqD;IACrD,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;CACxC;AAED,gFAAgF;AAChF,MAAM,WAAW,cAAc;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,GAAG,EAAE,kBAAkB,CAAC;IACjC,uDAAuD;IACvD,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,wDAAwD;IACxD,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;CAC5B;AA0CD;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,eAAe,EAAE,OAAO,GAAE,qBAA0B,GAAG,cAAc,CAsCnH;AAqBD,yGAAyG;AACzG,wBAAgB,oBAAoB,IAAI,MAAM,CAE7C;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,CAKzD;AAID,uGAAuG;AACvG,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,cAAc,EACnB,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAAC,iBAAiB,CAAC,CAK5B;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,MAAM,CAEtE;AAGD,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,CAAC;AACzE,YAAY,EAAE,cAAc,EAAE,oBAAoB,EAAE,CAAC"}