litedbmodel 2.0.0 → 2.0.2

package/dist/scp/makesql/compile.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — the COMPILE step (build time, TS). Emits the tuned dialect SQL
+ * TEXT for every surface as `makeSQL` port bundles, by REUSING the ORIGINAL tuned
+ * builders (`DBConditions`/`DBValues`, `LazyRelationContext`, `Postgres/Mysql/Sqlite
+ * SqlBuilder`, `DBModel.buildSelectSQL` + single INSERT/UPDATE/DELETE). Because each
+ * bundle's `sql`/`params` come from driving the original, the assembled + rendered
+ * output is byte-identical to what the original library sends over the wire.
+ *
+ * There is NO abstract IR here and NO reduced form. The produced artifact is ONLY
+ * `makeSQL` port bundles (`{ sql, params, skip? }`) — SQL structure (`= ANY`,
+ * `CROSS JOIN LATERAL`, `UNNEST`, cast, subquery, batch shapes) is TEXT inside `sql`.
+ *
+ * The three dialects share this compile: PG compiled text is the anchor and stays
+ * byte-identical to v1 (`= ANY(?::t[])` / `UNNEST` / LATERAL). MySQL/SQLite array &
+ * batch surfaces INTENTIONALLY DEVIATE from v1 (epic #43/#45): instead of v1's
+ * N-placeholder `IN (?, …)` / multi-VALUES / `VALUES ROW` / `CASE WHEN`, they now emit a
+ * SINGLE JSON param expanded server-side (`MEMBER OF` / `JSON_TABLE` / `json_each`; see
+ * `json-array.ts` / `json-batch.ts`). Result parity with v1 is proven on real MySQL 8 +
+ * SQLite (`test/scp/json-array-parity.test.ts`). Everything else stays v1 byte-match.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noCastFormatter = exports.pgCastFormatter = void 0;
+exports.formatterFor = formatterFor;
+exports.compileWhere = compileWhere;
+exports.whereClause = whereClause;
+exports.andTrailing = andTrailing;
+const json_array_1 = require("./json-array");
+// ============================================================================
+// Per-dialect cast formatter (drives DBConditions/DBValues casting text).
+// PG applies `?::type`; MySQL/SQLite leave the placeholder unchanged (dialect-gated —
+// the .rs bug of leaking `::uuid` to MySQL/SQLite is NOT reproduced; v1's dialect-aware
+// SqlCastFormatter is the anchor).
+// ============================================================================
+/** PostgreSQL cast formatter: `?` → `?::type` (matches `DBValues` default formatter). */
+const pgCastFormatter = (placeholder, sqlType) => `${placeholder}::${sqlType}`;
+exports.pgCastFormatter = pgCastFormatter;
+/** MySQL/SQLite cast formatter: no cast (placeholder unchanged). */
+const noCastFormatter = (placeholder) => placeholder;
+exports.noCastFormatter = noCastFormatter;
+/** The cast formatter the original builders use for a given dialect. */
+function formatterFor(dialect) {
+    return dialect === 'postgres' ? exports.pgCastFormatter : exports.noCastFormatter;
+}
+// ============================================================================
+// WHERE / conditions / values — compiled by the ORIGINAL DBConditions.
+// ============================================================================
+/**
+ * Compile a WHERE clause (bare, without the `WHERE` keyword) from a condition object
+ * to a `makeSQL` bundle. The text + params come STRAIGHT from the original
+ * `DBConditions.compile(params, formatter)`, so every construct it supports —
+ * eq/ne/cmp (custom-op key), IN-list, empty-IN (`1 = 0`), IS NULL, IS NOT NULL
+ * (`dbNotNull`), boolean literal (`= TRUE`), LIKE/ILIKE/BETWEEN (custom-op/raw),
+ * IN/NOT IN subquery (`DBSubquery`), EXISTS/NOT EXISTS (`DBExists`), correlated
+ * parentRef, raw (`__raw__`), AND/OR grouping with parens (`__or__` / nested
+ * DBConditions), cast (`dbCast`/`dbCastIn`, dialect-gated), immediate inline
+ * (`dbImmediate`/`dbRaw`), dynamic (`dbDynamic`), tuple/composite IN (`dbTupleIn`) —
+ * is reproduced byte-for-byte.
+ *
+ * Empty clause → `{ sql: '', params: [] }` (the original returns `''` when no part is
+ * present; folded here into an empty bundle so composition drops it).
+ */
+function compileWhere(conditions, dialect) {
+    const params = [];
+    const formatter = formatterFor(dialect);
+    const core = (0, json_array_1.conditionsFor)(conditions, dialect).compile(params, formatter);
+    return { sql: core, params };
+}
+// ============================================================================
+// Composition helpers: prefix a bare WHERE with the connector text the original uses.
+// ============================================================================
+/**
+ * Wrap a bare WHERE core (from {@link compileWhere}) as the ` WHERE <core>` clause a
+ * SELECT/UPDATE/DELETE appends — byte-identical to the originals which do
+ * `sql += \` WHERE ${whereClause}\`` only when `whereClause` is non-empty. An empty
+ * core yields an empty bundle (no ` WHERE`).
+ */
+function whereClause(where) {
+    if (where.sql === '')
+        return { sql: '', params: [] };
+    return { sql: ` WHERE ${where.sql}`, params: where.params };
+}
+/**
+ * Compose a leading condition with an ordered list of optional (SKIP-guarded) trailing
+ * conditions joined by ` AND `, exactly as the original relation/select path appends
+ * `config.conditions` after a mandatory key predicate. Each optional member carries
+ * its own connector (` AND <core>`), so a skipped member drops its connector too.
+ *
+ * Returns the list of `makeSQL` components (head + guarded tails); the caller composes.
+ */
+function andTrailing(head, tails) {
+    const guardedTails = tails.map((t) => ({
+        sql: ` AND ${t.sql}`,
+        params: t.params,
+        ...(t.skip !== undefined ? { skip: t.skip } : {}),
+    }));
+    return [head, ...guardedTails];
+}
+//# sourceMappingURL=compile.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compile.js","sourceRoot":"","sources":["../../../src/scp/makesql/compile.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;GAmBG;;;AAqBH,oCAEC;AAqBD,oCAKC;AAYD,kCAGC;AAUD,kCAOC;AA5ED,6CAA6C;AAG7C,+EAA+E;AAC/E,0EAA0E;AAC1E,sFAAsF;AACtF,wFAAwF;AACxF,mCAAmC;AACnC,+EAA+E;AAE/E,yFAAyF;AAClF,MAAM,eAAe,GAAqB,CAAC,WAAW,EAAE,OAAO,EAAE,EAAE,CAAC,GAAG,WAAW,KAAK,OAAO,EAAE,CAAC;AAA3F,QAAA,eAAe,mBAA4E;AACxG,oEAAoE;AAC7D,MAAM,eAAe,GAAqB,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,CAAC;AAAjE,QAAA,eAAe,mBAAkD;AAE9E,wEAAwE;AACxE,SAAgB,YAAY,CAAC,OAAgB;IAC3C,OAAO,OAAO,KAAK,UAAU,CAAC,CAAC,CAAC,uBAAe,CAAC,CAAC,CAAC,uBAAe,CAAC;AACpE,CAAC;AAED,+EAA+E;AAC/E,uEAAuE;AACvE,+EAA+E;AAE/E;;;;;;;;;;;;;;GAcG;AACH,SAAgB,YAAY,CAAC,UAA2B,EAAE,OAAgB;IACxE,MAAM,MAAM,GAAc,EAAE,CAAC;IAC7B,MAAM,SAAS,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;IACxC,MAAM,IAAI,GAAG,IAAA,0BAAa,EAAC,UAAU,EAAE,OAAO,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC3E,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;AAC/B,CAAC;AAED,+EAA+E;AAC/E,sFAAsF;AACtF,+EAA+E;AAE/E;;;;;GAKG;AACH,SAAgB,WAAW,CAAC,KAAc;IACxC,IAAI,KAAK,CAAC,GAAG,KAAK,EAAE;QAAE,OAAO,EAAE,GAAG,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;IACrD,OAAO,EAAE,GAAG,EAAE,UAAU,KAAK,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;AAC9D,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,WAAW,CAAC,IAAa,EAAE,KAAgB;IACzD,MAAM,YAAY,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QACrC,GAAG,EAAE,QAAQ,CAAC,CAAC,GAAG,EAAE;QACpB,MAAM,EAAE,CAAC,CAAC,MAAM;QAChB,GAAG,CAAC,CAAC,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAClD,CAAC,CAAC,CAAC;IACJ,OAAO,CAAC,IAAI,EAAE,GAAG,YAAY,CAAC,CAAC;AACjC,CAAC"}

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

@@ -0,0 +1,58 @@
+/**
+ * litedbmodel v2 SCP — the `makeSQL` HANDLER + dialect placeholder render.
+ *
+ * The handler is the ONE consumer implementation point behind the `makeSQL` catalog
+ * leaf (spec §11 item 4): it receives the evaluated `{ sql, params, skip }` port
+ * bundle from bc's `runBehavior`, assembles it (drop-on-skip, splice nested makeSQL),
+ * renders the dialect placeholder form, binds params, and executes the SQL. Side
+ * effects / driver / connection live entirely here (C4 — the IR carries no
+ * implementation).
+ *
+ * bc supplies composition / value-eval / envelope / plan; litedbmodel supplies only
+ * this handler + the compile that emits the SQL text.
+ */
+import type { Handler, HandlerCtx, Value } from 'behavior-contracts';
+import { type AssembledSql } from './makesql';
+/** A driver seam: run an already-rendered `{ sql, params }` and return result rows. */
+export type SqlExecutor = (sql: string, params: unknown[]) => Promise<Record<string, unknown>[]>;
+/** Synchronous driver seam (e.g. better-sqlite3) for the sync `runBehavior` path. */
+export type SqlExecutorSync = (sql: string, params: unknown[]) => Record<string, unknown>[];
+/** The dialect placeholder form: PostgreSQL uses `$N`, MySQL/SQLite keep `?`. */
+export type Dialect = 'postgres' | 'mysql' | 'sqlite';
+/**
+ * Render `?` placeholders into the dialect form.
+ *
+ * - PostgreSQL: `?` → `$1, $2, …` left-to-right, **quote-aware** — a `?` inside a
+ *   single-quoted SQL string literal is NOT a placeholder and is left untouched (mirrors
+ *   `litedbmodel.rs` `rewrite_placeholders`, #42). For SQL with no literal `?` (all
+ *   compiled forms today) this is byte-identical to the original naive
+ *   `src/drivers/postgres.ts` `convertPlaceholders`; it only diverges — correctly — when a
+ *   string literal contains a `?` (e.g. a Raw-SQL escape hatch), which the naive form would
+ *   mis-number.
+ * - MySQL / SQLite: `?` unchanged.
+ *
+ * There is NO array placeholder-count-expansion for ANY dialect (epic #43/#45): every
+ * array/batch surface now binds the whole array/rows as ONE param against STATIC SQL
+ * text — PG via `= ANY(?::t[])` / `UNNEST`, MySQL/SQLite via a single JSON param expanded
+ * server-side (`MEMBER OF` / `JSON_TABLE` / `json_each`; see `json-array.ts`/`json-batch.ts`).
+ * So `renderPlaceholders` is a pure `?`→`$N` mapping with a fixed placeholder count.
+ */
+export declare function renderPlaceholders(sql: string, dialect: Dialect): string;
+/** Assemble the evaluated ports (drop-on-skip, splice nested) and render the dialect form. */
+export declare function renderPorts(ports: Record<string, Value>, dialect: Dialect): AssembledSql;
+/**
+ * Build the async `makeSQL` handler bound to a driver + dialect. This is what a
+ * consumer registers under the catalog name `makeSQL` for `runBehaviorAsync`.
+ *
+ * A skipped component contributes nothing and never touches the driver — it returns
+ * the empty result (`[]`) so downstream wiring reading its result sees "no rows".
+ */
+export declare function makeSqlHandler(exec: SqlExecutor, dialect: Dialect): (ports: Record<string, Value>, _ctx: HandlerCtx) => Promise<{
+    ok: Value;
+}>;
+/**
+ * Build the synchronous `makeSQL` handler (for `runBehavior` + a sync driver such as
+ * better-sqlite3). Returns a bc {@link Handler}.
+ */
+export declare function makeSqlHandlerSync(exec: SqlExecutorSync, dialect: Dialect): Handler;
+//# sourceMappingURL=handler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../../../src/scp/makesql/handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AACrE,OAAO,EAAiC,KAAK,YAAY,EAAE,MAAM,WAAW,CAAC;AAE7E,uFAAuF;AACvF,MAAM,MAAM,WAAW,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;AACjG,qFAAqF;AACrF,MAAM,MAAM,eAAe,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;AAE5F,iFAAiF;AACjF,MAAM,MAAM,OAAO,GAAG,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAC;AAEtD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAoBxE;AAgBD,8FAA8F;AAC9F,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,OAAO,GAAG,YAAY,CAIxF;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,IAClD,OAAO,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,UAAU;QACH,KAAK;GAK/D;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAOnF"}

package/dist/scp/makesql/handler.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — the `makeSQL` HANDLER + dialect placeholder render.
+ *
+ * The handler is the ONE consumer implementation point behind the `makeSQL` catalog
+ * leaf (spec §11 item 4): it receives the evaluated `{ sql, params, skip }` port
+ * bundle from bc's `runBehavior`, assembles it (drop-on-skip, splice nested makeSQL),
+ * renders the dialect placeholder form, binds params, and executes the SQL. Side
+ * effects / driver / connection live entirely here (C4 — the IR carries no
+ * implementation).
+ *
+ * bc supplies composition / value-eval / envelope / plan; litedbmodel supplies only
+ * this handler + the compile that emits the SQL text.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderPlaceholders = renderPlaceholders;
+exports.renderPorts = renderPorts;
+exports.makeSqlHandler = makeSqlHandler;
+exports.makeSqlHandlerSync = makeSqlHandlerSync;
+const makesql_1 = require("./makesql");
+/**
+ * Render `?` placeholders into the dialect form.
+ *
+ * - PostgreSQL: `?` → `$1, $2, …` left-to-right, **quote-aware** — a `?` inside a
+ *   single-quoted SQL string literal is NOT a placeholder and is left untouched (mirrors
+ *   `litedbmodel.rs` `rewrite_placeholders`, #42). For SQL with no literal `?` (all
+ *   compiled forms today) this is byte-identical to the original naive
+ *   `src/drivers/postgres.ts` `convertPlaceholders`; it only diverges — correctly — when a
+ *   string literal contains a `?` (e.g. a Raw-SQL escape hatch), which the naive form would
+ *   mis-number.
+ * - MySQL / SQLite: `?` unchanged.
+ *
+ * There is NO array placeholder-count-expansion for ANY dialect (epic #43/#45): every
+ * array/batch surface now binds the whole array/rows as ONE param against STATIC SQL
+ * text — PG via `= ANY(?::t[])` / `UNNEST`, MySQL/SQLite via a single JSON param expanded
+ * server-side (`MEMBER OF` / `JSON_TABLE` / `json_each`; see `json-array.ts`/`json-batch.ts`).
+ * So `renderPlaceholders` is a pure `?`→`$N` mapping with a fixed placeholder count.
+ */
+function renderPlaceholders(sql, dialect) {
+    if (dialect !== 'postgres')
+        return sql;
+    let out = '';
+    let index = 0;
+    let inString = false;
+    for (let i = 0; i < sql.length; i++) {
+        const ch = sql[i];
+        if (inString) {
+            out += ch;
+            if (ch === "'")
+                inString = false; // end of string literal (SQL '' escape re-opens on the next ')
+        }
+        else if (ch === "'") {
+            out += ch;
+            inString = true;
+        }
+        else if (ch === '?') {
+            out += `$${++index}`;
+        }
+        else {
+            out += ch;
+        }
+    }
+    return out;
+}
+/**
+ * Coerce the evaluated `params` port back to a `MakeSQL['params']` list. bc evaluates
+ * each port value; a nested `makeSQL` param arrives as an object `{ sql, params, skip? }`
+ * and a bound value arrives as its opaque value. Nothing to transform — the handler
+ * treats them structurally in {@link assembleMakeSQL}.
+ */
+function toMakeSQL(ports) {
+    return {
+        sql: ports.sql,
+        params: ports.params ?? [],
+        skip: ports.skip === true,
+    };
+}
+/** Assemble the evaluated ports (drop-on-skip, splice nested) and render the dialect form. */
+function renderPorts(ports, dialect) {
+    const node = toMakeSQL(ports);
+    const assembled = (0, makesql_1.assembleMakeSQL)(node);
+    return { sql: renderPlaceholders(assembled.sql, dialect), params: assembled.params };
+}
+/**
+ * Build the async `makeSQL` handler bound to a driver + dialect. This is what a
+ * consumer registers under the catalog name `makeSQL` for `runBehaviorAsync`.
+ *
+ * A skipped component contributes nothing and never touches the driver — it returns
+ * the empty result (`[]`) so downstream wiring reading its result sees "no rows".
+ */
+function makeSqlHandler(exec, dialect) {
+    return async (ports, _ctx) => {
+        if (ports.skip === true)
+            return { ok: [] };
+        const { sql, params } = renderPorts(ports, dialect);
+        const rows = await exec(sql, params);
+        return { ok: rows };
+    };
+}
+/**
+ * Build the synchronous `makeSQL` handler (for `runBehavior` + a sync driver such as
+ * better-sqlite3). Returns a bc {@link Handler}.
+ */
+function makeSqlHandlerSync(exec, dialect) {
+    return (ports, _ctx) => {
+        if (ports.skip === true)
+            return { ok: [] };
+        const { sql, params } = renderPorts(ports, dialect);
+        const rows = exec(sql, params);
+        return { ok: rows };
+    };
+}
+//# sourceMappingURL=handler.js.map

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

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

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

@@ -0,0 +1,33 @@
+/**
+ * litedbmodel v2 SCP — the LOCKED `makeSQL` surface (epic #43 / design #45).
+ *
+ * ONE bc catalog component `makeSQL(sql, params, skip?)` + its handler + the compile
+ * that emits tuned dialect SQL text (by reusing the original builders). A query is a
+ * composition of `makeSQL` components; a subquery is a nested `makeSQL` in a param
+ * slot. Everything (`= ANY`, LATERAL, UNNEST, cast, batch shapes) is TEXT inside `sql`.
+ * bc supplies composition / value-eval / envelope / plan; litedbmodel supplies the
+ * catalog leaf + handler + compile. Pure-JSON bundle, multi-language ready.
+ */
+export { MAKESQL, makeSqlCatalogEntry, LITEDBMODEL_MAKESQL_CATALOG, isMakeSQL, assembleMakeSQL, composeMakeSQL, } from './makesql';
+export type { MakeSQL, SqlParam, AssembledSql } from './makesql';
+export { renderPlaceholders, renderPorts, makeSqlHandler, makeSqlHandlerSync, } from './handler';
+export type { Dialect, SqlExecutor, SqlExecutorSync } from './handler';
+export { compileWhere, whereClause, andTrailing, formatterFor, pgCastFormatter, noCastFormatter, } from './compile';
+export { compileSelect } from './compile-select';
+export type { SelectDesc } from './compile-select';
+export { builderFor, compileInsert, compileInsertMany, compileUpdateMany, compileUpdateSingle, compileDelete, compileDeleteMany, } from './compile-crud';
+export type { InsertManyBuildOptions } from './compile-crud';
+export { inferPgArrayType, resolvePgArrayCast, PG_ARRAY_CAST_TOKEN, compileSingleKeyUnlimited, compileSingleKeyLimited, compileCompositeKeyUnlimited, compileCompositeKeyStaticUnlimited, compileCompositeKeyLimited, compileCompositeKeyStaticLimited, } from './compile-relation';
+export type { RelationCompileBase } from './compile-relation';
+export { inListJson, JsonArrayConditions, conditionsFor } from './json-array';
+export { mysqlInsertJson, sqliteInsertJson, mysqlUpdateManyJson, sqliteUpdateManyJson, mysqlJsonTableColumn, rowsHaveDbToken, } from './json-batch';
+export { makeSqlComponentIR, makeSqlInput } from './ir';
+export { deriveTransactionPlan, deriveBatchPlan, literalize, mysqlPkHint, stripMysqlPkHint, executeTransaction, countingDriver, renderTxStatement, compileWriteNode, IN_SENTINEL, } from './tx';
+export type { TxExpr, TxOp, StatementRole, GateRule, TxStatement, IdempotentHitPolicy, TransactionPlan, BaseWrite, SqliteDb, ShortCircuitReason, TransactionResult, } from './tx';
+export { compileAuthoredBehavior, compileAuthoredNode, compileRelationMap, } from './authoring-compile';
+export type { AuthoredMakeSQL, RelationMapInput } from './authoring-compile';
+export { compileStaticBundle, compileSelectNode, executeStaticBundle, executeStaticWrite, executeReadBehavior, compileReadGraph, executeReadGraph, executeReadGraphAsync, renderReadPrimary, } from './static-bundle';
+export type { StaticBundle, StaticStatement, ValueSpec, ReadGraph, SqlExecutorAsync } from './static-bundle';
+export { pgPoolExecutor, mysqlPoolExecutor } from './pool-executor';
+export type { PgPoolLike, MysqlPoolLike } from './pool-executor';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/scp/makesql/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EACL,OAAO,EACP,mBAAmB,EACnB,2BAA2B,EAC3B,SAAS,EACT,eAAe,EACf,cAAc,GACf,MAAM,WAAW,CAAC;AACnB,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAGjE,OAAO,EACL,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,kBAAkB,GACnB,MAAM,WAAW,CAAC;AACnB,YAAY,EAAE,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAGvE,OAAO,EACL,YAAY,EACZ,WAAW,EACX,WAAW,EACX,YAAY,EACZ,eAAe,EACf,eAAe,GAChB,MAAM,WAAW,CAAC;AAGnB,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,YAAY,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAGnD,OAAO,EACL,UAAU,EACV,aAAa,EACb,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,aAAa,EACb,iBAAiB,GAClB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAG7D,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,EACnB,yBAAyB,EACzB,uBAAuB,EACvB,4BAA4B,EAC5B,kCAAkC,EAClC,0BAA0B,EAC1B,gCAAgC,GACjC,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAI9D,OAAO,EAAE,UAAU,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC9E,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,eAAe,GAChB,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAGxD,OAAO,EACL,qBAAqB,EACrB,eAAe,EACf,UAAU,EACV,WAAW,EACX,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,WAAW,GACZ,MAAM,MAAM,CAAC;AACd,YAAY,EACV,MAAM,EACN,IAAI,EACJ,aAAa,EACb,QAAQ,EACR,WAAW,EACX,mBAAmB,EACnB,eAAe,EACf,SAAS,EACT,QAAQ,EACR,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,MAAM,CAAC;AAKd,OAAO,EACL,uBAAuB,EACvB,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAK7E,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,EAChB,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,SAAS,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAI7G,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpE,YAAY,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/scp/makesql/index.js

@@ -0,0 +1,114 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — the LOCKED `makeSQL` surface (epic #43 / design #45).
+ *
+ * ONE bc catalog component `makeSQL(sql, params, skip?)` + its handler + the compile
+ * that emits tuned dialect SQL text (by reusing the original builders). A query is a
+ * composition of `makeSQL` components; a subquery is a nested `makeSQL` in a param
+ * slot. Everything (`= ANY`, LATERAL, UNNEST, cast, batch shapes) is TEXT inside `sql`.
+ * bc supplies composition / value-eval / envelope / plan; litedbmodel supplies the
+ * catalog leaf + handler + compile. Pure-JSON bundle, multi-language ready.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeTransaction = exports.stripMysqlPkHint = exports.mysqlPkHint = exports.literalize = exports.deriveBatchPlan = exports.deriveTransactionPlan = exports.makeSqlInput = exports.makeSqlComponentIR = exports.rowsHaveDbToken = exports.mysqlJsonTableColumn = exports.sqliteUpdateManyJson = exports.mysqlUpdateManyJson = exports.sqliteInsertJson = exports.mysqlInsertJson = exports.conditionsFor = exports.JsonArrayConditions = exports.inListJson = exports.compileCompositeKeyStaticLimited = exports.compileCompositeKeyLimited = exports.compileCompositeKeyStaticUnlimited = exports.compileCompositeKeyUnlimited = exports.compileSingleKeyLimited = exports.compileSingleKeyUnlimited = exports.PG_ARRAY_CAST_TOKEN = exports.resolvePgArrayCast = exports.inferPgArrayType = exports.compileDeleteMany = exports.compileDelete = exports.compileUpdateSingle = exports.compileUpdateMany = exports.compileInsertMany = exports.compileInsert = exports.builderFor = exports.compileSelect = exports.noCastFormatter = exports.pgCastFormatter = exports.formatterFor = exports.andTrailing = exports.whereClause = exports.compileWhere = exports.makeSqlHandlerSync = exports.makeSqlHandler = exports.renderPorts = exports.renderPlaceholders = exports.composeMakeSQL = exports.assembleMakeSQL = exports.isMakeSQL = exports.LITEDBMODEL_MAKESQL_CATALOG = exports.makeSqlCatalogEntry = exports.MAKESQL = void 0;
+exports.mysqlPoolExecutor = exports.pgPoolExecutor = exports.renderReadPrimary = exports.executeReadGraphAsync = exports.executeReadGraph = exports.compileReadGraph = exports.executeReadBehavior = exports.executeStaticWrite = exports.executeStaticBundle = exports.compileSelectNode = exports.compileStaticBundle = exports.compileRelationMap = exports.compileAuthoredNode = exports.compileAuthoredBehavior = exports.IN_SENTINEL = exports.compileWriteNode = exports.renderTxStatement = exports.countingDriver = void 0;
+// Catalog leaf + assembly core.
+var makesql_1 = require("./makesql");
+Object.defineProperty(exports, "MAKESQL", { enumerable: true, get: function () { return makesql_1.MAKESQL; } });
+Object.defineProperty(exports, "makeSqlCatalogEntry", { enumerable: true, get: function () { return makesql_1.makeSqlCatalogEntry; } });
+Object.defineProperty(exports, "LITEDBMODEL_MAKESQL_CATALOG", { enumerable: true, get: function () { return makesql_1.LITEDBMODEL_MAKESQL_CATALOG; } });
+Object.defineProperty(exports, "isMakeSQL", { enumerable: true, get: function () { return makesql_1.isMakeSQL; } });
+Object.defineProperty(exports, "assembleMakeSQL", { enumerable: true, get: function () { return makesql_1.assembleMakeSQL; } });
+Object.defineProperty(exports, "composeMakeSQL", { enumerable: true, get: function () { return makesql_1.composeMakeSQL; } });
+// Handler + dialect placeholder render.
+var handler_1 = require("./handler");
+Object.defineProperty(exports, "renderPlaceholders", { enumerable: true, get: function () { return handler_1.renderPlaceholders; } });
+Object.defineProperty(exports, "renderPorts", { enumerable: true, get: function () { return handler_1.renderPorts; } });
+Object.defineProperty(exports, "makeSqlHandler", { enumerable: true, get: function () { return handler_1.makeSqlHandler; } });
+Object.defineProperty(exports, "makeSqlHandlerSync", { enumerable: true, get: function () { return handler_1.makeSqlHandlerSync; } });
+// Compile (WHERE / conditions / values).
+var compile_1 = require("./compile");
+Object.defineProperty(exports, "compileWhere", { enumerable: true, get: function () { return compile_1.compileWhere; } });
+Object.defineProperty(exports, "whereClause", { enumerable: true, get: function () { return compile_1.whereClause; } });
+Object.defineProperty(exports, "andTrailing", { enumerable: true, get: function () { return compile_1.andTrailing; } });
+Object.defineProperty(exports, "formatterFor", { enumerable: true, get: function () { return compile_1.formatterFor; } });
+Object.defineProperty(exports, "pgCastFormatter", { enumerable: true, get: function () { return compile_1.pgCastFormatter; } });
+Object.defineProperty(exports, "noCastFormatter", { enumerable: true, get: function () { return compile_1.noCastFormatter; } });
+// Compile (SELECT tail).
+var compile_select_1 = require("./compile-select");
+Object.defineProperty(exports, "compileSelect", { enumerable: true, get: function () { return compile_select_1.compileSelect; } });
+// Compile (CRUD).
+var compile_crud_1 = require("./compile-crud");
+Object.defineProperty(exports, "builderFor", { enumerable: true, get: function () { return compile_crud_1.builderFor; } });
+Object.defineProperty(exports, "compileInsert", { enumerable: true, get: function () { return compile_crud_1.compileInsert; } });
+Object.defineProperty(exports, "compileInsertMany", { enumerable: true, get: function () { return compile_crud_1.compileInsertMany; } });
+Object.defineProperty(exports, "compileUpdateMany", { enumerable: true, get: function () { return compile_crud_1.compileUpdateMany; } });
+Object.defineProperty(exports, "compileUpdateSingle", { enumerable: true, get: function () { return compile_crud_1.compileUpdateSingle; } });
+Object.defineProperty(exports, "compileDelete", { enumerable: true, get: function () { return compile_crud_1.compileDelete; } });
+Object.defineProperty(exports, "compileDeleteMany", { enumerable: true, get: function () { return compile_crud_1.compileDeleteMany; } });
+// Compile (relations).
+var compile_relation_1 = require("./compile-relation");
+Object.defineProperty(exports, "inferPgArrayType", { enumerable: true, get: function () { return compile_relation_1.inferPgArrayType; } });
+Object.defineProperty(exports, "resolvePgArrayCast", { enumerable: true, get: function () { return compile_relation_1.resolvePgArrayCast; } });
+Object.defineProperty(exports, "PG_ARRAY_CAST_TOKEN", { enumerable: true, get: function () { return compile_relation_1.PG_ARRAY_CAST_TOKEN; } });
+Object.defineProperty(exports, "compileSingleKeyUnlimited", { enumerable: true, get: function () { return compile_relation_1.compileSingleKeyUnlimited; } });
+Object.defineProperty(exports, "compileSingleKeyLimited", { enumerable: true, get: function () { return compile_relation_1.compileSingleKeyLimited; } });
+Object.defineProperty(exports, "compileCompositeKeyUnlimited", { enumerable: true, get: function () { return compile_relation_1.compileCompositeKeyUnlimited; } });
+Object.defineProperty(exports, "compileCompositeKeyStaticUnlimited", { enumerable: true, get: function () { return compile_relation_1.compileCompositeKeyStaticUnlimited; } });
+Object.defineProperty(exports, "compileCompositeKeyLimited", { enumerable: true, get: function () { return compile_relation_1.compileCompositeKeyLimited; } });
+Object.defineProperty(exports, "compileCompositeKeyStaticLimited", { enumerable: true, get: function () { return compile_relation_1.compileCompositeKeyStaticLimited; } });
+// Single-JSON-param array/batch forms for MySQL 8 + SQLite (epic #43/#45) — the
+// intentional deviation from v1's N-placeholder expansion (server-side JSON expansion).
+var json_array_1 = require("./json-array");
+Object.defineProperty(exports, "inListJson", { enumerable: true, get: function () { return json_array_1.inListJson; } });
+Object.defineProperty(exports, "JsonArrayConditions", { enumerable: true, get: function () { return json_array_1.JsonArrayConditions; } });
+Object.defineProperty(exports, "conditionsFor", { enumerable: true, get: function () { return json_array_1.conditionsFor; } });
+var json_batch_1 = require("./json-batch");
+Object.defineProperty(exports, "mysqlInsertJson", { enumerable: true, get: function () { return json_batch_1.mysqlInsertJson; } });
+Object.defineProperty(exports, "sqliteInsertJson", { enumerable: true, get: function () { return json_batch_1.sqliteInsertJson; } });
+Object.defineProperty(exports, "mysqlUpdateManyJson", { enumerable: true, get: function () { return json_batch_1.mysqlUpdateManyJson; } });
+Object.defineProperty(exports, "sqliteUpdateManyJson", { enumerable: true, get: function () { return json_batch_1.sqliteUpdateManyJson; } });
+Object.defineProperty(exports, "mysqlJsonTableColumn", { enumerable: true, get: function () { return json_batch_1.mysqlJsonTableColumn; } });
+Object.defineProperty(exports, "rowsHaveDbToken", { enumerable: true, get: function () { return json_batch_1.rowsHaveDbToken; } });
+// bc IR wiring (a query rides runBehavior as a makeSQL component).
+var ir_1 = require("./ir");
+Object.defineProperty(exports, "makeSqlComponentIR", { enumerable: true, get: function () { return ir_1.makeSqlComponentIR; } });
+Object.defineProperty(exports, "makeSqlInput", { enumerable: true, get: function () { return ir_1.makeSqlInput; } });
+// Write-time relations → makeSQL transaction plan + 1-tx runtime (epic #43/#45 Phase B).
+var tx_1 = require("./tx");
+Object.defineProperty(exports, "deriveTransactionPlan", { enumerable: true, get: function () { return tx_1.deriveTransactionPlan; } });
+Object.defineProperty(exports, "deriveBatchPlan", { enumerable: true, get: function () { return tx_1.deriveBatchPlan; } });
+Object.defineProperty(exports, "literalize", { enumerable: true, get: function () { return tx_1.literalize; } });
+Object.defineProperty(exports, "mysqlPkHint", { enumerable: true, get: function () { return tx_1.mysqlPkHint; } });
+Object.defineProperty(exports, "stripMysqlPkHint", { enumerable: true, get: function () { return tx_1.stripMysqlPkHint; } });
+Object.defineProperty(exports, "executeTransaction", { enumerable: true, get: function () { return tx_1.executeTransaction; } });
+Object.defineProperty(exports, "countingDriver", { enumerable: true, get: function () { return tx_1.countingDriver; } });
+Object.defineProperty(exports, "renderTxStatement", { enumerable: true, get: function () { return tx_1.renderTxStatement; } });
+Object.defineProperty(exports, "compileWriteNode", { enumerable: true, get: function () { return tx_1.compileWriteNode; } });
+Object.defineProperty(exports, "IN_SENTINEL", { enumerable: true, get: function () { return tx_1.IN_SENTINEL; } });
+// Authoring → makeSQL bundle (Phase A, epic #43/#45): the ADDITIVE producer that routes an
+// authored behavior's declared/eager query (WS2 `../authoring.ts` component IR) through the
+// makeSQL compile* — preserving the single-compile-path invariant (declaration ≡ eager).
+var authoring_compile_1 = require("./authoring-compile");
+Object.defineProperty(exports, "compileAuthoredBehavior", { enumerable: true, get: function () { return authoring_compile_1.compileAuthoredBehavior; } });
+Object.defineProperty(exports, "compileAuthoredNode", { enumerable: true, get: function () { return authoring_compile_1.compileAuthoredNode; } });
+Object.defineProperty(exports, "compileRelationMap", { enumerable: true, get: function () { return authoring_compile_1.compileRelationMap; } });
+// The STATIC, portable makeSQL bundle + runtime (design #45 owner-confirmed static-bundle):
+// symbolic compile (no concrete input) → deferred value-specs + skip expression, bc-evaluated
+// per-input at runtime. The SOLE makeSQL read/compile path (epic #43/#45 Phase B).
+var static_bundle_1 = require("./static-bundle");
+Object.defineProperty(exports, "compileStaticBundle", { enumerable: true, get: function () { return static_bundle_1.compileStaticBundle; } });
+Object.defineProperty(exports, "compileSelectNode", { enumerable: true, get: function () { return static_bundle_1.compileSelectNode; } });
+Object.defineProperty(exports, "executeStaticBundle", { enumerable: true, get: function () { return static_bundle_1.executeStaticBundle; } });
+Object.defineProperty(exports, "executeStaticWrite", { enumerable: true, get: function () { return static_bundle_1.executeStaticWrite; } });
+Object.defineProperty(exports, "executeReadBehavior", { enumerable: true, get: function () { return static_bundle_1.executeReadBehavior; } });
+Object.defineProperty(exports, "compileReadGraph", { enumerable: true, get: function () { return static_bundle_1.compileReadGraph; } });
+Object.defineProperty(exports, "executeReadGraph", { enumerable: true, get: function () { return static_bundle_1.executeReadGraph; } });
+Object.defineProperty(exports, "executeReadGraphAsync", { enumerable: true, get: function () { return static_bundle_1.executeReadGraphAsync; } });
+Object.defineProperty(exports, "renderReadPrimary", { enumerable: true, get: function () { return static_bundle_1.renderReadPrimary; } });
+// Pooled async executor factories (PG / MySQL) that turn the plan's concurrency into real parallel
+// read-relation DB I/O behind the async seam (#40).
+var pool_executor_1 = require("./pool-executor");
+Object.defineProperty(exports, "pgPoolExecutor", { enumerable: true, get: function () { return pool_executor_1.pgPoolExecutor; } });
+Object.defineProperty(exports, "mysqlPoolExecutor", { enumerable: true, get: function () { return pool_executor_1.mysqlPoolExecutor; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/scp/makesql/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;;AAEH,gCAAgC;AAChC,qCAOmB;AANjB,kGAAA,OAAO,OAAA;AACP,8GAAA,mBAAmB,OAAA;AACnB,sHAAA,2BAA2B,OAAA;AAC3B,oGAAA,SAAS,OAAA;AACT,0GAAA,eAAe,OAAA;AACf,yGAAA,cAAc,OAAA;AAIhB,wCAAwC;AACxC,qCAKmB;AAJjB,6GAAA,kBAAkB,OAAA;AAClB,sGAAA,WAAW,OAAA;AACX,yGAAA,cAAc,OAAA;AACd,6GAAA,kBAAkB,OAAA;AAIpB,yCAAyC;AACzC,qCAOmB;AANjB,uGAAA,YAAY,OAAA;AACZ,sGAAA,WAAW,OAAA;AACX,sGAAA,WAAW,OAAA;AACX,uGAAA,YAAY,OAAA;AACZ,0GAAA,eAAe,OAAA;AACf,0GAAA,eAAe,OAAA;AAGjB,yBAAyB;AACzB,mDAAiD;AAAxC,+GAAA,aAAa,OAAA;AAGtB,kBAAkB;AAClB,+CAQwB;AAPtB,0GAAA,UAAU,OAAA;AACV,6GAAA,aAAa,OAAA;AACb,iHAAA,iBAAiB,OAAA;AACjB,iHAAA,iBAAiB,OAAA;AACjB,mHAAA,mBAAmB,OAAA;AACnB,6GAAA,aAAa,OAAA;AACb,iHAAA,iBAAiB,OAAA;AAInB,uBAAuB;AACvB,uDAU4B;AAT1B,oHAAA,gBAAgB,OAAA;AAChB,sHAAA,kBAAkB,OAAA;AAClB,uHAAA,mBAAmB,OAAA;AACnB,6HAAA,yBAAyB,OAAA;AACzB,2HAAA,uBAAuB,OAAA;AACvB,gIAAA,4BAA4B,OAAA;AAC5B,sIAAA,kCAAkC,OAAA;AAClC,8HAAA,0BAA0B,OAAA;AAC1B,oIAAA,gCAAgC,OAAA;AAIlC,gFAAgF;AAChF,wFAAwF;AACxF,2CAA8E;AAArE,wGAAA,UAAU,OAAA;AAAE,iHAAA,mBAAmB,OAAA;AAAE,2GAAA,aAAa,OAAA;AACvD,2CAOsB;AANpB,6GAAA,eAAe,OAAA;AACf,8GAAA,gBAAgB,OAAA;AAChB,iHAAA,mBAAmB,OAAA;AACnB,kHAAA,oBAAoB,OAAA;AACpB,kHAAA,oBAAoB,OAAA;AACpB,6GAAA,eAAe,OAAA;AAGjB,mEAAmE;AACnE,2BAAwD;AAA/C,wGAAA,kBAAkB,OAAA;AAAE,kGAAA,YAAY,OAAA;AAEzC,yFAAyF;AACzF,2BAWc;AAVZ,2GAAA,qBAAqB,OAAA;AACrB,qGAAA,eAAe,OAAA;AACf,gGAAA,UAAU,OAAA;AACV,iGAAA,WAAW,OAAA;AACX,sGAAA,gBAAgB,OAAA;AAChB,wGAAA,kBAAkB,OAAA;AAClB,oGAAA,cAAc,OAAA;AACd,uGAAA,iBAAiB,OAAA;AACjB,sGAAA,gBAAgB,OAAA;AAChB,iGAAA,WAAW,OAAA;AAgBb,2FAA2F;AAC3F,4FAA4F;AAC5F,yFAAyF;AACzF,yDAI6B;AAH3B,4HAAA,uBAAuB,OAAA;AACvB,wHAAA,mBAAmB,OAAA;AACnB,uHAAA,kBAAkB,OAAA;AAIpB,4FAA4F;AAC5F,8FAA8F;AAC9F,mFAAmF;AACnF,iDAUyB;AATvB,oHAAA,mBAAmB,OAAA;AACnB,kHAAA,iBAAiB,OAAA;AACjB,oHAAA,mBAAmB,OAAA;AACnB,mHAAA,kBAAkB,OAAA;AAClB,oHAAA,mBAAmB,OAAA;AACnB,iHAAA,gBAAgB,OAAA;AAChB,iHAAA,gBAAgB,OAAA;AAChB,sHAAA,qBAAqB,OAAA;AACrB,kHAAA,iBAAiB,OAAA;AAInB,mGAAmG;AACnG,oDAAoD;AACpD,iDAAoE;AAA3D,+GAAA,cAAc,OAAA;AAAE,kHAAA,iBAAiB,OAAA"}

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

@@ -0,0 +1,42 @@
+/**
+ * litedbmodel v2 SCP — build a bc `ComponentGraphIR` whose single body node is a
+ * `makeSQL` componentRef, so a query rides bc's `runBehavior` (composition / value-eval
+ * / plan / envelope come free). The `makeSQL` ports are bc Expression IR: `sql` and
+ * `skip` are simple literals/refs; `params` is an `{ arr: [...] }` of Expression IR
+ * nodes (each a bound-value literal, an input ref, or a nested-`makeSQL` `{ obj: … }`).
+ *
+ * The bundle is pure JSON (multi-language ready). The handler (see `handler.ts`)
+ * assembles + binds + executes. bc validates the envelope and evaluates the ports.
+ */
+import type { ComponentGraphIR } from 'behavior-contracts';
+import { type MakeSQL, type SqlParam, isMakeSQL } from './makesql';
+/** Wrap a bound SQL value as a bc Expression IR literal node.
+ *
+ * bc's Expression IR represents ints as `{int:"…"}` and rejects bare `Date`/arrays.
+ * SQL bound values are opaque to bc, so we pass them as an inert `{lit}` marker that
+ * the handler unwraps — but since bc has no `lit` op, we instead carry the raw params
+ * OUT-OF-BAND: the IR references `input.params` by ref and the caller supplies the
+ * assembled params in the input scope. This keeps values byte-exact (no bc coercion).
+ */
+/**
+ * Build the single-`makeSQL` component IR + the input scope for a pre-assembled query.
+ *
+ * We keep SQL bound values OUT of bc's numeric/format coercion by binding them through
+ * the input scope: the `params` port is `{ ref: ["__sqlParams"] }` and the caller
+ * passes `{ __sqlParams: <the params array>, __sql: <text>, __skip: <bool> }` as input.
+ * bc evaluates the refs (returning the values verbatim), then hands them to the
+ * `makeSQL` handler, which assembles + binds + executes.
+ */
+export declare function makeSqlComponentIR(entry?: string): ComponentGraphIR;
+/** The input scope for {@link makeSqlComponentIR}, from a compiled `makeSQL` bundle. */
+export declare function makeSqlInput(node: MakeSQL): Record<string, unknown>;
+/**
+ * bc's `evaluateExpression` rejects bare arrays / non-plain values as expressions, and
+ * the input scope is validated loosely (refs just read it). Because our params ride the
+ * scope as a plain `ref`, bc returns them verbatim (arrays, Dates, nested makeSQL
+ * objects) with NO coercion — exactly what the handler needs. `isMakeSQL` /
+ * `SqlParam` re-exported for callers building nested params.
+ */
+export { isMakeSQL };
+export type { SqlParam };
+//# sourceMappingURL=ir.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ir.d.ts","sourceRoot":"","sources":["../../../src/scp/makesql/ir.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAa,MAAM,oBAAoB,CAAC;AACtE,OAAO,EAAW,KAAK,OAAO,EAAE,KAAK,QAAQ,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE5E;;;;;;;GAOG;AAEH;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,SAAU,GAAG,gBAAgB,CAsBpE;AAED,wFAAwF;AACxF,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAMnE;AAED;;;;;;GAMG;AACH,OAAO,EAAE,SAAS,EAAE,CAAC;AACrB,YAAY,EAAE,QAAQ,EAAE,CAAC"}

package/dist/scp/makesql/ir.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — build a bc `ComponentGraphIR` whose single body node is a
+ * `makeSQL` componentRef, so a query rides bc's `runBehavior` (composition / value-eval
+ * / plan / envelope come free). The `makeSQL` ports are bc Expression IR: `sql` and
+ * `skip` are simple literals/refs; `params` is an `{ arr: [...] }` of Expression IR
+ * nodes (each a bound-value literal, an input ref, or a nested-`makeSQL` `{ obj: … }`).
+ *
+ * The bundle is pure JSON (multi-language ready). The handler (see `handler.ts`)
+ * assembles + binds + executes. bc validates the envelope and evaluates the ports.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMakeSQL = void 0;
+exports.makeSqlComponentIR = makeSqlComponentIR;
+exports.makeSqlInput = makeSqlInput;
+const makesql_1 = require("./makesql");
+Object.defineProperty(exports, "isMakeSQL", { enumerable: true, get: function () { return makesql_1.isMakeSQL; } });
+/** Wrap a bound SQL value as a bc Expression IR literal node.
+ *
+ * bc's Expression IR represents ints as `{int:"…"}` and rejects bare `Date`/arrays.
+ * SQL bound values are opaque to bc, so we pass them as an inert `{lit}` marker that
+ * the handler unwraps — but since bc has no `lit` op, we instead carry the raw params
+ * OUT-OF-BAND: the IR references `input.params` by ref and the caller supplies the
+ * assembled params in the input scope. This keeps values byte-exact (no bc coercion).
+ */
+/**
+ * Build the single-`makeSQL` component IR + the input scope for a pre-assembled query.
+ *
+ * We keep SQL bound values OUT of bc's numeric/format coercion by binding them through
+ * the input scope: the `params` port is `{ ref: ["__sqlParams"] }` and the caller
+ * passes `{ __sqlParams: <the params array>, __sql: <text>, __skip: <bool> }` as input.
+ * bc evaluates the refs (returning the values verbatim), then hands them to the
+ * `makeSQL` handler, which assembles + binds + executes.
+ */
+function makeSqlComponentIR(entry = 'Query') {
+    const component = {
+        name: entry,
+        inputPorts: {
+            __sql: { type: 'string', required: true },
+            __sqlParams: { type: 'arr' },
+            __skip: { type: 'bool' },
+        },
+        body: [
+            {
+                id: 'q',
+                component: makesql_1.MAKESQL,
+                ports: {
+                    sql: { ref: ['__sql'] },
+                    params: { ref: ['__sqlParams'] },
+                    skip: { ref: ['__skip'] },
+                },
+            },
+        ],
+        output: { ref: ['q'] },
+    };
+    return { irVersion: 1, exprVersion: 2, components: [component] };
+}
+/** The input scope for {@link makeSqlComponentIR}, from a compiled `makeSQL` bundle. */
+function makeSqlInput(node) {
+    return {
+        __sql: node.sql,
+        __sqlParams: node.params,
+        __skip: node.skip === true,
+    };
+}
+//# sourceMappingURL=ir.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ir.js","sourceRoot":"","sources":["../../../src/scp/makesql/ir.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;AAuBH,gDAsBC;AAGD,oCAMC;AAnDD,uCAA4E;AA4DnE,0FA5DsC,mBAAS,OA4DtC;AA1DlB;;;;;;;GAOG;AAEH;;;;;;;;GAQG;AACH,SAAgB,kBAAkB,CAAC,KAAK,GAAG,OAAO;IAChD,MAAM,SAAS,GAAc;QAC3B,IAAI,EAAE,KAAK;QACX,UAAU,EAAE;YACV,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE;YACzC,WAAW,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE;YAC5B,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE;SACzB;QACD,IAAI,EAAE;YACJ;gBACE,EAAE,EAAE,GAAG;gBACP,SAAS,EAAE,iBAAO;gBAClB,KAAK,EAAE;oBACL,GAAG,EAAE,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,EAAE;oBACvB,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,EAAE;oBAChC,IAAI,EAAE,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,EAAE;iBAC1B;aACF;SACF;QACD,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE;KACvB,CAAC;IACF,OAAO,EAAE,SAAS,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC;AACnE,CAAC;AAED,wFAAwF;AACxF,SAAgB,YAAY,CAAC,IAAa;IACxC,OAAO;QACL,KAAK,EAAE,IAAI,CAAC,GAAG;QACf,WAAW,EAAE,IAAI,CAAC,MAAM;QACxB,MAAM,EAAE,IAAI,CAAC,IAAI,KAAK,IAAI;KAC3B,CAAC;AACJ,CAAC"}