litedbmodel 1.2.10 → 2.0.1

package/dist/scp/catalog.js

@@ -0,0 +1,230 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP catalog — WS1 (#21).
+ *
+ * `LITEDBMODEL_CATALOG` is the behavior-contracts–typed `Catalog` that IS the whole
+ * per-DSL difference litedbmodel supplies as a SQL-backend consumer (bc C2: "the only
+ * per-DSL difference is the catalog"). It mirrors the SHAPE of graphddb's
+ * `GRAPHDDB_CATALOG` (`src/spec/catalog.ts`) exactly: compact `PortSchema` constructors,
+ * an `entry()` helper, per-primitive `inputPorts`, an `output.shape`, and a
+ * `portableToIR` flag. The effect implementation (SQL execution + row→model assembly) is
+ * bound separately in the handler registry (WS3, C4 — catalog declares, registry binds).
+ *
+ * ## Catalog names (spec §1 / §11 item 1)
+ *
+ * `Select` / `Insert` / `Update` / `Delete` are the CRUD leaf components. `Fragment` is
+ * the dynamic WHERE/SET fragment-tree component (SKIP → fragment existence rules, §8);
+ * `Tx` is the multi-statement transaction envelope. As in graphddb, the transaction
+ * envelope (`Tx`) is `portableToIR: false` — a transaction is emitted as a Component
+ * whose body references the per-statement CRUD primitives; the atomic BEGIN/COMMIT
+ * envelope is the runtime's execution concern (WS3), never a portable-IR node.
+ *
+ * ## Port schema conventions
+ *
+ * A `CatalogEntry.inputPorts` names the STATIC ports of the emitted wiring. Two families
+ * are dynamic by construction and are validated by {@link assertComponentsInCatalog}
+ * against documented patterns instead of being statically enumerable:
+ *
+ * - **`where`/`set`/`values` records**: one port per model field, flattened one-port-
+ *   per-field under a `<group>.<field>` key ({@link WRITE_PORT_FAMILIES}). These carry
+ *   Expression IR (the field's value/condition), from the closed operator set only.
+ *
+ * The CRUD entries carry `additionalPorts: true` (bc#26) so bc's shared port check
+ * (`checkPortNames` / `buildComponentDefinition`) accepts the dynamic families; every
+ * DECLARED port keeps bc's required/type checks regardless of the opt-in. `Tx`'s single
+ * port is static, so it keeps bc's fail-closed default.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WRITE_PORT_FAMILIES = exports.WRITE_CATALOG_NAMES = exports.CATALOG_NAMES = exports.LITEDBMODEL_CATALOG = void 0;
+exports.catalogEntry = catalogEntry;
+exports.assertComponentsInCatalog = assertComponentsInCatalog;
+exports.deriveContractEffect = deriveContractEffect;
+const behavior_contracts_1 = require("behavior-contracts");
+// Compact schema constructors (the IR bundle is size-budgeted — graphddb convention).
+const P = (type, required) => (required ? { type, required } : { type });
+/**
+ * The shared read-port surface for `Select`: `table` always; the optional
+ * `where` (a fragment-tree reference — see `Fragment`), `order`, `limit`, `offset`,
+ * `group` wiring, and the always-emitted `select` projection.
+ *
+ * `where` is typed `fragment` (not `expr`): a Select's dynamic WHERE is a fragment tree
+ * (§8), NOT a single Expression — the SKIP existence rules live on the tree, outside the
+ * Expression IR vocabulary (bc `expression-ir.md` §4: SKIP is OUTSIDE Expression IR).
+ * `limit` / `offset` are `expr` (they may be an input-ref or a `coalesce` default, §8).
+ */
+const SELECT_PORTS = {
+    table: P('string', true),
+    select: P('string[]', true),
+    where: P('fragment'),
+    order: P('string'),
+    limit: P('expr'),
+    offset: P('expr'),
+    group: P('string'),
+    // Additive read-tail/head ports (V0 R3/R4/R5/R6). SQL is v1-sourced from the matching
+    // `SelectDesc` fields via `compileSelect` (`_buildSelectSQL`), wired in `compileSelectNode`:
+    //  - `forUpdate` (R3): a literal `'true'` string toggles the ` FOR UPDATE` tail.
+    //  - `join`/`joinParams` (R5): a literal JOIN clause text (`JOIN t ON …`) + its bound
+    //    value-specs (`expr[]`), spliced after `FROM <t>` (v1 `_buildSelectSQL` JOIN position).
+    //  - `cte`/`cteParams` (R4): a WITH-CTE `{name, sql}` literal + its bound value-specs,
+    //    prefixed as `WITH <name> AS (<sql>) ` (v1 WITH-wrap). `cteParams` bind FIRST (v1 param
+    //    order: CTE → JOIN → WHERE).
+    //  - `append` (R6): a raw trailing clause text (e.g. `HAVING …`) appended verbatim.
+    forUpdate: P('string'),
+    join: P('string'),
+    joinParams: P('expr[]'),
+    cte: P('map'),
+    cteParams: P('expr[]'),
+    append: P('string'),
+};
+/**
+ * The shared write-port surface for `Insert`/`Update`/`Delete`: `table` always;
+ * `where` (fragment tree — required existence enforced by the compiler, not here, since a
+ * Select may legitimately omit it); `returning` projection; `onConflict` wiring for
+ * Insert. The per-field value/set ports (`values.<field>` / `set.<field>`) are dynamic
+ * ({@link WRITE_PORT_FAMILIES}) and each carries an Expression IR value.
+ */
+const WRITE_PORTS = {
+    table: P('string', true),
+    where: P('fragment'),
+    returning: P('string'),
+    onConflict: P('string'),
+    onConflictAction: P('string'),
+    // PRIMARY KEY descriptor for the MySQL RETURNING emulation (INSERT…RETURNING): `pk` is a
+    // comma-separated PK column list, `autoInc` names the single AUTO_INCREMENT column (absent for a
+    // client-supplied PK). Consumed by compileWriteNode → mysqlPkHint so the emulation re-selects by
+    // the REAL PK. Inert on PG/SQLite (native RETURNING).
+    pk: P('string'),
+    autoInc: P('string'),
+};
+const entry = (name, inputPorts, shape, portableToIR) => ({
+    name,
+    inputPorts,
+    output: { shape },
+    portableToIR,
+    // Dynamic port families (where/set/values record ports) are validated by
+    // assertComponentsInCatalog, not statically enumerable. Tx overrides back to
+    // fail-closed (its one port is static).
+    additionalPorts: true,
+});
+/**
+ * litedbmodel's specific-component catalog (spec §11 item 1) — the behavior-contracts
+ * `Catalog`-typed source of truth. Each entry declares the Port schema of one SQL
+ * primitive AS THE BACKEND COMPILE WIRES IT; the effect implementation is bound
+ * separately in the handler registry (WS3, C4). All entries except `Tx` may appear in
+ * the portable IR.
+ */
+exports.LITEDBMODEL_CATALOG = {
+    // Read: `items` (a Select root yields a row list; per-row collapse to `item` is the
+    // consumer's cardinality concern, mirrored from graphddb Query's `cardinality` port).
+    Select: entry('Select', { ...SELECT_PORTS, cardinality: P('string') }, 'items', true),
+    // COUNT(*) aggregate read (v1 `DBModel._count`): `SELECT COUNT(*) as count FROM t[ WHERE …]`.
+    // Only `table` (required) + the optional `where` fragment tree — v1's count carries no
+    // projection/order/limit/offset (it counts the filtered rows). Output is a one-row `[{count}]`
+    // list (the `items` shape, like every read); the consumer reads `count` — v1's `parseInt(count)`.
+    Count: entry('Count', { table: P('string', true), where: P('fragment') }, 'items', true),
+    // Writes yield the RETURNING row list (`items`); a single-row write collapses at the
+    // consumer boundary, same as reads.
+    Insert: entry('Insert', WRITE_PORTS, 'items', true),
+    Update: entry('Update', WRITE_PORTS, 'items', true),
+    Delete: entry('Delete', WRITE_PORTS, 'items', true),
+    // The dynamic WHERE/SET fragment-tree component (§8). Its ports carry the fragment
+    // tree; the compiler resolves SKIP/AND-OR structure to fragment existence rules.
+    Fragment: entry('Fragment', { tree: P('fragment', true) }, 'item', true),
+    // The runtime-side atomic envelope: never referenced by the portable IR (a transaction
+    // IS a component over the CRUD primitives) — runtime-only. Its single port is static,
+    // so it keeps bc's fail-closed default (no additionalPorts opt-in).
+    Tx: {
+        ...entry('Tx', { statements: P('map[]', true) }, 'item', false),
+        additionalPorts: false,
+    },
+};
+/** Look up a catalog entry by name (undefined for an unknown primitive). */
+function catalogEntry(name) {
+    return exports.LITEDBMODEL_CATALOG[name];
+}
+/** The catalog names litedbmodel declares (the C2 per-DSL surface). */
+exports.CATALOG_NAMES = [
+    'Select',
+    'Count',
+    'Insert',
+    'Update',
+    'Delete',
+    'Fragment',
+    'Tx',
+];
+/**
+ * The CQRS write catalog: the names whose presence in a component body makes the
+ * component a COMMAND (spec §2.4 — effect is derived from the graph, not authored).
+ * `Select`/`Fragment` are read-side; `Insert`/`Update`/`Delete`/`Tx` are write-side.
+ */
+exports.WRITE_CATALOG_NAMES = [
+    'Insert',
+    'Update',
+    'Delete',
+    'Tx',
+];
+const WRITE_SET = new Set(exports.WRITE_CATALOG_NAMES);
+/**
+ * The dynamic per-field write-port families (`<group>.<field>` — the flattened record
+ * convention; longest-prefix wins). A `values.<field>` (Insert) or `set.<field>`
+ * (Update) port carries the field's Expression IR value.
+ */
+exports.WRITE_PORT_FAMILIES = [
+    'values.',
+    'set.',
+];
+/**
+ * The emitter's catalog validation (loud; a violation is a BUILD error), mirrored from
+ * graphddb's `assertComponentsInCatalog`. Every `componentRef` / `map` body node of every
+ * emitted component must:
+ *
+ * 1. reference a declared catalog name;
+ * 2. wire every `required` port of that entry;
+ * 3. wire ONLY declared ports — a port is declared if it is a static `inputPorts` name or
+ *    a write record-family port ({@link WRITE_PORT_FAMILIES}, write entries only).
+ *
+ * All violations are collected and thrown as one error. `cond` nodes carry no component
+ * reference and are skipped.
+ */
+function assertComponentsInCatalog(components) {
+    const errs = [];
+    for (const c of components) {
+        for (const n of c.body) {
+            if ('cond' in n)
+                continue;
+            const ref = 'map' in n ? n.map : n;
+            const entryDef = exports.LITEDBMODEL_CATALOG[ref.component];
+            if (entryDef === undefined) {
+                errs.push(`${c.name}/${n.id}: references '${ref.component}', not a LITEDBMODEL_CATALOG entry (known: ${exports.CATALOG_NAMES.join(', ')})`);
+                continue;
+            }
+            const ports = ref.ports;
+            for (const [p, s] of Object.entries(entryDef.inputPorts)) {
+                if (s.required === true && !(p in ports)) {
+                    errs.push(`${c.name}/${n.id} (${ref.component}): required port '${p}' is not wired`);
+                }
+            }
+            const isWriteItem = WRITE_SET.has(ref.component);
+            for (const p of Object.keys(ports)) {
+                if (p in entryDef.inputPorts)
+                    continue;
+                if (isWriteItem && exports.WRITE_PORT_FAMILIES.some((f) => p.startsWith(f)))
+                    continue;
+                errs.push(`${c.name}/${n.id} (${ref.component}): port '${p}' is not declared by the catalog entry (nor a write record-family port)`);
+            }
+        }
+    }
+    if (errs.length > 0) {
+        throw new Error(`litedbmodel catalog validation failed (${errs.length} violation${errs.length === 1 ? '' : 's'}):\n - ${errs.join('\n - ')}`);
+    }
+}
+/**
+ * Derive one component's Query/Command classification FROM THE GRAPH: behavior-contracts'
+ * `classifyBehaviorEffect` over {@link WRITE_CATALOG_NAMES} — a component is a `'command'`
+ * iff its body references a write-catalog primitive, else a `'query'` (spec §2.4: effect
+ * is derived, never authored).
+ */
+function deriveContractEffect(component) {
+    return (0, behavior_contracts_1.classifyBehaviorEffect)(component, exports.WRITE_CATALOG_NAMES) === 'writing' ? 'command' : 'query';
+}
+//# sourceMappingURL=catalog.js.map

package/dist/scp/catalog.js.map

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

package/dist/scp/codegen.d.ts

@@ -0,0 +1,95 @@
+/**
+ * litedbmodel v2 SCP — mode-3 codegen (WS7f, #35; spec §9 exec-mode 3 / §10 / §11; makeSQL flip,
+ * epic #43/#45 Phase B).
+ *
+ * The static-codegen execution mode ("Codegen・静的（全言語）— IR → 各言語ソース生成 runtime≈0,
+ * 入力は可搬IRのみ, bc#13 共有 generator に SQL catalog を供給" — spec §9). It takes a §8 STATIC
+ * makeSQL {@link SqlBundle} and, per target language, emits:
+ *
+ *  1. **Behavior module** — bc's SHARED generator (`generateModule`, bc#13) run over the bundle's
+ *     portable IR (a read bundle's surrogate `ComponentGraphIR`, or the `makeSQL` component IR for
+ *     a write), baked as a language-native LITERAL with a `bind(handlers)` accessor delegating to
+ *     `runBehavior`. litedbmodel writes NO execution logic here — codegen is upstream-owned (bc).
+ *  2. **SQL catalog companion** — the pure-JSON STATIC makeSQL catalog (per-node statement
+ *     templates / relations / transaction). A codegen consumer's thin SQL layer reads it to
+ *     evaluate skip + value-specs → assemble → render → execute (identically to the mode-2 runtime).
+ *
+ * ## Byte-identical to the thin-runtime (mode-2), by construction
+ *
+ * The companion IS the bundle, so a codegen runtime that evaluates it drives the IDENTICAL
+ * static-makeSQL render/execute path {@link executeBundle} uses — SQL text (all dialects) and
+ * results are identical, not approximately equal. The TS leg PROVES this by executing via the
+ * artifact and asserting exact equality vs {@link executeBundle} (see {@link codegenExecuteBundleForTest}).
+ */
+import { type ComponentGraphIR, type GeneratedModule, type Scope, type Value } from 'behavior-contracts';
+import type { SqlBundle, SqliteDb } from './runtime';
+import type { DialectName } from './dialect';
+import type { RelationOp } from './relation';
+import type { ReadGraph } from './makesql/static-bundle';
+import type { TransactionPlan } from './makesql/tx';
+/**
+ * The languages litedbmodel mode-3 codegen supports — exactly the set bc's shared generator
+ * registers (bc#13 SP1 typescript/python + SP2 go/rust/php). {@link assertLanguageSupported}
+ * verifies against the LIVE registry so a bc capability drift is caught loudly.
+ */
+export declare const CODEGEN_LANGUAGES: readonly ["typescript", "python", "go", "rust", "php"];
+export type CodegenLanguage = (typeof CODEGEN_LANGUAGES)[number];
+/**
+ * The SQL catalog companion (spec §9): the STATIC makeSQL bundle fields the codegen consumer's
+ * thin SQL layer reads to evaluate + render + execute. Pure JSON — round-trips losslessly.
+ */
+export interface SqlCatalogCompanion {
+    /** Target SQL dialect (`sqlite`/`postgres`/`mysql`) — compiled once, TS-side (spec §10). */
+    readonly dialect: DialectName;
+    /** 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?: {
+        readonly sql: string;
+        readonly params: readonly unknown[];
+        readonly skip?: unknown;
+    };
+    /** Input heads normalized to present-as-null (absent-key SKIP) — mirrors the bundle. */
+    readonly optionalHeads: readonly string[];
+    /** Pre-compiled STATIC read-relation batch ops (spec §5/§8), keyed by relation name. */
+    readonly relations: Record<string, RelationOp>;
+    /** Derived gate-first write-time-relations transaction plan (spec §6/§8), for a Command bundle. */
+    readonly transaction?: TransactionPlan;
+}
+/** The full codegen artifact for one bundle × one language. */
+export interface CodegenArtifact {
+    /** The target language. */
+    readonly language: CodegenLanguage;
+    /** The generated behavior module (bc's shared generator output — IR baked as a native literal). */
+    readonly module: GeneratedModule;
+    /** The SQL catalog companion sidecar (the STATIC makeSQL execution catalog). */
+    readonly companion: SqlCatalogCompanion;
+    /** The portable IR baked into {@link module}. */
+    readonly ir: ComponentGraphIR;
+    /** The originating bundle (so the equivalence leg re-executes the SAME static bundle). */
+    readonly bundle: SqlBundle;
+}
+/**
+ * The portable {@link ComponentGraphIR} view of a §8 bundle: a read bundle's surrogate IR (each
+ * SQL node → a `makeSQL` node), or the single `makeSQL` component IR for a write. Baking THIS is
+ * what makes the generated module a genuine bc artifact; the static SQL catalog rides the companion.
+ */
+export declare function bundleToPortableIR(bundle: SqlBundle): ComponentGraphIR;
+/**
+ * Assert the requested language is one bc's shared generator can emit — checked against the LIVE
+ * registry, not just the {@link CODEGEN_LANGUAGES} constant, so a bc capability drift fails LOUDLY.
+ */
+export declare function assertLanguageSupported(language: string, registered: readonly string[]): asserts language is CodegenLanguage;
+/**
+ * Generate the mode-3 codegen artifact for ONE §8 bundle in ONE target language: bc's SHARED
+ * generator bakes the IR literal + emits `bind(handlers)`, and we attach the STATIC SQL catalog
+ * companion. litedbmodel supplies the input (IR + catalog); bc owns the emitter.
+ */
+export declare function generateCodegenArtifact(bundle: SqlBundle, language: string, registeredLanguages: readonly string[], runtimeImport?: string): CodegenArtifact;
+/**
+ * The TS codegen EXECUTION path used to PROVE byte-identity: a codegen runtime reads the SQL
+ * catalog companion (the STATIC makeSQL bundle) and evaluates skip + value-specs → assemble →
+ * render → execute — which is EXACTLY {@link executeBundle} over the SAME bundle.
+ */
+export declare function codegenExecuteBundleForTest(artifact: CodegenArtifact, input: Scope, db: SqliteDb): Value;
+//# sourceMappingURL=codegen.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../../src/scp/codegen.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAkB,KAAK,gBAAgB,EAAE,KAAK,eAAe,EAAE,KAAK,KAAK,EAAE,KAAK,KAAK,EAAE,MAAM,oBAAoB,CAAC;AACzH,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAGrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,wDAAyD,CAAC;AACxF,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjE;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,4FAA4F;IAC5F,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,0FAA0F;IAC1F,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,CAAC;IAC/B,uEAAuE;IACvE,QAAQ,CAAC,SAAS,CAAC,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC;QAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAC5G,wFAAwF;IACxF,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,wFAAwF;IACxF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAC/C,mGAAmG;IACnG,QAAQ,CAAC,WAAW,CAAC,EAAE,eAAe,CAAC;CACxC;AAED,+DAA+D;AAC/D,MAAM,WAAW,eAAe;IAC9B,2BAA2B;IAC3B,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;IACnC,mGAAmG;IACnG,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,gFAAgF;IAChF,QAAQ,CAAC,SAAS,EAAE,mBAAmB,CAAC;IACxC,iDAAiD;IACjD,QAAQ,CAAC,EAAE,EAAE,gBAAgB,CAAC;IAC9B,0FAA0F;IAC1F,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;CAC5B;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,GAAG,gBAAgB,CAGtE;AAcD;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,IAAI,eAAe,CAa5H;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,EACjB,QAAQ,EAAE,MAAM,EAChB,mBAAmB,EAAE,SAAS,MAAM,EAAE,EACtC,aAAa,CAAC,EAAE,MAAM,GACrB,eAAe,CAKjB;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,eAAe,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,QAAQ,GAAG,KAAK,CAExG"}

package/dist/scp/codegen.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — mode-3 codegen (WS7f, #35; spec §9 exec-mode 3 / §10 / §11; makeSQL flip,
+ * epic #43/#45 Phase B).
+ *
+ * The static-codegen execution mode ("Codegen・静的（全言語）— IR → 各言語ソース生成 runtime≈0,
+ * 入力は可搬IRのみ, bc#13 共有 generator に SQL catalog を供給" — spec §9). It takes a §8 STATIC
+ * makeSQL {@link SqlBundle} and, per target language, emits:
+ *
+ *  1. **Behavior module** — bc's SHARED generator (`generateModule`, bc#13) run over the bundle's
+ *     portable IR (a read bundle's surrogate `ComponentGraphIR`, or the `makeSQL` component IR for
+ *     a write), baked as a language-native LITERAL with a `bind(handlers)` accessor delegating to
+ *     `runBehavior`. litedbmodel writes NO execution logic here — codegen is upstream-owned (bc).
+ *  2. **SQL catalog companion** — the pure-JSON STATIC makeSQL catalog (per-node statement
+ *     templates / relations / transaction). A codegen consumer's thin SQL layer reads it to
+ *     evaluate skip + value-specs → assemble → render → execute (identically to the mode-2 runtime).
+ *
+ * ## Byte-identical to the thin-runtime (mode-2), by construction
+ *
+ * The companion IS the bundle, so a codegen runtime that evaluates it drives the IDENTICAL
+ * static-makeSQL render/execute path {@link executeBundle} uses — SQL text (all dialects) and
+ * results are identical, not approximately equal. The TS leg PROVES this by executing via the
+ * artifact and asserting exact equality vs {@link executeBundle} (see {@link codegenExecuteBundleForTest}).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CODEGEN_LANGUAGES = void 0;
+exports.bundleToPortableIR = bundleToPortableIR;
+exports.assertLanguageSupported = assertLanguageSupported;
+exports.generateCodegenArtifact = generateCodegenArtifact;
+exports.codegenExecuteBundleForTest = codegenExecuteBundleForTest;
+const behavior_contracts_1 = require("behavior-contracts");
+const runtime_1 = require("./runtime");
+const ir_1 = require("./makesql/ir");
+/**
+ * The languages litedbmodel mode-3 codegen supports — exactly the set bc's shared generator
+ * registers (bc#13 SP1 typescript/python + SP2 go/rust/php). {@link assertLanguageSupported}
+ * verifies against the LIVE registry so a bc capability drift is caught loudly.
+ */
+exports.CODEGEN_LANGUAGES = ['typescript', 'python', 'go', 'rust', 'php'];
+/**
+ * The portable {@link ComponentGraphIR} view of a §8 bundle: a read bundle's surrogate IR (each
+ * SQL node → a `makeSQL` node), or the single `makeSQL` component IR for a write. Baking THIS is
+ * what makes the generated module a genuine bc artifact; the static SQL catalog rides the companion.
+ */
+function bundleToPortableIR(bundle) {
+    if (bundle.readGraph !== undefined)
+        return bundle.readGraph.ir;
+    return (0, ir_1.makeSqlComponentIR)(bundle.name);
+}
+/** The STATIC makeSQL execution catalog carried alongside the (baked) portable IR. */
+function companionOf(bundle) {
+    const base = {
+        dialect: bundle.dialect,
+        optionalHeads: bundle.optionalHeads,
+        relations: bundle.relations,
+        ...(bundle.readGraph !== undefined ? { readGraph: bundle.readGraph } : {}),
+        ...(bundle.statement !== undefined ? { statement: bundle.statement } : {}),
+    };
+    return bundle.transaction === undefined ? base : { ...base, transaction: bundle.transaction };
+}
+/**
+ * Assert the requested language is one bc's shared generator can emit — checked against the LIVE
+ * registry, not just the {@link CODEGEN_LANGUAGES} constant, so a bc capability drift fails LOUDLY.
+ */
+function assertLanguageSupported(language, registered) {
+    if (!exports.CODEGEN_LANGUAGES.includes(language)) {
+        throw new Error(`litedbmodel codegen: language '${language}' is not a supported target (supported: ${exports.CODEGEN_LANGUAGES.join(', ')})`);
+    }
+    if (!registered.includes(language)) {
+        throw new Error(`litedbmodel codegen: bc's shared generator does not register an emitter for '${language}' ` +
+            `(bc registered: ${[...registered].sort().join(', ')}). This is a bc#13 capability limit — ESCALATE to bc (bc#22 pattern), ` +
+            `never fork a litedbmodel-local generator (codegen は上流所有, spec §9).`);
+    }
+}
+/**
+ * Generate the mode-3 codegen artifact for ONE §8 bundle in ONE target language: bc's SHARED
+ * generator bakes the IR literal + emits `bind(handlers)`, and we attach the STATIC SQL catalog
+ * companion. litedbmodel supplies the input (IR + catalog); bc owns the emitter.
+ */
+function generateCodegenArtifact(bundle, language, registeredLanguages, runtimeImport) {
+    assertLanguageSupported(language, registeredLanguages);
+    const ir = bundleToPortableIR(bundle);
+    const module = (0, behavior_contracts_1.generateModule)(ir, runtimeImport === undefined ? { language } : { language, runtimeImport });
+    return { language, module, companion: companionOf(bundle), ir, bundle };
+}
+/**
+ * The TS codegen EXECUTION path used to PROVE byte-identity: a codegen runtime reads the SQL
+ * catalog companion (the STATIC makeSQL bundle) and evaluates skip + value-specs → assemble →
+ * render → execute — which is EXACTLY {@link executeBundle} over the SAME bundle.
+ */
+function codegenExecuteBundleForTest(artifact, input, db) {
+    return (0, runtime_1.executeBundle)(artifact.bundle, input, { db });
+}
+//# sourceMappingURL=codegen.js.map

package/dist/scp/codegen.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen.js","sourceRoot":"","sources":["../../src/scp/codegen.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;;;AAyDH,gDAGC;AAkBD,0DAaC;AAOD,0DAUC;AAOD,kEAEC;AAnHD,2DAAyH;AAEzH,uCAA0C;AAC1C,qCAAkD;AAMlD;;;;GAIG;AACU,QAAA,iBAAiB,GAAG,CAAC,YAAY,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,CAAU,CAAC;AAoCxF;;;;GAIG;AACH,SAAgB,kBAAkB,CAAC,MAAiB;IAClD,IAAI,MAAM,CAAC,SAAS,KAAK,SAAS;QAAE,OAAO,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC;IAC/D,OAAO,IAAA,uBAAkB,EAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AACzC,CAAC;AAED,sFAAsF;AACtF,SAAS,WAAW,CAAC,MAAiB;IACpC,MAAM,IAAI,GAAwB;QAChC,OAAO,EAAE,MAAM,CAAC,OAAO;QACvB,aAAa,EAAE,MAAM,CAAC,aAAa;QACnC,SAAS,EAAE,MAAM,CAAC,SAAS;QAC3B,GAAG,CAAC,MAAM,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC1E,GAAG,CAAC,MAAM,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC3E,CAAC;IACF,OAAO,MAAM,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,WAAW,EAAE,MAAM,CAAC,WAAW,EAAE,CAAC;AAChG,CAAC;AAED;;;GAGG;AACH,SAAgB,uBAAuB,CAAC,QAAgB,EAAE,UAA6B;IACrF,IAAI,CAAE,yBAAuC,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;QACjE,MAAM,IAAI,KAAK,CACb,kCAAkC,QAAQ,2CAA2C,yBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CACrH,CAAC;IACJ,CAAC;IACD,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;QACnC,MAAM,IAAI,KAAK,CACb,gFAAgF,QAAQ,IAAI;YAC1F,mBAAmB,CAAC,GAAG,UAAU,CAAC,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,wEAAwE;YAC5H,oEAAoE,CACvE,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,SAAgB,uBAAuB,CACrC,MAAiB,EACjB,QAAgB,EAChB,mBAAsC,EACtC,aAAsB;IAEtB,uBAAuB,CAAC,QAAQ,EAAE,mBAAmB,CAAC,CAAC;IACvD,MAAM,EAAE,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC;IACtC,MAAM,MAAM,GAAG,IAAA,mCAAc,EAAC,EAAE,EAAE,aAAa,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,aAAa,EAAE,CAAC,CAAC;IAC5G,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,CAAC;AAC1E,CAAC;AAED;;;;GAIG;AACH,SAAgB,2BAA2B,CAAC,QAAyB,EAAE,KAAY,EAAE,EAAY;IAC/F,OAAO,IAAA,uBAAa,EAAC,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;AACvD,CAAC"}

package/dist/scp/dialect.d.ts

@@ -0,0 +1,141 @@
+/**
+ * litedbmodel v2 SCP — dialect strategy table (WS6, #26; spec §4/§5/§8/§10).
+ *
+ * The SINGLE SOURCE OF TRUTH for every SQL-dialect difference the Backend Compile + render
+ * pipeline needs. The dialect axis is compiled ONCE, TS-side (spec §10: "方言軸はコンパイル時
+ * に TS 側で1回検証"). This module encodes the differences as a closed strategy record — NO
+ * scattered `?:` in the engine code (the hard rule). A backend compile / renderer asks the
+ * {@link Dialect} for the dialect-specific text and never branches on the dialect name inline.
+ *
+ * ## What actually differs (verified against the v1 SqlBuilders — the golden bar)
+ *
+ * For the CRUD + write-tx + relation SQL the SCP Backend Compile emits (single-row VALUES,
+ * `?` placeholders, `col = ?` WHERE, `col IN (?, …)`), the dialect surface is small and
+ * closed:
+ *
+ *   - **INSERT conflict clause**: SQLite `INSERT OR IGNORE … ` / `… ON CONFLICT (cols) DO
+ *     UPDATE SET c = excluded.c`; Postgres `… ON CONFLICT (cols) DO NOTHING` / `… DO UPDATE
+ *     SET c = EXCLUDED.c`; MySQL `INSERT IGNORE …` / `… ON DUPLICATE KEY UPDATE c = VALUES(c)`.
+ *     These are byte-identical to `SqliteSqlBuilder` / `PostgresSqlBuilder` / `MysqlSqlBuilder`
+ *     `buildInsert` for the single-record case (see the WS6 dialect-golden test).
+ *   - **Bare `ON CONFLICT DO NOTHING`** (no column list — the gate-first idempotency/unique
+ *     guard INSERTs of the write-tx plan, spec §6): SQLite/Postgres emit `ON CONFLICT DO
+ *     NOTHING`; MySQL emits `INSERT IGNORE`.
+ *   - **Placeholder style**: all dialects author with `?`; Postgres converts `?`→`$1,$2,…` in a
+ *     final left-to-right one-pass AFTER the SQL text is fully assembled (spec §8 — the
+ *     number-reassignment problem is designed out because the pass runs once over the final
+ *     flat text). SQLite/MySQL keep `?`.
+ *
+ * Everything else (SELECT/UPDATE/DELETE skeletons, `col = ?`, `col IN (?, …)` expansion, the
+ * fragment tree, RETURNING for SQLite/Postgres) is identical text across dialects, so it is
+ * NOT part of the strategy — only the genuine divergences live here.
+ *
+ * ## DB behavior differences beyond SQL text (spec §13) — closeable-by-convention line
+ *
+ * SQL-text identity does not guarantee identical DB behavior (NULL ordering, collation,
+ * timezone). Per spec §13, those are closed "by dialect-compile-time convention" only within
+ * the closeable line. WS6 encodes the ONE convention that is mechanically closeable in the
+ * compiled SQL text: deterministic NULL ordering for an `ORDER BY … NULLS` requirement
+ * ({@link Dialect.orderByNulls}). Collation / timezone / float semantics are OUT OF SCOPE
+ * (documented, not silently defaulted).
+ */
+/** The SQL dialects the Backend Compile targets (spec §4 breadth: PG/MySQL/SQLite). */
+export type DialectName = 'sqlite' | 'postgres' | 'mysql';
+/** An INSERT conflict action (dialect-neutral intent; the dialect renders the clause). */
+export type ConflictAction = 'ignore' | {
+    readonly updateColumns: readonly string[];
+};
+/**
+ * A dialect strategy: the closed set of dialect-specific renderings the Backend Compile +
+ * render pipeline consumes. One frozen record per dialect (the SSoT). Every method is a pure
+ * text producer — no side effects, no hidden fallback.
+ */
+export interface Dialect {
+    readonly name: DialectName;
+    /**
+     * Render an INSERT's optional conflict clause, appended after `… VALUES (…)`.
+     *
+     * @param conflictColumns the conflict-target columns (`ON CONFLICT (a, b)`), or an empty
+     *   array for a bare conflict target (the write-tx guard INSERTs — spec §6).
+     * @param action `'ignore'` (do-nothing) or an upsert with the update-column list.
+     * @param insertColumns the INSERT's column list (needed for the `VALUES(col)` / `EXCLUDED.col`
+     *   SET-clause rendering when `updateColumns` is `'all'` at the call site — the caller passes
+     *   the resolved list, so this only needs the resolved update columns).
+     */
+    insertConflictClause(conflictColumns: readonly string[], action: ConflictAction): string;
+    /**
+     * For MySQL, an `ignore` conflict is expressed on the INSERT VERB (`INSERT IGNORE INTO`),
+     * not as a trailing clause; SQLite uses `INSERT OR IGNORE INTO`; Postgres uses a plain
+     * `INSERT INTO` + a trailing `ON CONFLICT … DO NOTHING`. This returns the INSERT verb+prefix
+     * up to and including `INTO` for the `ignore` case, and the plain `INSERT INTO` otherwise.
+     */
+    insertVerb(action: ConflictAction | undefined): string;
+    /**
+     * Whether this dialect's conflict `ignore` is a trailing clause (Postgres) rather than an
+     * INSERT-verb modifier (SQLite `OR IGNORE`, MySQL `IGNORE`). Drives whether
+     * {@link insertConflictClause} emits text for the `ignore` case.
+     */
+    readonly ignoreIsTrailingClause: boolean;
+    /**
+     * Render a bare do-nothing GUARD INSERT — the gate-first idempotency/unique guard of the
+     * write-tx plan (spec §6): `INSERT INTO <t> (<cols>) VALUES (<ph>)` + a do-nothing conflict
+     * on ANY unique constraint (no column target). SQLite/Postgres emit a trailing
+     * `… ON CONFLICT DO NOTHING`; MySQL emits `INSERT IGNORE INTO … VALUES (…)`.
+     *
+     * This is DISTINCT from the CRUD `ignore` path ({@link insertVerb} + {@link insertConflictClause}),
+     * which mirrors the v1 SqlBuilders (SQLite uses the `INSERT OR IGNORE` verb there). The guard
+     * form is SCP-internal and its SQLite golden is the trailing `ON CONFLICT DO NOTHING` (WS5),
+     * so the two contexts render differently ON SQLITE and are kept as separate strategy methods
+     * rather than one branch.
+     *
+     * @param table the guard table.
+     * @param columns the guard row's columns (in order).
+     * @param placeholders the pre-joined placeholder list (`"?, ?, ?"`).
+     */
+    guardInsert(table: string, columns: readonly string[], placeholders: string): string;
+    /**
+     * Convert the fully-assembled, param-flattened SQL text's `?` placeholders to this dialect's
+     * final placeholder style. SQLite/MySQL: identity (keep `?`). Postgres: a single left-to-right
+     * pass replacing the Nth `?` with `$N` (spec §8 final one-pass). This runs ONCE over the final
+     * text, so there is no number-reassignment problem.
+     */
+    finalizePlaceholders(sql: string): string;
+    /**
+     * Deterministic NULL ordering for an `ORDER BY <expr> <dir>` term when the model requires it
+     * (spec §13 "`ORDER BY … NULLS` 強制"). Postgres supports `NULLS FIRST/LAST` natively; SQLite
+     * (3.30+) also supports it; MySQL does NOT, so the convention is emulated with a leading
+     * `<expr> IS NULL` sort key. Returns the full ORDER BY term text.
+     */
+    orderByNulls(expr: string, dir: 'ASC' | 'DESC', nulls: 'FIRST' | 'LAST'): string;
+}
+/**
+ * Replace each `?` placeholder in a fully-assembled SQL string with `$1, $2, …` left-to-right
+ * (Postgres). This is the spec §8 "最終1パス" conversion: it runs ONCE over the final flat SQL
+ * text, so placeholder numbering is a plain running counter — the number-reassignment problem
+ * cannot reappear (there is no per-fragment renumbering). Every `?` is a bound param position
+ * (the render pipeline never emits a literal `?` inside a string literal — values are always
+ * parameterized), so a naive scan is correct for the compiled surface.
+ */
+export declare function toDollarPlaceholders(sql: string): string;
+/**
+ * SQLite. `ignore` is an INSERT-verb modifier (`INSERT OR IGNORE INTO`); upsert uses
+ * `ON CONFLICT (cols) DO UPDATE SET c = excluded.c`. Placeholders stay `?`. NULL ordering uses
+ * the native `NULLS FIRST/LAST` (SQLite 3.30+).
+ */
+export declare const SQLITE: Dialect;
+/**
+ * Postgres. `ignore` is a TRAILING clause (`… ON CONFLICT (cols) DO NOTHING`); upsert uses
+ * `ON CONFLICT (cols) DO UPDATE SET c = EXCLUDED.c`. Placeholders are converted `?`→`$N` in the
+ * final one-pass. NULL ordering uses native `NULLS FIRST/LAST`.
+ */
+export declare const POSTGRES: Dialect;
+/**
+ * MySQL. `ignore` is an INSERT-verb modifier (`INSERT IGNORE INTO`); upsert uses
+ * `… ON DUPLICATE KEY UPDATE c = VALUES(c)` (no conflict-column target — MySQL keys off any
+ * unique index). Placeholders stay `?`. NULL ordering is emulated with a leading
+ * `<expr> IS NULL` sort key (MySQL has no `NULLS FIRST/LAST`).
+ */
+export declare const MYSQL: Dialect;
+/** Look up a dialect strategy by name (throws on an unknown dialect — no silent default). */
+export declare function dialectFor(name: DialectName): Dialect;
+//# sourceMappingURL=dialect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dialect.d.ts","sourceRoot":"","sources":["../../src/scp/dialect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,uFAAuF;AACvF,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,UAAU,GAAG,OAAO,CAAC;AAE1D,0FAA0F;AAC1F,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG;IAAE,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC;AAEtF;;;;GAIG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAE3B;;;;;;;;;OASG;IACH,oBAAoB,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,EAAE,MAAM,EAAE,cAAc,GAAG,MAAM,CAAC;IAEzF;;;;;OAKG;IACH,UAAU,CAAC,MAAM,EAAE,cAAc,GAAG,SAAS,GAAG,MAAM,CAAC;IAEvD;;;;OAIG;IACH,QAAQ,CAAC,sBAAsB,EAAE,OAAO,CAAC;IAEzC;;;;;;;;;;;;;;;OAeG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,MAAM,EAAE,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAAC;IAErF;;;;;OAKG;IACH,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;IAE1C;;;;;OAKG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,GAAG,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;CAClF;AAID;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAYxD;AAwCD;;;;GAIG;AACH,eAAO,MAAM,MAAM,EAAE,OAoBnB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,QAAQ,EAAE,OAkBrB,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,KAAK,EAAE,OA0BlB,CAAC;AASH,6FAA6F;AAC7F,wBAAgB,UAAU,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAMrD"}