litedbmodel 2.0.0 → 2.0.1

package/dist/scp/codegen.js

@@ -1,44 +1,26 @@
 "use strict";
 /**
- * litedbmodel v2 SCP — mode-3 codegen (WS7f, #35; spec §9 exec-mode 3 / §10 / §11).
+ * 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 {@link SqlBundle} (already Backend-Compiled TS-side, WS1↔WS3) and, per target
- * language, emits:
+ * 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 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`.
+ *  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).
  *
- * ## Why this is byte-identical to the thin-runtime (mode-2), by construction
+ * ## 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).
+ * 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;
@@ -48,45 +30,37 @@ 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");
+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). 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.
+ * 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: 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.
+ * 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) {
-    return {
-        irVersion: bundle.irVersion,
-        exprVersion: bundle.exprVersion,
-        components: [bundle.component],
-    };
+    if (bundle.readGraph !== undefined)
+        return bundle.readGraph.ir;
+    return (0, ir_1.makeSqlComponentIR)(bundle.name);
 }
-/** The litedbmodel-specific execution catalog carried alongside the (baked) portable IR. */
+/** The STATIC makeSQL 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,
+        ...(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 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.
+ * 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)) {
@@ -100,38 +74,21 @@ function assertLanguageSupported(language, registered) {
 }
 /**
  * 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
+ * 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.
- *
- * @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 };
+    return { language, module, companion: companionOf(bundle), ir, bundle };
 }
 /**
- * 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.
+ * 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) {
-    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);
+    return (0, runtime_1.executeBundle)(artifact.bundle, input, { db });
 }
 //# sourceMappingURL=codegen.js.map

package/dist/scp/codegen.js.map

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

@@ -0,0 +1,68 @@
+/**
+ * litedbmodel v2 SCP — FIND_FILTER fail-closed authoring guard (#47 Finding B / plan R8).
+ *
+ * `FIND_FILTER` is a v1 PER-MODEL implicit predicate (a soft-delete / tenant scope) that
+ * v1 MERGES into the WHERE of every internal `find()`/`count()` before compiling
+ * (`DBModel._buildSelectSQL` / `_count`: `normalizedCond.add(condsToRecord(FIND_FILTER))`).
+ * It is not a distinct SQL construct — it manifests purely as extra WHERE fragments.
+ *
+ * The SCP compile path (`L.Select({ where })` → `compileReadGraph` → `renderReadPrimary`)
+ * is AUTHORED from an explicit `where`; it has NO `DBModel` class context, so it CANNOT
+ * auto-apply a model's `FIND_FILTER` (there is no model reference at compile time, and no
+ * production seam routes a `DBModel` into the SCP compile — grep: `FIND_FILTER` appears only
+ * in `DBModel`/`decorators`/`types`, never under `src/scp/`). Auto-apply is therefore
+ * impossible without model context the SCP compile does not have.
+ *
+ * Resolution = the plan's variant chosen fail-closed: a model that DECLARES a `FIND_FILTER`
+ * MUST have its scope predicates folded into the authored `L.Select({ where })`; if the
+ * author routes such a model through SCP WITHOUT the scope keys, this guard throws loudly
+ * ({@link FindFilterLeakError}) rather than silently dropping the filter (which would leak
+ * soft-deleted / cross-tenant rows — a correctness bug, not a cosmetic one). When the scope
+ * keys ARE present the guard is a no-op (byte-identical to v1's merged WHERE — proven in
+ * `test/scp/find-filter-noop.test.ts`).
+ */
+import { type Conds } from '../Column';
+/** A `DBModel`-shaped source: the only field this guard reads is the optional `FIND_FILTER`. */
+export interface FindFilterSource {
+    /** The per-model implicit scope predicate (v1 `DBModel.FIND_FILTER`), or null/undefined. */
+    readonly FIND_FILTER?: Conds | null;
+    /** Class name for diagnostics (present on every `DBModel` subclass). */
+    readonly name?: string;
+}
+/**
+ * A model declaring a `FIND_FILTER` was compiled via the SCP path without its scope
+ * predicates present in the authored WHERE — the filter would silently leak. Thrown
+ * fail-closed at compile time; never swallowed.
+ */
+export declare class FindFilterLeakError extends Error {
+    /** The declaring model's class name (diagnostics). */
+    readonly modelName: string;
+    /** The FIND_FILTER scope keys that are MISSING from the authored WHERE. */
+    readonly missingKeys: readonly string[];
+    constructor(
+    /** The declaring model's class name (diagnostics). */
+    modelName: string, 
+    /** The FIND_FILTER scope keys that are MISSING from the authored WHERE. */
+    missingKeys: readonly string[]);
+}
+/**
+ * Extract the top-level predicate KEYS a `FIND_FILTER` folds into a WHERE. Uses the SAME
+ * `condsToRecord` v1 runs when merging (`DBModel._buildSelectSQL`:597) so the key set is
+ * exactly what v1 would add to `normalizedCond`. `__or__` (grouped OR) is kept as a key so a
+ * scoped OR-group also demands explicit authoring (fail-closed; never silently satisfied).
+ */
+export declare function findFilterKeys(filter: Conds | null | undefined): string[];
+/**
+ * Fail-closed guard: assert a model's `FIND_FILTER` scope keys are all present in the
+ * authored WHERE key set BEFORE an SCP compile of that model. No FIND_FILTER → no-op. When
+ * present, EVERY scope key must appear in `authoredWhereKeys`; any missing key throws
+ * {@link FindFilterLeakError}. The caller passes the top-level keys of the object it hands to
+ * `L.Select({ where })` (the same shape `condsToRecord` yields), so the check compares
+ * like-for-like against v1's merged predicate.
+ *
+ * @param model  a `DBModel`-shaped source that MAY declare `FIND_FILTER`.
+ * @param authoredWhereKeys  the top-level WHERE keys the SCP author expressed for this model.
+ * @throws FindFilterLeakError when a declared scope key is absent from the authored WHERE.
+ */
+export declare function assertFindFilterFolded(model: FindFilterSource, authoredWhereKeys: Iterable<string>): void;
+//# sourceMappingURL=find-filter-guard.d.ts.map

package/dist/scp/find-filter-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-filter-guard.d.ts","sourceRoot":"","sources":["../../src/scp/find-filter-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAiB,KAAK,KAAK,EAAE,MAAM,WAAW,CAAC;AAEtD,gGAAgG;AAChG,MAAM,WAAW,gBAAgB;IAC/B,4FAA4F;IAC5F,QAAQ,CAAC,WAAW,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;IACpC,wEAAwE;IACxE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;GAIG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;IAE1C,sDAAsD;IACtD,QAAQ,CAAC,SAAS,EAAE,MAAM;IAC1B,2EAA2E;IAC3E,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE;;IAHvC,sDAAsD;IAC7C,SAAS,EAAE,MAAM;IAC1B,2EAA2E;IAClE,WAAW,EAAE,SAAS,MAAM,EAAE;CAY1C;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,KAAK,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,EAAE,CAGzE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,gBAAgB,EACvB,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,GAClC,IAAI,CAQN"}

package/dist/scp/find-filter-guard.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — FIND_FILTER fail-closed authoring guard (#47 Finding B / plan R8).
+ *
+ * `FIND_FILTER` is a v1 PER-MODEL implicit predicate (a soft-delete / tenant scope) that
+ * v1 MERGES into the WHERE of every internal `find()`/`count()` before compiling
+ * (`DBModel._buildSelectSQL` / `_count`: `normalizedCond.add(condsToRecord(FIND_FILTER))`).
+ * It is not a distinct SQL construct — it manifests purely as extra WHERE fragments.
+ *
+ * The SCP compile path (`L.Select({ where })` → `compileReadGraph` → `renderReadPrimary`)
+ * is AUTHORED from an explicit `where`; it has NO `DBModel` class context, so it CANNOT
+ * auto-apply a model's `FIND_FILTER` (there is no model reference at compile time, and no
+ * production seam routes a `DBModel` into the SCP compile — grep: `FIND_FILTER` appears only
+ * in `DBModel`/`decorators`/`types`, never under `src/scp/`). Auto-apply is therefore
+ * impossible without model context the SCP compile does not have.
+ *
+ * Resolution = the plan's variant chosen fail-closed: a model that DECLARES a `FIND_FILTER`
+ * MUST have its scope predicates folded into the authored `L.Select({ where })`; if the
+ * author routes such a model through SCP WITHOUT the scope keys, this guard throws loudly
+ * ({@link FindFilterLeakError}) rather than silently dropping the filter (which would leak
+ * soft-deleted / cross-tenant rows — a correctness bug, not a cosmetic one). When the scope
+ * keys ARE present the guard is a no-op (byte-identical to v1's merged WHERE — proven in
+ * `test/scp/find-filter-noop.test.ts`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindFilterLeakError = void 0;
+exports.findFilterKeys = findFilterKeys;
+exports.assertFindFilterFolded = assertFindFilterFolded;
+const Column_1 = require("../Column");
+/**
+ * A model declaring a `FIND_FILTER` was compiled via the SCP path without its scope
+ * predicates present in the authored WHERE — the filter would silently leak. Thrown
+ * fail-closed at compile time; never swallowed.
+ */
+class FindFilterLeakError extends Error {
+    modelName;
+    missingKeys;
+    constructor(
+    /** The declaring model's class name (diagnostics). */
+    modelName, 
+    /** The FIND_FILTER scope keys that are MISSING from the authored WHERE. */
+    missingKeys) {
+        super(`FIND_FILTER leak: model '${modelName}' declares an implicit scope predicate on ` +
+            `[${missingKeys.join(', ')}] that is NOT present in the SCP-authored WHERE. The SCP ` +
+            `compile cannot auto-apply FIND_FILTER (no model context at compile time), so the ` +
+            `scope predicate would be silently dropped (soft-delete / tenant scope leak). Fold ` +
+            `the FIND_FILTER predicates into the authored L.Select({ where }) explicitly ` +
+            `(e.g. whereEq/whereIsNull on ${missingKeys.join(', ')}).`);
+        this.modelName = modelName;
+        this.missingKeys = missingKeys;
+        this.name = 'FindFilterLeakError';
+    }
+}
+exports.FindFilterLeakError = FindFilterLeakError;
+/**
+ * Extract the top-level predicate KEYS a `FIND_FILTER` folds into a WHERE. Uses the SAME
+ * `condsToRecord` v1 runs when merging (`DBModel._buildSelectSQL`:597) so the key set is
+ * exactly what v1 would add to `normalizedCond`. `__or__` (grouped OR) is kept as a key so a
+ * scoped OR-group also demands explicit authoring (fail-closed; never silently satisfied).
+ */
+function findFilterKeys(filter) {
+    if (!filter || filter.length === 0)
+        return [];
+    return Object.keys((0, Column_1.condsToRecord)(filter));
+}
+/**
+ * Fail-closed guard: assert a model's `FIND_FILTER` scope keys are all present in the
+ * authored WHERE key set BEFORE an SCP compile of that model. No FIND_FILTER → no-op. When
+ * present, EVERY scope key must appear in `authoredWhereKeys`; any missing key throws
+ * {@link FindFilterLeakError}. The caller passes the top-level keys of the object it hands to
+ * `L.Select({ where })` (the same shape `condsToRecord` yields), so the check compares
+ * like-for-like against v1's merged predicate.
+ *
+ * @param model  a `DBModel`-shaped source that MAY declare `FIND_FILTER`.
+ * @param authoredWhereKeys  the top-level WHERE keys the SCP author expressed for this model.
+ * @throws FindFilterLeakError when a declared scope key is absent from the authored WHERE.
+ */
+function assertFindFilterFolded(model, authoredWhereKeys) {
+    const required = findFilterKeys(model.FIND_FILTER);
+    if (required.length === 0)
+        return; // No implicit scope → nothing to fold → no-op.
+    const present = new Set(authoredWhereKeys);
+    const missing = required.filter((k) => !present.has(k));
+    if (missing.length > 0) {
+        throw new FindFilterLeakError(model.name ?? '<anonymous model>', missing);
+    }
+}
+//# sourceMappingURL=find-filter-guard.js.map

package/dist/scp/find-filter-guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-filter-guard.js","sourceRoot":"","sources":["../../src/scp/find-filter-guard.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;;;AA0CH,wCAGC;AAcD,wDAWC;AApED,sCAAsD;AAUtD;;;;GAIG;AACH,MAAa,mBAAoB,SAAQ,KAAK;IAGjC;IAEA;IAJX;IACE,sDAAsD;IAC7C,SAAiB;IAC1B,2EAA2E;IAClE,WAA8B;QAEvC,KAAK,CACH,4BAA4B,SAAS,4CAA4C;YAC/E,IAAI,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,2DAA2D;YACrF,mFAAmF;YACnF,oFAAoF;YACpF,8EAA8E;YAC9E,gCAAgC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAC7D,CAAC;QAXO,cAAS,GAAT,SAAS,CAAQ;QAEjB,gBAAW,GAAX,WAAW,CAAmB;QAUvC,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAC;IACpC,CAAC;CACF;AAjBD,kDAiBC;AAED;;;;;GAKG;AACH,SAAgB,cAAc,CAAC,MAAgC;IAC7D,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAC9C,OAAO,MAAM,CAAC,IAAI,CAAC,IAAA,sBAAa,EAAC,MAAM,CAAC,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,sBAAsB,CACpC,KAAuB,EACvB,iBAAmC;IAEnC,MAAM,QAAQ,GAAG,cAAc,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;IACnD,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,CAAC,+CAA+C;IAClF,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,iBAAiB,CAAC,CAAC;IAC3C,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IACxD,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvB,MAAM,IAAI,mBAAmB,CAAC,KAAK,CAAC,IAAI,IAAI,mBAAmB,EAAE,OAAO,CAAC,CAAC;IAC5E,CAAC;AACH,CAAC"}

package/dist/scp/fragment/assemble.d.ts

@@ -0,0 +1,61 @@
+/**
+ * litedbmodel v2 SCP — fragment RUNTIME (assemble + bind).
+ *
+ * This is the thin runtime a bundle drives. It does exactly three things:
+ *
+ *   1. ASSEMBLE — walk the ordered fragment list; drop any fragment whose `skip`
+ *      is satisfied; concatenate the present fragments' `sql`, and their `params`
+ *      in order. Nested-fragment params splice their own `sql` at the `?` and
+ *      contribute their own params in order.
+ *   2. EVALUATE — turn each value-spec param into a concrete bound value using the
+ *      runtime `input` (and upstream `wire` results).
+ *   3. RENDER — the produced `{ sql, params }` uses `?`; a dialect step turns `?`
+ *      into `$N` for PostgreSQL (identical to the original driver's naive replace).
+ *
+ * NO SQL structure is generated here. The `sql` text is already complete; the
+ * runtime only splices nested-fragment text and fills `?`.
+ */
+import { type Fragment, type Node, type WhereGroup, type ValueSpec, type PresenceCondition } from './model';
+/** Runtime binding scope: FLAT — input keys and wire results are top-level roots. */
+export interface Scope {
+    input: Record<string, unknown>;
+    wire?: Record<string, Record<string, unknown>>;
+}
+/** Is a fragment's `skip` satisfied (⇒ omit the fragment)? */
+export declare function isSkipped(cond: PresenceCondition | undefined, scope: Scope): boolean;
+/** Evaluate a value-spec to its bound value against the runtime scope. */
+export declare function evalValueSpec(spec: ValueSpec, scope: Scope): unknown;
+/**
+ * Assemble a single fragment: interleave its literal `sql` (split on `?`) with the
+ * rendered text of each param, concatenating params in order.
+ */
+export declare function assembleFragment(frag: Fragment, scope: Scope): {
+    sql: string;
+    params: unknown[];
+};
+/**
+ * Assemble a WHERE group: join present members with `" AND "`, prefix `" WHERE "`.
+ * If no member is present, produce the empty string (identical to the ORIGINAL
+ * `DBConditions.compile` → `parts.length === 0 ? '' : parts.join(' AND ')`, with the
+ * `" WHERE "` prefix owned by the caller/select in the original — here folded in).
+ */
+export declare function assembleWhereGroup(group: WhereGroup, scope: Scope): {
+    sql: string;
+    params: unknown[];
+};
+/**
+ * Assemble an ordered fragment/WHERE-group list into a single `{ sql, params }`
+ * (with `?`). Fragments whose `skip` is satisfied are omitted entirely (sql AND
+ * params). A WHERE group joins its present members with the original's text glue.
+ */
+export declare function assemble(nodes: Node[], scope: Scope): {
+    sql: string;
+    params: unknown[];
+};
+/**
+ * PostgreSQL dialect render: `?` → `$1, $2, …`. Byte-identical to the original
+ * driver's `convertPlaceholders` (naive left-to-right replace; see
+ * `src/drivers/postgres.ts`).
+ */
+export declare function toPostgres(sql: string): string;
+//# sourceMappingURL=assemble.d.ts.map

package/dist/scp/fragment/assemble.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assemble.d.ts","sourceRoot":"","sources":["../../../src/scp/fragment/assemble.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,IAAI,EACT,KAAK,UAAU,EAEf,KAAK,SAAS,EACd,KAAK,iBAAiB,EAOvB,MAAM,SAAS,CAAC;AAEjB,qFAAqF;AACrF,MAAM,WAAW,KAAK;IACpB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CAChD;AAWD,8DAA8D;AAC9D,wBAAgB,SAAS,CAAC,IAAI,EAAE,iBAAiB,GAAG,SAAS,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAIpF;AAED,0EAA0E;AAC1E,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAqBpE;AAYD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,EAAE,CAAA;CAAE,CAejG;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,EAAE,CAAA;CAAE,CAWtG;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,KAAK,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,EAAE,CAAA;CAAE,CAgBxF;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG9C"}

package/dist/scp/fragment/assemble.js

@@ -0,0 +1,148 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — fragment RUNTIME (assemble + bind).
+ *
+ * This is the thin runtime a bundle drives. It does exactly three things:
+ *
+ *   1. ASSEMBLE — walk the ordered fragment list; drop any fragment whose `skip`
+ *      is satisfied; concatenate the present fragments' `sql`, and their `params`
+ *      in order. Nested-fragment params splice their own `sql` at the `?` and
+ *      contribute their own params in order.
+ *   2. EVALUATE — turn each value-spec param into a concrete bound value using the
+ *      runtime `input` (and upstream `wire` results).
+ *   3. RENDER — the produced `{ sql, params }` uses `?`; a dialect step turns `?`
+ *      into `$N` for PostgreSQL (identical to the original driver's naive replace).
+ *
+ * NO SQL structure is generated here. The `sql` text is already complete; the
+ * runtime only splices nested-fragment text and fills `?`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSkipped = isSkipped;
+exports.evalValueSpec = evalValueSpec;
+exports.assembleFragment = assembleFragment;
+exports.assembleWhereGroup = assembleWhereGroup;
+exports.assemble = assemble;
+exports.toPostgres = toPostgres;
+const model_1 = require("./model");
+function readPath(root, path) {
+    let cur = root;
+    for (const seg of path) {
+        if (cur == null)
+            return undefined;
+        cur = cur[seg];
+    }
+    return cur;
+}
+/** Is a fragment's `skip` satisfied (⇒ omit the fragment)? */
+function isSkipped(cond, scope) {
+    if (!cond)
+        return false;
+    const v = readPath(scope.input, cond.absent);
+    return v == null;
+}
+/** Evaluate a value-spec to its bound value against the runtime scope. */
+function evalValueSpec(spec, scope) {
+    if ((0, model_1.isInputRef)(spec))
+        return readPath(scope.input, spec.input);
+    if ((0, model_1.isWireRef)(spec)) {
+        const [node, ...rest] = spec.wire;
+        const nodeResults = scope.wire?.[node] ?? {};
+        return readPath(nodeResults, rest);
+    }
+    if ((0, model_1.isLiteral)(spec))
+        return spec.literal;
+    if ((0, model_1.isValueExpr)(spec)) {
+        if (spec.op === 'coalesce') {
+            for (const a of spec.args) {
+                const v = evalValueSpec(a, scope);
+                if (v != null)
+                    return v;
+            }
+            return null;
+        }
+        if (spec.op === 'add') {
+            return spec.args.reduce((acc, a) => acc + evalValueSpec(a, scope), 0);
+        }
+    }
+    throw new Error(`unknown value-spec: ${JSON.stringify(spec)}`);
+}
+/** Flatten one param (value-spec OR nested fragment) into sql text + bound params. */
+function assembleParam(param, scope) {
+    if ((0, model_1.isFragment)(param)) {
+        // Nested fragment: splice its own sql at the `?`, contribute its own params.
+        return assembleFragment(param, scope);
+    }
+    // Value-spec: this `?` is filled by a single bound value.
+    return { sql: '?', params: [evalValueSpec(param, scope)] };
+}
+/**
+ * Assemble a single fragment: interleave its literal `sql` (split on `?`) with the
+ * rendered text of each param, concatenating params in order.
+ */
+function assembleFragment(frag, scope) {
+    const chunks = frag.sql.split('?');
+    if (chunks.length - 1 !== frag.params.length) {
+        throw new Error(`fragment placeholder/param mismatch: ${chunks.length - 1} '?' vs ${frag.params.length} params in ${JSON.stringify(frag.sql)}`);
+    }
+    let sql = chunks[0];
+    const params = [];
+    for (let i = 0; i < frag.params.length; i++) {
+        const rendered = assembleParam(frag.params[i], scope);
+        sql += rendered.sql + chunks[i + 1];
+        params.push(...rendered.params);
+    }
+    return { sql, params };
+}
+/**
+ * Assemble a WHERE group: join present members with `" AND "`, prefix `" WHERE "`.
+ * If no member is present, produce the empty string (identical to the ORIGINAL
+ * `DBConditions.compile` → `parts.length === 0 ? '' : parts.join(' AND ')`, with the
+ * `" WHERE "` prefix owned by the caller/select in the original — here folded in).
+ */
+function assembleWhereGroup(group, scope) {
+    const parts = [];
+    const params = [];
+    for (const member of group.where) {
+        if (isSkipped(member.skip, scope))
+            continue;
+        const r = assembleFragment(member, scope);
+        parts.push(r.sql);
+        params.push(...r.params);
+    }
+    if (parts.length === 0)
+        return { sql: '', params: [] };
+    return { sql: ` WHERE ${parts.join(' AND ')}`, params };
+}
+/**
+ * Assemble an ordered fragment/WHERE-group list into a single `{ sql, params }`
+ * (with `?`). Fragments whose `skip` is satisfied are omitted entirely (sql AND
+ * params). A WHERE group joins its present members with the original's text glue.
+ */
+function assemble(nodes, scope) {
+    let sql = '';
+    const params = [];
+    for (const node of nodes) {
+        if ((0, model_1.isWhereGroup)(node)) {
+            const r = assembleWhereGroup(node, scope);
+            sql += r.sql;
+            params.push(...r.params);
+            continue;
+        }
+        if (isSkipped(node.skip, scope))
+            continue;
+        const r = assembleFragment(node, scope);
+        sql += r.sql;
+        params.push(...r.params);
+    }
+    return { sql, params };
+}
+/**
+ * PostgreSQL dialect render: `?` → `$1, $2, …`. Byte-identical to the original
+ * driver's `convertPlaceholders` (naive left-to-right replace; see
+ * `src/drivers/postgres.ts`).
+ */
+function toPostgres(sql) {
+    let index = 0;
+    return sql.replace(/\?/g, () => `$${++index}`);
+}
+//# sourceMappingURL=assemble.js.map

package/dist/scp/fragment/assemble.js.map

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