@bjornpagen/bumbledb 0.1.0 → 0.3.0

package/dist/index.d.ts

@@ -1,49 +1,54 @@
 /**
  * @bjornpagen/bumbledb — the type-theoretic TypeScript SDK for the
- * bumbledb embedded relational engine. Public surface: the type kernel
- * (brands, fields, `relation()`, `closed()` — PRD-05), the statement
- * algebra with `schema()` and `SchemaSpec` lowering (PRD-06), the `Db`
+ * bumbledb embedded relational engine. Public surface: the structural type
+ * kernel (fields as pure structure, `relation()`, `closed()` — domains are
+ * never declared: THE LAWS TYPE THE COLUMNS, `schema()` computing every
+ * field's equivalence class FROM the statement list at both tiers), the
+ * statement algebra with `schema()` and `SchemaSpec` lowering (PRD-06), the `Db`
  * runtime (path-cached stores, transactions, typed violations, scoped
  * snapshot reads, the witnessed write loop with `abandon` — PRD-07, zero
- * closables), the query surface (Datalog as values: scoped vars/params,
- * atoms, negation, conditions, aggregates, engine recursion via predicates,
- * `db.prepare` as a plain value — PRD-08), and the exhume surface
+ * closables), the query surface (Datalog as values, kysely-shaped:
+ * `query(S).rule(r => r.match(...).where(...).select(...))` with
+ * string-named domain-typed vars, params typed by use, negation,
+ * conditions, aggregates, and stratified recursion via `program()`/`rec` —
+ * `db.prepare` as a plain value; the comparison/connective builders are
+ * also free exports, and the free names `eq`/`not`/`and`/`or` collide with
+ * common host identifiers — import aliasing is the answer; the SDK does
+ * not rename for collision-avoidance), and the exhume surface
  * (`Db.exhume` — the one schema-independent read path: the store's
- * self-described shapes and raw facts by name, deliberately untyped —
- * course-serialization PRD-02). The raw native bridge is not exported (the
- * PRD-03 stub died here as scheduled).
+ * self-described shapes and raw facts by name, typed at bare structural
+ * values, deliberately schema-free). The raw native bridge is not exported.
  */
-export type { Brand, Interval, IntervalValue } from "#brand.ts";
-export { span } from "#brand.ts";
-export type { AnyClosed, AxiomRow, Axioms, Closed, ClosedColumn, ClosedCore, ClosedData, ClosedRow, PayloadField } from "#closed.ts";
+export type { AnyClosed, AnySelectedClosed, AxiomRow, Axioms, Closed, ClosedColumn, ClosedCore, ClosedData, ClosedRow, ClosedSelectionInput, PayloadField, SelectedClosed } from "#closed.ts";
 export { closed } from "#closed.ts";
 export type { Count } from "#count.ts";
 export { atLeast, atMost, between, exactly, none } from "#count.ts";
 export type { Abandon, DeclaredKeyFact, DeltaBuild, MemberRelation, OffendingFact, Prepared, ReadScope, Tx, Violation, WitnessedWriteResult, WriteResult } from "#db.ts";
-export { abandon, Db } from "#db.ts";
+export { abandon, Db, ErrNewtypeMismatch } from "#db.ts";
 export type { Exhumed, ExhumedAxiom, ExhumedDescriptor, ExhumedFact, ExhumedField, ExhumedRelation } from "#exhume.ts";
 export { ErrExhumeCorruption, ErrExhumeFormatMismatch, ErrExhumeNoDescriptor } from "#exhume.ts";
-export type { AnyFace, Arity, Face, FaceArityMismatch, FaceData, FaceFields, FaceOwner, FaceSource, OneOf, SameArity } from "#face.ts";
+export type { AnyFace, Arity, Face, FaceArityMismatch, FaceData, FaceFields, FaceOwner, FaceShapeMismatch, FaceShapes, FaceSource, OneOf, OwnerOf, SameArity, SameShapes } from "#face.ts";
 export { on, oneOf } from "#face.ts";
-export type { AnyField, BoolField, BytesField, BytesNewtype, ClosedIdField, ClosedRoster, Field, FieldData, FieldValue, FreshU64Newtype, I64Field, I64Newtype, Infer, IntervalField, IntervalNewtype, StrField, U64Field, U64Newtype } from "#fields.ts";
-export { bool, bytes, i64, interval, str, u64 } from "#fields.ts";
+export type { AnyField, BoolField, BytesField, ClosedIdField, ClosedRoster, FreshU64Field, I64Field, Infer, IntervalField, IntervalValue, StrField, U64Field } from "#fields.ts";
+export { bool, bytes, i64, interval, span, str, u64 } from "#fields.ts";
+export type { ClassesOf, ClassWall, LawfulStatements, RelationClasses, SchemaClasses } from "#law.ts";
 export { lower, lowerClosed, lowerRelation } from "#lower.ts";
 export type { KeyFact, Minted } from "#marshal.ts";
 export type { FactValue, OccurrenceDrift, ProgramIr, Staleness, StatementKindTag } from "#native.ts";
-export type { AnyBodyItem, AnyCondition, ComparisonItem, ConditionTreeItem, Duration, MatchAtom, MatchInput, TermInput } from "#query/atom.ts";
-export { ALLEN, allen, and, covers, duration, ge, gt, is, le, lt, match, ne, not, or } from "#query/atom.ts";
-export type { AnyQuery, Query, QueryBuild, QueryParams, QueryRow, Scope } from "#query/lower.ts";
+export type { AnyCond, BindingInput, Cmp, MatchFields, MatchOwner, MatchShape, NotAtom, RecData, RuleData, SelectColumn, Tree } from "#query/atom.ts";
+export { ALLEN, allen, and, covers, eq, ge, gt, le, lt, ne, not, or, pointIn } from "#query/atom.ts";
+export type { AnyQuery, AnyRuleValue, OutputRuleChain, OutputRuleScope, Query, QueryData, QueryParams, QueryRelation, QueryRow, QueryRuleChain, QueryRuleScope, QueryStart, RecRef, RecRuleChain, RecRuleScope, RuleValue, TermOps } from "#query/lower.ts";
 export { lowerQuery, query } from "#query/lower.ts";
-export type { Predicate, PredicateBindings, PredicateRuleInput, PredicateSelf } from "#query/predicate.ts";
-export type { MaskParam, Param, ParamSet, ParamsRecord, Var } from "#query/scope.ts";
-export type { Aggregate, RowOf, SelectShape } from "#query/select.ts";
-export { argmax, argmin, count, countDistinct, max, min, pack, sum } from "#query/select.ts";
+export type { ProgramScope, Rec } from "#query/predicate.ts";
+export { program } from "#query/predicate.ts";
+export type { ClassedField, Duration, MaskParam, Param, ParamEntry, ParamsRecord, SetParam, Var, VarsRecord } from "#query/scope.ts";
+export type { Agg, SelectEntry } from "#query/select.ts";
 export type { AnyRelation, AnySelected, Fact, FieldRef, FieldRefs, FieldsShape, FreshKeys, InsertFact, Relation, RelationData, RelationField, RelationFields, Selected, SelectionBinding, SelectionInput } from "#relation.ts";
 export { relation } from "#relation.ts";
 export type { AnySchema, Schema, SchemaRelation, SchemaRelations } from "#schema.ts";
 export { schema } from "#schema.ts";
 export type { FieldSpec, LiteralSetSpec, LiteralSpec, RelationSpec, RowSpec, SchemaSpec, SideSpec, StatementSpec, ValueSpec, ValueTypeSpec, WindowSpec } from "#spec.ts";
 export { renderLiteral, renderLiteralSet, renderWindow } from "#spec.ts";
-export type { KeyStatement, Statement, StatementData } from "#statements.ts";
+export type { ContainedStatement, ContainmentData, KeyData, KeyStatement, Statement, StatementData, WindowData, WindowStatement } from "#statements.ts";
 export { contained, key, mirrors, renderStatement, window } from "#statements.ts";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -1,29 +1,34 @@
 /**
  * @bjornpagen/bumbledb — the type-theoretic TypeScript SDK for the
- * bumbledb embedded relational engine. Public surface: the type kernel
- * (brands, fields, `relation()`, `closed()` — PRD-05), the statement
- * algebra with `schema()` and `SchemaSpec` lowering (PRD-06), the `Db`
+ * bumbledb embedded relational engine. Public surface: the structural type
+ * kernel (fields as pure structure, `relation()`, `closed()` — domains are
+ * never declared: THE LAWS TYPE THE COLUMNS, `schema()` computing every
+ * field's equivalence class FROM the statement list at both tiers), the
+ * statement algebra with `schema()` and `SchemaSpec` lowering (PRD-06), the `Db`
  * runtime (path-cached stores, transactions, typed violations, scoped
  * snapshot reads, the witnessed write loop with `abandon` — PRD-07, zero
- * closables), the query surface (Datalog as values: scoped vars/params,
- * atoms, negation, conditions, aggregates, engine recursion via predicates,
- * `db.prepare` as a plain value — PRD-08), and the exhume surface
+ * closables), the query surface (Datalog as values, kysely-shaped:
+ * `query(S).rule(r => r.match(...).where(...).select(...))` with
+ * string-named domain-typed vars, params typed by use, negation,
+ * conditions, aggregates, and stratified recursion via `program()`/`rec` —
+ * `db.prepare` as a plain value; the comparison/connective builders are
+ * also free exports, and the free names `eq`/`not`/`and`/`or` collide with
+ * common host identifiers — import aliasing is the answer; the SDK does
+ * not rename for collision-avoidance), and the exhume surface
  * (`Db.exhume` — the one schema-independent read path: the store's
- * self-described shapes and raw facts by name, deliberately untyped —
- * course-serialization PRD-02). The raw native bridge is not exported (the
- * PRD-03 stub died here as scheduled).
+ * self-described shapes and raw facts by name, typed at bare structural
+ * values, deliberately schema-free). The raw native bridge is not exported.
  */
-export { span } from "#brand.ts";
 export { closed } from "#closed.ts";
 export { atLeast, atMost, between, exactly, none } from "#count.ts";
-export { abandon, Db } from "#db.ts";
+export { abandon, Db, ErrNewtypeMismatch } from "#db.ts";
 export { ErrExhumeCorruption, ErrExhumeFormatMismatch, ErrExhumeNoDescriptor } from "#exhume.ts";
 export { on, oneOf } from "#face.ts";
-export { bool, bytes, i64, interval, str, u64 } from "#fields.ts";
+export { bool, bytes, i64, interval, span, str, u64 } from "#fields.ts";
 export { lower, lowerClosed, lowerRelation } from "#lower.ts";
-export { ALLEN, allen, and, covers, duration, ge, gt, is, le, lt, match, ne, not, or } from "#query/atom.ts";
+export { ALLEN, allen, and, covers, eq, ge, gt, le, lt, ne, not, or, pointIn } from "#query/atom.ts";
 export { lowerQuery, query } from "#query/lower.ts";
-export { argmax, argmin, count, countDistinct, max, min, pack, sum } from "#query/select.ts";
+export { program } from "#query/predicate.ts";
 export { relation } from "#relation.ts";
 export { schema } from "#schema.ts";
 export { renderLiteral, renderLiteralSet, renderWindow } from "#spec.ts";

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAYhC,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAEnC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAcnE,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAA;AASpC,OAAO,EACN,mBAAmB,EACnB,uBAAuB,EACvB,qBAAqB,EACrB,MAAM,YAAY,CAAA;AAanB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AAqBpC,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,YAAY,CAAA;AACjE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAqB7D,OAAO,EACN,KAAK,EACL,KAAK,EACL,GAAG,EACH,MAAM,EACN,QAAQ,EACR,EAAE,EACF,EAAE,EACF,EAAE,EACF,EAAE,EACF,EAAE,EACF,KAAK,EACL,EAAE,EACF,GAAG,EACH,EAAE,EACF,MAAM,gBAAgB,CAAA;AAUvB,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AASnD,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAkB5F,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAEvC,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAcnC,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAExE,OAAO,EAAE,SAAS,EAAE,GAAG,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAgBH,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAEnC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAcnE,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAA;AASxD,OAAO,EACN,mBAAmB,EACnB,uBAAuB,EACvB,qBAAqB,EACrB,MAAM,YAAY,CAAA;AAiBnB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AAepC,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,YAAY,CAAA;AAEvE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAuB7D,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAoBpG,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AAEnD,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AA8B7C,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAEvC,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAcnC,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAWxE,OAAO,EAAE,SAAS,EAAE,GAAG,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA"}

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