litedbmodel 1.2.9 → 2.0.0

package/dist/scp/codegen.d.ts

@@ -0,0 +1,131 @@
+/**
+ * litedbmodel v2 SCP — mode-3 codegen (WS7f, #35; spec §9 exec-mode 3 / §10 / §11).
+ *
+ * The static-codegen execution mode ("Codegen・静的（全言語）— IR → 各言語ソース生成
+ * runtime≈0, 入力は可搬IRのみ, bc#13 共有 generator に SQL catalog を供給" — spec §9). It
+ * takes a §8 {@link SqlBundle} (already Backend-Compiled TS-side, WS1↔WS3) and, per target
+ * language, emits:
+ *
+ *  1. **Behavior module** — bc's SHARED generator (`generateModule`, bc#13) run over the
+ *     bundle's SURROGATE component wrapped as a portable {@link ComponentGraphIR}. The generator
+ *     bakes that IR as a language-native LITERAL (no runtime JSON parse) and emits a `bind(handlers)`
+ *     accessor that delegates to the EXISTING runtime-core `runBehavior`. litedbmodel writes NO
+ *     execution logic here — codegen is upstream-owned (bc), we only SUPPLY the input.
+ *  2. **SQL catalog companion** — a pure-JSON sidecar carrying the litedbmodel-specific bundle
+ *     fields that are OUTSIDE bc's portable-IR vocabulary (`operations` / `dialect` /
+ *     `optionalHeads` / `relations` / `transaction`). This is the "SQL catalog supplied to the
+ *     shared generator" (§9): a codegen consumer's thin SQL-handler layer reads it to render →
+ *     execute, exactly as the mode-2 thin-runtime handler does. It is byte-identical to the bundle
+ *     minus the (now baked-as-literal) `component`/`irVersion`/`exprVersion`.
+ *
+ * ## Why this is byte-identical to the thin-runtime (mode-2), by construction
+ *
+ * The mode-2 thin-runtime ({@link executeBundle}) computes
+ * `runBehavior({components:[bundle.component]}, buildHandlers(db, operations, dialect),
+ * normalizeInput(...), name)`. The generated module bakes `IR === bundle.component` (proven by
+ * the FNV-1a fingerprint the generator embeds and re-checks at load) and its `bind(handlers)`
+ * calls the SAME `runBehavior(IR, handlers, input, name)`. So when a codegen runtime pairs the
+ * generated `bind` with the SAME {@link buildHandlers} + {@link normalizeInput} (from the SQL
+ * catalog companion), it drives the identical core over the identical IR and handlers — the SQL
+ * text (all dialects) and the results are identical, NOT approximately equal. The TS leg PROVES
+ * this by executing the generated module and asserting exact equality vs `executeBundle` AND vs
+ * the frozen conformance vector (see `codegenExecuteBundleForTest`).
+ *
+ * ## Language support (bc#13 capability — the honest scope boundary)
+ *
+ * bc's shared generator registers emitters for FIVE languages
+ * ({@link CODEGEN_LANGUAGES}); Go IS among them (bc#13 SP2 `emit-go.ts`). So litedbmodel mode-3
+ * codegen covers all five — TS/Python/Go/Rust/PHP. If a future litedbmodel construct needed an
+ * emitter bc does not provide, the honest move is to ESCALATE to bc (bc#22 pattern), never to
+ * fork a parallel litedbmodel-local generator (that would defeat the "codegen は上流所有" design).
+ */
+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 { CompiledOperation } from './ir';
+import type { RelationOp } from './relation';
+import type { TransactionPlan } from './write-plan';
+/**
+ * The languages litedbmodel mode-3 codegen supports — exactly the set bc's shared generator
+ * registers (bc#13 SP1 typescript/python + SP2 go/rust/php). This is a FIXED capability the
+ * generator advertises via `registeredLanguages()`; {@link assertLanguageSupported} verifies the
+ * requested language against the LIVE registry so a bc capability change is caught loudly rather
+ * than silently drifting from this constant.
+ */
+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 "SQL catalog supplied to the shared generator"): the
+ * litedbmodel-specific §8 bundle fields that live OUTSIDE bc's portable-IR vocabulary and so are
+ * NOT baked into the generated behavior module. A codegen consumer's thin SQL-handler layer reads
+ * this sidecar to render → bind → execute (identically to the mode-2 handler). Pure JSON —
+ * round-trips losslessly (proven by the codegen conformance leg).
+ */
+export interface SqlCatalogCompanion {
+    /** Backend-Compiled SQL IR per catalog node id (§8) — `sql` + fragment tree + closed-set params. */
+    readonly operations: Record<string, CompiledOperation>;
+    /** Target SQL dialect (`sqlite`/`postgres`/`mysql`) — compiled once, TS-side (spec §10). */
+    readonly dialect: DialectName;
+    /** Input heads normalized to present-as-null (absent-key SKIP) — mirrors the bundle. */
+    readonly optionalHeads: readonly string[];
+    /** Pre-compiled 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 litedbmodel-specific execution catalog). */
+    readonly companion: SqlCatalogCompanion;
+    /**
+     * The portable IR that WAS baked into {@link module} (the surrogate component + envelope). Kept
+     * on the artifact so the in-process TS equivalence check drives the IDENTICAL IR the emitted
+     * source embeds — the generator's fingerprint (checked at the emitted module's load) proves the
+     * baked literal equals this object.
+     */
+    readonly ir: ComponentGraphIR;
+}
+/**
+ * The portable {@link ComponentGraphIR} view of a §8 bundle: the surrogate component (wiring /
+ * plan / output / `__scope` ports only — every SQL-structural port already collapsed to portable
+ * Expression IR TS-side) wrapped with the bundle's IR envelope. This is EXACTLY the IR
+ * {@link executeBundle} feeds `runBehavior`, so baking it is what makes codegen equivalent.
+ */
+export declare function bundleToPortableIR(bundle: SqlBundle): ComponentGraphIR;
+/**
+ * Assert the requested language is one bc's shared generator can actually emit — checked against
+ * the LIVE generator registry, not just the {@link CODEGEN_LANGUAGES} constant, so a bc capability
+ * drift (an emitter removed/renamed upstream) fails LOUDLY here instead of surfacing as a broken
+ * generated module. `generateModule` itself also fail-closes on an unknown language; this is the
+ * earlier, litedbmodel-scoped guard with the honest "bc supports X" message.
+ */
+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 surrogate IR literal + emits `bind(handlers)`, and we attach the SQL catalog
+ * companion. litedbmodel supplies the input (IR + catalog); bc owns the emitter.
+ *
+ * @param registeredLanguages the live `registeredLanguages()` from bc (injected so the guard sees
+ *   the actual generator capability; the caller passes `bc.registeredLanguages()`).
+ * @param runtimeImport optional runtime-core import specifier override (test/vendored layouts);
+ *   forwarded verbatim to the generator so the generated code stays deterministic.
+ */
+export declare function generateCodegenArtifact(bundle: SqlBundle, language: string, registeredLanguages: readonly string[], runtimeImport?: string): CodegenArtifact;
+/**
+ * The TS codegen EXECUTION path used to PROVE byte-identity: reconstruct the exact call the
+ * generated TS module's `bind(handlers)` makes — `runBehavior(IR, handlers, normalizedInput,
+ * name)` — where `IR` is the baked portable IR and `handlers` are the SAME SQL handlers the SQL
+ * catalog companion drives ({@link buildHandlers}). Executing this and comparing to
+ * {@link executeBundle} is a REAL byte-identity check on the codegen path (the generated TS module
+ * is separately IMPORTED and run in the conformance leg to prove the emitted source itself agrees).
+ *
+ * This mirrors {@link executeBundle} field-for-field, but drives the components/handlers via the
+ * codegen ARTIFACT (baked IR + companion) rather than the raw bundle — so a divergence between the
+ * codegen artifact and the bundle would surface as a mismatch.
+ */
+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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;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,EAAc,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,MAAM,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,wDAAyD,CAAC;AACxF,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjE;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAClC,oGAAoG;IACpG,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IACvD,4FAA4F;IAC5F,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,wFAAwF;IACxF,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,iFAAiF;IACjF,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,sFAAsF;IACtF,QAAQ,CAAC,SAAS,EAAE,mBAAmB,CAAC;IACxC;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,EAAE,gBAAgB,CAAC;CAC/B;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,GAAG,gBAAgB,CAMtE;AAaD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,IAAI,eAAe,CAa5H;AAED;;;;;;;;;GASG;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;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,eAAe,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,QAAQ,GAAG,KAAK,CAOxG"}

package/dist/scp/codegen.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — mode-3 codegen (WS7f, #35; spec §9 exec-mode 3 / §10 / §11).
+ *
+ * The static-codegen execution mode ("Codegen・静的（全言語）— IR → 各言語ソース生成
+ * runtime≈0, 入力は可搬IRのみ, bc#13 共有 generator に SQL catalog を供給" — spec §9). It
+ * takes a §8 {@link SqlBundle} (already Backend-Compiled TS-side, WS1↔WS3) and, per target
+ * language, emits:
+ *
+ *  1. **Behavior module** — bc's SHARED generator (`generateModule`, bc#13) run over the
+ *     bundle's SURROGATE component wrapped as a portable {@link ComponentGraphIR}. The generator
+ *     bakes that IR as a language-native LITERAL (no runtime JSON parse) and emits a `bind(handlers)`
+ *     accessor that delegates to the EXISTING runtime-core `runBehavior`. litedbmodel writes NO
+ *     execution logic here — codegen is upstream-owned (bc), we only SUPPLY the input.
+ *  2. **SQL catalog companion** — a pure-JSON sidecar carrying the litedbmodel-specific bundle
+ *     fields that are OUTSIDE bc's portable-IR vocabulary (`operations` / `dialect` /
+ *     `optionalHeads` / `relations` / `transaction`). This is the "SQL catalog supplied to the
+ *     shared generator" (§9): a codegen consumer's thin SQL-handler layer reads it to render →
+ *     execute, exactly as the mode-2 thin-runtime handler does. It is byte-identical to the bundle
+ *     minus the (now baked-as-literal) `component`/`irVersion`/`exprVersion`.
+ *
+ * ## Why this is byte-identical to the thin-runtime (mode-2), by construction
+ *
+ * The mode-2 thin-runtime ({@link executeBundle}) computes
+ * `runBehavior({components:[bundle.component]}, buildHandlers(db, operations, dialect),
+ * normalizeInput(...), name)`. The generated module bakes `IR === bundle.component` (proven by
+ * the FNV-1a fingerprint the generator embeds and re-checks at load) and its `bind(handlers)`
+ * calls the SAME `runBehavior(IR, handlers, input, name)`. So when a codegen runtime pairs the
+ * generated `bind` with the SAME {@link buildHandlers} + {@link normalizeInput} (from the SQL
+ * catalog companion), it drives the identical core over the identical IR and handlers — the SQL
+ * text (all dialects) and the results are identical, NOT approximately equal. The TS leg PROVES
+ * this by executing the generated module and asserting exact equality vs `executeBundle` AND vs
+ * the frozen conformance vector (see `codegenExecuteBundleForTest`).
+ *
+ * ## Language support (bc#13 capability — the honest scope boundary)
+ *
+ * bc's shared generator registers emitters for FIVE languages
+ * ({@link CODEGEN_LANGUAGES}); Go IS among them (bc#13 SP2 `emit-go.ts`). So litedbmodel mode-3
+ * codegen covers all five — TS/Python/Go/Rust/PHP. If a future litedbmodel construct needed an
+ * emitter bc does not provide, the honest move is to ESCALATE to bc (bc#22 pattern), never to
+ * fork a parallel litedbmodel-local generator (that would defeat the "codegen は上流所有" design).
+ */
+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 behavior_contracts_2 = require("behavior-contracts");
+const dialect_1 = require("./dialect");
+/**
+ * The languages litedbmodel mode-3 codegen supports — exactly the set bc's shared generator
+ * registers (bc#13 SP1 typescript/python + SP2 go/rust/php). This is a FIXED capability the
+ * generator advertises via `registeredLanguages()`; {@link assertLanguageSupported} verifies the
+ * requested language against the LIVE registry so a bc capability change is caught loudly rather
+ * than silently drifting from this constant.
+ */
+exports.CODEGEN_LANGUAGES = ['typescript', 'python', 'go', 'rust', 'php'];
+/**
+ * The portable {@link ComponentGraphIR} view of a §8 bundle: the surrogate component (wiring /
+ * plan / output / `__scope` ports only — every SQL-structural port already collapsed to portable
+ * Expression IR TS-side) wrapped with the bundle's IR envelope. This is EXACTLY the IR
+ * {@link executeBundle} feeds `runBehavior`, so baking it is what makes codegen equivalent.
+ */
+function bundleToPortableIR(bundle) {
+    return {
+        irVersion: bundle.irVersion,
+        exprVersion: bundle.exprVersion,
+        components: [bundle.component],
+    };
+}
+/** The litedbmodel-specific execution catalog carried alongside the (baked) portable IR. */
+function companionOf(bundle) {
+    const base = {
+        operations: bundle.operations,
+        dialect: bundle.dialect,
+        optionalHeads: bundle.optionalHeads,
+        relations: bundle.relations,
+    };
+    return bundle.transaction === undefined ? base : { ...base, transaction: bundle.transaction };
+}
+/**
+ * Assert the requested language is one bc's shared generator can actually emit — checked against
+ * the LIVE generator registry, not just the {@link CODEGEN_LANGUAGES} constant, so a bc capability
+ * drift (an emitter removed/renamed upstream) fails LOUDLY here instead of surfacing as a broken
+ * generated module. `generateModule` itself also fail-closes on an unknown language; this is the
+ * earlier, litedbmodel-scoped guard with the honest "bc supports X" message.
+ */
+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 surrogate IR literal + emits `bind(handlers)`, and we attach the SQL catalog
+ * companion. litedbmodel supplies the input (IR + catalog); bc owns the emitter.
+ *
+ * @param registeredLanguages the live `registeredLanguages()` from bc (injected so the guard sees
+ *   the actual generator capability; the caller passes `bc.registeredLanguages()`).
+ * @param runtimeImport optional runtime-core import specifier override (test/vendored layouts);
+ *   forwarded verbatim to the generator so the generated code stays deterministic.
+ */
+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 };
+}
+/**
+ * The TS codegen EXECUTION path used to PROVE byte-identity: reconstruct the exact call the
+ * generated TS module's `bind(handlers)` makes — `runBehavior(IR, handlers, normalizedInput,
+ * name)` — where `IR` is the baked portable IR and `handlers` are the SAME SQL handlers the SQL
+ * catalog companion drives ({@link buildHandlers}). Executing this and comparing to
+ * {@link executeBundle} is a REAL byte-identity check on the codegen path (the generated TS module
+ * is separately IMPORTED and run in the conformance leg to prove the emitted source itself agrees).
+ *
+ * This mirrors {@link executeBundle} field-for-field, but drives the components/handlers via the
+ * codegen ARTIFACT (baked IR + companion) rather than the raw bundle — so a divergence between the
+ * codegen artifact and the bundle would surface as a mismatch.
+ */
+function codegenExecuteBundleForTest(artifact, input, db) {
+    const { ir } = artifact;
+    const component = ir.components[0];
+    const { operations, dialect, optionalHeads } = artifact.companion;
+    const handlers = (0, runtime_1.buildHandlers)(db, operations, (0, dialect_1.dialectFor)(dialect));
+    const normalized = (0, runtime_1.normalizeInput)(component, new Set(optionalHeads), input);
+    return (0, behavior_contracts_2.runBehavior)(ir, handlers, normalized, component.name);
+}
+//# 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":"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"}

package/dist/scp/compile-dialect.d.ts

@@ -0,0 +1,39 @@
+/**
+ * litedbmodel v2 SCP — dialect-parameterized Backend Compile (WS6, #26; spec §4/§5/§8/§10).
+ *
+ * The SAME Component-graph IR compiles to SQLite, Postgres and MySQL SQL. The IR→structure
+ * lowering (SELECT/INSERT/UPDATE/DELETE skeletons, the WHERE fragment tree, `col = ?`, IN-list
+ * `(?)` expansion, param slots) is SHARED across dialects; only the genuine dialect divergences
+ * (INSERT conflict clause + INSERT verb) are delegated to the {@link Dialect} strategy (the SSoT
+ * — no scattered `?:`). Placeholders stay `?` through compilation; the PG `?`→`$N` conversion is
+ * a final render-time one-pass ({@link import('./dialect').Dialect.finalizePlaceholders}), NOT a
+ * compile-time concern — so the compiled `CompiledOperation.sql` is dialect-tagged but still
+ * `?`-placeheld, keeping the bundle uniform.
+ *
+ * `compile-sqlite.ts` delegates its INSERT compile here with the SQLite dialect, so the pinned
+ * SQLite golden (WS1) is preserved byte-for-byte and the PG/MySQL variants diverge ONLY where the
+ * v1 SqlBuilders diverge (proven byte-identical in the WS6 dialect-golden test).
+ */
+import type { CompiledOperation, ExprNode } from './ir';
+import type { Dialect } from './dialect';
+/** Column → value Expression IR (insertion order = SQL column order). */
+export interface InsertShape {
+    readonly table: string;
+    readonly values: Record<string, ExprNode>;
+    readonly returning?: readonly string[];
+    readonly onConflict?: readonly string[];
+    readonly onConflictAction?: 'ignore' | {
+        readonly updateColumns: 'all' | readonly string[];
+    };
+}
+/**
+ * Compile an INSERT for a given dialect. Byte-identical to the corresponding v1 SqlBuilder's
+ * single-record `buildInsert` output (the golden bar):
+ *   - SQLite: `INSERT [OR IGNORE] INTO t (c) VALUES (?)[ ON CONFLICT (k) DO UPDATE SET c = excluded.c][ RETURNING r]`
+ *   - Postgres: `INSERT INTO t (c) VALUES (?)[ ON CONFLICT (k) DO NOTHING | DO UPDATE SET c = EXCLUDED.c][ RETURNING r]`
+ *   - MySQL: `INSERT [IGNORE] INTO t (c) VALUES (?)[ ON DUPLICATE KEY UPDATE c = VALUES(c)]`
+ *
+ * Placeholders remain `?`; PG's `?`→`$N` is applied at render time.
+ */
+export declare function compileInsertFor(dialect: Dialect, desc: InsertShape): CompiledOperation;
+//# sourceMappingURL=compile-dialect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compile-dialect.d.ts","sourceRoot":"","sources":["../../src/scp/compile-dialect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,QAAQ,EAAE,MAAM,MAAM,CAAC;AACxD,OAAO,KAAK,EAAE,OAAO,EAAkB,MAAM,WAAW,CAAC;AAKzD,yEAAyE;AACzE,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC1C,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,QAAQ,GAAG;QAAE,QAAQ,CAAC,aAAa,EAAE,KAAK,GAAG,SAAS,MAAM,EAAE,CAAA;KAAE,CAAC;CAC9F;AAKD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,iBAAiB,CAiBvF"}

package/dist/scp/compile-dialect.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — dialect-parameterized Backend Compile (WS6, #26; spec §4/§5/§8/§10).
+ *
+ * The SAME Component-graph IR compiles to SQLite, Postgres and MySQL SQL. The IR→structure
+ * lowering (SELECT/INSERT/UPDATE/DELETE skeletons, the WHERE fragment tree, `col = ?`, IN-list
+ * `(?)` expansion, param slots) is SHARED across dialects; only the genuine dialect divergences
+ * (INSERT conflict clause + INSERT verb) are delegated to the {@link Dialect} strategy (the SSoT
+ * — no scattered `?:`). Placeholders stay `?` through compilation; the PG `?`→`$N` conversion is
+ * a final render-time one-pass ({@link import('./dialect').Dialect.finalizePlaceholders}), NOT a
+ * compile-time concern — so the compiled `CompiledOperation.sql` is dialect-tagged but still
+ * `?`-placeheld, keeping the bundle uniform.
+ *
+ * `compile-sqlite.ts` delegates its INSERT compile here with the SQLite dialect, so the pinned
+ * SQLite golden (WS1) is preserved byte-for-byte and the PG/MySQL variants diverge ONLY where the
+ * v1 SqlBuilders diverge (proven byte-identical in the WS6 dialect-golden test).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileInsertFor = compileInsertFor;
+/** Row → logical model assembly (shape only). */
+const assembly = (shape) => ({ shape });
+/**
+ * Compile an INSERT for a given dialect. Byte-identical to the corresponding v1 SqlBuilder's
+ * single-record `buildInsert` output (the golden bar):
+ *   - SQLite: `INSERT [OR IGNORE] INTO t (c) VALUES (?)[ ON CONFLICT (k) DO UPDATE SET c = excluded.c][ RETURNING r]`
+ *   - Postgres: `INSERT INTO t (c) VALUES (?)[ ON CONFLICT (k) DO NOTHING | DO UPDATE SET c = EXCLUDED.c][ RETURNING r]`
+ *   - MySQL: `INSERT [IGNORE] INTO t (c) VALUES (?)[ ON DUPLICATE KEY UPDATE c = VALUES(c)]`
+ *
+ * Placeholders remain `?`; PG's `?`→`$N` is applied at render time.
+ */
+function compileInsertFor(dialect, desc) {
+    const columns = Object.keys(desc.values);
+    if (columns.length === 0)
+        throw new Error('INSERT requires at least one value column');
+    const placeholders = columns.map(() => '?').join(', ');
+    const params = columns.map((c) => desc.values[c]);
+    const conflictAction = resolveConflictAction(desc, columns);
+    const verb = dialect.insertVerb(conflictAction);
+    let sql = `${verb} ${desc.table} (${columns.join(', ')}) VALUES (${placeholders})`;
+    if (conflictAction !== undefined) {
+        sql += dialect.insertConflictClause(desc.onConflict ?? [], conflictAction);
+    }
+    if (desc.returning !== undefined)
+        sql += ` RETURNING ${desc.returning.join(', ')}`;
+    return { component: 'Insert', sql, where: null, params, assembly: assembly('items') };
+}
+/**
+ * Resolve the dialect-neutral {@link ConflictAction} from the INSERT description. An `'all'`
+ * update-column list is expanded to the concrete inserted columns EXCEPT the conflict keys
+ * (matching the v1 SqlBuilders' `onConflictUpdate === 'all' ? columns : …`, which include all
+ * columns; the v1 builders use the full `columns` list for `'all'`, so we mirror that exactly).
+ * Returns undefined when the INSERT declares no conflict handling.
+ */
+function resolveConflictAction(desc, columns) {
+    if (desc.onConflict === undefined || desc.onConflictAction === undefined)
+        return undefined;
+    if (desc.onConflictAction === 'ignore')
+        return 'ignore';
+    const cols = desc.onConflictAction.updateColumns === 'all' ? columns : desc.onConflictAction.updateColumns;
+    return { updateColumns: cols };
+}
+//# sourceMappingURL=compile-dialect.js.map

package/dist/scp/compile-dialect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile-dialect.js","sourceRoot":"","sources":["../../src/scp/compile-dialect.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;AA6BH,4CAiBC;AA7BD,iDAAiD;AACjD,MAAM,QAAQ,GAAG,CAAC,KAAa,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;AAEhD;;;;;;;;GAQG;AACH,SAAgB,gBAAgB,CAAC,OAAgB,EAAE,IAAiB;IAClE,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACzC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;IACvF,MAAM,YAAY,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACvD,MAAM,MAAM,GAAe,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAE9D,MAAM,cAAc,GAAG,qBAAqB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAC5D,MAAM,IAAI,GAAG,OAAO,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;IAChD,IAAI,GAAG,GAAG,GAAG,IAAI,IAAI,IAAI,CAAC,KAAK,KAAK,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,YAAY,GAAG,CAAC;IAEnF,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;QACjC,GAAG,IAAI,OAAO,CAAC,oBAAoB,CAAC,IAAI,CAAC,UAAU,IAAI,EAAE,EAAE,cAAc,CAAC,CAAC;IAC7E,CAAC;IAED,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS;QAAE,GAAG,IAAI,cAAc,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;IAEnF,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;AACxF,CAAC;AAED;;;;;;GAMG;AACH,SAAS,qBAAqB,CAAC,IAAiB,EAAE,OAA0B;IAC1E,IAAI,IAAI,CAAC,UAAU,KAAK,SAAS,IAAI,IAAI,CAAC,gBAAgB,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC3F,IAAI,IAAI,CAAC,gBAAgB,KAAK,QAAQ;QAAE,OAAO,QAAQ,CAAC;IACxD,MAAM,IAAI,GAAG,IAAI,CAAC,gBAAgB,CAAC,aAAa,KAAK,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC;IAC3G,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC;AACjC,CAAC"}

package/dist/scp/compile-sqlite.d.ts

@@ -0,0 +1,114 @@
+/**
+ * litedbmodel v2 SCP — SQLite Backend Compile (WS1, #21).
+ *
+ * Lowers a structured CRUD operation description (a Component-graph Select/Insert/Update/
+ * Delete node with ports) into a {@link CompiledOperation}: SQLite dialect SQL text,
+ * a fragment tree (dynamic WHERE/SET with existence rules), and static param slots — the
+ * IR shape of spec §8. Placeholders are unified as `?` (the `?`→`$N` pass is PG-only and
+ * OUT OF SCOPE for WS1).
+ *
+ * The generated SQLite SQL is byte-identical to what litedbmodel v1's SqliteSqlBuilder /
+ * `DBModel._buildSelectSQL` produce for equivalent queries (the golden bar). In
+ * particular:
+ *   - SELECT: `SELECT <cols> FROM <t>[ WHERE <c>][ GROUP BY <g>][ ORDER BY <o>][ LIMIT ?][ OFFSET ?]`
+ *   - INSERT: `INSERT INTO <t> (<cols>) VALUES (<vals>)[ RETURNING <r>]`
+ *   - UPDATE: `UPDATE <t> SET <a = ?, …> WHERE <c>[ RETURNING <r>]`
+ *   - DELETE: `DELETE FROM <t> WHERE <c>[ RETURNING <r>]`
+ *   - WHERE parts joined by ` AND ` (or ` OR ` for an OR group), equality `col = ?`,
+ *     IN-list `col IN (?, …)`, empty array → `1 = 0`, NULL → `col IS NULL`.
+ *
+ * ## Hard rule: closed Expression IR only
+ *
+ * Every param slot this compiler emits is an Expression IR node from bc's closed set
+ * (`PORTABLE_EXPR_OPERATORS`). NO litedbmodel-local opcode is ever invented. An
+ * un-lowerable predicate is the Raw SQL escape hatch's concern (spec §13), not a fake
+ * opcode. {@link compileSelect} et al. only construct `ref` / `coalesce` / etc.
+ */
+import type { CompiledOperation, ExprNode } from './ir';
+/** A reference into the input scope or a sibling wire result (Expression IR `ref`). */
+export type Ref = {
+    ref: string[];
+};
+/** A single WHERE condition. `skipWhen` (absent → always present) drives SKIP (§8). */
+export type Condition = {
+    kind: 'eq';
+    column: string;
+    value: ExprNode;
+    skipWhen?: ExprNode;
+} | {
+    kind: 'cmp';
+    column: string;
+    op: '<' | '<=' | '>' | '>=' | '<>';
+    value: ExprNode;
+    skipWhen?: ExprNode;
+} | {
+    kind: 'isNull';
+    column: string;
+    skipWhen?: ExprNode;
+} | {
+    kind: 'in';
+    column: string;
+    value: ExprNode;
+    skipWhen?: ExprNode;
+}
+/** A nested AND/OR group (parenthesized, dynamic-expansion spec §4). */
+ | {
+    kind: 'group';
+    connector: 'AND' | 'OR';
+    conditions: Condition[];
+    skipWhen?: ExprNode;
+};
+export interface SelectDesc {
+    table: string;
+    /** Projection columns; `['*']` renders `*`. */
+    select: string[];
+    where?: Condition[];
+    /** Raw ORDER BY body (dialect-neutral text, e.g. `"created_at DESC"`). */
+    order?: string;
+    /** GROUP BY body. */
+    group?: string;
+    /** LIMIT value as an Expression IR node (e.g. a `coalesce` default). */
+    limit?: ExprNode;
+    /** OFFSET value as an Expression IR node. */
+    offset?: ExprNode;
+}
+export interface InsertDesc {
+    table: string;
+    /** Column → value Expression IR (insertion order = SQL column order). */
+    values: Record<string, ExprNode>;
+    returning?: string[];
+    onConflict?: string[];
+    onConflictAction?: 'ignore' | {
+        updateColumns: 'all' | string[];
+    };
+}
+export interface UpdateDesc {
+    table: string;
+    /** Column → value Expression IR (insertion order = SET clause order). */
+    set: Record<string, ExprNode>;
+    where: Condition[];
+    returning?: string[];
+}
+export interface DeleteDesc {
+    table: string;
+    where: Condition[];
+    returning?: string[];
+}
+/**
+ * Compile a SELECT. Static params (LIMIT / OFFSET) sit AFTER the `{where}` splice, so
+ * they are emitted after the fragment params (dynamic-expansion spec §6).
+ */
+export declare function compileSelect(desc: SelectDesc): CompiledOperation;
+/**
+ * Compile an INSERT (SQLite). All params are static (no WHERE); order = column order. The
+ * dialect-specific conflict/verb rendering is delegated to the SQLite {@link SQLITE} strategy
+ * ({@link compileInsertFor}) — the SAME dialect-parameterized compile the PG/MySQL Backend
+ * Compile uses (WS6), so SQLite is byte-for-byte unchanged and the other dialects diverge only
+ * where the v1 SqlBuilders diverge.
+ */
+export declare function compileInsert(desc: InsertDesc): CompiledOperation;
+/** Compile an UPDATE. SET params (static) precede the `{where}` splice (spec §6). */
+export declare function compileUpdate(desc: UpdateDesc): CompiledOperation;
+/** Compile a DELETE. No static params before the WHERE (all params are conditions). */
+export declare function compileDelete(desc: DeleteDesc): CompiledOperation;
+//# sourceMappingURL=compile-sqlite.d.ts.map

package/dist/scp/compile-sqlite.d.ts.map

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