@bjornpagen/bumbledb 0.2.0 → 0.4.0

package/dist/law.d.ts

@@ -0,0 +1,224 @@
+/**
+ * The law-typing engine (owner ruling 2026-07-18, "option 2, zero debate"):
+ * THE LAWS TYPE THE COLUMNS. Domains are declared nowhere — `schema()`
+ * computes every field's domain FROM the statement list, at BOTH the type
+ * level (this module's type machinery, reading the statements tuple type)
+ * and at runtime (a plain union-find over the same pairs), and the two
+ * tiers are the same computation by construction.
+ *
+ * The three class laws (ratified; implemented exactly):
+ *
+ *   1. GENERATORS — a `fresh` field is a generator and names its class by
+ *      its declaration coordinate (`"Account.id"`); a closed relation's
+ *      synthetic id is a generator named `"Kind.id"`.
+ *   2. GENERATOR-LESS classes are named by their least member coordinate
+ *      in relation-declaration × field-declaration order (readable off the
+ *      relation record and each member's frozen field list at the VALUE
+ *      tier — deterministic, pinned forever; the wire reads only this
+ *      tier). At the TYPE tier the same class is carried as its
+ *      member-coordinate SET (see {@link ClassOfCoord}): TypeScript's
+ *      union member order is not observably deterministic, so a type-level
+ *      least-member pick would drift between compilations — the set is the
+ *      canonical deterministic spelling, the runtime name is always a
+ *      member of it, and the join judgment is identical at both tiers.
+ *   3. BARE — a field in no law has NO class and pairs only with bare in
+ *      queries (the deliberate sum-domain pointer stays legal).
+ *
+ * THE WALL: a class containing more than one generator is a contradiction
+ * (two mints cannot share a carrier) — a schema-level COMPILE error (the
+ * named, self-locating {@link ClassWall}: which generator coordinates
+ * collided, through which paired slots) with a construction-time runtime
+ * twin (`computeClasses` throws with the same content, naming the exact
+ * statement).
+ *
+ * Every paired face of the statement tuple unions its positionwise field
+ * slots: containment (ψ-selected targets included — a selection changes
+ * pairing not at all), the `==` bijection, and window source/target pairs.
+ * `key()` statements pair nothing (an FD constrains one relation's own
+ * rows; it identifies no carriers).
+ *
+ * The type tier reads pairs off the statement types' exact face data, so
+ * spell the statement list INLINE in `schema()` (the `const` type
+ * parameter keeps the tuple precise). A widened `Statement[]` list
+ * degrades the TYPE tier to generators-only (no pair is readable off a
+ * widened type) — the runtime map stays complete and authoritative, and
+ * the wire lowering reads only the runtime map. Every loop below is
+ * tail-recursive with an accumulator, so the machinery rides TypeScript's
+ * tail-recursion elimination at primer scale (~40 relations, ~200 slots,
+ * ~123 statements); should a schema ever exceed the compiler's limits, tsc
+ * fails LOUDLY with its own instantiation-depth error — the map is never
+ * silently widened.
+ */
+import type { AnyClosed } from "#closed.ts";
+import type { FaceData } from "#face.ts";
+import type { AnyRelation, RelationFields } from "#relation.ts";
+import type { SchemaRelation, SchemaRelations } from "#schema.ts";
+import { type Statement } from "#statements.ts";
+/** One relation's computed classes: field name → class name, `undefined` = bare. */
+type RelationClasses = {
+    readonly [field: string]: string | undefined;
+};
+/**
+ * The class map a schema carries — relation name → field name → the
+ * computed class name (`undefined` = bare). THE domain authority: queries
+ * and the wire lowering read domains from here and nowhere else. The wide
+ * shape is the default every `Schema`-generic surface accepts; a concrete
+ * schema's `classes` property carries the EXACT computed map
+ * ({@link ClassesOf}) at the type level and the frozen runtime twin
+ * (`computeClasses`) at the value level — one property, two tiers, one
+ * computation.
+ */
+type SchemaClasses = {
+    readonly [relation: string]: RelationClasses;
+};
+/** Looks one relation's class record up in a schema's class map (absent relation = no classes). */
+type ClassRecordOf<Classes extends SchemaClasses, N extends string> = N extends keyof Classes ? Classes[N] : Record<never, never>;
+/** Looks one field's class up in a relation's class record (absent field = bare). */
+type ClassLookup<CR, K> = K extends keyof CR ? CR[K] & (string | undefined) : undefined;
+/** A closed member's declared payload-column record (`never` on ordinary relations). */
+type MemberColumns<M> = M extends AnyClosed ? M["columns"] : never;
+/** The field names of one schema member: a relation's declared fields; a closed relation's sealed `id` + columns. */
+type MemberFieldNames<M extends SchemaRelation> = M extends AnyClosed ? "id" | (keyof MemberColumns<M> & string) : M extends AnyRelation ? keyof RelationFields<M> & string : never;
+/** The fresh-marked field names of one field block. */
+type FreshFieldNames<Fields> = {
+    [F in keyof Fields & string]: Fields[F] extends {
+        readonly fresh: true;
+    } ? F : never;
+}[keyof Fields & string];
+/** One member's generator coordinates: fresh fields; a closed relation's synthetic id. */
+type MemberGenerators<N extends string, M extends SchemaRelation> = M extends AnyClosed ? `${N}.id` : M extends AnyRelation ? `${N}.${FreshFieldNames<RelationFields<M>>}` : never;
+/** Every generator coordinate of a relation record (a union). */
+type GeneratorsOf<Rels extends SchemaRelations> = {
+    [N in keyof Rels & string]: MemberGenerators<N, Rels[N]>;
+}[keyof Rels & string];
+/** One paired-slot pair of coordinates. */
+type Pair = readonly [string, string];
+/** A list of slot pairs. */
+type PairList = readonly Pair[];
+/** Zips two faces' projections into coordinate pairs, positionwise. */
+type ZipCoords<SN extends string, SP extends readonly string[], TN extends string, TP extends readonly string[], Acc extends PairList = []> = SP extends readonly [infer SH extends string, ...infer ST extends readonly string[]] ? TP extends readonly [infer TH extends string, ...infer TT extends readonly string[]] ? ZipCoords<SN, ST, TN, TT, readonly [...Acc, readonly [`${SN}.${SH}`, `${TN}.${TH}`]]> : Acc : Acc;
+/**
+ * One statement's slot pairs: containments (bidirectional included — pair
+ * unions are symmetric) and windows pair their two faces positionwise;
+ * `key()` pairs nothing. A widened face (owner name or projection no
+ * longer literal) contributes nothing — the runtime map stays complete.
+ */
+type StatementPairs<St extends Statement> = St["data"] extends {
+    readonly source: infer S extends FaceData;
+    readonly target: infer T extends FaceData;
+} ? string extends S["owner"]["name"] ? [] : string extends T["owner"]["name"] ? [] : ZipCoords<S["owner"]["name"], S["projection"], T["owner"]["name"], T["projection"]> : [];
+/** Every slot pair of a statements tuple, in written order. */
+type PairsOf<Stmts extends readonly Statement[], Acc extends PairList = []> = Stmts extends readonly [
+    infer H extends Statement,
+    ...infer T extends readonly Statement[]
+] ? PairsOf<T, readonly [...Acc, ...StatementPairs<H>]> : Acc;
+/** The component (a union of coordinates) containing `X`, or `never` when `X` is in none. */
+type CompOf<Comps extends readonly string[], X extends string> = Comps extends readonly [
+    infer H extends string,
+    ...infer T extends readonly string[]
+] ? [X] extends [H] ? H : CompOf<T, X> : never;
+/** Rebuilds the component list without the component `C` (components are disjoint; identity is mutual extension). */
+type WithoutComp<Comps extends readonly string[], C extends string, Acc extends readonly string[] = []> = Comps extends readonly [infer H extends string, ...infer T extends readonly string[]] ? [H, C] extends [C, H] ? WithoutComp<T, C, Acc> : WithoutComp<T, C, readonly [...Acc, H]> : Acc;
+/** Unions one pair into the component list: create, extend, keep, or merge. */
+type AddPair<Comps extends readonly string[], A extends string, B extends string> = [
+    CompOf<Comps, A>,
+    CompOf<Comps, B>
+] extends [infer CA extends string, infer CB extends string] ? [CA] extends [never] ? [CB] extends [never] ? readonly [...Comps, A | B] : readonly [...WithoutComp<Comps, CB>, CB | A] : [CB] extends [never] ? readonly [...WithoutComp<Comps, CA>, CA | B] : [CA, CB] extends [CB, CA] ? Comps : readonly [...WithoutComp<WithoutComp<Comps, CA>, CB>, CA | CB] : Comps;
+/** Folds every pair into connected components (tail-recursive — the whole walk is one loop). */
+type BuildComps<Pairs extends PairList, Comps extends readonly string[] = readonly []> = Pairs extends readonly [
+    infer P extends Pair,
+    ...infer T extends PairList
+] ? BuildComps<T, AddPair<Comps, P[0], P[1]>> : Comps;
+/** Whether a union holds two or more members (`All` captures the whole union across distribution). */
+type IsMulti<U, All = U> = [U] extends [never] ? false : U extends unknown ? ([All] extends [U] ? false : true) : never;
+/**
+ * The named, self-locating compile verdict of the one-generator wall: the
+ * generator coordinates that collided and the paired slots (rendered
+ * `A.x ~ B.y`, statement order) whose chain unified them. Intersected into
+ * `schema()`'s statements parameter, so the error lands ON the statement
+ * list with this key naming the law. The runtime twin throws from
+ * `computeClasses` with the same content, naming the exact statement.
+ */
+interface ClassWall<Generators extends string, Chain extends readonly string[]> {
+    readonly "schema class wall — the statements unify two generators into one class (two mints cannot share a carrier)": {
+        readonly generators: Generators;
+        readonly through: Chain;
+    };
+}
+/** The paired slots lying inside component `C`, rendered — the wall's self-locating chain. */
+type ChainOf<Pairs extends PairList, C extends string, Acc extends readonly string[] = []> = Pairs extends readonly [
+    infer P extends Pair,
+    ...infer T extends PairList
+] ? [P[0]] extends [C] ? ChainOf<T, C, readonly [...Acc, `${P[0]} ~ ${P[1]}`]> : ChainOf<T, C, Acc> : Acc;
+/** Scans the components for a two-generator class: `unknown` (lawful) or the {@link ClassWall}. */
+type WallScan<Comps extends readonly string[], Gens extends string, Pairs extends PairList> = Comps extends readonly [
+    infer H extends string,
+    ...infer T extends readonly string[]
+] ? true extends IsMulti<Extract<H, Gens>> ? ClassWall<Extract<H, Gens>, ChainOf<Pairs, H>> : WallScan<T, Gens, Pairs> : unknown;
+/**
+ * The one-generator-per-class law as a constraint: resolves to `unknown`
+ * (a no-op intersection into the statements parameter) when the statement
+ * list is lawful, and to the named {@link ClassWall} otherwise.
+ */
+type LawfulStatements<Rels extends SchemaRelations, Stmts extends readonly Statement[]> = WallScan<BuildComps<PairsOf<Stmts>>, GeneratorsOf<Rels>, PairsOf<Stmts>>;
+/**
+ * One coordinate's class per the three laws, at the TYPE tier: its
+ * component's single generator (the exact literal — a generator names its
+ * class); a component-less generator is its own class; a component-less
+ * non-generator is bare (`undefined`); and a GENERATOR-LESS component is
+ * carried as its member-coordinate SET (the union of the component's
+ * coordinates — a canonical, deterministic type). The set REPRESENTS the
+ * runtime's least-member class name faithfully: the runtime name is by
+ * construction a member, two slots share a class exactly when their sets
+ * are identical (so `JoinOk` judges identically at both tiers), and bare
+ * never equals a set. The least-member PICK itself is deliberately not
+ * made at the type tier: TypeScript's union member order is not observably
+ * deterministic (the same key union tuples differently across checking
+ * contexts — measured, not conjectured), so any type-level "least in
+ * declaration order" would drift between compilations; the ratified
+ * declaration-order name lives at the VALUE tier (`computeClasses`), which
+ * is the only tier the wire reads.
+ */
+type ClassOfCoord<Comps extends readonly string[], Gens extends string, C extends string> = [CompOf<Comps, C>] extends [
+    infer M extends string
+] ? [M] extends [never] ? [C] extends [Gens] ? C : undefined : [Extract<M, Gens>] extends [infer G extends string] ? [G] extends [never] ? M : G : never : never;
+/** The computed class map over precomputed components/generators. */
+type ComputedClasses<Rels extends SchemaRelations, Comps extends readonly string[], Gens extends string> = {
+    readonly [N in keyof Rels & string]: {
+        readonly [F in MemberFieldNames<Rels[N]>]: ClassOfCoord<Comps, Gens, `${N}.${F}`>;
+    };
+};
+/**
+ * THE type-level class map of a schema: relation name → field name → the
+ * law-computed class (`undefined` = bare) — what `schema()` returns as the
+ * `classes` property's type, and what query joins compare. Generator
+ * classes are exact name literals; generator-less classes are their
+ * member-coordinate sets (see {@link ClassOfCoord} — the runtime map's
+ * least-member name is always a member, so the property type is honest).
+ */
+type ClassesOf<Rels extends SchemaRelations, Stmts extends readonly Statement[]> = ComputedClasses<Rels, BuildComps<PairsOf<Stmts>>, GeneratorsOf<Rels>>;
+/**
+ * Computes the class map — the runtime twin of {@link ClassesOf}, the SAME
+ * computation as a plain union-find: every paired face's positionwise slot
+ * pairs union their coordinates; a fresh field or closed id is a generator
+ * naming its class; a generator-less class is named by its least member in
+ * relation-declaration × field-declaration order; a slot in no law is bare
+ * (`undefined`). The one-generator wall throws HERE, naming the two
+ * coordinates and the statement that unified them — the same content the
+ * compile-tier {@link ClassWall} carries. The returned map is frozen, own
+ * properties throughout (arbitrary field names ride own-property
+ * definition, never the object protocol).
+ */
+declare function computeClasses(name: string, relations: SchemaRelations, statements: readonly Statement[]): SchemaClasses;
+/**
+ * The trusted seam of the class-map mint (the `refsComplete` pattern): the
+ * checkable facts — one own record per declared relation, one own entry
+ * per declared field (the closed sealed shape's `id` included), everything
+ * frozen — are verified before the runtime map is admitted at the computed
+ * {@link ClassesOf} type. The NAME agreement of the two tiers is pinned by
+ * the generated fixture probes (the runtime/type diff check).
+ */
+declare function classesComplete<Classes extends SchemaClasses>(classes: SchemaClasses, relations: SchemaRelations): classes is Classes;
+export type { ClassesOf, ClassLookup, ClassRecordOf, ClassWall, LawfulStatements, RelationClasses, SchemaClasses };
+export { classesComplete, computeClasses };
+//# sourceMappingURL=law.d.ts.map

package/dist/law.d.ts.map

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

package/dist/law.js

@@ -0,0 +1,224 @@
+/**
+ * The law-typing engine (owner ruling 2026-07-18, "option 2, zero debate"):
+ * THE LAWS TYPE THE COLUMNS. Domains are declared nowhere — `schema()`
+ * computes every field's domain FROM the statement list, at BOTH the type
+ * level (this module's type machinery, reading the statements tuple type)
+ * and at runtime (a plain union-find over the same pairs), and the two
+ * tiers are the same computation by construction.
+ *
+ * The three class laws (ratified; implemented exactly):
+ *
+ *   1. GENERATORS — a `fresh` field is a generator and names its class by
+ *      its declaration coordinate (`"Account.id"`); a closed relation's
+ *      synthetic id is a generator named `"Kind.id"`.
+ *   2. GENERATOR-LESS classes are named by their least member coordinate
+ *      in relation-declaration × field-declaration order (readable off the
+ *      relation record and each member's frozen field list at the VALUE
+ *      tier — deterministic, pinned forever; the wire reads only this
+ *      tier). At the TYPE tier the same class is carried as its
+ *      member-coordinate SET (see {@link ClassOfCoord}): TypeScript's
+ *      union member order is not observably deterministic, so a type-level
+ *      least-member pick would drift between compilations — the set is the
+ *      canonical deterministic spelling, the runtime name is always a
+ *      member of it, and the join judgment is identical at both tiers.
+ *   3. BARE — a field in no law has NO class and pairs only with bare in
+ *      queries (the deliberate sum-domain pointer stays legal).
+ *
+ * THE WALL: a class containing more than one generator is a contradiction
+ * (two mints cannot share a carrier) — a schema-level COMPILE error (the
+ * named, self-locating {@link ClassWall}: which generator coordinates
+ * collided, through which paired slots) with a construction-time runtime
+ * twin (`computeClasses` throws with the same content, naming the exact
+ * statement).
+ *
+ * Every paired face of the statement tuple unions its positionwise field
+ * slots: containment (ψ-selected targets included — a selection changes
+ * pairing not at all), the `==` bijection, and window source/target pairs.
+ * `key()` statements pair nothing (an FD constrains one relation's own
+ * rows; it identifies no carriers).
+ *
+ * The type tier reads pairs off the statement types' exact face data, so
+ * spell the statement list INLINE in `schema()` (the `const` type
+ * parameter keeps the tuple precise). A widened `Statement[]` list
+ * degrades the TYPE tier to generators-only (no pair is readable off a
+ * widened type) — the runtime map stays complete and authoritative, and
+ * the wire lowering reads only the runtime map. Every loop below is
+ * tail-recursive with an accumulator, so the machinery rides TypeScript's
+ * tail-recursion elimination at primer scale (~40 relations, ~200 slots,
+ * ~123 statements); should a schema ever exceed the compiler's limits, tsc
+ * fails LOUDLY with its own instantiation-depth error — the map is never
+ * silently widened.
+ */
+import * as errors from "@superbuilders/errors";
+import { renderStatement } from "#statements.ts";
+/** Reads every member's coordinates off the relation record, declaration order throughout. */
+function memberCoords(relations) {
+    const out = [];
+    for (const [relationName, member] of Object.entries(relations)) {
+        if ("handles" in member.data) {
+            const fields = [
+                { name: "id", generator: true },
+                ...member.data.columns.map(function columnCoord(column) {
+                    return { name: column.name, generator: false };
+                })
+            ];
+            out.push({ relation: relationName, fields });
+            continue;
+        }
+        const fields = member.data.fields.map(function fieldCoord(declared) {
+            return { name: declared.name, generator: "fresh" in declared.field && declared.field.fresh === true };
+        });
+        out.push({ relation: relationName, fields });
+    }
+    return out;
+}
+/** Builds the union-find. */
+function makeUnionFind() {
+    const parent = new Map();
+    const generators = new Map();
+    function find(coord) {
+        const at = parent.get(coord);
+        if (at === undefined) {
+            parent.set(coord, coord);
+            return coord;
+        }
+        if (at === coord) {
+            return coord;
+        }
+        const root = find(at);
+        parent.set(coord, root);
+        return root;
+    }
+    return {
+        find,
+        union(a, b) {
+            const rootA = find(a);
+            const rootB = find(b);
+            if (rootA === rootB) {
+                return rootA;
+            }
+            parent.set(rootB, rootA);
+            const merged = [...(generators.get(rootA) ?? []), ...(generators.get(rootB) ?? [])];
+            generators.delete(rootB);
+            if (merged.length > 0) {
+                generators.set(rootA, merged);
+            }
+            return rootA;
+        },
+        generatorsOf(root) {
+            return generators.get(root) ?? [];
+        },
+        markGenerator(coord) {
+            const root = find(coord);
+            generators.set(root, [...(generators.get(root) ?? []), coord]);
+        }
+    };
+}
+/** The paired faces of one statement, or undefined for a key (an FD pairs nothing). */
+function statementFaces(statement) {
+    const data = statement.data;
+    if (data.kind === "key") {
+        return undefined;
+    }
+    return [data.source, data.target];
+}
+/**
+ * Computes the class map — the runtime twin of {@link ClassesOf}, the SAME
+ * computation as a plain union-find: every paired face's positionwise slot
+ * pairs union their coordinates; a fresh field or closed id is a generator
+ * naming its class; a generator-less class is named by its least member in
+ * relation-declaration × field-declaration order; a slot in no law is bare
+ * (`undefined`). The one-generator wall throws HERE, naming the two
+ * coordinates and the statement that unified them — the same content the
+ * compile-tier {@link ClassWall} carries. The returned map is frozen, own
+ * properties throughout (arbitrary field names ride own-property
+ * definition, never the object protocol).
+ */
+function computeClasses(name, relations, statements) {
+    const members = memberCoords(relations);
+    const uf = makeUnionFind();
+    const paired = new Set();
+    const generatorSet = new Set();
+    for (const member of members) {
+        for (const field of member.fields) {
+            const coord = `${member.relation}.${field.name}`;
+            uf.find(coord);
+            if (field.generator) {
+                generatorSet.add(coord);
+                uf.markGenerator(coord);
+            }
+        }
+    }
+    for (const statement of statements) {
+        const faces = statementFaces(statement);
+        if (faces === undefined) {
+            continue;
+        }
+        const [source, target] = faces;
+        source.projection.forEach(function unionSlot(fieldName, position) {
+            const targetField = target.projection[position];
+            if (targetField === undefined) {
+                return;
+            }
+            const coordA = `${source.owner.name}.${fieldName}`;
+            const coordB = `${target.owner.name}.${targetField}`;
+            paired.add(coordA);
+            paired.add(coordB);
+            const root = uf.union(coordA, coordB);
+            const gens = uf.generatorsOf(root);
+            if (gens.length > 1) {
+                throw errors.new(`schema ${name}: the statements unify two generators into one class — ${gens.join(" and ")} (two mints cannot share a carrier) — ${renderStatement(statement)}`);
+            }
+        });
+    }
+    const names = new Map();
+    for (const member of members) {
+        for (const field of member.fields) {
+            const coord = `${member.relation}.${field.name}`;
+            const root = uf.find(coord);
+            if (!names.has(root)) {
+                const gens = uf.generatorsOf(root);
+                names.set(root, gens[0] ?? coord);
+            }
+        }
+    }
+    const classes = {};
+    for (const member of members) {
+        const record = {};
+        for (const field of member.fields) {
+            const coord = `${member.relation}.${field.name}`;
+            const classed = paired.has(coord) || generatorSet.has(coord);
+            Object.defineProperty(record, field.name, {
+                value: classed ? names.get(uf.find(coord)) : undefined,
+                enumerable: true
+            });
+        }
+        Object.freeze(record);
+        Object.defineProperty(classes, member.relation, { value: record, enumerable: true });
+    }
+    return Object.freeze(classes);
+}
+/**
+ * The trusted seam of the class-map mint (the `refsComplete` pattern): the
+ * checkable facts — one own record per declared relation, one own entry
+ * per declared field (the closed sealed shape's `id` included), everything
+ * frozen — are verified before the runtime map is admitted at the computed
+ * {@link ClassesOf} type. The NAME agreement of the two tiers is pinned by
+ * the generated fixture probes (the runtime/type diff check).
+ */
+function classesComplete(classes, relations) {
+    if (!Object.isFrozen(classes)) {
+        return false;
+    }
+    return memberCoords(relations).every(function relationMinted(member) {
+        const record = classes[member.relation];
+        if (record === undefined || !Object.isFrozen(record)) {
+            return false;
+        }
+        return member.fields.every(function fieldMinted(field) {
+            return Object.hasOwn(record, field.name);
+        });
+    });
+}
+export { classesComplete, computeClasses };
+//# sourceMappingURL=law.js.map

package/dist/law.js.map

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

package/dist/lower.d.ts

@@ -8,29 +8,36 @@
  * fixed key order, so serialization is deterministic (byte-stable).
  */
 import type { AnyClosed } from "#closed.ts";
+import type { RelationClasses } from "#law.ts";
 import type { AnyRelation } from "#relation.ts";
 import type { AnySchema } from "#schema.ts";
 import type { RelationSpec, SchemaSpec } from "#spec.ts";
 /**
  * Lowers one ordinary relation to its `RelationSpec` fragment: fields in
- * declaration order, `extension: undefined` (the option is the kind).
+ * declaration order, each carrying its law-computed class name as the
+ * `newtype` (`classes` — the schema's class record for this relation;
+ * bare fields carry `undefined`), `extension: undefined` (the option is
+ * the kind).
  */
-declare function lowerRelation(relation: AnyRelation): RelationSpec;
+declare function lowerRelation(relation: AnyRelation, classes: RelationClasses): RelationSpec;
 /**
  * Lowers one closed relation to its `RelationSpec` fragment: declared
  * intrinsic columns only (the engine materializes the synthetic `id`),
- * the HANDLE DOMAIN as its handle newtype — the `id` descriptor's own
- * `` `${name}Id` `` label (Rust's `closed relation Kind as KindId`), the
- * same string every referencing field carries, which is exactly how the
- * engine resolves a handle literal back to its roster — and the ground
- * axioms in declaration order (row id = index); the literals were already
- * lowered at `closed()` construction.
+ * the handle newtype — the COMPUTED class name of the id's generator
+ * class (`"Kind.id"`, always present: a closed id is a generator), which
+ * every referencing field shares by law (how the engine resolves a handle
+ * literal back to its roster) — and the ground axioms in declaration
+ * order (row id = index); the literals were already lowered at `closed()`
+ * construction.
  */
-declare function lowerClosed(member: AnyClosed): RelationSpec;
+declare function lowerClosed(member: AnyClosed, classes: RelationClasses): RelationSpec;
 /**
  * Lowers a whole theory to the `SchemaSpec` the bridge takes: relations in
  * record declaration order, DECLARED statements only in written order (the
- * engine materializes the fresh-implied and closed auto-keys itself).
+ * engine materializes the fresh-implied and closed auto-keys itself), and
+ * every field's `newtype` slot fed from the schema's law-computed class
+ * map — the ONE domain authority (fingerprint-neutral: the engine drops
+ * newtypes at descriptor lowering).
  */
 declare function lower(theory: AnySchema): SchemaSpec;
 export { lower, lowerClosed, lowerRelation };

package/dist/lower.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lower.d.ts","sourceRoot":"","sources":["../src/lower.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAG3C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAkB,MAAM,YAAY,CAAA;AAC3D,OAAO,KAAK,EAGX,YAAY,EACZ,UAAU,EAIV,MAAM,UAAU,CAAA;AA0FjB;;;GAGG;AACH,iBAAS,aAAa,CAAC,QAAQ,EAAE,WAAW,GAAG,YAAY,CAK1D;AAED;;;;;;;;;GASG;AACH,iBAAS,WAAW,CAAC,MAAM,EAAE,SAAS,GAAG,YAAY,CAQpD;AAED;;;;GAIG;AACH,iBAAS,KAAK,CAAC,MAAM,EAAE,SAAS,GAAG,UAAU,CAQ5C;AAED,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,CAAA"}
+{"version":3,"file":"lower.d.ts","sourceRoot":"","sources":["../src/lower.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAG3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAkB,MAAM,YAAY,CAAA;AAC3D,OAAO,KAAK,EAGX,YAAY,EACZ,UAAU,EAIV,MAAM,UAAU,CAAA;AA4FjB;;;;;;GAMG;AACH,iBAAS,aAAa,CAAC,QAAQ,EAAE,WAAW,EAAE,OAAO,EAAE,eAAe,GAAG,YAAY,CAKpF;AAED;;;;;;;;;GASG;AACH,iBAAS,WAAW,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,GAAG,YAAY,CAQ9E;AAKD;;;;;;;GAOG;AACH,iBAAS,KAAK,CAAC,MAAM,EAAE,SAAS,GAAG,UAAU,CAS5C;AAED,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,CAAA"}

package/dist/lower.js

@@ -38,17 +38,19 @@ function valueTypeOf(field) {
 }
 /**
  * Lowers one field descriptor to its {@link FieldSpec}: the structural
- * type, the DOMAIN label as the wire's `newtype` (the macro's `as NewType`
- * name — carried for engine handle resolution, dropped at descriptor
- * lowering, never fingerprinted), and the structural fresh mark (`fresh`
- * is the literal `true` exactly on a fresh-marked u64 — on an unmarked one
- * the property holds the marked descriptor, never `true`).
+ * type, the structural fresh mark (`fresh` is the literal `true` exactly
+ * on a fresh-marked u64 — on an unmarked one the property holds the marked
+ * descriptor, never `true`), and the wire's `newtype` — the COMPUTED class
+ * name `schema()` derived from the statement list (the laws type the
+ * columns), `undefined` on a bare field. The engine reads newtypes for
+ * handle resolution and the coherence check only and DROPS them at
+ * descriptor lowering — class names are never fingerprinted.
  */
-function lowerField(name, field) {
+function lowerField(name, field, newtype) {
     return {
         name,
         valueType: valueTypeOf(field),
-        newtype: field.domain,
+        newtype,
         fresh: "fresh" in field && field.fresh === true
     };
 }
@@ -91,44 +93,53 @@ function lowerStatement(statement) {
 }
 /**
  * Lowers one ordinary relation to its `RelationSpec` fragment: fields in
- * declaration order, `extension: undefined` (the option is the kind).
+ * declaration order, each carrying its law-computed class name as the
+ * `newtype` (`classes` — the schema's class record for this relation;
+ * bare fields carry `undefined`), `extension: undefined` (the option is
+ * the kind).
  */
-function lowerRelation(relation) {
+function lowerRelation(relation, classes) {
     const fields = relation.data.fields.map(function lowerDeclared(declared) {
-        return lowerField(declared.name, declared.field);
+        return lowerField(declared.name, declared.field, classes[declared.name]);
     });
     return { name: relation.name, newtype: undefined, fields, extension: undefined };
 }
 /**
  * Lowers one closed relation to its `RelationSpec` fragment: declared
  * intrinsic columns only (the engine materializes the synthetic `id`),
- * the HANDLE DOMAIN as its handle newtype — the `id` descriptor's own
- * `` `${name}Id` `` label (Rust's `closed relation Kind as KindId`), the
- * same string every referencing field carries, which is exactly how the
- * engine resolves a handle literal back to its roster — and the ground
- * axioms in declaration order (row id = index); the literals were already
- * lowered at `closed()` construction.
+ * the handle newtype — the COMPUTED class name of the id's generator
+ * class (`"Kind.id"`, always present: a closed id is a generator), which
+ * every referencing field shares by law (how the engine resolves a handle
+ * literal back to its roster) — and the ground axioms in declaration
+ * order (row id = index); the literals were already lowered at `closed()`
+ * construction.
  */
-function lowerClosed(member) {
+function lowerClosed(member, classes) {
     const fields = member.data.columns.map(function lowerColumn(column) {
-        return lowerField(column.name, column.field);
+        return lowerField(column.name, column.field, classes[column.name]);
     });
     const extension = member.data.rows.map(function lowerRow(row) {
         return { handle: row.handle, values: row.values };
     });
-    return { name: member.name, newtype: member.id.domain, fields, extension };
+    return { name: member.name, newtype: classes.id, fields, extension };
 }
+/** The frozen empty class record a relation outside the schema's map lowers under (nothing classed). */
+const noClasses = Object.freeze({});
 /**
  * Lowers a whole theory to the `SchemaSpec` the bridge takes: relations in
  * record declaration order, DECLARED statements only in written order (the
- * engine materializes the fresh-implied and closed auto-keys itself).
+ * engine materializes the fresh-implied and closed auto-keys itself), and
+ * every field's `newtype` slot fed from the schema's law-computed class
+ * map — the ONE domain authority (fingerprint-neutral: the engine drops
+ * newtypes at descriptor lowering).
  */
 function lower(theory) {
-    const relations = Object.values(theory.relations).map(function lowerMember(member) {
+    const relations = Object.entries(theory.relations).map(function lowerMember([name, member]) {
+        const classes = theory.classes[name] ?? noClasses;
         if (isClosedMember(member)) {
-            return lowerClosed(member);
+            return lowerClosed(member, classes);
         }
-        return lowerRelation(member);
+        return lowerRelation(member, classes);
     });
     return { relations, statements: theory.statements.map(lowerStatement) };
 }