litedbmodel 2.1.0 → 2.2.0

package/dist/scp/authoring.d.ts

@@ -1,218 +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 ComponentGraphIRDoc, type PortSchema, type Recorded } from 'behavior-contracts';
-/** Unbranded whole-IR structural shape (bc `ComponentGraphIRDoc`) — litedbmodel's carried/transformed IR. */
-export type ComponentGraphIR = ComponentGraphIRDoc;
-/** Unbranded component structural shape (`ir.components[number]`). */
-export type Component = ComponentGraphIRDoc['components'][number];
-/** Unbranded body-node structural shapes. */
-export type BodyNode = Component['body'][number];
-export type MapNode = Extract<BodyNode, {
-    map: unknown;
-}>;
-export type FanoutNode = Extract<BodyNode, {
-    fanout: unknown;
-}>;
-export type CondNode = Extract<BodyNode, {
-    cond: unknown;
-}>;
-export type ComponentRefNode = Exclude<BodyNode, MapNode | FanoutNode | CondNode>;
-import { type CatalogName, type ContractEffect } from './catalog';
-import { type MaterializeResolver, type ColumnTypeResolver } from './coltype';
-/**
- * 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 litedbmodel leaf-function map (typed, memoized). Each typed-CRUD leaf self-annotates its output
- * `PortableType` via `.as` from the ambient per-compile `static columns` resolver (see
- * {@link currentResolver}); authors call `L.Select({…})` exactly as before — the typing is automatic.
- */
-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>>;
-    /**
-     * The STATIC read-path materialize resolver (issue #59), derived ONCE at registration from the
-     * model's INLINE typed-column declaration (`static columns` — see {@link ModelColumns}).
-     * `(table, column) → MaterializeClass`, pure in-memory map lookups — ZERO per-read DB
-     * introspection. The read entry points (`executeBehavior`/`executeBehaviorAsync`/`read`) consult
-     * it so INT→number / BIGINT→string / DATE→string / BOOLEAN→boolean de-boxes for every read. Absent
-     * only when the model declared no `columns` (a model with no typed reads → raw driver values).
-     */
-    readonly materializeResolver?: MaterializeResolver;
-    /**
-     * The STATIC codegen column-type resolver (issue #58/#59), derived from the SAME inline `columns`
-     * declaration — `(table, column) → SQL type token`. Feeds `deriveReadOutTypes` so the typed-native
-     * codegen `outType` annotations come from the declaration (not an external DDL). Absent when the
-     * model declared no `columns`.
-     */
-    readonly resolveColumnType?: ColumnTypeResolver;
-}
-/**
- * The INLINE typed-column declaration (issue #59): `table → (column → SQL type token)`, declared
- * ONCE per table on the behavior model — the BC-native, consumer-inline column-type SoT (bc never
- * infers types; the author annotates them, exactly as graphddb declares its typed entity columns).
- * A read's projection resolves each column's type from THIS declaration (no external DDL string, no
- * DB introspection). The registration precomputes both the codegen `outType` resolver and the TS
- * read-path materialize resolver from it, so de-box is always-on for every registered model. SQL
- * type tokens are the §4.1 vocabulary (`INTEGER`/`INT`/`BIGINT`/`REAL`/`DOUBLE`/`DECIMAL(…)`/`TEXT`/
- * `VARCHAR(…)`/`BOOLEAN`/`DATE`/`TIMESTAMP`/`JSON`/`JSONB`/`UUID`/…).
- */
-export type ModelColumns = Readonly<Record<string, Readonly<Record<string, string>>>>;
-/**
- * A behavior model class may declare its columns inline via a `static columns` field — the typed
- * catalog the reads project from. `publishBehaviors` reads it at registration to build the de-box
- * resolvers. (Optional per class; a model with no typed reads may omit it.)
- */
-export interface TypedModelClass {
-    readonly columns?: ModelColumns;
-}
-/** 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;
-    /**
-     * The model's inline typed-column declaration (issue #59) — see {@link ModelColumns}. Normally
-     * declared as a `static columns` field ON the behavior class (the BC-native shape); this option is
-     * an alternative for callers that build the class dynamically. When both are present the option
-     * takes precedence. Absent from BOTH ⇒ the model has no declared types → reads stay un-materialized
-     * (raw driver values; pre-#59 — a model with no typed reads).
-     */
-    readonly columns?: ModelColumns;
-}
-/**
- * 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;
-//# 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":"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"}

package/dist/scp/authoring.js

@@ -1,351 +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");
-const coltype_1 = require("./coltype");
-const outtype_1 = require("./makesql/outtype");
-let boundRaw;
-let boundComponents;
-/**
- * The AMBIENT per-compile column-type resolver (bc 0.8.0 SA5 / #12). `lowerBehaviorClass` sets this
- * from the model's inline `static columns` immediately BEFORE `compileBehaviors` and clears it right
- * after (a synchronous window — bc records every method body inside that single call). The typed CRUD
- * leaf wrappers (Select/Insert/Update/Delete) read it to compute each authored node's determined
- * output `PortableType` and stamp it via bc's `.as(t)` recording API, so `compileBehaviors`'
- * all-nodes-typed gate passes. It is the SAME `static columns` SoT the post-compile de-box
- * (`deriveReadOutTypes`) reads — moved to authoring time so the type is fixed at compile (declare-via-BC:
- * column-types-in-authoring, no hand-built IR; SQL stays opaque text on the makeSQL leaf).
- */
-let currentResolver;
-/** Run `fn` with the ambient compile-time column resolver bound (restored on exit — reentrancy-safe). */
-function withColumnResolver(resolve, fn) {
-    const prev = currentResolver;
-    currentResolver = resolve;
-    try {
-        return fn();
-    }
-    finally {
-        currentResolver = prev;
-    }
-}
-/**
- * Leaves whose authored node's output row shape is per-projection and MUST be typed via `.as` from the
- * model's `static columns` (bc 0.8.0 SA5). A `Select` (read) is de-boxed by the typed read/codegen
- * path, so its row REQUIRES the column-type SoT (fail-closed when absent — mirrors #59's
- * `assertReadColumnsDeclared`). A write (`Insert`/`Update`/`Delete`) is NOT typed-codegen'd — its
- * RETURNING de-box is derived POST-compile from the tuned SQL (`writeouttype.ts`); the write NODE's
- * compile-time outType exists only to satisfy bc's all-nodes-typed gate, so it is typed from the
- * `returning` port WHEN `static columns` is present, else annotated with the determined empty-row list
- * `{arr:{obj:{}}}` (writes stay EXEMPT from a `static columns` requirement, as before #12).
- */
-const READ_TYPED_LEAF = 'Select';
-const WRITE_TYPED_LEAVES = new Set(['Insert', 'Update', 'Delete']);
-/**
- * Wrap one raw `catalogComponents` leaf so a typed-CRUD leaf stamps its authored node's determined
- * output type via bc's `.as(t)` (bc 0.8.0 SA5). `Count` (static `int` via the catalog `elemType`),
- * `Fragment`, and `Tx` pass through unchanged (no per-projection output).
- */
-function wrapLeaf(name, raw) {
-    const isRead = name === READ_TYPED_LEAF;
-    const isWrite = WRITE_TYPED_LEAVES.has(name);
-    if (!isRead && !isWrite)
-        return raw;
-    return (ports) => {
-        const handle = raw(ports);
-        // Reads REQUIRE the column-type SoT (typed de-box); writes do not (RETURNING de-box is post-compile).
-        if (isRead && currentResolver === undefined) {
-            throw new Error(`scp authoring: a Select node needs its output row type at compile time (bc 0.8.0 all-nodes-typed ` +
-                `gate), but the model declares NO \`columns\` — a typed read REQUIRES an inline \`static columns\` ` +
-                `SoT (or \`options.columns\`). No-assume, no-fallback.`);
-        }
-        const outType = currentResolver !== undefined
-            ? (0, outtype_1.crudNodeAsType)(name, ports, currentResolver, `${name} node`)
-            : { arr: { obj: {} } }; // write with no `static columns`: determined empty-row list (gate-only, inert)
-        return handle.as(outType);
-    };
-}
-/** The raw `catalogComponents(LITEDBMODEL_CATALOG)` leaf map (memoized). */
-function rawComponents() {
-    if (boundRaw === undefined) {
-        boundRaw = (0, behavior_contracts_1.catalogComponents)(catalog_1.LITEDBMODEL_CATALOG);
-    }
-    return boundRaw;
-}
-/**
- * The litedbmodel leaf-function map (typed, memoized). Each typed-CRUD leaf self-annotates its output
- * `PortableType` via `.as` from the ambient per-compile `static columns` resolver (see
- * {@link currentResolver}); authors call `L.Select({…})` exactly as before — the typing is automatic.
- */
-function components() {
-    if (boundComponents === undefined) {
-        const raw = rawComponents();
-        const wrapped = {};
-        for (const name of Object.keys(raw))
-            wrapped[name] = wrapLeaf(name, raw[name]);
-        boundComponents = wrapped;
-    }
-    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) {
-    // STATIC de-box resolvers (issue #59): the column types come from the model's INLINE declaration
-    // (`static columns` on the class, or `options.columns`) — the BC-native, consumer-inline SoT (bc
-    // never infers types). Build the `table → (col → SQL type)` map ONCE at registration into BOTH the
-    // codegen outType resolver AND the FAIL-CLOSED TS read-path materialize resolver. A read then
-    // de-boxes with ZERO DB introspection (litedbmodel's static-resolution core value).
-    //
-    // bc 0.8.0 (#12 / SA5): the resolver is built BEFORE `compileBehaviors` and bound as the AMBIENT
-    // compile-time resolver (`withColumnResolver`) so the typed CRUD leaf wrappers can stamp each
-    // authored node's determined output type via `.as` DURING recording — clearing bc's all-nodes-typed
-    // gate. Same `static columns` SoT as the post-compile de-box, moved to authoring time.
-    const className = cls.name ?? '<anonymous>';
-    const declaredColumns = options.columns ?? cls.columns;
-    const columnMap = declaredColumns !== undefined ? toColumnMap(declaredColumns) : undefined;
-    const materializeResolver = columnMap !== undefined ? (0, coltype_1.failClosedMaterializeResolverFromColumnMap)(columnMap) : undefined;
-    const resolveColumnType = columnMap !== undefined ? (0, coltype_1.columnTypeResolverFromColumnMap)(columnMap) : undefined;
-    const ir = withColumnResolver(resolveColumnType, () => (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,
-        };
-    }
-    // FAIL-CLOSED coverage-by-construction (issue #59 audit): every column a READ method projects MUST
-    // have a declared type. Validate NOW, at registration — a read whose projected columns aren't fully
-    // declared cannot be published (so no production read can silently skip de-box and leak a rounded
-    // i64). A model with NO `columns` but a read that projects columns fails here too (columns are
-    // REQUIRED for a typed read). A write / a read that projects no explicit columns is exempt.
-    assertReadColumnsDeclared(className, ir.components, methods, resolveColumnType);
-    return {
-        className,
-        ir,
-        components: ir.components,
-        methods,
-        ...(materializeResolver !== undefined ? { materializeResolver } : {}),
-        ...(resolveColumnType !== undefined ? { resolveColumnType } : {}),
-    };
-}
-/** Normalize a declared {@link ModelColumns} into the `Map<table, Map<column, sqlType>>` the resolvers use. */
-function toColumnMap(columns) {
-    const map = new Map();
-    for (const [table, cols] of Object.entries(columns)) {
-        const inner = new Map();
-        for (const [col, sqlType] of Object.entries(cols))
-            inner.set(col, sqlType);
-        map.set(table, inner);
-    }
-    return map;
-}
-/** Read a literal string port of a body node, or `undefined` (not a literal). */
-function literalStringPort(ports, name) {
-    const v = ports[name];
-    return typeof v === 'string' ? v : undefined;
-}
-/** Read a literal `{arr:[str,…]}` string-list port, or `undefined` (not a literal list). */
-function literalStringArrayPort(ports, name) {
-    const v = ports[name];
-    if (v !== null && typeof v === 'object' && 'arr' in v && Array.isArray(v.arr)) {
-        const arr = v.arr;
-        if (arr.every((e) => typeof e === 'string'))
-            return arr;
-    }
-    return undefined;
-}
-/** Extract each `Select` body node's `{ table, columns }` projection (skips Count / non-literal). */
-function selectProjectionsOf(component) {
-    const out = [];
-    for (const n of component.body) {
-        if ('cond' in n)
-            continue;
-        if ('fanout' in n) {
-            // bc 0.7.3+ `FanoutNode`. litedbmodel never emits fanout — reject fail-closed rather
-            // than mis-read it as a component ref with no `Select` projection.
-            throw new Error(`selectProjectionsOf: component '${component.name}' node '${n.id}' is a fanout node, not supported by litedbmodel (bc FanoutNode)`);
-        }
-        const ref = 'map' in n ? n.map : n;
-        if (ref.component !== 'Select')
-            continue; // Count → scalar; no projection
-        const ports = ref.ports;
-        const table = literalStringPort(ports, 'table');
-        const columns = literalStringArrayPort(ports, 'select');
-        if (table === undefined || columns === undefined || columns.length === 0)
-            continue;
-        out.push({ table, columns });
-    }
-    return out;
-}
-/**
- * FAIL-CLOSED registration guard (issue #59 audit): every column a READ (`query`) method PROJECTS —
- * in ANY shape (bare `col`, qualified `t.col`, aliased `col AS b`) — must resolve to a declared type
- * in the model's inline `columns`. Uses the SHARED {@link parseProjectionColumn} (the SAME projection
- * parser the read-path materializer + codegen outType derivations use), so no projection shape can
- * escape validation. A `*` / computed projection, an undeclared underlying column, or a read with NO
- * `columns` declared at all, THROWS here — a typed read whose projected columns aren't fully declared
- * cannot be registered, so no production read can silently skip de-box and return a rounded i64.
- * Writes are exempt.
- */
-function assertReadColumnsDeclared(className, components, methods, resolveColumnType) {
-    for (const component of components) {
-        if (methods[component.name]?.effect !== 'query')
-            continue; // reads only (writes exempt)
-        for (const proj of selectProjectionsOf(component)) {
-            const at = `model '${className}' method '${component.name}'`;
-            // SHARED parse (all shapes): `*` → throw; computed → no schema column (skip); bare/qualified/
-            // aliased schema column → must be declared (against its OWNER table = qualifier ?? base table).
-            const schemaCols = proj.columns
-                .map((col) => (0, outtype_1.parseProjectionColumn)(col, proj.table, at))
-                .filter((e) => e.kind === 'column')
-                .map((e) => ({ table: e.qualifier ?? proj.table, column: e.underlying }));
-            if (schemaCols.length === 0)
-                continue; // only computed projections — nothing to type
-            if (resolveColumnType === undefined) {
-                // A read projecting schema columns with NO `columns` declared → fail closed (columns REQUIRED).
-                throw new Error(`scp publishBehaviors: ${at} reads projecting typed columns ` +
-                    `[${schemaCols.map((s) => `${s.table}.${s.column}`).join(', ')}] but the model declares NO ` +
-                    `\`columns\`. A typed read REQUIRES an inline \`static columns\` declaration so the read-path ` +
-                    `de-box (INT→number / BIGINT→string / DATE→string / BOOLEAN→boolean) is always-on — never a ` +
-                    `silent raw (rounded i64) result. Declare the model's \`static columns\`.`);
-            }
-            // resolveColumnType THROWS (naming the table/column) for any undeclared UNDERLYING column.
-            for (const s of schemaCols)
-                resolveColumnType(s.table, s.column);
-        }
-    }
-}
-/**
- * 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;
-}
-// The component-graph node/component/graph types consumers (WS3) narrow the emitted IR with are
-// declared+exported as UNBRANDED structural aliases near the top of this module (bc 0.8.0: the branded
-// compile-seam handle is re-adopted only at `generateModule` via `loadCompiledIR`).
-//# 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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"}