@bjornpagen/bumbledb 0.1.0

package/dist/fields.d.ts

@@ -0,0 +1,187 @@
+/**
+ * Field type constructors — the value half of the `schema!` field grammar
+ * (`docs/architecture/70-api.md`): `bool`, `u64`, `i64`, `str`, `bytes(n)`,
+ * `interval(u64|i64[, width])`, each a plain frozen value carrying its
+ * structural type at runtime and its host value type in a phantom generic.
+ * Newtypes are DECLARATION-FIRST, one spelling only (owner ruling
+ * 2026-07-16): `const AccountId = u64.newtype("AccountId")` declares the
+ * brand ONCE as a value that IS the field, paired with
+ * `type AccountId = Infer<typeof AccountId>` for signatures; every field
+ * position references the declared value (`holder: HolderId`). The macro's
+ * refusals are reproduced representationally: `.newtype` exists only where
+ * Rust's `as` is legal (u64, i64, bytes, intervals — never bool/str),
+ * `.fresh` exists only on declared u64 newtypes (the macro demands `as
+ * NewType` on fresh fields), and no field-level constraint vocabulary of
+ * any kind exists — `unique`/`fk` are unwritable, not rejected.
+ */
+import type { Brand, Interval, IntervalValue } from "#brand.ts";
+import { phantom } from "#brand.ts";
+import type { LiteralSpec, ValueTypeSpec } from "#spec.ts";
+/**
+ * A closed relation's roster as seen from a referencing field: the handle
+ * namespace `where()` selections and ground axioms resolve bare handles
+ * through (the macro's own rule: a handle is legal exactly on a field whose
+ * newtype is a closed relation's handle newtype).
+ */
+interface ClosedRoster {
+    readonly name: string;
+    readonly handles: readonly string[];
+}
+/**
+ * One field's runtime description: structural type, host newtype name, the
+ * `fresh` mint mark (`minted` — the property name `fresh` is taken by the
+ * builder surface), and the closed-relation reference when the field is a
+ * closed relation's id type.
+ */
+interface FieldData<Minted extends boolean = boolean> {
+    readonly type: ValueTypeSpec;
+    readonly newtype: string | undefined;
+    readonly minted: Minted;
+    readonly closed: ClosedRoster | undefined;
+}
+/**
+ * The base shape every field value shares: runtime data plus the phantom
+ * host value type `V` (never present at runtime).
+ */
+interface Field<V> {
+    readonly data: FieldData;
+    readonly [phantom]?: V;
+}
+/** Extracts a field value's host value type from its phantom. */
+type FieldValue<F> = F extends Field<infer V> ? V : never;
+/** Any field value, whatever its host value type. */
+type AnyField = Field<unknown>;
+/** The `bool` field: host type `boolean`. No `.newtype`, no `.fresh` (macro parity). */
+interface BoolField extends Field<boolean> {
+    readonly data: FieldData<false>;
+}
+/** The `str` field: host type `string`. No `.newtype`, no `.fresh` (macro parity). */
+interface StrField extends Field<string> {
+    readonly data: FieldData<false>;
+}
+/**
+ * A `fresh`-marked u64 newtype field — `id: AccountId.fresh` (Rust: `id:
+ * u64 as AccountId, fresh`). Terminal: the mark implies the key
+ * `R(field) -> R`, which the ENGINE materializes
+ * (`SchemaDescriptor::materialized_statements`); `schema()` rejects an
+ * explicit duplicate of it (macro parity).
+ */
+interface FreshU64Newtype<Name extends string> extends Field<Brand<bigint, Name>> {
+    readonly data: FieldData<true>;
+}
+/**
+ * A declared u64 newtype — `const AccountId = u64.newtype("AccountId")`
+ * (Rust: `u64 as AccountId`). The value IS the field: relation blocks
+ * reference it (`holder: HolderId`). `.fresh` marks it as minted; the
+ * property exists ONLY here (the macro demands `as NewType` on fresh
+ * fields, so bare-u64 fresh is unwritable).
+ */
+interface U64Newtype<Name extends string> extends Field<Brand<bigint, Name>> {
+    readonly data: FieldData<false>;
+    readonly fresh: FreshU64Newtype<Name>;
+}
+/** The bare `u64` field; `.newtype(name)` declares a branded u64 newtype. */
+interface U64Field extends Field<bigint> {
+    readonly data: FieldData<false>;
+    newtype<const Name extends string>(name: Name): U64Newtype<Name>;
+}
+/** A declared i64 newtype. Terminal: `fresh` is legal on u64 only. */
+interface I64Newtype<Name extends string> extends Field<Brand<bigint, Name>> {
+    readonly data: FieldData<false>;
+}
+/** The bare `i64` field; `.newtype(name)` declares a branded i64 newtype. */
+interface I64Field extends Field<bigint> {
+    readonly data: FieldData<false>;
+    newtype<const Name extends string>(name: Name): I64Newtype<Name>;
+}
+/** A declared `bytes<N>` newtype (no order derived — no comparators exist). */
+interface BytesNewtype<Name extends string> extends Field<Brand<Uint8Array, Name>> {
+    readonly data: FieldData<false>;
+}
+/** A `bytes<N>` field; `.newtype(name)` declares a branded bytes newtype. */
+interface BytesField extends Field<Uint8Array> {
+    readonly data: FieldData<false>;
+    newtype<const Name extends string>(name: Name): BytesNewtype<Name>;
+}
+/** A declared interval newtype — Rust: `interval<i64> as ActiveDuring`. */
+interface IntervalNewtype<Name extends string> extends Field<Interval<Name>> {
+    readonly data: FieldData<false>;
+}
+/** An interval field; `.newtype(name)` brands the whole `{ start, end }` object. */
+interface IntervalField extends Field<IntervalValue> {
+    readonly data: FieldData<false>;
+    newtype<const Name extends string>(name: Name): IntervalNewtype<Name>;
+}
+/**
+ * The branded value type of a declared newtype — the type half of the
+ * declaration-first pairing (owner ruling 2026-07-16): `const AccountId =
+ * u64.newtype("AccountId")` + `type AccountId = Infer<typeof AccountId>`.
+ * Reads the phantom, so it works on any field value (a closed relation's
+ * `id` field infers its handle brand the same way).
+ */
+type Infer<F extends AnyField> = F extends Field<infer V> ? V : never;
+/**
+ * A closed relation's id field constructor (`Kind.id`) — a u64 field
+ * pre-branded with the closed relation's handle newtype, for use in other
+ * relations' field blocks (`kind: Kind.id`). Terminal: its newtype IS the
+ * closed relation, so `.newtype` and `.fresh` do not exist.
+ */
+interface ClosedIdField<Name extends string> extends Field<Brand<bigint, Name>> {
+    readonly data: FieldData<false>;
+}
+/**
+ * Rejects a declaration name that JavaScript would re-order. Declaration
+ * order = ordinal ids is the law relations, columns, and schemas all lean
+ * on, and it is carried by object-literal key order — which ECMA-262's
+ * OrdinaryOwnPropertyKeys breaks for integer-index keys (they enumerate
+ * first, ascending, regardless of where they were written). An
+ * integer-index name would silently reorder its declaration, so it is a
+ * construction error, exactly as an unparseable name is a macro expansion
+ * error.
+ */
+declare function assertDeclarationOrderKey(where: string, name: string): void;
+/**
+ * Builds one frozen {@link FieldData}. Internal seam shared by the field
+ * constructors here and by `closed()` (which mints {@link ClosedIdField}
+ * values against its own roster).
+ */
+declare function fieldData<Minted extends boolean>(type: ValueTypeSpec, newtype: string | undefined, minted: Minted, closed: ClosedRoster | undefined): FieldData<Minted>;
+/** The one `u64` field constructor value. */
+declare const u64: U64Field;
+/** The one `i64` field constructor value. */
+declare const i64: I64Field;
+/** The one `bool` field constructor value. */
+declare const bool: BoolField;
+/** The one `str` field constructor value. */
+declare const str: StrField;
+/**
+ * The `bytes<N>` field constructor. The width is mandatory and part of the
+ * type; `len` is validated to 1..=64 here because the grammar pins that
+ * range at declaration (`docs/architecture/70-api.md` § the `schema!`
+ * grammar: N ∈ 1..=64 — bare `bytes` does not parse), the macro-expansion
+ * boundary's analog being construction.
+ */
+declare function bytes(len: number): BytesField;
+/**
+ * The interval field constructor — `interval(u64)` / `interval(i64)` for
+ * the general type (rays representable), `interval(u64, w)` for the
+ * fixed-width family whose width IS the type. The element is spelled with
+ * the u64/i64 field constructor values themselves, never a string. `width
+ * >= 1` is validated here because the grammar pins it at declaration
+ * (`docs/architecture/70-api.md`: w ≥ 1; `interval<u64, 0>` is an
+ * expansion error naming the field).
+ */
+declare function interval(element: U64Field | I64Field, width?: bigint): IntervalField;
+/**
+ * Lowers one host literal at its field position to the wire
+ * {@link LiteralSpec} — the selection-literal machine ground axioms and
+ * `where()` bindings both ride (one machine, same errors — the macro's own
+ * rule). A value on a closed-reference field resolves to its handle NAME
+ * (the id is re-verified against the roster: an out-of-roster id is a
+ * construction error); everything else lowers to a plain value tagged by
+ * the field's structural type.
+ */
+declare function literalOf(field: FieldData, value: unknown): LiteralSpec;
+export type { AnyField, BoolField, BytesField, BytesNewtype, ClosedIdField, ClosedRoster, Field, FieldData, FieldValue, FreshU64Newtype, I64Field, I64Newtype, Infer, IntervalField, IntervalNewtype, StrField, U64Field, U64Newtype };
+export { assertDeclarationOrderKey, bool, bytes, fieldData, i64, interval, literalOf, str, u64 };
+//# sourceMappingURL=fields.d.ts.map

package/dist/fields.d.ts.map

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

package/dist/fields.js

@@ -0,0 +1,204 @@
+/**
+ * Field type constructors — the value half of the `schema!` field grammar
+ * (`docs/architecture/70-api.md`): `bool`, `u64`, `i64`, `str`, `bytes(n)`,
+ * `interval(u64|i64[, width])`, each a plain frozen value carrying its
+ * structural type at runtime and its host value type in a phantom generic.
+ * Newtypes are DECLARATION-FIRST, one spelling only (owner ruling
+ * 2026-07-16): `const AccountId = u64.newtype("AccountId")` declares the
+ * brand ONCE as a value that IS the field, paired with
+ * `type AccountId = Infer<typeof AccountId>` for signatures; every field
+ * position references the declared value (`holder: HolderId`). The macro's
+ * refusals are reproduced representationally: `.newtype` exists only where
+ * Rust's `as` is legal (u64, i64, bytes, intervals — never bool/str),
+ * `.fresh` exists only on declared u64 newtypes (the macro demands `as
+ * NewType` on fresh fields), and no field-level constraint vocabulary of
+ * any kind exists — `unique`/`fk` are unwritable, not rejected.
+ */
+import * as errors from "@superbuilders/errors";
+import { phantom } from "#brand.ts";
+/**
+ * The typed shape refusal of the selection-literal machine — reached only
+ * through ill-typed input (the well-typed surfaces make it unrepresentable).
+ */
+function literalShapeError(expected, value) {
+    return errors.new(`selection literal shape mismatch: expected ${expected}, got ${typeof value}`);
+}
+/** Narrows an interval literal: a plain object with bigint start/end. */
+function isIntervalLiteral(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "start" in value &&
+        "end" in value &&
+        typeof value.start === "bigint" &&
+        typeof value.end === "bigint");
+}
+/**
+ * Resolves one closed-handle literal: the branded id (a bigint at runtime)
+ * back to its handle NAME through the roster — an out-of-roster id is a
+ * construction error, the belt the type level cannot provide against
+ * forged brands.
+ */
+function handleLiteral(closed, value) {
+    if (typeof value !== "bigint") {
+        throw literalShapeError(`a ${closed.name} handle id (bigint)`, value);
+    }
+    const handle = closed.handles[Number(value)];
+    if (handle === undefined) {
+        throw errors.new(`closed relation ${closed.name} has no handle with id ${value} (roster holds ${closed.handles.length})`);
+    }
+    return { kind: "handle", handle };
+}
+/** Lowers one interval literal at its element type. */
+function intervalLiteral(element, value) {
+    if (!isIntervalLiteral(value)) {
+        throw literalShapeError("interval ({ start, end } bigints)", value);
+    }
+    if (element === "u64") {
+        return { kind: "value", value: { kind: "intervalU64", start: value.start, end: value.end } };
+    }
+    return { kind: "value", value: { kind: "intervalI64", start: value.start, end: value.end } };
+}
+/**
+ * Rejects a declaration name that JavaScript would re-order. Declaration
+ * order = ordinal ids is the law relations, columns, and schemas all lean
+ * on, and it is carried by object-literal key order — which ECMA-262's
+ * OrdinaryOwnPropertyKeys breaks for integer-index keys (they enumerate
+ * first, ascending, regardless of where they were written). An
+ * integer-index name would silently reorder its declaration, so it is a
+ * construction error, exactly as an unparseable name is a macro expansion
+ * error.
+ */
+function assertDeclarationOrderKey(where, name) {
+    if (/^(?:0|[1-9][0-9]*)$/.test(name)) {
+        throw errors.new(`${where}: name ${name} is an integer index — JavaScript object keys re-order integer indices, breaking the declaration-order law; use a non-numeric name`);
+    }
+}
+/**
+ * Builds one frozen {@link FieldData}. Internal seam shared by the field
+ * constructors here and by `closed()` (which mints {@link ClosedIdField}
+ * values against its own roster).
+ */
+function fieldData(type, newtype, minted, closed) {
+    return Object.freeze({ type: Object.freeze(type), newtype, minted, closed });
+}
+/** The one `u64` field constructor value. */
+const u64 = Object.freeze({
+    data: fieldData({ kind: "u64" }, undefined, false, undefined),
+    newtype(name) {
+        const fresh = Object.freeze({
+            data: fieldData({ kind: "u64" }, name, true, undefined)
+        });
+        return Object.freeze({
+            data: fieldData({ kind: "u64" }, name, false, undefined),
+            fresh
+        });
+    }
+});
+/** The one `i64` field constructor value. */
+const i64 = Object.freeze({
+    data: fieldData({ kind: "i64" }, undefined, false, undefined),
+    newtype(name) {
+        return Object.freeze({ data: fieldData({ kind: "i64" }, name, false, undefined) });
+    }
+});
+/** The one `bool` field constructor value. */
+const bool = Object.freeze({
+    data: fieldData({ kind: "bool" }, undefined, false, undefined)
+});
+/** The one `str` field constructor value. */
+const str = Object.freeze({
+    data: fieldData({ kind: "string" }, undefined, false, undefined)
+});
+/**
+ * The `bytes<N>` field constructor. The width is mandatory and part of the
+ * type; `len` is validated to 1..=64 here because the grammar pins that
+ * range at declaration (`docs/architecture/70-api.md` § the `schema!`
+ * grammar: N ∈ 1..=64 — bare `bytes` does not parse), the macro-expansion
+ * boundary's analog being construction.
+ */
+function bytes(len) {
+    if (!Number.isInteger(len) || len < 1 || len > 64) {
+        throw errors.new(`bytes width must be an integer in 1..=64 (got ${len}) — docs/architecture/70-api.md pins the range at declaration`);
+    }
+    return Object.freeze({
+        data: fieldData({ kind: "fixedBytes", len }, undefined, false, undefined),
+        newtype(name) {
+            return Object.freeze({ data: fieldData({ kind: "fixedBytes", len }, name, false, undefined) });
+        }
+    });
+}
+/**
+ * The interval field constructor — `interval(u64)` / `interval(i64)` for
+ * the general type (rays representable), `interval(u64, w)` for the
+ * fixed-width family whose width IS the type. The element is spelled with
+ * the u64/i64 field constructor values themselves, never a string. `width
+ * >= 1` is validated here because the grammar pins it at declaration
+ * (`docs/architecture/70-api.md`: w ≥ 1; `interval<u64, 0>` is an
+ * expansion error naming the field).
+ */
+function interval(element, width) {
+    const elementKind = element.data.type.kind;
+    if (elementKind !== "u64" && elementKind !== "i64") {
+        throw errors.new(`interval element must be the u64 or i64 field constructor (got ${elementKind})`);
+    }
+    if (width !== undefined && width < 1n) {
+        throw errors.new(`interval width must be >= 1 (got ${width}) — docs/architecture/70-api.md pins w >= 1 at declaration`);
+    }
+    const type = { kind: "interval", element: elementKind, width };
+    return Object.freeze({
+        data: fieldData(type, undefined, false, undefined),
+        newtype(name) {
+            return Object.freeze({ data: fieldData(type, name, false, undefined) });
+        }
+    });
+}
+/**
+ * Lowers one host literal at its field position to the wire
+ * {@link LiteralSpec} — the selection-literal machine ground axioms and
+ * `where()` bindings both ride (one machine, same errors — the macro's own
+ * rule). A value on a closed-reference field resolves to its handle NAME
+ * (the id is re-verified against the roster: an out-of-roster id is a
+ * construction error); everything else lowers to a plain value tagged by
+ * the field's structural type.
+ */
+function literalOf(field, value) {
+    if (field.closed !== undefined) {
+        return handleLiteral(field.closed, value);
+    }
+    switch (field.type.kind) {
+        case "bool": {
+            if (typeof value !== "boolean") {
+                throw literalShapeError("boolean", value);
+            }
+            return { kind: "value", value: { kind: "bool", value } };
+        }
+        case "u64": {
+            if (typeof value !== "bigint") {
+                throw literalShapeError("bigint", value);
+            }
+            return { kind: "value", value: { kind: "u64", value } };
+        }
+        case "i64": {
+            if (typeof value !== "bigint") {
+                throw literalShapeError("bigint", value);
+            }
+            return { kind: "value", value: { kind: "i64", value } };
+        }
+        case "string": {
+            if (typeof value !== "string") {
+                throw literalShapeError("string", value);
+            }
+            return { kind: "value", value: { kind: "string", value } };
+        }
+        case "fixedBytes": {
+            if (!(value instanceof Uint8Array)) {
+                throw literalShapeError("Uint8Array", value);
+            }
+            return { kind: "value", value: { kind: "fixedBytes", value } };
+        }
+        case "interval":
+            return intervalLiteral(field.type.element, value);
+    }
+}
+export { assertDeclarationOrderKey, bool, bytes, fieldData, i64, interval, literalOf, str, u64 };
+//# sourceMappingURL=fields.js.map

package/dist/fields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fields.js","sourceRoot":"","sources":["../src/fields.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,MAAM,MAAM,uBAAuB,CAAA;AAE/C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAGnC;;;GAGG;AACH,SAAS,iBAAiB,CAAC,QAAgB,EAAE,KAAc;IAC1D,OAAO,MAAM,CAAC,GAAG,CAAC,8CAA8C,QAAQ,SAAS,OAAO,KAAK,EAAE,CAAC,CAAA;AACjG,CAAC;AAED,yEAAyE;AACzE,SAAS,iBAAiB,CAAC,KAAc;IACxC,OAAO,CACN,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,OAAO,IAAI,KAAK;QAChB,KAAK,IAAI,KAAK;QACd,OAAO,KAAK,CAAC,KAAK,KAAK,QAAQ;QAC/B,OAAO,KAAK,CAAC,GAAG,KAAK,QAAQ,CAC7B,CAAA;AACF,CAAC;AAED;;;;;GAKG;AACH,SAAS,aAAa,CAAC,MAAoB,EAAE,KAAc;IAC1D,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC/B,MAAM,iBAAiB,CAAC,KAAK,MAAM,CAAC,IAAI,qBAAqB,EAAE,KAAK,CAAC,CAAA;IACtE,CAAC;IACD,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;IAC5C,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QAC1B,MAAM,MAAM,CAAC,GAAG,CACf,mBAAmB,MAAM,CAAC,IAAI,0BAA0B,KAAK,kBAAkB,MAAM,CAAC,OAAO,CAAC,MAAM,GAAG,CACvG,CAAA;IACF,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAA;AAClC,CAAC;AAED,uDAAuD;AACvD,SAAS,eAAe,CAAC,OAAsB,EAAE,KAAc;IAC9D,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC/B,MAAM,iBAAiB,CAAC,mCAAmC,EAAE,KAAK,CAAC,CAAA;IACpE,CAAC;IACD,IAAI,OAAO,KAAK,KAAK,EAAE,CAAC;QACvB,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,EAAE,EAAE,CAAA;IAC7F,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,EAAE,EAAE,CAAA;AAC7F,CAAC;AAoID;;;;;;;;;GASG;AACH,SAAS,yBAAyB,CAAC,KAAa,EAAE,IAAY;IAC7D,IAAI,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QACtC,MAAM,MAAM,CAAC,GAAG,CACf,GAAG,KAAK,UAAU,IAAI,oIAAoI,CAC1J,CAAA;IACF,CAAC;AACF,CAAC;AAED;;;;GAIG;AACH,SAAS,SAAS,CACjB,IAAmB,EACnB,OAA2B,EAC3B,MAAc,EACd,MAAgC;IAEhC,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;AAC7E,CAAC;AAED,6CAA6C;AAC7C,MAAM,GAAG,GAAa,MAAM,CAAC,MAAM,CAAC;IACnC,IAAI,EAAE,SAAS,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,CAAC;IAC7D,OAAO,CAA4B,IAAU;QAC5C,MAAM,KAAK,GAA0B,MAAM,CAAC,MAAM,CAAC;YAClD,IAAI,EAAE,SAAS,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,CAAC;SACvD,CAAC,CAAA;QACF,OAAO,MAAM,CAAC,MAAM,CAAC;YACpB,IAAI,EAAE,SAAS,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,CAAC;YACxD,KAAK;SACL,CAAC,CAAA;IACH,CAAC;CACD,CAAC,CAAA;AAEF,6CAA6C;AAC7C,MAAM,GAAG,GAAa,MAAM,CAAC,MAAM,CAAC;IACnC,IAAI,EAAE,SAAS,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,CAAC;IAC7D,OAAO,CAA4B,IAAU;QAC5C,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,CAAC,CAAA;IACnF,CAAC;CACD,CAAC,CAAA;AAEF,8CAA8C;AAC9C,MAAM,IAAI,GAAc,MAAM,CAAC,MAAM,CAAC;IACrC,IAAI,EAAE,SAAS,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,CAAC;CAC9D,CAAC,CAAA;AAEF,6CAA6C;AAC7C,MAAM,GAAG,GAAa,MAAM,CAAC,MAAM,CAAC;IACnC,IAAI,EAAE,SAAS,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,CAAC;CAChE,CAAC,CAAA;AAEF;;;;;;GAMG;AACH,SAAS,KAAK,CAAC,GAAW;IACzB,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,IAAI,GAAG,GAAG,EAAE,EAAE,CAAC;QACnD,MAAM,MAAM,CAAC,GAAG,CACf,iDAAiD,GAAG,+DAA+D,CACnH,CAAA;IACF,CAAC;IACD,OAAO,MAAM,CAAC,MAAM,CAAC;QACpB,IAAI,EAAE,SAAS,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,GAAG,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,CAAC;QACzE,OAAO,CAA4B,IAAU;YAC5C,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,CAAC,CAAA;QAC/F,CAAC;KACD,CAAC,CAAA;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,QAAQ,CAAC,OAA4B,EAAE,KAAc;IAC7D,MAAM,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAA;IAC1C,IAAI,WAAW,KAAK,KAAK,IAAI,WAAW,KAAK,KAAK,EAAE,CAAC;QACpD,MAAM,MAAM,CAAC,GAAG,CAAC,kEAAkE,WAAW,GAAG,CAAC,CAAA;IACnG,CAAC;IACD,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,GAAG,EAAE,EAAE,CAAC;QACvC,MAAM,MAAM,CAAC,GAAG,CACf,oCAAoC,KAAK,4DAA4D,CACrG,CAAA;IACF,CAAC;IACD,MAAM,IAAI,GAAkB,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,CAAA;IAC7E,OAAO,MAAM,CAAC,MAAM,CAAC;QACpB,IAAI,EAAE,SAAS,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,CAAC;QAClD,OAAO,CAA4B,IAAU;YAC5C,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,CAAC,CAAA;QACxE,CAAC;KACD,CAAC,CAAA;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,SAAS,CAAC,KAAgB,EAAE,KAAc;IAClD,IAAI,KAAK,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QAChC,OAAO,aAAa,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;IAC1C,CAAC;IACD,QAAQ,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;QACzB,KAAK,MAAM,EAAE,CAAC;YACb,IAAI,OAAO,KAAK,KAAK,SAAS,EAAE,CAAC;gBAChC,MAAM,iBAAiB,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;YAC1C,CAAC;YACD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,CAAA;QACzD,CAAC;QACD,KAAK,KAAK,EAAE,CAAC;YACZ,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;gBAC/B,MAAM,iBAAiB,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAA;YACzC,CAAC;YACD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,CAAA;QACxD,CAAC;QACD,KAAK,KAAK,EAAE,CAAC;YACZ,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;gBAC/B,MAAM,iBAAiB,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAA;YACzC,CAAC;YACD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,CAAA;QACxD,CAAC;QACD,KAAK,QAAQ,EAAE,CAAC;YACf,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;gBAC/B,MAAM,iBAAiB,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAA;YACzC,CAAC;YACD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,CAAA;QAC3D,CAAC;QACD,KAAK,YAAY,EAAE,CAAC;YACnB,IAAI,CAAC,CAAC,KAAK,YAAY,UAAU,CAAC,EAAE,CAAC;gBACpC,MAAM,iBAAiB,CAAC,YAAY,EAAE,KAAK,CAAC,CAAA;YAC7C,CAAC;YACD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,EAAE,CAAA;QAC/D,CAAC;QACD,KAAK,UAAU;YACd,OAAO,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;IACnD,CAAC;AACF,CAAC;AAsBD,OAAO,EAAE,yBAAyB,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,QAAQ,EAAE,SAAS,EAAE,GAAG,EAAE,GAAG,EAAE,CAAA"}

package/dist/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @bjornpagen/bumbledb — the type-theoretic TypeScript SDK for the
+ * bumbledb embedded relational engine. Public surface: the type kernel
+ * (brands, fields, `relation()`, `closed()` — PRD-05), the statement
+ * algebra with `schema()` and `SchemaSpec` lowering (PRD-06), the `Db`
+ * runtime (path-cached stores, transactions, typed violations, scoped
+ * snapshot reads, the witnessed write loop with `abandon` — PRD-07, zero
+ * closables), the query surface (Datalog as values: scoped vars/params,
+ * atoms, negation, conditions, aggregates, engine recursion via predicates,
+ * `db.prepare` as a plain value — PRD-08), and the exhume surface
+ * (`Db.exhume` — the one schema-independent read path: the store's
+ * self-described shapes and raw facts by name, deliberately untyped —
+ * course-serialization PRD-02). The raw native bridge is not exported (the
+ * PRD-03 stub died here as scheduled).
+ */
+export type { Brand, Interval, IntervalValue } from "#brand.ts";
+export { span } from "#brand.ts";
+export type { AnyClosed, AxiomRow, Axioms, Closed, ClosedColumn, ClosedCore, ClosedData, ClosedRow, PayloadField } from "#closed.ts";
+export { closed } from "#closed.ts";
+export type { Count } from "#count.ts";
+export { atLeast, atMost, between, exactly, none } from "#count.ts";
+export type { Abandon, DeclaredKeyFact, DeltaBuild, MemberRelation, OffendingFact, Prepared, ReadScope, Tx, Violation, WitnessedWriteResult, WriteResult } from "#db.ts";
+export { abandon, Db } from "#db.ts";
+export type { Exhumed, ExhumedAxiom, ExhumedDescriptor, ExhumedFact, ExhumedField, ExhumedRelation } from "#exhume.ts";
+export { ErrExhumeCorruption, ErrExhumeFormatMismatch, ErrExhumeNoDescriptor } from "#exhume.ts";
+export type { AnyFace, Arity, Face, FaceArityMismatch, FaceData, FaceFields, FaceOwner, FaceSource, OneOf, SameArity } from "#face.ts";
+export { on, oneOf } from "#face.ts";
+export type { AnyField, BoolField, BytesField, BytesNewtype, ClosedIdField, ClosedRoster, Field, FieldData, FieldValue, FreshU64Newtype, I64Field, I64Newtype, Infer, IntervalField, IntervalNewtype, StrField, U64Field, U64Newtype } from "#fields.ts";
+export { bool, bytes, i64, interval, str, u64 } from "#fields.ts";
+export { lower, lowerClosed, lowerRelation } from "#lower.ts";
+export type { KeyFact, Minted } from "#marshal.ts";
+export type { FactValue, OccurrenceDrift, ProgramIr, Staleness, StatementKindTag } from "#native.ts";
+export type { AnyBodyItem, AnyCondition, ComparisonItem, ConditionTreeItem, Duration, MatchAtom, MatchInput, TermInput } from "#query/atom.ts";
+export { ALLEN, allen, and, covers, duration, ge, gt, is, le, lt, match, ne, not, or } from "#query/atom.ts";
+export type { AnyQuery, Query, QueryBuild, QueryParams, QueryRow, Scope } from "#query/lower.ts";
+export { lowerQuery, query } from "#query/lower.ts";
+export type { Predicate, PredicateBindings, PredicateRuleInput, PredicateSelf } from "#query/predicate.ts";
+export type { MaskParam, Param, ParamSet, ParamsRecord, Var } from "#query/scope.ts";
+export type { Aggregate, RowOf, SelectShape } from "#query/select.ts";
+export { argmax, argmin, count, countDistinct, max, min, pack, sum } from "#query/select.ts";
+export type { AnyRelation, AnySelected, Fact, FieldRef, FieldRefs, FieldsShape, FreshKeys, InsertFact, Relation, RelationData, RelationField, RelationFields, Selected, SelectionBinding, SelectionInput } from "#relation.ts";
+export { relation } from "#relation.ts";
+export type { AnySchema, Schema, SchemaRelation, SchemaRelations } from "#schema.ts";
+export { schema } from "#schema.ts";
+export type { FieldSpec, LiteralSetSpec, LiteralSpec, RelationSpec, RowSpec, SchemaSpec, SideSpec, StatementSpec, ValueSpec, ValueTypeSpec, WindowSpec } from "#spec.ts";
+export { renderLiteral, renderLiteralSet, renderWindow } from "#spec.ts";
+export type { KeyStatement, Statement, StatementData } from "#statements.ts";
+export { contained, key, mirrors, renderStatement, window } from "#statements.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -0,0 +1,31 @@
+/**
+ * @bjornpagen/bumbledb — the type-theoretic TypeScript SDK for the
+ * bumbledb embedded relational engine. Public surface: the type kernel
+ * (brands, fields, `relation()`, `closed()` — PRD-05), the statement
+ * algebra with `schema()` and `SchemaSpec` lowering (PRD-06), the `Db`
+ * runtime (path-cached stores, transactions, typed violations, scoped
+ * snapshot reads, the witnessed write loop with `abandon` — PRD-07, zero
+ * closables), the query surface (Datalog as values: scoped vars/params,
+ * atoms, negation, conditions, aggregates, engine recursion via predicates,
+ * `db.prepare` as a plain value — PRD-08), and the exhume surface
+ * (`Db.exhume` — the one schema-independent read path: the store's
+ * self-described shapes and raw facts by name, deliberately untyped —
+ * course-serialization PRD-02). The raw native bridge is not exported (the
+ * PRD-03 stub died here as scheduled).
+ */
+export { span } from "#brand.ts";
+export { closed } from "#closed.ts";
+export { atLeast, atMost, between, exactly, none } from "#count.ts";
+export { abandon, Db } from "#db.ts";
+export { ErrExhumeCorruption, ErrExhumeFormatMismatch, ErrExhumeNoDescriptor } from "#exhume.ts";
+export { on, oneOf } from "#face.ts";
+export { bool, bytes, i64, interval, str, u64 } from "#fields.ts";
+export { lower, lowerClosed, lowerRelation } from "#lower.ts";
+export { ALLEN, allen, and, covers, duration, ge, gt, is, le, lt, match, ne, not, or } from "#query/atom.ts";
+export { lowerQuery, query } from "#query/lower.ts";
+export { argmax, argmin, count, countDistinct, max, min, pack, sum } from "#query/select.ts";
+export { relation } from "#relation.ts";
+export { schema } from "#schema.ts";
+export { renderLiteral, renderLiteralSet, renderWindow } from "#spec.ts";
+export { contained, key, mirrors, renderStatement, window } from "#statements.ts";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAYhC,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAEnC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAcnE,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAA;AASpC,OAAO,EACN,mBAAmB,EACnB,uBAAuB,EACvB,qBAAqB,EACrB,MAAM,YAAY,CAAA;AAanB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AAqBpC,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,YAAY,CAAA;AACjE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAqB7D,OAAO,EACN,KAAK,EACL,KAAK,EACL,GAAG,EACH,MAAM,EACN,QAAQ,EACR,EAAE,EACF,EAAE,EACF,EAAE,EACF,EAAE,EACF,EAAE,EACF,KAAK,EACL,EAAE,EACF,GAAG,EACH,EAAE,EACF,MAAM,gBAAgB,CAAA;AAUvB,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AASnD,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAkB5F,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAEvC,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAcnC,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAExE,OAAO,EAAE,SAAS,EAAE,GAAG,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA"}

package/dist/lower.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Descriptor lowering: SDK values down to the PRD-01 `SchemaSpec` plain
+ * data (`#spec.ts`), which the napi bridge marshals verbatim. Lowering is
+ * TOTAL on well-typed inputs — no validation lives here beyond what the
+ * types and the construction boundaries already guarantee — and it is the
+ * only place statement internals are read for the wire. Ordering is
+ * declaration order throughout, and every output object is built with one
+ * fixed key order, so serialization is deterministic (byte-stable).
+ */
+import type { AnyClosed } from "#closed.ts";
+import type { AnyRelation } from "#relation.ts";
+import type { AnySchema } from "#schema.ts";
+import type { RelationSpec, SchemaSpec } from "#spec.ts";
+/**
+ * Lowers one ordinary relation to its `RelationSpec` fragment: fields in
+ * declaration order, `extension: undefined` (the option is the kind).
+ */
+declare function lowerRelation(relation: AnyRelation): RelationSpec;
+/**
+ * Lowers one closed relation to its `RelationSpec` fragment: declared
+ * intrinsic columns only (the engine materializes the synthetic `id`),
+ * the relation's own name as its handle newtype, and the ground axioms in
+ * declaration order (row id = index) — the literals were already lowered
+ * at `closed()` construction.
+ */
+declare function lowerClosed(member: AnyClosed): RelationSpec;
+/**
+ * Lowers a whole theory to the `SchemaSpec` the bridge takes: relations in
+ * record declaration order, DECLARED statements only in written order (the
+ * engine materializes the fresh-implied and closed auto-keys itself).
+ */
+declare function lower(theory: AnySchema): SchemaSpec;
+export { lower, lowerClosed, lowerRelation };
+//# sourceMappingURL=lower.d.ts.map

package/dist/lower.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lower.d.ts","sourceRoot":"","sources":["../src/lower.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAE3C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAkB,MAAM,YAAY,CAAA;AAC3D,OAAO,KAAK,EAAa,YAAY,EAAE,UAAU,EAA2B,MAAM,UAAU,CAAA;AAkD5F;;;GAGG;AACH,iBAAS,aAAa,CAAC,QAAQ,EAAE,WAAW,GAAG,YAAY,CAU1D;AAED;;;;;;GAMG;AACH,iBAAS,WAAW,CAAC,MAAM,EAAE,SAAS,GAAG,YAAY,CAapD;AAED;;;;GAIG;AACH,iBAAS,KAAK,CAAC,MAAM,EAAE,SAAS,GAAG,UAAU,CAQ5C;AAED,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,CAAA"}

package/dist/lower.js

@@ -0,0 +1,105 @@
+/**
+ * Descriptor lowering: SDK values down to the PRD-01 `SchemaSpec` plain
+ * data (`#spec.ts`), which the napi bridge marshals verbatim. Lowering is
+ * TOTAL on well-typed inputs — no validation lives here beyond what the
+ * types and the construction boundaries already guarantee — and it is the
+ * only place statement internals are read for the wire. Ordering is
+ * declaration order throughout, and every output object is built with one
+ * fixed key order, so serialization is deterministic (byte-stable).
+ */
+/**
+ * The relation-kind discriminant: a closed relation's runtime description
+ * carries its handle roster, an ordinary relation's never does.
+ */
+function isClosedMember(member) {
+    return "handles" in member.data;
+}
+/** Lowers one face to a `SideSpec`: names only, σ as (field, set) pairs. */
+function lowerFace(face) {
+    return {
+        relation: face.owner.name,
+        projection: [...face.projection],
+        selection: face.selection.map(function lowerBinding(binding) {
+            return [binding.field, binding.set];
+        })
+    };
+}
+/**
+ * Lowers one statement. `mirrors` stays ONE spec statement
+ * (`bidirectional: true`) — the engine performs the `==` lowering to two
+ * adjacent containments, `source <= target` first, exactly as the macro
+ * does.
+ */
+function lowerStatement(statement) {
+    const data = statement.data;
+    switch (data.kind) {
+        case "key":
+            return { kind: "fd", relation: data.owner.name, projection: [...data.projection] };
+        case "containment":
+            return {
+                kind: "containment",
+                source: lowerFace(data.source),
+                target: lowerFace(data.target),
+                bidirectional: data.bidirectional
+            };
+        case "window":
+            return {
+                kind: "cardinality",
+                target: lowerFace(data.target),
+                window: data.window,
+                source: lowerFace(data.source)
+            };
+    }
+}
+/**
+ * Lowers one ordinary relation to its `RelationSpec` fragment: fields in
+ * declaration order, `extension: undefined` (the option is the kind).
+ */
+function lowerRelation(relation) {
+    const fields = relation.data.fields.map(function lowerField(declared) {
+        return {
+            name: declared.name,
+            valueType: declared.field.type,
+            newtype: declared.field.newtype,
+            fresh: declared.field.minted
+        };
+    });
+    return { name: relation.name, newtype: undefined, fields, extension: undefined };
+}
+/**
+ * Lowers one closed relation to its `RelationSpec` fragment: declared
+ * intrinsic columns only (the engine materializes the synthetic `id`),
+ * the relation's own name as its handle newtype, and the ground axioms in
+ * declaration order (row id = index) — the literals were already lowered
+ * at `closed()` construction.
+ */
+function lowerClosed(member) {
+    const fields = member.data.columns.map(function lowerColumn(column) {
+        return {
+            name: column.name,
+            valueType: column.field.type,
+            newtype: column.field.newtype,
+            fresh: false
+        };
+    });
+    const extension = member.data.rows.map(function lowerRow(row) {
+        return { handle: row.handle, values: row.values };
+    });
+    return { name: member.name, newtype: member.name, fields, extension };
+}
+/**
+ * Lowers a whole theory to the `SchemaSpec` the bridge takes: relations in
+ * record declaration order, DECLARED statements only in written order (the
+ * engine materializes the fresh-implied and closed auto-keys itself).
+ */
+function lower(theory) {
+    const relations = Object.values(theory.relations).map(function lowerMember(member) {
+        if (isClosedMember(member)) {
+            return lowerClosed(member);
+        }
+        return lowerRelation(member);
+    });
+    return { relations, statements: theory.statements.map(lowerStatement) };
+}
+export { lower, lowerClosed, lowerRelation };
+//# sourceMappingURL=lower.js.map