litedbmodel 2.0.2 → 2.2.0

package/dist/scp/makesql/static-bundle.js

@@ -1,1113 +0,0 @@
-"use strict";
-/**
- * litedbmodel v2 SCP — the STATIC, PORTABLE `makeSQL` bundle + its runtime (epic #43/#45
- * Phase B; design #45 owner-confirmed static-bundle decision).
- *
- * This is the SOLE read/compile path of the makeSQL SCP model, expressed as a compile step
- * that is **symbolic** (no concrete input needed) and a runtime that evaluates value-specs +
- * skip PER-INPUT via behavior-contracts. It REPLACES the reduced-spine `../runtime.ts`
- * `SqlBundle`/`compileBundle`/`executeBundle` for the read path.
- *
- * ## The static bundle shape (design #45)
- *
- * A compiled behavior method is a bundle of ordered {@link StaticStatement} — each a
- * `makeSQL` TEMPLATE:
- *   - `sql`    — tuned dialect SQL text (`?` placeholders), COMPLETE and value-independent
- *                (compiled ONCE; the single-JSON-param array forms + PG `= ANY`/UNNEST keep
- *                the text fixed regardless of the runtime array length — no per-input text).
- *   - `params` — value-specs = bc Expression IR (`{ref:[…]}` / small ops / literals), 1:1 with
- *                the top-level `?`, evaluated AT RUNTIME by bc `evaluateExpression`.
- *   - `skip?`  — a bc presence expression, evaluated at runtime; when truthy the whole
- *                statement (its `sql` and `params`) drops (contributes NOTHING).
- *
- * So the compile step emits a reusable portable artifact; the runtime (this module's
- * {@link executeStaticBundle}) evaluates skip + params per-input via bc, assembles present
- * fragments, renders placeholders, and executes. This unifies read/write/codegen on ONE
- * `SqlBundle` shape and enables multi-language IR-reference execution.
- *
- * ## Symbolic compile — reuses `authoring-compile`'s port decoding, defers evaluation
- *
- * Phase A's `authoring-compile.ts` compiled per-input EAGERLY (it called `evaluateExpression`
- * on every value slot to produce concrete `{sql, params}`). Here we keep the SAME closed-set
- * port decoding (`../bridge.ts` operators, IN-sentinel, SKIP-`cond` collapse) but DEFER the
- * value/skip evaluation to the runtime: a where-member's value operand stays as its raw bc
- * Expression IR, a SKIP-`cond` guard becomes the statement's `skip` expression, and the SQL
- * text is emitted once.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compileSelectNode = compileSelectNode;
-exports.compileStaticBundle = compileStaticBundle;
-exports.executeStaticBundle = executeStaticBundle;
-exports.executeStaticWrite = executeStaticWrite;
-exports.compileReadGraph = compileReadGraph;
-exports.executeReadGraph = executeReadGraph;
-exports.executeReadGraphAsync = executeReadGraphAsync;
-exports.executeReadBehavior = executeReadBehavior;
-exports.renderReadPrimary = renderReadPrimary;
-const behavior_contracts_1 = require("behavior-contracts");
-const tx_1 = require("./tx");
-const makesql_1 = require("./makesql");
-const handler_1 = require("./handler");
-const tx_2 = require("./tx");
-const find_filter_guard_1 = require("../find-filter-guard");
-const outtype_1 = require("./outtype");
-const errors_1 = require("../errors");
-const DBConditions_1 = require("../../DBConditions");
-const DBValues_1 = require("../../DBValues");
-const json_array_1 = require("./json-array");
-const compile_select_1 = require("./compile-select");
-const compile_1 = require("./compile");
-const authoring_sql_1 = require("../authoring-sql");
-function isMap(n) {
-    return 'map' in n;
-}
-function nodeRef(n) {
-    return isMap(n) ? { component: n.map.component, ports: n.map.ports } : { component: n.component, ports: n.ports };
-}
-function stringPort(ports, name) {
-    const v = ports[name];
-    if (v === undefined)
-        return undefined;
-    if (typeof v !== 'string')
-        throw new Error(`static-bundle: port '${name}' must be a literal string in the IR (got ${JSON.stringify(v)})`);
-    return v;
-}
-function arrPort(ports, name) {
-    const v = ports[name];
-    if (v === undefined)
-        return undefined;
-    if (typeof v === 'object' && v !== null && 'arr' in v && Array.isArray(v.arr)) {
-        return v.arr;
-    }
-    throw new Error(`static-bundle: port '${name}' must be an {arr:[...]} literal in the IR (got ${JSON.stringify(v)})`);
-}
-function stringArrayPort(ports, name) {
-    const arr = arrPort(ports, name);
-    if (arr === undefined)
-        return undefined;
-    return arr.map((e) => {
-        if (typeof e !== 'string')
-            throw new Error(`static-bundle: '${name}' entries must be literal strings (got ${JSON.stringify(e)})`);
-        return e;
-    });
-}
-/** Read a `{name, sql}` CTE map port (V0 R4). Both fields must be literal strings in the IR. */
-function mapPort(ports, name) {
-    const v = ports[name];
-    if (v === undefined)
-        return undefined;
-    if (typeof v === 'object' && v !== null && 'obj' in v && typeof v.obj === 'object') {
-        const obj = v.obj;
-        if (typeof obj.name !== 'string' || typeof obj.sql !== 'string') {
-            throw new Error(`static-bundle: port '${name}' must be a {name, sql} literal map (got ${JSON.stringify(v)})`);
-        }
-        return { name: obj.name, sql: obj.sql };
-    }
-    throw new Error(`static-bundle: port '${name}' must be an {obj:{name, sql}} literal (got ${JSON.stringify(v)})`);
-}
-/** Read an `{arr:[…]}` list of DEFERRED value-specs (bc Expression IR), e.g. cte/join params. */
-function exprArrayPort(ports, name) {
-    const arr = arrPort(ports, name);
-    if (arr === undefined)
-        return undefined;
-    return arr;
-}
-function opKey(node) {
-    if (node === null || typeof node !== 'object' || Array.isArray(node))
-        return undefined;
-    const keys = Object.keys(node);
-    return keys.length === 1 ? keys[0] : undefined;
-}
-function columnOf(node, ctx) {
-    const op = opKey(node);
-    if (op !== 'ref' && op !== 'refOpt')
-        throw new Error(`static-bundle: ${ctx}: the column operand must be a {ref:[…]} / {refOpt:[…]} path`);
-    const path = node[op];
-    if (!Array.isArray(path) || path.length === 0 || typeof path[path.length - 1] !== 'string') {
-        throw new Error(`static-bundle: ${ctx}: column ref path must be a non-empty string path`);
-    }
-    return path[path.length - 1];
-}
-function inSentinelColumn(node) {
-    const op = opKey(node);
-    if (op !== 'ref' && op !== 'refOpt')
-        return undefined;
-    const path = node[op];
-    if (Array.isArray(path) && path.length >= 2 && path[0] === tx_1.IN_SENTINEL && typeof path[path.length - 1] === 'string') {
-        return path[path.length - 1];
-    }
-    return undefined;
-}
-function binOperands(node, op, at) {
-    const args = node[op];
-    if (!Array.isArray(args) || args.length !== 2)
-        throw new Error(`static-bundle: ${at}: '${op}' expects exactly 2 operands`);
-    return [args[0], args[1]];
-}
-// ── Additive where-primitive decode (V0 R2/R3) ─────────────────────────────────
-//
-// The authoring layer (`authoring-sql.ts`) encodes each additive where-primitive as
-// `eq(<sentinel ref>, <value>)` (the SAME closed-set trick `whereIn` uses). Here we detect the
-// sentinel ref-path head, rebuild the EXACT v1 `ConditionObject` (or `DBSubquery`/`DBExists`) it
-// stands for, drive the ORIGINAL `DBConditions.compile()` for byte-true text, and defer the value
-// operands as value-specs 1:1 with the produced `?` placeholders — never a hand-rolled string.
-/** The sentinel ref-path segments (`[head, seg0, …]`) if `node` is a sentinel column ref. */
-function sentinelPath(node) {
-    const op = opKey(node);
-    if (op !== 'ref' && op !== 'refOpt')
-        return undefined;
-    const path = node[op];
-    if (!Array.isArray(path) || path.length === 0)
-        return undefined;
-    return path.every((s) => typeof s === 'string') ? path : undefined;
-}
-/** Extract a literal `{arr:[…]}` value-spec list from a value operand (else undefined). */
-function litArr(node) {
-    if (node !== null && typeof node === 'object' && !Array.isArray(node) && 'arr' in node) {
-        const a = node.arr;
-        if (Array.isArray(a))
-            return a;
-    }
-    return undefined;
-}
-/** Decode the nested-makeSQL Fragment param operand of a subquery/EXISTS primitive. */
-function nestedSub(node, at) {
-    if (node === null || typeof node !== 'object' || Array.isArray(node) || !('obj' in node)) {
-        throw new Error(`static-bundle: ${at}: subquery operand must be a nested makeSQL Fragment {obj:{sql, params?}}`);
-    }
-    const obj = node.obj;
-    const sqlNode = obj.sql;
-    if (typeof sqlNode !== 'string')
-        throw new Error(`static-bundle: ${at}: nested subquery 'sql' must be a literal string`);
-    const params = obj.params === undefined ? [] : (litArr(obj.params) ?? undefinedThrow(at));
-    return { sql: sqlNode, params };
-}
-function undefinedThrow(at) {
-    throw new Error(`static-bundle: ${at}: nested subquery 'params' must be an {arr:[…]} literal`);
-}
-/**
- * Decode a sentinel-encoded additive where-primitive into its v1-sourced fragment. Returns
- * undefined when the LHS is NOT one of the additive sentinels (the caller falls through to the
- * eq/cmp/IN handling). The TEXT is always produced by the ORIGINAL builders (`DBConditions` /
- * `dbCast` / `dbDynamic` / `dbImmediate` / `dbTupleIn` / `DBSubquery` / `DBExists`).
- */
-function decodeSentinel(col, val, dialect, at) {
-    const path = sentinelPath(col);
-    if (path === undefined)
-        return undefined;
-    const head = path[0];
-    if (head === authoring_sql_1.BETWEEN_SENTINEL) {
-        const [column] = [path[1]];
-        const bounds = litArr(val);
-        if (bounds === undefined || bounds.length !== 2)
-            throw new Error(`static-bundle: ${at}: BETWEEN expects a 2-element bounds array`);
-        // v1 custom-op key `col BETWEEN ? AND ?` → 2 placeholders, both deferred.
-        return { sql: v1ConditionText({ [`${column} BETWEEN ? AND ?`]: [PROBE, PROBE] }, dialect), params: bounds };
-    }
-    if (head === authoring_sql_1.LIKE_SENTINEL) {
-        const [column, keyword] = [path[1], path[2]];
-        // v1 custom-op key `col LIKE ?` / `col ILIKE ?` → 1 placeholder, deferred.
-        return { sql: v1ConditionText({ [`${column} ${keyword} ?`]: PROBE }, dialect), params: [val] };
-    }
-    if (head === authoring_sql_1.CAST_SENTINEL) {
-        const [column, sqlType, cmpOp] = [path[1], path[2], path[3]];
-        // Drive the ORIGINAL `dbCast(value, type, op)` so the PG `::type` cast (and MySQL/SQLite
-        // no-cast) is byte-true and dialect-gated by the formatter `v1ConditionText` passes.
-        return { sql: v1ConditionText({ [column]: (0, DBValues_1.dbCast)(PROBE, sqlType, cmpOp) }, dialect), params: [val] };
-    }
-    if (head === authoring_sql_1.DYNAMIC_SENTINEL) {
-        const [column, template] = [path[1], path[2]];
-        const values = litArr(val);
-        // `dbDynamic(template, values)` → `col = <template>` with one `?` per template placeholder.
-        const nPlaceholders = (template.match(/\?/g) ?? []).length;
-        const probeVals = Array.from({ length: nPlaceholders }, () => PROBE);
-        const deferred = values ?? [val];
-        if (deferred.length !== nPlaceholders) {
-            throw new Error(`static-bundle: ${at}: dbDynamic template has ${nPlaceholders} '?' but ${deferred.length} value-specs`);
-        }
-        return { sql: v1ConditionText({ [column]: (0, DBValues_1.dbDynamic)(template, probeVals) }, dialect), params: deferred };
-    }
-    if (head === authoring_sql_1.IMMEDIATE_SENTINEL) {
-        const [column, sql] = [path[1], path[2]];
-        // `dbImmediate(sql)` → `col = <sql>` inline, NO bound param.
-        return { sql: v1ConditionText({ [column]: (0, DBValues_1.dbImmediate)(sql) }, dialect), params: [] };
-    }
-    if (head === authoring_sql_1.TUPLE_SENTINEL) {
-        const columns = path.slice(1);
-        const tuples = litArr(val);
-        if (tuples === undefined)
-            throw new Error(`static-bundle: ${at}: tuple-IN expects an array-of-tuples value`);
-        // Each tuple is itself a literal `{arr:[…]}` of value-specs. The v1 `dbTupleIn` text is
-        // `(a, b) IN ((?, ?), …)` — one `?` per tuple element; defer them in row-major order.
-        const rows = tuples.map((t) => litArr(t) ?? throwTuple(at));
-        const deferred = [];
-        for (const row of rows)
-            for (const el of row)
-                deferred.push(el);
-        // Build the v1 text with PROBE tuples of the same shape (all-int probes → identical text).
-        const probeRows = rows.map((r) => r.map(() => PROBE));
-        return { sql: tupleInText(columns, probeRows, dialect), params: deferred };
-    }
-    if (head === authoring_sql_1.SUBQUERY_SENTINEL) {
-        const [lhs, keyword] = [path[1], path[2]];
-        const sub = nestedSub(val, at);
-        // v1 `DBSubquery` renders `<lhs> <IN|NOT IN> (<inner SELECT>)`. The inner SELECT text is
-        // v1-sourced by the AUTHOR (dialect-tuned) and spliced verbatim; its bound value-specs follow.
-        return { sql: `${lhs} ${keyword} (${sub.sql})`, params: sub.params };
-    }
-    if (head === authoring_sql_1.EXISTS_SENTINEL) {
-        const [keyword] = [path[1]];
-        const sub = nestedSub(val, at);
-        // v1 `DBExists` renders `<EXISTS|NOT EXISTS> (<inner SELECT 1 …>)`. Inner text v1-sourced.
-        return { sql: `${keyword} (${sub.sql})`, params: sub.params };
-    }
-    return undefined;
-}
-function throwTuple(at) {
-    throw new Error(`static-bundle: ${at}: each tuple-IN row must be an {arr:[…]} literal`);
-}
-/** The v1 `dbTupleIn` text via a nested `DBConditions.__tuple__` (byte-true; probe tuples). */
-function tupleInText(columns, probeRows, dialect) {
-    // Reuse the ORIGINAL dbTupleIn so the `(cols) IN ((?, …), …)` text is v1-produced, not hand-rolled.
-    const cond = { __tuple__: (0, DBValues_1.dbTupleIn)([...columns], probeRows) };
-    return v1ConditionText(cond, dialect);
-}
-/** The comparison-operator SQL symbols, keyed by the bc operator name (drives the v1 custom-op key). */
-const CMP_OPS = { lt: '<', le: '<=', gt: '>', ge: '>=', ne: '<>' };
-/** A probe placeholder value fed to the v1 builder so it emits one `?` per bound slot. */
-const PROBE = '__probe__';
-/**
- * Produce a bare condition body's TEXT by driving the ORIGINAL v1 builder
- * `DBConditions.compile()` (through `conditionsFor`, so MySQL/SQLite IN-lists take the
- * single-JSON server-side form and PG stays base-class). The `conditions` object is built to
- * be byte-identical to what the v1 eager path would pass for the same construct; the throwaway
- * `probe` params array absorbs the probe values (the real runtime values are the caller's
- * deferred value-specs). Returns the v1 text — no v2 hand-roll.
- */
-function v1ConditionText(conditions, dialect) {
-    const probe = [];
-    // Pass the dialect cast formatter so `dbCast` gates the `::type` cast per-dialect (PG applies it,
-    // MySQL/SQLite drop it — v1 parity). Inert for every non-cast construct (the formatter is only
-    // consulted by DBCast/DBCastArray), so it stays byte-identical for eq/cmp/BETWEEN/LIKE/etc.
-    return (0, json_array_1.conditionsFor)(conditions, dialect).compile(probe, (0, compile_1.formatterFor)(dialect));
-}
-/**
- * Assemble an AND/OR GROUP's text by driving the ORIGINAL `DBConditions.compile()` — the SAME join
- * + paren-wrapping the v1 eager path performs — NOT a v2 hand-roll (#47 item 5). The already-v1-
- * produced leaf texts are fed as `__raw__` members of a nested `DBConditions` under the group's
- * operator; a parent references that nested group, so v1's own `compileCondition` emits the wrapping
- * `(${nested.compile()})` and `nested.compile()` joins the leaves with ` AND `/` OR ` — i.e. the
- * `(A AND B)` / `(A OR B)` text is byte-produced by v1's builder, not concatenated here.
- *
- * `DBConditions.compile` appends probe values per `__raw__` in encounter order, so the parent probe
- * list length equals the group's total placeholder count; the leaf value-specs (kept 1:1 with those
- * placeholders by the caller) remain the runtime binds — the probe array is throwaway.
- */
-function v1GroupText(op, leafSqls) {
-    const operator = op === 'and' ? 'AND' : 'OR';
-    // Each leaf is a v1-produced predicate string → a `__raw__` member. `add` preserves order and the
-    // nested group's `compile()` joins them with ` ${operator} ` (v1's exact algorithm).
-    const inner = new DBConditions_1.DBConditions({}, operator);
-    for (const sql of leafSqls)
-        inner.add({ __raw__: sql }, operator);
-    // A parent whose sole member is the nested group → v1 wraps it as `(${inner.compile()})`
-    // (DBConditions.compileCondition, the `value instanceof DBConditions` branch) — the group parens.
-    const parent = new DBConditions_1.DBConditions({});
-    parent.add(inner);
-    const probe = [];
-    return parent.compile(probe);
-}
-/** A deferred value-spec that JSON-encodes an array value-spec at runtime (single-param IN). */
-function jsonArraySpec(dialect, valueSpec) {
-    // Marker op the runtime interprets: `{ __jsonArray: <valueSpec>, dialect }`. Postgres keeps
-    // the array as-is (bound as a t[] param via node-postgres); mysql/sqlite JSON-encode it.
-    return { __jsonArray: valueSpec, dialect };
-}
-/**
- * The IN-list membership fragment, driven by the ORIGINAL builders (never hand-rolled):
- *   - MySQL/SQLite: `conditionsFor({col:[…]})` → the single-JSON `JsonArrayConditions` form
- *     (`JSON_TABLE`/`json_each`) — the SAME text the eager path emits; ONE `?`, one JSON param.
- *   - PostgreSQL: the single-array-param form `col = ANY(?)` with NO element-type cast. This
- *     authored `whereIn` surface carries NO column type (spec §7 `inColumn`), so there is nothing
- *     to cast the array TO at compile time — and value-inference (v1's `inferPgArrayType`) cannot
- *     recover it either: `[]` is indistinguishable from any element type, and a uuid value is
- *     indistinguishable-from-text by value. Emitting a cast therefore RE-BROKE #46 twice on live
- *     PG (empty int → `integer = text`; uuid → `uuid = text`). Instead we cast NOTHING and let
- *     PostgreSQL infer the array element type from the column context (`id` int → `int[]`, a uuid
- *     column → `uuid[]`, empty → the column's type → zero rows, no error) — proven on live PG16
- *     for int/bigint/uuid/bool/numeric/text and all three empty cases. This is v1-RESULT-parity
- *     (same rows, incl. empty → zero rows via `1 = 0` in v1): v1's authored surface had no
- *     `= ANY` form (it expanded `IN(?,?,…)`), so byte-identity to a v1 `= ANY(?::T[])` is not the
- *     requirement here — only that the rows match. The array binds verbatim as ONE param.
- */
-function inListFragment(dialect, column, valueSpec) {
-    if (dialect === 'postgres') {
-        // `col = ANY(?)` — no cast. PG infers the array element type from the column, which is correct
-        // for every type INCLUDING empty and uuid (a value-inferred cast cannot, and re-broke #46).
-        const conditions = { __raw__: [`${column} = ANY(?)`, [PROBE]] };
-        return { sql: v1ConditionText(conditions, dialect), params: [jsonArraySpec(dialect, valueSpec)] };
-    }
-    // MySQL/SQLite: the single-JSON IN-list is the JsonArrayConditions form (v1/epic builder).
-    const conditions = { [column]: [PROBE] };
-    return { sql: v1ConditionText(conditions, dialect), params: [jsonArraySpec(dialect, valueSpec)] };
-}
-/**
- * Lower ONE where-member Expression node to a static fragment. The TEXT of every leaf is
- * emitted by the ORIGINAL `DBConditions`; AND/OR groups join the v1-produced leaf texts with
- * the EXACT connector `DBConditions.compile` uses (`parts.join(' AND '|' OR ')` + wrapping
- * parens) — pure text glue, the original's own algorithm (mirrors `compile-pg.compileBaseSelect`).
- */
-function lowerWhereMember(node, dialect, at) {
-    const op = opKey(node);
-    if (op === undefined)
-        throw new Error(`static-bundle: ${at}: a where member must be a single-operator Expression node`);
-    if (op === 'and' || op === 'or') {
-        const args = node[op];
-        if (!Array.isArray(args) || args.length < 2)
-            throw new Error(`static-bundle: ${at}: '${op}' group expects >= 2 members`);
-        const parts = [];
-        const params = [];
-        args.forEach((m, i) => {
-            const f = lowerWhereMember(m, dialect, `${at}.${op}[${i}]`);
-            parts.push(f.sql);
-            params.push(...f.params);
-        });
-        // Assemble the group text through the ORIGINAL `DBConditions` join + paren-wrap (item 5) — NOT
-        // a v2 `parts.join(connector)` hand-roll. The v1-produced leaf texts keep their `?` order, so
-        // the deferred value-specs (`params`) still bind 1:1 with the placeholders in the assembled sql.
-        return { sql: v1GroupText(op, parts), params };
-    }
-    if (op === 'eq') {
-        const [col, val] = binOperands(node, op, at);
-        // Additive where-primitives (V0 R2/R3) — decoded FIRST (an IMMEDIATE/EXISTS primitive carries a
-        // `null` RHS that would otherwise be mis-read as IS NULL).
-        const inCol = inSentinelColumn(col);
-        if (inCol !== undefined)
-            return inListFragment(dialect, inCol, val);
-        const additive = decodeSentinel(col, val, dialect, at);
-        if (additive !== undefined)
-            return additive;
-        const column = columnOf(col, at);
-        if (val === null)
-            return { sql: v1ConditionText({ [column]: null }, dialect), params: [] };
-        // v1 default equality: `{col: value}` → `col = ?`.
-        return { sql: v1ConditionText({ [column]: PROBE }, dialect), params: [val] };
-    }
-    if (op in CMP_OPS) {
-        const [col, val] = binOperands(node, op, at);
-        const column = columnOf(col, at);
-        if (op === 'ne' && val === null) {
-            // v1 `IS NOT NULL`: a boolean-true key that is a SQL expression returns the key verbatim.
-            return { sql: v1ConditionText({ [`${column} IS NOT NULL`]: true }, dialect), params: [] };
-        }
-        // v1 comparison: a custom-operator key (`col <op> ?`) returns the key + pushes the value.
-        return { sql: v1ConditionText({ [`${column} ${CMP_OPS[op]} ?`]: PROBE }, dialect), params: [val] };
-    }
-    throw new Error(`static-bundle: ${at}: unsupported where operator '${op}' (supported: eq/ne/lt/le/gt/ge/and/or; IN via ${tx_1.IN_SENTINEL}; IS NULL via eq(col,null))`);
-}
-/**
- * Lower the `where` port to a list of `{ sql, params, skip? }` fragment statements. A
- * `{cond:[c, member, null]}` SKIP-optional member lowers its inner member and attaches `c`
- * as the fragment's `skip` presence expression (dropped at runtime when `c` is null/false).
- * The FIRST present fragment carries no leading connector; every later one carries ` AND `.
- */
-function lowerWherePort(ports, dialect, at) {
-    const arr = arrPort(ports, 'where');
-    if (arr === undefined || arr.length === 0)
-        return [];
-    // Each member becomes a fragment statement. The leading ` WHERE `/` AND ` connectors are
-    // resolved at runtime from the PRESENT set (a compile-time connector would be wrong when an
-    // earlier fragment skips). We therefore mark each fragment and let the assembler join them.
-    const fragments = [];
-    arr.forEach((m, i) => {
-        const memberAt = `${at}.where[${i}]`;
-        if (opKey(m) === 'cond') {
-            const cargs = m.cond;
-            if (!Array.isArray(cargs) || cargs.length !== 3 || cargs[2] !== null) {
-                throw new Error(`static-bundle: ${memberAt}: a SKIP-optional condition must be {cond:[c, <member>, null]} (else = null)`);
-            }
-            const inner = lowerWhereMember(cargs[1], dialect, `${memberAt}.cond.then`);
-            fragments.push({ sql: inner.sql, params: inner.params, skip: skipFrom(cargs[0]) });
-            return;
-        }
-        const f = lowerWhereMember(m, dialect, memberAt);
-        fragments.push({ sql: f.sql, params: f.params });
-    });
-    return fragments.map((f) => ({ sql: f.sql, params: f.params, ...(f.skip !== undefined ? { skip: f.skip } : {}) }));
-}
-/**
- * Turn a SKIP-`cond` guard condition `c` (present iff `c` is a present binding) into a bc
- * `skip` expression: the statement is SKIPPED when the guard is ABSENT, i.e. `skip = not(c)`.
- * `c` is a closed-set bc Expression (e.g. `{ne:[{refOpt:['status']}, null]}`).
- */
-function skipFrom(guard) {
-    return { not: [guard] };
-}
-// ── Node → static statements (SELECT read path) ────────────────────────────────
-/**
- * The ORIGINAL `_buildSelectSQL` GROUP BY / ORDER BY append text for a Select tail fragment.
- * Drives `compileSelect` (a bare `SELECT * FROM <t>` head + the one tail field) and slices off
- * the shared head, so the remaining ` GROUP BY …` / ` ORDER BY …` is v1's exact append — never
- * a v2 hand-roll. The head is always `SELECT * FROM <table>` here (no `select`/conditions given).
- */
-function selectTail(desc, table) {
-    const full = (0, compile_select_1.compileSelect)(desc).sql;
-    const head = `SELECT * FROM ${table}`;
-    return full.startsWith(head) ? full.slice(head.length) : full;
-}
-/**
- * The ` LIMIT `/` OFFSET ` KEYWORD text sourced from the ORIGINAL `_buildSelectSQL` (via
- * `compileSelect`) — item 5. v1 INLINES the count as a literal (` LIMIT 10`); the static bundle
- * keeps the INTENTIONAL divergence of binding it as a `?` deferred value-spec (a portable equivalent
- * every language runtime renders identically, evaluated per-input). So we drive v1 with a sentinel
- * count, take v1's exact ` LIMIT <n>`/` OFFSET <n>` append, and swap the sentinel for `?` — the
- * keyword text is v1's, only the literal becomes a placeholder. Documented, all-dialect parity-checked.
- */
-function limitOffsetTail(kind, dialect, table) {
-    const SENTINEL = 987654321; // a distinctive count with no substring clash in the keyword text
-    const desc = kind === 'limit' ? { dialect, tableName: table, limit: SENTINEL } : { dialect, tableName: table, offset: SENTINEL };
-    const tail = selectTail(desc, table); // v1's ` LIMIT 987654321` / ` OFFSET 987654321`
-    return tail.replace(String(SENTINEL), '?'); // keep the bound-param behavior; keyword text is v1's
-}
-/**
- * Compile ONE authored `Select` node into its static `makeSQL` statement templates:
- * the head `SELECT … FROM t` fragment plus one guarded WHERE fragment per member, then the
- * trailing GROUP BY / ORDER BY / LIMIT / OFFSET tail. The head + GROUP BY + ORDER BY TEXT is
- * produced by the ORIGINAL `compileSelect` (which reproduces `_buildSelectSQL` byte-for-byte),
- * never a v2 hand-roll. LIMIT/OFFSET are INLINE literals in v1; for the static bundle they are
- * deferred value-specs bound as `?` (a portable equivalent a per-language runtime renders
- * identically) — evaluated at runtime.
- */
-function compileSelectNode(node, dialect) {
-    const { component, ports } = nodeRef(node);
-    if (component !== 'Select' && component !== 'Count') {
-        throw new Error(`static-bundle: compileSelectNode only compiles Select/Count nodes (got '${component}')`);
-    }
-    const table = stringPort(ports, 'table');
-    if (table === undefined)
-        throw new Error(`static-bundle: ${component} node requires a literal 'table' port`);
-    // A `Count` node projects `COUNT(*) as count` (v1 `DBModel._count`: `SELECT COUNT(*) as count
-    // FROM t`), a `Select` its own column list (default `*`). Both heads go through the ORIGINAL
-    // `compileSelect`, so the text is v1-sourced (count head byte-identical to `_count`).
-    const isCount = component === 'Count';
-    const select = stringArrayPort(ports, 'select');
-    const cols = isCount ? 'COUNT(*) as count' : select && select.length > 0 ? select.join(', ') : '*';
-    const statements = [];
-    // Head `[WITH …] SELECT <cols> FROM <t>[ JOIN …]` — driven by the ORIGINAL `_buildSelectSQL` (via
-    // compileSelect, no WHERE/tail) so the skeleton text is byte-identical to v1. The optional
-    // `cte`/`join` head fields (V0 R4/R5) are v1-sourced from the SAME `SelectDesc`; the `?`
-    // placeholders in their raw text bind to the deferred `cteParams`/`joinParams` value-specs (v1
-    // param order: CTE → JOIN → WHERE). `select` carries the joined-column projection as authored.
-    const cte = mapPort(ports, 'cte');
-    const join = stringPort(ports, 'join');
-    const cteParams = exprArrayPort(ports, 'cteParams');
-    const joinParams = exprArrayPort(ports, 'joinParams');
-    const headDesc = { dialect, tableName: table, select: cols };
-    if (cte !== undefined)
-        headDesc.cte = { name: cte.name, sql: cte.sql, params: [] };
-    if (join !== undefined)
-        headDesc.join = join;
-    const headParams = [...(cteParams ?? []), ...(joinParams ?? [])];
-    statements.push({ sql: (0, compile_select_1.compileSelect)(headDesc).sql, params: headParams });
-    const whereFrags = lowerWherePort(ports, dialect, component);
-    for (const frag of whereFrags) {
-        // A bare predicate body flagged `whereFragment`; the runtime resolves the ` WHERE `/` AND `
-        // connector from the present set (a compile-time connector would be wrong when an earlier
-        // fragment skips).
-        statements.push({ sql: frag.sql, params: frag.params, whereFragment: true, ...(frag.skip !== undefined ? { skip: frag.skip } : {}) });
-    }
-    // A Count carries no projection/order/limit/offset tail (v1 `_count` is `COUNT(*)` + WHERE only).
-    if (isCount)
-        return statements;
-    // GROUP BY / ORDER BY tail — the ORIGINAL `_buildSelectSQL` append text (via compileSelect over
-    // a bare table, then slicing off the leading `SELECT * FROM <t>` head it shares).
-    const group = stringPort(ports, 'group');
-    if (group !== undefined)
-        statements.push({ sql: selectTail({ dialect, tableName: table, group }, table), params: [] });
-    const order = stringPort(ports, 'order');
-    if (order !== undefined)
-        statements.push({ sql: selectTail({ dialect, tableName: table, order }, table), params: [] });
-    // LIMIT/OFFSET: the ` LIMIT `/` OFFSET ` keyword text is v1-sourced (via compileSelect), the count
-    // stays a bound `?` value-spec (the intentional portable divergence from v1's literal inlining).
-    if (ports.limit !== undefined)
-        statements.push({ sql: limitOffsetTail('limit', dialect, table), params: [ports.limit] });
-    if (ports.offset !== undefined)
-        statements.push({ sql: limitOffsetTail('offset', dialect, table), params: [ports.offset] });
-    // FOR UPDATE / append (V0 R3/R6) — v1 `_buildSelectSQL` tail order is `… FOR UPDATE <append>`.
-    // Both are v1-sourced via `selectTail` (a bare-head compileSelect, head sliced off). `append`
-    // (e.g. HAVING) is raw trailing text with no bound param on this authored surface.
-    const forUpdate = stringPort(ports, 'forUpdate');
-    if (forUpdate === 'true')
-        statements.push({ sql: selectTail({ dialect, tableName: table, forUpdate: true }, table), params: [] });
-    const append = stringPort(ports, 'append');
-    if (append !== undefined)
-        statements.push({ sql: selectTail({ dialect, tableName: table, append }, table), params: [] });
-    return statements;
-}
-// ── Compile a behavior method → static bundle (CRUD primary node) ──────────────
-/**
- * Compile ONE authored primary catalog node into its static `makeSQL` statement templates. A
- * `Select` lowers to the fragment/tail statements ({@link compileSelectNode}); a single
- * `Insert`/`Update`/`Delete` lowers via the SAME symbolic write compile the write-tx spine uses
- * ({@link compileWriteNode} in `./tx` — complete tuned SQL text + deferred Expression-IR params),
- * yielding ONE statement. This is the makeSQL SCP path for a standalone CRUD query (a Command
- * with write-time relations rides the tx-DAG plan, not this single-statement path).
- */
-function compilePrimaryNode(node, dialect) {
-    const component = 'map' in node ? node.map.component : node.component;
-    if (component === 'Select' || component === 'Count')
-        return compileSelectNode(node, dialect);
-    if (component === 'Insert' || component === 'Update' || component === 'Delete') {
-        const op = (0, tx_2.compileWriteNode)(node, dialect);
-        return [{ sql: op.sql, params: op.params }];
-    }
-    throw new Error(`static-bundle: catalog component '${component}' has no makeSQL compile (SQL CRUD only: Select/Count/Insert/Update/Delete)`);
-}
-/**
- * Compile the primary CRUD query of an authored behavior method into a {@link StaticBundle}.
- * Relation `.map` nodes are NOT part of the primary bundle (they are the read-relations concern
- * — step 3, still on the reduced spine). The compile is SYMBOLIC (no concrete input); the runtime
- * ({@link executeStaticBundle} for reads / {@link executeStaticWrite} for writes) evaluates skip +
- * value-specs per-input.
- */
-function compileStaticBundle(contract, dialect, entry) {
-    const component = entry ? contract.components.find((c) => c.name === entry) : contract.components[0];
-    if (component === undefined)
-        throw new Error(`static-bundle: entry component '${entry ?? '<first>'}' not found in contract`);
-    let primary;
-    for (const n of component.body) {
-        if ('cond' in n)
-            continue;
-        if (isMap(n))
-            continue;
-        if (primary === undefined)
-            primary = n;
-    }
-    if (primary === undefined)
-        throw new Error(`static-bundle: behavior '${component.name}' has no primary catalog node`);
-    const statements = compilePrimaryNode(primary, dialect);
-    return {
-        dialect,
-        name: component.name,
-        statements,
-        optionalHeads: [...optionalHeadsOf(component, statements)],
-    };
-}
-// ── Optional-head detection (SSoT-driven, mirrors ../runtime.optionalHeadsOf) ──
-/**
- * The OPTIONAL input heads to normalize to present-as-null (absent-key SKIP): the
- * schema-optional ports, the SKIP-`cond`-guarded heads (a guard declares its driving input
- * optional — spec §7), AND every head accessed via `refOpt` in a value-spec or skip expression
- * (the author reached for `opt(…)`/`refOpt` precisely because the binding may be absent — e.g. a
- * `coalesce`-defaulted LIMIT). bc's `evaluateExpression` fail-closes on an absent head even
- * under `refOpt`, so these must be pre-normalized to null. A REQUIRED, non-refOpt head that is
- * missing is left absent so a real wiring bug surfaces loudly. This is SSoT-driven (the
- * schema/guard/refOpt IS the optionality declaration), never an ad-hoc code default.
- */
-function optionalHeadsOf(component, statements) {
-    const optional = new Set();
-    for (const [port, schema] of Object.entries(component.inputPorts)) {
-        if (schema.required !== true)
-            optional.add(port);
-    }
-    for (const n of component.body)
-        skipGuardHeads(n, optional);
-    for (const stmt of statements) {
-        for (const p of stmt.params)
-            collectRefOptHeads(p, optional);
-        if (stmt.skip !== undefined)
-            collectRefOptHeads(stmt.skip, optional);
-    }
-    return optional;
-}
-/** Collect every path HEAD accessed via `refOpt` in an Expression IR node. */
-function collectRefOptHeads(node, into) {
-    if (node === null || typeof node !== 'object')
-        return;
-    if (Array.isArray(node)) {
-        for (const e of node)
-            collectRefOptHeads(e, into);
-        return;
-    }
-    const keys = Object.keys(node);
-    if (keys.length === 1 && keys[0] === 'refOpt') {
-        const path = node.refOpt;
-        if (Array.isArray(path) && path.length > 0 && typeof path[0] === 'string')
-            into.add(path[0]);
-        return;
-    }
-    for (const v of Object.values(node))
-        collectRefOptHeads(v, into);
-}
-function skipGuardHeads(n, into) {
-    if ('cond' in n)
-        return;
-    const ports = isMap(n) ? n.map.ports : n.ports;
-    const where = ports.where;
-    if (typeof where !== 'object' || where === null || !('arr' in where))
-        return;
-    const arr = where.arr;
-    if (!Array.isArray(arr))
-        return;
-    for (const m of arr) {
-        if (opKey(m) === 'cond') {
-            const cond = m.cond;
-            if (Array.isArray(cond) && cond.length === 3)
-                collectRefHeads(cond[0], into);
-        }
-    }
-}
-function collectRefHeads(node, into) {
-    if (node === null || typeof node !== 'object')
-        return;
-    if (Array.isArray(node)) {
-        for (const e of node)
-            collectRefHeads(e, into);
-        return;
-    }
-    const op = opKey(node);
-    if (op === 'ref' || op === 'refOpt') {
-        const path = node[op];
-        if (Array.isArray(path) && path.length > 0 && typeof path[0] === 'string')
-            into.add(path[0]);
-        return;
-    }
-    for (const v of Object.values(node))
-        collectRefHeads(v, into);
-}
-// ── FIND_FILTER leak guard: authored WHERE column keys (fail-closed model-scope enforcement) ──
-/**
- * Collect the top-level COLUMN names an authored `where` port constrains — the LHS column of each
- * eq/ne/cmp member, the IN-sentinel column, and (recursively) the columns of `and`/`or` groups and
- * SKIP-`cond` members. This is exactly the key set v1 compares against when it folds a model's
- * `FIND_FILTER` into the WHERE (`condsToRecord(FIND_FILTER)` keys vs the compiled predicate), so the
- * {@link assertFindFilterFolded} guard can fail-closed when a FIND_FILTER model is SCP-compiled
- * without its scope predicates folded in. Additive sentinel primitives (immediate/dynamic/exists/…)
- * carry no plain column key and are skipped — a scope key must be an ordinary eq/cmp/in the author
- * expressed, matching how a FIND_FILTER predicate manifests.
- */
-function whereMemberColumns(node, into) {
-    const op = opKey(node);
-    if (op === undefined)
-        return;
-    if (op === 'and' || op === 'or') {
-        const args = node[op];
-        if (Array.isArray(args))
-            for (const m of args)
-                whereMemberColumns(m, into);
-        return;
-    }
-    if (op === 'cond') {
-        const cargs = node.cond;
-        if (Array.isArray(cargs) && cargs.length === 3)
-            whereMemberColumns(cargs[1], into);
-        return;
-    }
-    if (op === 'eq' || op in CMP_OPS) {
-        const args = node[op];
-        if (!Array.isArray(args) || args.length !== 2)
-            return;
-        const inCol = inSentinelColumn(args[0]);
-        if (inCol !== undefined) {
-            into.add(inCol);
-            return;
-        }
-        // A plain column ref LHS (a bare eq/cmp). An additive sentinel LHS (immediate/dynamic/exists/…)
-        // is NOT a plain column — its column key would be encoded in the primitive, so it is skipped
-        // (a FIND_FILTER scope key is always an ordinary eq/cmp/IS NULL the author must fold explicitly).
-        const lhsOp = opKey(args[0]);
-        if (lhsOp === 'ref' || lhsOp === 'refOpt') {
-            const path = args[0][lhsOp];
-            if (Array.isArray(path) && path.length > 0 && typeof path[path.length - 1] === 'string' && path[0] !== tx_1.IN_SENTINEL) {
-                into.add(path[path.length - 1]);
-            }
-        }
-    }
-}
-/** The authored WHERE column-key set of a read node's `where` port (for the FIND_FILTER guard). */
-function authoredWhereKeysOf(ports) {
-    const keys = new Set();
-    const arr = arrPort(ports, 'where');
-    if (arr === undefined)
-        return keys;
-    for (const m of arr)
-        whereMemberColumns(m, keys);
-    return keys;
-}
-// ── Runtime: evaluate value-specs + skip per-input, assemble, render, execute ──
-/** bc evaluates ints to bigint; convert a rendered param to a driver-bindable value. */
-function toDriverParam(v) {
-    if (typeof v === 'bigint') {
-        if (v >= BigInt(Number.MIN_SAFE_INTEGER) && v <= BigInt(Number.MAX_SAFE_INTEGER))
-            return Number(v);
-        return v;
-    }
-    return v;
-}
-/** Evaluate one deferred value-spec against the input scope (handling the JSON-array marker). */
-function evalSpec(spec, scope) {
-    if (spec !== null && typeof spec === 'object' && !Array.isArray(spec) && '__jsonArray' in spec) {
-        const marker = spec;
-        const arr = (0, behavior_contracts_1.evaluateExpression)(marker.__jsonArray, scope);
-        if (!Array.isArray(arr))
-            throw new Error('static-bundle: IN-list value-spec did not evaluate to an array');
-        if (marker.dialect === 'postgres')
-            return arr.map((e) => toDriverParam(e));
-        // MySQL/SQLite single-JSON IN-list param. A BOOLEAN element is encoded as `1`/`0` for MySQL
-        // (NOT JSON `true`/`false`): MySQL's `JSON_UNQUOTE(v)` yields the STRING `'true'`, which coerces
-        // to `0` against a TINYINT(1) — a silent mismatch. `1`/`0` is exactly what v1's `col IN (?)`
-        // bound (mysql2 sends a JS bool as `1`/`0`), preserving v1 RESULT parity. SQLite's `json_each`
-        // coerces JSON booleans natively, so it keeps the plain form.
-        const encodeElem = (e) => marker.dialect === 'mysql' && typeof e === 'boolean' ? (e ? 1 : 0) : toDriverParam(e);
-        return JSON.stringify(arr.map(encodeElem));
-    }
-    return toDriverParam((0, behavior_contracts_1.evaluateExpression)(spec, scope));
-}
-/**
- * Evaluate a list of statement templates against a scope: drop skipped statements (skip
- * expression truthy), resolve each surviving statement's WHERE-role connector from the present
- * set, build concrete `makeSQL` nodes, assemble + render to the dialect placeholder form.
- */
-function renderStatements(statements, dialect, scope) {
-    const nodes = [];
-    let whereSeen = false;
-    for (const stmt of statements) {
-        if (stmt.skip !== undefined) {
-            const drop = (0, behavior_contracts_1.evaluateExpression)(stmt.skip, scope);
-            if (drop !== null && drop !== false)
-                continue;
-        }
-        let sql = stmt.sql;
-        if (stmt.whereFragment === true) {
-            sql = (whereSeen ? ' AND ' : ' WHERE ') + stmt.sql;
-            whereSeen = true;
-        }
-        const params = stmt.params.map((p) => evalSpec(p, scope));
-        // The authored PG IN-list emits `col = ANY(?)` with NO cast token (#46 — PG infers the array
-        // element type from the column, correct for empty/uuid where value-inference cannot). No
-        // render-time cast resolution is needed here; the relation-batch path resolves its own v1
-        // `::T[]` cast in `runRelationOp`, not on this authored-statement surface.
-        nodes.push({ sql, params });
-    }
-    const assembled = (0, makesql_1.composeMakeSQL)(nodes);
-    return { sql: (0, handler_1.renderPlaceholders)(assembled.sql, dialect), params: assembled.params };
-}
-/** Evaluate a whole bundle's statements against the input scope (convenience over the list). */
-function renderBundle(bundle, scope) {
-    return renderStatements(bundle.statements, bundle.dialect, scope);
-}
-/** Normalize omitted OPTIONAL heads to present-as-null (absent-key SKIP; SSoT-driven). */
-function normalizeInput(bundle, input) {
-    const out = { ...input };
-    for (const head of bundle.optionalHeads) {
-        if (!(head in out))
-            out[head] = null;
-    }
-    return out;
-}
-/**
- * Execute a {@link StaticBundle} read query end-to-end against real SQLite: normalize optional
- * heads, evaluate skip + value-specs per-input, assemble present fragments, render, and run the
- * SELECT. Returns the row list.
- */
-function executeStaticBundle(bundle, input, db) {
-    const scope = normalizeInput(bundle, input);
-    const { sql, params } = renderBundle(bundle, scope);
-    let stmt;
-    try {
-        stmt = db.prepare(sql);
-        return stmt.all(...params);
-    }
-    catch (e) {
-        throw (0, errors_1.mapSqliteError)(e);
-    }
-}
-/**
- * Execute a single-statement WRITE {@link StaticBundle} (Insert/Update/Delete) against real
- * SQLite: evaluate the deferred value-specs per-input, render, and run the statement. A statement
- * with a RETURNING tail returns its rows; a non-returning write returns a single-row summary
- * `[{ changes, lastInsertRowid }]`. A driver error maps to a {@link SqlFailure} at the boundary.
- * (A Command with write-time relations rides the tx-DAG plan of `./tx`, not this path.)
- */
-function executeStaticWrite(bundle, input, db) {
-    const scope = normalizeInput(bundle, input);
-    const { sql, params } = renderBundle(bundle, scope);
-    const hasReturn = /\breturning\b/i.test(sql);
-    try {
-        const stmt = db.prepare(sql);
-        if (hasReturn)
-            return stmt.all(...params);
-        const info = stmt.run(...params);
-        return [{ changes: info.changes, lastInsertRowid: toDriverParam(BigInt(info.lastInsertRowid)) }];
-    }
-    catch (e) {
-        throw (0, errors_1.mapSqliteError)(e);
-    }
-}
-// ============================================================================
-// Step 0 — the bc-runBehavior read executor: bc composes (map / Φ-merge / wiring),
-// makeSQL executes. A read behavior method whose output is a Φ-merge of SQL nodes
-// (`{obj:{posts:ref[n0], authors:map(n0)}}`) is executed by rewriting each SQL node
-// to a `makeSQL` node carrying a synthetic `__scope` port and running bc `runBehavior`
-// with a handler that renders that node's static statements against the evaluated scope.
-// This gives map iteration + Φ output + wiring FOR FREE (bc owns orchestration).
-// ============================================================================
-/** The synthetic port that carries a SQL node's render scope (bc evaluates it in-scope). */
-const SCOPE_PORT = '__scope';
-/** The makeSQL catalog leaf name every rewritten SQL node references. */
-const NODE_COMPONENT = '__makeSqlNode';
-/** Collect every ref/refOpt path HEAD used inside an Expression IR node. */
-function collectAllHeads(node, heads) {
-    if (node === null || typeof node !== 'object')
-        return;
-    if (Array.isArray(node)) {
-        for (const el of node)
-            collectAllHeads(el, heads);
-        return;
-    }
-    const keys = Object.keys(node);
-    if (keys.length === 1 && (keys[0] === 'ref' || keys[0] === 'refOpt')) {
-        const path = node[keys[0]];
-        if (Array.isArray(path) && typeof path[0] === 'string')
-            heads.add(path[0]);
-        return;
-    }
-    for (const k of keys)
-        collectAllHeads(node[k], heads);
-}
-/** Every binding head a node's compiled statements reference (params + skip). */
-function statementHeads(statements) {
-    const heads = new Set();
-    for (const stmt of statements) {
-        for (const p of stmt.params)
-            collectAllHeads(p, heads);
-        if (stmt.skip !== undefined)
-            collectAllHeads(stmt.skip, heads);
-    }
-    return heads;
-}
-/**
- * Build the surrogate `__scope` port for a node: a bc `{obj:{…}}` re-exporting each referenced
- * head as `{ref:[head]}` (excluding the IN-sentinel column marker). bc evaluates this in ITS
- * scope (so `input`, sibling wire results and the `map` element `as` all resolve), then the
- * handler renders the node's static statements against the resulting plain scope.
- */
-function scopePort(statements) {
-    const obj = {};
-    for (const head of statementHeads(statements)) {
-        if (head === tx_1.IN_SENTINEL)
-            continue;
-        obj[head] = { ref: [head] };
-    }
-    return { obj };
-}
-/** Compile ONE authored SQL node (Select or CRUD write) into its static statements. */
-function compileNodeStatements(node, dialect) {
-    const component = 'map' in node ? node.map.component : node.component;
-    if (component === 'Select' || component === 'Count')
-        return compileSelectNode(node, dialect);
-    const op = (0, tx_2.compileWriteNode)(node, dialect);
-    return [{ sql: op.sql, params: op.params }];
-}
-/**
- * Compile a READ behavior method into a portable {@link ReadGraph}: rewrite each authored SQL
- * body node to a `makeSQL` node carrying a synthetic `__scope` port (bc evaluates it in-scope),
- * and compile each node's static statements ONCE. SYMBOLIC — no concrete input. bc will own map
- * iteration / wire binding / Φ output at execute time; the handler renders each node's statements.
- */
-function compileReadGraph(contract, dialect, entry, findFilterModel, resolveColumnType) {
-    const component = entry ? contract.components.find((c) => c.name === entry) : contract.components[0];
-    if (component === undefined)
-        throw new Error(`static-bundle: entry component '${entry ?? '<first>'}' not found in contract`);
-    // FIND_FILTER fail-closed guard (M2): when a `DBModel`-shaped source that DECLARES a `FIND_FILTER`
-    // (soft-delete / tenant scope) is routed through the SCP read compile, its scope predicates MUST be
-    // folded into the authored `where` of every read node — the SCP compile has no model context to
-    // auto-apply them (see find-filter-guard.ts). If any read node's authored WHERE omits a scope key,
-    // `assertFindFilterFolded` throws (never a silent cross-tenant / soft-deleted leak). No model
-    // supplied ⇒ nothing to enforce (the guard is a no-op for a model with no FIND_FILTER either way).
-    if (findFilterModel !== undefined) {
-        for (const n of component.body) {
-            if ('cond' in n)
-                continue;
-            const ref = 'map' in n ? n.map : n;
-            if (ref.component !== 'Select' && ref.component !== 'Count')
-                continue;
-            (0, find_filter_guard_1.assertFindFilterFolded)(findFilterModel, authoredWhereKeysOf(ref.ports));
-        }
-    }
-    const statementsById = {};
-    for (const n of component.body) {
-        if ('cond' in n)
-            continue;
-        statementsById[n.id] = compileNodeStatements(n, dialect);
-    }
-    // Typed-codegen `outType`/`outputType` annotations (spec §4.1; #58/#56). Derived from the ORIGINAL
-    // body (real `table`/`select` ports) so bc's typed-raw de-box emitters can materialize concrete
-    // row structs instead of hard-failing ("nothing to de-box"). Only when a column-type resolver (the
-    // schema/DDL SoT) is supplied — without it the read graph stays un-annotated (interpret path only;
-    // typed codegen then fail-closes downstream, never silently boxes). Any ambiguity throws here.
-    const outTypes = resolveColumnType !== undefined ? (0, outtype_1.deriveReadOutTypes)(component, resolveColumnType) : undefined;
-    const surrogateBody = component.body.map((n) => {
-        if ('cond' in n)
-            return n;
-        const stmts = statementsById[n.id];
-        const outType = outTypes?.byNode.get(n.id);
-        const outAnn = outType !== undefined ? { outType } : {};
-        if ('map' in n) {
-            return { ...n, ...outAnn, map: { ...n.map, component: NODE_COMPONENT, ports: { [SCOPE_PORT]: scopePort(stmts) } } };
-        }
-        return { ...n, ...outAnn, component: NODE_COMPONENT, ports: { [SCOPE_PORT]: scopePort(stmts) } };
-    });
-    const surrogate = {
-        ...component,
-        body: surrogateBody,
-        ...(outTypes !== undefined ? { outputType: outTypes.outputType } : {}),
-    };
-    const ir = { irVersion: 1, exprVersion: 2, components: [surrogate] };
-    return {
-        dialect,
-        name: component.name,
-        ir,
-        statementsById,
-        optionalHeads: [...optionalHeadsOfComponent(component, dialect)],
-    };
-}
-/**
- * Execute a compiled {@link ReadGraph} via bc `runBehavior` + a makeSQL handler: bc drives map
- * iteration / wire binding / Φ output; the handler renders each node's static statements against
- * the evaluated `__scope` and runs REAL SQLite. Returns the component's Φ output. This is the
- * design's "bc composes, makeSQL executes" — the SAME path a per-language runtime follows.
- */
-function executeReadGraph(graph, input, db) {
-    const handle = (ports, ctx) => {
-        const stmts = graph.statementsById[ctx.nodeId];
-        if (stmts === undefined)
-            return { error: `static-bundle: no statements for node '${ctx.nodeId}'` };
-        const scope = ports[SCOPE_PORT];
-        if (scope === null || typeof scope !== 'object' || Array.isArray(scope)) {
-            return { error: `static-bundle: node '${ctx.nodeId}' surrogate scope did not evaluate to an object` };
-        }
-        const { sql, params } = renderStatements(stmts, graph.dialect, scope);
-        try {
-            const rows = db.prepare(sql).all(...params);
-            return { ok: rows };
-        }
-        catch (e) {
-            return { error: (0, errors_1.mapSqliteError)(e).message };
-        }
-    };
-    const handlers = { [NODE_COMPONENT]: handle };
-    const normalized = { ...input };
-    for (const head of graph.optionalHeads)
-        if (!(head in normalized))
-            normalized[head] = null;
-    try {
-        return (0, behavior_contracts_1.runBehavior)(graph.ir, handlers, normalized, graph.name);
-    }
-    catch (e) {
-        throw reErrorToSqlFailure(e);
-    }
-}
-/**
- * Async twin of {@link executeReadGraph} — the PG / MySQL execution model (#40).
- *
- * Byte-identical composition (SAME IR, SAME per-node SQL text + params, SAME Φ output), but bc's
- * `runBehaviorAsync` drives it: the makeSQL handler returns a Promise, and bc dispatches the
- * INDEPENDENT sibling nodes of a plan stage on `runPlanAsync`'s bounded-parallel path (bc#23),
- * bounded by the plan's `concurrency` (default 16). Against a pooled async driver (`pg` / `mysql2`,
- * each `exec` call resolving on its own pooled connection), that becomes REAL parallel read-relation
- * DB I/O — the plan's declared concurrency finally cashes out as concurrent dispatch. The result is
- * deterministic (bc commits stage outcomes in declaration order), so it equals the serial
- * `executeReadGraph` output exactly; only the wall-clock changes.
- *
- * The conformance bar stays on the SYNC in-proc better-sqlite3 path (`executeReadGraph`); this async
- * path is the live PG/MySQL execution model and is proven by the latency-injecting concurrency test.
- */
-async function executeReadGraphAsync(graph, input, exec) {
-    const handle = async (ports, ctx) => {
-        const stmts = graph.statementsById[ctx.nodeId];
-        if (stmts === undefined)
-            return { error: `static-bundle: no statements for node '${ctx.nodeId}'` };
-        const scope = ports[SCOPE_PORT];
-        if (scope === null || typeof scope !== 'object' || Array.isArray(scope)) {
-            return { error: `static-bundle: node '${ctx.nodeId}' surrogate scope did not evaluate to an object` };
-        }
-        const { sql, params } = renderStatements(stmts, graph.dialect, scope);
-        try {
-            const rows = await exec(sql, params);
-            return { ok: rows };
-        }
-        catch (e) {
-            return { error: (0, errors_1.mapSqliteError)(e).message };
-        }
-    };
-    const handlers = { [NODE_COMPONENT]: handle };
-    const normalized = { ...input };
-    for (const head of graph.optionalHeads)
-        if (!(head in normalized))
-            normalized[head] = null;
-    try {
-        return await (0, behavior_contracts_1.runBehaviorAsync)(graph.ir, handlers, normalized, graph.name);
-    }
-    catch (e) {
-        throw reErrorToSqlFailure(e);
-    }
-}
-/**
- * Convenience: compile + execute a READ behavior method whose output may be a Φ-merge of SQL
- * nodes (including relation `.map` nodes). Equivalent to `executeReadGraph(compileReadGraph(...))`.
- */
-function executeReadBehavior(contract, input, dialect, db, entry) {
-    return executeReadGraph(compileReadGraph(contract, dialect, entry), input, db);
-}
-/**
- * Render the PRIMARY read node's statements of a {@link ReadGraph} against an input scope to its
- * dialect SQL text + bound params (the render axis for conformance golden). The primary node is
- * the first non-map body node (the root SELECT the relations map over). Optional heads are
- * normalized to present-as-null first (absent-key SKIP), so an omitted optional head renders the
- * SAME text a runtime would produce.
- */
-function renderReadPrimary(graph, input) {
-    const ids = Object.keys(graph.statementsById);
-    // The primary node is the first body node in the surrogate IR order (map nodes reference it).
-    const bodyIds = graph.ir.components[0].body.map((n) => n.id).filter((id) => ids.includes(id));
-    const primaryId = bodyIds[0];
-    if (primaryId === undefined)
-        throw new Error('static-bundle: read graph has no primary node to render');
-    const scope = { ...input };
-    for (const head of graph.optionalHeads)
-        if (!(head in scope))
-            scope[head] = null;
-    return renderStatements(graph.statementsById[primaryId], graph.dialect, scope);
-}
-/** Optional heads across ALL SQL nodes of a component (schema + SKIP-guard + refOpt). */
-function optionalHeadsOfComponent(component, dialect) {
-    const optional = new Set();
-    for (const [port, schema] of Object.entries(component.inputPorts)) {
-        if (schema.required !== true)
-            optional.add(port);
-    }
-    for (const n of component.body)
-        skipGuardHeads(n, optional);
-    for (const n of component.body) {
-        if ('cond' in n)
-            continue;
-        const stmts = compileNodeStatements(n, dialect);
-        for (const stmt of stmts) {
-            for (const p of stmt.params)
-                collectRefOptHeads(p, optional);
-            if (stmt.skip !== undefined)
-                collectRefOptHeads(stmt.skip, optional);
-        }
-    }
-    return optional;
-}
-/** Re-surface a mapped SqlFailure from a runBehavior OP_FAILED message (SQLITE_* code embedded). */
-function reErrorToSqlFailure(e) {
-    const message = e instanceof Error ? e.message : String(e);
-    const m = /(SQLITE_[A-Z_]+)/.exec(message);
-    if (m)
-        return (0, errors_1.mapSqliteError)({ code: m[1], message });
-    return e;
-}
-//# sourceMappingURL=static-bundle.js.map