@bjornpagen/bumbledb 0.3.0 → 0.5.0

package/README.md

@@ -27,9 +27,11 @@ classes, inferred query rows, and rejections that arrive as data rather than
 exceptions.
 
 ```ts
-import { bool, closed, contained, Db, gt, key, on, query, relation, schema, u64 } from "@bjornpagen/bumbledb"
+import { bool, closed, contained, Db, gt, type Infer, key, on, query, relation, schema, u64 } from "@bjornpagen/bumbledb"
 
 // A closed relation: a sealed roster of axioms with typed payload columns.
+// At the host surface a handle is its NAME — the string literal "DirectPass"
+// is the one spelling, and closed columns type as the handle union.
 const Kind = closed(
 	"Kind",
 	{ mastered: bool, rank: u64 },
@@ -57,10 +59,12 @@ const Review = schema("Review", { Kind, Attempt, Certificate }, [
 
 const db = await Db.create("./review.db", Review)
 
-// Write. The delta is judged against every statement at commit.
+// Write. The delta is judged against every statement at commit. A closed
+// column takes the handle name — a wrong string is a compile error AND a
+// marshal refusal.
 const result = db.write((tx) => {
-	const attempt = tx.insert(Attempt, { kind: Kind.DirectPass }) // attempt.id minted, a bare bigint
-	tx.insert(Certificate, { attempt: attempt.id, kind: Kind.DirectPass })
+	const attempt = tx.insert(Attempt, { kind: "DirectPass" }) // attempt.id minted, a bare bigint
+	tx.insert(Certificate, { attempt: attempt.id, kind: "DirectPass" })
 })
 
 // Rejection-as-data: no throw — a rejected commit is a typed value carrying
@@ -75,7 +79,9 @@ if (!result.ok) {
 // 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")
+	const a = r.var("a")
+	const k = r.var("k")
+	const rank = r.var("rank")
 	return r
 		.match(Certificate, { attempt: a, kind: k })
 		.match(Kind, { id: k, mastered: true, rank }) // ψ on the read side too
@@ -87,14 +93,21 @@ 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"
+// Host dispatch over the sealed roster is native `switch` narrowing over
+// the handle union ("DirectPass" | "JudgedPass" | "Failed") — exhaustive
+// via `satisfies never`; the sealed axioms read back typed.
+function describe(kind: Infer<typeof Kind.id>): string {
+	switch (kind) {
+		case "DirectPass":
+		case "JudgedPass":
+			return `mastered, rank ${Kind.axioms[kind].rank}`
+		case "Failed":
+			return "not mastered"
+		default:
+			return kind satisfies never
+	}
+}
+console.log(describe("JudgedPass")) // "mastered, rank 20"
 ```
 
 Every `ts` fence in this README is extracted and type-checked against the
@@ -102,10 +115,12 @@ real surface by `test/readme.test.ts` — the examples cannot drift.
 
 ## Surface
 
-- 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 drizzle law governs this surface: the SDK's job at the host boundary is translation, not abstraction — every database idiom arrives as the modern TypeScript idiom for that concept, and the SDK never invents an operator where the language already has one.
+
+- The structural type kernel — fields as pure structure (`bool`, `bytes`, `i64`, `u64`, `str`, `interval`, `span`), `relation()`, and `closed()` sealed rosters with typed axiom payloads. A closed reference's value type IS the handle union (`Infer` speaks it); dispatch is native `switch` narrowing with `satisfies never` exhaustiveness. 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` (set membership is a plain array in `.where`); 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 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`); set membership at a closed field is a plain array in the match record (`r.match(Ticket, { priority: ["Normal", "Urgent"] })` — closed-only there: an ordinary field's membership is a bound `r.inSet` param); 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

package/dist/closed.d.ts

@@ -1,34 +1,37 @@
 /**
  * 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, 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",
+ * tiers, one function. 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.
+ * (type-enforced). At the host surface a handle is its NAME — a string
+ * literal of the roster's union (the drizzle law: translation, not
+ * abstraction; dispatch over a vocabulary is native `switch` narrowing, so
+ * no match operator is minted and no handle constants exist — the literal
+ * `"Checking"` is the ONE spelling). Handles are pure DATA, not properties
+ * of the value, so NO handle name is reserved: a vocabulary may legally
+ * contain handles named `match`, `where`, or `id` — the axioms record and
+ * the roster are their own namespaces. The value's whole surface: `name`;
+ * `id` — the 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`); `data` (the lowering
+ * carrier); `axioms` (payload readback, `Kind.axioms`); `columns` (the
+ * runtime twin of the `Cols` type parameter, which the face layer's
+ * structural wall reads); and — exactly when payload columns exist —
+ * `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.
+ * No fact type and no insert surface exist — closed relations are
+ * unwritable by construction: the value simply lacks the writable relation
+ * shape.
  */
-import type { OneOf } from "#face.ts";
 import { type AnyField, type ClosedIdField, type Infer } from "#fields.ts";
-import { type SelectionBinding } from "#relation.ts";
+import type { AnyRelation, RelationField } from "#relation.ts";
+import { type SelectionBinding, type SelectionInput } from "#relation.ts";
 import type { LiteralSpec } from "#spec.ts";
 /**
  * A payload column of a closed relation: any field descriptor except a
@@ -42,7 +45,7 @@ type PayloadField = Exclude<AnyField, {
  * 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
+ * (`sealedFieldsOf`, 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`.
@@ -93,12 +96,14 @@ interface ClosedCore<Name extends string, Handles extends string, Cols extends R
     readonly name: Name;
     /**
      * 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).
+     * field block is the reference through which handle literals become
+     * legal in that relation's selections. Pure structure plus the PRECISE
+     * roster (`ClosedIdField<Handles>` — the handle union is the field's
+     * value type under `Infer`); the referencing field's domain is law-born:
+     * `schema()` computes it from the declared containment (`"Kind.id"`, the
+     * generator class).
      */
-    readonly id: ClosedIdField;
+    readonly id: ClosedIdField<Handles>;
     readonly data: ClosedData;
     /** Payload readback: handle to its declared column values, bare and structural. */
     readonly axioms: Axioms<Handles, Cols>;
@@ -111,19 +116,17 @@ interface ClosedCore<Name extends string, Handles extends string, Cols extends R
      * 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: bigint): Handles | undefined;
 }
 /**
- * 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).
+ * The `where()` argument of a closed relation: EXACTLY the relation
+ * surface's {@link SelectionInput}, over the declared payload columns — the
+ * ONE selection vocabulary, so a spelling change there (H3's membership
+ * arrays) flows through with no local change here. The synthetic `id` is
+ * deliberately unspellable ({@link PayloadColumns} refuses an `id` column):
+ * an id selection is spelled only as handle literals on the REFERENCING
+ * side (the canonical-utterance law).
  */
-type ClosedSelectionInput<Cols extends Record<string, PayloadField>> = {
-    readonly [C in keyof Cols]?: Infer<Cols[C]> | OneOf<Infer<Cols[C]>>;
-};
+type ClosedSelectionInput<Cols extends Record<string, PayloadField>> = SelectionInput<Cols>;
 /**
  * A closed relation with a ψ selection applied — what `on()` consumes as a
  * σ-carrying closed source (`on(Kind.where({ mastered: true }), "id")`).
@@ -152,42 +155,17 @@ interface ClosedSelectable<Name extends string, Handles extends string, Cols ext
     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).
+ * A closed relation value: the core surface plus — exactly when payload
+ * columns exist — `where()` (the bare tier has nothing to select on, so
+ * the method is ABSENT there, not merely uncallable). NOTHING else:
+ * handles are data on the roster, never properties of the value (the
+ * handle constants, the match operator, and the id-to-handle weld died
+ * with the bigint era — dispatch is native `switch` narrowing over the
+ * handle union).
  */
-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>);
+type Closed<Name extends string, Handles extends string, Cols extends Record<string, PayloadField>> = [
+    keyof Cols
+] extends [never] ? ClosedCore<Name, Handles, Cols> : ClosedCore<Name, Handles, Cols> & ClosedSelectable<Name, Handles, Cols>;
 /** Any closed relation value, whatever its roster and columns. */
 interface AnyClosed {
     readonly name: string;
@@ -196,6 +174,33 @@ interface AnyClosed {
     readonly axioms: Readonly<Record<string, object>>;
     readonly columns: Readonly<Record<string, PayloadField>>;
 }
+/**
+ * THE relation-kind discriminant — the ONE spelling of "is this schema
+ * member closed?" (the type tier's twin is the `AnyClosed` conditional
+ * arms). A closed relation's runtime description carries its handle
+ * roster; an ordinary relation's never does. Every runtime closed/ordinary
+ * fork in the SDK judges through this predicate — never a re-spelled
+ * structural probe.
+ */
+declare function isClosedMember(member: AnyRelation | AnyClosed): member is AnyClosed;
+/**
+ * The SEALED field list of a schema member — THE one reader of "what
+ * fields does this owner expose": an ordinary relation's declared fields;
+ * a closed relation's sealed shape — the synthetic `id` (the value's own
+ * roster-carrying descriptor, by identity) at ordinal 0, then the declared
+ * payload columns at declared index + 1 (the sealed shift, mirroring the
+ * engine's `SchemaDescriptor::sealed_fields`). A `ClosedColumn` is
+ * structurally a `RelationField`, so both kinds read uniformly.
+ */
+declare function sealedFieldsOf(member: AnyRelation | AnyClosed): readonly RelationField[];
+/**
+ * One sealed field by name — derived from {@link sealedFieldsOf}, so the
+ * closed synthetic `id` resolves everywhere a name is looked up (no reader
+ * can silently lack the `id` arm). `undefined` when the name is foreign
+ * (the type tiers make that unwritable; the engine re-judges at
+ * `Db.create`).
+ */
+declare function sealedFieldOf(member: AnyRelation | AnyClosed, fieldName: string): AnyField | undefined;
 /** 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[number], Record<never, never>>;
 /**
@@ -211,6 +216,6 @@ declare function closed<const Name extends string, const Handles extends readonl
  * {@link Axioms}).
  */
 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 };
+export type { AnyClosed, AnySelectedClosed, AxiomRow, Axioms, Closed, ClosedColumn, ClosedCore, ClosedData, ClosedRow, ClosedSelectable, ClosedSelectionInput, PayloadField, SelectedClosed };
+export { closed, isClosedMember, sealedFieldOf, sealedFieldsOf };
 //# 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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"}