litedbmodel 2.0.2 → 2.2.0

package/dist/scp/catalog.js

@@ -1,234 +0,0 @@
-"use strict";
-/**
- * litedbmodel v2 SCP catalog — WS1 (#21).
- *
- * `LITEDBMODEL_CATALOG` is the behavior-contracts–typed `Catalog` that IS the whole
- * per-DSL difference litedbmodel supplies as a SQL-backend consumer (bc C2: "the only
- * per-DSL difference is the catalog"). It mirrors the SHAPE of graphddb's
- * `GRAPHDDB_CATALOG` (`src/spec/catalog.ts`) exactly: compact `PortSchema` constructors,
- * an `entry()` helper, per-primitive `inputPorts`, an `output.shape`, and a
- * `portableToIR` flag. The effect implementation (SQL execution + row→model assembly) is
- * bound separately in the handler registry (WS3, C4 — catalog declares, registry binds).
- *
- * ## Catalog names (spec §1 / §11 item 1)
- *
- * `Select` / `Insert` / `Update` / `Delete` are the CRUD leaf components. `Fragment` is
- * the dynamic WHERE/SET fragment-tree component (SKIP → fragment existence rules, §8);
- * `Tx` is the multi-statement transaction envelope. As in graphddb, the transaction
- * envelope (`Tx`) is `portableToIR: false` — a transaction is emitted as a Component
- * whose body references the per-statement CRUD primitives; the atomic BEGIN/COMMIT
- * envelope is the runtime's execution concern (WS3), never a portable-IR node.
- *
- * ## Port schema conventions
- *
- * A `CatalogEntry.inputPorts` names the STATIC ports of the emitted wiring. Two families
- * are dynamic by construction and are validated by {@link assertComponentsInCatalog}
- * against documented patterns instead of being statically enumerable:
- *
- * - **`where`/`set`/`values` records**: one port per model field, flattened one-port-
- *   per-field under a `<group>.<field>` key ({@link WRITE_PORT_FAMILIES}). These carry
- *   Expression IR (the field's value/condition), from the closed operator set only.
- *
- * The CRUD entries carry `additionalPorts: true` (bc#26) so bc's shared port check
- * (`checkPortNames` / `buildComponentDefinition`) accepts the dynamic families; every
- * DECLARED port keeps bc's required/type checks regardless of the opt-in. `Tx`'s single
- * port is static, so it keeps bc's fail-closed default.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WRITE_PORT_FAMILIES = exports.WRITE_CATALOG_NAMES = exports.CATALOG_NAMES = exports.LITEDBMODEL_CATALOG = void 0;
-exports.catalogEntry = catalogEntry;
-exports.assertComponentsInCatalog = assertComponentsInCatalog;
-exports.deriveContractEffect = deriveContractEffect;
-const behavior_contracts_1 = require("behavior-contracts");
-// Compact schema constructors (the IR bundle is size-budgeted — graphddb convention).
-const P = (type, required) => (required ? { type, required } : { type });
-/**
- * The shared read-port surface for `Select`: `table` always; the optional
- * `where` (a fragment-tree reference — see `Fragment`), `order`, `limit`, `offset`,
- * `group` wiring, and the always-emitted `select` projection.
- *
- * `where` is typed `fragment` (not `expr`): a Select's dynamic WHERE is a fragment tree
- * (§8), NOT a single Expression — the SKIP existence rules live on the tree, outside the
- * Expression IR vocabulary (bc `expression-ir.md` §4: SKIP is OUTSIDE Expression IR).
- * `limit` / `offset` are `expr` (they may be an input-ref or a `coalesce` default, §8).
- */
-const SELECT_PORTS = {
-    table: P('string', true),
-    select: P('string[]', true),
-    where: P('fragment'),
-    order: P('string'),
-    limit: P('expr'),
-    offset: P('expr'),
-    group: P('string'),
-    // Additive read-tail/head ports (V0 R3/R4/R5/R6). SQL is v1-sourced from the matching
-    // `SelectDesc` fields via `compileSelect` (`_buildSelectSQL`), wired in `compileSelectNode`:
-    //  - `forUpdate` (R3): a literal `'true'` string toggles the ` FOR UPDATE` tail.
-    //  - `join`/`joinParams` (R5): a literal JOIN clause text (`JOIN t ON …`) + its bound
-    //    value-specs (`expr[]`), spliced after `FROM <t>` (v1 `_buildSelectSQL` JOIN position).
-    //  - `cte`/`cteParams` (R4): a WITH-CTE `{name, sql}` literal + its bound value-specs,
-    //    prefixed as `WITH <name> AS (<sql>) ` (v1 WITH-wrap). `cteParams` bind FIRST (v1 param
-    //    order: CTE → JOIN → WHERE).
-    //  - `append` (R6): a raw trailing clause text (e.g. `HAVING …`) appended verbatim.
-    forUpdate: P('string'),
-    join: P('string'),
-    joinParams: P('expr[]'),
-    cte: P('map'),
-    cteParams: P('expr[]'),
-    append: P('string'),
-};
-/**
- * The shared write-port surface for `Insert`/`Update`/`Delete`: `table` always;
- * `where` (fragment tree — required existence enforced by the compiler, not here, since a
- * Select may legitimately omit it); `returning` projection; `onConflict` wiring for
- * Insert. The per-field value/set ports (`values.<field>` / `set.<field>`) are dynamic
- * ({@link WRITE_PORT_FAMILIES}) and each carries an Expression IR value.
- */
-const WRITE_PORTS = {
-    table: P('string', true),
-    where: P('fragment'),
-    returning: P('string'),
-    onConflict: P('string'),
-    onConflictAction: P('string'),
-    // PRIMARY KEY descriptor for the MySQL RETURNING emulation (INSERT…RETURNING): `pk` is a
-    // comma-separated PK column list, `autoInc` names the single AUTO_INCREMENT column (absent for a
-    // client-supplied PK). Consumed by compileWriteNode → mysqlPkHint so the emulation re-selects by
-    // the REAL PK. Inert on PG/SQLite (native RETURNING).
-    pk: P('string'),
-    autoInc: P('string'),
-};
-const entry = (name, inputPorts, shape, portableToIR) => ({
-    name,
-    inputPorts,
-    output: { shape },
-    portableToIR,
-    // Dynamic port families (where/set/values record ports) are validated by
-    // assertComponentsInCatalog, not statically enumerable. Tx overrides back to
-    // fail-closed (its one port is static).
-    additionalPorts: true,
-});
-/**
- * litedbmodel's specific-component catalog (spec §11 item 1) — the behavior-contracts
- * `Catalog`-typed source of truth. Each entry declares the Port schema of one SQL
- * primitive AS THE BACKEND COMPILE WIRES IT; the effect implementation is bound
- * separately in the handler registry (WS3, C4). All entries except `Tx` may appear in
- * the portable IR.
- */
-exports.LITEDBMODEL_CATALOG = {
-    // Read: `items` (a Select root yields a row list; per-row collapse to `item` is the
-    // consumer's cardinality concern, mirrored from graphddb Query's `cardinality` port).
-    Select: entry('Select', { ...SELECT_PORTS, cardinality: P('string') }, 'items', true),
-    // COUNT(*) aggregate read (v1 `DBModel._count`): `SELECT COUNT(*) as count FROM t[ WHERE …]`.
-    // Only `table` (required) + the optional `where` fragment tree — v1's count carries no
-    // projection/order/limit/offset (it counts the filtered rows). Output is a one-row `[{count}]`
-    // list (the `items` shape, like every read); the consumer reads `count` — v1's `parseInt(count)`.
-    Count: entry('Count', { table: P('string', true), where: P('fragment') }, 'items', true),
-    // Writes yield the RETURNING row list (`items`); a single-row write collapses at the
-    // consumer boundary, same as reads.
-    Insert: entry('Insert', WRITE_PORTS, 'items', true),
-    Update: entry('Update', WRITE_PORTS, 'items', true),
-    Delete: entry('Delete', WRITE_PORTS, 'items', true),
-    // The dynamic WHERE/SET fragment-tree component (§8). Its ports carry the fragment
-    // tree; the compiler resolves SKIP/AND-OR structure to fragment existence rules.
-    Fragment: entry('Fragment', { tree: P('fragment', true) }, 'item', true),
-    // The runtime-side atomic envelope: never referenced by the portable IR (a transaction
-    // IS a component over the CRUD primitives) — runtime-only. Its single port is static,
-    // so it keeps bc's fail-closed default (no additionalPorts opt-in).
-    Tx: {
-        ...entry('Tx', { statements: P('map[]', true) }, 'item', false),
-        additionalPorts: false,
-    },
-};
-/** Look up a catalog entry by name (undefined for an unknown primitive). */
-function catalogEntry(name) {
-    return exports.LITEDBMODEL_CATALOG[name];
-}
-/** The catalog names litedbmodel declares (the C2 per-DSL surface). */
-exports.CATALOG_NAMES = [
-    'Select',
-    'Count',
-    'Insert',
-    'Update',
-    'Delete',
-    'Fragment',
-    'Tx',
-];
-/**
- * The CQRS write catalog: the names whose presence in a component body makes the
- * component a COMMAND (spec §2.4 — effect is derived from the graph, not authored).
- * `Select`/`Fragment` are read-side; `Insert`/`Update`/`Delete`/`Tx` are write-side.
- */
-exports.WRITE_CATALOG_NAMES = [
-    'Insert',
-    'Update',
-    'Delete',
-    'Tx',
-];
-const WRITE_SET = new Set(exports.WRITE_CATALOG_NAMES);
-/**
- * The dynamic per-field write-port families (`<group>.<field>` — the flattened record
- * convention; longest-prefix wins). A `values.<field>` (Insert) or `set.<field>`
- * (Update) port carries the field's Expression IR value; a `sqlCast.<field>` port carries
- * the field's PostgreSQL cast type (a literal string, e.g. `jsonb`/`uuid`/`int[]`) that drives
- * the v1 per-column `?::<sqlCast>` on Postgres (`DBModel._insert`/`_update`). `sqlCast.` ports are
- * INERT on MySQL/SQLite (v1's dialect-aware cast formatter is identity there).
- */
-exports.WRITE_PORT_FAMILIES = [
-    'values.',
-    'set.',
-    'sqlCast.',
-];
-/**
- * The emitter's catalog validation (loud; a violation is a BUILD error), mirrored from
- * graphddb's `assertComponentsInCatalog`. Every `componentRef` / `map` body node of every
- * emitted component must:
- *
- * 1. reference a declared catalog name;
- * 2. wire every `required` port of that entry;
- * 3. wire ONLY declared ports — a port is declared if it is a static `inputPorts` name or
- *    a write record-family port ({@link WRITE_PORT_FAMILIES}, write entries only).
- *
- * All violations are collected and thrown as one error. `cond` nodes carry no component
- * reference and are skipped.
- */
-function assertComponentsInCatalog(components) {
-    const errs = [];
-    for (const c of components) {
-        for (const n of c.body) {
-            if ('cond' in n)
-                continue;
-            const ref = 'map' in n ? n.map : n;
-            const entryDef = exports.LITEDBMODEL_CATALOG[ref.component];
-            if (entryDef === undefined) {
-                errs.push(`${c.name}/${n.id}: references '${ref.component}', not a LITEDBMODEL_CATALOG entry (known: ${exports.CATALOG_NAMES.join(', ')})`);
-                continue;
-            }
-            const ports = ref.ports;
-            for (const [p, s] of Object.entries(entryDef.inputPorts)) {
-                if (s.required === true && !(p in ports)) {
-                    errs.push(`${c.name}/${n.id} (${ref.component}): required port '${p}' is not wired`);
-                }
-            }
-            const isWriteItem = WRITE_SET.has(ref.component);
-            for (const p of Object.keys(ports)) {
-                if (p in entryDef.inputPorts)
-                    continue;
-                if (isWriteItem && exports.WRITE_PORT_FAMILIES.some((f) => p.startsWith(f)))
-                    continue;
-                errs.push(`${c.name}/${n.id} (${ref.component}): port '${p}' is not declared by the catalog entry (nor a write record-family port)`);
-            }
-        }
-    }
-    if (errs.length > 0) {
-        throw new Error(`litedbmodel catalog validation failed (${errs.length} violation${errs.length === 1 ? '' : 's'}):\n - ${errs.join('\n - ')}`);
-    }
-}
-/**
- * Derive one component's Query/Command classification FROM THE GRAPH: behavior-contracts'
- * `classifyBehaviorEffect` over {@link WRITE_CATALOG_NAMES} — a component is a `'command'`
- * iff its body references a write-catalog primitive, else a `'query'` (spec §2.4: effect
- * is derived, never authored).
- */
-function deriveContractEffect(component) {
-    return (0, behavior_contracts_1.classifyBehaviorEffect)(component, exports.WRITE_CATALOG_NAMES) === 'writing' ? 'command' : 'query';
-}
-//# sourceMappingURL=catalog.js.map

package/dist/scp/catalog.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"catalog.js","sourceRoot":"","sources":["../../src/scp/catalog.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;;;AA2HH,oCAEC;AAsDD,8DA4BC;AAYD,oDAEC;AA3ND,2DAA8H;AAiB9H,sFAAsF;AACtF,MAAM,CAAC,GAAG,CAAC,IAAY,EAAE,QAAe,EAAc,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;AAEpG;;;;;;;;;GASG;AACH,MAAM,YAAY,GAA+B;IAC/C,KAAK,EAAE,CAAC,CAAC,QAAQ,EAAE,IAAI,CAAC;IACxB,MAAM,EAAE,CAAC,CAAC,UAAU,EAAE,IAAI,CAAC;IAC3B,KAAK,EAAE,CAAC,CAAC,UAAU,CAAC;IACpB,KAAK,EAAE,CAAC,CAAC,QAAQ,CAAC;IAClB,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC;IAChB,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC;IACjB,KAAK,EAAE,CAAC,CAAC,QAAQ,CAAC;IAClB,sFAAsF;IACtF,6FAA6F;IAC7F,iFAAiF;IACjF,sFAAsF;IACtF,4FAA4F;IAC5F,uFAAuF;IACvF,4FAA4F;IAC5F,iCAAiC;IACjC,oFAAoF;IACpF,SAAS,EAAE,CAAC,CAAC,QAAQ,CAAC;IACtB,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC;IACjB,UAAU,EAAE,CAAC,CAAC,QAAQ,CAAC;IACvB,GAAG,EAAE,CAAC,CAAC,KAAK,CAAC;IACb,SAAS,EAAE,CAAC,CAAC,QAAQ,CAAC;IACtB,MAAM,EAAE,CAAC,CAAC,QAAQ,CAAC;CACpB,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,WAAW,GAA+B;IAC9C,KAAK,EAAE,CAAC,CAAC,QAAQ,EAAE,IAAI,CAAC;IACxB,KAAK,EAAE,CAAC,CAAC,UAAU,CAAC;IACpB,SAAS,EAAE,CAAC,CAAC,QAAQ,CAAC;IACtB,UAAU,EAAE,CAAC,CAAC,QAAQ,CAAC;IACvB,gBAAgB,EAAE,CAAC,CAAC,QAAQ,CAAC;IAC7B,yFAAyF;IACzF,iGAAiG;IACjG,iGAAiG;IACjG,sDAAsD;IACtD,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC;IACf,OAAO,EAAE,CAAC,CAAC,QAAQ,CAAC;CACrB,CAAC;AAEF,MAAM,KAAK,GAAG,CAAC,IAAiB,EAAE,UAAsC,EAAE,KAAa,EAAE,YAAqB,EAAgB,EAAE,CAAC,CAAC;IAChI,IAAI;IACJ,UAAU;IACV,MAAM,EAAE,EAAE,KAAK,EAAE;IACjB,YAAY;IACZ,yEAAyE;IACzE,6EAA6E;IAC7E,wCAAwC;IACxC,eAAe,EAAE,IAAI;CACtB,CAAC,CAAC;AAEH;;;;;;GAMG;AACU,QAAA,mBAAmB,GAAY;IAC1C,oFAAoF;IACpF,sFAAsF;IACtF,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,EAAE,GAAG,YAAY,EAAE,WAAW,EAAE,CAAC,CAAC,QAAQ,CAAC,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC;IACrF,8FAA8F;IAC9F,uFAAuF;IACvF,+FAA+F;IAC/F,kGAAkG;IAClG,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC,QAAQ,EAAE,IAAI,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,UAAU,CAAC,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC;IACxF,qFAAqF;IACrF,oCAAoC;IACpC,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,WAAW,EAAE,OAAO,EAAE,IAAI,CAAC;IACnD,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,WAAW,EAAE,OAAO,EAAE,IAAI,CAAC;IACnD,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,WAAW,EAAE,OAAO,EAAE,IAAI,CAAC;IACnD,mFAAmF;IACnF,iFAAiF;IACjF,QAAQ,EAAE,KAAK,CAAC,UAAU,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,UAAU,EAAE,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC;IACxE,uFAAuF;IACvF,sFAAsF;IACtF,oEAAoE;IACpE,EAAE,EAAE;QACF,GAAG,KAAK,CAAC,IAAI,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC;QAC/D,eAAe,EAAE,KAAK;KACvB;CACF,CAAC;AAEF,4EAA4E;AAC5E,SAAgB,YAAY,CAAC,IAAY;IACvC,OAAO,2BAAmB,CAAC,IAAI,CAAC,CAAC;AACnC,CAAC;AAED,uEAAuE;AAC1D,QAAA,aAAa,GAA2B;IACnD,QAAQ;IACR,OAAO;IACP,QAAQ;IACR,QAAQ;IACR,QAAQ;IACR,UAAU;IACV,IAAI;CACL,CAAC;AAEF;;;;GAIG;AACU,QAAA,mBAAmB,GAA2B;IACzD,QAAQ;IACR,QAAQ;IACR,QAAQ;IACR,IAAI;CACL,CAAC;AAEF,MAAM,SAAS,GAAwB,IAAI,GAAG,CAAC,2BAAmB,CAAC,CAAC;AAEpE;;;;;;;GAOG;AACU,QAAA,mBAAmB,GAAsB;IACpD,SAAS;IACT,MAAM;IACN,UAAU;CACX,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,SAAgB,yBAAyB,CAAC,UAAgC;IACxE,MAAM,IAAI,GAAa,EAAE,CAAC;IAC1B,KAAK,MAAM,CAAC,IAAI,UAAU,EAAE,CAAC;QAC3B,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;YACvB,IAAI,MAAM,IAAI,CAAC;gBAAE,SAAS;YAC1B,MAAM,GAAG,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YACnC,MAAM,QAAQ,GAAG,2BAAmB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YACpD,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;gBAC3B,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,iBAAiB,GAAG,CAAC,SAAS,8CAA8C,qBAAa,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBACpI,SAAS;YACX,CAAC;YACD,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC;YACxB,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;gBACzD,IAAI,CAAC,CAAC,QAAQ,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;oBACzC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,KAAK,GAAG,CAAC,SAAS,qBAAqB,CAAC,gBAAgB,CAAC,CAAC;gBACvF,CAAC;YACH,CAAC;YACD,MAAM,WAAW,GAAG,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YACjD,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;gBACnC,IAAI,CAAC,IAAI,QAAQ,CAAC,UAAU;oBAAE,SAAS;gBACvC,IAAI,WAAW,IAAI,2BAAmB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;oBAAE,SAAS;gBAC9E,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,KAAK,GAAG,CAAC,SAAS,YAAY,CAAC,yEAAyE,CAAC,CAAC;YACvI,CAAC;QACH,CAAC;IACH,CAAC;IACD,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CAAC,0CAA0C,IAAI,CAAC,MAAM,aAAa,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,UAAU,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IAChJ,CAAC;AACH,CAAC;AAMD;;;;;GAKG;AACH,SAAgB,oBAAoB,CAAC,SAAoB;IACvD,OAAO,IAAA,2CAAsB,EAAC,SAAS,EAAE,2BAAmB,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC;AACpG,CAAC"}

package/dist/scp/codegen.d.ts

@@ -1,189 +0,0 @@
-/**
- * litedbmodel v2 SCP — mode-3 codegen (WS7f, #35; spec §9 exec-mode 3 / §10 / §11; makeSQL flip,
- * epic #43/#45 Phase B; #60 milestone 1 — typed-NATIVE READ codegen, bc#77/#90).
- *
- * The static-codegen execution mode ("Codegen・静的（全言語）— IR → 各言語ソース生成 runtime≈0,
- * 入力は可搬IRのみ, bc#13 共有 generator に SQL catalog を供給" — spec §9). It takes a §8 STATIC
- * makeSQL {@link SqlBundle} and, per target language, emits:
- *
- *  1. **Behavior module** — bc's SHARED generator run over the bundle's portable IR through bc's
- *     de-interpreted, RUNTIME-FREE emitter. For a READ bundle covered by bc's typed-NATIVE
- *     endpoint (`rust-typed-native` / `go-typed-native`, bc#77/#90 — the 1.0 read de-box: fully
- *     concrete `HandlerNR<Comp>`/`InNR<Comp>`/`PortsNR<Comp><node>`/`RawRowNR<Comp><node>` structs,
- *     ZERO boxed `Value`/`RawValue`, ZERO IR baked into the module), the CODEGEN-ONLY lowering
- *     below ({@link lowerReadGraphForTypedNative}) makes the read's shape structurally ELIGIBLE
- *     (splits the surrogate `__scope` boxed-obj port into individual scalar ref ports + types the
- *     component's `inputPorts` from the schema) before handing it to bc. For a WRITE bundle, or a
- *     READ shape typed-native does not (yet) cover, codegen uses bc's existing de-interpreted
- *     STRAIGHT-LINE endpoint (`<lang>-straightline`, bc#75) — see {@link typedEmitterFor}.
- *  2. **SQL catalog companion** — the pure-JSON STATIC makeSQL catalog (per-node statement
- *     templates / relations / transaction). A codegen consumer's thin SQL layer reads it to
- *     evaluate skip + value-specs → assemble → render → execute (identically to the mode-2 runtime).
- *
- * ## #60 milestone 1 scope (CODEGEN-PATH ONLY)
- *
- * This lowering exists SOLELY for the codegen emitter call — it builds a NEW, separate
- * `ComponentGraphIR` from the bundle's `readGraph`; it never mutates `SqlBundle`/`ReadGraph` and
- * never touches the shared `readGraph`/`executeReadGraph` the ir/interpret exec surface (and the
- * frozen conformance corpus) depend on. Those keep consuming the ORIGINAL boxed-`__scope`-port
- * surrogate IR ({@link bundleToPortableIR}), completely unaffected by anything in this file.
- *
- * ## Behavior-identical to the thin-runtime (mode-2), by construction
- *
- * The generated module is observationally equivalent to `runBehavior` (same values, same emitted
- * op sequence, same Failure code/message), and the companion IS the bundle, so a codegen runtime
- * that drives it follows the IDENTICAL static-makeSQL render/execute path {@link executeBundle}
- * uses — SQL text (all dialects) and results are identical, not approximately equal. The TS leg
- * PROVES this by executing via the artifact and asserting exact equality vs {@link executeBundle}
- * (see {@link codegenExecuteBundleForTest}).
- *
- * ## No literal-bake / no boxed fallback
- *
- * typed-native fails CLOSED on an uncovered shape (a `map`/`cond` relation kind it does not cover,
- * or an input head that cannot lower to a native scalar — e.g. an IN-list's array-typed head).
- * Such a shape is NOT silently regenerated on the boxed `-typed`/`-typed-raw` emitter — it THROWS,
- * naming the exact gap, so it can be tracked as a bc coverage gap (bc#86) rather than masked.
- */
-import { type ComponentGraphIR, type GeneratedModule, type Scope, type Value } from 'behavior-contracts';
-import type { SqlBundle, SqliteDb } from './runtime';
-import type { DialectName } from './dialect';
-import type { RelationOp } from './relation';
-import type { ReadGraph } from './makesql/static-bundle';
-import type { TransactionPlan } from './makesql/tx';
-import { type ColumnTypeResolver } from './coltype';
-/**
- * The languages litedbmodel mode-3 codegen supports — exactly the set bc's shared generator
- * registers (bc#13 SP1 typescript/python + SP2 go/rust/php). {@link codegenEmitterFor}
- * verifies against the LIVE registry so a bc capability drift is caught loudly.
- */
-export declare const CODEGEN_LANGUAGES: readonly ["typescript", "python", "go", "rust", "php"];
-export type CodegenLanguage = (typeof CODEGEN_LANGUAGES)[number];
-/**
- * The bc READ emitter litedbmodel drives for each codegen target (#60 milestone 1): the
- * **de-interpreted, RUNTIME-FREE typed-NATIVE** endpoint (bc#77/#90) for go/rust — ZERO boxed
- * `Value`/`RawValue`, ZERO IR baked into the module, concrete `HandlerNR`/`InNR`/`PortsNR`/
- * `RawRowNR` structs. There is **NO literal / straight-line / boxed-typed fallback** for a read: an
- * unspec'd fallback is INVALID (it silently swallows the "this shape can't be natively codegen'd"
- * signal) — a read shape typed-native does not cover MUST fail loudly at generation, naming the gap
- * (report it as a bc#86 coverage gap), never silently regenerate on `-typed`/`-typed-raw`.
- *
- * `-typed-raw` (bc#76, the boxed-wire intermediate) and `-typed` (the boxed-Value intermediate) are
- * RETIRED from litedbmodel's codegen surface entirely (#60 milestone 1) — typed-native supersedes
- * both for every read shape it covers (bc#77/#90: single-componentRef reads AND the `map`
- * relationKind:single|connection shape, bc#86 part 2).
- *
- * - ts: **no typed-native endpoint registered yet** (bc has not shipped `typescript-typed-native`).
- *   TS stays on its existing `typescript-typed` (boxed) endpoint until bc adds one — a DECLARED,
- *   reported gap (not silently mirrored to go/rust's retirement), tracked as a bc#77 TS follow-up.
- * - **python/php: NOT present.** bc registers no de-boxed typed endpoint for them (capability limit).
- *   litedbmodel does NOT substitute the literal (≈ir) emitter — that would be an unspec'd fallback.
- *   Codegen for py/php is a bc capability gap that ERRORS (ESCALATE to bc), never a silent literal.
- *
- * WRITES (batchInsert / gate-first tx) are NOT reads — they are NOT routed through this table at
- * all (#60 milestone 1): a write bundle stays on the existing write/tx execution path
- * (`executeTransactionBundle` / the native adapter's hand-written tx mirror), never a codegen
- * module, boxed or typed-raw. {@link generateCodegenArtifact} throws if asked to codegen a write.
- */
-export declare const CODEGEN_EMITTER: Partial<Record<CodegenLanguage, string>>;
-/**
- * The SQL catalog companion (spec §9): the STATIC makeSQL bundle fields the codegen consumer's
- * thin SQL layer reads to evaluate + render + execute. Pure JSON — round-trips losslessly.
- */
-export interface SqlCatalogCompanion {
-    /** Target SQL dialect (`sqlite`/`postgres`/`mysql`) — compiled once, TS-side (spec §10). */
-    readonly dialect: DialectName;
-    /** READ bundles: the portable read graph (surrogate IR + per-node makeSQL statements). */
-    readonly readGraph?: ReadGraph;
-    /** WRITE bundles: the single base-write makeSQL statement template. */
-    readonly statement?: {
-        readonly sql: string;
-        readonly params: readonly unknown[];
-        readonly skip?: unknown;
-    };
-    /** Input heads normalized to present-as-null (absent-key SKIP) — mirrors the bundle. */
-    readonly optionalHeads: readonly string[];
-    /** Pre-compiled STATIC read-relation batch ops (spec §5/§8), keyed by relation name. */
-    readonly relations: Record<string, RelationOp>;
-    /** Derived gate-first write-time-relations transaction plan (spec §6/§8), for a Command bundle. */
-    readonly transaction?: TransactionPlan;
-    /**
-     * WRITE bundles: the codegen typed-de-box `outputType` (the TransactionResult typed shape). Rides
-     * the companion so a codegen consumer that reassembles the bundle from the artifact round-trips it
-     * losslessly (the read de-box carries its outType/outputType inside `readGraph.ir` instead).
-     */
-    readonly outputType?: unknown;
-}
-/** The full codegen artifact for one bundle × one language. */
-export interface CodegenArtifact {
-    /** The target language. */
-    readonly language: CodegenLanguage;
-    /** The generated behavior module (bc's SHARED STRAIGHT-LINE generator output — real static code). */
-    readonly module: GeneratedModule;
-    /** The SQL catalog companion sidecar (the STATIC makeSQL execution catalog). */
-    readonly companion: SqlCatalogCompanion;
-    /** The originating bundle (so the equivalence leg re-executes the SAME static bundle). */
-    readonly bundle: SqlBundle;
-}
-/**
- * The portable {@link ComponentGraphIR} view of a §8 bundle: a read bundle's surrogate IR (each
- * SQL node → a `makeSQL` node), or the single `makeSQL` component IR for a write. This is the
- * ORIGINAL boxed-`__scope`-port form the ir/interpret exec surface's `executeReadGraph` also
- * consumes (via `bundle.readGraph.ir` directly) — {@link generateCodegenArtifact} does NOT use
- * this for a READ bundle (it uses the codegen-only lowered form, {@link lowerReadGraphForTypedNative});
- * this function is kept for callers that want the untouched portable IR (e.g. diagnostics, the
- * write path, or a future straight-line fallback caller).
- */
-export declare function bundleToPortableIR(bundle: SqlBundle): ComponentGraphIR;
-/** A head could not be typed for typed-native codegen — the read is NOT typed-native-coverable. */
-export declare class TypedNativeCoverageError extends Error {
-    readonly component: string;
-    readonly reasons: readonly string[];
-    constructor(component: string, reasons: readonly string[]);
-}
-/**
- * Lower a read bundle's surrogate `ComponentGraphIR` into a NEW, CODEGEN-ONLY IR eligible for bc's
- * typed-native endpoint (#60 milestone 1): split the single `__scope: {obj:{...}}` boxed port into
- * individual scalar `{ref:[head]}` ports, and type the component's `inputPorts` from the schema
- * (via {@link deriveHeadTypesFromStatements}). Throws {@link TypedNativeCoverageError} if any
- * referenced head cannot be natively typed (e.g. an IN-list's array head) — NO silent `unknown`
- * port, NO fallback. Does NOT mutate `bundle`/`bundle.readGraph` (a fresh IR object is returned);
- * the ir/interpret exec surface's `executeReadGraph` keeps consuming the ORIGINAL `readGraph.ir`.
- *
- * Scope: bc's typed-native predicate itself still governs `map`/`cond`/relationKind/policy
- * coverage (this lowering does not special-case those — `generateModule` fails closed on them with
- * its own detailed diagnostic, which this function does not need to duplicate).
- */
-export declare function lowerReadGraphForTypedNative(readGraph: ReadGraph, resolveColumnType: ColumnTypeResolver): ComponentGraphIR;
-/**
- * Resolve the READ codegen emitter for a target language, or throw. No fallback: a language
- * without a registered endpoint is a bc capability gap that fails LOUDLY (never a silent
- * substitution of the literal/interpreter/boxed emitter — an unspec'd fallback is invalid).
- */
-export declare function typedEmitterFor(language: string, registered: readonly string[]): string;
-/**
- * Shape-INDEPENDENT emitter resolution — identical to {@link typedEmitterFor} now that there is
- * exactly one READ endpoint per language (kept as a distinct export for callers that historically
- * used the shape-independent form; both resolve the SAME table).
- */
-export declare function codegenEmitterFor(language: string, registered: readonly string[]): string;
-/**
- * Generate the mode-3 READ codegen artifact for ONE §8 READ bundle in ONE target language. For a
- * typed-NATIVE target (go/rust, bc#77/#90), lowers the bundle's surrogate read graph into the
- * typed-native-eligible IR ({@link lowerReadGraphForTypedNative}) first — REAL static native
- * source, RUNTIME-FREE, no baked-IR interpret path. For any OTHER registered endpoint (currently
- * only TS's boxed `typescript-typed`, which has no typed-native counterpart yet), the ORIGINAL
- * portable IR ({@link bundleToPortableIR}) is used unchanged — the lowering is typed-native-only
- * and would needlessly narrow a boxed endpoint's existing coverage. litedbmodel supplies the
- * input (portable IR + catalog); bc owns the emitter.
- *
- * WRITE bundles are OUT OF SCOPE (#60 milestone 1: writes stay on the existing write/tx execution
- * path, never a codegen module) — throws if `bundle.readGraph` is absent.
- */
-export declare function generateCodegenArtifact(bundle: SqlBundle, language: string, registeredLanguages: readonly string[], resolveColumnType: ColumnTypeResolver, runtimeImport?: string): CodegenArtifact;
-/**
- * The TS codegen EXECUTION path used to PROVE behavior-identity: a codegen runtime reads the SQL
- * catalog companion (the STATIC makeSQL bundle) and evaluates skip + value-specs → assemble →
- * render → execute — which is EXACTLY {@link executeBundle} over the SAME bundle.
- */
-export declare function codegenExecuteBundleForTest(artifact: CodegenArtifact, input: Scope, db: SqliteDb): Value;
-//# sourceMappingURL=codegen.d.ts.map

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

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