litedbmodel 2.0.0 → 2.0.2

package/dist/scp/runtime.d.ts

@@ -1,241 +1,214 @@
 /**
- * litedbmodel v2 SCP — the thin TS runtime (WS3, #23; spec §3 / §10 / §11).
- *
- * Consumes bc's runtime-core (`runBehavior` = plan stage execution + map/wire/skip
- * propagation + Φ output assembly) and adds ONLY the SQL-backend concerns (spec §11):
- * Backend-Compile bridge (WS1↔WS3), per-Catalog Handlers (render → driver execute →
- * row→model assembly), and Error Mapping. It re-implements NO generic execution.
- *
- * ## Execution pipeline (spec §3)
- *
- *   validate → fragment select (SKIP) → array expand → Expression eval → bind → SQL execute
- *   → assembly
- *
- * bc's `runBehavior` owns the orchestration (which node runs when, map iteration, wire
- * binding, output merge). But the SQL-structural ports (`where` fragment tree, `limit`, …)
- * MUST NOT go through bc's generic port evaluation — a `where` `{arr:[…]}` of comparison
- * Expressions would evaluate to bare booleans (losing the SQL structure), and a SKIP guard
- * over an ABSENT optional input would fail-closed with `UNKNOWN_BINDING`. So the runtime:
- *
- *  1. Backend-Compiles every SQL node up front ({@link import('./bridge').compileNode}) to a
- *     WS1 `CompiledOperation` (SQL text + fragment tree + closed-set param slots).
- *  2. Rewrites the IR into a SURROGATE graph: each SQL node keeps its `id` / wiring / `map`
- *     shape, but its ports collapse to ONE synthetic `__scope` port — a bc `{obj:…}` that
- *     re-exports every binding head the op references (`input` names, wire node ids, the
- *     `map` element `as`). bc evaluates `__scope` in ITS scope (so `input`, sibling results
- *     and the map element all resolve through bc's own machinery) and hands the plain scope
- *     to the handler. No SQL-structural port is ever evaluated by bc.
- *  3. Each handler renders its pre-compiled op against `ports.__scope` via WS1's normative
- *     {@link renderOperation} (fragment select + array expand + Expression eval), binds the
- *     params through the driver, executes REAL SQL, and returns the row list (assembly).
+ * litedbmodel v2 SCP — the thin TS runtime on the STATIC makeSQL bundle (WS3, #23; makeSQL
+ * flip, epic #43/#45 Phase B; spec §3 / §10 / §11).
+ *
+ * makeSQL is the SOLE SCP compile/execute path. A behavior method compiles (SYMBOLICALLY — no
+ * concrete input) to a {@link SqlBundle}:
+ *   - a READ bundle carries a {@link ReadGraph} — the surrogate bc `ComponentGraphIR` (each SQL
+ *     node → a `makeSQL` node) + per-node static statement templates. bc `runBehavior` drives
+ *     map iteration / wire binding / Φ output; the makeSQL handler renders each node's statements
+ *     (value-specs + skip evaluated per-input) and executes real SQL ("bc composes, makeSQL
+ *     executes"). Read-relation batch ops ride the bundle too.
+ *   - a WRITE bundle carries a single `makeSQL` statement (the base write) + the derived gate-first
+ *     {@link TransactionPlan} for a Command with write-time relations.
+ *
+ * The reduced spine (`CompiledOperation` + `FragmentTree` + `renderOperation`) is RETIRED — this
+ * module carries no reduced IR. Reads execute via {@link import('./makesql/static-bundle')} (bc
+ * `runBehavior` + makeSQL handler); writes via {@link import('./makesql/tx')} (gate-first tx-DAG).
  *
  * ## Input normalization (SSoT — defaults live in the schema, not code)
  *
- * An OPTIONAL Input Port that the caller omits is normalized to `null` (present-as-null) so
- * a SKIP guard `{ne:[{refOpt:[port]}, null]}` evaluates to `false` and drops its fragment —
- * absent-key SKIP via `refOpt`. This is driven by the component's `inputPorts` schema
- * (`required !== true` ⇒ optional), NOT an ad-hoc `?? null` in engine code: the schema is
- * the single source of truth for which ports are optional.
+ * An OPTIONAL input head the caller omits is normalized to `null` (present-as-null) so a SKIP
+ * presence expression drops its fragment (absent-key SKIP). "Optional" comes from the bundle's
+ * `optionalHeads` (schema-optional + SKIP-guarded + every `refOpt` head) — the SSoT.
  */
-import { type Component, type Handlers, type Scope, type Value } from 'behavior-contracts';
+import { type Scope, type Value } from 'behavior-contracts';
 import type { BehaviorModelContract } from './authoring';
-import type { CompiledOperation } from './ir';
 import { SqlFailure } from './errors';
-import { type RelationDecl, type RelationOp, type RelationDriver } from './relation';
+import { type RelationDecl, type RelationOp } from './relation';
 import { type ReadOptions } from './typed-object';
-import { type TransactionPlan } from './write-plan';
-import { type TransactionResult } from './write-runtime';
+import type { DialectName } from './dialect';
+import type { FindFilterSource } from './find-filter-guard';
+import type { ColumnTypeResolver } from './coltype';
+import { type ReadGraph, type StaticStatement, type SqliteDb as StaticSqliteDb, type SqlExecutorAsync } from './makesql/static-bundle';
+import { type TransactionPlan, type TransactionResult } from './makesql/tx';
+import { type InsertManyBuildOptions } from './makesql/compile-crud';
+import type { UpdateManyBuildOptions } from '../drivers/types';
 import { type EntityWritesDefinition, type LifecycleContract, type WriteLifecyclePhase } from './writes';
-import { type Dialect, type DialectName } from './dialect';
-/**
- * The minimal synchronous SQLite driver surface the runtime needs (better-sqlite3
- * `Database`). `all` returns the row list of a SELECT / RETURNING statement; `run` executes
- * a non-returning write and reports `changes` + `lastInsertRowid`. In-process, synchronous
- * — the sanctioned in-proc substitute for a docker integration DB (#23 AC).
- */
-export interface SqliteDb {
-    prepare(sql: string): {
-        all(...params: unknown[]): unknown[];
-        run(...params: unknown[]): {
-            changes: number;
-            lastInsertRowid: number | bigint;
-        };
-        reader?: boolean;
-    };
-}
-/**
- * Build the SQL handler registry: one handler per SQL Catalog name (spec §11 item 4).
- *
- * Exported so the mode-3 codegen path (WS7f) binds the IDENTICAL SQL handlers into bc's
- * generated `bind(handlers)` accessor — the generated module bakes the surrogate IR literal and
- * calls the SAME `runBehavior`, so pairing it with THIS handler builder makes the codegen output
- * byte-identical to {@link executeBundle} by construction (not a parallel reimplementation).
- */
-export declare function buildHandlers(db: SqliteDb, compiled: Record<string, CompiledOperation>, dialect: Dialect): Handlers;
-/**
- * Normalize the caller input to `null` (present-as-null) for every OPTIONAL binding the
- * caller omitted, so a SKIP guard using `refOpt` evaluates to `false` and drops its
- * fragment (absent-key SKIP). "Optional" is determined from the SSoT, NOT an ad-hoc code
- * default — a head is optional iff EITHER (a) the component's Input Port schema marks the
- * port `required !== true`, OR (b) the head is SKIP-guarded in a compiled fragment (the
- * SKIP fragment declares its driving input optional — spec §7). A REQUIRED, non-SKIP head
- * that is missing is left absent so a real wiring bug surfaces loudly as bc's
- * `UNKNOWN_BINDING` rather than being silently defaulted.
- */
-export declare function normalizeInput(component: Component, optionalHeads: Set<string>, input: Scope): Scope;
+/** The minimal synchronous SQLite driver surface the runtime needs (better-sqlite3 `Database`). */
+export type SqliteDb = StaticSqliteDb;
 /** Execute options: the driver and the entry component (method) to run. */
 export interface ExecuteOptions {
     /** The synchronous SQLite driver (better-sqlite3 `Database`). */
     readonly db: SqliteDb;
     /** The behavior method (component) name to run (default: the first component). */
     readonly entry?: string;
-    /**
-     * The model's read-relation declarations (spec §4/§5). Compiled ONCE into the bundle's
-     * relation ops so the typed-object read surface ({@link read}) can batch-resolve both
-     * declarative-select and lazy relations via the SAME compiled op.
-     */
+    /** The model's read-relation declarations (spec §4/§5), compiled ONCE into the bundle. */
     readonly relations?: readonly RelationDecl[];
-    /**
-     * The target SQL dialect (spec §4/§10). Defaults to `'sqlite'` (the in-process runtime seam
-     * is synchronous SQLite). A `'postgres'`/`'mysql'` bundle is Backend-Compiled dialect-tagged
-     * for the dialect golden + a language runtime; the `?`→`$N` (PG) conversion is applied at
-     * render time. The SSoT dialect strategy governs every dialect divergence.
-     */
+    /** The target SQL dialect (spec §4/§10). Defaults to `'sqlite'` (the in-process runtime seam). */
     readonly dialect?: DialectName;
 }
 /**
- * The Backend-Compiled bundle of ONE behavior method (spec §8): the fully compiled SQL IR a
- * thin per-language runtime (bc runtime-core + a SQL handler) can execute WITHOUT
- * re-implementing litedbmodel's Backend-Compile. It is pure serializable JSON:
+ * The compiled bundle of ONE behavior method (spec §8) — pure serializable JSON a thin
+ * per-language runtime (bc + a SQL handler) can execute WITHOUT re-implementing litedbmodel's
+ * compile.
  *
- *  - `component` — the bc component's WIRING ONLY (body node ids / parent / map `over`+`as` /
- *    `cond` / output / plan / inputPorts). The catalog nodes' original Expression-IR ports
- *    are replaced by the surrogate `__scope` port so a consumer runtime feeds bc's
- *    `runBehavior` the plan/map/wire orchestration with NO SQL-structural port to mis-evaluate.
- *  - `operations` — `nodeId → CompiledOperation` (§8: `sql` with the `{where}` splice,
- *    `where` fragment tree with existence rules, `params` static slots, `assembly`). Param
- *    slots stay as Expression IR (`{coalesce:[…]}`, `{ref:[…]}`) so bc runtime-core owns
- *    value/SKIP evaluation per language (they are NOT pre-evaluated to literals).
- *  - `optionalHeads` — the input heads normalized to present-as-null (absent-key SKIP), so a
- *    consumer runtime reproduces the same normalization from the bundle (not from TS state).
+ *  - READ (`readGraph` present): the surrogate `ComponentGraphIR` + per-node makeSQL statement
+ *    templates; bc `runBehavior` owns orchestration, the makeSQL handler renders + executes.
+ *  - WRITE (`statement` present): the single base-write makeSQL template; for a Command with
+ *    write-time relations, `transaction` carries the derived gate-first plan.
+ *  - `relations` — STATIC read-relation batch ops (spec §8 relation ops), keyed by name.
  *
- * `dialect` is the target SQL dialect (`'sqlite'`/`'postgres'`/`'mysql'`); the dialect axis is
- * compiled ONCE, TS-side (spec §10). A PG bundle's `operations[*].sql` still carries `?`
- * placeholders — the `?`→`$N` conversion is the render-time final one-pass, so the bundle stays
- * uniform and dialect-tagged.
+ * `dialect` is the target SQL dialect (compiled ONCE, TS-side); a PG bundle's `?`→`$N` conversion
+ * is the render-time final pass, so the bundle stays uniform and dialect-tagged.
  */
 export interface SqlBundle {
-    readonly irVersion: number;
-    readonly exprVersion: number;
     readonly dialect: DialectName;
-    /** The surrogate component (wiring/plan/output only; catalog ports → `__scope`). */
-    readonly component: Component;
-    /** Backend-Compiled SQL IR per catalog node id (§8 shape). */
-    readonly operations: Record<string, CompiledOperation>;
+    /** The behavior (component) name. */
+    readonly name: string;
+    /** READ bundles: the portable read graph (surrogate IR + per-node makeSQL statements). */
+    readonly readGraph?: ReadGraph;
+    /** WRITE bundles: the single base-write makeSQL statement template. */
+    readonly statement?: StaticStatement;
     /** Optional input heads normalized to present-as-null (absent-key SKIP). */
-    readonly optionalHeads: string[];
-    /**
-     * Pre-compiled read-relation batch ops (spec §8 `relation ops`), keyed by relation name.
-     * Derived ONCE (TS-side) from the model relation declarations, dialect-aware (SQLite).
-     * Pure JSON (each op's `query` is a {@link CompiledOperation}) so a thin per-language
-     * runtime gets the relation batch SQL for free (WS7). BOTH read surfaces (declarative
-     * select + lazy) resolve through these ops — the identical compiled op.
-     */
+    readonly optionalHeads: readonly string[];
+    /** Pre-compiled STATIC read-relation batch ops, keyed by relation name (pure JSON). */
     readonly relations: Record<string, RelationOp>;
+    /** The derived write-time-relations transaction plan (present ONLY for a write Command bundle). */
+    readonly transaction?: TransactionPlan;
     /**
-     * The derived write-time-relations transaction plan (spec §6 / §8 `transaction plan`), present
-     * ONLY for a Command bundle whose base write declares an `onWrite` lifecycle. Pure JSON:
-     * ordered statements + gate-first rules + `$.entity` exposure. A WS7 runtime executes the SAME
-     * plan via {@link executeTransactionBundle} (bc-core render + a SQL handler + BEGIN/COMMIT) —
-     * no re-derivation per language (spec §6). Absent for read bundles and for Command bundles with
-     * no write-time relations (those run through the ordinary {@link executeBundle} path).
+     * Codegen typed-de-box `outputType` for a WRITE bundle (spec §4.1 / §9): the bc portable type of
+     * the write's {@link TransactionResult} (entity / returnedRows rows typed via the schema SoT). A
+     * READ bundle carries its outType/outputType inside `readGraph.ir` instead; a write bundle has no
+     * such surrogate, so its output type rides HERE and is attached to the write's `makeSqlComponentIR`
+     * node/component by {@link bundleToPortableIR}. Present ONLY when a column-type resolver was
+     * supplied at compile (additive/back-compat: absent → the write IR stays un-annotated, as before).
      */
-    readonly transaction?: TransactionPlan;
+    readonly outputType?: unknown;
 }
 /**
- * Execute a published behavior contract (WS2 {@link BehaviorModelContract}) end-to-end:
- * Backend-Compile every SQL node → surrogate IR → bc `runBehavior` (plan / map / wire /
- * output) with SQL handlers → REAL SQLite execution → assembled Φ output.
- *
- * This is α's vertical slice: authoring → IR → Backend-Compile → thin runtime → real
- * SQLite → assembly. The returned Value is the component's `output` (Φ merge) with each SQL
- * node's slot filled by its executed row list.
+ * Execute a published behavior contract (WS2 {@link BehaviorModelContract}) end-to-end via the
+ * static makeSQL bundle. Returns the component's output (a read Φ output / row list, or a write's
+ * RETURNING rows / `[{changes, lastInsertRowid}]` summary).
  *
- * @throws {SqlFailure} a mapped driver failure re-surfaced at the boundary (a `fail`-policy
- *   node re-throws through `runPlan` as `OP_FAILED`; the runtime unwraps it back to the
- *   structured {@link SqlFailure} so the caller sees `kind` / `policy` / `sqliteCode`).
+ * @throws {SqlFailure} a mapped driver failure re-surfaced at the boundary.
  */
 export declare function executeBehavior(contract: BehaviorModelContract, input: Scope, options: ExecuteOptions): Value;
 /**
- * Backend-Compile ONE behavior method of a contract into the serializable {@link SqlBundle}
- * (spec §8) — the published multi-language artifact. This runs the WS1↔WS3 bridge and the
- * surrogate rewrite ONCE, on the TS side (spec §10: the dialect axis is compiled once), and
- * emits pure JSON: no TS runtime state is captured, so `JSON.stringify(bundle)` round-trips
- * losslessly and a thin per-language runtime can execute it with bc runtime-core + a SQL
- * handler alone (proven by the bundle round-trip test).
+ * Compile ONE behavior method into the serializable STATIC {@link SqlBundle} (spec §8) — the
+ * published multi-language artifact. SYMBOLIC (no concrete input). A read method compiles to a
+ * {@link ReadGraph}; a single-write method to a `makeSQL` statement. Pure JSON throughout.
  */
-export declare function compileBundle(contract: BehaviorModelContract, entry?: string, relations?: readonly RelationDecl[], dialectName?: DialectName): SqlBundle;
+export declare function compileBundle(contract: BehaviorModelContract, entry?: string, relations?: readonly RelationDecl[], dialectName?: DialectName, findFilterModel?: FindFilterSource, resolveColumnType?: ColumnTypeResolver): SqlBundle;
 /**
- * Execute a {@link SqlBundle} (the §8 published artifact) end-to-end: feed bc `runBehavior`
- * the bundle's surrogate component (plan / map / wire / output orchestration) with SQL
- * handlers that render the bundle's `CompiledOperation`s and run REAL SQLite. This is the
- * SAME code path a thin per-language runtime follows — it consumes ONLY the serialized
- * bundle + bc runtime-core, never re-running litedbmodel's Backend-Compile. The bundle
- * round-trip test parses this from JSON (no TS state) to prove self-sufficiency (WS7).
+ * Execute a {@link SqlBundle} (the §8 published artifact) end-to-end via the static makeSQL
+ * runtime + REAL SQLite. Read bundles run the read graph via bc `runBehavior`; single-statement
+ * write bundles run the write (RETURNING rows / summary). The SAME code path a thin per-language
+ * runtime follows — it consumes ONLY the serialized bundle + bc, never re-running the compile.
  *
  * @throws {SqlFailure} a mapped driver failure re-surfaced at the boundary.
  */
 export declare function executeBundle(bundle: SqlBundle, input: Scope, options: ExecuteOptions): Value;
+/** Async execute options: the pooled async SQL executor + the entry component (method) to run. */
+export interface AsyncExecuteOptions {
+    /** The pooled async SQL executor (build via `pgPoolExecutor` / `mysqlPoolExecutor`). */
+    readonly exec: SqlExecutorAsync;
+    /** The behavior method (component) name to run (default: the first component). */
+    readonly entry?: string;
+    /** The model's read-relation declarations (spec §4/§5), compiled ONCE into the bundle. */
+    readonly relations?: readonly RelationDecl[];
+    /** The target SQL dialect (spec §4/§10). For the live async path this is `'postgres'`/`'mysql'`. */
+    readonly dialect?: DialectName;
+}
 /**
- * Backend-Compile a Command method + its `entityWrites` save contract into a {@link SqlBundle}
- * that carries the derived, gate-first write-time-relations {@link TransactionPlan} (spec §6/§8).
- * The base write op is Backend-Compiled ONCE (the same {@link compileNode} bridge), and
- * {@link deriveTransactionPlan} lowers the lifecycle's §6 effect arrays around it into the ordered
- * statement list. The whole plan is pure JSON (it round-trips inside the bundle), so a WS7 runtime
- * honors the SAME plan via {@link executeTransactionBundle} — no re-derivation.
+ * Execute a READ {@link SqlBundle} end-to-end via the ASYNC PG / MySQL execution model (#40): bc
+ * `runBehaviorAsync` drives map iteration / wire binding / Φ output and dispatches independent
+ * sibling read nodes in bounded parallel against the pooled async executor. This is the PRODUCTION
+ * live-DB read entry point — the async twin of {@link executeBundle} for read bundles.
+ *
+ * Byte-identical composition (SAME IR, SAME per-node SQL text + params, SAME Φ output) to the
+ * serial `executeBundle`; concurrency changes only the wall-clock. A single-relation (zero-sibling)
+ * read graph runs exactly one query, so it is identical to the serial path either way.
  *
- * @throws if the method is not a Command, the phase lifecycle is not declared, the scope is not a
- *   single base write, or a `$.entity.*` reference lacks a RETURNING body (all fail-closed).
+ * A single-statement WRITE bundle is NOT accepted here — the write-tx path stays sync + serial
+ * (`executeBundle` / `executeTransactionBundle`); this async path is READ-only.
+ *
+ * @throws {SqlFailure} a mapped driver failure re-surfaced at the boundary.
  */
-export declare function compileWriteBundle(contract: BehaviorModelContract, entry: string, writes: EntityWritesDefinition, phase: WriteLifecyclePhase, dialectName?: DialectName): SqlBundle;
+export declare function executeBundleAsync(bundle: SqlBundle, input: Scope, options: AsyncExecuteOptions): Promise<Value>;
+/**
+ * Compile + execute a READ behavior method via the ASYNC PG / MySQL execution model (#40). The
+ * async twin of {@link executeBehavior} for reads: compile the contract to a {@link SqlBundle}
+ * (SYMBOLIC), then run its read graph through {@link executeBundleAsync}.
+ *
+ * @throws {SqlFailure} a mapped driver failure re-surfaced at the boundary.
+ */
+export declare function executeBehaviorAsync(contract: BehaviorModelContract, input: Scope, options: AsyncExecuteOptions): Promise<Value>;
+/**
+ * Compile a Command method + its `entityWrites` save contract into a {@link SqlBundle} carrying
+ * the derived, gate-first write-time-relations {@link TransactionPlan} (spec §6/§8). The base
+ * write op is compiled ONCE (the SAME `compileWriteNode` — complete tuned SQL + deferred
+ * Expression-IR params); {@link deriveTransactionPlan} lowers the lifecycle's §6 effect arrays
+ * around it into the ordered statement list. Pure JSON; a WS7 runtime honors the SAME plan.
+ */
+export declare function compileWriteBundle(contract: BehaviorModelContract, entry: string, writes: EntityWritesDefinition, phase: WriteLifecyclePhase, dialectName?: DialectName, resolveColumnType?: ColumnTypeResolver): SqlBundle;
 /**
  * One member of a COMPOSITE (multi-write) Command (WS8a, #28 — spec §6 nested write / §14 tx-DAG):
  * a named base write (its sole Insert/Update/Delete node in `entry`) carrying its OWN save-contract
  * `effects`. A later member references an earlier member's RETURNING row via `$.ref.<name>.<field>`.
  */
 export interface CompositeWriteEntry {
-    /** The Command method whose sole base-write node is this member's body. */
     readonly entry: string;
-    /** The member's stable name (downstream members address its row as `$.ref.<name>.<field>`). */
     readonly name: string;
-    /** The member's write-time-relations lifecycle for this phase (its gates/derive/edges/emits). */
     readonly lifecycle: LifecycleContract;
 }
 /**
- * Backend-Compile a COMPOSITE (multi-write) Command into a {@link SqlBundle} carrying ONE derived,
- * gate-first, TOPOLOGICALLY-ORDERED transaction plan (spec §6 nested write / §14 "write-time tx DAG
- * 導出"). Each {@link CompositeWriteEntry} contributes a named base write + its effects; a later
- * member depends on an earlier via `$.ref.<name>.*` (e.g. a child INSERT keyed by the parent's
- * RETURNING id). {@link deriveTransactionPlan} builds the data-dependency graph + gate-first
- * constraint and derives the correct ordered plan (deterministic, stable tie-break; a cycle or
- * dangling ref is ESCALATED). The plan is pure JSON — the 5 language runtimes execute it verbatim
- * (they already bind each statement's `binds` row into scope for downstream `$.ref` resolution).
- *
- * @throws if an entry is missing/not a single-write node, or the DAG cannot be derived (cycle /
- *   dangling `$.ref` / missing RETURNING on a referenced write) — all fail-closed.
+ * Compile a COMPOSITE (multi-write) Command into a {@link SqlBundle} carrying ONE derived,
+ * gate-first, TOPOLOGICALLY-ORDERED transaction plan (spec §6 nested write / §14). Each entry
+ * contributes a named base write + its effects; a later member depends on an earlier via
+ * `$.ref.<name>.*`. {@link deriveTransactionPlan} builds the DAG + gate-first constraint and
+ * derives the ordered plan; a cycle / dangling ref is ESCALATED. Pure JSON.
  */
 export declare function compileCompositeWriteBundle(contract: BehaviorModelContract, entries: readonly CompositeWriteEntry[], phase: WriteLifecyclePhase, dialectName?: DialectName): SqlBundle;
+/**
+ * Compile a `createMany` into a batch write {@link SqlBundle} carrying a gate-free
+ * {@link TransactionPlan}. Heterogeneous column-set groups become MULTIPLE ordered INSERT
+ * statements — byte-identical to what `DBModel._insert` emits per group (via `compileInsertMany`).
+ *
+ * `pk` (the target PK descriptor) is REQUIRED when the createMany carries a RETURNING clause on the
+ * MySQL dialect: a batch INSERT persists N rows, so the MySQL RETURNING emulation must re-select ALL
+ * N (a range on the AUTO_INCREMENT column, or the client-supplied PK values), not a single `id`.
+ */
+export declare function compileCreateManyBundle(name: string, options: InsertManyBuildOptions & {
+    pk?: {
+        columns: readonly string[];
+        autoInc: string | null;
+    };
+}, dialectName?: DialectName, resolveColumnType?: ColumnTypeResolver): SqlBundle;
+/**
+ * Compile an `updateMany` into a batch write {@link SqlBundle} (one UNNEST/JSON/CASE statement,
+ * byte-identical to `compileUpdateMany` driving the v1 `buildUpdateMany` / JSON-batch builder).
+ */
+export declare function compileUpdateManyBundle(name: string, options: UpdateManyBuildOptions, dialectName?: DialectName): SqlBundle;
+/**
+ * Compile a `deleteMany` into a batch write {@link SqlBundle} — a PK-set IN-list DELETE (single-key)
+ * or one DELETE per composite-key group, driven by the v1 `DBConditions` builder (`compileDeleteMany`).
+ */
+export declare function compileDeleteManyBundle(name: string, options: {
+    tableName: string;
+    keyColumns: string[];
+    keys: Record<string, unknown>[];
+    returning?: string;
+}, dialectName?: DialectName): SqlBundle;
 /**
  * Execute a COMPOSITE (multi-write) Command end-to-end as ONE real SQLite transaction with gate-
- * first short-circuit + DAG-ordered statements (spec §6 / §14): Backend-Compile the members into a
- * bundle with the derived tx-DAG plan, then run {@link executeTransactionBundle}.
+ * first short-circuit + DAG-ordered statements (spec §6 / §14).
  */
 export declare function executeCompositeCommand(contract: BehaviorModelContract, entries: readonly CompositeWriteEntry[], phase: WriteLifecyclePhase, input: Scope, options: ExecuteOptions): TransactionResult;
 /**
  * Execute a Command end-to-end as ONE real SQLite transaction with gate-first short-circuit
- * (spec §6): Backend-Compile the Command + its save contract into a {@link SqlBundle} with a
- * transaction plan, then run {@link executeTransactionBundle}. This is the v2 public write path
- * ("write-time relations が自動導出 → 1 tx", spec §2.3).
+ * (spec §6): compile the Command + its save contract into a {@link SqlBundle} with a transaction
+ * plan, then run {@link executeTransactionBundle}. The v2 public write path.
  *
  * @throws {SqlFailure} a mapped driver failure (the transaction ROLLBACKs first).
  */
@@ -244,52 +217,26 @@ export declare function executeCommand(contract: BehaviorModelContract, writes:
 }): TransactionResult;
 /**
  * Execute a {@link SqlBundle}'s derived transaction plan (spec §6/§8) as ONE real SQLite
- * transaction. This is the SAME code path a thin per-language runtime follows: it consumes ONLY
- * the serialized {@link TransactionPlan} (pure JSON) + the render pipeline + a SQL driver, never
- * re-deriving the plan. The bundle round-trip test parses this from JSON (no TS state) to prove
- * WS7 self-sufficiency.
+ * transaction. The SAME code path a thin per-language runtime follows: it consumes ONLY the
+ * serialized {@link TransactionPlan} (pure JSON) + a SQL driver, never re-deriving the plan.
  *
- * @throws if the bundle carries no transaction plan (it is not a write-time-relations Command
- *   bundle), or {@link SqlFailure} on a mapped driver failure.
+ * @throws if the bundle carries no transaction plan, or {@link SqlFailure} on a driver failure.
  */
 export declare function executeTransactionBundle(bundle: SqlBundle, input: Scope, options: ExecuteOptions): TransactionResult;
 /** Options for the typed-object {@link read} surface: base execution + relation read opts. */
 export interface ReadRuntimeOptions<R = Record<string, unknown>> extends ExecuteOptions, ReadOptions<R> {
 }
 /**
- * The v2 typed-object read surface (spec §4/§5/§12): run a read behavior whose output is a
- * row list (a Select), then wrap each raw row in a plain TYPED-OBJECT (own props = data only,
- * NOT a DBModel instance) with read relations attached.
- *
- * - A relation named in `options.with` is DECLARATIVELY selected: batch-prefetched ONCE over
- *   the whole page (staged, no N+1) and attached as an OWN prop.
- * - Every OTHER declared relation is LAZY: a prototype getter that, on `await result.author`,
- *   fires the SAME compiled relation op over the sibling set (batched — still no N+1).
- * - `options.hydrate` recovers host objects (`(raw) => new Domain(raw)`) — the consumer-side
- *   method-UX recovery. It stays in the runtime and never enters the bundle.
- *
- * Both surfaces share the ONE compiled relation op in the bundle (spec §5). The base row list
- * is produced by the SAME {@link executeBundle} path (bc runtime-core + SQL handlers), so the
- * read query itself is fully IR-driven; relations are the runtime's staged-batch concern.
+ * The v2 typed-object read surface (spec §4/§5/§12): run a read behavior whose output is a row
+ * list (a Select), then wrap each raw row in a plain TYPED-OBJECT with read relations attached.
+ * A relation named in `options.with` is declaratively batch-prefetched; every other declared
+ * relation is lazy (a prototype getter firing the SAME compiled op over the sibling set). Both
+ * surfaces share the ONE compiled relation op in the bundle.
  *
- * @throws if the behavior output is not a row list (the typed-object surface is for reads).
+ * @throws if the behavior output is not a row list (the typed-object read surface is for reads).
  */
 export declare function read<R = Record<string, unknown>>(contract: BehaviorModelContract, input: Scope, options: ReadRuntimeOptions<R>): R[];
 /** {@link read} against an already-compiled {@link SqlBundle} (the published §8 artifact). */
 export declare function readBundle<R = Record<string, unknown>>(bundle: SqlBundle, input: Scope, options: ReadRuntimeOptions<R>): R[];
-/**
- * Resolve ONE relation for a page of parent rows by driving bc's PLAN mechanism (spec §5:
- * `deriveExecutionPlan` — result path → stage groups + concurrency). This is the staged-batch
- * path: it builds a bc component with a single `map.batched` node over the parent rows and
- * runs it through {@link runBehavior} (the SAME multi-language execution core WS7 languages
- * use). Because the map is `batched`, bc evaluates every parent's key port and invokes the
- * relation handler EXACTLY ONCE with `{items:[…]}` — so the relation op fires ONE batched
- * query for the whole page (structurally no N+1, enforced by bc's batch contract). The
- * handler runs the IDENTICAL compiled {@link RelationOp} the declarative-select and lazy
- * surfaces use, and `into` attaches each parent's resolved child(ren).
- *
- * Returns the parent rows augmented with the relation under `op.name` (per cardinality).
- */
-export declare function resolveRelationViaPlan(op: RelationOp, parents: readonly Record<string, unknown>[], db: RelationDriver): Record<string, unknown>[];
 export { SqlFailure };
 //# sourceMappingURL=runtime.d.ts.map

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

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