litedbmodel 2.2.1 → 2.2.3

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

@@ -14,13 +14,152 @@
  *
  * ## The port vocabulary
  *
- * The ports are declared `WireValue` / `WireValue[]` — bc's OPAQUE wire type. A binding annotated
+ * The DATA 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.
+ *
+ * Everything a statement carries BESIDES its text and its bound values rides in ONE optional CONTROL
+ * struct, {@link ExecOptions} (`opts`): WHICH database it runs on (`db`), how to run it (`write` /
+ * `returning`) and the two CONCRETE control structs — {@link DynamicWherePlan} (`whereDynamic`) and
+ * {@link CapGuard} (`guard`) — the
+ * emitter CONSTRUCTS at the call site from the endpoint's own parameters (not leaf→leaf wire values),
+ * so a native-codegen emitter builds them as typed structs. It is ONE argument because a mode flag is a
+ * NAMED FIELD there: a positional list grows a new slot per fact and every call site's remaining
+ * arguments shift (#193), and a trailing optional port can only be reached by passing a filler for the
+ * one before it. A PLAIN READ omits `opts` entirely (native-clean — the payload carries `sql`/`params`
+ * and nothing else); every other statement spells the whole record, so absence is `null` (a fact) and
+ * never a stand-in value. bc typed-native lowers a NON-NULL struct into an `opt<named>` port via
+ * `optSome` (bc#275), so a concrete optional port is native — no boxing. The fragment vocabulary is
+ * CLAUDE.md §2's: SQL + params + a SKIP FLAG (a homogeneous `{skipped, sql, params}` struct), assembled
+ * by the leaf at run — never a `cond`-to-null variant element (which the native-codegen emitters reject).
  */
-import { type WireValue } from 'behavior-contracts';
+import { type Int, type WireValue } from 'behavior-contracts';
+/**
+ * ONE dynamic-WHERE fragment — always an OPTIONAL predicate's, never a bounded one's (a bounded
+ * predicate is lowered into the statement's static WHERE at emit, CLAUDE.md §2). The fragment
+ * vocabulary that §2 fixes: the fragment's SQL text, its bound `params`, and a SKIP FLAG — nothing
+ * else. `skipped` carries the per-call SKIP decision as DATA (`param === null`), so every element of a
+ * plan is the SAME struct — never a `cond`-to-null variant, which the native-codegen emitters reject.
+ * `params` rides opaque (`WireValue[]`) exactly like the base `params` port; the leaf binds them in
+ * order. The runtime side ({@link import('./leaves')}) READS this struct — it never constructs one — so
+ * the one definition serves both the emitter's authored literal and the leaf's runtime assembly.
+ */
+export interface DynamicWhereFrag {
+    readonly skipped: boolean;
+    readonly sql: string;
+    /**
+     * The fragment's bound params (`WireValue`), the SAME order the fragment's `?`s appear. The predicate
+     * binds its own parameter, which is `null` exactly when the fragment is SKIPPED — so the element is
+     * `WireValue | null`; a skipped fragment's params are never bound (the leaf drops it), so the null is
+     * inert.
+     */
+    readonly params: (WireValue | null)[];
+}
+/**
+ * The dynamic-WHERE plan a SKIP read carries (OPTIONAL — a read with no optional predicate omits it): a
+ * HOMOGENEOUS fragment list the leaf assembles at run, dropping the `skipped` fragments and continuing
+ * the statement's static WHERE with the survivors.
+ *
+ * When a plan is present the statement's `sql`/`params` ports carry only its HEAD — the text up to the
+ * end of its WHERE region — and the plan carries everything needed to finish it. That split comes from
+ * the emitter's own SELECT builder ({@link import('./makesql/compile-select').SelectBundle}), which knows
+ * the boundary because it is the code that puts the WHERE there. The leaf therefore CONCATENATES
+ * (`head` + the survivors + `tail`) and never SCANS: a scan of the finished statement mistakes a nested
+ * statement's tail keyword for the outer one's (#198) and counts a quoted `?` the placeholder render
+ * skips (#202), and a scan-derived byte OFFSET is not even the same number in five languages.
+ */
+export interface DynamicWherePlan {
+    readonly frags: readonly DynamicWhereFrag[];
+    /**
+     * How the FIRST surviving fragment joins the head: `'AND'` when the head ends in a static WHERE (its
+     * BOUNDED predicates, lowered at emit — CLAUDE.md §2), `'WHERE'` when it carries none. Further
+     * survivors always join with `AND`, which is the leaf's own separator.
+     */
+    readonly lead: string;
+    /**
+     * The statement text that follows the WHERE region — ` GROUP BY …` / ` ORDER BY …` / the page / the
+     * row lock / a raw append tail, `''` when the statement ends at its WHERE. Appended VERBATIM after the
+     * assembled clause.
+     */
+    readonly tail: string;
+    /**
+     * The params `tail`'s own placeholders bind (a bound ` LIMIT ?` then ` OFFSET ?`), which are therefore
+     * the LAST values of the effective statement — after the head's and the survivors'. Carrying them
+     * separately is what removes the `?`-counting arithmetic: there is no position to compute.
+     */
+    readonly tailParams: WireValue[];
+}
+/**
+ * The relation runaway cap a GUARDED child fetch carries — the bc wire-construction twin of the runtime
+ * {@link import('./limit-config').RelationGuard} (the emitter serializes the compiled op's resolved
+ * guard into this shape; the leaf transport asserts the raw child-row count against it). It is a
+ * SEPARATE type on purpose: `limit` is bc's `Int` brand so the native struct field is an integer (a
+ * plain `number` would emit as a float and the wire int-probe would miss it), whereas the runtime
+ * `RelationGuard` is `number`-typed because it is CONSTRUCTED from `resolveHasManyHardLimit`'s plain
+ * numbers — the two cannot be one type. `model` names the capped relation's target table, the identity
+ * `LimitExceededError` reports. On the WIRE its key is always spelled — bc types a port by the literal
+ * wired into it and rejects a partial struct — so "no model" rides as `null`, and every language
+ * transport reads the key fail-closed rather than defaulting an absent one.
+ */
+export interface CapGuard {
+    readonly limit: Int;
+    readonly model: string | null;
+    readonly relation: string;
+}
+/**
+ * EVERYTHING a statement carries besides its text and its bound values — the ONE optional control
+ * argument of {@link Db.executeSQL}. A plain read OMITS it; every other statement spells the WHOLE
+ * record, because bc types a port by the literal wired into it and rejects a partial one
+ * (`the value wired into it has type obj{…}` — an omitted field is a different type, not a default).
+ * That is the point: absence is the `null` VALUE of a NAMED field, so no call site ever passes a
+ * stand-in value to reach the field after it.
+ *
+ * `write` describes the STATEMENT, not the transport's branch, and it carries its OWN `returning`
+ * ({@link WriteMode}) rather than sitting beside a sibling flag: a statement is a read (`null`) or a
+ * write, and only a write can say whether it yields rows. A flag PAIR would encode four states for
+ * three meanings, and the fourth — "returns rows but is not a write" — has no meaning to reject at
+ * run time in five languages; as a nested struct it does not exist to be rejected.
+ */
+export interface ExecOptions {
+    /**
+     * The NAME of the connection (database) this statement runs on — the multi-DB routing key. `null` ⇒
+     * the DEFAULT connection, which is every single-DB deployment.
+     *
+     * It is a STATIC field, not a per-call value: which database a statement belongs to is a property of
+     * its MODEL (v1 gives the model that authority through its `createDBBase` handler, and loads a
+     * relation on the TARGET model's — `LazyRelation.ts:236`), so the emitter resolves it at emit time
+     * from {@link import('./decorator-adapter').connectionOf} and bakes the name in. The transport puts
+     * it on the statement's {@link import('./exec-context').StatementIntent}, which is the ONE input
+     * `connectionFor` → {@link import('./connection-routing').resolvePool} routes on: the named
+     * connection's reader/writer pair is selected FIRST, then the tx-pin / writer-sticky / reader-writer
+     * split apply within it. An unregistered name is LOUD — never a silent run against another database,
+     * which is exactly what a dropped name did.
+     */
+    readonly db: string | null;
+    /**
+     * How the statement RUNS: `null` ⇒ a READ (the `execute` seam, read intent); a {@link WriteMode} ⇒
+     * an INSERT/UPDATE/DELETE (the write seam + the write intent), carrying whether it yields rows.
+     */
+    readonly write: WriteMode | null;
+    /** The DYNAMIC (SKIP) WHERE plan — `null` unless the read declares an OPTIONAL predicate. */
+    readonly whereDynamic: DynamicWherePlan | null;
+    /** The RELATION runaway cap — `null` unless this is a GUARDED relation child fetch. */
+    readonly guard: CapGuard | null;
+}
+/**
+ * A WRITE statement's own shape — the value of {@link ExecOptions.write} (its absence, `null`, is what
+ * makes a statement a read). `returning` is nested HERE because it is only meaningful under a write:
+ * a RETURNING write stays on the ROW path, a plain write yields the one-row
+ * `[{changes, lastInsertRowid}]` summary instead, which is what keeps the leaf's output shape uniform.
+ * bc lowers this exactly as it lowers {@link CapGuard} — an optional concrete struct, native in go and
+ * rust with no boxing — so the three statement shapes are three values of ONE field.
+ */
+export interface WriteMode {
+    /** The write yields ROWS (a RETURNING write) rather than the affected-rows summary. */
+    readonly returning: boolean;
+}
 /**
  * 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
@@ -29,19 +168,23 @@ import { type WireValue } from 'behavior-contracts';
  */
 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
+     * The SOLE SQL transport: bind `params` and run `sql` through the central execute/run seam. Its
+     * whole control surface is the OPTIONAL {@link ExecOptions} record: `opts.write` is the statement's
+     * RUN MODE — `null` selects `execute` (a read), a {@link WriteMode} selects `run`
+     * (INSERT/UPDATE/DELETE), and its own `opts.write.returning` keeps a RETURNING write on the row path
+     * (`execute`) instead. A non-returning write yields the one-row `[{changes, lastInsertRowid}]`
+     * summary so the output shape is uniform. `opts.guard` is the RELATION runaway cap
+     * ({@link CapGuard}, the compiled op's own resolved cap) 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).
+     * already nested — and because SCP has no throw. `opts.whereDynamic` is the SKIP plan of a read that
+     * declares an optional predicate (CLAUDE.md §2 "only actually-optional predicates accumulate a plan").
+     *
+     * A PLAIN READ omits `opts` (native-clean: the payload is `sql` + `params`); bc typed-native lowers a
+     * non-null struct into the `opt<named>` port via `optSome` (bc#275), so the record is a native struct
+     * literal in go / rust with no boxing.
      */
-    static executeSQL(sql: string, params: WireValue[], write: boolean, returning: boolean, bigint: boolean, whereDynamic?: WireValue | null, guard?: WireValue | null): WireValue[];
+    static executeSQL(sql: string, params: WireValue[], opts?: ExecOptions | 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]`. */

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

@@ -1 +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"}
+{"version":3,"file":"leaf-transport.d.ts","sourceRoot":"","sources":["../../src/scp/leaf-transport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,OAAO,EAAQ,KAAK,GAAG,EAAE,KAAK,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAkBpE;;;;;;;;;GASG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,CAAC,SAAS,GAAG,IAAI,CAAC,EAAE,CAAC;CACvC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC5C;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,SAAS,EAAE,CAAC;CAClC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;IACjC,6FAA6F;IAC7F,QAAQ,CAAC,YAAY,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAC/C,uFAAuF;IACvF,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAAC;CACjC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,SAAS;IACxB,uFAAuF;IACvF,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;GAKG;AACH,qBAAa,EAAE;IACb;;;;;;;;;;;;;;;;OAgBG;IACG,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,EAAE;IAEjG,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

@@ -15,11 +15,26 @@
  *
  * ## The port vocabulary
  *
- * The ports are declared `WireValue` / `WireValue[]` — bc's OPAQUE wire type. A binding annotated
+ * The DATA 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.
+ *
+ * Everything a statement carries BESIDES its text and its bound values rides in ONE optional CONTROL
+ * struct, {@link ExecOptions} (`opts`): WHICH database it runs on (`db`), how to run it (`write` /
+ * `returning`) and the two CONCRETE control structs — {@link DynamicWherePlan} (`whereDynamic`) and
+ * {@link CapGuard} (`guard`) — the
+ * emitter CONSTRUCTS at the call site from the endpoint's own parameters (not leaf→leaf wire values),
+ * so a native-codegen emitter builds them as typed structs. It is ONE argument because a mode flag is a
+ * NAMED FIELD there: a positional list grows a new slot per fact and every call site's remaining
+ * arguments shift (#193), and a trailing optional port can only be reached by passing a filler for the
+ * one before it. A PLAIN READ omits `opts` entirely (native-clean — the payload carries `sql`/`params`
+ * and nothing else); every other statement spells the whole record, so absence is `null` (a fact) and
+ * never a stand-in value. bc typed-native lowers a NON-NULL struct into an `opt<named>` port via
+ * `optSome` (bc#275), so a concrete optional port is native — no boxing. The fragment vocabulary is
+ * CLAUDE.md §2's: SQL + params + a SKIP FLAG (a homogeneous `{skipped, sql, params}` struct), assembled
+ * by the leaf at run — never a `cond`-to-null variant element (which the native-codegen emitters reject).
  */
 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;
@@ -52,19 +67,23 @@ function declarationStub(leafName, args) {
  */
 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
+     * The SOLE SQL transport: bind `params` and run `sql` through the central execute/run seam. Its
+     * whole control surface is the OPTIONAL {@link ExecOptions} record: `opts.write` is the statement's
+     * RUN MODE — `null` selects `execute` (a read), a {@link WriteMode} selects `run`
+     * (INSERT/UPDATE/DELETE), and its own `opts.write.returning` keeps a RETURNING write on the row path
+     * (`execute`) instead. A non-returning write yields the one-row `[{changes, lastInsertRowid}]`
+     * summary so the output shape is uniform. `opts.guard` is the RELATION runaway cap
+     * ({@link CapGuard}, the compiled op's own resolved cap) 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).
+     * already nested — and because SCP has no throw. `opts.whereDynamic` is the SKIP plan of a read that
+     * declares an optional predicate (CLAUDE.md §2 "only actually-optional predicates accumulate a plan").
+     *
+     * A PLAIN READ omits `opts` (native-clean: the payload is `sql` + `params`); bc typed-native lowers a
+     * non-null struct into the `opt<named>` port via `optSome` (bc#275), so the record is a native struct
+     * literal in go / rust with no boxing.
      */
-    static executeSQL(sql, params, write, returning, bigint, whereDynamic, guard) { return declarationStub('executeSQL', [sql, params, write, returning, bigint, whereDynamic, guard]); }
+    static executeSQL(sql, params, opts) { return declarationStub('executeSQL', [sql, params, opts]); }
     /** 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]`. */
@@ -74,7 +93,7 @@ exports.Db = Db;
 __decorate([
     behavior_contracts_1.leaf,
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Array, Boolean, Boolean, Boolean, Object, Object]),
+    __metadata("design:paramtypes", [String, Array, Object]),
     __metadata("design:returntype", Array)
 ], Db, "executeSQL", null);
 __decorate([

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

@@ -1 +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"}
+{"version":3,"file":"leaf-transport.js","sourceRoot":"","sources":["../../src/scp/leaf-transport.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;;;;;;;;;;;;AAEH,2DAAoE;AAEpE;;;;;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;AAqID;;;;;GAKG;AACH,MAAa,EAAE;IACb;;;;;;;;;;;;;;;;OAgBG;IACU,AAAP,MAAM,CAAC,UAAU,CAAC,GAAW,EAAE,MAAmB,EAAE,IAAyB,IAAiB,OAAO,eAAe,CAAC,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAEhK,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;AAzBD,gBAyBC;AAPc;IAAZ,yBAAI;;;;0BAA2J;AAGnJ;IAAZ,yBAAI;;;;qBAA8G;AAGtG;IAAZ,yBAAI;;;;qBAAkN"}

package/dist/scp/leaves.d.ts

@@ -10,10 +10,11 @@
  *
  *   - {@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
+ *     (`write:null`) → rows; write (`write:{returning}`) → a one-row `[{changes,lastInsertRowid}]`
+ *     summary (a RETURNING write returns its rows via `execute` instead). 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
@@ -26,10 +27,16 @@
  * 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}).
+ *
+ * What the statement DOES carry is the NAME of its database (`opts.db`) — a static property of its
+ * model, not an environment fact: the factory owns the connection REGISTRY, the statement owns which
+ * entry of it it belongs to. The two meet on the {@link StatementIntent} ({@link prepareSql}), which is
+ * the only input `connectionFor` routes on.
  */
 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 { DynamicWherePlan, WriteMode } from './leaf-transport';
 import { type Dialect } from './makesql/handler';
 /**
  * The environment boundary the handler factory captures (C4 — never on the IR). `exec` is the SYNC
@@ -52,14 +59,29 @@ export interface AsyncLeafContext {
     /** The target SQL dialect. */
     readonly dialect: Dialect;
 }
-/** The evaluated `executeSQL` ports a generated module hands the transport. */
+/**
+ * The UNBOXED `executeSQL` ports the transport body runs on: the statement plus the facts its ONE
+ * optional control record ({@link import('./leaf-transport').ExecOptions}) carries, already read out
+ * ({@link executeSqlPorts}) — the same flattening the rust / go / python / php transports do after
+ * probing the payload. The imperative tx runner ({@link import('./makesql/tx')}) hands this record
+ * directly, since it holds the statement facts already and has no wire payload to decode.
+ */
 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}. */
+    /**
+     * The NAMED connection (database) this statement runs on — `null`/absent ⇒ the DEFAULT connection.
+     * Baked at emit from the statement's model ({@link import('./decorator-adapter').connectionOf}) or, for
+     * a relation child fetch, from the compiled op's target ({@link import('./relation').RelationOp.connection}).
+     * It reaches the router as the {@link StatementIntent}'s `db` ({@link prepareSql}).
+     */
+    readonly db?: string | null;
+    /**
+     * How the statement RUNS: `null` ⇒ a READ; a {@link WriteMode} ⇒ a write carrying its OWN
+     * `returning`. ONE field, three values — "returns rows but is not a write" is not representable.
+     */
+    readonly write: WriteMode | null;
+    /** The DYNAMIC WHERE plan (absent on a fully-bounded statement — CLAUDE.md §2). See {@link assembleDynamicWhere}. */
     readonly whereDynamic?: DynamicWherePlan | null;
     /**
      * The RELATION runaway cap this statement's rows are asserted against (absent ⇒ uncapped). Carried
@@ -67,31 +89,27 @@ interface ExecuteSqlPorts {
      */
     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).
+ * Assemble the effective statement from a DYNAMIC WHERE plan: drop the SKIPPED fragments (`skipped`
+ * true — the per-call SKIP decision the emitter carried as DATA), join the survivors with ` AND `, and
+ * CONCATENATE the three pieces the plan and the ports already hold — the statement's HEAD (`sql`, which
+ * ends at its WHERE region), the assembled clause, and the plan's `tail`. The params follow the same
+ * three-way order: the head's, the survivors', the tail's.
+ *
+ * There is nothing to LOCATE here. The emitter's SELECT builder is what puts the WHERE in the statement,
+ * so it hands the boundary over ({@link import('./makesql/compile-select').SelectBundle}) instead of
+ * leaving the transport to rediscover it: `plan.lead` says whether the head already ends in a WHERE (so
+ * the clause CONTINUES it) or not (so it OPENS one), and `plan.tailParams` are the tail's own bound
+ * values. That is what removed a lexical scan the five transports each carried a copy of — one that
+ * took a NESTED statement's tail keyword for the outer statement's (#198), counted a QUOTED `?` the
+ * placeholder render skips (#202), and derived a byte offset that is not the same number in five
+ * languages.
  *
  * 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.
+ * emit time. Only the ACTUALLY-optional predicates are in the plan (CLAUDE.md §2): a read with none
+ * carries no plan at all and never reaches this function, and one whose fragments are all skipped
+ * leaves the emitted statement exactly as it was compiled (head + tail, no clause).
  */
 export declare function assembleDynamicWhere(p: {
     sql: string;
@@ -101,11 +119,19 @@ export declare function assembleDynamicWhere(p: {
     sql: string;
     params: unknown[];
 };
-/** Prepare a statement for the seam: resolve deferred PG cast(s), render `?`→`$N`, encode params. */
+/**
+ * Prepare a statement for the seam: resolve deferred PG cast(s), render `?`→`$N`, encode params, and
+ * carry the ONE {@link StatementIntent} both seams take. The intent is the statement's RUN MODE
+ * ({@link effectiveStatement} — a write mode present ⇒ a write), NOT the branch: the branch picks the
+ * SEAM (`returning` ⇒ the row seam), the intent picks the CONNECTION
+ * ({@link import('./connection-routing').resolvePool}), so a RETURNING write runs on `execute` and
+ * still routes to the WRITER. The four native transports derive it the same way (#207).
+ */
 export declare function prepareSql(p: {
     sql: string;
     params: unknown[];
     write: boolean;
+    db?: string | null;
 }, dialect: Dialect): {
     sql: string;
     bound: unknown[];
@@ -121,8 +147,8 @@ export declare function prepareSql(p: {
  * 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.
+ * which the conformance corpus rejects as dialect-variant. There is therefore no exactness port at all
+ * (#193 deleted the `bigint` one, which no language read).
  */
 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. */

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

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