@bjornpagen/bumbledb 0.1.0 → 0.3.0

package/README.md

@@ -4,6 +4,8 @@ Type-theoretic TypeScript SDK for the [bumbledb](https://github.com/bjornpagen/b
 
 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).
 
+The surface is structural to the bone. Relation declarations are pure structure — kind, width, element, fresh, nothing else — and domains are never declared anywhere: **the laws type the columns**. `schema()` computes every field's equivalence class from the statement list itself, so the containments and mirrors you already write ARE the typing, at compile time and again at construction. Values stay bare (`bigint`, `string`, …); identity lives in the class the laws compute, not in a wrapper.
+
 > **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
@@ -18,32 +20,47 @@ 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.
+Declare relations as pure structure, let the statement list type every column,
+write facts through a transaction, and query with Datalog as values.
+Everything is typed end to end — bare structural values in law-computed
+classes, 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")
+import { bool, closed, contained, Db, gt, key, on, query, relation, schema, u64 } from "@bjornpagen/bumbledb"
+
+// A closed relation: a sealed roster of axioms with typed payload columns.
+const Kind = closed(
+	"Kind",
+	{ mastered: bool, rank: u64 },
+	{
+		DirectPass: { mastered: true, rank: 30n },
+		JudgedPass: { mastered: true, rank: 20n },
+		Failed: { mastered: false, rank: 10n }
+	}
+)
 
-// 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 })
+// Relations are pure structure — no domain is declared anywhere.
+// `u64.fresh` marks an engine-minted primary key.
+const Attempt = relation("Attempt", { id: u64.fresh, kind: Kind.id })
+const Certificate = relation("Certificate", { attempt: u64, kind: Kind.id })
 
-// A theory: every Account.holder must reference an existing Holder.id.
-const Ledger = schema("Ledger", { Holder, Account }, [contained(on(Account, "holder"), on(Holder, "id"))])
+// THE LAWS TYPE THE COLUMNS: schema() computes every field's class FROM this
+// statement list — the containments are the typing. The last statement uses
+// ψ-selection: a certificate may only ever cite a mastered kind.
+const Review = schema("Review", { Kind, Attempt, Certificate }, [
+	contained(on(Attempt, "kind"), on(Kind, "id")),
+	key(Certificate, ["attempt"]),
+	contained(on(Certificate, "attempt"), on(Attempt, "id")),
+	contained(on(Certificate, "kind"), on(Kind.where({ mastered: true }), "id"))
+])
 
-const db = await Db.create("./ledger.db", Ledger)
+const db = await Db.create("./review.db", Review)
 
 // 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 })
+	const attempt = tx.insert(Attempt, { kind: Kind.DirectPass }) // attempt.id minted, a bare bigint
+	tx.insert(Certificate, { attempt: attempt.id, kind: Kind.DirectPass })
 })
 
 // Rejection-as-data: no throw — a rejected commit is a typed value carrying
@@ -54,24 +71,46 @@ if (!result.ok) {
 	}
 }
 
-// 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 } }
+// Query: Datalog as values. Vars are named and typed by the class of their
+// first binding; params are typed by use; rows are typed from the select.
+// `gt` is one of the free comparison exports.
+const certifiedAbove = query(Review).rule((r) => {
+	const { a, k, rank } = r.vars("a", "k", "rank")
+	return r
+		.match(Certificate, { attempt: a, kind: k })
+		.match(Kind, { id: k, mastered: true, rank }) // ψ on the read side too
+		.where(gt(rank, r.param("floor")))
+		.select("a", "rank")
 })
 
-const prepared = db.prepare(accountsOf)
-const rows = db.execute(prepared, { holder: adaId }) // rows: { acct: AccountId }[]
+const prepared = db.prepare(certifiedAbove)
+const rows = db.execute(prepared, { floor: 15n }) // rows: { a: bigint; rank: bigint }[]
+console.log(rows)
+
+// Host dispatch over the sealed roster — exhaustive by construction; each
+// arm receives its axiom row.
+const label = Kind.match(Kind.JudgedPass, {
+	DirectPass: (row) => `mastered, rank ${row.rank}`,
+	JudgedPass: (row) => `mastered, rank ${row.rank}`,
+	Failed: () => "not mastered"
+})
+console.log(label) // "mastered, rank 20"
 ```
 
+Every `ts` fence in this README is extracted and type-checked against the
+real surface by `test/readme.test.ts` — the examples cannot drift.
+
 ## 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.
+- The structural type kernel — fields as pure structure (`bool`, `bytes`, `i64`, `u64`, `str`, `interval`, `span`), `relation()`, and `closed()` sealed rosters with typed axiom payloads and exhaustive host dispatch via `.match`. Domains are never declared: `schema()` computes every field's class from the statement list.
+- The statement algebra — `schema()`, `key`, `contained`, `mirrors`, `window`; faces via `on`/`oneOf`; counts via `exactly`, `atLeast`, `atMost`, `between`, `none`; ψ-selection via `.where` on relations and closed rosters.
+- The `Db` runtime — `Db.create`/`Db.open`, path-cached stores, transactions, typed violations, scoped snapshot reads, the witnessed write loop with `abandon`.
+- The query surface — Datalog as values, `query(S).rule(r => ...)`: named vars, params typed by use, negation, aggregates, and the free comparison/connective exports (`eq`, `ne`, `lt`, `le`, `gt`, `ge`, `and`, `or`, `not`, `allen`/`ALLEN`, `pointIn`, `covers`); stratified recursion via `program()`; `db.prepare` as a plain value.
+- The exhume surface — `Db.exhume`, the schema-independent read path: a store's self-described shapes and raw facts by name, with typed refusals (`ErrExhumeNoDescriptor`, `ErrExhumeFormatMismatch`, `ErrExhumeCorruption`).
+
+## Cookbook
+
+The engine cookbook's 29 modeling recipes, translated to this SDK's structural API: [COOKBOOK.md](./COOKBOOK.md). Two referees hold it: `test/cookbook-doc.test.ts` extracts the document's own `ts` fences and type-checks them against the real surface (the doc itself cannot drift), and `test/cookbook.test.ts` runs compiled copies of the recipes — each schema admitted by the real engine, its fingerprint asserted against the cross-host goldens the Rust cookbook suite also pins, every query snippet lowered through `db.prepare`.
 
 ## Architecture
 

package/dist/closed.d.ts

@@ -1,28 +1,59 @@
 /**
  * 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.
+ * 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, each a BARE `bigint` — no
+ * brand), the `fromId` weld, an `id` field descriptor carrying the CLOSED
+ * LINKAGE (the roster — pure structure, no declared domain: the laws type
+ * the columns, and `schema()` names the id's generator class `"Kind.id"`)
+ * for other relations' field blocks (`kind: Kind.id`), payload readback
+ * (`Kind.axioms`), and the declared payload column descriptors
+ * (`Kind.columns` — the runtime twin of the `Cols` type parameter, which
+ * the face layer's structural wall reads). Bare tier: `closed("Kind", ["Checking",
+ * "Savings"])`. Payload tier: `closed("Sev", { pages: bool }, { Critical:
+ * { pages: true }, ... })` — one call, three arguments (the curried tier-2
+ * spelling is DELETED — canonical utterance): the axioms record IS the
+ * handle declaration, every handle carrying every column exactly once
+ * (type-enforced). No fact type and no insert surface exist — closed
+ * relations are unwritable by construction: the value simply lacks the
+ * writable relation shape. Both tiers mint `match()` — exhaustive dispatch
+ * over the handle union (arms typed by the mapped type, so a missing or
+ * extra arm is a compile error; the payload tier's arm receives the typed
+ * axiom row). The payload tier additionally mints `where()` — the
+ * ψ-selection surface (`Kind.where({ mastered: true })` as a face source),
+ * resolved through the ONE selection machine
+ * (`relation.ts::resolveSelection`); the bare tier has no payload columns to
+ * select on, so `.where` is absent there, at the type AND on the value.
  */
-import type { Brand } from "#brand.ts";
-import { type AnyField, type ClosedIdField, type FieldData, type FieldValue } from "#fields.ts";
+import type { OneOf } from "#face.ts";
+import { type AnyField, type ClosedIdField, type Infer } from "#fields.ts";
+import { type SelectionBinding } from "#relation.ts";
 import type { LiteralSpec } from "#spec.ts";
 /**
- * A payload column of a closed relation: any field constructor except a
+ * A payload column of a closed relation: any field descriptor except a
  * fresh-marked one (a vocabulary's rows are ground axioms, never minted).
  */
-type PayloadField = AnyField & {
-    readonly data: FieldData<false>;
+type PayloadField = Exclude<AnyField, {
+    readonly fresh: true;
+}>;
+/**
+ * A declared payload column BLOCK: name → descriptor, with `id`
+ * unspellable — the sealed shape mints the synthetic `id` itself (ordinal
+ * 0 of the matchable fields), so a declared column named `id` would be
+ * shadowed by the synthetic slot everywhere the shape resolves by name
+ * (`matchFieldsOf`, the projected face, `spec.rs`'s resolver). The wall is
+ * typed here and judged again at construction in {@link mintClosed} — the
+ * runtime twin for untyped callers, warmer and earlier than the engine's
+ * `DuplicateFieldName` at `Db.create`.
+ */
+type PayloadColumns = Record<string, PayloadField> & {
+    readonly id?: never;
 };
-/** One declared payload column: name plus its field description. */
+/** One declared payload column: name plus its field descriptor. */
 interface ClosedColumn {
     readonly name: string;
-    readonly field: FieldData;
+    readonly field: PayloadField;
 }
 /**
  * One ground axiom, already lowered: the handle plus one wire literal per
@@ -41,57 +72,145 @@ interface ClosedData {
     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]>;
+/** One axiom row as the host writes and reads it: column name to bare structural value. */
+type AxiomRow<Cols extends Record<string, PayloadField>> = {
+    readonly [C in keyof Cols]: Infer<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).
+ * once per row — a missing or extra column is a TYPE error (each row is
+ * contextually checked against the declared columns), and the handle set
+ * IS the record's key set.
  */
-type Axioms<Handles extends readonly string[], Cols> = {
-    readonly [H in Handles[number]]: AxiomRow<Cols>;
+type Axioms<Handles extends string, Cols extends Record<string, PayloadField>> = {
+    readonly [H in Handles]: 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> {
+interface ClosedCore<Name extends string, Handles extends string, Cols extends Record<string, PayloadField>> {
     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.
+     * The closed reference descriptor: `kind: Kind.id` in another relation's
+     * field block is the reference through which bare handle ids become
+     * legal in that relation's selections. Pure structure plus the roster —
+     * the referencing field's domain is law-born: `schema()` computes it
+     * from the declared containment (`"Kind.id"`, the generator class).
      */
-    readonly id: ClosedIdField<Name>;
+    readonly id: ClosedIdField;
     readonly data: ClosedData;
-    /** Payload readback: handle to its declared column values. */
+    /** Payload readback: handle to its declared column values, bare and structural. */
     readonly axioms: Axioms<Handles, Cols>;
+    /**
+     * The declared payload columns, name → field descriptor — an HONEST
+     * frozen runtime record (the descriptors themselves, by identity), and
+     * the typed carrier a projected payload column's structural shape is
+     * recovered through off the schema type (the face layer's
+     * `ProjectedShape` reads it; `data.columns` carries the same
+     * descriptors in declaration order for the lowering).
+     */
+    readonly columns: Cols;
     /** The weld: declaration-order id back to its handle, or undefined beyond the roster. */
-    fromId(id: Brand<bigint, Name>): Handles[number] | undefined;
+    fromId(id: bigint): Handles | undefined;
 }
 /**
- * A closed relation value: the core surface plus one branded constant per
- * handle (`Kind.Checking: Brand<bigint, "Kind">`, ids = declaration order).
+ * The `where()` argument of a closed relation: per PAYLOAD column, a bare
+ * structural literal of that column's value type or an `oneOf(a, b, ...)`
+ * literal set — the ordinary `where()`'s vocabulary exactly. The synthetic
+ * `id` is deliberately absent: an id selection is spelled only as handle
+ * literals on the REFERENCING side (the canonical-utterance law).
  */
-type Closed<Name extends string, Handles extends readonly string[], Cols> = ClosedCore<Name, Handles, Cols> & {
-    readonly [H in Handles[number]]: Brand<bigint, Name>;
+type ClosedSelectionInput<Cols extends Record<string, PayloadField>> = {
+    readonly [C in keyof Cols]?: Infer<Cols[C]> | OneOf<Infer<Cols[C]>>;
 };
+/**
+ * A closed relation with a ψ selection applied — what `on()` consumes as a
+ * σ-carrying closed source (`on(Kind.where({ mastered: true }), "id")`).
+ * Deliberately the SAME discriminant shape as the ordinary `Selected`
+ * (`relation`/`selection` — `face.ts::faceParts` splits both by `"relation"
+ * in source`), and structurally UNMISTAKABLE for one: an `AnyClosed` lacks
+ * the relation shape (no `fields` record, no `RelationData`).
+ */
+interface SelectedClosed<Name extends string, Handles extends string, Cols extends Record<string, PayloadField>> {
+    readonly relation: Closed<Name, Handles, Cols>;
+    readonly selection: readonly SelectionBinding[];
+}
+/** Any ψ-selected closed relation value. */
+interface AnySelectedClosed {
+    readonly relation: AnyClosed;
+    readonly selection: readonly SelectionBinding[];
+}
+/**
+ * The ψ-selection surface of a payload-tier closed value. The selection is
+ * resolved EAGERLY against the declared columns and lowered as-is — the SDK
+ * never pre-folds ψ into an id set: pass-through lowering is what the macro
+ * does, and the ENGINE folds against the sealed extension at validate
+ * (`compile_member_set`).
+ */
+interface ClosedSelectable<Name extends string, Handles extends string, Cols extends Record<string, PayloadField>> {
+    where(selection: ClosedSelectionInput<Cols>): SelectedClosed<Name, Handles, Cols>;
+}
+/**
+ * Exhaustive dispatch over a BARE closed vocabulary: one arm per handle,
+ * no literal types and no brands — the handle-name union on the value's
+ * type IS the exhaustiveness proof (a missing arm is a missing-property
+ * compile error; an extra arm an excess-property compile error). The bare
+ * tier declares no payload, so an arm takes nothing. The arms record types
+ * any `bigint` in — the runtime roster refuses an out-of-vocabulary id
+ * with a throw, never a misdispatch.
+ */
+interface ClosedMatchBare<Handles extends string> {
+    match<T>(id: bigint, arms: {
+        readonly [H in Handles]: () => T;
+    }): T;
+}
+/**
+ * Exhaustive dispatch over a PAYLOAD-tier closed vocabulary: the same
+ * mapped-type exhaustiveness as the bare tier, and each arm receives its
+ * handle's typed axiom row (the declared columns, bare and structural —
+ * the frozen readback row from `axioms`).
+ */
+interface ClosedMatchPayload<Handles extends string, Cols extends Record<string, PayloadField>> {
+    match<T>(id: bigint, arms: {
+        readonly [H in Handles]: (row: AxiomRow<Cols>) => T;
+    }): T;
+}
+/**
+ * A closed relation value: the core surface plus one BARE constant per
+ * handle (`Kind.Checking: bigint`, ids = declaration order — the value is
+ * structural; the roster judges out-of-vocabulary ids at construction and
+ * the engine at commit), plus `match()` on BOTH tiers (bare arms take
+ * nothing; payload arms receive the typed axiom row), plus — exactly when
+ * payload columns exist — `where()` (the bare tier has nothing to select
+ * on, so the method is ABSENT there, not merely uncallable).
+ */
+type Closed<Name extends string, Handles extends string, Cols extends Record<string, PayloadField>> = ClosedCore<Name, Handles, Cols> & {
+    readonly [H in Handles]: bigint;
+} & ([keyof Cols] extends [never] ? ClosedMatchBare<Handles> : ClosedSelectable<Name, Handles, Cols> & ClosedMatchPayload<Handles, Cols>);
 /** Any closed relation value, whatever its roster and columns. */
 interface AnyClosed {
     readonly name: string;
-    readonly id: ClosedIdField<string>;
+    readonly id: ClosedIdField;
     readonly data: ClosedData;
     readonly axioms: Readonly<Record<string, object>>;
+    readonly columns: Readonly<Record<string, PayloadField>>;
 }
 /** 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>>;
+declare function closed<const Name extends string, const Handles extends readonly [string, ...string[]]>(name: Name, handles: Handles): Closed<Name, Handles[number], Record<never, never>>;
 /**
- * Payload tier: declared columns plus ground axioms, every handle with
- * every column exactly once (type-enforced by {@link Axioms}).
+ * Payload tier: declared columns AND ground axioms, one call — `closed(
+ * "Grade", { mastered: bool }, { DirectPass: { mastered: true }, Failed:
+ * { mastered: false } })`. The curried tier-2 spelling is DELETED
+ * (canonical utterance): `Cols` infers from the column block, the handle
+ * set from the axioms record's keys (reverse mapped-type inference), and
+ * every row is contextually checked against the declared columns — a
+ * wrong-typed value errors ON its property. The axioms record's keys ARE
+ * the handles (declaration order = key order, integer-index names
+ * rejected); every row carries 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 };
+declare function closed<const Name extends string, const Cols extends PayloadColumns, Handles extends string>(name: Name, columns: Cols, axioms: Axioms<Handles, Cols>): Closed<Name, Handles, Cols>;
+export type { AnyClosed, AnySelectedClosed, AxiomRow, Axioms, Closed, ClosedColumn, ClosedCore, ClosedData, ClosedRow, ClosedSelectionInput, PayloadField, SelectedClosed };
 export { closed };
 //# sourceMappingURL=closed.d.ts.map

package/dist/closed.d.ts.map

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