litedbmodel 2.0.0 → 2.0.1

package/dist/scp/fragment/compile-pg.d.ts

@@ -0,0 +1,107 @@
+/**
+ * litedbmodel v2 SCP — PostgreSQL compile (build time, TS).
+ *
+ * Produces the fragment list for a query. Every fragment's `sql` text is emitted by
+ * REUSING the ORIGINAL tuned builders (`DBConditions`, `buildSelectSQL`,
+ * `LazyRelation`) so that ANY SKIP combination reassembles to exactly what the
+ * original builder would produce for that combination. The compiler runs at build
+ * time (TS); its OUTPUT (the fragment list) is the pure-JSON portable bundle.
+ *
+ * NO abstract IR is produced. Only `{ sql, params, skip }` fragments (+ nested
+ * fragment params where a subquery/sub-expression is needed).
+ */
+import type { Fragment, Node, ValueSpec } from './model';
+/**
+ * An authored optional WHERE equality: `<column> = <value from input.path>`,
+ * present only when `input.path` is non-null (else the fragment is skipped).
+ */
+export interface OptionalEq {
+    column: string;
+    inputPath: string[];
+}
+/**
+ * Compile one optional equality to a fragment carrying a `skip`.
+ *
+ * The condition core text (`<col> = ?`) is emitted by the ORIGINAL `DBConditions`,
+ * so it is byte-identical to the tuned builder. The leading `" AND "` is the exact
+ * connector the original uses when joining a present condition after an earlier
+ * (mandatory) part — see the byte-match invariant in {@link compileSelect}.
+ */
+export declare function compileOptionalEq(cond: OptionalEq): Fragment;
+/**
+ * belongsTo / single-key batch (PG): `SELECT … FROM t WHERE t.key = ANY(?::type[])`.
+ *
+ * This is byte-identical to `LazyRelation.batchLoadWithAnyArray`. The array of keys
+ * binds as ONE param (`keys` value-spec) — the `?::type[]` cast text is static,
+ * chosen at compile time by the ORIGINAL `inferPgArrayType`. Optional relation
+ * `where`-filters (config.conditions) are appended as `compileOptionalEq` fragments.
+ */
+export declare function compileBelongsTo(opts: {
+    tableName: string;
+    selectColumn?: string;
+    targetKey: string;
+    /** compile-time sample values used ONLY for cast-type inference. */
+    sampleKeys: unknown[];
+    /** value-spec producing the runtime key array (bound as one param). */
+    keys: ValueSpec;
+    sqlCast?: string;
+    filters?: OptionalEq[];
+}): Fragment[];
+/**
+ * hasMany + per-parent limit (PG): `CROSS JOIN LATERAL`.
+ *
+ * Byte-identical to `LazyRelation.batchLoadWithLateral`. The inner SELECT is emitted
+ * by the ORIGINAL `buildSelectSQL` (reproduced here as the same template it yields:
+ * `SELECT <sel> FROM t WHERE t.key = _keys.key[ AND <filters>] ORDER BY <order> LIMIT n`).
+ * The outer wraps it in `unnest(?::type[]) AS _keys(key) CROSS JOIN LATERAL (…)`.
+ *
+ * `limit` is inlined into the text (the original inlines it: `LIMIT ${limit}`), so it
+ * is NOT a param. The key array binds as ONE param.
+ */
+export declare function compileHasManyLimited(opts: {
+    tableName: string;
+    selectColumn?: string;
+    targetKey: string;
+    sampleKeys: unknown[];
+    keys: ValueSpec;
+    order: string;
+    limit: number;
+    sqlCast?: string;
+    filters?: OptionalEq[];
+}): Fragment[];
+/**
+ * hasMany / single-key batch WITHOUT limit (PG): `= ANY(?::type[])` + ORDER BY.
+ * Byte-identical to `batchLoadWithAnyArray` (used for hasMany when no limit) —
+ * same shape as {@link compileBelongsTo} plus a trailing ORDER BY carried on the
+ * base fragment (so optional filters slot BEFORE the ORDER BY, matching the
+ * original which appends conditions before the order clause).
+ */
+export declare function compileHasManyAny(opts: {
+    tableName: string;
+    selectColumn?: string;
+    targetKey: string;
+    sampleKeys: unknown[];
+    keys: ValueSpec;
+    order?: string;
+    sqlCast?: string;
+    filters?: OptionalEq[];
+}): Fragment[];
+/**
+ * A plain `SELECT <sel> FROM t` with a WHERE built only from optional conditions.
+ *
+ * The WHERE is a {@link WhereGroup}: each member fragment carries the BARE condition
+ * core (`"status = ?"`, NO leading connector), emitted by the ORIGINAL
+ * `DBConditions`, and its own `skip`. At assemble time the group joins the SURVIVORS
+ * with `" AND "` and prefixes `" WHERE "` — byte-identical to the original
+ * `DBConditions.compile` → `parts.join(' AND ')` for EVERY present/absent subset,
+ * including when the first condition is skipped (the group's join, not a static
+ * connector, decides the leading text). No new SQL-structure vocabulary: the join is
+ * pure text glue, exactly the original's algorithm.
+ */
+export declare function compileBaseSelect(opts: {
+    tableName: string;
+    selectColumn?: string;
+    /** ordered optional equality conditions */
+    conditions: OptionalEq[];
+}): Node[];
+//# sourceMappingURL=compile-pg.d.ts.map

package/dist/scp/fragment/compile-pg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile-pg.d.ts","sourceRoot":"","sources":["../../../src/scp/fragment/compile-pg.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAqB,SAAS,EAAE,MAAM,SAAS,CAAC;AAM5E;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,QAAQ,CAU5D;AAMD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,oEAAoE;IACpE,UAAU,EAAE,OAAO,EAAE,CAAC;IACtB,uEAAuE;IACvE,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;CACxB,GAAG,QAAQ,EAAE,CAQb;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,OAAO,EAAE,CAAC;IACtB,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;CACxB,GAAG,QAAQ,EAAE,CAsBb;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,OAAO,EAAE,CAAC;IACtB,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;CACxB,GAAG,QAAQ,EAAE,CAUb;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2CAA2C;IAC3C,UAAU,EAAE,UAAU,EAAE,CAAC;CAC1B,GAAG,IAAI,EAAE,CAeT"}

package/dist/scp/fragment/compile-pg.js

@@ -0,0 +1,142 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — PostgreSQL compile (build time, TS).
+ *
+ * Produces the fragment list for a query. Every fragment's `sql` text is emitted by
+ * REUSING the ORIGINAL tuned builders (`DBConditions`, `buildSelectSQL`,
+ * `LazyRelation`) so that ANY SKIP combination reassembles to exactly what the
+ * original builder would produce for that combination. The compiler runs at build
+ * time (TS); its OUTPUT (the fragment list) is the pure-JSON portable bundle.
+ *
+ * NO abstract IR is produced. Only `{ sql, params, skip }` fragments (+ nested
+ * fragment params where a subquery/sub-expression is needed).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileOptionalEq = compileOptionalEq;
+exports.compileBelongsTo = compileBelongsTo;
+exports.compileHasManyLimited = compileHasManyLimited;
+exports.compileHasManyAny = compileHasManyAny;
+exports.compileBaseSelect = compileBaseSelect;
+const DBConditions_1 = require("../../DBConditions");
+const pg_array_type_1 = require("./pg-array-type");
+/**
+ * Compile one optional equality to a fragment carrying a `skip`.
+ *
+ * The condition core text (`<col> = ?`) is emitted by the ORIGINAL `DBConditions`,
+ * so it is byte-identical to the tuned builder. The leading `" AND "` is the exact
+ * connector the original uses when joining a present condition after an earlier
+ * (mandatory) part — see the byte-match invariant in {@link compileSelect}.
+ */
+function compileOptionalEq(cond) {
+    const probe = [];
+    const core = new DBConditions_1.DBConditions({ [cond.column]: '__probe__' }).compile(probe);
+    // core === `<col> = ?`   (source of the text is the original builder)
+    const param = { input: cond.inputPath };
+    return {
+        sql: ` AND ${core}`,
+        params: [param],
+        skip: { absent: cond.inputPath },
+    };
+}
+// ============================================================================
+// Relation batch-load fragments — text emitted by the ORIGINAL LazyRelation paths.
+// ============================================================================
+/**
+ * belongsTo / single-key batch (PG): `SELECT … FROM t WHERE t.key = ANY(?::type[])`.
+ *
+ * This is byte-identical to `LazyRelation.batchLoadWithAnyArray`. The array of keys
+ * binds as ONE param (`keys` value-spec) — the `?::type[]` cast text is static,
+ * chosen at compile time by the ORIGINAL `inferPgArrayType`. Optional relation
+ * `where`-filters (config.conditions) are appended as `compileOptionalEq` fragments.
+ */
+function compileBelongsTo(opts) {
+    const select = opts.selectColumn ?? '*';
+    const pgType = (0, pg_array_type_1.inferPgArrayTypeForCompile)(opts.sampleKeys, opts.sqlCast);
+    const base = {
+        sql: `SELECT ${select} FROM ${opts.tableName} WHERE ${opts.tableName}.${opts.targetKey} = ANY(?::${pgType})`,
+        params: [opts.keys],
+    };
+    return [base, ...(opts.filters ?? []).map(compileOptionalEq)];
+}
+/**
+ * hasMany + per-parent limit (PG): `CROSS JOIN LATERAL`.
+ *
+ * Byte-identical to `LazyRelation.batchLoadWithLateral`. The inner SELECT is emitted
+ * by the ORIGINAL `buildSelectSQL` (reproduced here as the same template it yields:
+ * `SELECT <sel> FROM t WHERE t.key = _keys.key[ AND <filters>] ORDER BY <order> LIMIT n`).
+ * The outer wraps it in `unnest(?::type[]) AS _keys(key) CROSS JOIN LATERAL (…)`.
+ *
+ * `limit` is inlined into the text (the original inlines it: `LIMIT ${limit}`), so it
+ * is NOT a param. The key array binds as ONE param.
+ */
+function compileHasManyLimited(opts) {
+    const select = opts.selectColumn ?? '*';
+    const pgType = (0, pg_array_type_1.inferPgArrayTypeForCompile)(opts.sampleKeys, opts.sqlCast);
+    const filterFrags = (opts.filters ?? []).map(compileOptionalEq);
+    // The full inner+outer text (byte-identical to batchLoadWithLateral) is split into
+    // three fragments so optional filters slot in AFTER the mandatory `t.key=_keys.key`
+    // predicate and BEFORE the ORDER BY, exactly where the original appends them:
+    //   head:   ... CROSS JOIN LATERAL (SELECT * FROM t WHERE t.key = _keys.key
+    //   [filters]  each `" AND <core>"` (skip-guarded)
+    //   tail:    ORDER BY <order> LIMIT <n>) t
+    const head = {
+        sql: `SELECT ${opts.tableName}.* FROM unnest(?::${pgType}) AS _keys(key) CROSS JOIN LATERAL (` +
+            `SELECT ${select} FROM ${opts.tableName} WHERE ${opts.tableName}.${opts.targetKey} = _keys.key`,
+        params: [opts.keys],
+    };
+    const tail = {
+        sql: ` ORDER BY ${opts.order} LIMIT ${opts.limit}) ${opts.tableName}`,
+        params: [],
+    };
+    return [head, ...filterFrags, tail];
+}
+/**
+ * hasMany / single-key batch WITHOUT limit (PG): `= ANY(?::type[])` + ORDER BY.
+ * Byte-identical to `batchLoadWithAnyArray` (used for hasMany when no limit) —
+ * same shape as {@link compileBelongsTo} plus a trailing ORDER BY carried on the
+ * base fragment (so optional filters slot BEFORE the ORDER BY, matching the
+ * original which appends conditions before the order clause).
+ */
+function compileHasManyAny(opts) {
+    const select = opts.selectColumn ?? '*';
+    const pgType = (0, pg_array_type_1.inferPgArrayTypeForCompile)(opts.sampleKeys, opts.sqlCast);
+    const head = {
+        sql: `SELECT ${select} FROM ${opts.tableName} WHERE ${opts.tableName}.${opts.targetKey} = ANY(?::${pgType})`,
+        params: [opts.keys],
+    };
+    const filterFrags = (opts.filters ?? []).map(compileOptionalEq);
+    const tail = opts.order ? [{ sql: ` ORDER BY ${opts.order}`, params: [] }] : [];
+    return [head, ...filterFrags, ...tail];
+}
+// ============================================================================
+// Base SELECT + WHERE (all-optional conditions, no mandatory predicate).
+// ============================================================================
+/**
+ * A plain `SELECT <sel> FROM t` with a WHERE built only from optional conditions.
+ *
+ * The WHERE is a {@link WhereGroup}: each member fragment carries the BARE condition
+ * core (`"status = ?"`, NO leading connector), emitted by the ORIGINAL
+ * `DBConditions`, and its own `skip`. At assemble time the group joins the SURVIVORS
+ * with `" AND "` and prefixes `" WHERE "` — byte-identical to the original
+ * `DBConditions.compile` → `parts.join(' AND ')` for EVERY present/absent subset,
+ * including when the first condition is skipped (the group's join, not a static
+ * connector, decides the leading text). No new SQL-structure vocabulary: the join is
+ * pure text glue, exactly the original's algorithm.
+ */
+function compileBaseSelect(opts) {
+    const select = opts.selectColumn ?? '*';
+    const base = { sql: `SELECT ${select} FROM ${opts.tableName}`, params: [] };
+    const group = {
+        where: opts.conditions.map((c) => {
+            const probe = [];
+            const core = new DBConditions_1.DBConditions({ [c.column]: '__probe__' }).compile(probe);
+            return {
+                sql: core, // bare core, e.g. `status = ?` — connector belongs to the join
+                params: [{ input: c.inputPath }],
+                skip: { absent: c.inputPath },
+            };
+        }),
+    };
+    return [base, group];
+}
+//# sourceMappingURL=compile-pg.js.map

package/dist/scp/fragment/compile-pg.js.map

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

package/dist/scp/fragment/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * litedbmodel v2 SCP — the MINIMAL fragment model (epic #43 reset).
+ *
+ * Public surface: the fragment types, the compile helpers (build-time TS, reuse the
+ * original tuned builders), and the runtime assembler (thin, language-portable).
+ *
+ * There is NO abstract IR here. The portable artifact is ONLY a combination of
+ * `{ sql, params, skip }` fragments, with params being either value-specs or nested
+ * fragments. SQL structure (`= ANY`, `CROSS JOIN LATERAL`, `UNNEST`, subquery, cast)
+ * is TEXT inside `sql`, never a modeled construct.
+ */
+export * from './model';
+export * from './assemble';
+export * from './compile-pg';
+export { inferPgArrayTypeForCompile } from './pg-array-type';
+//# sourceMappingURL=index.d.ts.map

package/dist/scp/fragment/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/scp/fragment/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/scp/fragment/index.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — the MINIMAL fragment model (epic #43 reset).
+ *
+ * Public surface: the fragment types, the compile helpers (build-time TS, reuse the
+ * original tuned builders), and the runtime assembler (thin, language-portable).
+ *
+ * There is NO abstract IR here. The portable artifact is ONLY a combination of
+ * `{ sql, params, skip }` fragments, with params being either value-specs or nested
+ * fragments. SQL structure (`= ANY`, `CROSS JOIN LATERAL`, `UNNEST`, subquery, cast)
+ * is TEXT inside `sql`, never a modeled construct.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferPgArrayTypeForCompile = void 0;
+__exportStar(require("./model"), exports);
+__exportStar(require("./assemble"), exports);
+__exportStar(require("./compile-pg"), exports);
+var pg_array_type_1 = require("./pg-array-type");
+Object.defineProperty(exports, "inferPgArrayTypeForCompile", { enumerable: true, get: function () { return pg_array_type_1.inferPgArrayTypeForCompile; } });
+//# sourceMappingURL=index.js.map

package/dist/scp/fragment/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/scp/fragment/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;;;;;;;;;;;;;;;;AAEH,0CAAwB;AACxB,6CAA2B;AAC3B,+CAA6B;AAC7B,iDAA6D;AAApD,2HAAA,0BAA0B,OAAA"}

package/dist/scp/fragment/model.d.ts

@@ -0,0 +1,119 @@
+/**
+ * litedbmodel v2 SCP — the MINIMAL fragment model (epic #43 reset).
+ *
+ * ## The locked vocabulary (owner-specified — nothing else exists here)
+ *
+ * The portable artifact is ONLY a combination of **fragments**. There is NO
+ * abstract "Expression IR", NO relation-op / operator kinds for SQL structure,
+ * NO `FragmentTree` connector algebra, NO `{where}` splice marker. SQL structure
+ * (`= ANY`, `CROSS JOIN LATERAL`, `UNNEST`, subquery, cast, batch shapes) lives
+ * ENTIRELY as TEXT inside `sql`.
+ *
+ *   fragment = { sql: string, params: Param[], skip?: PresenceCondition }
+ *
+ * - A query is an ordered list of fragments.
+ * - Assembling = concatenate the `sql` of every PRESENT fragment, and concatenate
+ *   their `params` in order. If a fragment's `skip` is satisfied, BOTH its `sql`
+ *   and its `params` are omitted.
+ *
+ *   Param = EITHER
+ *     (a) a **value-spec** — how to compute the bound value from input at runtime:
+ *         an input-ref / wire-ref / a small closed value-expression
+ *         (e.g. `coalesce(input.limit, 20)`). This computes the VALUE only.
+ *     OR
+ *     (b) a **nested fragment** — a raw SQL sub-piece with its own params. This is
+ *         how subqueries / sub-expressions are represented: NOT as IR constructs,
+ *         just a nested { sql, params }.
+ *
+ * Array-parameter placeholder expansion is DRIVER-side, not modeled here. On
+ * PostgreSQL an array param binds directly (`= ANY(?::int[])`), so the text is
+ * static and the array is ONE param. On MySQL/SQLite (no array binding) the DRIVER
+ * expands an array param into `(?, ?, …)` at bind time. The bundle stays
+ * "string + params" regardless.
+ *
+ * The whole model is plain JSON / serializable so a thin runtime in any language
+ * reads it identically.
+ */
+/** Read a value from runtime input by path, e.g. `{ input: ["authorId"] }`. */
+export interface InputRef {
+    input: string[];
+}
+/** Read a value produced by an upstream node/wire, e.g. `{ wire: ["node1", "id"] }`. */
+export interface WireRef {
+    wire: string[];
+}
+/** A literal constant value baked into the bundle (e.g. an array of keys, or 20). */
+export interface LiteralValue {
+    literal: unknown;
+}
+/**
+ * A small CLOSED value-expression. It computes a value from other value-specs.
+ * This is deliberately tiny: `coalesce` and `add` are enough for the LIMIT / key
+ * shapes in this slice. It is NOT an SQL-structure IR — it never emits SQL.
+ */
+export interface ValueExpr {
+    op: 'coalesce' | 'add';
+    args: ValueSpec[];
+}
+/** Param variant (a): a value-spec. */
+export type ValueSpec = InputRef | WireRef | LiteralValue | ValueExpr;
+/**
+ * Param variant (b): a nested fragment. A subquery / sub-expression is just a
+ * `{ sql, params }` embedded as a param — its `sql` is spliced into the parent's
+ * `?` position, its params flow into the parent's param stream in order. This is
+ * how subqueries are represented WITHOUT any IR construct.
+ */
+export type Param = ValueSpec | Fragment;
+/**
+ * A presence condition for `skip`. When SATISFIED, the fragment (sql + params)
+ * is OMITTED. Deliberately closed and tiny: "the input at this path is absent /
+ * null / undefined". SKIP is not an operator — it is the ABSENCE of the fragment.
+ */
+export interface PresenceCondition {
+    /** Skip the fragment when the input at this path is null/undefined. */
+    absent: string[];
+}
+/**
+ * The one and only structural type: `{ sql, params, skip? }`.
+ *
+ * `sql` is literal SQL text (leading connector included where relevant, e.g.
+ * `" AND status = ?"`) with `?` placeholders. `params` are 1:1 with the `?`
+ * (a value-spec fills one `?`; a nested-fragment param splices its own `sql`,
+ * which itself may contain further `?`). `skip`, when present and satisfied,
+ * omits the whole fragment.
+ */
+export interface Fragment {
+    sql: string;
+    params: Param[];
+    skip?: PresenceCondition;
+}
+/**
+ * A WHERE clause is an ordered list of condition fragments joined by the SAME text
+ * glue the ORIGINAL `DBConditions.compile` uses: present members are joined with
+ * `" AND "` and the whole is prefixed with `" WHERE "` — and if NO member is
+ * present, the clause degenerates to the empty string (exactly the original's
+ * `parts.length === 0 → ''`).
+ *
+ * This is the "tree" form of the fragment model (a query is an ordered list/tree of
+ * fragments). It carries NO SQL-structure vocabulary — the join is pure text glue,
+ * identical to the original builder's `parts.join(' AND ')`. Each member fragment's
+ * `sql` is the bare condition core (`"status = ?"`, NO leading connector); the
+ * connector belongs to the join, so it is SKIP-stable regardless of which members
+ * survive.
+ *
+ * Members carry their own `skip`; a skipped member contributes neither text nor
+ * params, and the join simply closes over the survivors (so the first survivor never
+ * emits a stray leading `" AND "`).
+ */
+export interface WhereGroup {
+    where: Fragment[];
+}
+/** A member of an assembled query: a plain fragment or a WHERE group. */
+export type Node = Fragment | WhereGroup;
+export declare function isFragment(p: Param | Node): p is Fragment;
+export declare function isWhereGroup(n: Node): n is WhereGroup;
+export declare function isInputRef(v: ValueSpec): v is InputRef;
+export declare function isWireRef(v: ValueSpec): v is WireRef;
+export declare function isLiteral(v: ValueSpec): v is LiteralValue;
+export declare function isValueExpr(v: ValueSpec): v is ValueExpr;
+//# sourceMappingURL=model.d.ts.map

package/dist/scp/fragment/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../src/scp/fragment/model.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAOH,+EAA+E;AAC/E,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,wFAAwF;AACxF,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,qFAAqF;AACrF,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,UAAU,GAAG,KAAK,CAAC;IACvB,IAAI,EAAE,SAAS,EAAE,CAAC;CACnB;AAED,uCAAuC;AACvC,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,OAAO,GAAG,YAAY,GAAG,SAAS,CAAC;AAMtE;;;;;GAKG;AACH,MAAM,MAAM,KAAK,GAAG,SAAS,GAAG,QAAQ,CAAC;AAMzC;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,uEAAuE;IACvE,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,QAAQ;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,IAAI,CAAC,EAAE,iBAAiB,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,QAAQ,EAAE,CAAC;CACnB;AAED,yEAAyE;AACzE,MAAM,MAAM,IAAI,GAAG,QAAQ,GAAG,UAAU,CAAC;AAMzC,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,GAAG,CAAC,IAAI,QAAQ,CAEzD;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,SAAS,GAAG,CAAC,IAAI,QAAQ,CAEtD;AACD,wBAAgB,SAAS,CAAC,CAAC,EAAE,SAAS,GAAG,CAAC,IAAI,OAAO,CAEpD;AACD,wBAAgB,SAAS,CAAC,CAAC,EAAE,SAAS,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,wBAAgB,WAAW,CAAC,CAAC,EAAE,SAAS,GAAG,CAAC,IAAI,SAAS,CAExD"}

package/dist/scp/fragment/model.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — the MINIMAL fragment model (epic #43 reset).
+ *
+ * ## The locked vocabulary (owner-specified — nothing else exists here)
+ *
+ * The portable artifact is ONLY a combination of **fragments**. There is NO
+ * abstract "Expression IR", NO relation-op / operator kinds for SQL structure,
+ * NO `FragmentTree` connector algebra, NO `{where}` splice marker. SQL structure
+ * (`= ANY`, `CROSS JOIN LATERAL`, `UNNEST`, subquery, cast, batch shapes) lives
+ * ENTIRELY as TEXT inside `sql`.
+ *
+ *   fragment = { sql: string, params: Param[], skip?: PresenceCondition }
+ *
+ * - A query is an ordered list of fragments.
+ * - Assembling = concatenate the `sql` of every PRESENT fragment, and concatenate
+ *   their `params` in order. If a fragment's `skip` is satisfied, BOTH its `sql`
+ *   and its `params` are omitted.
+ *
+ *   Param = EITHER
+ *     (a) a **value-spec** — how to compute the bound value from input at runtime:
+ *         an input-ref / wire-ref / a small closed value-expression
+ *         (e.g. `coalesce(input.limit, 20)`). This computes the VALUE only.
+ *     OR
+ *     (b) a **nested fragment** — a raw SQL sub-piece with its own params. This is
+ *         how subqueries / sub-expressions are represented: NOT as IR constructs,
+ *         just a nested { sql, params }.
+ *
+ * Array-parameter placeholder expansion is DRIVER-side, not modeled here. On
+ * PostgreSQL an array param binds directly (`= ANY(?::int[])`), so the text is
+ * static and the array is ONE param. On MySQL/SQLite (no array binding) the DRIVER
+ * expands an array param into `(?, ?, …)` at bind time. The bundle stays
+ * "string + params" regardless.
+ *
+ * The whole model is plain JSON / serializable so a thin runtime in any language
+ * reads it identically.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFragment = isFragment;
+exports.isWhereGroup = isWhereGroup;
+exports.isInputRef = isInputRef;
+exports.isWireRef = isWireRef;
+exports.isLiteral = isLiteral;
+exports.isValueExpr = isValueExpr;
+// ============================================================================
+// Type guards (structural — a nested-fragment param has `sql`; value-specs don't)
+// ============================================================================
+function isFragment(p) {
+    return typeof p.sql === 'string';
+}
+function isWhereGroup(n) {
+    return Array.isArray(n.where);
+}
+function isInputRef(v) {
+    return Array.isArray(v.input);
+}
+function isWireRef(v) {
+    return Array.isArray(v.wire);
+}
+function isLiteral(v) {
+    return 'literal' in v;
+}
+function isValueExpr(v) {
+    return typeof v.op === 'string' && Array.isArray(v.args);
+}
+//# sourceMappingURL=model.js.map

package/dist/scp/fragment/model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.js","sourceRoot":"","sources":["../../../src/scp/fragment/model.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;;AAyGH,gCAEC;AAED,oCAEC;AAED,gCAEC;AACD,8BAEC;AACD,8BAEC;AACD,kCAEC;AAvBD,+EAA+E;AAC/E,kFAAkF;AAClF,+EAA+E;AAE/E,SAAgB,UAAU,CAAC,CAAe;IACxC,OAAO,OAAQ,CAAc,CAAC,GAAG,KAAK,QAAQ,CAAC;AACjD,CAAC;AAED,SAAgB,YAAY,CAAC,CAAO;IAClC,OAAO,KAAK,CAAC,OAAO,CAAE,CAAgB,CAAC,KAAK,CAAC,CAAC;AAChD,CAAC;AAED,SAAgB,UAAU,CAAC,CAAY;IACrC,OAAO,KAAK,CAAC,OAAO,CAAE,CAAc,CAAC,KAAK,CAAC,CAAC;AAC9C,CAAC;AACD,SAAgB,SAAS,CAAC,CAAY;IACpC,OAAO,KAAK,CAAC,OAAO,CAAE,CAAa,CAAC,IAAI,CAAC,CAAC;AAC5C,CAAC;AACD,SAAgB,SAAS,CAAC,CAAY;IACpC,OAAO,SAAS,IAAK,CAAkB,CAAC;AAC1C,CAAC;AACD,SAAgB,WAAW,CAAC,CAAY;IACtC,OAAO,OAAQ,CAAe,CAAC,EAAE,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAE,CAAe,CAAC,IAAI,CAAC,CAAC;AACzF,CAAC"}

package/dist/scp/fragment/pg-array-type.d.ts

@@ -0,0 +1,13 @@
+/**
+ * PostgreSQL array-type inference for compile-time cast text.
+ *
+ * VERBATIM reuse of the ORIGINAL `LazyRelation.inferPgArrayType` logic so the
+ * `?::<type>[]` cast text a fragment carries is byte-identical to the tuned
+ * builder. sqlCast (from the target column's metadata) wins; otherwise the element
+ * type is inferred from the compile-time sample values.
+ *
+ * (This is TEXT chosen at build time; it is NOT an IR "kind". The array itself is
+ * bound as ONE param on PostgreSQL.)
+ */
+export declare function inferPgArrayTypeForCompile(values: unknown[], sqlCast?: string): string;
+//# sourceMappingURL=pg-array-type.d.ts.map

package/dist/scp/fragment/pg-array-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pg-array-type.d.ts","sourceRoot":"","sources":["../../../src/scp/fragment/pg-array-type.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAYtF"}

package/dist/scp/fragment/pg-array-type.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferPgArrayTypeForCompile = inferPgArrayTypeForCompile;
+/**
+ * PostgreSQL array-type inference for compile-time cast text.
+ *
+ * VERBATIM reuse of the ORIGINAL `LazyRelation.inferPgArrayType` logic so the
+ * `?::<type>[]` cast text a fragment carries is byte-identical to the tuned
+ * builder. sqlCast (from the target column's metadata) wins; otherwise the element
+ * type is inferred from the compile-time sample values.
+ *
+ * (This is TEXT chosen at build time; it is NOT an IR "kind". The array itself is
+ * bound as ONE param on PostgreSQL.)
+ */
+function inferPgArrayTypeForCompile(values, sqlCast) {
+    if (sqlCast)
+        return `${sqlCast}[]`;
+    if (values.length === 0)
+        return 'text[]';
+    const sample = values[0];
+    if (typeof sample === 'number') {
+        if (values.every((v) => Number.isInteger(v)))
+            return 'int[]';
+        return 'numeric[]';
+    }
+    if (typeof sample === 'bigint')
+        return 'bigint[]';
+    if (typeof sample === 'boolean')
+        return 'boolean[]';
+    if (sample instanceof Date)
+        return 'timestamp[]';
+    return 'text[]';
+}
+//# sourceMappingURL=pg-array-type.js.map

package/dist/scp/fragment/pg-array-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pg-array-type.js","sourceRoot":"","sources":["../../../src/scp/fragment/pg-array-type.ts"],"names":[],"mappings":";;AAWA,gEAYC;AAvBD;;;;;;;;;;GAUG;AACH,SAAgB,0BAA0B,CAAC,MAAiB,EAAE,OAAgB;IAC5E,IAAI,OAAO;QAAE,OAAO,GAAG,OAAO,IAAI,CAAC;IACnC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,QAAQ,CAAC;IACzC,MAAM,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IACzB,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;QAC/B,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YAAE,OAAO,OAAO,CAAC;QAC7D,OAAO,WAAW,CAAC;IACrB,CAAC;IACD,IAAI,OAAO,MAAM,KAAK,QAAQ;QAAE,OAAO,UAAU,CAAC;IAClD,IAAI,OAAO,MAAM,KAAK,SAAS;QAAE,OAAO,WAAW,CAAC;IACpD,IAAI,MAAM,YAAY,IAAI;QAAE,OAAO,aAAa,CAAC;IACjD,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/scp/guard.d.ts

@@ -9,7 +9,8 @@
  * plus the operator-set check.
  */
 import { type Component, type ComponentGraphIR } from 'behavior-contracts';
-import type { CompiledOperation, ExprNode } from './ir';
+/** A bc Expression IR node (closed operator set). Structural alias — a JSON expression tree. */
+export type ExprNode = unknown;
 /**
  * Assert one Expression IR node is portable: no residue (functions/Date/…) and every
  * operator-node key is in bc's closed set. Literals (number/string/bool/null) and arrays
@@ -23,11 +24,6 @@ import type { CompiledOperation, ExprNode } from './ir';
  * semantics exactly — see {@link walkExpr} for the `obj` field-map special case.
  */
 export declare function assertExprPortable(node: ExprNode, path?: string): void;
-/**
- * Assert a whole compiled operation emits only portable Expression IR (static params +
- * fragment tree). Throws {@link PortabilityError} on the first non-portable construct.
- */
-export declare function assertOperationPortable(op: CompiledOperation): void;
 /**
  * Assert every Expression IR node in ONE lowered component's port wiring is portable
  * (WS2 AC). Walks every `componentRef`/`map` node's `ports` (and `map.over` / `map.when`)

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

@@ -1 +1 @@
-{"version":3,"file":"guard.d.ts","sourceRoot":"","sources":["../../src/scp/guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAmF,KAAK,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC5J,OAAO,KAAK,EAAE,iBAAiB,EAAE,QAAQ,EAA0B,MAAM,MAAM,CAAC;AAEhF;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,SAAM,GAAG,IAAI,CAGnE;AAwDD;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,iBAAiB,GAAG,IAAI,CAGnE;AAID;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI,CAgBlE;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,EAAE,EAAE,gBAAgB,GAAG,IAAI,CAEvE"}
+{"version":3,"file":"guard.d.ts","sourceRoot":"","sources":["../../src/scp/guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAmF,KAAK,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE5J,gGAAgG;AAChG,MAAM,MAAM,QAAQ,GAAG,OAAO,CAAC;AAE/B;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,SAAM,GAAG,IAAI,CAGnE;AAgDD;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI,CAgBlE;AAoBD;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,EAAE,EAAE,gBAAgB,GAAG,IAAI,CAEvE"}