litedbmodel 2.0.2 → 2.2.0

package/dist/scp/authoring.d.ts

@@ -1,155 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,162 +0,0 @@
-"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

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

package/dist/scp/catalog.d.ts

@@ -1,94 +0,0 @@
-/**
- * litedbmodel v2 SCP catalog — WS1 (#21).
- *
- * `LITEDBMODEL_CATALOG` is the behavior-contracts–typed `Catalog` that IS the whole
- * per-DSL difference litedbmodel supplies as a SQL-backend consumer (bc C2: "the only
- * per-DSL difference is the catalog"). It mirrors the SHAPE of graphddb's
- * `GRAPHDDB_CATALOG` (`src/spec/catalog.ts`) exactly: compact `PortSchema` constructors,
- * an `entry()` helper, per-primitive `inputPorts`, an `output.shape`, and a
- * `portableToIR` flag. The effect implementation (SQL execution + row→model assembly) is
- * bound separately in the handler registry (WS3, C4 — catalog declares, registry binds).
- *
- * ## Catalog names (spec §1 / §11 item 1)
- *
- * `Select` / `Insert` / `Update` / `Delete` are the CRUD leaf components. `Fragment` is
- * the dynamic WHERE/SET fragment-tree component (SKIP → fragment existence rules, §8);
- * `Tx` is the multi-statement transaction envelope. As in graphddb, the transaction
- * envelope (`Tx`) is `portableToIR: false` — a transaction is emitted as a Component
- * whose body references the per-statement CRUD primitives; the atomic BEGIN/COMMIT
- * envelope is the runtime's execution concern (WS3), never a portable-IR node.
- *
- * ## Port schema conventions
- *
- * A `CatalogEntry.inputPorts` names the STATIC ports of the emitted wiring. Two families
- * are dynamic by construction and are validated by {@link assertComponentsInCatalog}
- * against documented patterns instead of being statically enumerable:
- *
- * - **`where`/`set`/`values` records**: one port per model field, flattened one-port-
- *   per-field under a `<group>.<field>` key ({@link WRITE_PORT_FAMILIES}). These carry
- *   Expression IR (the field's value/condition), from the closed operator set only.
- *
- * The CRUD entries carry `additionalPorts: true` (bc#26) so bc's shared port check
- * (`checkPortNames` / `buildComponentDefinition`) accepts the dynamic families; every
- * DECLARED port keeps bc's required/type checks regardless of the opt-in. `Tx`'s single
- * port is static, so it keeps bc's fail-closed default.
- */
-import { type Catalog, type CatalogEntry, type Component } from 'behavior-contracts';
-/**
- * The catalog-name literal union — one entry per SQL primitive litedbmodel declares:
- * the CRUD leaves (`Select` / `Insert` / `Update` / `Delete`), the dynamic WHERE/SET
- * fragment-tree component (`Fragment`), and the multi-statement transaction envelope
- * (`Tx`).
- */
-export type CatalogName = 'Select' | 'Count' | 'Insert' | 'Update' | 'Delete' | 'Fragment' | 'Tx';
-/**
- * litedbmodel's specific-component catalog (spec §11 item 1) — the behavior-contracts
- * `Catalog`-typed source of truth. Each entry declares the Port schema of one SQL
- * primitive AS THE BACKEND COMPILE WIRES IT; the effect implementation is bound
- * separately in the handler registry (WS3, C4). All entries except `Tx` may appear in
- * the portable IR.
- */
-export declare const LITEDBMODEL_CATALOG: Catalog;
-/** Look up a catalog entry by name (undefined for an unknown primitive). */
-export declare function catalogEntry(name: string): CatalogEntry | undefined;
-/** The catalog names litedbmodel declares (the C2 per-DSL surface). */
-export declare const CATALOG_NAMES: readonly CatalogName[];
-/**
- * The CQRS write catalog: the names whose presence in a component body makes the
- * component a COMMAND (spec §2.4 — effect is derived from the graph, not authored).
- * `Select`/`Fragment` are read-side; `Insert`/`Update`/`Delete`/`Tx` are write-side.
- */
-export declare const WRITE_CATALOG_NAMES: readonly CatalogName[];
-/**
- * The dynamic per-field write-port families (`<group>.<field>` — the flattened record
- * convention; longest-prefix wins). A `values.<field>` (Insert) or `set.<field>`
- * (Update) port carries the field's Expression IR value; a `sqlCast.<field>` port carries
- * the field's PostgreSQL cast type (a literal string, e.g. `jsonb`/`uuid`/`int[]`) that drives
- * the v1 per-column `?::<sqlCast>` on Postgres (`DBModel._insert`/`_update`). `sqlCast.` ports are
- * INERT on MySQL/SQLite (v1's dialect-aware cast formatter is identity there).
- */
-export declare const WRITE_PORT_FAMILIES: readonly string[];
-/**
- * The emitter's catalog validation (loud; a violation is a BUILD error), mirrored from
- * graphddb's `assertComponentsInCatalog`. Every `componentRef` / `map` body node of every
- * emitted component must:
- *
- * 1. reference a declared catalog name;
- * 2. wire every `required` port of that entry;
- * 3. wire ONLY declared ports — a port is declared if it is a static `inputPorts` name or
- *    a write record-family port ({@link WRITE_PORT_FAMILIES}, write entries only).
- *
- * All violations are collected and thrown as one error. `cond` nodes carry no component
- * reference and are skipped.
- */
-export declare function assertComponentsInCatalog(components: readonly Component[]): void;
-/** litedbmodel's CQRS effect vocabulary, mapped 1:1 from bc's `BehaviorEffect`. */
-export type ContractEffect = 'query' | 'command';
-/**
- * Derive one component's Query/Command classification FROM THE GRAPH: behavior-contracts'
- * `classifyBehaviorEffect` over {@link WRITE_CATALOG_NAMES} — a component is a `'command'`
- * iff its body references a write-catalog primitive, else a `'query'` (spec §2.4: effect
- * is derived, never authored).
- */
-export declare function deriveContractEffect(component: Component): ContractEffect;
-//# sourceMappingURL=catalog.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../src/scp/catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,EAA0B,KAAK,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,SAAS,EAAmB,MAAM,oBAAoB,CAAC;AAE9H;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GACnB,QAAQ,GACR,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,IAAI,CAAC;AAwET;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,EAAE,OAwBjC,CAAC;AAEF,4EAA4E;AAC5E,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAEnE;AAED,uEAAuE;AACvE,eAAO,MAAM,aAAa,EAAE,SAAS,WAAW,EAQ/C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,WAAW,EAKrD,CAAC;AAIF;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,MAAM,EAIhD,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,GAAG,IAAI,CA4BhF;AAGD,mFAAmF;AACnF,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,SAAS,CAAC;AAEjD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,SAAS,GAAG,cAAc,CAEzE"}