@bjornpagen/bumbledb 0.1.0

package/LICENSE

@@ -0,0 +1,12 @@
+Copyright © 2026 Bjorn Pagen <11238136+bjornpagen@users.noreply.github.com>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,84 @@
+# @bjornpagen/bumbledb
+
+Type-theoretic TypeScript SDK for the [bumbledb](https://github.com/bjornpagen/bumbledb) embedded relational engine.
+
+bumbledb models data as relations judged by statements (functionality, containment, cardinality) and queried with Datalog expressed as plain values — no SQL, no query-string parser. The SDK is a thin, fully typed surface over an in-process native engine (LMDB storage, MVCC snapshots, a single-writer witnessed write loop).
+
+> **Research-grade, one platform.** This is a `0.x` release of an embedded engine under active development. It targets a single platform today (below), the API is not yet frozen across `0.x`, and the FFI ABI is pinned exactly per version. Treat it as an early adopter's tool, not a production datastore.
+
+## Platform support
+
+This release targets **darwin-arm64 (macOS Apple Silicon) only**. The native binary ships as the optional platform package `@bjornpagen/bumbledb-darwin-arm64`, resolved automatically at install on a matching host. Installs on other platforms succeed (the main package is pure JS) but throw a typed, actionable error at first load naming the running platform and that only `darwin-arm64` ships today. More targets are pure addition — one more `os`/`cpu`-gated package plus a CI matrix — not a redesign.
+
+## Install
+
+```sh
+pnpm add @bjornpagen/bumbledb
+```
+
+## Quick start
+
+Declare a schema, write facts through a transaction, and query with Datalog as
+values. Everything is typed end to end — branded ids, inferred query rows, and
+rejections that arrive as data rather than exceptions.
+
+```ts
+import { Db, relation, schema, contained, on, query, match, u64, str, type Brand, type Scope } from "@bjornpagen/bumbledb"
+
+// Branded, fresh-minted id types.
+const HolderId = u64.newtype("HolderId")
+const AccountId = u64.newtype("AccountId")
+
+// Relations. `.fresh` marks an engine-minted primary key.
+const Holder = relation("Holder", { id: HolderId.fresh, name: str })
+const Account = relation("Account", { id: AccountId.fresh, holder: HolderId })
+
+// A theory: every Account.holder must reference an existing Holder.id.
+const Ledger = schema("Ledger", { Holder, Account }, [contained(on(Account, "holder"), on(Holder, "id"))])
+
+const db = await Db.create("./ledger.db", Ledger)
+
+// Write. The delta is judged against every statement at commit.
+let adaId: Brand<bigint, "HolderId"> | undefined
+const result = db.write((tx) => {
+	const ada = tx.insert(Holder, { name: "ada" }) // ada.id is a branded HolderId
+	adaId = ada.id
+	tx.insert(Account, { holder: ada.id })
+})
+
+// Rejection-as-data: no throw — a rejected commit is a typed value carrying
+// every violated statement, cited once, with its canonical spelling and facts.
+if (!result.ok) {
+	for (const v of result.violations) {
+		console.error(v.kind, v.canonical, v.facts)
+	}
+}
+
+// Query: Datalog as values. Rows are typed from the `select` shape.
+const accountsOf = query(Ledger, ($: Scope<(typeof Ledger)["relations"]>) => {
+	const acct = $.var(Account.fields.id)
+	const holder = $.param("holder", Holder.fields.id)
+	return { rules: [[match(Account, { id: acct, holder })]], select: { acct } }
+})
+
+const prepared = db.prepare(accountsOf)
+const rows = db.execute(prepared, { holder: adaId }) // rows: { acct: AccountId }[]
+```
+
+## Surface
+
+- The type kernel — brands, fields, `relation()`, `closed()`.
+- The statement algebra — `schema()`, `key`, `contained`, `mirrors`, `window`.
+- The `Db` runtime — path-cached stores, transactions, typed violations, scoped snapshot reads, the witnessed write loop.
+- The query surface — Datalog as values: scoped vars/params, atoms, negation, conditions, aggregates, engine recursion via predicates, `db.prepare`.
+- The exhume surface — `Db.exhume`, the schema-independent read path: a store's self-described shapes and raw facts by name.
+
+## Architecture
+
+The SDK is a typed surface over the native engine; the model (relations,
+statement-based judgment, Datalog evaluation, MVCC storage, the witnessed
+write loop) is documented in the [bumbledb engine repository](https://github.com/bjornpagen/bumbledb).
+
+## License
+
+0BSD

package/dist/brand.d.ts

@@ -0,0 +1,59 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,47 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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/dist/closed.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Closed relations (`docs/architecture/10-data-model.md` § closed
+ * relations): a vocabulary whose extension is declared in the schema — two
+ * tiers, one function. The emission per closed relation mirrors the macro's
+ * (host-enum analog): handle CONSTANTS on the value (`Kind.Checking`, ids =
+ * declaration order), the `fromId` weld, an `id` field constructor
+ * pre-branded with the handle newtype for other relations' field blocks
+ * (`kind: Kind.id`), and payload readback (`Kind.axioms`). No fact type and
+ * no insert surface exist — closed relations are unwritable by
+ * construction: the value simply lacks the writable relation shape.
+ */
+import type { Brand } from "#brand.ts";
+import { type AnyField, type ClosedIdField, type FieldData, type FieldValue } from "#fields.ts";
+import type { LiteralSpec } from "#spec.ts";
+/**
+ * A payload column of a closed relation: any field constructor except a
+ * fresh-marked one (a vocabulary's rows are ground axioms, never minted).
+ */
+type PayloadField = AnyField & {
+    readonly data: FieldData<false>;
+};
+/** One declared payload column: name plus its field description. */
+interface ClosedColumn {
+    readonly name: string;
+    readonly field: FieldData;
+}
+/**
+ * One ground axiom, already lowered: the handle plus one wire literal per
+ * declared column in column-declaration order (row id = index). Lowered
+ * EAGERLY at construction so axiom literals ride the same selection-literal
+ * machine as `where()` bindings, with the same errors (the macro's rule).
+ */
+interface ClosedRow {
+    readonly handle: string;
+    readonly values: readonly LiteralSpec[];
+}
+/** A closed relation's runtime description. */
+interface ClosedData {
+    readonly name: string;
+    readonly handles: readonly string[];
+    readonly columns: readonly ClosedColumn[];
+    readonly rows: readonly ClosedRow[];
+}
+/** One axiom row as the host writes and reads it: column name to host value. */
+type AxiomRow<Cols> = {
+    readonly [C in keyof Cols]: FieldValue<Cols[C]>;
+};
+/**
+ * The whole axiom record: every handle exactly once, every column exactly
+ * once per row — a missing or extra axiom, column, or handle is a TYPE
+ * error (mapped over the handle tuple).
+ */
+type Axioms<Handles extends readonly string[], Cols> = {
+    readonly [H in Handles[number]]: AxiomRow<Cols>;
+};
+/**
+ * The named surface of a closed relation value, minus the handle constants
+ * (which {@link Closed} intersects in).
+ */
+interface ClosedCore<Name extends string, Handles extends readonly string[], Cols> {
+    readonly name: Name;
+    /**
+     * The pre-branded u64 field constructor: `kind: Kind.id` in another
+     * relation's field block is the reference through which bare handles
+     * become legal in that relation's selections.
+     */
+    readonly id: ClosedIdField<Name>;
+    readonly data: ClosedData;
+    /** Payload readback: handle to its declared column values. */
+    readonly axioms: Axioms<Handles, Cols>;
+    /** The weld: declaration-order id back to its handle, or undefined beyond the roster. */
+    fromId(id: Brand<bigint, Name>): Handles[number] | undefined;
+}
+/**
+ * A closed relation value: the core surface plus one branded constant per
+ * handle (`Kind.Checking: Brand<bigint, "Kind">`, ids = declaration order).
+ */
+type Closed<Name extends string, Handles extends readonly string[], Cols> = ClosedCore<Name, Handles, Cols> & {
+    readonly [H in Handles[number]]: Brand<bigint, Name>;
+};
+/** Any closed relation value, whatever its roster and columns. */
+interface AnyClosed {
+    readonly name: string;
+    readonly id: ClosedIdField<string>;
+    readonly data: ClosedData;
+    readonly axioms: Readonly<Record<string, object>>;
+}
+/** Bare tier: `closed("Kind", ["Checking", "Savings"])` — handles only. */
+declare function closed<const Name extends string, const Handles extends readonly [string, ...string[]]>(name: Name, handles: Handles): Closed<Name, Handles, Record<never, never>>;
+/**
+ * Payload tier: declared columns plus ground axioms, every handle with
+ * every column exactly once (type-enforced by {@link Axioms}).
+ */
+declare function closed<const Name extends string, const Handles extends readonly [string, ...string[]], const Cols extends Record<string, PayloadField>>(name: Name, handles: Handles, columns: Cols, axioms: Axioms<Handles, Cols>): Closed<Name, Handles, Cols>;
+export type { AnyClosed, AxiomRow, Axioms, Closed, ClosedColumn, ClosedCore, ClosedData, ClosedRow, PayloadField };
+export { closed };
+//# sourceMappingURL=closed.d.ts.map

package/dist/closed.d.ts.map

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

package/dist/closed.js

@@ -0,0 +1,107 @@
+/**
+ * Closed relations (`docs/architecture/10-data-model.md` § closed
+ * relations): a vocabulary whose extension is declared in the schema — two
+ * tiers, one function. The emission per closed relation mirrors the macro's
+ * (host-enum analog): handle CONSTANTS on the value (`Kind.Checking`, ids =
+ * declaration order), the `fromId` weld, an `id` field constructor
+ * pre-branded with the handle newtype for other relations' field blocks
+ * (`kind: Kind.id`), and payload readback (`Kind.axioms`). No fact type and
+ * no insert surface exist — closed relations are unwritable by
+ * construction: the value simply lacks the writable relation shape.
+ */
+import * as errors from "@superbuilders/errors";
+import { assertDeclarationOrderKey, fieldData, literalOf } from "#fields.ts";
+/**
+ * The value-surface property names a handle may not shadow — the macro's
+ * name-collision diagnostic, here over the closed value's own properties
+ * (`relation`/`selection` are reserved so a closed value can never be
+ * mistaken for a selected relation by `on()`'s discriminant).
+ */
+const reservedHandleNames = Object.freeze([
+    "name",
+    "id",
+    "data",
+    "axioms",
+    "fromId",
+    "relation",
+    "selection"
+]);
+/**
+ * Reads one handle's axiom row, refusing absence loudly: the payload tier's
+ * overload types the record exhaustively, so a missing row is ill-typed
+ * input, and the bare tier never reaches here (it declares no columns).
+ */
+function axiomRow(name, axioms, handle) {
+    if (axioms === undefined) {
+        throw errors.new(`closed relation ${name}: payload columns declared without ground axioms`);
+    }
+    const row = axioms[handle];
+    if (row === undefined) {
+        throw errors.new(`closed relation ${name}: no ground axiom for handle ${handle}`);
+    }
+    return row;
+}
+function closed(name, handles, columns, axioms) {
+    const seen = new Set();
+    for (const handle of handles) {
+        if (seen.has(handle)) {
+            throw errors.new(`closed relation ${name}: duplicate handle ${handle}`);
+        }
+        seen.add(handle);
+        if (reservedHandleNames.includes(handle)) {
+            throw errors.new(`closed relation ${name}: handle ${handle} collides with the closed value's own surface (${reservedHandleNames.join(", ")})`);
+        }
+    }
+    const roster = Object.freeze({ name, handles: Object.freeze([...handles]) });
+    const cols = [];
+    if (columns !== undefined) {
+        for (const [columnName, field] of Object.entries(columns)) {
+            assertDeclarationOrderKey(`closed relation ${name} column`, columnName);
+            cols.push(Object.freeze({ name: columnName, field: field.data }));
+        }
+    }
+    const rows = handles.map(function lowerRow(handle) {
+        const values = cols.map(function lowerAxiomLiteral(column) {
+            const row = axiomRow(name, axioms, handle);
+            return Object.freeze(literalOf(column.field, row[column.name]));
+        });
+        return Object.freeze({ handle, values: Object.freeze(values) });
+    });
+    const data = Object.freeze({
+        name,
+        handles: roster.handles,
+        columns: Object.freeze(cols),
+        rows: Object.freeze(rows)
+    });
+    const id = Object.freeze({
+        data: fieldData({ kind: "u64" }, name, false, roster)
+    });
+    /**
+     * Handle names are arbitrary identifiers, so rows and constants are
+     * minted with OWN-property definition, never assignment: a handle named
+     * "__proto__" would otherwise ride the Object.prototype accessor —
+     * silently swapping the record's prototype instead of creating the row,
+     * and no-oping the constant (a primitive through the setter) — minting a
+     * value whose type claims Brand<bigint, Name> but reads back an object.
+     */
+    const axiomsOut = {};
+    for (const handle of handles) {
+        const row = axioms === undefined ? Object.freeze({}) : Object.freeze({ ...axiomRow(name, axioms, handle) });
+        Object.defineProperty(axiomsOut, handle, { value: row, enumerable: true });
+    }
+    const value = {
+        name,
+        id,
+        data,
+        axioms: Object.freeze(axiomsOut),
+        fromId(idValue) {
+            return roster.handles[Number(idValue)];
+        }
+    };
+    handles.forEach(function mintHandleConstant(handle, index) {
+        Object.defineProperty(value, handle, { value: BigInt(index), enumerable: true });
+    });
+    return Object.freeze(value);
+}
+export { closed };
+//# sourceMappingURL=closed.js.map

package/dist/closed.js.map

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

package/dist/count.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Cardinality-window counts — exactly five constructors, and nothing else
+ * (`docs/architecture/70-api.md` § the canonical-utterance law). The ban
+ * table is enforced REPRESENTATIONALLY, stronger than Rust's expansion
+ * errors: `{1..*}`, `{n..n}`, `{0..0}`, `{0..*}`, and inverted windows have
+ * NO constructor — the spellings that could produce them are construction
+ * errors naming the canonical form, and no other spelling exists at all.
+ * 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;
+}
+/**
+ * `{n}` — THE exact-count spelling, n ≥ 1. `exactly(0)` is the exclusion
+ * respelled and rejected naming `none`.
+ */
+declare function exactly(n: bigint): Count;
+/** `{0}` — the exclusion: no source fact may pair with the target group. */
+declare const none: Count;
+/**
+ * `{lo..hi}` — both bounds explicit, 0 ≤ lo < hi. `lo === hi` is the exact
+ * count respelled (rejected naming `exactly(n)`, or `none` at 0); an
+ * inverted window is unsatisfiable and rejected.
+ */
+declare function between(lo: bigint, hi: bigint): Count;
+/**
+ * `{lo..*}` — a floor with no ceiling, lo ≥ 2: `atLeast(1)` says only what
+ * the bare containment says (rejected naming `contained`), and
+ * `atLeast(0)` is vacuous (rejected naming deletion).
+ */
+declare function atLeast(lo: bigint): Count;
+/**
+ * `{0..hi}` — a ceiling, hi ≥ 1: `atMost(0)` is the exclusion respelled
+ * and rejected naming `none`.
+ */
+declare function atMost(hi: bigint): Count;
+export type { Count };
+export { atLeast, atMost, between, exactly, none };
+//# sourceMappingURL=count.d.ts.map

package/dist/count.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"count.d.ts","sourceRoot":"","sources":["../src/count.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAK1C;;;;;;;GAOG;AACH,QAAA,MAAM,QAAQ,EAAE,OAAO,MAA0C,CAAA;AAEjE;;;;GAIG;AACH,UAAU,KAAK;IACd,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAA;IAC3B,QAAQ,CAAC,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAA;CACzB;AAOD;;;GAGG;AACH,iBAAS,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,KAAK,CAQjC;AAED,4EAA4E;AAC5E,QAAA,MAAM,IAAI,EAAE,KAAwB,CAAA;AAEpC;;;;GAIG;AACH,iBAAS,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,KAAK,CAgB9C;AAED;;;;GAIG;AACH,iBAAS,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,KAAK,CAalC;AAED;;;GAGG;AACH,iBAAS,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,KAAK,CAQjC;AAED,YAAY,EAAE,KAAK,EAAE,CAAA;AACrB,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAA"}

package/dist/count.js

@@ -0,0 +1,92 @@
+/**
+ * Cardinality-window counts — exactly five constructors, and nothing else
+ * (`docs/architecture/70-api.md` § the canonical-utterance law). The ban
+ * table is enforced REPRESENTATIONALLY, stronger than Rust's expansion
+ * errors: `{1..*}`, `{n..n}`, `{0..0}`, `{0..*}`, and inverted windows have
+ * NO constructor — the spellings that could produce them are construction
+ * errors naming the canonical form, and no other spelling exists at all.
+ * 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) {
+    return Object.freeze({ window, [admitted]: true });
+}
+/**
+ * `{n}` — THE exact-count spelling, n ≥ 1. `exactly(0)` is the exclusion
+ * respelled and rejected naming `none`.
+ */
+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..0}`-shaped spelling: the exclusion is written `{0}` — use 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, 0 ≤ lo < hi. `lo === hi` is the exact
+ * count respelled (rejected naming `exactly(n)`, or `none` at 0); an
+ * inverted window is unsatisfiable and rejected.
+ */
+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})`);
+    }
+    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 (rejected naming `contained`), and
+ * `atLeast(0)` is vacuous (rejected naming deletion).
+ */
+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
+ * and rejected naming `none`.
+ */
+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

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