litedbmodel 1.2.9 → 2.0.0

package/dist/scp/authoring.d.ts

@@ -0,0 +1,155 @@
+/**
+ * litedbmodel v2 SCP — Authoring Parse (WS2, #22).
+ *
+ * The litedbmodel authoring surface (spec §2.4 / §7) and the SINGLE compile path
+ * (spec §9) that lowers BOTH the SCP declaration blocks and the eager public API into
+ * ONE internal Component-graph IR (behavior-contracts' portable JSON). This module is a
+ * thin SQL-backend consumer over bc's shared authoring layer (`SemanticBehavior` /
+ * `compileBehaviors` / `catalogComponents` — bc#24): litedbmodel supplies ONLY the
+ * Catalog ({@link LITEDBMODEL_CATALOG}) and the CQRS effect derivation; bc owns all
+ * composition, `$`-wiring, structured control (`when` / `.map`), expression lowering,
+ * plan derivation and the portability self-check (C2: "the difference is the catalog
+ * only"). It mirrors graphddb's `publishBehaviors` precedent exactly.
+ *
+ * ## Authoring surface (spec §2.4)
+ *
+ * - **Root = class**: a `SemanticBehavior` subclass (default) or an `@behavior`-marked
+ *   class; each PUBLIC method is one root Behavior (= one component; name = method name).
+ *   `#`-private / `_`-prefixed members are helpers and are not published. The marker is
+ *   one-per-class and effect-agnostic — there is NO query/command vocabulary to author.
+ * - **Input Port** = the method's `$: In<...>` argument; **Output Port** = its return
+ *   value; the internal DAG is derived from `$`-refs, `.map` and `when` wiring.
+ * - **Leaf vocabulary** = the Catalog only ({@link components} = `catalogComponents(
+ *   LITEDBMODEL_CATALOG)` — `Select` / `Insert` / `Update` / `Delete` / `Fragment`). There
+ *   is NO litedbmodel-local authoring vocabulary beyond the Catalog. Conditions/values are
+ *   written with bc's expression builders (`eq` / `ne` / `coalesce` / …); `cond ? [...] :
+ *   SKIP` is written as `when(cond, () => <fragment>)` — in a `where` port it lowers to a
+ *   pure `{cond:[c, <frag>, null]}` Expression IR node (SKIP is the ABSENCE of the
+ *   fragment when `c` is false — spec §7, WS1 render), NOT a new opcode. Native `?:` / `??`
+ *   / `&&` are rejected by bc's source scan; use `when` / `coalesce` / `and`.
+ *
+ * ## CQRS effect (spec §2.4 — derived, never authored)
+ *
+ * Query vs Command is DERIVED from whether a lowered component references a write-Catalog
+ * primitive (`Insert` / `Update` / `Delete` / `Tx`), via {@link deriveContractEffect}
+ * (bc `classifyBehaviorEffect` over {@link WRITE_CATALOG_NAMES}). Class names carry no
+ * meaning.
+ *
+ * ## Single compile path (spec §9 — a real invariant)
+ *
+ * The eager public API ({@link compileEager}) does NOT interpret model metadata on a
+ * separate path. It synthesizes the SAME authoring (a one-method `SemanticBehavior`
+ * subclass) and runs it through the SAME {@link compileBehaviors}. `test/scp` pins that
+ * the eager path and the declaration path for an equivalent query produce byte-identical
+ * component IR.
+ */
+import { type BehaviorClass, type Component, type ComponentGraphIR, type MapNode, type ComponentRefNode, type PortSchema, type Recorded } from 'behavior-contracts';
+import { type CatalogName, type ContractEffect } from './catalog';
+/**
+ * The litedbmodel leaf-component functions for the shared authoring surface —
+ * `catalogComponents(LITEDBMODEL_CATALOG)` bound once, lazily (so importing this module
+ * does not pay for the binding until authoring actually runs). Invoke them inside
+ * `SemanticBehavior` method bodies:
+ *
+ * ```ts
+ * const L = components();
+ * class PostBehaviors extends SemanticBehavior {
+ *   PostSearch($: In<{ authorId: number; status?: string; since: string }>) {
+ *     const posts = L.Select({ table: 'posts', select: ['id', 'author_id', 'title'],
+ *       where: [ eq($.authorId, $.authorId),
+ *                when(ne($.status, null), () => eq($.status, $.status)),   // SKIP-optional
+ *                ge($.since, $.since) ] });
+ *     const authors = posts.map(($p: Recorded) =>
+ *       L.Select({ table: 'users', select: ['id', 'name'], where: [ eq($p.author_id, $p.author_id) ] }));
+ *     return { posts, authors };
+ *   }
+ * }
+ * ```
+ *
+ * `Tx` is in the map but is `portableToIR: false`, so wiring it is rejected at record
+ * time — the atomic transaction envelope is a WS3 runtime concern, never authored.
+ */
+export type ComponentFns = Record<CatalogName, (ports: Record<string, unknown>) => Recorded>;
+/** The `catalogComponents(LITEDBMODEL_CATALOG)` leaf-function map (typed, memoized). */
+export declare function components(): ComponentFns;
+/**
+ * One published behavior method: the bc-lowered component (name = the method name) plus
+ * its graph-DERIVED CQRS effect (spec §2.4 — the classification source of truth is the
+ * component graph; there is no query/command vocabulary for the author to declare).
+ */
+export interface BehaviorMethodSpec {
+    /** The method (= root Behavior = component) name. */
+    readonly name: string;
+    /** Graph-derived Query/Command classification (never author-declared). */
+    readonly effect: ContractEffect;
+    /** The lowered portable component (bc `compileBehaviors` output). */
+    readonly component: Component;
+}
+/**
+ * A resolved behavior contract — {@link publishBehaviors} output. Carries the whole
+ * bc-lowered {@link ComponentGraphIR} (directly consumable by WS3's runtime + WS1's
+ * backend-compile) and the per-method specs with their derived effects.
+ */
+export interface BehaviorModelContract {
+    /** The authored class name (diagnostics only). */
+    readonly className: string;
+    /** The bc-lowered portable IR (all methods; the shared internal IR — spec §9). */
+    readonly ir: ComponentGraphIR;
+    /** The lowered components (`ir.components`, one per public method). */
+    readonly components: readonly Component[];
+    /** Method name → lowered component + derived effect. */
+    readonly methods: Readonly<Record<string, BehaviorMethodSpec>>;
+}
+/** Options passed through to bc `compileBehaviors` (additive; all optional). */
+export interface PublishBehaviorsOptions {
+    /**
+     * Input Port schema overrides (method → port → schema): build-time evaluation derives
+     * port NAMES from `$` accesses, but TS types (`In<...>`) are erased at runtime, so a
+     * consumer that wants the IR to carry the declared type strings supplies them here.
+     */
+    readonly inputPorts?: Record<string, Record<string, PortSchema>>;
+    /** Plan concurrency recorded on the lowered components (bc default: 16). */
+    readonly concurrency?: number;
+}
+/**
+ * Publish an SCP declaration block: a `SemanticBehavior` (or `@behavior`) class whose
+ * public methods are the root Behaviors (spec §2.4). Lowers through the single compile
+ * path ({@link lowerBehaviorClass}).
+ *
+ * @throws bc `AuthoringFailure` for a non-declarative body (native control syntax,
+ *   coercion, unknown/missing ports, …); an `Error` from the catalog validation for an
+ *   undeclared dynamic port; a `PortabilityError` for a non-portable expression.
+ */
+export declare function publishBehaviors(cls: BehaviorClass, options?: PublishBehaviorsOptions): BehaviorModelContract;
+/**
+ * An eager authoring body: the composition a public-API call (`find` / `create` / …)
+ * would run, expressed in the SAME authoring vocabulary as a declaration-block method.
+ * `$` is the recorder Input Port and `L` is the litedbmodel leaf-component map
+ * ({@link components}); it returns the Output Port. Expression builders (`eq` /
+ * `coalesce` / …) and `when` MUST be used over `$` (they only work inside the recording
+ * frame) — never native `?:` / `??` / `&&`.
+ *
+ * The public API funnels here so its lowering shares one compiler with the declaration
+ * path (spec §9). It is installed AS the class method (below), so bc's source scan covers
+ * it in full — the eager path has the same fail-closed coverage as the declaration path.
+ */
+export type EagerBehavior = ($: Recorded, L: ComponentFns) => unknown;
+/**
+ * Compile an eager public-API call through the SINGLE compile path (spec §9). It does NOT
+ * interpret model metadata on a separate path: it synthesizes a one-method
+ * `SemanticBehavior` subclass whose single public method IS `fn` (with `L` bound), and
+ * runs it through the SAME {@link compileBehaviors} the declaration path uses.
+ * Consequently the eager path and an equivalent declaration method produce byte-identical
+ * component IR (pinned by the single-compile-path equivalence test in `test/scp/authoring.test.ts`).
+ *
+ * Because `fn` is installed AS the class method (not delegated to via a closure), bc's
+ * source scan runs over `fn`'s own source — native control syntax inside `fn` is rejected
+ * fail-closed exactly as in a declaration block (no unscanned-thunk residual). The
+ * synthesized method is named `name` so the emitted component name matches a
+ * declaration-block method of the same name (byte-identity requires equal names).
+ *
+ * @throws the same failures as {@link publishBehaviors} (single path, single guard).
+ */
+export declare function compileEager(name: string, fn: EagerBehavior, options?: PublishBehaviorsOptions): BehaviorModelContract;
+export type { Component, ComponentGraphIR, MapNode, ComponentRefNode };
+//# sourceMappingURL=authoring.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"authoring.d.ts","sourceRoot":"","sources":["../../src/scp/authoring.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,OAAO,EAIL,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,gBAAgB,EACrB,KAAK,OAAO,EACZ,KAAK,gBAAgB,EACrB,KAAK,UAAU,EACf,KAAK,QAAQ,EACd,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAIL,KAAK,WAAW,EAChB,KAAK,cAAc,EACpB,MAAM,WAAW,CAAC;AAGnB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC;AAI7F,wFAAwF;AACxF,wBAAgB,UAAU,IAAI,YAAY,CAKzC;AAED;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,qDAAqD;IACrD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,0EAA0E;IAC1E,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,qEAAqE;IACrE,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;CAC/B;AAED;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACpC,kDAAkD;IAClD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,kFAAkF;IAClF,QAAQ,CAAC,EAAE,EAAE,gBAAgB,CAAC;IAC9B,uEAAuE;IACvE,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,wDAAwD;IACxD,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAAC;CAChE;AAED,gFAAgF;AAChF,MAAM,WAAW,uBAAuB;IACtC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;IACjE,4EAA4E;IAC5E,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AA+CD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,aAAa,EAClB,OAAO,GAAE,uBAA4B,GACpC,qBAAqB,CAEvB;AAID;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC;AAEtE;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,aAAa,EACjB,OAAO,GAAE,uBAA4B,GACpC,qBAAqB,CAGvB;AA+BD,YAAY,EAAE,SAAS,EAAE,gBAAgB,EAAE,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/scp/authoring.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * litedbmodel v2 SCP — Authoring Parse (WS2, #22).
+ *
+ * The litedbmodel authoring surface (spec §2.4 / §7) and the SINGLE compile path
+ * (spec §9) that lowers BOTH the SCP declaration blocks and the eager public API into
+ * ONE internal Component-graph IR (behavior-contracts' portable JSON). This module is a
+ * thin SQL-backend consumer over bc's shared authoring layer (`SemanticBehavior` /
+ * `compileBehaviors` / `catalogComponents` — bc#24): litedbmodel supplies ONLY the
+ * Catalog ({@link LITEDBMODEL_CATALOG}) and the CQRS effect derivation; bc owns all
+ * composition, `$`-wiring, structured control (`when` / `.map`), expression lowering,
+ * plan derivation and the portability self-check (C2: "the difference is the catalog
+ * only"). It mirrors graphddb's `publishBehaviors` precedent exactly.
+ *
+ * ## Authoring surface (spec §2.4)
+ *
+ * - **Root = class**: a `SemanticBehavior` subclass (default) or an `@behavior`-marked
+ *   class; each PUBLIC method is one root Behavior (= one component; name = method name).
+ *   `#`-private / `_`-prefixed members are helpers and are not published. The marker is
+ *   one-per-class and effect-agnostic — there is NO query/command vocabulary to author.
+ * - **Input Port** = the method's `$: In<...>` argument; **Output Port** = its return
+ *   value; the internal DAG is derived from `$`-refs, `.map` and `when` wiring.
+ * - **Leaf vocabulary** = the Catalog only ({@link components} = `catalogComponents(
+ *   LITEDBMODEL_CATALOG)` — `Select` / `Insert` / `Update` / `Delete` / `Fragment`). There
+ *   is NO litedbmodel-local authoring vocabulary beyond the Catalog. Conditions/values are
+ *   written with bc's expression builders (`eq` / `ne` / `coalesce` / …); `cond ? [...] :
+ *   SKIP` is written as `when(cond, () => <fragment>)` — in a `where` port it lowers to a
+ *   pure `{cond:[c, <frag>, null]}` Expression IR node (SKIP is the ABSENCE of the
+ *   fragment when `c` is false — spec §7, WS1 render), NOT a new opcode. Native `?:` / `??`
+ *   / `&&` are rejected by bc's source scan; use `when` / `coalesce` / `and`.
+ *
+ * ## CQRS effect (spec §2.4 — derived, never authored)
+ *
+ * Query vs Command is DERIVED from whether a lowered component references a write-Catalog
+ * primitive (`Insert` / `Update` / `Delete` / `Tx`), via {@link deriveContractEffect}
+ * (bc `classifyBehaviorEffect` over {@link WRITE_CATALOG_NAMES}). Class names carry no
+ * meaning.
+ *
+ * ## Single compile path (spec §9 — a real invariant)
+ *
+ * The eager public API ({@link compileEager}) does NOT interpret model metadata on a
+ * separate path. It synthesizes the SAME authoring (a one-method `SemanticBehavior`
+ * subclass) and runs it through the SAME {@link compileBehaviors}. `test/scp` pins that
+ * the eager path and the declaration path for an equivalent query produce byte-identical
+ * component IR.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.components = components;
+exports.publishBehaviors = publishBehaviors;
+exports.compileEager = compileEager;
+const behavior_contracts_1 = require("behavior-contracts");
+const catalog_1 = require("./catalog");
+const guard_1 = require("./guard");
+let boundComponents;
+/** The `catalogComponents(LITEDBMODEL_CATALOG)` leaf-function map (typed, memoized). */
+function components() {
+    if (boundComponents === undefined) {
+        boundComponents = (0, behavior_contracts_1.catalogComponents)(catalog_1.LITEDBMODEL_CATALOG);
+    }
+    return boundComponents;
+}
+/**
+ * The single lowering core (spec §9): bc `compileBehaviors` → litedbmodel catalog check →
+ * litedbmodel portability guard → CQRS effect derivation. BOTH {@link publishBehaviors}
+ * (declaration path) and {@link compileEager} (eager public-API path) call this so there
+ * is exactly one compile path and one guard application.
+ *
+ * Pipeline (all loud, nothing dropped):
+ *  1. bc `compileBehaviors(cls)` lowers every public method into one portable component
+ *     (bc owns ALL composition/lowering and runs its own `assertPortableComponentGraph`);
+ *  2. {@link assertComponentsInCatalog} validates every lowered component against
+ *     `LITEDBMODEL_CATALOG` — the SAME check the WS1 emitter path uses (covers the
+ *     dynamic `values.<field>` / `set.<field>` write families bc's static schema check
+ *     cannot enumerate);
+ *  3. {@link assertComponentGraphPortable} AUTO-APPLIES litedbmodel's portability guard
+ *     over every port Expression IR node (WS2 AC — the lower path rejects any opcode
+ *     outside bc's closed set fail-closed, independently of bc's own self-check);
+ *  4. the CQRS effect of every method is DERIVED from its graph
+ *     ({@link deriveContractEffect}); the author never declares it.
+ */
+function lowerBehaviorClass(cls, options) {
+    const ir = (0, behavior_contracts_1.compileBehaviors)(cls, {
+        ...(options.inputPorts !== undefined ? { inputPorts: options.inputPorts } : {}),
+        ...(options.concurrency !== undefined ? { concurrency: options.concurrency } : {}),
+    });
+    (0, catalog_1.assertComponentsInCatalog)(ir.components);
+    (0, guard_1.assertComponentGraphPortable)(ir);
+    const methods = {};
+    for (const component of ir.components) {
+        methods[component.name] = {
+            name: component.name,
+            effect: (0, catalog_1.deriveContractEffect)(component),
+            component,
+        };
+    }
+    return {
+        className: cls.name ?? '<anonymous>',
+        ir,
+        components: ir.components,
+        methods,
+    };
+}
+/**
+ * Publish an SCP declaration block: a `SemanticBehavior` (or `@behavior`) class whose
+ * public methods are the root Behaviors (spec §2.4). Lowers through the single compile
+ * path ({@link lowerBehaviorClass}).
+ *
+ * @throws bc `AuthoringFailure` for a non-declarative body (native control syntax,
+ *   coercion, unknown/missing ports, …); an `Error` from the catalog validation for an
+ *   undeclared dynamic port; a `PortabilityError` for a non-portable expression.
+ */
+function publishBehaviors(cls, options = {}) {
+    return lowerBehaviorClass(cls, options);
+}
+/**
+ * Compile an eager public-API call through the SINGLE compile path (spec §9). It does NOT
+ * interpret model metadata on a separate path: it synthesizes a one-method
+ * `SemanticBehavior` subclass whose single public method IS `fn` (with `L` bound), and
+ * runs it through the SAME {@link compileBehaviors} the declaration path uses.
+ * Consequently the eager path and an equivalent declaration method produce byte-identical
+ * component IR (pinned by the single-compile-path equivalence test in `test/scp/authoring.test.ts`).
+ *
+ * Because `fn` is installed AS the class method (not delegated to via a closure), bc's
+ * source scan runs over `fn`'s own source — native control syntax inside `fn` is rejected
+ * fail-closed exactly as in a declaration block (no unscanned-thunk residual). The
+ * synthesized method is named `name` so the emitted component name matches a
+ * declaration-block method of the same name (byte-identity requires equal names).
+ *
+ * @throws the same failures as {@link publishBehaviors} (single path, single guard).
+ */
+function compileEager(name, fn, options = {}) {
+    const cls = makeEagerClass(name, fn);
+    return lowerBehaviorClass(cls, options);
+}
+/**
+ * Build a one-method `SemanticBehavior` subclass whose PUBLIC method is named `name` and
+ * IS `fn` bound to the litedbmodel leaf map. bc records the method with a recorder `$`;
+ * `fn`'s source is what bc scans for native control syntax (full fail-closed coverage).
+ */
+function makeEagerClass(name, fn) {
+    const L = components();
+    const cls = class extends behavior_contracts_1.SemanticBehavior {
+    };
+    // The method's source that bc scans is `fn.toString()` (via `method`), so native control
+    // syntax inside `fn` is rejected. `L` is bound by partial application, NOT closed over
+    // inside `fn`'s scanned body.
+    const method = function ($) {
+        return fn($, L);
+    };
+    // Make bc scan `fn`'s source (the authored body), not the trivial wrapper: expose `fn`'s
+    // source as the method's `toString`. bc's scanNativeControlSyntax reads `method.toString()`.
+    Object.defineProperty(method, 'toString', { value: () => fn.toString(), configurable: true });
+    Object.defineProperty(cls.prototype, name, {
+        value: method,
+        writable: true,
+        enumerable: false,
+        configurable: true,
+    });
+    Object.defineProperty(cls, 'name', { value: name, configurable: true });
+    return cls;
+}
+//# sourceMappingURL=authoring.js.map

package/dist/scp/authoring.js.map

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

package/dist/scp/bridge.d.ts

@@ -0,0 +1,64 @@
+/**
+ * litedbmodel v2 SCP — the WS1↔WS3 Backend-Compile bridge (WS3, #23).
+ *
+ * WS2 (`authoring.ts`) produces the REAL behavior-contracts `ComponentGraphIR`: a
+ * Component's body carries `componentRef` / `map` nodes whose `ports` are Expression IR.
+ * The SQL-structural ports (`where`, `select`, `values.<field>`, `set.<field>`, `limit`,
+ * `order`, …) are NOT plain scalars — the `where` port is `{arr:[ <cond-expr>, … ]}` where
+ * a SKIP-optional condition is a pure `{cond:[c, <frag-expr>, null]}` node (WS2), and a
+ * comparison condition is a closed-set Expression `{eq:[<colRef>, <valueExpr>]}` (spec §7).
+ *
+ * WS1's Backend-Compile (`compile-sqlite.ts`) consumes a structured `SelectDesc` /
+ * `Condition[]`. NOTHING produced that shape from the real IR — this module closes that
+ * gap. It reads a raw `componentRef`/`map` node's ports directly and lowers them to WS1's
+ * `CompiledOperation` (SQL text + fragment tree + static param slots), performing the
+ * **SKIP → fragment-existence collapse**: a `{cond:[c, frag, null]}` where-member becomes a
+ * fragment guarded by `when: c` (present iff `c` is present), exactly the existence rule
+ * `render.ts` implements (dynamic-expansion spec §2). This is the single place that maps
+ * the real bc port shape → WS1 compile input; WS1's compiler is unchanged (its golden
+ * SQL text is the pinned bar) and now has a producer for its `SelectDesc`/`Condition`.
+ *
+ * ## WHERE condition interpretation (spec §7) — closed-set ONLY
+ *
+ * SKIP existence, IN-list membership and IS NULL are **fragment structure, NOT Expression
+ * IR opcodes** (catalog `where` port type is `fragment`; bc `expression-ir.md` §4: SKIP is
+ * OUTSIDE Expression IR). But bc's authoring lowering (`compileBehaviors`) only emits
+ * closed-set Expression IR into a port, so every where-member arrives as a closed-set node.
+ * This bridge therefore reads them STRUCTURALLY into fragment kinds WITHOUT inventing any
+ * opcode (the hard rule): every member is one of bc's closed operators, decoded here.
+ *
+ *   - `{eq:[<colRef>, null]}`          → `{ kind:'isNull', column }`  (SQL `col IS NULL`)
+ *   - `{eq:[<colRef>, <valueExpr>]}`   → `{ kind:'eq',  column, value:<valueExpr> }`
+ *   - `{eq:[{ref:[IN_SENTINEL, col]}, <arrExpr>]}` → `{ kind:'in', column, value:<arrExpr> }`
+ *   - `{lt|le|gt|ge|ne:[<colRef>, v]}` → `{ kind:'cmp', column, op, value:v }`
+ *   - `{and|or:[m1, m2, …]}`           → a nested `{ kind:'group', connector, conditions }`
+ *   - `{cond:[c, <member>, null]}`     → the lowered `<member>` with `skipWhen: c` (SKIP)
+ *
+ * The LEFT operand of a comparison names the column (spec §7 `{ref:["author_id"]}`): its
+ * `ref` path's LAST segment is the column name. The RIGHT operand is the value slot — a
+ * closed-set Expression IR node bound at render time. The litedbmodel authoring helpers
+ * ({@link import('./authoring-sql')}) produce exactly these closed-set encodings, so the
+ * WS2 portability guard passes and this decoder round-trips them to the WS1 fragment tree.
+ */
+/** The reserved column-ref path head that marks an IN-list membership (see module doc). */
+export declare const IN_SENTINEL = "@in";
+import type { Component, ComponentRefNode, MapNode } from './authoring';
+import { type Dialect } from './dialect';
+import type { CompiledOperation } from './ir';
+/** A bc body node that references a catalog component (not a `cond` node). */
+type RefLike = ComponentRefNode | MapNode;
+/**
+ * Backend-Compile ONE catalog `componentRef`/`map` body node into a WS1
+ * {@link CompiledOperation}. This is the real IR → WS1 compile-input bridge for the
+ * SQL CRUD primitives.
+ */
+export declare function compileNode(node: RefLike, dialect?: Dialect): CompiledOperation;
+/**
+ * Backend-Compile every catalog node of a component into a `nodeId → CompiledOperation`
+ * map. `cond` nodes carry no catalog reference and are skipped (they are pure Expression,
+ * evaluated by bc's `runBehavior`). The thin runtime looks up a node's `CompiledOperation`
+ * by `ctx.nodeId` when its handler fires.
+ */
+export declare function compileComponentNodes(component: Component, dialect?: Dialect): Map<string, CompiledOperation>;
+export {};
+//# sourceMappingURL=bridge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bridge.d.ts","sourceRoot":"","sources":["../../src/scp/bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,2FAA2F;AAC3F,eAAO,MAAM,WAAW,QAAQ,CAAC;AAEjC,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAYxE,OAAO,EAAU,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,KAAK,EAAE,iBAAiB,EAAY,MAAM,MAAM,CAAC;AAExD,8EAA8E;AAC9E,KAAK,OAAO,GAAG,gBAAgB,GAAG,OAAO,CAAC;AAiN1C;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,GAAE,OAAgB,GAAG,iBAAiB,CAkDvF;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,SAAS,EAAE,OAAO,GAAE,OAAgB,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAOrH"}