@bjornpagen/bumbledb 0.6.0 → 0.8.0

package/src/spec.ts

@@ -72,10 +72,10 @@ type LiteralSetSpec =
 	| { readonly kind: "many"; readonly literals: readonly LiteralSpec[] }
 
 /**
- * One side of a containment or window: `R(fields… | field == literal…)`,
- * all names. `projection` is π in the statement's written order (positional
- * pairing with the other side); `selection` is σ as (field, literal-or-set)
- * pairs, read conjunctively.
+ * One side of a containment or capacity statement:
+ * `R(fields… | field == literal…)`, all names. `projection` is π in the
+ * statement's written order (positional pairing with the other side);
+ * `selection` is σ as (field, literal-or-set) pairs, read conjunctively.
  */
 interface SideSpec {
 	readonly relation: string
@@ -84,16 +84,43 @@ interface SideSpec {
 }
 
 /**
- * A cardinality window's bounds — the canonical-utterance law's surviving
- * spellings only, since the SDK's `Count` constructors make every banned
- * spelling unwritable or a construction error: `exact` is `{n}` (`{0}` the
- * exclusion), `range` is `{lo..hi}` with lo < hi, `floor` is `{lo..*}` with
- * lo ≥ 2.
+ * One capacity bound: a non-negative literal, a u64 field of the TARGET
+ * row (the dependent bound — per-group capacity read at judge time), or
+ * the interval-measure of a TARGET-row field (`Duration(span)`). Names,
+ * not ids — the spec is the name-level wire; the engine resolves bound
+ * names against the target's FULL roster (C1), never the projection.
  */
-type WindowSpec =
-	| { readonly kind: "exact"; readonly n: bigint }
-	| { readonly kind: "range"; readonly lo: bigint; readonly hi: bigint }
-	| { readonly kind: "floor"; readonly lo: bigint }
+type CapacityBoundSpec =
+	| { readonly kind: "lit"; readonly value: bigint }
+	| { readonly kind: "field"; readonly field: string }
+	| { readonly kind: "durationField"; readonly field: string }
+
+/**
+ * A capacity statement's weight — a TOTAL sum (C4: `unit` is a case, not
+ * an absence): the count instance (`unit`), a u64 field of the SOURCE row
+ * (`field`), or a SOURCE-row interval's measure (`durationField`). The
+ * wire always carries it — a unit statement crosses as `{ kind: "unit" }`,
+ * never by omission.
+ */
+type WeightSpec =
+	| { readonly kind: "unit" }
+	| { readonly kind: "field"; readonly field: string }
+	| { readonly kind: "durationField"; readonly field: string }
+
+/**
+ * A capacity statement's window — the canonical-utterance law's surviving
+ * spellings, per-aggregate where weight-sensitive (design § 6), since the
+ * SDK's `within()` mint makes every banned spelling unwritable or a
+ * construction error: `exact` is `{n}` (`{0}` the exclusion on the unit
+ * instance, "total is zero" on a weighted one), `range` is `{lo..hi}` with
+ * lo < hi (`{0..hi}` the canonical ceiling; the hi slot admits a dependent
+ * bound — C6: hi only), `floor` is `{lo..*}` (`{1..*}` legal on weighted
+ * statements only).
+ */
+type CapacityWindowSpec =
+	| { readonly kind: "exact"; readonly n: CapacityBoundSpec }
+	| { readonly kind: "range"; readonly lo: CapacityBoundSpec; readonly hi: CapacityBoundSpec }
+	| { readonly kind: "floor"; readonly lo: CapacityBoundSpec }
 
 /**
  * One field: name, structural type, host newtype name — the field's
@@ -118,27 +145,40 @@ interface RowSpec {
 }
 
 /**
- * One relation. `extension: rows` declares it closed (the option is the
- * 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 emits the id's law-computed generator class,
- * `` `${name}.id` `` — the same label every referencing field carries by
- * law), undefined on an ordinary one.
+ * A relation's closedness as ONE sum (ruled 2026-07-23, R7): the handle
+ * newtype and the ground axioms travel together — the two illegal states
+ * (a roster without its newtype, a newtype without its roster) are
+ * unspellable on the wire exactly as they are unrepresentable in the
+ * fused Rust `RelationSpec`. `newtype` is the id's law-computed generator
+ * class (`` `${name}.id` `` — the same label every referencing field
+ * carries by law), which is how the engine resolves a handle literal back
+ * to its roster.
+ */
+interface ClosedSpec {
+	readonly newtype: string
+	readonly rows: readonly RowSpec[]
+}
+
+/**
+ * One relation. A present `closed` declares it closed (the option is the
+ * kind, one sum — R7); 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.
  */
 interface RelationSpec {
 	readonly name: string
-	readonly newtype: string | undefined
 	readonly fields: readonly FieldSpec[]
-	readonly extension: readonly RowSpec[] | undefined
+	readonly closed: ClosedSpec | undefined
 }
 
 /**
  * One dependency statement, tagged by form. `==` is not a variant: a
  * bidirectional containment is `containment` with `bidirectional: true`,
  * lowered by the engine to the two adjacent containments (`source <=
- * target` first). `cardinality` is B-family, target-left: the target is the
- * per-group parent, the source is counted.
+ * target` first). `capacity` reads as the operator does (C2 — target,
+ * weight, window, source): the target is the per-group parent, the source
+ * is the weighed side, and the weight is ALWAYS present (`unit` the count
+ * instance).
  */
 type StatementSpec =
 	| { readonly kind: "fd"; readonly relation: string; readonly projection: readonly string[] }
@@ -149,9 +189,10 @@ type StatementSpec =
 			readonly bidirectional: boolean
 	  }
 	| {
-			readonly kind: "cardinality"
+			readonly kind: "capacity"
 			readonly target: SideSpec
-			readonly window: WindowSpec
+			readonly weight: WeightSpec
+			readonly window: CapacityWindowSpec
 			readonly source: SideSpec
 	  }
 
@@ -297,22 +338,59 @@ function renderLiteralSet(set: LiteralSetSpec): string {
 }
 
 /**
- * Renders window bounds in their one canonical spelling: `{n}` exact
+ * Renders one capacity bound in its one canonical spelling: a literal as
+ * digits, a dependent bound bare by field name, an interval-measure bound
+ * as `Duration(field)` — the spellings the engine's renderer emits.
+ */
+function renderCapacityBound(bound: CapacityBoundSpec): string {
+	switch (bound.kind) {
+		case "lit":
+			return bound.value.toString()
+		case "field":
+			return bound.field
+		case "durationField":
+			return `Duration(${bound.field})`
+	}
+}
+
+/**
+ * Renders a capacity window in its one canonical spelling: `{n}` exact
  * (`{0}` the exclusion), `{lo..hi}`, `{lo..*}` — the spelling set the
- * engine's renderer emits for sealed statements.
+ * engine's renderer emits for sealed statements, bounds through
+ * {@link renderCapacityBound}.
  */
-function renderWindow(window: WindowSpec): string {
+function renderCapacityWindow(window: CapacityWindowSpec): string {
 	switch (window.kind) {
 		case "exact":
-			return `{${window.n}}`
+			return `{${renderCapacityBound(window.n)}}`
 		case "range":
-			return `{${window.lo}..${window.hi}}`
+			return `{${renderCapacityBound(window.lo)}..${renderCapacityBound(window.hi)}}`
 		case "floor":
-			return `{${window.lo}..*}`
+			return `{${renderCapacityBound(window.lo)}..*}`
+	}
+}
+
+/**
+ * Renders a capacity weight as the operator's bracket: the unit weight
+ * renders NOTHING — the count utterance `<={lo..hi}` falls out of the one
+ * printer, never a second "legacy" arm — a field weight as `[field]`, an
+ * interval measure as `[Duration(field)]`.
+ */
+function renderWeight(weight: WeightSpec): string {
+	switch (weight.kind) {
+		case "unit":
+			return ""
+		case "field":
+			return `[${weight.field}]`
+		case "durationField":
+			return `[Duration(${weight.field})]`
 	}
 }
 
 export type {
+	CapacityBoundSpec,
+	CapacityWindowSpec,
+	ClosedSpec,
 	FieldSpec,
 	LiteralSetSpec,
 	LiteralSpec,
@@ -323,6 +401,6 @@ export type {
 	StatementSpec,
 	ValueSpec,
 	ValueTypeSpec,
-	WindowSpec
+	WeightSpec
 }
-export { renderLiteral, renderLiteralSet, renderWindow }
+export { renderCapacityBound, renderCapacityWindow, renderLiteral, renderLiteralSet, renderWeight }

package/src/statements.ts

@@ -2,7 +2,7 @@
  * Dependency statements as typed values (`docs/architecture/30-dependencies.md`
  * owns the semantics; `docs/architecture/70-api.md` the surface): the FD key
  * form, conditional containment, the bidirectional `==` abbreviation, and
- * the cardinality window. A statement value is opaque and inert — no
+ * the capacity statement. 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
@@ -35,12 +35,21 @@
  */
 
 import * as errors from "@superbuilders/errors"
+import {
+	type BoundsOnTarget,
+	type CapacityWeight,
+	type CapacityWindow,
+	isCapacityWeight,
+	isCapacityWindow,
+	type UnitWindowBan,
+	unitWeight,
+	type WeightOnSource
+} from "#capacity.ts"
 import { isClosedMember, sealedFieldOf } from "#closed.ts"
-import type { Count } from "#count.ts"
 import { type AnyFace, type FaceData, renderFace, type SameArity, type SameShapes } from "#face.ts"
 import { type ClosedRoster, rosterOf } from "#fields.ts"
 import type { AnyRelation, RelationFields } from "#relation.ts"
-import { renderWindow, type WindowSpec } from "#spec.ts"
+import { type CapacityWindowSpec, renderCapacityWindow, renderWeight, type WeightSpec } 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[]> {
@@ -63,20 +72,50 @@ interface ContainmentData<Src extends FaceData = FaceData, Tgt extends FaceData
 	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"
+/**
+ * A capacity statement's runtime description — target-left, in the
+ * operator's own order (C2: target, weight, window, source), faces at
+ * exact types like {@link ContainmentData}. The weight is ALWAYS present
+ * (C4 — `unit` is a case, not an absence).
+ */
+interface CapacityData<Tgt extends FaceData = FaceData, Src extends FaceData = FaceData> {
+	readonly kind: "capacity"
 	readonly target: Tgt
-	readonly window: WindowSpec
+	readonly weight: WeightSpec
+	readonly window: CapacityWindowSpec
 	readonly source: Src
 }
 
 /** One statement's runtime description, tagged by form. */
-type StatementData = KeyData<AnyRelation, readonly string[]> | ContainmentData | WindowData
+type StatementData = KeyData<AnyRelation, readonly string[]> | ContainmentData | CapacityData
 
-/** An opaque statement value — what `schema()` assembles into a theory. */
+/**
+ * The admission brand — a module-private symbol, deliberately unexported
+ * (the `capacity.ts` pattern): `Statement` is a public structural type, so
+ * without this brand a forged plain object of the right shape would walk
+ * past the construction-time arity and roster walls into `schema()` — and
+ * the roster wall is the one the engine cannot backstop (the wire carries
+ * plain u64s, no rosters). The symbol makes the four constructors the ONLY
+ * mints, so a statement that skipped the walls is unspellable.
+ */
+const admitted: unique symbol = Symbol("bumbledb.statement.admitted")
+
+/** An opaque statement value — what `schema()` assembles into a theory. Only the four constructors produce one. */
 interface Statement {
 	readonly data: StatementData
+	readonly [admitted]: true
+}
+
+/**
+ * Narrows any value to an admitted statement — the probe is the
+ * module-private {@link admitted} brand only the four constructors set, so
+ * no host-built value (fact cells are structurally OPEN — an interval with
+ * an excess `kind` property is a legal cell) can ever be misread as one.
+ * The keyed-get selector dispatch and `schema()`'s admission both judge
+ * through here.
+ */
+function isStatement(value: unknown): value is Statement {
+	return typeof value === "object" && value !== null && admitted in value
 }
 
 /**
@@ -91,9 +130,9 @@ interface ContainedStatement<Src extends FaceData, Tgt extends FaceData> extends
 	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 capacity statement as a TYPED value — the {@link ContainedStatement} of the capacity form. */
+interface CapacityStatement<Tgt extends FaceData, Src extends FaceData> extends Statement {
+	readonly data: CapacityData<Tgt, Src>
 }
 
 /**
@@ -188,7 +227,7 @@ function key<
 		owner: relation,
 		projection: Object.freeze(fields)
 	})
-	return Object.freeze({ data })
+	return Object.freeze({ data, [admitted]: true as const })
 }
 
 /**
@@ -210,7 +249,7 @@ function contained<A extends AnyFace, B extends AnyFace>(
 		target: target.data,
 		bidirectional: false
 	})
-	const statement = Object.freeze({ data })
+	const statement = Object.freeze({ data, [admitted]: true as const })
 	assertArityAgreement(data.source, data.target, statement)
 	assertRosterAgreement(data.source, data.target, statement)
 	return statement
@@ -235,36 +274,145 @@ function mirrors<A extends AnyFace, B extends AnyFace>(
 		target: target.data,
 		bidirectional: true
 	})
-	const statement = Object.freeze({ data })
+	const statement = Object.freeze({ data, [admitted]: true as const })
 	assertArityAgreement(data.source, data.target, statement)
 	assertRosterAgreement(data.source, data.target, statement)
 	return statement
 }
 
 /**
- * `B(Y|ψ) <={window} A(X|φ)` — the cardinality window. READ CAREFULLY: the
- * 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. The two faces
- * pair by arity AND structural shape ({@link SameShapes}), exactly as
- * containment — the grouping join reads the same positionwise field
- * pairing.
+ * The runtime twin of the weight source wall ({@link WeightOnSource}): the
+ * weighed field must be a u64-encoded position of the SOURCE's own row
+ * (a signed weight would break the polarity scheduler — the illegal weight
+ * is unrepresentable, not checked), an interval position for the
+ * `Duration(...)` form. Judged at CONSTRUCTION for untyped callers; the
+ * engine's `validate_capacity` stays the final authority.
+ */
+function assertWeightOnSource(weight: WeightSpec, source: FaceData, statement: Statement): void {
+	if (weight.kind === "unit") {
+		return
+	}
+	const field = sealedFieldOf(source.owner, weight.field)
+	if (field === undefined) {
+		throw errors.new(
+			`${source.owner.name} has no field ${weight.field} — a weight names a field of the SOURCE's own row (the weight vocabulary is closed at the row) — ${renderStatement(statement)}`
+		)
+	}
+	if (weight.kind === "field" && field.kind !== "u64") {
+		throw errors.new(
+			`${source.owner.name}.${weight.field} is ${field.kind}, not u64 — a weight is u64-encoded (a signed weight would break the polarity scheduler: an insert could lower a sum) — ${renderStatement(statement)}`
+		)
+	}
+	if (weight.kind === "durationField" && field.kind !== "interval") {
+		throw errors.new(
+			`${source.owner.name}.${weight.field} is ${field.kind}, not an interval — Duration(...) weighs an interval field's measure — ${renderStatement(statement)}`
+		)
+	}
+}
+
+/**
+ * The runtime twin of the dependent-bound target wall
+ * ({@link BoundsOnTarget}): a `ref()` bound must name a u64 field of the
+ * TARGET's own row, a `duration()` bound an interval field — bound names
+ * resolve against the target's FULL roster (C1), never the projection.
+ * `within()` mints dependent bounds in the hi slot only (C6), but the walk
+ * here is total over the window's bound slots.
+ */
+function assertBoundsOnTarget(window: CapacityWindowSpec, target: FaceData, statement: Statement): void {
+	const bounds = window.kind === "range" ? [window.lo, window.hi] : [window.kind === "exact" ? window.n : window.lo]
+	for (const bound of bounds) {
+		if (bound.kind === "lit") {
+			continue
+		}
+		const field = sealedFieldOf(target.owner, bound.field)
+		if (field === undefined) {
+			throw errors.new(
+				`${target.owner.name} has no field ${bound.field} — a dependent bound names a field of the TARGET's own row (bound names resolve against the target's full roster) — ${renderStatement(statement)}`
+			)
+		}
+		if (bound.kind === "field" && field.kind !== "u64") {
+			throw errors.new(
+				`${target.owner.name}.${bound.field} is ${field.kind}, not u64 — a dependent bound reads a u64 field of the TARGET row (Duration(...) is the interval-measure spelling) — ${renderStatement(statement)}`
+			)
+		}
+		if (bound.kind === "durationField" && field.kind !== "interval") {
+			throw errors.new(
+				`${target.owner.name}.${bound.field} is ${field.kind}, not an interval — Duration(...) bounds by an interval field's measure — ${renderStatement(statement)}`
+			)
+		}
+	}
+}
+
+/**
+ * `B(Y|ψ) <=[w]{window} A(X|φ)` — the capacity statement, the one
+ * extension form: per ψ-selected target fact, the group of φ-selected
+ * source facts sharing its key tuple must have its MEASURE (Σ weight; the
+ * unit weight IS the count instance) inside the window. READ CAREFULLY:
+ * the LEFT face is the TARGET, the per-group parent (B-family, target-left
+ * — macro parity), and the RIGHT face is the weighed source. Two
+ * overloads mirror the operator positionally (target, weight?, window,
+ * source): `capacity(on(Holder, "id"), within(0n, 3n), on(Account,
+ * "holder"))` says each Holder id groups at most three Account rows;
+ * `capacity(on(Pool, "id"), weigh("watts"), within(0n, ref("supply")),
+ * on(Device, "pool"))` bounds each pool's summed draw by the pool's own
+ * row. The two faces pair by arity AND structural shape
+ * ({@link SameShapes}), exactly as containment — the grouping join reads
+ * the same positionwise field pairing. The weight-sensitive `{1..*}` ban
+ * rides the UNIT overload only ({@link UnitWindowBan} — on a weighted
+ * statement "positive total" is a different, weaker law than containment).
  */
-function window<B extends AnyFace, A extends AnyFace>(
+function capacity<B extends AnyFace, W extends CapacityWindow, A extends AnyFace>(
 	target: B,
-	count: Count,
+	window: W & UnitWindowBan<W> & BoundsOnTarget<W, B>,
 	source: A & SameArity<B, A> & SameShapes<B, A>
-): WindowStatement<B["data"], A["data"]> {
-	const data: WindowData<B["data"], A["data"]> = Object.freeze({
-		kind: "window",
+): CapacityStatement<B["data"], A["data"]>
+function capacity<B extends AnyFace, M extends CapacityWeight, W extends CapacityWindow, A extends AnyFace>(
+	target: B,
+	weight: M & WeightOnSource<M, A>,
+	window: W & BoundsOnTarget<W, B>,
+	source: A & SameArity<B, A> & SameShapes<B, A>
+): CapacityStatement<B["data"], A["data"]>
+function capacity(
+	target: AnyFace,
+	second: unknown,
+	third: unknown,
+	fourth?: AnyFace
+): CapacityStatement<FaceData, FaceData> {
+	const weighted = fourth !== undefined
+	const windowValue = weighted ? third : second
+	const source = weighted ? fourth : (third as AnyFace)
+	if (!isCapacityWindow(windowValue)) {
+		throw errors.new(
+			"a capacity window is minted only by within() — a structural literal skips the ban table (the canonical-utterance law)"
+		)
+	}
+	let weight: WeightSpec = unitWeight
+	if (weighted) {
+		if (!isCapacityWeight(second)) {
+			throw errors.new(
+				"a capacity weight is minted only by weigh() — a structural literal skips the row-local weight wall"
+			)
+		}
+		weight = second.weight
+	}
+	const window = windowValue.window
+	if (weight.kind === "unit" && window.kind === "floor" && window.lo.kind === "lit" && window.lo.value === 1n) {
+		throw errors.new(
+			"`{1..*}` on the unit instance says only what the bare containment says — drop the annotation and write the containment: contained(source, target)"
+		)
+	}
+	const data: CapacityData = Object.freeze({
+		kind: "capacity",
 		target: target.data,
-		window: count.window,
+		weight,
+		window,
 		source: source.data
 	})
-	const statement = Object.freeze({ data })
+	const statement = Object.freeze({ data, [admitted]: true as const })
 	assertArityAgreement(data.source, data.target, statement)
 	assertRosterAgreement(data.source, data.target, statement)
+	assertWeightOnSource(weight, data.source, statement)
+	assertBoundsOnTarget(window, data.target, statement)
 	return statement
 }
 
@@ -274,9 +422,11 @@ function window<B extends AnyFace, A extends AnyFace>(
  * same shapes for violations) — `Account(id) -> Account`,
  * `Account(holder) <= Holder(id)`,
  * `Account(id | kind == Savings) == SavingsTerms(account)`,
- * `Holder(id) <={0..3} Account(holder)` — so TS-side errors and
+ * `Holder(id) <={0..3} Account(holder)`,
+ * `Pool(id) <=[watts]{0..supply} Device(pool)` — so TS-side errors and
  * engine-side diagnostics read identically. A renderer, never a parser:
- * strings are output-only.
+ * strings are output-only. The unit weight renders nothing — the count
+ * utterance falls out of the one printer.
  */
 function renderStatement(statement: Statement): string {
 	const data = statement.data
@@ -287,19 +437,19 @@ function renderStatement(statement: Statement): string {
 			const operator = data.bidirectional ? "==" : "<="
 			return `${renderFace(data.source)} ${operator} ${renderFace(data.target)}`
 		}
-		case "window":
-			return `${renderFace(data.target)} <=${renderWindow(data.window)} ${renderFace(data.source)}`
+		case "capacity":
+			return `${renderFace(data.target)} <=${renderWeight(data.weight)}${renderCapacityWindow(data.window)} ${renderFace(data.source)}`
 	}
 }
 
 export type {
+	CapacityData,
+	CapacityStatement,
 	ContainedStatement,
 	ContainmentData,
 	KeyData,
 	KeyStatement,
 	Statement,
-	StatementData,
-	WindowData,
-	WindowStatement
+	StatementData
 }
-export { contained, key, mirrors, renderStatement, window }
+export { capacity, contained, isStatement, key, mirrors, renderStatement }

package/dist/count.d.ts

@@ -1,102 +0,0 @@
-/**
- * Cardinality-window counts — exactly five constructors, and nothing else
- * (`docs/architecture/70-api.md` § the canonical-utterance law). The five
- * constructors PARTITION the legal windows, and the ban table is enforced
- * REPRESENTATIONALLY, stronger than Rust's expansion errors, in two tiers:
- *
- * - **The type tier**: a banned spelling written as a LITERAL does not
- *   compile — `exactly(0n)`, `between(n, n)`, `between(0n, hi)`,
- *   `atLeast(0n)`, `atLeast(1n)`, `atMost(0n)`, and every negative bound
- *   are type errors naming the canonical form (`{n..n}`, `{0..0}`,
- *   `{0..hi}`-via-between, `{0..*}`, `{1..*}` have NO argument shape that
- *   produces them), and no sixth constructor exists at all.
- * - **The construction tier**: a bound the type level cannot judge — a
- *   COMPUTED `bigint`, whose literal identity is erased, or an inverted
- *   `between(lo, hi)` order, which type-level bigints cannot compare — is
- *   judged here at construction with the same canonical-naming errors; and
- *   past both tiers the engine's own spec validation remains the law for a
- *   hostile FFI caller (the standing two-tier ban enforcement).
- *
- * Bounds are `bigint` (u64 crosses as bigint always, PRD-04's law).
- */
-import type { WindowSpec } from "#spec.ts";
-/**
- * The admission brand — a module-private symbol, deliberately unexported:
- * `WindowSpec` is a public wire type, so without this brand every banned
- * spelling in the ban table would be writable as a plain object literal
- * (`{ window: { kind: "floor", lo: 1n } }` typechecks structurally). The
- * symbol makes the five constructors the ONLY producers of a `Count`
- * value, which is what "the ban table is unwritable" means.
- */
-declare const admitted: unique symbol;
-/**
- * An admitted window count — opaque and inert: a fact about the theory,
- * not a builder. Only the five constructors below produce one (the
- * module-private {@link admitted} brand forecloses structural literals).
- */
-interface Count {
-    readonly window: WindowSpec;
-    readonly [admitted]: true;
-}
-/**
- * The legible banned-spelling verdict: intersected into a count
- * constructor's parameter when the LITERAL argument spells a banned window,
- * naming the canonical form — the compile-time face of the ban table.
- */
-interface BannedWindow<Canonical extends string> {
-    readonly "banned window spelling — the canonical-utterance law names the one legal form": Canonical;
-}
-/** `true` exactly when the literal bigint `N` is negative (out of the u64 count domain). */
-type IsNegative<N extends bigint> = `${N}` extends `-${string}` ? true : false;
-/** The ban verdict on `exactly(n)`: negatives are out of domain; `{0}` is the exclusion, written `none`. */
-type ExactlyBan<N extends bigint> = bigint extends N ? unknown : IsNegative<N> extends true ? BannedWindow<"window counts are u64 — a negative count is out of domain"> : N extends 0n ? BannedWindow<"`{0}` is the exclusion — write none"> : unknown;
-/** The ban verdict on `atLeast(lo)`: `{0..*}` is vacuous; `{1..*}` is the bare containment respelled. */
-type AtLeastBan<N extends bigint> = bigint extends N ? unknown : IsNegative<N> extends true ? BannedWindow<"window counts are u64 — a negative count is out of domain"> : N extends 0n ? BannedWindow<"`{0..*}` is vacuous — it provably says nothing; delete the statement"> : N extends 1n ? BannedWindow<"`{1..*}` says only what the bare containment says — write contained(source, target)"> : unknown;
-/** The ban verdict on `atMost(hi)`: `{0..0}` is the exclusion, written `none`. */
-type AtMostBan<N extends bigint> = bigint extends N ? unknown : IsNegative<N> extends true ? BannedWindow<"window counts are u64 — a negative count is out of domain"> : N extends 0n ? BannedWindow<"`{0..0}` — the exclusion is written `{0}`: use none"> : unknown;
-/** The ban verdict on a `between` floor of zero: `{0..hi}` is the ceiling respelled (`atMost(hi)`). */
-type BetweenFloorBan<Lo extends bigint> = Lo extends 0n ? BannedWindow<"`{0..hi}` — a ceiling is written atMost(hi)"> : unknown;
-/**
- * The ban verdict on `between(lo, hi)`, judged on the second bound once
- * both literals are known: `{n..n}` is the exact count respelled
- * (`exactly(n)`, or `none` at 0), and `{0..hi}` is the ceiling respelled
- * (`atMost(hi)` — the five constructors PARTITION the legal windows, so
- * the one ceiling window keeps its one spelling). Bound ORDER (`{hi..lo}`
- * inverted) is not type-expressible — bigint literals have no type-level
- * comparison — so inversion stays a construction error below.
- */
-type BetweenBan<Lo extends bigint, Hi extends bigint> = bigint extends Lo ? unknown : bigint extends Hi ? unknown : IsNegative<Lo> extends true ? BannedWindow<"window counts are u64 — a negative bound is out of domain"> : IsNegative<Hi> extends true ? BannedWindow<"window counts are u64 — a negative bound is out of domain"> : Lo extends Hi ? Hi extends Lo ? Lo extends 0n ? BannedWindow<"`{0..0}` — the exclusion is written `{0}`: use none"> : BannedWindow<"`{n..n}` — an exact count is written `{n}`: use exactly(n)"> : BetweenFloorBan<Lo> : BetweenFloorBan<Lo>;
-/**
- * `{n}` — THE exact-count spelling, n ≥ 1. `exactly(0)` is the exclusion
- * respelled: unwritable as a literal ({@link ExactlyBan} names `none`),
- * rejected at construction when computed.
- */
-declare function exactly<const N extends bigint>(n: N & ExactlyBan<N>): Count;
-/** `{0}` — the exclusion: no source fact may pair with the target group. */
-declare const none: Count;
-/**
- * `{lo..hi}` — both bounds explicit, 1 ≤ lo < hi. `lo === hi` is the exact
- * count respelled and `lo === 0` is the ceiling respelled: unwritable as
- * literals ({@link BetweenBan} names `exactly(n)`, `none` at `{0..0}`, or
- * `atMost(hi)` at a zero floor — the five constructors PARTITION the legal
- * windows), rejected at construction when computed; an inverted window is
- * unsatisfiable and rejected at construction (bigint literals carry no
- * type-level order).
- */
-declare function between<const Lo extends bigint, const Hi extends bigint>(lo: Lo, hi: Hi & BetweenBan<Lo, Hi>): Count;
-/**
- * `{lo..*}` — a floor with no ceiling, lo ≥ 2: `atLeast(1)` says only what
- * the bare containment says and `atLeast(0)` is vacuous — both unwritable
- * as literals ({@link AtLeastBan} names the canonical form), rejected at
- * construction when computed.
- */
-declare function atLeast<const N extends bigint>(lo: N & AtLeastBan<N>): Count;
-/**
- * `{0..hi}` — a ceiling, hi ≥ 1: `atMost(0)` is the exclusion respelled —
- * unwritable as a literal ({@link AtMostBan} names `none`), rejected at
- * construction when computed.
- */
-declare function atMost<const N extends bigint>(hi: N & AtMostBan<N>): Count;
-export type { Count };
-export { atLeast, atMost, between, exactly, none };
-//# sourceMappingURL=count.d.ts.map

package/dist/count.d.ts.map

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