litedbmodel 2.0.0 → 2.0.2

package/dist/scp/compile-dialect.d.ts

@@ -1,39 +0,0 @@
-/**
- * litedbmodel v2 SCP — dialect-parameterized Backend Compile (WS6, #26; spec §4/§5/§8/§10).
- *
- * The SAME Component-graph IR compiles to SQLite, Postgres and MySQL SQL. The IR→structure
- * lowering (SELECT/INSERT/UPDATE/DELETE skeletons, the WHERE fragment tree, `col = ?`, IN-list
- * `(?)` expansion, param slots) is SHARED across dialects; only the genuine dialect divergences
- * (INSERT conflict clause + INSERT verb) are delegated to the {@link Dialect} strategy (the SSoT
- * — no scattered `?:`). Placeholders stay `?` through compilation; the PG `?`→`$N` conversion is
- * a final render-time one-pass ({@link import('./dialect').Dialect.finalizePlaceholders}), NOT a
- * compile-time concern — so the compiled `CompiledOperation.sql` is dialect-tagged but still
- * `?`-placeheld, keeping the bundle uniform.
- *
- * `compile-sqlite.ts` delegates its INSERT compile here with the SQLite dialect, so the pinned
- * SQLite golden (WS1) is preserved byte-for-byte and the PG/MySQL variants diverge ONLY where the
- * v1 SqlBuilders diverge (proven byte-identical in the WS6 dialect-golden test).
- */
-import type { CompiledOperation, ExprNode } from './ir';
-import type { Dialect } from './dialect';
-/** Column → value Expression IR (insertion order = SQL column order). */
-export interface InsertShape {
-    readonly table: string;
-    readonly values: Record<string, ExprNode>;
-    readonly returning?: readonly string[];
-    readonly onConflict?: readonly string[];
-    readonly onConflictAction?: 'ignore' | {
-        readonly updateColumns: 'all' | readonly string[];
-    };
-}
-/**
- * Compile an INSERT for a given dialect. Byte-identical to the corresponding v1 SqlBuilder's
- * single-record `buildInsert` output (the golden bar):
- *   - SQLite: `INSERT [OR IGNORE] INTO t (c) VALUES (?)[ ON CONFLICT (k) DO UPDATE SET c = excluded.c][ RETURNING r]`
- *   - Postgres: `INSERT INTO t (c) VALUES (?)[ ON CONFLICT (k) DO NOTHING | DO UPDATE SET c = EXCLUDED.c][ RETURNING r]`
- *   - MySQL: `INSERT [IGNORE] INTO t (c) VALUES (?)[ ON DUPLICATE KEY UPDATE c = VALUES(c)]`
- *
- * Placeholders remain `?`; PG's `?`→`$N` is applied at render time.
- */
-export declare function compileInsertFor(dialect: Dialect, desc: InsertShape): CompiledOperation;
-//# sourceMappingURL=compile-dialect.d.ts.map

package/dist/scp/compile-dialect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"compile-dialect.d.ts","sourceRoot":"","sources":["../../src/scp/compile-dialect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,QAAQ,EAAE,MAAM,MAAM,CAAC;AACxD,OAAO,KAAK,EAAE,OAAO,EAAkB,MAAM,WAAW,CAAC;AAKzD,yEAAyE;AACzE,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC1C,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,QAAQ,GAAG;QAAE,QAAQ,CAAC,aAAa,EAAE,KAAK,GAAG,SAAS,MAAM,EAAE,CAAA;KAAE,CAAC;CAC9F;AAKD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,iBAAiB,CAiBvF"}

package/dist/scp/compile-dialect.js

@@ -1,62 +0,0 @@
-"use strict";
-/**
- * litedbmodel v2 SCP — dialect-parameterized Backend Compile (WS6, #26; spec §4/§5/§8/§10).
- *
- * The SAME Component-graph IR compiles to SQLite, Postgres and MySQL SQL. The IR→structure
- * lowering (SELECT/INSERT/UPDATE/DELETE skeletons, the WHERE fragment tree, `col = ?`, IN-list
- * `(?)` expansion, param slots) is SHARED across dialects; only the genuine dialect divergences
- * (INSERT conflict clause + INSERT verb) are delegated to the {@link Dialect} strategy (the SSoT
- * — no scattered `?:`). Placeholders stay `?` through compilation; the PG `?`→`$N` conversion is
- * a final render-time one-pass ({@link import('./dialect').Dialect.finalizePlaceholders}), NOT a
- * compile-time concern — so the compiled `CompiledOperation.sql` is dialect-tagged but still
- * `?`-placeheld, keeping the bundle uniform.
- *
- * `compile-sqlite.ts` delegates its INSERT compile here with the SQLite dialect, so the pinned
- * SQLite golden (WS1) is preserved byte-for-byte and the PG/MySQL variants diverge ONLY where the
- * v1 SqlBuilders diverge (proven byte-identical in the WS6 dialect-golden test).
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compileInsertFor = compileInsertFor;
-/** Row → logical model assembly (shape only). */
-const assembly = (shape) => ({ shape });
-/**
- * Compile an INSERT for a given dialect. Byte-identical to the corresponding v1 SqlBuilder's
- * single-record `buildInsert` output (the golden bar):
- *   - SQLite: `INSERT [OR IGNORE] INTO t (c) VALUES (?)[ ON CONFLICT (k) DO UPDATE SET c = excluded.c][ RETURNING r]`
- *   - Postgres: `INSERT INTO t (c) VALUES (?)[ ON CONFLICT (k) DO NOTHING | DO UPDATE SET c = EXCLUDED.c][ RETURNING r]`
- *   - MySQL: `INSERT [IGNORE] INTO t (c) VALUES (?)[ ON DUPLICATE KEY UPDATE c = VALUES(c)]`
- *
- * Placeholders remain `?`; PG's `?`→`$N` is applied at render time.
- */
-function compileInsertFor(dialect, desc) {
-    const columns = Object.keys(desc.values);
-    if (columns.length === 0)
-        throw new Error('INSERT requires at least one value column');
-    const placeholders = columns.map(() => '?').join(', ');
-    const params = columns.map((c) => desc.values[c]);
-    const conflictAction = resolveConflictAction(desc, columns);
-    const verb = dialect.insertVerb(conflictAction);
-    let sql = `${verb} ${desc.table} (${columns.join(', ')}) VALUES (${placeholders})`;
-    if (conflictAction !== undefined) {
-        sql += dialect.insertConflictClause(desc.onConflict ?? [], conflictAction);
-    }
-    if (desc.returning !== undefined)
-        sql += ` RETURNING ${desc.returning.join(', ')}`;
-    return { component: 'Insert', sql, where: null, params, assembly: assembly('items') };
-}
-/**
- * Resolve the dialect-neutral {@link ConflictAction} from the INSERT description. An `'all'`
- * update-column list is expanded to the concrete inserted columns EXCEPT the conflict keys
- * (matching the v1 SqlBuilders' `onConflictUpdate === 'all' ? columns : …`, which include all
- * columns; the v1 builders use the full `columns` list for `'all'`, so we mirror that exactly).
- * Returns undefined when the INSERT declares no conflict handling.
- */
-function resolveConflictAction(desc, columns) {
-    if (desc.onConflict === undefined || desc.onConflictAction === undefined)
-        return undefined;
-    if (desc.onConflictAction === 'ignore')
-        return 'ignore';
-    const cols = desc.onConflictAction.updateColumns === 'all' ? columns : desc.onConflictAction.updateColumns;
-    return { updateColumns: cols };
-}
-//# sourceMappingURL=compile-dialect.js.map

package/dist/scp/compile-dialect.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"compile-dialect.js","sourceRoot":"","sources":["../../src/scp/compile-dialect.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;AA6BH,4CAiBC;AA7BD,iDAAiD;AACjD,MAAM,QAAQ,GAAG,CAAC,KAAa,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;AAEhD;;;;;;;;GAQG;AACH,SAAgB,gBAAgB,CAAC,OAAgB,EAAE,IAAiB;IAClE,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACzC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;IACvF,MAAM,YAAY,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACvD,MAAM,MAAM,GAAe,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAE9D,MAAM,cAAc,GAAG,qBAAqB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAC5D,MAAM,IAAI,GAAG,OAAO,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;IAChD,IAAI,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,CAAC,KAAK,KAAK,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,YAAY,GAAG,CAAC;IAEnF,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;QACjC,GAAG,IAAI,OAAO,CAAC,oBAAoB,CAAC,IAAI,CAAC,UAAU,IAAI,EAAE,EAAE,cAAc,CAAC,CAAC;IAC7E,CAAC;IAED,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS;QAAE,GAAG,IAAI,cAAc,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;IAEnF,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;AACxF,CAAC;AAED;;;;;;GAMG;AACH,SAAS,qBAAqB,CAAC,IAAiB,EAAE,OAA0B;IAC1E,IAAI,IAAI,CAAC,UAAU,KAAK,SAAS,IAAI,IAAI,CAAC,gBAAgB,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC3F,IAAI,IAAI,CAAC,gBAAgB,KAAK,QAAQ;QAAE,OAAO,QAAQ,CAAC;IACxD,MAAM,IAAI,GAAG,IAAI,CAAC,gBAAgB,CAAC,aAAa,KAAK,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC;IAC3G,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC;AACjC,CAAC"}

package/dist/scp/compile-sqlite.d.ts

@@ -1,114 +0,0 @@
-/**
- * litedbmodel v2 SCP — SQLite Backend Compile (WS1, #21).
- *
- * Lowers a structured CRUD operation description (a Component-graph Select/Insert/Update/
- * Delete node with ports) into a {@link CompiledOperation}: SQLite dialect SQL text,
- * a fragment tree (dynamic WHERE/SET with existence rules), and static param slots — the
- * IR shape of spec §8. Placeholders are unified as `?` (the `?`→`$N` pass is PG-only and
- * OUT OF SCOPE for WS1).
- *
- * The generated SQLite SQL is byte-identical to what litedbmodel v1's SqliteSqlBuilder /
- * `DBModel._buildSelectSQL` produce for equivalent queries (the golden bar). In
- * particular:
- *   - SELECT: `SELECT <cols> FROM <t>[ WHERE <c>][ GROUP BY <g>][ ORDER BY <o>][ LIMIT ?][ OFFSET ?]`
- *   - INSERT: `INSERT INTO <t> (<cols>) VALUES (<vals>)[ RETURNING <r>]`
- *   - UPDATE: `UPDATE <t> SET <a = ?, …> WHERE <c>[ RETURNING <r>]`
- *   - DELETE: `DELETE FROM <t> WHERE <c>[ RETURNING <r>]`
- *   - WHERE parts joined by ` AND ` (or ` OR ` for an OR group), equality `col = ?`,
- *     IN-list `col IN (?, …)`, empty array → `1 = 0`, NULL → `col IS NULL`.
- *
- * ## Hard rule: closed Expression IR only
- *
- * Every param slot this compiler emits is an Expression IR node from bc's closed set
- * (`PORTABLE_EXPR_OPERATORS`). NO litedbmodel-local opcode is ever invented. An
- * un-lowerable predicate is the Raw SQL escape hatch's concern (spec §13), not a fake
- * opcode. {@link compileSelect} et al. only construct `ref` / `coalesce` / etc.
- */
-import type { CompiledOperation, ExprNode } from './ir';
-/** A reference into the input scope or a sibling wire result (Expression IR `ref`). */
-export type Ref = {
-    ref: string[];
-};
-/** A single WHERE condition. `skipWhen` (absent → always present) drives SKIP (§8). */
-export type Condition = {
-    kind: 'eq';
-    column: string;
-    value: ExprNode;
-    skipWhen?: ExprNode;
-} | {
-    kind: 'cmp';
-    column: string;
-    op: '<' | '<=' | '>' | '>=' | '<>';
-    value: ExprNode;
-    skipWhen?: ExprNode;
-} | {
-    kind: 'isNull';
-    column: string;
-    skipWhen?: ExprNode;
-} | {
-    kind: 'in';
-    column: string;
-    value: ExprNode;
-    skipWhen?: ExprNode;
-}
-/** A nested AND/OR group (parenthesized, dynamic-expansion spec §4). */
- | {
-    kind: 'group';
-    connector: 'AND' | 'OR';
-    conditions: Condition[];
-    skipWhen?: ExprNode;
-};
-export interface SelectDesc {
-    table: string;
-    /** Projection columns; `['*']` renders `*`. */
-    select: string[];
-    where?: Condition[];
-    /** Raw ORDER BY body (dialect-neutral text, e.g. `"created_at DESC"`). */
-    order?: string;
-    /** GROUP BY body. */
-    group?: string;
-    /** LIMIT value as an Expression IR node (e.g. a `coalesce` default). */
-    limit?: ExprNode;
-    /** OFFSET value as an Expression IR node. */
-    offset?: ExprNode;
-}
-export interface InsertDesc {
-    table: string;
-    /** Column → value Expression IR (insertion order = SQL column order). */
-    values: Record<string, ExprNode>;
-    returning?: string[];
-    onConflict?: string[];
-    onConflictAction?: 'ignore' | {
-        updateColumns: 'all' | string[];
-    };
-}
-export interface UpdateDesc {
-    table: string;
-    /** Column → value Expression IR (insertion order = SET clause order). */
-    set: Record<string, ExprNode>;
-    where: Condition[];
-    returning?: string[];
-}
-export interface DeleteDesc {
-    table: string;
-    where: Condition[];
-    returning?: string[];
-}
-/**
- * Compile a SELECT. Static params (LIMIT / OFFSET) sit AFTER the `{where}` splice, so
- * they are emitted after the fragment params (dynamic-expansion spec §6).
- */
-export declare function compileSelect(desc: SelectDesc): CompiledOperation;
-/**
- * Compile an INSERT (SQLite). All params are static (no WHERE); order = column order. The
- * dialect-specific conflict/verb rendering is delegated to the SQLite {@link SQLITE} strategy
- * ({@link compileInsertFor}) — the SAME dialect-parameterized compile the PG/MySQL Backend
- * Compile uses (WS6), so SQLite is byte-for-byte unchanged and the other dialects diverge only
- * where the v1 SqlBuilders diverge.
- */
-export declare function compileInsert(desc: InsertDesc): CompiledOperation;
-/** Compile an UPDATE. SET params (static) precede the `{where}` splice (spec §6). */
-export declare function compileUpdate(desc: UpdateDesc): CompiledOperation;
-/** Compile a DELETE. No static params before the WHERE (all params are conditions). */
-export declare function compileDelete(desc: DeleteDesc): CompiledOperation;
-//# sourceMappingURL=compile-sqlite.d.ts.map

package/dist/scp/compile-sqlite.d.ts.map

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

package/dist/scp/compile-sqlite.js

@@ -1,149 +0,0 @@
-"use strict";
-/**
- * litedbmodel v2 SCP — SQLite Backend Compile (WS1, #21).
- *
- * Lowers a structured CRUD operation description (a Component-graph Select/Insert/Update/
- * Delete node with ports) into a {@link CompiledOperation}: SQLite dialect SQL text,
- * a fragment tree (dynamic WHERE/SET with existence rules), and static param slots — the
- * IR shape of spec §8. Placeholders are unified as `?` (the `?`→`$N` pass is PG-only and
- * OUT OF SCOPE for WS1).
- *
- * The generated SQLite SQL is byte-identical to what litedbmodel v1's SqliteSqlBuilder /
- * `DBModel._buildSelectSQL` produce for equivalent queries (the golden bar). In
- * particular:
- *   - SELECT: `SELECT <cols> FROM <t>[ WHERE <c>][ GROUP BY <g>][ ORDER BY <o>][ LIMIT ?][ OFFSET ?]`
- *   - INSERT: `INSERT INTO <t> (<cols>) VALUES (<vals>)[ RETURNING <r>]`
- *   - UPDATE: `UPDATE <t> SET <a = ?, …> WHERE <c>[ RETURNING <r>]`
- *   - DELETE: `DELETE FROM <t> WHERE <c>[ RETURNING <r>]`
- *   - WHERE parts joined by ` AND ` (or ` OR ` for an OR group), equality `col = ?`,
- *     IN-list `col IN (?, …)`, empty array → `1 = 0`, NULL → `col IS NULL`.
- *
- * ## Hard rule: closed Expression IR only
- *
- * Every param slot this compiler emits is an Expression IR node from bc's closed set
- * (`PORTABLE_EXPR_OPERATORS`). NO litedbmodel-local opcode is ever invented. An
- * un-lowerable predicate is the Raw SQL escape hatch's concern (spec §13), not a fake
- * opcode. {@link compileSelect} et al. only construct `ref` / `coalesce` / etc.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compileSelect = compileSelect;
-exports.compileInsert = compileInsert;
-exports.compileUpdate = compileUpdate;
-exports.compileDelete = compileDelete;
-const ir_1 = require("./ir");
-const dialect_1 = require("./dialect");
-const compile_dialect_1 = require("./compile-dialect");
-// ── WHERE fragment-tree lowering (spec §8) ────────────────────────────────────
-/** Lower one condition to a fragment (leaf) or nested tree, without a leading connector. */
-function lowerCondition(c) {
-    if (c.kind === 'group') {
-        const tree = {
-            connector: c.connector,
-            fragments: c.conditions.map(lowerCondition),
-        };
-        // A group's own SKIP guard is carried by wrapping it — but a FragmentTree has no
-        // `when`; represent a conditional group as a single-fragment tree is not expressible,
-        // so a guarded group is lowered as a leaf-less tree whose presence is the OR/AND of
-        // its members' presence (renderTree already drops it when empty). A group with its
-        // own skipWhen is not part of WS1's representative surface; reject loudly if used.
-        if (c.skipWhen !== undefined) {
-            throw new Error('a conditional (SKIP) group is not supported in WS1; guard the member conditions individually');
-        }
-        return tree;
-    }
-    let f;
-    switch (c.kind) {
-        case 'eq':
-            f = { always: true, sql: `${c.column} = ?`, params: [c.value] };
-            break;
-        case 'cmp':
-            f = { always: true, sql: `${c.column} ${c.op} ?`, params: [c.value] };
-            break;
-        case 'isNull':
-            f = { always: true, sql: `${c.column} IS NULL`, params: [] };
-            break;
-        case 'in':
-            // IN-list: single `(?)` slot expands at render time (spec §5). golden text:
-            // `col IN (?, ?, …)` with `, ` separators; empty array degenerates to `(NULL)`.
-            f = { always: true, sql: `${c.column} IN (?)`, params: [c.value], expand: 0 };
-            break;
-    }
-    if (c.skipWhen !== undefined) {
-        delete f.always;
-        f.when = c.skipWhen;
-    }
-    return f;
-}
-/** Build a top-level AND fragment tree from a condition list (null when empty). */
-function lowerWhere(conditions) {
-    if (conditions === undefined || conditions.length === 0)
-        return null;
-    return { connector: 'AND', fragments: conditions.map(lowerCondition) };
-}
-// ── CRUD compilers ────────────────────────────────────────────────────────────
-const assembly = (shape) => ({ shape });
-/**
- * Compile a SELECT. Static params (LIMIT / OFFSET) sit AFTER the `{where}` splice, so
- * they are emitted after the fragment params (dynamic-expansion spec §6).
- */
-function compileSelect(desc) {
-    const cols = desc.select.length === 1 && desc.select[0] === '*' ? '*' : desc.select.join(', ');
-    let sql = `SELECT ${cols} FROM ${desc.table}`;
-    const where = lowerWhere(desc.where);
-    // The WHERE splice marker is emitted whenever a fragment tree exists (even if all
-    // fragments may skip — degeneration is a render-time decision, spec §3).
-    if (where !== null)
-        sql += ir_1.WHERE_SLOT;
-    if (desc.group !== undefined)
-        sql += ` GROUP BY ${desc.group}`;
-    if (desc.order !== undefined)
-        sql += ` ORDER BY ${desc.order}`;
-    const params = [];
-    if (desc.limit !== undefined) {
-        sql += ` LIMIT ?`;
-        params.push(desc.limit);
-    }
-    if (desc.offset !== undefined) {
-        sql += ` OFFSET ?`;
-        params.push(desc.offset);
-    }
-    return { component: 'Select', sql, where, params, assembly: assembly('items') };
-}
-/**
- * Compile an INSERT (SQLite). All params are static (no WHERE); order = column order. The
- * dialect-specific conflict/verb rendering is delegated to the SQLite {@link SQLITE} strategy
- * ({@link compileInsertFor}) — the SAME dialect-parameterized compile the PG/MySQL Backend
- * Compile uses (WS6), so SQLite is byte-for-byte unchanged and the other dialects diverge only
- * where the v1 SqlBuilders diverge.
- */
-function compileInsert(desc) {
-    return (0, compile_dialect_1.compileInsertFor)(dialect_1.SQLITE, desc);
-}
-/** Compile an UPDATE. SET params (static) precede the `{where}` splice (spec §6). */
-function compileUpdate(desc) {
-    const setCols = Object.keys(desc.set);
-    if (setCols.length === 0)
-        throw new Error('UPDATE requires at least one SET column');
-    const setClauses = setCols.map((c) => `${c} = ?`);
-    const params = setCols.map((c) => desc.set[c]);
-    const where = lowerWhere(desc.where);
-    if (where === null)
-        throw new Error('UPDATE requires conditions');
-    // The ` WHERE ` keyword is emitted by render() (it prepends ` WHERE ` when the fragment
-    // tree renders non-empty). Splice the marker directly after the SET clause.
-    let sql = `UPDATE ${desc.table} SET ${setClauses.join(', ')}${ir_1.WHERE_SLOT}`;
-    if (desc.returning !== undefined)
-        sql += ` RETURNING ${desc.returning.join(', ')}`;
-    return { component: 'Update', sql, where, params, assembly: assembly('items') };
-}
-/** Compile a DELETE. No static params before the WHERE (all params are conditions). */
-function compileDelete(desc) {
-    const where = lowerWhere(desc.where);
-    if (where === null)
-        throw new Error('DELETE requires conditions');
-    let sql = `DELETE FROM ${desc.table}${ir_1.WHERE_SLOT}`;
-    if (desc.returning !== undefined)
-        sql += ` RETURNING ${desc.returning.join(', ')}`;
-    return { component: 'Delete', sql, where, params: [], assembly: assembly('items') };
-}
-//# sourceMappingURL=compile-sqlite.js.map

package/dist/scp/compile-sqlite.js.map

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

package/dist/scp/ir.d.ts

@@ -1,92 +0,0 @@
-/**
- * litedbmodel v2 SCP — Backend Compile IR shapes (WS1, #21).
- *
- * These are the litedbmodel-specific SQL IR structures a Component-graph CRUD node
- * carries AFTER Backend Compile (spec §8). They are the input a thin multi-language
- * runtime reads (WS3) to produce byte-identical SQL. The normative rules for how a
- * runtime expands them are `docs/proposal/sql-dynamic-expansion-spec.md`.
- *
- * ## Param slots (spec §8) — the closed Expression IR set only
- *
- * Every element of a `params` array is 1:1 with a `?` placeholder and is one of (using
- * bc's FLAT scope — input ports and node results are top-level scope roots, matching
- * `runBehavior`'s `{...input, ...results}`):
- *   - an **input reference** `{ ref: ["authorId"] }`
- *   - a **wire reference** `{ ref: ["<nodeId>", "field"] }`
- *   - an **Expression IR operator node** `{ coalesce: [{ refOpt: ["limit"] }, 20] }`
- *
- * All three are Expression IR nodes from bc's CLOSED operator set (`PORTABLE_EXPR_OPERATORS`
- * — `ref`/`refOpt`/`coalesce`/`add`/`eq`/… ~23 ops). NO litedbmodel-local opcodes are ever
- * emitted; an un-lowerable SQL construct is the Raw SQL escape hatch's concern (spec §13),
- * not a fake opcode. This is enforced by {@link assertParamsPortable}.
- */
-/** An Expression IR node (bc closed set). Opaque here; validated by the guard. */
-export type ExprNode = unknown;
-/**
- * A dynamic WHERE/SET fragment with an existence rule (spec §8).
- *
- * - `always: true` — the fragment is unconditionally present.
- * - `when: <ExprNode>` — the fragment is present iff the Expression evaluates to a
- *   truthy (present) binding. A `cond ? [...] : SKIP` in authoring lowers to a fragment
- *   whose `when` tests the presence of the driving input (§8 / feasibility §4). SKIP is
- *   NOT an Expression opcode — it is the ABSENCE of the fragment when `when` is false.
- *
- * `sql` is the fragment's literal SQL text (leading connector included, e.g. `" AND "`),
- * with `?` placeholders. `params` are the fragment's param slots (1:1 with its `?`),
- * appended to the assembled params array in fragment order only when the fragment is
- * present. `expand` marks an IN-list slot whose single `?` expands to `(?, ?, …)` per the
- * bound array's length (dynamic-expansion spec §5).
- */
-export interface Fragment {
-    /** Unconditionally present. Exactly one of `always` / `when` is set. */
-    always?: true;
-    /** Presence guard (Expression IR). Present iff it evaluates truthy. */
-    when?: ExprNode;
-    /** Literal SQL text (includes the leading connector, e.g. `" AND status = ?"`). */
-    sql: string;
-    /** Param slots (Expression IR nodes), 1:1 with this fragment's `?`. */
-    params: ExprNode[];
-    /**
-     * IN-list expansion: index into `params` whose bound value is an array; its single `?`
-     * in `sql` (written `(?)`) expands to `(?, ?, …)` (dynamic-expansion spec §5).
-     */
-    expand?: number;
-}
-/**
- * A compiled fragment tree (spec §8): ordered fragments combined by a single connector
- * (`AND` / `OR`). Nested groups parenthesize (dynamic-expansion spec §4). A `null` tree
- * means "no WHERE" (empty-WHERE degeneration, §3 of the spec).
- */
-export interface FragmentTree {
-    connector: 'AND' | 'OR';
-    fragments: (Fragment | FragmentTree)[];
-}
-/** The assembly spec (row → logical model). WS1 emits the shape only. */
-export interface AssemblySpec {
-    shape: string;
-}
-/**
- * The Backend Compile output of one CRUD node (spec §8). `sql` is the fully flattened
- * static SQL with a single `{where}` splice point where the fragment tree renders (or no
- * splice point at all for writes whose WHERE is static). `params` are the STATIC param
- * slots (those outside the fragment tree — e.g. Insert values, LIMIT); fragment params
- * are interleaved at render time per the dynamic-expansion spec.
- */
-export interface CompiledOperation {
-    /** Catalog component name (`Select` / `Insert` / `Update` / `Delete`). */
-    component: string;
-    /** SQLite dialect SQL text with a `{where}` splice marker if a fragment tree applies. */
-    sql: string;
-    /** The dynamic WHERE/SET fragment tree, or null when the WHERE is fully static/absent. */
-    where: FragmentTree | null;
-    /**
-     * Static param slots outside the fragment tree, in SQL position order. Each is an
-     * Expression IR node (input-ref / wire-ref / operator) from the closed set.
-     */
-    params: ExprNode[];
-    /** Row → logical model assembly (shape only in WS1). */
-    assembly: AssemblySpec;
-}
-/** The literal `{where}` splice marker inside `CompiledOperation.sql`. */
-export declare const WHERE_SLOT = "{where}";
-//# sourceMappingURL=ir.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ir.d.ts","sourceRoot":"","sources":["../../src/scp/ir.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,kFAAkF;AAClF,MAAM,MAAM,QAAQ,GAAG,OAAO,CAAC;AAE/B;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,QAAQ;IACvB,wEAAwE;IACxE,MAAM,CAAC,EAAE,IAAI,CAAC;IACd,uEAAuE;IACvE,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,mFAAmF;IACnF,GAAG,EAAE,MAAM,CAAC;IACZ,uEAAuE;IACvE,MAAM,EAAE,QAAQ,EAAE,CAAC;IACnB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,KAAK,GAAG,IAAI,CAAC;IACxB,SAAS,EAAE,CAAC,QAAQ,GAAG,YAAY,CAAC,EAAE,CAAC;CACxC;AAED,yEAAyE;AACzE,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC,0EAA0E;IAC1E,SAAS,EAAE,MAAM,CAAC;IAClB,yFAAyF;IACzF,GAAG,EAAE,MAAM,CAAC;IACZ,0FAA0F;IAC1F,KAAK,EAAE,YAAY,GAAG,IAAI,CAAC;IAC3B;;;OAGG;IACH,MAAM,EAAE,QAAQ,EAAE,CAAC;IACnB,wDAAwD;IACxD,QAAQ,EAAE,YAAY,CAAC;CACxB;AAED,0EAA0E;AAC1E,eAAO,MAAM,UAAU,YAAY,CAAC"}

package/dist/scp/ir.js

@@ -1,28 +0,0 @@
-"use strict";
-/**
- * litedbmodel v2 SCP — Backend Compile IR shapes (WS1, #21).
- *
- * These are the litedbmodel-specific SQL IR structures a Component-graph CRUD node
- * carries AFTER Backend Compile (spec §8). They are the input a thin multi-language
- * runtime reads (WS3) to produce byte-identical SQL. The normative rules for how a
- * runtime expands them are `docs/proposal/sql-dynamic-expansion-spec.md`.
- *
- * ## Param slots (spec §8) — the closed Expression IR set only
- *
- * Every element of a `params` array is 1:1 with a `?` placeholder and is one of (using
- * bc's FLAT scope — input ports and node results are top-level scope roots, matching
- * `runBehavior`'s `{...input, ...results}`):
- *   - an **input reference** `{ ref: ["authorId"] }`
- *   - a **wire reference** `{ ref: ["<nodeId>", "field"] }`
- *   - an **Expression IR operator node** `{ coalesce: [{ refOpt: ["limit"] }, 20] }`
- *
- * All three are Expression IR nodes from bc's CLOSED operator set (`PORTABLE_EXPR_OPERATORS`
- * — `ref`/`refOpt`/`coalesce`/`add`/`eq`/… ~23 ops). NO litedbmodel-local opcodes are ever
- * emitted; an un-lowerable SQL construct is the Raw SQL escape hatch's concern (spec §13),
- * not a fake opcode. This is enforced by {@link assertParamsPortable}.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WHERE_SLOT = void 0;
-/** The literal `{where}` splice marker inside `CompiledOperation.sql`. */
-exports.WHERE_SLOT = '{where}';
-//# sourceMappingURL=ir.js.map

package/dist/scp/ir.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ir.js","sourceRoot":"","sources":["../../src/scp/ir.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;;;AA0EH,0EAA0E;AAC7D,QAAA,UAAU,GAAG,SAAS,CAAC"}

package/dist/scp/render.d.ts

@@ -1,40 +0,0 @@
-/**
- * litedbmodel v2 SCP — fragment-tree render + param assembly (WS1, #21).
- *
- * The NORMATIVE reference implementation of `docs/proposal/sql-dynamic-expansion-spec.md`.
- * Given a compiled operation and a bound input scope, it deterministically produces the
- * final SQLite SQL text (`?` placeholders) and the flat params array. Every multi-language
- * runtime (WS3) must reproduce this byte-for-byte; this TS implementation is the golden
- * reference the conformance harness pins.
- *
- * The three moving parts (dynamic-expansion spec):
- *   §2 SKIP → fragment existence: a fragment with `when` is present iff `when` evaluates
- *       to a present (non-null / true) binding; an absent fragment contributes NO SQL and
- *       NO params.
- *   §3 empty-WHERE degeneration: if no fragment is present the whole `{where}` splice
- *       (including the ` WHERE ` keyword) collapses to the empty string.
- *   §4 AND/OR structure + parenthesization: a nested tree renders `(… <connector> …)`.
- *   §5 IN-list array expansion: a fragment slot marked `expand` turns its `(?)` into
- *       `(?, ?, …)` for each element of the bound array (0 elements → the `1 = 0`
- *       always-false degeneration, byte-identical to litedbmodel v1's empty-IN handling).
- */
-import { type Scope, type Value } from 'behavior-contracts';
-import type { CompiledOperation } from './ir';
-import { type Dialect } from './dialect';
-/** The result of rendering: final SQL text + flat params (1:1 with `?`). */
-export interface RenderedSql {
-    sql: string;
-    params: Value[];
-}
-/**
- * Render a compiled operation to final SQLite SQL + params for a bound input scope.
- *
- * Param order (matches SQL text order, dynamic-expansion spec §6): the compiled `sql`
- * splices the WHERE tree at `{where}`; static params before the marker are emitted first,
- * then the fragment params in tree order, then static params after the marker. WS1's CRUD
- * shapes place all pre-WHERE statics (Insert values, Update SET) before `{where}` and all
- * post-WHERE statics (LIMIT / OFFSET) after — so a single left-to-right walk of the
- * spliced SQL yields the canonical `?` order.
- */
-export declare function renderOperation(op: CompiledOperation, input: Scope, dialect?: Dialect): RenderedSql;
-//# sourceMappingURL=render.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../src/scp/render.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAsB,KAAK,KAAK,EAAE,KAAK,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAChF,OAAO,KAAK,EAAE,iBAAiB,EAA0B,MAAM,MAAM,CAAC;AAEtE,OAAO,EAAU,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAEjD,4EAA4E;AAC5E,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,KAAK,EAAE,CAAC;CACjB;AAqFD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,iBAAiB,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,GAAE,OAAgB,GAAG,WAAW,CA6B3G"}