litedbmodel 2.1.0 → 2.2.0

package/dist/scp/leaf-transport.d.ts

@@ -0,0 +1,50 @@
+/**
+ * litedbmodel v2 SCP — the op-INDEPENDENT leaf transport DECLARATION (the `@leaf static` SSoT).
+ *
+ * The whole per-DSL execution surface is THREE op-agnostic leaves. This module DECLARES them on
+ * behavior-contracts' native TS authoring surface and NOTHING else: it imports only
+ * `behavior-contracts`, holds no implementation, and is READ by `bc generate --from` (the bodies are
+ * never executed — bc derives each leaf's catalog entry from the signature alone).
+ *
+ * Every authored / emitted litedbmodel model imports `Db` FROM HERE, so there is exactly one leaf
+ * catalog in the repo: change a port here and every generated module in every language follows. The
+ * runtime side of the same three symbols lives in `./leaves` (the handler bodies + the native
+ * transport symbol map); it is deliberately a DIFFERENT module so a `--from` typecheck of an authored
+ * model pulls in the declaration only, never the driver stack.
+ *
+ * ## The port vocabulary
+ *
+ * The ports are declared `WireValue` / `WireValue[]` — bc's OPAQUE wire type. A binding annotated
+ * `WireValue[]` stays opaque (wire passthrough), so an intermediate result flows leaf→leaf with no
+ * typed↔generic round-trip; the SINGLE de-box happens at the one binding that declares a CONCRETE row
+ * type. A relation op therefore runs `executeSQL → pluck → executeSQL → … → group` entirely on the
+ * wire plane and materializes the whole nested typed graph exactly once, at the end.
+ */
+import { type WireValue } from 'behavior-contracts';
+/**
+ * The three OP-AGNOSTIC leaf transports. The bodies are declaration stubs — `bc generate --from`
+ * reads this source and derives the catalog from the signatures; the executable side is the handler
+ * map in `./leaves` (TS) and the per-language runtime transports (`execute_sql` / `pluck_keys` /
+ * `group_children`, see {@link import('./leaves').LEAF_TRANSPORT_SYMBOLS}).
+ */
+export declare class Db {
+    /**
+     * The SOLE SQL transport: bind `params` and run `sql` through the central execute/run seam.
+     * `write` selects `run` (INSERT/UPDATE/DELETE) vs `execute` (SELECT / RETURNING); `returning` keeps
+     * a RETURNING write on the row path; `bigint` runs the read in exact-integer mode. A non-returning
+     * write yields the one-row `[{changes, lastInsertRowid}]` summary so the output shape is uniform.
+     *
+     * `guard` is the RELATION runaway cap (`{limit, model, relation}` — the compiled op's own
+     * {@link import('./limit-config').RelationGuard}) that a guarded relation child fetch carries: the
+     * transport asserts the fetched row count against it and raises `LimitExceededError` when the batch
+     * overruns. It rides HERE because this is where the RAW child rows exist — past `group` the graph is
+     * already nested — and because SCP has no throw, so the enforcement must live in the transport. A
+     * statement with no cap omits the port entirely (every non-relation call is byte-unchanged).
+     */
+    static executeSQL(sql: string, params: WireValue[], write: boolean, returning: boolean, bigint: boolean, whereDynamic?: WireValue | null, guard?: WireValue | null): WireValue[];
+    /** Relation key extraction: the deduped, non-null key set over the ordered key-column tuple `col`. */
+    static pluck(rows: WireValue[], col: string[]): WireValue[];
+    /** Relation shaping: nest `children` under each parent's `into`, matching `child[fk]` to `parent[pk]`. */
+    static group(parents: WireValue[], children: WireValue[], pk: string[], fk: string[], into: string, single: boolean): WireValue[];
+}
+//# sourceMappingURL=leaf-transport.d.ts.map

package/dist/scp/leaf-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"leaf-transport.d.ts","sourceRoot":"","sources":["../../src/scp/leaf-transport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAQ,KAAK,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAgB1D;;;;;GAKG;AACH,qBAAa,EAAE;IACb;;;;;;;;;;;;OAYG;IACG,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,CAAC,EAAE,SAAS,GAAG,IAAI,EAAE,KAAK,CAAC,EAAE,SAAS,GAAG,IAAI,GAAG,SAAS,EAAE;IAEtL,sGAAsG;IAChG,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE;IAEjE,0GAA0G;IACpG,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,SAAS,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,SAAS,EAAE;CACxI"}

package/dist/scp/leaf-transport.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — the op-INDEPENDENT leaf transport DECLARATION (the `@leaf static` SSoT).
+ *
+ * The whole per-DSL execution surface is THREE op-agnostic leaves. This module DECLARES them on
+ * behavior-contracts' native TS authoring surface and NOTHING else: it imports only
+ * `behavior-contracts`, holds no implementation, and is READ by `bc generate --from` (the bodies are
+ * never executed — bc derives each leaf's catalog entry from the signature alone).
+ *
+ * Every authored / emitted litedbmodel model imports `Db` FROM HERE, so there is exactly one leaf
+ * catalog in the repo: change a port here and every generated module in every language follows. The
+ * runtime side of the same three symbols lives in `./leaves` (the handler bodies + the native
+ * transport symbol map); it is deliberately a DIFFERENT module so a `--from` typecheck of an authored
+ * model pulls in the declaration only, never the driver stack.
+ *
+ * ## The port vocabulary
+ *
+ * The ports are declared `WireValue` / `WireValue[]` — bc's OPAQUE wire type. A binding annotated
+ * `WireValue[]` stays opaque (wire passthrough), so an intermediate result flows leaf→leaf with no
+ * typed↔generic round-trip; the SINGLE de-box happens at the one binding that declares a CONCRETE row
+ * type. A relation op therefore runs `executeSQL → pluck → executeSQL → … → group` entirely on the
+ * wire plane and materializes the whole nested typed graph exactly once, at the end.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Db = void 0;
+const behavior_contracts_1 = require("behavior-contracts");
+/**
+ * The body of every declaration below. A `@leaf` body is never lowered and never executed — bc derives
+ * the catalog entry from the SIGNATURE alone — so calling a leaf on the TS plane is a wiring bug, and
+ * this throws rather than returning a plausible empty result. Taking `args` keeps every declared
+ * parameter genuinely referenced (they are the PORT NAMES; they may not be renamed or dropped).
+ */
+function declarationStub(leafName, args) {
+    void args;
+    throw new Error(`litedbmodel Db.${leafName} is a leaf DECLARATION read by \`bc generate\` — it has no TS body. ` +
+        `The executable transport is the handler map \`leafHandlers\` / \`leafHandlersAsync\` in ./leaves.`);
+}
+/**
+ * The three OP-AGNOSTIC leaf transports. The bodies are declaration stubs — `bc generate --from`
+ * reads this source and derives the catalog from the signatures; the executable side is the handler
+ * map in `./leaves` (TS) and the per-language runtime transports (`execute_sql` / `pluck_keys` /
+ * `group_children`, see {@link import('./leaves').LEAF_TRANSPORT_SYMBOLS}).
+ */
+class Db {
+    /**
+     * The SOLE SQL transport: bind `params` and run `sql` through the central execute/run seam.
+     * `write` selects `run` (INSERT/UPDATE/DELETE) vs `execute` (SELECT / RETURNING); `returning` keeps
+     * a RETURNING write on the row path; `bigint` runs the read in exact-integer mode. A non-returning
+     * write yields the one-row `[{changes, lastInsertRowid}]` summary so the output shape is uniform.
+     *
+     * `guard` is the RELATION runaway cap (`{limit, model, relation}` — the compiled op's own
+     * {@link import('./limit-config').RelationGuard}) that a guarded relation child fetch carries: the
+     * transport asserts the fetched row count against it and raises `LimitExceededError` when the batch
+     * overruns. It rides HERE because this is where the RAW child rows exist — past `group` the graph is
+     * already nested — and because SCP has no throw, so the enforcement must live in the transport. A
+     * statement with no cap omits the port entirely (every non-relation call is byte-unchanged).
+     */
+    static executeSQL(sql, params, write, returning, bigint, whereDynamic, guard) { return declarationStub('executeSQL', [sql, params, write, returning, bigint, whereDynamic, guard]); }
+    /** Relation key extraction: the deduped, non-null key set over the ordered key-column tuple `col`. */
+    static pluck(rows, col) { return declarationStub('pluck', [rows, col]); }
+    /** Relation shaping: nest `children` under each parent's `into`, matching `child[fk]` to `parent[pk]`. */
+    static group(parents, children, pk, fk, into, single) { return declarationStub('group', [parents, children, pk, fk, into, single]); }
+}
+exports.Db = Db;
+__decorate([
+    behavior_contracts_1.leaf,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array, Boolean, Boolean, Boolean, Object, Object]),
+    __metadata("design:returntype", Array)
+], Db, "executeSQL", null);
+__decorate([
+    behavior_contracts_1.leaf,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Array]),
+    __metadata("design:returntype", Array)
+], Db, "pluck", null);
+__decorate([
+    behavior_contracts_1.leaf,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Array, Array, Array, String, Boolean]),
+    __metadata("design:returntype", Array)
+], Db, "group", null);
+//# sourceMappingURL=leaf-transport.js.map

package/dist/scp/leaf-transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"leaf-transport.js","sourceRoot":"","sources":["../../src/scp/leaf-transport.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;;;;;;;;;;;;AAEH,2DAA0D;AAE1D;;;;;GAKG;AACH,SAAS,eAAe,CAAC,QAAgB,EAAE,IAAwB;IACjE,KAAK,IAAI,CAAC;IACV,MAAM,IAAI,KAAK,CACb,kBAAkB,QAAQ,sEAAsE;QAC9F,mGAAmG,CACtG,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAa,EAAE;IACb;;;;;;;;;;;;OAYG;IACU,AAAP,MAAM,CAAC,UAAU,CAAC,GAAW,EAAE,MAAmB,EAAE,KAAc,EAAE,SAAkB,EAAE,MAAe,EAAE,YAA+B,EAAE,KAAwB,IAAiB,OAAO,eAAe,CAAC,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAE9R,sGAAsG;IACzF,AAAP,MAAM,CAAC,KAAK,CAAC,IAAiB,EAAE,GAAa,IAAiB,OAAO,eAAe,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IAEnH,0GAA0G;IAC7F,AAAP,MAAM,CAAC,KAAK,CAAC,OAAoB,EAAE,QAAqB,EAAE,EAAY,EAAE,EAAY,EAAE,IAAY,EAAE,MAAe,IAAiB,OAAO,eAAe,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;CACxN;AArBD,gBAqBC;AAPc;IAAZ,yBAAI;;;;0BAAyR;AAGjR;IAAZ,yBAAI;;;;qBAA8G;AAGtG;IAAZ,yBAAI;;;;qBAAkN"}

package/dist/scp/leaves.d.ts

@@ -0,0 +1,174 @@
+/**
+ * litedbmodel v2 SCP — the op-INDEPENDENT leaf transport IMPLEMENTATION (the TS runtime side).
+ *
+ * The three leaves are DECLARED once in {@link import('./leaf-transport').Db} (`@leaf static`, read by
+ * `bc generate --from`). THIS module carries their executable bodies and hands them to a generated
+ * module as a behavior-contracts handler map — the boundary injection a `bind(handlers)` /
+ * `bindAsync(handlers)` facade expects. Declaration and implementation are separate modules on
+ * purpose: a `--from` typecheck of an authored model must pull in the signature only, never the
+ * driver stack.
+ *
+ *   - {@link executeSQL} — the SOLE SQL transport. Binds params and runs one statement through the
+ *     central {@link import('./exec-context') execute/run seam} (the ONLY driver contact). Read
+ *     (`write:false`) → rows; write (`write:true`) → a one-row `[{changes,lastInsertRowid}]` summary
+ *     (RETURNING writes return their rows via `execute`). It owns the transport-level param shaping a
+ *     relation key-set needs — the dialect array encoding + deferred PG cast resolution + `?`→`$N`
+ *     render — and, when the statement is a GUARDED relation child fetch, the runaway check on its raw
+ *     rows ({@link import('./limit-config').assertRelationHardLimit}): the RAW child rows exist only
+ *     here, since `group` already sees a nested graph and SCP itself has no throw.
+ *   - {@link pluck} — rows + the ordered key-column tuple → the deduped, non-null key array (the
+ *     `= ANY($1)` / `json_each(?)` batch key set).
+ *   - {@link group} — parents + a flat child list + `pk`/`fk`/`into` → each parent with its matching
+ *     children nested under `into` (`hasMany` → list, single → the one child or null). This is the
+ *     in-memory grouping that makes the child fetch ONE query (N+1-free).
+ *
+ * The environment (connection seam + dialect) is captured by the handler FACTORY, never carried on
+ * the IR (C4): {@link leafHandlers} closes over a sync {@link LeafContext} and {@link
+ * leafHandlersAsync} over an {@link AsyncLeafContext}. The same three symbols are what the native
+ * codegen calls directly ({@link LEAF_TRANSPORT_SYMBOLS}).
+ */
+import type { Handlers, AsyncHandlers } from 'behavior-contracts/runtime';
+import { type ExecutionContext, type AsyncExecutionContext, type StatementIntent } from './exec-context';
+import { type RelationGuard } from './limit-config';
+import { type Dialect } from './makesql/handler';
+/**
+ * The environment boundary the handler factory captures (C4 — never on the IR). `exec` is the SYNC
+ * connection/middleware/tx seam (better-sqlite3, run via a generated module's `bind`); `dialect`
+ * selects the transport-level param encoding + placeholder render. The native ports carry the SAME facts.
+ */
+export interface LeafContext {
+    /** The central sync execute/run seam (connection provider + middleware + tx pin). */
+    readonly exec: ExecutionContext;
+    /** The target SQL dialect (drives array-param encoding + `?`→`$N` render). */
+    readonly dialect: Dialect;
+}
+/**
+ * The ASYNC environment boundary (live PG / MySQL, run via a generated module's `bindAsync`). Carries
+ * the async execute/run seam ({@link AsyncExecutionContext}) instead of the sync one.
+ */
+export interface AsyncLeafContext {
+    /** The central async execute/run seam (pooled per-execution connection ownership). */
+    readonly execAsync: AsyncExecutionContext;
+    /** The target SQL dialect. */
+    readonly dialect: Dialect;
+}
+/** The evaluated `executeSQL` ports a generated module hands the transport. */
+interface ExecuteSqlPorts {
+    readonly sql: string;
+    readonly params: unknown[];
+    readonly write: boolean;
+    readonly returning: boolean;
+    readonly bigint: boolean;
+    /** The DYNAMIC WHERE plan (absent on a fully-bounded statement). See {@link assembleDynamicWhere}. */
+    readonly whereDynamic?: DynamicWherePlan | null;
+    /**
+     * The RELATION runaway cap this statement's rows are asserted against (absent ⇒ uncapped). Carried
+     * verbatim from the compiled relation op — see {@link assertRelationHardLimit}.
+     */
+    readonly guard?: RelationGuard | null;
+}
+/** Splice a ` WHERE …` clause (leading space included, or `''`) into `baseSql` before its first tail keyword. */
+export declare function spliceWhere(baseSql: string, whereSql: string): string;
+/**
+ * ONE evaluated WHERE fragment of a dynamic plan. bc has ALREADY evaluated the fragment's params and
+ * its SKIP guard against the input: a fragment whose guard was false evaluated LAZILY to `null` (bc's
+ * `cond` only evaluates the taken branch, so a dropped fragment's params are never evaluated).
+ */
+export interface DynamicWhereFrag {
+    readonly sql: string;
+    readonly params: readonly unknown[];
+}
+/** The evaluated dynamic-WHERE plan: the fragment list, holes (skipped fragments) included. */
+export interface DynamicWherePlan {
+    readonly frags?: readonly (DynamicWhereFrag | null)[];
+}
+/**
+ * Assemble the effective statement from a DYNAMIC WHERE plan: drop the absent (`null`) fragments,
+ * join the survivors with ` WHERE ` / ` AND `, splice the clause into the base `sql` before its first
+ * tail keyword ({@link spliceWhere}) — the exact position a bounded WHERE occupies — and bind the
+ * surviving fragments' params BEFORE the base params (the WHERE `?`s precede the tail's).
+ *
+ * A SKIP predicate's presence is per-CALL, so the FINAL statement can only be determined here, at
+ * execution time — which is also why `?`→`$N` is rendered after this ({@link prepareSql}), never at
+ * emit time. A statement with NO optional predicate carries no plan at all: its WHERE is spliced into
+ * the static `sql` at emit time and it never reaches this function.
+ */
+export declare function assembleDynamicWhere(p: {
+    sql: string;
+    params: unknown[];
+    whereDynamic: DynamicWherePlan;
+}): {
+    sql: string;
+    params: unknown[];
+};
+/** Prepare a statement for the seam: resolve deferred PG cast(s), render `?`→`$N`, encode params. */
+export declare function prepareSql(p: {
+    sql: string;
+    params: unknown[];
+    write: boolean;
+}, dialect: Dialect): {
+    sql: string;
+    bound: unknown[];
+    intent: StatementIntent;
+};
+/**
+ * The SYNC `executeSQL` body. `write` selects `run` (INSERT/UPDATE/DELETE) vs `execute` (SELECT /
+ * RETURNING); a non-returning write returns the one-row `[{changes,lastInsertRowid}]` summary so the
+ * leaf output shape is uniform.
+ *
+ * A read ALWAYS runs in exact-integer mode (better-sqlite3 `safeIntegers`), so an INTEGER column
+ * arrives as a `BigInt` — the value bc's `int` scalar declares. It is not conditional: the wire carries
+ * int and float as DISTINCT kinds, so a column declared `Int` cannot be satisfied by a JS number on any
+ * dialect, and gating exactness per endpoint made SQLite disagree with PostgreSQL and MySQL (whose
+ * integer type parsers are unconditional — `configurePgDeboxTypeParsers`, `mysqlDeboxPoolOptions`),
+ * which the conformance corpus rejects as dialect-variant. `bigint` is retained as a port because the
+ * generated modules declare it, but it no longer selects the seam.
+ */
+export declare function executeSQL(p: ExecuteSqlPorts, ctx: LeafContext): Array<Record<string, unknown>>;
+/** The ASYNC (live PG / MySQL) `executeSQL` body — the twin of {@link executeSQL} over the async seam. */
+export declare function executeSQLAsync(p: ExecuteSqlPorts, ctx: AsyncLeafContext): Promise<Array<Record<string, unknown>>>;
+/**
+ * Extract the deduped, non-null key set from `rows` over the ordered key-column tuple `col` — the
+ * batch key set a relation child fetch binds. Insertion order preserved; a row missing any key column
+ * is dropped (no partial keys). A single-key tuple yields a flat scalar array (`json_each` scalar
+ * `value`); a composite tuple yields an array-of-tuples (`json_each` per-ordinal `$[i]`). Dedupe is
+ * the shared grouping core ({@link dedupeKeyTuples}) — the SAME SSoT the lazy-relation path uses.
+ */
+export declare function pluck(p: {
+    rows: Array<Record<string, unknown>>;
+    col: string[];
+}): unknown[];
+/**
+ * Distribute a flat `children` list onto `parents` by matching `child[fk]` to `parent[pk]`, nesting
+ * the result under `into`. `single:true` (belongsTo/hasOne) nests the one matching child (or `null`);
+ * otherwise (hasMany) nests the child list (`[]` when none). `pk`/`fk` are the ordered key-column
+ * tuples, so a composite relation nests by the WHOLE key (no `''`-collapse cartesian). Grouping is the
+ * shared core ({@link groupByKey}/{@link attachToParent}) — the SAME SSoT the lazy-relation path uses.
+ */
+export declare function group(p: {
+    parents: Array<Record<string, unknown>>;
+    children: Array<Record<string, unknown>>;
+    pk: string[];
+    fk: string[];
+    into: string;
+    single: boolean;
+}): Array<Record<string, unknown>>;
+/**
+ * The SYNC handler map for a generated module's `bind(handlers)` — catalog name → the transport body,
+ * closed over the sync environment. This is the ONLY place the three leaves are wired to the TS
+ * runtime; a generated module never carries an implementation.
+ */
+export declare function leafHandlers(ctx: LeafContext): Handlers;
+/**
+ * The ASYNC handler map for a generated module's `bindAsync(handlers)` (live PG / MySQL). Only the SQL
+ * transport differs — the shaping leaves are the SAME implementations.
+ */
+export declare function leafHandlersAsync(ctx: AsyncLeafContext): AsyncHandlers;
+/**
+ * The native-codegen transport symbol table (`bc generate --leaf-transport`): each op-independent leaf
+ * → the runtime symbol the covered native module calls directly. The consumer supplies these
+ * (litedbmodel = a fixed set of ops, not one method per node).
+ */
+export declare const LEAF_TRANSPORT_SYMBOLS: Readonly<Record<string, string>>;
+export {};
+//# sourceMappingURL=leaves.d.ts.map

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

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

package/dist/scp/leaves.js

@@ -0,0 +1,287 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — the op-INDEPENDENT leaf transport IMPLEMENTATION (the TS runtime side).
+ *
+ * The three leaves are DECLARED once in {@link import('./leaf-transport').Db} (`@leaf static`, read by
+ * `bc generate --from`). THIS module carries their executable bodies and hands them to a generated
+ * module as a behavior-contracts handler map — the boundary injection a `bind(handlers)` /
+ * `bindAsync(handlers)` facade expects. Declaration and implementation are separate modules on
+ * purpose: a `--from` typecheck of an authored model must pull in the signature only, never the
+ * driver stack.
+ *
+ *   - {@link executeSQL} — the SOLE SQL transport. Binds params and runs one statement through the
+ *     central {@link import('./exec-context') execute/run seam} (the ONLY driver contact). Read
+ *     (`write:false`) → rows; write (`write:true`) → a one-row `[{changes,lastInsertRowid}]` summary
+ *     (RETURNING writes return their rows via `execute`). It owns the transport-level param shaping a
+ *     relation key-set needs — the dialect array encoding + deferred PG cast resolution + `?`→`$N`
+ *     render — and, when the statement is a GUARDED relation child fetch, the runaway check on its raw
+ *     rows ({@link import('./limit-config').assertRelationHardLimit}): the RAW child rows exist only
+ *     here, since `group` already sees a nested graph and SCP itself has no throw.
+ *   - {@link pluck} — rows + the ordered key-column tuple → the deduped, non-null key array (the
+ *     `= ANY($1)` / `json_each(?)` batch key set).
+ *   - {@link group} — parents + a flat child list + `pk`/`fk`/`into` → each parent with its matching
+ *     children nested under `into` (`hasMany` → list, single → the one child or null). This is the
+ *     in-memory grouping that makes the child fetch ONE query (N+1-free).
+ *
+ * The environment (connection seam + dialect) is captured by the handler FACTORY, never carried on
+ * the IR (C4): {@link leafHandlers} closes over a sync {@link LeafContext} and {@link
+ * leafHandlersAsync} over an {@link AsyncLeafContext}. The same three symbols are what the native
+ * codegen calls directly ({@link LEAF_TRANSPORT_SYMBOLS}).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LEAF_TRANSPORT_SYMBOLS = void 0;
+exports.spliceWhere = spliceWhere;
+exports.assembleDynamicWhere = assembleDynamicWhere;
+exports.prepareSql = prepareSql;
+exports.executeSQL = executeSQL;
+exports.executeSQLAsync = executeSQLAsync;
+exports.pluck = pluck;
+exports.group = group;
+exports.leafHandlers = leafHandlers;
+exports.leafHandlersAsync = leafHandlersAsync;
+const exec_context_1 = require("./exec-context");
+const limit_config_1 = require("./limit-config");
+const handler_1 = require("./makesql/handler");
+const json_array_1 = require("./makesql/json-array");
+const compile_relation_1 = require("./makesql/compile-relation");
+const grouping_1 = require("./grouping");
+// ── the DYNAMIC (SKIP) WHERE: assembled by the transport, at execution time ────────────────────
+/**
+ * The SQL keywords that may follow a WHERE clause. The WHERE must be spliced BEFORE the first of
+ * them, so a dynamic WHERE lands at exactly the position a bounded one occupies.
+ */
+const WHERE_TAIL_RE = /\s+(GROUP BY|ORDER BY|LIMIT|OFFSET|FOR UPDATE|RETURNING)\b/i;
+/** Splice a ` WHERE …` clause (leading space included, or `''`) into `baseSql` before its first tail keyword. */
+function spliceWhere(baseSql, whereSql) {
+    if (whereSql === '')
+        return baseSql;
+    const tail = WHERE_TAIL_RE.exec(baseSql);
+    return tail === null ? baseSql + whereSql : baseSql.slice(0, tail.index) + whereSql + baseSql.slice(tail.index);
+}
+/**
+ * Assemble the effective statement from a DYNAMIC WHERE plan: drop the absent (`null`) fragments,
+ * join the survivors with ` WHERE ` / ` AND `, splice the clause into the base `sql` before its first
+ * tail keyword ({@link spliceWhere}) — the exact position a bounded WHERE occupies — and bind the
+ * surviving fragments' params BEFORE the base params (the WHERE `?`s precede the tail's).
+ *
+ * A SKIP predicate's presence is per-CALL, so the FINAL statement can only be determined here, at
+ * execution time — which is also why `?`→`$N` is rendered after this ({@link prepareSql}), never at
+ * emit time. A statement with NO optional predicate carries no plan at all: its WHERE is spliced into
+ * the static `sql` at emit time and it never reaches this function.
+ */
+function assembleDynamicWhere(p) {
+    const frags = (p.whereDynamic.frags ?? []).filter((f) => f != null);
+    let whereSql = '';
+    const whereParams = [];
+    frags.forEach((f, i) => {
+        whereSql += (i === 0 ? ' WHERE ' : ' AND ') + f.sql;
+        whereParams.push(...f.params);
+    });
+    return { sql: spliceWhere(p.sql, whereSql), params: [...whereParams, ...p.params] };
+}
+/**
+ * The effective `{sql, params}` a statement executes: the dynamic plan assembled when one is present,
+ * the ports verbatim otherwise. The ONE place the two shapes converge — both transports consume it.
+ */
+function effectiveStatement(p) {
+    if (p.whereDynamic == null)
+        return p;
+    return { ...assembleDynamicWhere({ sql: p.sql, params: p.params, whereDynamic: p.whereDynamic }), write: p.write };
+}
+/** Normalize a driver integer (number|bigint) to bc's `int` value model (BigInt). */
+function toBcInt(v) {
+    return typeof v === 'bigint' ? v : BigInt(v);
+}
+// ── executeSQL — the sole op-independent SQL transport ─────────────────────────
+/**
+ * Encode a value list for the driver: a bound scalar passes through; an ARRAY element (a key set or a
+ * batch record list bound as ONE param — `= ANY(?)` / `json_each(?)` / `JSON_TABLE(?)`) binds as the
+ * raw array on PostgreSQL and as a single JSON string on MySQL/SQLite (the `makesql` locked model).
+ *
+ * A TUPLE SET (an array whose elements are themselves arrays — the composite relation key set the
+ * `pluck` leaf yields) binds as the single JSON array-of-tuples string on EVERY dialect, PostgreSQL
+ * included: each dialect's composite batch expands that ONE param server-side
+ * (`json_array_elements` / `JSON_TABLE` / `json_each`), which is what lets a composite relation ride
+ * the same three-leaf transport as everything else instead of needing a per-column transpose (#159).
+ *
+ * The JSON encoding is the SHARED one ({@link encodeJsonArrayParam}) — the same encoder the imperative
+ * `inListJson` path uses, so the generated and imperative paths cannot drift on bigint / boolean
+ * element handling.
+ */
+function encodeParams(params, dialect) {
+    return params.map((p) => {
+        if (!Array.isArray(p))
+            return p;
+        if (dialect === 'postgres' && !isTupleSet(p))
+            return p;
+        return (0, json_array_1.encodeJsonArrayParam)(dialect, p);
+    });
+}
+/**
+ * A composite key set: a bound array whose elements are the key TUPLES (arrays). Total under the
+ * library's type system — every OTHER array param is a list of SCALAR cells (a single-key set, an
+ * IN-list, a batch write's per-column array), because every non-scalar column class (json / uuid /
+ * decimal) de-boxes to a bc STRING ({@link import('./coltype').keyArrayElemScalar}), never a JS array.
+ */
+function isTupleSet(param) {
+    return param.length > 0 && Array.isArray(param[0]);
+}
+/** Prepare a statement for the seam: resolve deferred PG cast(s), render `?`→`$N`, encode params. */
+function prepareSql(p, dialect) {
+    let sql = p.sql;
+    if (dialect === 'postgres') {
+        for (const param of p.params)
+            if (Array.isArray(param))
+                sql = (0, compile_relation_1.resolvePgArrayCast)(sql, param);
+    }
+    sql = (0, handler_1.renderPlaceholders)(sql, dialect);
+    const bound = encodeParams(p.params, dialect);
+    const intent = { write: p.write === true };
+    return { sql, bound, intent };
+}
+/**
+ * The affected-write summary row a non-returning write yields (uniform `items` output shape).
+ *
+ * BOTH fields are integers, so both are normalized to bc's `int` value model (BigInt) — the shape a
+ * declared `{changes: Int, lastInsertRowid: Int}` contract conforms against, and the shape the rust /
+ * go / python / php transports return. Leaving `changes` a JS number made the SAME generated IR
+ * conform in one language and fail `expected int, got float` in another.
+ */
+function writeSummary(info) {
+    return [{ changes: toBcInt(info.changes), lastInsertRowid: toBcInt(info.lastInsertRowid) }];
+}
+/**
+ * The SYNC `executeSQL` body. `write` selects `run` (INSERT/UPDATE/DELETE) vs `execute` (SELECT /
+ * RETURNING); a non-returning write returns the one-row `[{changes,lastInsertRowid}]` summary so the
+ * leaf output shape is uniform.
+ *
+ * A read ALWAYS runs in exact-integer mode (better-sqlite3 `safeIntegers`), so an INTEGER column
+ * arrives as a `BigInt` — the value bc's `int` scalar declares. It is not conditional: the wire carries
+ * int and float as DISTINCT kinds, so a column declared `Int` cannot be satisfied by a JS number on any
+ * dialect, and gating exactness per endpoint made SQLite disagree with PostgreSQL and MySQL (whose
+ * integer type parsers are unconditional — `configurePgDeboxTypeParsers`, `mysqlDeboxPoolOptions`),
+ * which the conformance corpus rejects as dialect-variant. `bigint` is retained as a port because the
+ * generated modules declare it, but it no longer selects the seam.
+ */
+function executeSQL(p, ctx) {
+    const prepared = prepareSql(effectiveStatement(p), ctx.dialect);
+    if (p.write === true && p.returning !== true)
+        return writeSummary((0, exec_context_1.run)(ctx.exec, prepared.sql, prepared.bound, prepared.intent));
+    const rows = (0, exec_context_1.executeSafe)(ctx.exec, prepared.sql, prepared.bound, prepared.intent);
+    (0, limit_config_1.assertRelationHardLimit)(rows, p.guard);
+    return rows;
+}
+/** The ASYNC (live PG / MySQL) `executeSQL` body — the twin of {@link executeSQL} over the async seam. */
+async function executeSQLAsync(p, ctx) {
+    const prepared = prepareSql(effectiveStatement(p), ctx.dialect);
+    if (p.write === true && p.returning !== true)
+        return writeSummary(await (0, exec_context_1.runAsync)(ctx.execAsync, prepared.sql, prepared.bound, prepared.intent));
+    const rows = (await (0, exec_context_1.executeAsync)(ctx.execAsync, prepared.sql, prepared.bound, prepared.intent));
+    (0, limit_config_1.assertRelationHardLimit)(rows, p.guard);
+    return rows;
+}
+// ── pluck — rows + key columns → the deduped key array (the `= ANY($1)` batch key set) ──
+/**
+ * Extract the deduped, non-null key set from `rows` over the ordered key-column tuple `col` — the
+ * batch key set a relation child fetch binds. Insertion order preserved; a row missing any key column
+ * is dropped (no partial keys). A single-key tuple yields a flat scalar array (`json_each` scalar
+ * `value`); a composite tuple yields an array-of-tuples (`json_each` per-ordinal `$[i]`). Dedupe is
+ * the shared grouping core ({@link dedupeKeyTuples}) — the SAME SSoT the lazy-relation path uses.
+ */
+function pluck(p) {
+    const tuples = (0, grouping_1.dedupeKeyTuples)(p.rows, p.col);
+    return p.col.length === 1 ? tuples.map((t) => t[0]) : tuples.map((t) => [...t]);
+}
+// ── group — parents + flat children → each parent with its children nested ─────
+/**
+ * Distribute a flat `children` list onto `parents` by matching `child[fk]` to `parent[pk]`, nesting
+ * the result under `into`. `single:true` (belongsTo/hasOne) nests the one matching child (or `null`);
+ * otherwise (hasMany) nests the child list (`[]` when none). `pk`/`fk` are the ordered key-column
+ * tuples, so a composite relation nests by the WHOLE key (no `''`-collapse cartesian). Grouping is the
+ * shared core ({@link groupByKey}/{@link attachToParent}) — the SAME SSoT the lazy-relation path uses.
+ */
+function group(p) {
+    const byKey = (0, grouping_1.groupByKey)(p.children, p.fk);
+    return p.parents.map((par) => ({ ...par, [p.into]: (0, grouping_1.attachToParent)(par, p.pk, byKey, p.single === true) }));
+}
+// ── handler maps: the boundary injection a generated module's bind()/bindAsync() consumes ──
+/**
+ * Read the OPTIONAL relation `guard` port. Absent (or null) ⇒ the statement is uncapped. The cap
+ * arrives in bc's `int` value model, which on the TS plane is a BigInt, so it is normalized to the
+ * `number` {@link RelationGuard} (and {@link import('./errors').LimitExceededError}) declare — the
+ * SAME numeric type the rust/go/python/php transports hand their own check. A guard that is present
+ * but not a `{limit, relation}` record is a LOUD port failure, never a silently dropped cap: a guard
+ * that fails to unbox is a runaway that would otherwise sail through.
+ */
+function relationGuardPort(port) {
+    if (port === undefined || port === null)
+        return null;
+    const g = port;
+    const limit = typeof g.limit === 'bigint' ? Number(g.limit) : g.limit;
+    if (typeof limit !== 'number' || !Number.isInteger(limit) || typeof g.relation !== 'string') {
+        throw new Error(`scp leaf executeSQL: the 'guard' port must be a {limit:int, model?:string, relation:string} ` +
+            `relation cap, got ${JSON.stringify(port)}`);
+    }
+    return { limit, ...(typeof g.model === 'string' ? { model: g.model } : {}), relation: g.relation };
+}
+/** Read the declared `executeSQL` ports off the evaluated port record (the generated module's Values). */
+function executeSqlPorts(ports) {
+    return {
+        sql: ports.sql,
+        params: ports.params,
+        write: ports.write === true,
+        returning: ports.returning === true,
+        bigint: ports.bigint === true,
+        whereDynamic: (ports.whereDynamic ?? null),
+        guard: relationGuardPort(ports.guard),
+    };
+}
+/**
+ * The two ENVIRONMENT-FREE relation handlers. `pluck`/`group` are pure in-memory shaping, so the sync
+ * and async maps share this ONE definition (never a second copy per environment).
+ */
+const shapingHandlers = {
+    pluck: (ports) => ({ ok: pluck({ rows: ports.rows, col: ports.col }) }),
+    group: (ports) => ({
+        ok: group({
+            parents: ports.parents,
+            children: ports.children,
+            pk: ports.pk,
+            fk: ports.fk,
+            into: ports.into,
+            single: ports.single === true,
+        }),
+    }),
+};
+/**
+ * The SYNC handler map for a generated module's `bind(handlers)` — catalog name → the transport body,
+ * closed over the sync environment. This is the ONLY place the three leaves are wired to the TS
+ * runtime; a generated module never carries an implementation.
+ */
+function leafHandlers(ctx) {
+    return {
+        ...shapingHandlers,
+        executeSQL: (ports) => ({ ok: executeSQL(executeSqlPorts(ports), ctx) }),
+    };
+}
+/**
+ * The ASYNC handler map for a generated module's `bindAsync(handlers)` (live PG / MySQL). Only the SQL
+ * transport differs — the shaping leaves are the SAME implementations.
+ */
+function leafHandlersAsync(ctx) {
+    return {
+        ...shapingHandlers,
+        executeSQL: async (ports) => ({ ok: (await executeSQLAsync(executeSqlPorts(ports), ctx)) }),
+    };
+}
+/**
+ * The native-codegen transport symbol table (`bc generate --leaf-transport`): each op-independent leaf
+ * → the runtime symbol the covered native module calls directly. The consumer supplies these
+ * (litedbmodel = a fixed set of ops, not one method per node).
+ */
+exports.LEAF_TRANSPORT_SYMBOLS = {
+    executeSQL: 'execute_sql',
+    pluck: 'pluck_keys',
+    group: 'group_children',
+};
+//# sourceMappingURL=leaves.js.map

package/dist/scp/leaves.js.map

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