litedbmodel 2.0.1 → 2.1.0

package/dist/scp/codegen.d.ts

@@ -1,39 +1,98 @@
 /**
  * litedbmodel v2 SCP — mode-3 codegen (WS7f, #35; spec §9 exec-mode 3 / §10 / §11; makeSQL flip,
- * epic #43/#45 Phase B).
+ * epic #43/#45 Phase B; #60 milestone 1 — typed-NATIVE READ codegen, bc#77/#90).
  *
  * 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).
+ *  1. **Behavior module** — bc's SHARED generator run over the bundle's portable IR through bc's
+ *     de-interpreted, RUNTIME-FREE emitter. For a READ bundle covered by bc's typed-NATIVE
+ *     endpoint (`rust-typed-native` / `go-typed-native`, bc#77/#90 — the 1.0 read de-box: fully
+ *     concrete `HandlerNR<Comp>`/`InNR<Comp>`/`PortsNR<Comp><node>`/`RawRowNR<Comp><node>` structs,
+ *     ZERO boxed `Value`/`RawValue`, ZERO IR baked into the module), the CODEGEN-ONLY lowering
+ *     below ({@link lowerReadGraphForTypedNative}) makes the read's shape structurally ELIGIBLE
+ *     (derives each real Select-node's referenced heads from its statements → individual scalar ref
+ *     ports + types the component's `inputPorts` from the schema) before handing it to bc. For a WRITE bundle, or a
+ *     READ shape typed-native does not (yet) cover, codegen uses bc's existing de-interpreted
+ *     STRAIGHT-LINE endpoint (`<lang>-straightline`, bc#75) — see {@link typedEmitterFor}.
  *  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
+ * ## #60 milestone 1 scope (CODEGEN-PATH ONLY)
  *
- * 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}).
+ * This lowering exists SOLELY for the codegen emitter call — it builds a NEW, separate
+ * `ComponentGraphIR` from the bundle's `readGraph`; it never mutates `SqlBundle`/`ReadGraph` and
+ * never touches the shared `readGraph`/`executeReadGraph` the native exec surface (and the
+ * frozen conformance corpus) depend on. Those keep consuming the REAL Select-node
+ * `readGraph.ir`, completely unaffected by anything in this file.
+ *
+ * ## Behavior-identical to the thin-runtime (mode-2), by construction
+ *
+ * The generated module is observationally equivalent to `runBehavior` (same values, same emitted
+ * op sequence, same Failure code/message), and the companion IS the bundle, so a codegen runtime
+ * that drives it follows 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}).
+ *
+ * ## No literal-bake / no boxed fallback
+ *
+ * typed-native fails CLOSED on an uncovered shape (a `map`/`cond` relation kind it does not cover,
+ * or an input head that cannot lower to a native port). Such a shape is NOT silently regenerated on
+ * the boxed `-typed`/`-typed-raw` emitter — it THROWS, naming the exact gap, so it can be tracked as
+ * a bc coverage gap rather than masked.
+ *
+ * IN-list / array-bound WHERE heads (the `whereIn` `{__jsonArray:{ref:[head]},dialect}` param) are
+ * now COVERED via bc#110 (native array/list port for a componentRef input port): the lowering
+ * resolves the IN-list column's element scalar and emits a native ARRAY input port
+ * (`{type:'array', elemType}` → `Vec<ElemT>`/`[]ElemT`), so `complexWhere`/`inList` reach the
+ * zero-boxing native hot path (no serde_json/encoding-json, no boxed `Value`). They no longer
+ * fail closed as a bc#86/coverage gap.
  */
-import { type ComponentGraphIR, type GeneratedModule, type Scope, type Value } from 'behavior-contracts';
+import { type GeneratedModule, type Scope, type Value } from 'behavior-contracts';
+import type { ComponentGraphIR } from './authoring';
 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';
+import { type ColumnTypeResolver } from './coltype';
 /**
  * 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}
+ * registers (bc#13 SP1 typescript/python + SP2 go/rust/php). {@link codegenEmitterFor}
  * 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 bc READ emitter litedbmodel drives for each codegen target (#60 milestone 1): the
+ * **de-interpreted, RUNTIME-FREE typed-NATIVE** endpoint (bc#77/#90) for go/rust — ZERO boxed
+ * `Value`/`RawValue`, ZERO IR baked into the module, concrete `HandlerNR`/`InNR`/`PortsNR`/
+ * `RawRowNR` structs. There is **NO literal / straight-line / boxed-typed fallback** for a read: an
+ * unspec'd fallback is INVALID (it silently swallows the "this shape can't be natively codegen'd"
+ * signal) — a read shape typed-native does not cover MUST fail loudly at generation, naming the gap
+ * (report it as a bc#86 coverage gap), never silently regenerate on `-typed`/`-typed-raw`.
+ *
+ * `-typed-raw` (bc#76, the boxed-wire intermediate) and `-typed` (the boxed-Value intermediate) are
+ * RETIRED from litedbmodel's codegen surface entirely (#60 milestone 1) — typed-native supersedes
+ * both for every read shape it covers (bc#77/#90: single-componentRef reads AND the `map`
+ * relationKind:single|connection shape, bc#86 part 2).
+ *
+ * - ts: **no typed-native endpoint registered yet** (bc has not shipped `typescript-typed-native`).
+ *   TS stays on its existing `typescript-typed` (boxed) endpoint until bc adds one — a DECLARED,
+ *   reported gap (not silently mirrored to go/rust's retirement), tracked as a bc#77 TS follow-up.
+ * - **python/php: NOT present.** bc registers no de-boxed typed endpoint for them (capability limit).
+ *   litedbmodel does NOT substitute the literal (≈ir) emitter — that would be an unspec'd fallback.
+ *   Codegen for py/php is a bc capability gap that ERRORS (ESCALATE to bc), never a silent literal.
+ *
+ * WRITES (batchInsert / gate-first tx) are NOT reads — they are NOT routed through this table at
+ * all (#60 milestone 1): a write bundle stays on the existing write/tx execution path
+ * (`executeTransactionBundle` / the native adapter's hand-written tx mirror), never a codegen
+ * module, boxed or typed-raw. {@link generateCodegenArtifact} throws if asked to codegen a write.
+ */
+export declare const CODEGEN_EMITTER: Partial<Record<CodegenLanguage, string>>;
 /**
  * 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.
@@ -55,39 +114,86 @@ export interface SqlCatalogCompanion {
     readonly relations: Record<string, RelationOp>;
     /** Derived gate-first write-time-relations transaction plan (spec §6/§8), for a Command bundle. */
     readonly transaction?: TransactionPlan;
+    /**
+     * WRITE bundles: the codegen typed-de-box `outputType` (the TransactionResult typed shape). Rides
+     * the companion so a codegen consumer that reassembles the bundle from the artifact round-trips it
+     * losslessly (the read de-box carries its outType/outputType inside `readGraph.ir` instead).
+     */
+    readonly outputType?: unknown;
 }
 /** 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). */
+    /** The generated behavior module (bc's SHARED STRAIGHT-LINE generator output — real static code). */
     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.
+ * The portable {@link ComponentGraphIR} view of a §8 READ bundle: `compileBehaviors`' real-node
+ * read-graph IR (the de-surrogated `Select`/`Count`/map nodes; #12) — the SAME IR the native exec
+ * surface (`executeReadGraph`) walks (via `bundle.readGraph.ir` directly). litedbmodel constructs NO
+ * `ComponentGraphIR` literal here; it returns the compiler's own output. {@link generateCodegenArtifact}
+ * does NOT use this for a typed-native READ target (that uses the codegen-only lowered form,
+ * {@link lowerReadGraphForTypedNative}); this is the portable IR for a boxed READ endpoint / fingerprint.
+ *
+ * WRITE bundles have NO portable component-graph IR (they carry a single compiled `statement`, not a
+ * component graph — and are NOT codegen-module cases: {@link generateCodegenArtifact} rejects them).
+ * There is therefore no hand-built `makeSQL` write surrogate anymore (#12) — a write bundle throws.
  */
 export declare function bundleToPortableIR(bundle: SqlBundle): ComponentGraphIR;
+/** A head could not be typed for typed-native codegen — the read is NOT typed-native-coverable. */
+export declare class TypedNativeCoverageError extends Error {
+    readonly component: string;
+    readonly reasons: readonly string[];
+    constructor(component: string, reasons: readonly string[]);
+}
 /**
- * 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.
+ * Lower a read bundle's REAL Select-node `ComponentGraphIR` into a NEW, CODEGEN-ONLY IR eligible
+ * for bc's typed-native endpoint (#60 milestone 1): derive each node's referenced heads from its
+ * `statementsById` fragments and emit individual native-scalar `{ref:[head]}` ports, typing the
+ * component's `inputPorts` from the schema (via {@link deriveHeadTypesFromStatements}). Throws
+ * {@link TypedNativeCoverageError} if any referenced head cannot be natively typed (e.g. an IN-list's
+ * array head) — NO silent `unknown` port, NO fallback. Does NOT mutate `bundle`/`bundle.readGraph`
+ * (a fresh IR object is returned); the native `executeReadGraph` keeps consuming the real `readGraph.ir`.
+ *
+ * Scope: bc's typed-native predicate itself still governs `map`/`cond`/relationKind/policy
+ * coverage (this lowering does not special-case those — `generateModule` fails closed on them with
+ * its own detailed diagnostic, which this function does not need to duplicate).
  */
-export declare function assertLanguageSupported(language: string, registered: readonly string[]): asserts language is CodegenLanguage;
+export declare function lowerReadGraphForTypedNative(readGraph: ReadGraph, resolveColumnType: ColumnTypeResolver): ComponentGraphIR;
 /**
- * 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.
+ * Resolve the READ codegen emitter for a target language, or throw. No fallback: a language
+ * without a registered endpoint is a bc capability gap that fails LOUDLY (never a silent
+ * substitution of the literal/interpreter/boxed emitter — an unspec'd fallback is invalid).
+ */
+export declare function typedEmitterFor(language: string, registered: readonly string[]): string;
+/**
+ * Shape-INDEPENDENT emitter resolution — identical to {@link typedEmitterFor} now that there is
+ * exactly one READ endpoint per language (kept as a distinct export for callers that historically
+ * used the shape-independent form; both resolve the SAME table).
+ */
+export declare function codegenEmitterFor(language: string, registered: readonly string[]): string;
+/**
+ * Generate the mode-3 READ codegen artifact for ONE §8 READ bundle in ONE target language. Lowers
+ * the bundle's real Select-node read graph into the native-scalar-port IR
+ * ({@link lowerReadGraphForTypedNative}) FIRST — for go/rust's typed-NATIVE endpoint (bc#77/#90,
+ * RUNTIME-FREE) AND for TS's boxed `typescript-typed` endpoint alike. Both consume the SAME
+ * genuine-bound-head shape: the lowering derives each node's ports from its compiled
+ * `statementsById` fragments, so a WHERE COLUMN-NAME MARKER head (`whereGe($.created_at, $.since)`
+ * — `$.created_at` names the column, is never bound) is EXCLUDED from the emitted ports/input
+ * struct, exactly as go/rust already handled it (#12 regression: TS previously fed the raw IR and
+ * emitted a stray `created_at` binding → `unknown binding: created_at` at execution).
+ *
+ * WRITE bundles are OUT OF SCOPE (#60 milestone 1: writes stay on the existing write/tx execution
+ * path, never a codegen module) — throws if `bundle.readGraph` is absent.
  */
-export declare function generateCodegenArtifact(bundle: SqlBundle, language: string, registeredLanguages: readonly string[], runtimeImport?: string): CodegenArtifact;
+export declare function generateCodegenArtifact(bundle: SqlBundle, language: string, registeredLanguages: readonly string[], resolveColumnType: ColumnTypeResolver, runtimeImport?: string): CodegenArtifact;
 /**
- * The TS codegen EXECUTION path used to PROVE byte-identity: a codegen runtime reads the SQL
+ * The TS codegen EXECUTION path used to PROVE behavior-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.
  */

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

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