litedbmodel 2.0.0 → 2.0.2

package/dist/scp/makesql/makesql.d.ts

@@ -0,0 +1,99 @@
+/**
+ * litedbmodel v2 SCP — the LOCKED minimal bc integration: ONE catalog component
+ * **`makeSQL(sql, params, skip?)`** (a behavior-contracts catalog leaf, exactly like
+ * graphddb's `GetItem`/`Query`).
+ *
+ * ## The locked model (owner-specified — nothing else exists)
+ *
+ * - bc integration = ONE catalog component `makeSQL`. Ports:
+ *     - `sql`    — tuned dialect SQL text (a string; `?` placeholders).
+ *     - `params` — value list. Each element is EITHER a bound value (an opaque SQL
+ *                  value: number/string/bool/null/Date/array/…) OR a **nested
+ *                  `makeSQL`** (a `{ sql, params, skip? }` object) whose `sql` is
+ *                  spliced at the corresponding `?` and whose params flow inline.
+ *                  A subquery / sub-expression is a nested `makeSQL` in a param slot.
+ *     - `skip?`  — presence condition. When satisfied, the component contributes
+ *                  NOTHING (its `sql` and its `params` both drop).
+ * - A query = a composition of `makeSQL` components. bc composes; present ones
+ *   concatenate. There is NO relation-op / operator / "kind" for SQL structure.
+ * - `= ANY`, `CROSS JOIN LATERAL`, `UNNEST`, cast, subquery, batch shapes are ALL
+ *   TEXT inside `sql`. Never modeled.
+ * - An array/rows param binds as ONE value with STATIC text on EVERY dialect
+ *   (epic #43/#45): PostgreSQL `= ANY(?::t[])` / `UNNEST`, MySQL/SQLite a single JSON
+ *   param expanded server-side (`MEMBER OF` / `JSON_TABLE` / `json_each`). There is no
+ *   array placeholder-count-expansion anywhere anymore.
+ *
+ * litedbmodel supplies (spec §11): the `makeSQL` catalog entry, its **handler**
+ * (bind params → execute SQL), and the **compile** step that emits the tuned dialect
+ * SQL text (by REUSING the original tuned builders — see `compile-*.ts`). bc supplies
+ * composition / value-eval / envelope / plan (it comes free once queries are `makeSQL`
+ * components). The bundle stays pure JSON (multi-language ready).
+ */
+import type { CatalogEntry } from 'behavior-contracts';
+/** The single catalog leaf name. Everything SQL is a `makeSQL`. */
+export declare const MAKESQL: "makeSQL";
+/**
+ * A bound SQL param value OR a nested `makeSQL` (subquery / sub-expression).
+ *
+ * A nested `makeSQL` in a param slot is how subqueries are represented: its `sql`
+ * splices into the parent's `?` position and its params flow into the parent's param
+ * stream in order. This is the ONLY recursion; there is no other SQL-structure
+ * vocabulary.
+ */
+export type SqlParam = unknown | MakeSQL;
+/**
+ * The `makeSQL` port bundle — the ONLY structural type.
+ *
+ * `sql` is complete tuned SQL text with `?` placeholders (leading connector included
+ * where the composition needs it, exactly as the original builder emits). `params`
+ * are 1:1 with the top-level `?` (a bound value fills one `?`; a nested `makeSQL`
+ * param splices its own `sql`, which may contain further `?`). `skip`, when `true`,
+ * omits the whole component (sql AND params).
+ */
+export interface MakeSQL {
+    sql: string;
+    params: SqlParam[];
+    /** Presence condition already resolved to a boolean at bind/eval time. */
+    skip?: boolean;
+}
+/** Structural guard: a nested-`makeSQL` param has a string `sql`; a bound value does not. */
+export declare function isMakeSQL(p: SqlParam): p is MakeSQL;
+/**
+ * The `makeSQL` catalog entry (bc `CatalogEntry`). A leaf Specialty Component: name +
+ * Port contract + output shape. The handler implementation is separate (see
+ * `handler.ts`) — the IR carries only the reference name + port wiring (C4).
+ *
+ * `params` is a dynamic-arity port family (the value list length is query-specific),
+ * so `additionalPorts` is not needed: `params` is a single arr-typed port, `sql` a
+ * string, `skip` an optional bool. `output.shape = 'items'` (a SELECT yields rows; a
+ * write yields RETURNING rows or `[]`).
+ */
+export declare const makeSqlCatalogEntry: CatalogEntry;
+/** The litedbmodel catalog — a single leaf, `makeSQL`. */
+export declare const LITEDBMODEL_MAKESQL_CATALOG: Record<string, CatalogEntry>;
+/** A fully-assembled statement: complete SQL text (`?`) + a flat ordered value list. */
+export interface AssembledSql {
+    sql: string;
+    params: unknown[];
+}
+/**
+ * Assemble one `makeSQL` into `{ sql, params }`.
+ *
+ * - If `skip` is true, this component contributes nothing: returns empty text + no
+ *   params (the caller composes over the survivors).
+ * - Otherwise interleave the literal `sql` (split on `?`) with each param: a bound
+ *   value emits a single `?` and contributes its value; a nested `makeSQL` splices
+ *   its assembled `sql` and contributes its assembled params (recursively). A nested
+ *   `makeSQL` that is itself skipped contributes empty text + no params.
+ */
+export declare function assembleMakeSQL(node: MakeSQL): AssembledSql;
+/**
+ * Compose an ordered list of `makeSQL` components into one statement: concatenate the
+ * assembled `sql` of every PRESENT component and their params in order (the locked
+ * model's "present ones concatenate"). Skipped components drop entirely.
+ *
+ * Each component's `sql` already carries whatever connector text the tuned builder
+ * emits for that position, so concatenation is byte-faithful for every skip subset.
+ */
+export declare function composeMakeSQL(nodes: MakeSQL[]): AssembledSql;
+//# sourceMappingURL=makesql.d.ts.map

package/dist/scp/makesql/makesql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makesql.d.ts","sourceRoot":"","sources":["../../../src/scp/makesql/makesql.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,mEAAmE;AACnE,eAAO,MAAM,OAAO,EAAG,SAAkB,CAAC;AAE1C;;;;;;;GAOG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,OAAO,CAAC;AAEzC;;;;;;;;GAQG;AACH,MAAM,WAAW,OAAO;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,QAAQ,EAAE,CAAC;IACnB,0EAA0E;IAC1E,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,6FAA6F;AAC7F,wBAAgB,SAAS,CAAC,CAAC,EAAE,QAAQ,GAAG,CAAC,IAAI,OAAO,CAOnD;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,EAAE,YASjC,CAAC;AAEF,0DAA0D;AAC1D,eAAO,MAAM,2BAA2B,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAEpE,CAAC;AAWF,wFAAwF;AACxF,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,OAAO,EAAE,CAAC;CACnB;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,GAAG,YAAY,CAwB3D;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,YAAY,CAS7D"}

package/dist/scp/makesql/makesql.js

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — the LOCKED minimal bc integration: ONE catalog component
+ * **`makeSQL(sql, params, skip?)`** (a behavior-contracts catalog leaf, exactly like
+ * graphddb's `GetItem`/`Query`).
+ *
+ * ## The locked model (owner-specified — nothing else exists)
+ *
+ * - bc integration = ONE catalog component `makeSQL`. Ports:
+ *     - `sql`    — tuned dialect SQL text (a string; `?` placeholders).
+ *     - `params` — value list. Each element is EITHER a bound value (an opaque SQL
+ *                  value: number/string/bool/null/Date/array/…) OR a **nested
+ *                  `makeSQL`** (a `{ sql, params, skip? }` object) whose `sql` is
+ *                  spliced at the corresponding `?` and whose params flow inline.
+ *                  A subquery / sub-expression is a nested `makeSQL` in a param slot.
+ *     - `skip?`  — presence condition. When satisfied, the component contributes
+ *                  NOTHING (its `sql` and its `params` both drop).
+ * - A query = a composition of `makeSQL` components. bc composes; present ones
+ *   concatenate. There is NO relation-op / operator / "kind" for SQL structure.
+ * - `= ANY`, `CROSS JOIN LATERAL`, `UNNEST`, cast, subquery, batch shapes are ALL
+ *   TEXT inside `sql`. Never modeled.
+ * - An array/rows param binds as ONE value with STATIC text on EVERY dialect
+ *   (epic #43/#45): PostgreSQL `= ANY(?::t[])` / `UNNEST`, MySQL/SQLite a single JSON
+ *   param expanded server-side (`MEMBER OF` / `JSON_TABLE` / `json_each`). There is no
+ *   array placeholder-count-expansion anywhere anymore.
+ *
+ * litedbmodel supplies (spec §11): the `makeSQL` catalog entry, its **handler**
+ * (bind params → execute SQL), and the **compile** step that emits the tuned dialect
+ * SQL text (by REUSING the original tuned builders — see `compile-*.ts`). bc supplies
+ * composition / value-eval / envelope / plan (it comes free once queries are `makeSQL`
+ * components). The bundle stays pure JSON (multi-language ready).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LITEDBMODEL_MAKESQL_CATALOG = exports.makeSqlCatalogEntry = exports.MAKESQL = void 0;
+exports.isMakeSQL = isMakeSQL;
+exports.assembleMakeSQL = assembleMakeSQL;
+exports.composeMakeSQL = composeMakeSQL;
+/** The single catalog leaf name. Everything SQL is a `makeSQL`. */
+exports.MAKESQL = 'makeSQL';
+/** Structural guard: a nested-`makeSQL` param has a string `sql`; a bound value does not. */
+function isMakeSQL(p) {
+    return (typeof p === 'object' &&
+        p !== null &&
+        typeof p.sql === 'string' &&
+        Array.isArray(p.params));
+}
+/**
+ * The `makeSQL` catalog entry (bc `CatalogEntry`). A leaf Specialty Component: name +
+ * Port contract + output shape. The handler implementation is separate (see
+ * `handler.ts`) — the IR carries only the reference name + port wiring (C4).
+ *
+ * `params` is a dynamic-arity port family (the value list length is query-specific),
+ * so `additionalPorts` is not needed: `params` is a single arr-typed port, `sql` a
+ * string, `skip` an optional bool. `output.shape = 'items'` (a SELECT yields rows; a
+ * write yields RETURNING rows or `[]`).
+ */
+exports.makeSqlCatalogEntry = {
+    name: exports.MAKESQL,
+    inputPorts: {
+        sql: { type: 'string', required: true },
+        params: { type: 'arr' },
+        skip: { type: 'bool' },
+    },
+    output: { shape: 'items' },
+    portableToIR: true,
+};
+/** The litedbmodel catalog — a single leaf, `makeSQL`. */
+exports.LITEDBMODEL_MAKESQL_CATALOG = {
+    [exports.MAKESQL]: exports.makeSqlCatalogEntry,
+};
+/**
+ * Assemble one `makeSQL` into `{ sql, params }`.
+ *
+ * - If `skip` is true, this component contributes nothing: returns empty text + no
+ *   params (the caller composes over the survivors).
+ * - Otherwise interleave the literal `sql` (split on `?`) with each param: a bound
+ *   value emits a single `?` and contributes its value; a nested `makeSQL` splices
+ *   its assembled `sql` and contributes its assembled params (recursively). A nested
+ *   `makeSQL` that is itself skipped contributes empty text + no params.
+ */
+function assembleMakeSQL(node) {
+    if (node.skip === true)
+        return { sql: '', params: [] };
+    const chunks = node.sql.split('?');
+    if (chunks.length - 1 !== node.params.length) {
+        throw new Error(`makeSQL placeholder/param mismatch: ${chunks.length - 1} '?' vs ${node.params.length} params in ${JSON.stringify(node.sql)}`);
+    }
+    let sql = chunks[0];
+    const params = [];
+    for (let i = 0; i < node.params.length; i++) {
+        const p = node.params[i];
+        if (isMakeSQL(p)) {
+            const inner = assembleMakeSQL(p);
+            sql += inner.sql + chunks[i + 1];
+            params.push(...inner.params);
+        }
+        else {
+            sql += '?' + chunks[i + 1];
+            params.push(p);
+        }
+    }
+    return { sql, params };
+}
+/**
+ * Compose an ordered list of `makeSQL` components into one statement: concatenate the
+ * assembled `sql` of every PRESENT component and their params in order (the locked
+ * model's "present ones concatenate"). Skipped components drop entirely.
+ *
+ * Each component's `sql` already carries whatever connector text the tuned builder
+ * emits for that position, so concatenation is byte-faithful for every skip subset.
+ */
+function composeMakeSQL(nodes) {
+    let sql = '';
+    const params = [];
+    for (const node of nodes) {
+        const r = assembleMakeSQL(node);
+        sql += r.sql;
+        params.push(...r.params);
+    }
+    return { sql, params };
+}
+//# sourceMappingURL=makesql.js.map

package/dist/scp/makesql/makesql.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"makesql.js","sourceRoot":"","sources":["../../../src/scp/makesql/makesql.ts"],"names":[],"mappings":"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"}

package/dist/scp/makesql/outtype.d.ts

@@ -0,0 +1,44 @@
+/**
+ * litedbmodel v2 SCP — codegen `outType` derivation (spec §4.1; issues #58/#56).
+ *
+ * bc's TYPED-RAW de-box emitters (`rust-typed-raw` / `go-typed-raw` / `typescript-typed`) require
+ * each read node to carry an `outType` and the component an `outputType` (bc portable type
+ * notation). WITHOUT them the emitter hard-fails ("nothing to de-box") — the correct fail-closed
+ * behavior. This module derives those annotations for a READ component from:
+ *
+ *   1. the per-node SELECT projection (`table` + `select` ports) → a row `obj` type, each column's
+ *      bc scalar resolved from its SQL type (the schema/DDL SoT) via {@link sqlTypeToBcScalar};
+ *   2. the node cardinality (a Select node returns a row LIST → `{arr:rowObj}`; a Count → `int`; a
+ *      `.map` node wraps its per-element handler result → `{arr:<elem>}`);
+ *   3. the component `output` Φ-expression, walked to compose the `outputType` from the node types
+ *      (`{ref:[nodeId]}` → that node's outType; `{obj:{…}}`/`{arr:…}`/`{opt:…}` recurse).
+ *
+ * Spec §4.1 discipline: an ambiguous/unmappable projection is a HARD ERROR (no-assume,
+ * no-fallback) — a `*` projection, a computed/aliased column, or a column with no schema type
+ * THROWS. It is NEVER degraded to a boxed/untyped output; that would silently defeat the de-box.
+ */
+import type { PortableType } from 'behavior-contracts';
+import type { Component, ComponentRefNode, MapNode } from '../authoring';
+import { type ColumnTypeResolver } from '../coltype';
+/** A body node that is a component ref or a map (a cond node has no SELECT projection). */
+type RefLike = ComponentRefNode | MapNode;
+/**
+ * The `outType` of ONE read body node. A `Select` returns a ROW LIST → `{arr:rowObj}`. A `Count`
+ * returns a single `int`. A `.map` node runs its inner component PER element of the iterated list,
+ * so its result is `{arr:<per-element outType>}` (the per-element type being the inner node's own
+ * outType — for a `.map` over a Select-per-element that is `{arr:{arr:rowObj}}`). An unrecognized
+ * component throws (typed codegen covers only the SQL read catalog).
+ */
+export declare function nodeOutType(node: RefLike, resolveColumnType: ColumnTypeResolver): PortableType;
+/**
+ * Per-node `outType` (keyed by body node id) + the component `outputType`, derived for a READ
+ * component (spec §4.1). `cond` nodes are skipped for the per-node map but a `cond` at the OUTPUT
+ * position (a shared-branch merge) would be handled by {@link outputType} if reached — the bench's
+ * read outputs are ref / obj compositions of Select nodes. Any ambiguity throws (fail-closed).
+ */
+export declare function deriveReadOutTypes(component: Component, resolveColumnType: ColumnTypeResolver): {
+    byNode: Map<string, PortableType>;
+    outputType: PortableType;
+};
+export {};
+//# sourceMappingURL=outtype.d.ts.map

package/dist/scp/makesql/outtype.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outtype.d.ts","sourceRoot":"","sources":["../../../src/scp/makesql/outtype.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAsB,MAAM,oBAAoB,CAAC;AAC3E,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACzE,OAAO,EAAoC,KAAK,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAcvF,2FAA2F;AAC3F,KAAK,OAAO,GAAG,gBAAgB,GAAG,OAAO,CAAC;AAwE1C;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,GAAG,YAAY,CAmB9F;AAwDD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,SAAS,EACpB,iBAAiB,EAAE,kBAAkB,GACpC;IAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAAC,UAAU,EAAE,YAAY,CAAA;CAAE,CAOjE"}

package/dist/scp/makesql/outtype.js

@@ -0,0 +1,197 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — codegen `outType` derivation (spec §4.1; issues #58/#56).
+ *
+ * bc's TYPED-RAW de-box emitters (`rust-typed-raw` / `go-typed-raw` / `typescript-typed`) require
+ * each read node to carry an `outType` and the component an `outputType` (bc portable type
+ * notation). WITHOUT them the emitter hard-fails ("nothing to de-box") — the correct fail-closed
+ * behavior. This module derives those annotations for a READ component from:
+ *
+ *   1. the per-node SELECT projection (`table` + `select` ports) → a row `obj` type, each column's
+ *      bc scalar resolved from its SQL type (the schema/DDL SoT) via {@link sqlTypeToBcScalar};
+ *   2. the node cardinality (a Select node returns a row LIST → `{arr:rowObj}`; a Count → `int`; a
+ *      `.map` node wraps its per-element handler result → `{arr:<elem>}`);
+ *   3. the component `output` Φ-expression, walked to compose the `outputType` from the node types
+ *      (`{ref:[nodeId]}` → that node's outType; `{obj:{…}}`/`{arr:…}`/`{opt:…}` recurse).
+ *
+ * Spec §4.1 discipline: an ambiguous/unmappable projection is a HARD ERROR (no-assume,
+ * no-fallback) — a `*` projection, a computed/aliased column, or a column with no schema type
+ * THROWS. It is NEVER degraded to a boxed/untyped output; that would silently defeat the de-box.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeOutType = nodeOutType;
+exports.deriveReadOutTypes = deriveReadOutTypes;
+const coltype_1 = require("../coltype");
+const tx_1 = require("./tx");
+/**
+ * Narrow a {@link BcScalar} to a bc {@link PortableScalarType}. `BcScalar`'s members
+ * (`string|int|float|bool|null`) are exactly bc 0.3.0's portable scalar notation, so this is an
+ * identity narrow. DATE/TIMESTAMP columns map to `string` at the `sqlTypeToBcScalar` layer (spec
+ * §4.1 owner decision; bc has no `date` scalar — behavior-contracts#84 deferred), so no `date`
+ * scalar ever reaches here.
+ */
+function toPortableScalar(scalar, _table, _column) {
+    return scalar;
+}
+function isMap(n) {
+    return 'map' in n;
+}
+/** The `{component, ports}` of a body node (unwrapping a `.map`). */
+function nodeRef(n) {
+    return isMap(n) ? { component: n.map.component, ports: n.map.ports } : { component: n.component, ports: n.ports };
+}
+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;
+}
+/** Read a required literal string port, or throw (the projection SoT must be a literal in the IR). */
+function stringPort(ports, name) {
+    const v = ports[name];
+    if (v === undefined)
+        return undefined;
+    if (typeof v !== 'string') {
+        throw new Error(`outtype: port '${name}' must be a literal string in the IR (got ${JSON.stringify(v)})`);
+    }
+    return v;
+}
+/** Read a literal `{arr:[str,…]}` string-list port (the SELECT projection). */
+function stringArrayPort(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.map((e) => {
+            if (typeof e !== 'string')
+                throw new Error(`outtype: '${name}' entries must be literal strings (got ${JSON.stringify(e)})`);
+            return e;
+        });
+    }
+    throw new Error(`outtype: port '${name}' must be an {arr:[…]} literal in the IR (got ${JSON.stringify(v)})`);
+}
+/**
+ * The row `obj` type of a SELECT projection: `{obj:{col: <bcScalar>, …}}`. Each column is typed by
+ * resolving its SQL type from the schema SoT and mapping via {@link sqlTypeToBcScalar}. A `*` or
+ * absent projection, a computed/aliased/qualified column, or a duplicate column is a HARD ERROR —
+ * such a projection cannot be de-boxed into a concrete struct (no-assume, no-fallback).
+ */
+function rowObjType(table, projection, resolveColumnType, at) {
+    if (projection === undefined || projection.length === 0) {
+        throw new Error(`outtype: ${at}: SELECT on '${table}' has no explicit column projection ('*' / empty). A typed ` +
+            `de-box needs the concrete column list to build the row struct — spec §4.1 is column-typed. ` +
+            `Project explicit columns (no-assume, no-fallback).`);
+    }
+    const obj = {};
+    for (const col of projection) {
+        // Reject anything that is not a bare column name — an alias (`x AS y`), a qualified name
+        // (`t.c`), or a computed expression cannot be typed from the schema alone.
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(col)) {
+            throw new Error(`outtype: ${at}: projected column '${col}' on '${table}' is not a bare column name (alias / ` +
+                `qualified / computed). Typed de-box (spec §4.1) requires bare schema columns so each maps ` +
+                `to a SQL type. No-assume, no-fallback.`);
+        }
+        if (col in obj)
+            throw new Error(`outtype: ${at}: duplicate projected column '${col}' on '${table}'`);
+        // sqlTypeToBcScalar throws on an unknown/ambiguous SQL type — fail-closed by construction.
+        obj[col] = toPortableScalar((0, coltype_1.sqlTypeToBcScalar)(resolveColumnType(table, col)), table, col);
+    }
+    return { obj };
+}
+/**
+ * The `outType` of ONE read body node. A `Select` returns a ROW LIST → `{arr:rowObj}`. A `Count`
+ * returns a single `int`. A `.map` node runs its inner component PER element of the iterated list,
+ * so its result is `{arr:<per-element outType>}` (the per-element type being the inner node's own
+ * outType — for a `.map` over a Select-per-element that is `{arr:{arr:rowObj}}`). An unrecognized
+ * component throws (typed codegen covers only the SQL read catalog).
+ */
+function nodeOutType(node, resolveColumnType) {
+    const { component, ports } = nodeRef(node);
+    const at = `node '${node.id}'`;
+    if (component === 'Count')
+        return 'int';
+    if (component === 'Select') {
+        const table = stringPort(ports, 'table');
+        if (table === undefined)
+            throw new Error(`outtype: ${at}: Select node requires a literal 'table' port`);
+        const projection = stringArrayPort(ports, 'select');
+        const row = rowObjType(table, projection, resolveColumnType, at);
+        // A `.map` node iterates a list and invokes the inner component per element; the node result is
+        // the list of per-element results. Here the inner is a Select → per element a row LIST, so the
+        // map node's outType is `{arr:{arr:rowObj}}`. A non-map Select node returns the row list `{arr:rowObj}`.
+        if (isMap(node))
+            return { arr: { arr: row } };
+        return { arr: row };
+    }
+    throw new Error(`outtype: ${at}: component '${component}' has no typed outType (typed read codegen covers Select/Count only). ` +
+        `A write / unknown node cannot be de-boxed here — no-assume, no-fallback.`);
+}
+/**
+ * Derive the component `outputType` by walking the `output` Φ-expression against a `nodeId →
+ * outType` map. `{ref:[id]}` resolves to that node's outType; `{obj:{k:expr,…}}` /
+ * `{arr:expr}` / `{opt:expr}` recurse structurally. A `ref` to an unknown id, or an operator the
+ * typed output path does not cover, is a HARD ERROR (no-assume, no-fallback) — the output must be
+ * a pure composition of typed node results, never a boxed dynamic tree.
+ */
+function outputType(output, byNode, at) {
+    const op = opKey(output);
+    if (op === 'ref' || op === 'refOpt') {
+        const path = output[op];
+        if (!Array.isArray(path) || path.length === 0 || typeof path[0] !== 'string') {
+            throw new Error(`outtype: ${at}: a '${op}' output must reference a node id`);
+        }
+        // A node-result ref is a single-segment path `[nodeId]`. A deeper path (field access on a node
+        // result) cannot be typed here without walking into the row struct — out of the bench's scope.
+        if (path.length !== 1 || path[0].startsWith('$') || path[0] === tx_1.IN_SENTINEL) {
+            throw new Error(`outtype: ${at}: output ref path ${JSON.stringify(path)} is not a bare node-result reference; ` +
+                `field access / input refs at the output position are not supported by the typed de-box path. No-assume, no-fallback.`);
+        }
+        const t = byNode.get(path[0]);
+        if (t === undefined)
+            throw new Error(`outtype: ${at}: output references node '${path[0]}' which has no derived outType`);
+        return t;
+    }
+    if (op === 'obj') {
+        const obj = output.obj;
+        if (obj === null || typeof obj !== 'object' || Array.isArray(obj))
+            throw new Error(`outtype: ${at}: 'obj' output must be a record`);
+        const out = {};
+        for (const [k, expr] of Object.entries(obj)) {
+            if (k === '__proto__')
+                throw new Error(`outtype: ${at}: '__proto__' key forbidden in output obj`);
+            out[k] = outputType(expr, byNode, `${at}.obj.${k}`);
+        }
+        return { obj: out };
+    }
+    if (op === 'arr') {
+        const arr = output.arr;
+        // An `{arr:<expr>}` output whose single element expr types the element (the typed corpus uses
+        // homogeneous arrays). An `{arr:[…]}` literal list is not a typed homogeneous array here.
+        if (Array.isArray(arr))
+            throw new Error(`outtype: ${at}: an '{arr:[…]}' literal list output cannot be typed as a homogeneous array. No-assume, no-fallback.`);
+        return { arr: outputType(arr, byNode, `${at}.arr`) };
+    }
+    if (op === 'opt') {
+        const inner = output.opt;
+        return { opt: outputType(inner, byNode, `${at}.opt`) };
+    }
+    throw new Error(`outtype: ${at}: output expression ${JSON.stringify(output)} is not a typed composition ` +
+        `(ref / obj / arr / opt of node results). The typed de-box path does not build a dynamic ` +
+        `Value output tree — no-assume, no-fallback.`);
+}
+/**
+ * Per-node `outType` (keyed by body node id) + the component `outputType`, derived for a READ
+ * component (spec §4.1). `cond` nodes are skipped for the per-node map but a `cond` at the OUTPUT
+ * position (a shared-branch merge) would be handled by {@link outputType} if reached — the bench's
+ * read outputs are ref / obj compositions of Select nodes. Any ambiguity throws (fail-closed).
+ */
+function deriveReadOutTypes(component, resolveColumnType) {
+    const byNode = new Map();
+    for (const n of component.body) {
+        if ('cond' in n)
+            continue; // a cond node carries no SELECT projection; it is typed by its branch
+        byNode.set(n.id, nodeOutType(n, resolveColumnType));
+    }
+    return { byNode, outputType: outputType(component.output, byNode, `component '${component.name}' output`) };
+}
+//# sourceMappingURL=outtype.js.map

package/dist/scp/makesql/outtype.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outtype.js","sourceRoot":"","sources":["../../../src/scp/makesql/outtype.ts"],"names":[],"mappings":"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"}

package/dist/scp/makesql/pool-executor.d.ts

@@ -0,0 +1,47 @@
+/**
+ * litedbmodel v2 SCP — pooled async `SqlExecutorAsync` factories for PG / MySQL (#40).
+ *
+ * The read-graph async execution model (`executeReadGraphAsync`) dispatches independent sibling
+ * relations in bounded parallel via bc `runBehaviorAsync`. For that concurrency to become REAL
+ * parallel DB I/O the driver seam must be an async CONNECTION POOL — each concurrent `exec` call
+ * checks out a DISTINCT pooled connection. These factories adapt a `pg.Pool` / `mysql2` pool to the
+ * {@link SqlExecutorAsync} seam.
+ *
+ * The read graph already renders the dialect placeholder form (`$N` for postgres, `?` for
+ * MySQL/SQLite, via `renderPlaceholders`) and flattens params 1:1, so each executor is a THIN
+ * adapter — it passes the already-rendered `{ sql, params }` straight to the pool. The pool sizing
+ * should be aligned with the plan's `concurrency` (default 16) so `concurrency` sibling relations
+ * can each hold a live connection without queueing.
+ *
+ * `pg` / `mysql2` are optional peer dependencies loaded dynamically — importing this module does not
+ * force either into a consumer that only uses the sync better-sqlite3 conformance path.
+ */
+import type { SqlExecutorAsync } from './static-bundle';
+/** The minimal `pg.Pool` surface we need: `query(text, values)` resolving `{ rows }`. */
+export interface PgPoolLike {
+    query(text: string, values?: unknown[]): Promise<{
+        rows: Record<string, unknown>[];
+    }>;
+}
+/** The minimal `mysql2/promise` pool surface: `query(sql, values)` resolving `[rows, fields]`. */
+export interface MysqlPoolLike {
+    query(sql: string, values?: unknown[]): Promise<[Record<string, unknown>[], unknown]>;
+}
+/**
+ * Adapt a `pg.Pool` to the async executor seam. Each `exec` runs `pool.query`, which acquires a
+ * pooled connection, runs the query, and releases it — so N concurrent siblings run on N pooled
+ * connections in parallel. The graph renders `$N` placeholders for the `postgres` dialect, so the
+ * `sql` is already in `pg`'s native form.
+ *
+ * Recommend constructing the pool with `max` ≥ the plan's `concurrency` (default 16).
+ */
+export declare function pgPoolExecutor(pool: PgPoolLike): SqlExecutorAsync;
+/**
+ * Adapt a `mysql2/promise` pool to the async executor seam. `pool.query` acquires + releases a
+ * pooled connection per call, so concurrent siblings run in parallel. The graph renders `?`
+ * placeholders for the `mysql` dialect — `mysql2`'s native form.
+ *
+ * Recommend `connectionLimit` ≥ the plan's `concurrency` (default 16).
+ */
+export declare function mysqlPoolExecutor(pool: MysqlPoolLike): SqlExecutorAsync;
+//# sourceMappingURL=pool-executor.d.ts.map

package/dist/scp/makesql/pool-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool-executor.d.ts","sourceRoot":"","sources":["../../../src/scp/makesql/pool-executor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,yFAAyF;AACzF,MAAM,WAAW,UAAU;IACzB,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAA;KAAE,CAAC,CAAC;CACvF;AAED,kGAAkG;AAClG,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC,CAAC;CACvF;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,gBAAgB,CAKjE;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa,GAAG,gBAAgB,CAKvE"}

package/dist/scp/makesql/pool-executor.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — pooled async `SqlExecutorAsync` factories for PG / MySQL (#40).
+ *
+ * The read-graph async execution model (`executeReadGraphAsync`) dispatches independent sibling
+ * relations in bounded parallel via bc `runBehaviorAsync`. For that concurrency to become REAL
+ * parallel DB I/O the driver seam must be an async CONNECTION POOL — each concurrent `exec` call
+ * checks out a DISTINCT pooled connection. These factories adapt a `pg.Pool` / `mysql2` pool to the
+ * {@link SqlExecutorAsync} seam.
+ *
+ * The read graph already renders the dialect placeholder form (`$N` for postgres, `?` for
+ * MySQL/SQLite, via `renderPlaceholders`) and flattens params 1:1, so each executor is a THIN
+ * adapter — it passes the already-rendered `{ sql, params }` straight to the pool. The pool sizing
+ * should be aligned with the plan's `concurrency` (default 16) so `concurrency` sibling relations
+ * can each hold a live connection without queueing.
+ *
+ * `pg` / `mysql2` are optional peer dependencies loaded dynamically — importing this module does not
+ * force either into a consumer that only uses the sync better-sqlite3 conformance path.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pgPoolExecutor = pgPoolExecutor;
+exports.mysqlPoolExecutor = mysqlPoolExecutor;
+/**
+ * Adapt a `pg.Pool` to the async executor seam. Each `exec` runs `pool.query`, which acquires a
+ * pooled connection, runs the query, and releases it — so N concurrent siblings run on N pooled
+ * connections in parallel. The graph renders `$N` placeholders for the `postgres` dialect, so the
+ * `sql` is already in `pg`'s native form.
+ *
+ * Recommend constructing the pool with `max` ≥ the plan's `concurrency` (default 16).
+ */
+function pgPoolExecutor(pool) {
+    return async (sql, params) => {
+        const result = await pool.query(sql, params);
+        return result.rows;
+    };
+}
+/**
+ * Adapt a `mysql2/promise` pool to the async executor seam. `pool.query` acquires + releases a
+ * pooled connection per call, so concurrent siblings run in parallel. The graph renders `?`
+ * placeholders for the `mysql` dialect — `mysql2`'s native form.
+ *
+ * Recommend `connectionLimit` ≥ the plan's `concurrency` (default 16).
+ */
+function mysqlPoolExecutor(pool) {
+    return async (sql, params) => {
+        const [rows] = await pool.query(sql, params);
+        return rows;
+    };
+}
+//# sourceMappingURL=pool-executor.js.map

package/dist/scp/makesql/pool-executor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool-executor.js","sourceRoot":"","sources":["../../../src/scp/makesql/pool-executor.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;GAiBG;;AAsBH,wCAKC;AASD,8CAKC;AA3BD;;;;;;;GAOG;AACH,SAAgB,cAAc,CAAC,IAAgB;IAC7C,OAAO,KAAK,EAAE,GAAW,EAAE,MAAiB,EAAsC,EAAE;QAClF,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;QAC7C,OAAO,MAAM,CAAC,IAAI,CAAC;IACrB,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,iBAAiB,CAAC,IAAmB;IACnD,OAAO,KAAK,EAAE,GAAW,EAAE,MAAiB,EAAsC,EAAE;QAClF,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;QAC7C,OAAO,IAAI,CAAC;IACd,CAAC,CAAC;AACJ,CAAC"}