@bjornpagen/bumbledb 0.7.0 → 0.9.0

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,26 @@ 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
 
 /**
  * The admission brand — a module-private symbol, deliberately unexported
- * (the `count.ts` pattern): `Statement` is a public structural type, so
+ * (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
@@ -115,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>
 }
 
 /**
@@ -266,29 +281,138 @@ function mirrors<A extends AnyFace, B extends AnyFace>(
 }
 
 /**
- * `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 window<B extends AnyFace, A extends AnyFace>(
+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 capacity<B extends AnyFace, W extends CapacityWindow, A extends AnyFace>(
+	target: B,
+	window: W & UnitWindowBan<W> & BoundsOnTarget<W, B>,
+	source: A & SameArity<B, A> & SameShapes<B, A>
+): CapacityStatement<B["data"], A["data"]>
+function capacity<B extends AnyFace, M extends CapacityWeight, W extends CapacityWindow, A extends AnyFace>(
 	target: B,
-	count: Count,
+	weight: M & WeightOnSource<M, A>,
+	window: 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(
+	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, [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
 }
 
@@ -298,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
@@ -311,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, isStatement, 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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"}

package/dist/count.js

@@ -1,115 +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 * as errors from "@superbuilders/errors";
-/** The exclusion's one spelling, shared by `none`. */
-const exclusion = Object.freeze({ kind: "exact", n: 0n });
-/**
- * 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.
- */
-const admitted = Symbol("bumbledb.count.admitted");
-/** Stamps one admitted window as a frozen `Count` value. */
-function admit(window) {
-    const count = { window, [admitted]: true };
-    return Object.freeze(count);
-}
-/**
- * `{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.
- */
-function exactly(n) {
-    if (n < 0n) {
-        throw errors.new(`window counts are u64: exactly(${n}) is out of domain`);
-    }
-    if (n === 0n) {
-        throw errors.new("`{0}` is the exclusion — write none");
-    }
-    return admit(Object.freeze({ kind: "exact", n }));
-}
-/** `{0}` — the exclusion: no source fact may pair with the target group. */
-const none = admit(exclusion);
-/**
- * `{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).
- */
-function between(lo, hi) {
-    if (lo < 0n || hi < 0n) {
-        throw errors.new(`window counts are u64: between(${lo}, ${hi}) is out of domain`);
-    }
-    if (hi < lo) {
-        throw errors.new(`the window \`{${lo}..${hi}}\` is inverted — no count satisfies it; bounds are \`{lo..hi}\` with lo < hi (an exact count is \`{n}\`: exactly(n))`);
-    }
-    if (lo === hi) {
-        if (lo === 0n) {
-            throw errors.new("`{0..0}` — the exclusion is written `{0}`: use none");
-        }
-        throw errors.new(`\`{${lo}..${lo}}\` — an exact count is written \`{${lo}}\`: use exactly(${lo})`);
-    }
-    if (lo === 0n) {
-        throw errors.new(`\`{0..${hi}}\` — a ceiling is written atMost: use atMost(${hi})`);
-    }
-    return admit(Object.freeze({ kind: "range", lo, hi }));
-}
-/**
- * `{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.
- */
-function atLeast(lo) {
-    if (lo < 0n) {
-        throw errors.new(`window counts are u64: atLeast(${lo}) is out of domain`);
-    }
-    if (lo === 0n) {
-        throw errors.new("the `{0..*}` window is vacuous — it provably says nothing; delete the statement");
-    }
-    if (lo === 1n) {
-        throw errors.new("`{1..*}` says only what the bare containment says — drop the annotation and write the containment: contained(source, target)");
-    }
-    return admit(Object.freeze({ kind: "floor", lo }));
-}
-/**
- * `{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.
- */
-function atMost(hi) {
-    if (hi < 0n) {
-        throw errors.new(`window counts are u64: atMost(${hi}) is out of domain`);
-    }
-    if (hi === 0n) {
-        throw errors.new("`{0..0}` — the exclusion is written `{0}`: use none");
-    }
-    return admit(Object.freeze({ kind: "range", lo: 0n, hi }));
-}
-export { atLeast, atMost, between, exactly, none };
-//# sourceMappingURL=count.js.map

package/dist/count.js.map

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