@bjornpagen/bumbledb 0.1.0 → 0.3.0

package/src/schema.ts

@@ -12,7 +12,8 @@
 import * as errors from "@superbuilders/errors"
 import type { AnyClosed } from "#closed.ts"
 import type { FaceData } from "#face.ts"
-import { assertDeclarationOrderKey, type FieldData } from "#fields.ts"
+import { type AnyField, assertDeclarationOrderKey, type ClosedRoster } from "#fields.ts"
+import { type ClassesOf, classesComplete, computeClasses, type LawfulStatements, type SchemaClasses } from "#law.ts"
 import type { AnyRelation } from "#relation.ts"
 import type { LiteralSetSpec, LiteralSpec } from "#spec.ts"
 import { renderStatement, type Statement } from "#statements.ts"
@@ -38,7 +39,7 @@ function collectImplied(name: string, relations: SchemaRelations): Set<string> {
 			continue
 		}
 		for (const declared of member.data.fields) {
-			if (declared.field.minted) {
+			if ("fresh" in declared.field && declared.field.fresh === true) {
 				implied.add(`${member.name}(${declared.name}) -> ${member.name}`)
 			}
 		}
@@ -74,8 +75,8 @@ function verifyMembership(name: string, relations: SchemaRelations, statement: S
 	}
 }
 
-/** Finds a face's field description by name, across both relation kinds. */
-function faceField(face: FaceData, fieldName: string): FieldData | undefined {
+/** Finds a face's field descriptor by name, across both relation kinds. */
+function faceField(face: FaceData, fieldName: string): AnyField | undefined {
 	const data = face.owner.data
 	if ("handles" in data) {
 		const column = data.columns.find(function byName(candidate) {
@@ -89,6 +90,18 @@ function faceField(face: FaceData, fieldName: string): FieldData | undefined {
 	return declared?.field
 }
 
+/**
+ * The roster a field resolves handles through: present exactly on a closed
+ * reference descriptor (the structural `closed` property — S1's
+ * `ClosedIdField`), absent on every other field kind.
+ */
+function rosterOf(field: AnyField | undefined): ClosedRoster | undefined {
+	if (field !== undefined && "closed" in field) {
+		return field.closed
+	}
+	return undefined
+}
+
 /** Flattens one binding's literal set into its literals. */
 function bindingLiterals(set: LiteralSetSpec): readonly LiteralSpec[] {
 	if (set.kind === "one") {
@@ -109,20 +122,18 @@ function verifyBindingHandles(
 	binding: { readonly field: string; readonly set: LiteralSetSpec },
 	rendered: string
 ): void {
-	const field = faceField(face, binding.field)
+	const roster = rosterOf(faceField(face, binding.field))
 	for (const literal of bindingLiterals(binding.set)) {
 		if (literal.kind !== "handle") {
 			continue
 		}
-		if (field?.closed === undefined) {
+		if (roster === undefined) {
 			throw errors.new(
-				`schema ${name}: ${face.owner.name}.${binding.field} is not a closed-relation reference — the handle literal ${literal.handle} is legal only on a field whose newtype is a closed relation's handle newtype — ${rendered}`
+				`schema ${name}: ${face.owner.name}.${binding.field} is not a closed-relation reference — the handle literal ${literal.handle} is legal only on a field carrying a closed relation's roster — ${rendered}`
 			)
 		}
-		if (!field.closed.handles.includes(literal.handle)) {
-			throw errors.new(
-				`schema ${name}: closed relation ${field.closed.name} has no handle ${literal.handle} — ${rendered}`
-			)
+		if (!roster.handles.includes(literal.handle)) {
+			throw errors.new(`schema ${name}: closed relation ${roster.name} has no handle ${literal.handle} — ${rendered}`)
 		}
 	}
 }
@@ -216,7 +227,7 @@ function verifyClosedReferenceBinding(
 	if (!spellsHandle) {
 		return
 	}
-	const roster = faceField(face, binding.field)?.closed
+	const roster = rosterOf(faceField(face, binding.field))
 	if (roster === undefined) {
 		return
 	}
@@ -237,16 +248,43 @@ type SchemaRelation = AnyRelation | AnyClosed
 /** The relation record a schema is generic over — what `Db` and queries key on. */
 type SchemaRelations = Record<string, SchemaRelation>
 
-/** A theory value: named relations plus the DECLARED dependency statements. */
-interface Schema<Rels extends SchemaRelations> {
+/**
+ * A theory value: named relations, the DECLARED dependency statements, and
+ * the LAW-COMPUTED class map (`classes` — relation → field → class name,
+ * `undefined` = bare). The class map is THE domain authority: `schema()`
+ * computes it FROM the statement list at both tiers (the type through
+ * {@link ClassesOf}, the value through the union-find twin), queries
+ * compare class names off it, and the wire lowering emits it as the spec
+ * `newtype` labels. Nothing is ever synthesized: `statements` is exactly
+ * the declared list, in written order.
+ */
+interface Schema<Rels extends SchemaRelations, Classes extends SchemaClasses = SchemaClasses> {
 	readonly name: string
 	readonly relations: Rels
 	readonly statements: readonly Statement[]
+	readonly classes: Classes
 }
 
 /** Any schema value, whatever its relation record. */
 type AnySchema = Schema<SchemaRelations>
 
+/**
+ * Forces the class map to EVALUATE at the `schema()` boundary: a two-level
+ * mapped copy, type-identical to `C` — but instantiation resolves it to
+ * the finished relation → field → class record, so hovering a schema value
+ * (or anything carrying its `Classes` parameter — queries, `Db`) shows the
+ * computed record instead of the unevaluated `ClassesOf<...>` application
+ * dragging the whole statement-tuple type along. The conditional wrapper
+ * is the display mechanism, not a judgment: resolving it drops the alias
+ * reference, so tsc renders the finished record (measured against tsc's
+ * own type rendering; a bare mapped alias still displays by name).
+ * Display-only by construction; `classesComplete` guards the same type at
+ * the value tier.
+ */
+type EvaluatedClasses<C extends SchemaClasses> = C extends SchemaClasses
+	? { readonly [N in keyof C]: { readonly [F in keyof C[N]]: C[N][F] } }
+	: never
+
 /**
  * Assembles a theory:
  * `schema("Ledger", { Kind, Account, Holder }, [ ...statements ])`.
@@ -267,12 +305,21 @@ type AnySchema = Schema<SchemaRelations>
  * list: the engine materializes them itself, in its own pinned order
  * (`SchemaDescriptor::materialized_statements`), and restating them would
  * double them.
+ *
+ * THE LAW-TYPING happens here too (rulings 2/3 — the laws type the
+ * columns): the statement list induces the equivalence classes over field
+ * slots, at the TYPE level ({@link ClassesOf} — spell the statement list
+ * inline so the tuple type stays precise) and at runtime (the union-find
+ * twin), and the one-generator-per-class wall holds at both tiers — the
+ * {@link LawfulStatements} verdict lands the compile error on the
+ * statements argument; `computeClasses` throws the same content naming the
+ * exact statement.
  */
-function schema<const Rels extends SchemaRelations>(
+function schema<const Rels extends SchemaRelations, const Stmts extends readonly Statement[]>(
 	name: string,
 	relations: Rels,
-	statements: readonly Statement[]
-): Schema<Rels> {
+	statements: Stmts & LawfulStatements<Rels, Stmts>
+): Schema<Rels, EvaluatedClasses<ClassesOf<Rels, Stmts>>> {
 	const implied = collectImplied(name, relations)
 	const seen = new Set<string>()
 	for (const statement of statements) {
@@ -290,7 +337,11 @@ function schema<const Rels extends SchemaRelations>(
 		verifyHandles(name, statement, rendered)
 	}
 	verifyClosedReferences(name, statements)
-	return Object.freeze({ name, relations, statements: Object.freeze([...statements]) })
+	const classes = computeClasses(name, relations, statements)
+	if (!classesComplete<EvaluatedClasses<ClassesOf<Rels, Stmts>>>(classes, relations)) {
+		throw errors.new(`schema ${name}: class-map construction incomplete`)
+	}
+	return Object.freeze({ name, relations, statements: Object.freeze([...statements]), classes })
 }
 
 export type { AnySchema, Schema, SchemaRelation, SchemaRelations }

package/src/spec.ts

@@ -95,9 +95,10 @@ type WindowSpec =
 	| { readonly kind: "floor"; readonly lo: bigint }
 
 /**
- * One field: name, structural type, host newtype name (carried for handle
- * resolution only — dropped by the engine at descriptor lowering), and the
- * `fresh` mint mark.
+ * One field: name, structural type, host newtype name — the field's
+ * DOMAIN (the macro's declared `as NewType`; the SDK's law-computed class
+ * name), carried for handle resolution only, dropped by the engine at
+ * descriptor lowering and never fingerprinted — and the `fresh` mint mark.
  */
 interface FieldSpec {
 	readonly name: string
@@ -120,8 +121,9 @@ interface RowSpec {
  * kind); a closed relation's `fields` are its declared intrinsic columns
  * only — the synthetic (`id`, u64) handle field is materialized by the
  * engine's schema validation. `newtype` is the handle newtype of a closed
- * relation (the SDK uses the closed relation's own name), undefined on an
- * ordinary one.
+ * relation (the SDK emits the id's law-computed generator class,
+ * `` `${name}.id` `` — the same label every referencing field carries by
+ * law), undefined on an ordinary one.
  */
 interface RelationSpec {
 	readonly name: string

package/src/statements.ts

@@ -4,30 +4,64 @@
  * form, conditional containment, the bidirectional `==` abbreviation, and
  * the cardinality window. A statement value is opaque and inert — no
  * methods, no fluent continuation: a fact about the theory, not a builder.
+ *
+ * Every field reference is checked against the relation it names in the
+ * TYPE — existence through {@link FaceFields} (`on(R, "nope")` does not
+ * compile) and STRUCTURAL compatibility through {@link SameShapes}: the two
+ * faces' projected kind/width/element triples are read off the schema type
+ * (the minimal kernel — descriptors are pure structure) and constrained
+ * positionwise equal, so a u64 face against a str face, a bytes width
+ * mismatch, or an interval element mismatch is a compile error. Domains are
+ * NOT compared here — there is no domain to compare at construction: the
+ * statements themselves are what define the equivalence classes, and the
+ * domain wall lives where they aggregate — `schema()` (the
+ * one-generator-per-class law) and query joins (class names off the schema
+ * type). What is only a SEMANTIC property — the target side of a
+ * containment resolving a declared key of its relation — is DELIBERATELY
+ * not (and cannot be) stated here: whether `B(y)` is a key of `B` depends
+ * on which `key()` statements the surrounding `schema()` collects, a set no
+ * face type can see; it stays the engine's typed `SchemaError` judgment at
+ * `Db.create`/`Db.open` (the two-boundary split, engine as final
+ * authority).
  */
 
 import * as errors from "@superbuilders/errors"
-import { phantom } from "#brand.ts"
 import type { Count } from "#count.ts"
-import { type AnyFace, type FaceData, renderFace, type SameArity } from "#face.ts"
+import { type AnyFace, type FaceData, renderFace, type SameArity, type SameShapes } from "#face.ts"
 import type { AnyRelation, RelationFields } from "#relation.ts"
 import { renderWindow, type WindowSpec } from "#spec.ts"
 
+/** A `key()` statement's runtime description — owner and projection carried at exact types. */
+interface KeyData<R extends AnyRelation, Projection extends readonly string[]> {
+	readonly kind: "key"
+	readonly owner: R
+	readonly projection: Projection
+}
+
+/**
+ * A containment statement's runtime description — the two faces carried at
+ * their EXACT types (owner names and projection tuples are honest runtime
+ * properties, and they are the type-level carrier `schema()`'s law-typing
+ * pairs slots through). The defaults are the wide shape renderers and the
+ * wire lowering consume.
+ */
+interface ContainmentData<Src extends FaceData = FaceData, Tgt extends FaceData = FaceData> {
+	readonly kind: "containment"
+	readonly source: Src
+	readonly target: Tgt
+	readonly bidirectional: boolean
+}
+
+/** A window statement's runtime description — target-left, faces at exact types like {@link ContainmentData}. */
+interface WindowData<Tgt extends FaceData = FaceData, Src extends FaceData = FaceData> {
+	readonly kind: "window"
+	readonly target: Tgt
+	readonly window: WindowSpec
+	readonly source: Src
+}
+
 /** One statement's runtime description, tagged by form. */
-type StatementData =
-	| { readonly kind: "key"; readonly owner: AnyRelation; readonly projection: readonly string[] }
-	| {
-			readonly kind: "containment"
-			readonly source: FaceData
-			readonly target: FaceData
-			readonly bidirectional: boolean
-	  }
-	| {
-			readonly kind: "window"
-			readonly target: FaceData
-			readonly window: WindowSpec
-			readonly source: FaceData
-	  }
+type StatementData = KeyData<AnyRelation, readonly string[]> | ContainmentData | WindowData
 
 /** An opaque statement value — what `schema()` assembles into a theory. */
 interface Statement {
@@ -35,15 +69,33 @@ interface Statement {
 }
 
 /**
- * A `key()` statement as a TYPED value: the statement plus a phantom
- * carrying its owner and projection tuple — what the key-statement-selected
+ * A containment (or `==` bijection) statement as a TYPED value: `data`
+ * carries both faces at their exact types, so the schema-level class laws
+ * can read every paired (relation, field) slot off the statement type —
+ * spell the statement list inline in `schema()` and the equivalence
+ * classes compute at the type level too. Structurally still a plain
+ * {@link Statement}.
+ */
+interface ContainedStatement<Src extends FaceData, Tgt extends FaceData> extends Statement {
+	readonly data: ContainmentData<Src, Tgt>
+}
+
+/** A window statement as a TYPED value — the {@link ContainedStatement} of the window form. */
+interface WindowStatement<Tgt extends FaceData, Src extends FaceData> extends Statement {
+	readonly data: WindowData<Tgt, Src>
+}
+
+/**
+ * A `key()` statement as a TYPED value: its `data` carries the owner
+ * relation and the projection tuple at their EXACT types (honest runtime
+ * properties — no phantom), which is what the key-statement-selected
  * `get(relation, keyStatement, key)` overload types its key object by
- * (`docs/architecture/70-api.md` § the freeze, the multi-key typed get).
- * Structurally still a plain {@link Statement}; the phantom is never present
- * at runtime.
+ * (`docs/architecture/70-api.md` § the freeze, the multi-key typed get) and
+ * what resolves each projected field's descriptor through the owner's
+ * schema type. Structurally still a plain {@link Statement}.
  */
 interface KeyStatement<R extends AnyRelation, Projection extends readonly string[]> extends Statement {
-	readonly [phantom]?: { readonly owner: R; readonly projection: Projection }
+	readonly data: KeyData<R, Projection>
 }
 
 /**
@@ -51,9 +103,11 @@ interface KeyStatement<R extends AnyRelation, Projection extends readonly string
  * parameter exists (the FD-with-selection shape is unrepresentable, as in
  * the grammar), and only ordinary relations are accepted: a closed
  * relation's key `R(id) -> R` is materialized by the engine, so an
- * explicit one would only ever be a duplicate. The projection tuple is
- * carried in the returned value's type ({@link KeyStatement}), so keyed
- * point reads through THIS statement are typed field-for-field.
+ * explicit one would only ever be a duplicate. Every projected name is
+ * checked against `R`'s field block in the type, and the tuple is carried
+ * in the returned value's type ({@link KeyStatement}) — keyed point reads
+ * through THIS statement are typed field-for-field, descriptors resolvable
+ * through the owner's schema type.
  */
 function key<
 	R extends AnyRelation,
@@ -64,22 +118,28 @@ function key<
 			`key(${relation.name}, ...): closedness already materializes ${relation.name}(id) -> ${relation.name} — an explicit key on a closed relation is rejected as a duplicate`
 		)
 	}
-	const data: StatementData = Object.freeze({
+	const data: KeyData<R, Projection> = Object.freeze({
 		kind: "key",
 		owner: relation,
-		projection: Object.freeze([...fields])
+		projection: Object.freeze(fields)
 	})
 	return Object.freeze({ data })
 }
 
 /**
- * `A(X|φ) <= B(Y|ψ)` — conditional inclusion, source left. The target
- * side must resolve a declared key of B — DELIBERATELY judged by the
+ * `A(X|φ) <= B(Y|ψ)` — conditional inclusion, source left. Arity mismatch
+ * between the two faces is a type error ({@link SameArity}); a structurally
+ * mismatched pair is a type error ({@link SameShapes} — positionwise
+ * equality of the projected kind/width/element triples). The target side
+ * must resolve a declared key of B — a SEMANTIC property of the whole
+ * statement set that no face type can state, DELIBERATELY judged by the
  * engine at `Db.create`/`Db.open` (`SchemaError`), never re-checked here.
- * Arity mismatch between the two faces is a type error ({@link SameArity}).
  */
-function contained<A extends AnyFace, B extends AnyFace>(source: A, target: B & SameArity<A, B>): Statement {
-	const data: StatementData = Object.freeze({
+function contained<A extends AnyFace, B extends AnyFace>(
+	source: A,
+	target: B & SameArity<A, B> & SameShapes<A, B>
+): ContainedStatement<A["data"], B["data"]> {
+	const data: ContainmentData<A["data"], B["data"]> = Object.freeze({
 		kind: "containment",
 		source: source.data,
 		target: target.data,
@@ -89,12 +149,19 @@ function contained<A extends AnyFace, B extends AnyFace>(source: A, target: B &
 }
 
 /**
- * `A(X|φ) == B(Y|ψ)` — the bidirectional abbreviation, one utterance. It
- * lowers to the two adjacent containments in the `A <= B` first order
- * (macro parity) and renders as `==` once, in the written orientation.
+ * `A(X|φ) == B(Y|ψ)` — the bidirectional abbreviation, one utterance: the
+ * selected `==` bijection, a keyed one-to-one correspondence between the
+ * two faces (each side contains the other). It lowers to the two adjacent
+ * containments in the `A <= B` first order (macro parity — the engine
+ * performs the split, source-first) and renders as `==` once, in the
+ * written orientation. Faces pair by arity AND structural shape, exactly
+ * as {@link contained}.
  */
-function mirrors<A extends AnyFace, B extends AnyFace>(source: A, target: B & SameArity<A, B>): Statement {
-	const data: StatementData = Object.freeze({
+function mirrors<A extends AnyFace, B extends AnyFace>(
+	source: A,
+	target: B & SameArity<A, B> & SameShapes<A, B>
+): ContainedStatement<A["data"], B["data"]> {
+	const data: ContainmentData<A["data"], B["data"]> = Object.freeze({
 		kind: "containment",
 		source: source.data,
 		target: target.data,
@@ -108,10 +175,17 @@ function mirrors<A extends AnyFace, B extends AnyFace>(source: A, target: B & Sa
  * LEFT face is the window's TARGET, the per-group parent (B-family,
  * target-left — macro parity), and the RIGHT face is the counted source.
  * `window(on(Holder, "id"), atMost(3n), on(Account, "holder"))` says: each
- * Holder id groups at most three Account rows by holder.
+ * Holder id groups at most three Account rows by holder. The two faces
+ * pair by arity AND structural shape ({@link SameShapes}), exactly as
+ * containment — the grouping join reads the same positionwise field
+ * pairing.
  */
-function window<B extends AnyFace, A extends AnyFace>(target: B, count: Count, source: A & SameArity<B, A>): Statement {
-	const data: StatementData = Object.freeze({
+function window<B extends AnyFace, A extends AnyFace>(
+	target: B,
+	count: Count,
+	source: A & SameArity<B, A> & SameShapes<B, A>
+): WindowStatement<B["data"], A["data"]> {
+	const data: WindowData<B["data"], A["data"]> = Object.freeze({
 		kind: "window",
 		target: target.data,
 		window: count.window,
@@ -144,5 +218,14 @@ function renderStatement(statement: Statement): string {
 	}
 }
 
-export type { KeyStatement, Statement, StatementData }
+export type {
+	ContainedStatement,
+	ContainmentData,
+	KeyData,
+	KeyStatement,
+	Statement,
+	StatementData,
+	WindowData,
+	WindowStatement
+}
 export { contained, key, mirrors, renderStatement, window }

package/dist/brand.d.ts

@@ -1,59 +0,0 @@
-/**
- * Nominal branding — the TS analog of the Rust macro's host newtypes
- * (`docs/architecture/10-data-model.md`, the nominal-safety layer). A brand
- * is a phantom: it exists only in the type, tsc polices the wall exactly as
- * rustc polices newtype domains, and nothing is allocated or wrapped at
- * runtime.
- */
-/**
- * The brand key. A real runtime symbol (so modules can import it without a
- * `declare`-only lie), but no branded value ever carries the property — the
- * brand is purely a typing device.
- */
-declare const brand: unique symbol;
-/**
- * The phantom-value key used by field values, field references, and faces
- * to carry their value type without any runtime representation.
- */
-declare const phantom: unique symbol;
-/**
- * A branded scalar: `T` walled off under the literal name `Name`. A
- * `Brand<bigint, "HolderId">` is not assignable where a
- * `Brand<bigint, "AccountId">` is expected — the Rust newtype wall,
- * verbatim. Scalars brand as `bigint` (u64/i64), `Uint8Array` (bytes), and
- * whole interval objects (`Interval<Name>`); `bool` and `str` take no
- * newtype, exactly as the macro's `as` grammar refuses them.
- */
-type Brand<T, Name extends string> = T & {
-    readonly [brand]: Name;
-};
-/**
- * A half-open interval `[start, end)` as a plain value object. The ray is
- * representable (`end` = the element domain's MAX_END); widths and
- * signedness are NOT modeled here — the engine judges widths at the typed
- * write boundary, the brand blocks cross-field assignment, and nothing
- * else is TS's business. Interval newtypes derive no order (the Rust
- * refusal, `docs/architecture/10-data-model.md`), so no comparators exist.
- */
-interface IntervalValue {
-    readonly start: bigint;
-    readonly end: bigint;
-}
-/**
- * A branded interval: the whole `{ start, end }` object walled under
- * `Name` — the `interval<i64> as ActiveDuring` analog.
- */
-type Interval<Name extends string> = Brand<IntervalValue, Name>;
-/**
- * Constructs an interval literal — the `start..end` spelling. Half-open
- * and nonempty by construction: `start >= end` is a typed construction
- * error (parse, don't validate — the same invariant Rust's
- * `Interval::new` enforces at the host boundary). The default `never`
- * brand makes a fresh literal assignable to any interval field or brand,
- * the wrap-at-construction idiom; pass the brand explicitly
- * (`span<"ActiveDuring">(0n, 10n)`) to pin it.
- */
-declare function span<Name extends string = never>(start: bigint, end: bigint): Interval<Name>;
-export type { Brand, Interval, IntervalValue };
-export { brand, phantom, span };
-//# sourceMappingURL=brand.d.ts.map

package/dist/brand.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"brand.d.ts","sourceRoot":"","sources":["../src/brand.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAeH;;;;GAIG;AACH,QAAA,MAAM,KAAK,EAAE,OAAO,MAAiC,CAAA;AAErD;;;GAGG;AACH,QAAA,MAAM,OAAO,EAAE,OAAO,MAAmC,CAAA;AAEzD;;;;;;;GAOG;AACH,KAAK,KAAK,CAAC,CAAC,EAAE,IAAI,SAAS,MAAM,IAAI,CAAC,GAAG;IAAE,QAAQ,CAAC,CAAC,KAAK,CAAC,EAAE,IAAI,CAAA;CAAE,CAAA;AAEnE;;;;;;;GAOG;AACH,UAAU,aAAa;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CACpB;AAED;;;GAGG;AACH,KAAK,QAAQ,CAAC,IAAI,SAAS,MAAM,IAAI,KAAK,CAAC,aAAa,EAAE,IAAI,CAAC,CAAA;AAE/D;;;;;;;;GAQG;AACH,iBAAS,IAAI,CAAC,IAAI,SAAS,MAAM,GAAG,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAC,IAAI,CAAC,CAMrF;AAED,YAAY,EAAE,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,CAAA;AAC9C,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,CAAA"}

package/dist/brand.js

@@ -1,47 +0,0 @@
-/**
- * Nominal branding — the TS analog of the Rust macro's host newtypes
- * (`docs/architecture/10-data-model.md`, the nominal-safety layer). A brand
- * is a phantom: it exists only in the type, tsc polices the wall exactly as
- * rustc polices newtype domains, and nothing is allocated or wrapped at
- * runtime.
- */
-import * as errors from "@superbuilders/errors";
-/**
- * The brand-minting guard behind {@link span} — the one nominal step, as a
- * type guard carrying the interval's REAL invariant (`start < end`, the
- * same check Rust's `Interval::new` runs): a value that passes IS a legal
- * interval of any brand, exactly as a Rust newtype wraps a checked
- * `Interval<T>` at construction.
- */
-function isNonemptyInterval(value) {
-    return value.start < value.end;
-}
-/**
- * The brand key. A real runtime symbol (so modules can import it without a
- * `declare`-only lie), but no branded value ever carries the property — the
- * brand is purely a typing device.
- */
-const brand = Symbol("bumbledb.brand");
-/**
- * The phantom-value key used by field values, field references, and faces
- * to carry their value type without any runtime representation.
- */
-const phantom = Symbol("bumbledb.phantom");
-/**
- * Constructs an interval literal — the `start..end` spelling. Half-open
- * and nonempty by construction: `start >= end` is a typed construction
- * error (parse, don't validate — the same invariant Rust's
- * `Interval::new` enforces at the host boundary). The default `never`
- * brand makes a fresh literal assignable to any interval field or brand,
- * the wrap-at-construction idiom; pass the brand explicitly
- * (`span<"ActiveDuring">(0n, 10n)`) to pin it.
- */
-function span(start, end) {
-    const value = Object.freeze({ start, end });
-    if (!isNonemptyInterval(value)) {
-        throw errors.new(`interval is half-open and nonempty: start must be < end (got ${start}..${end})`);
-    }
-    return value;
-}
-export { brand, phantom, span };
-//# sourceMappingURL=brand.js.map

package/dist/brand.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"brand.js","sourceRoot":"","sources":["../src/brand.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,MAAM,MAAM,uBAAuB,CAAA;AAE/C;;;;;;GAMG;AACH,SAAS,kBAAkB,CAAsB,KAAoB;IACpE,OAAO,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,GAAG,CAAA;AAC/B,CAAC;AAED;;;;GAIG;AACH,MAAM,KAAK,GAAkB,MAAM,CAAC,gBAAgB,CAAC,CAAA;AAErD;;;GAGG;AACH,MAAM,OAAO,GAAkB,MAAM,CAAC,kBAAkB,CAAC,CAAA;AA+BzD;;;;;;;;GAQG;AACH,SAAS,IAAI,CAA8B,KAAa,EAAE,GAAW;IACpE,MAAM,KAAK,GAAkB,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAA;IAC1D,IAAI,CAAC,kBAAkB,CAAO,KAAK,CAAC,EAAE,CAAC;QACtC,MAAM,MAAM,CAAC,GAAG,CAAC,gEAAgE,KAAK,KAAK,GAAG,GAAG,CAAC,CAAA;IACnG,CAAC;IACD,OAAO,KAAK,CAAA;AACb,CAAC;AAGD,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,CAAA"}

package/src/brand.ts

@@ -1,82 +0,0 @@
-/**
- * Nominal branding — the TS analog of the Rust macro's host newtypes
- * (`docs/architecture/10-data-model.md`, the nominal-safety layer). A brand
- * is a phantom: it exists only in the type, tsc polices the wall exactly as
- * rustc polices newtype domains, and nothing is allocated or wrapped at
- * runtime.
- */
-
-import * as errors from "@superbuilders/errors"
-
-/**
- * The brand-minting guard behind {@link span} — the one nominal step, as a
- * type guard carrying the interval's REAL invariant (`start < end`, the
- * same check Rust's `Interval::new` runs): a value that passes IS a legal
- * interval of any brand, exactly as a Rust newtype wraps a checked
- * `Interval<T>` at construction.
- */
-function isNonemptyInterval<Name extends string>(value: IntervalValue): value is Interval<Name> {
-	return value.start < value.end
-}
-
-/**
- * The brand key. A real runtime symbol (so modules can import it without a
- * `declare`-only lie), but no branded value ever carries the property — the
- * brand is purely a typing device.
- */
-const brand: unique symbol = Symbol("bumbledb.brand")
-
-/**
- * The phantom-value key used by field values, field references, and faces
- * to carry their value type without any runtime representation.
- */
-const phantom: unique symbol = Symbol("bumbledb.phantom")
-
-/**
- * A branded scalar: `T` walled off under the literal name `Name`. A
- * `Brand<bigint, "HolderId">` is not assignable where a
- * `Brand<bigint, "AccountId">` is expected — the Rust newtype wall,
- * verbatim. Scalars brand as `bigint` (u64/i64), `Uint8Array` (bytes), and
- * whole interval objects (`Interval<Name>`); `bool` and `str` take no
- * newtype, exactly as the macro's `as` grammar refuses them.
- */
-type Brand<T, Name extends string> = T & { readonly [brand]: Name }
-
-/**
- * A half-open interval `[start, end)` as a plain value object. The ray is
- * representable (`end` = the element domain's MAX_END); widths and
- * signedness are NOT modeled here — the engine judges widths at the typed
- * write boundary, the brand blocks cross-field assignment, and nothing
- * else is TS's business. Interval newtypes derive no order (the Rust
- * refusal, `docs/architecture/10-data-model.md`), so no comparators exist.
- */
-interface IntervalValue {
-	readonly start: bigint
-	readonly end: bigint
-}
-
-/**
- * A branded interval: the whole `{ start, end }` object walled under
- * `Name` — the `interval<i64> as ActiveDuring` analog.
- */
-type Interval<Name extends string> = Brand<IntervalValue, Name>
-
-/**
- * Constructs an interval literal — the `start..end` spelling. Half-open
- * and nonempty by construction: `start >= end` is a typed construction
- * error (parse, don't validate — the same invariant Rust's
- * `Interval::new` enforces at the host boundary). The default `never`
- * brand makes a fresh literal assignable to any interval field or brand,
- * the wrap-at-construction idiom; pass the brand explicitly
- * (`span<"ActiveDuring">(0n, 10n)`) to pin it.
- */
-function span<Name extends string = never>(start: bigint, end: bigint): Interval<Name> {
-	const value: IntervalValue = Object.freeze({ start, end })
-	if (!isNonemptyInterval<Name>(value)) {
-		throw errors.new(`interval is half-open and nonempty: start must be < end (got ${start}..${end})`)
-	}
-	return value
-}
-
-export type { Brand, Interval, IntervalValue }
-export { brand, phantom, span }