@bjornpagen/bumbledb 0.12.2 → 0.15.0

package/src/query/lower.ts

@@ -772,7 +772,7 @@ function advanceInterior(
 }
 
 /** Narrows a find entry to an aggregate value. */
-function isAggregateEntry(value: unknown): value is { readonly agg: string; readonly over: unknown } {
+function isAggregateEntry(value: unknown): value is { readonly agg: string; readonly over?: unknown } {
 	return typeof value === "object" && value !== null && "agg" in value
 }
 
@@ -785,11 +785,12 @@ function asVarTerm(context: string, value: unknown): AnyVar {
 }
 
 /** Classifies one aggregate find entry into its runtime data (variables ride by reference). */
-function aggDataOf(name: string, entry: { readonly agg: string; readonly over: unknown }): AggData {
+function aggDataOf(name: string, entry: { readonly agg: string; readonly over?: unknown }): AggData {
+	if (entry.agg === "count") {
+		return Object.freeze({ op: "count" as const })
+	}
 	const over = entry.over
 	switch (entry.agg) {
-		case "count":
-			return Object.freeze({ op: "count" as const })
 		case "sum":
 		case "min":
 		case "max": {
@@ -2051,7 +2052,7 @@ function lowerFind(entry: FindEntryData, ids: VarIds): FindTermIr {
 	const agg = entry.agg
 	switch (agg.op) {
 		case "count":
-			return { kind: "aggregate", op: { kind: "count" } }
+			return { kind: "count" }
 		case "fold": {
 			if ("duration" in agg.over) {
 				return { kind: "aggregateMeasure", op: { kind: agg.fold }, over: ids.of(agg.over.duration) }
@@ -2059,7 +2060,7 @@ function lowerFind(entry: FindEntryData, ids: VarIds): FindTermIr {
 			return { kind: "aggregate", op: { kind: agg.fold }, over: ids.of(agg.over) }
 		}
 		case "pack":
-			return { kind: "aggregate", op: { kind: "pack" }, over: ids.of(agg.over) }
+			return { kind: "pack", over: ids.of(agg.over) }
 	}
 }
 

package/src/query/parse-ir.ts

@@ -50,28 +50,30 @@ function align(context: string, head: readonly HeadTermIr[], rules: readonly Rul
 	}
 }
 
-/** Count forbids `over`; every other aggregate requires it. */
+/** Count is nullary; pack and folds require `over`. */
 function parseFind(context: string, find: FindTermIr): void {
-	if (find.kind !== "aggregate") {
-		return
-	}
-	if (find.op.kind === "count") {
-		if ("over" in find) {
+	const raw = find as Record<string, unknown>
+	if (find.kind === "count") {
+		if ("over" in raw) {
 			throw errors.new(`${context}: Count carries no over`)
 		}
 		return
 	}
-	if (!("over" in find)) {
-		throw errors.new(`${context}: fold aggregate requires over`)
+	if (find.kind === "pack" || find.kind === "aggregate" || find.kind === "aggregateMeasure") {
+		if (!("over" in raw)) {
+			throw errors.new(`${context}: ${find.kind} requires over`)
+		}
 	}
 }
 
-/** Head family of one find term: measure is a var slot; measure-folds are aggregates. */
+/** Head family of one find term: measure is a var slot; count/pack/folds are aggregates. */
 function findFamily(find: FindTermIr): "var" | "aggregate" {
 	switch (find.kind) {
 		case "var":
 		case "measure":
 			return "var"
+		case "count":
+		case "pack":
 		case "aggregate":
 		case "aggregateMeasure":
 			return "aggregate"

package/src/relation.ts

@@ -7,29 +7,15 @@
  * verified against their roster at construction). Fields are addressed by
  * NAME everywhere — statements (`on(R, "holder")`), selections, and match
  * records all spell the field's own name, checked by type
- * (`FaceFields`/`MatchShape`). `Fact<>`/`InsertFact<>` are the inferred
- * row object types at BARE structural value types (no brands): fresh
- * fields are optional on insert input (omit-to-mint) and present on read
- * (resupply-to-preserve-identity), typed exactly.
+ * (`FaceFields`/`MatchShape`). `Fact<>` is the inferred row object type
+ * at BARE structural value types (no brands): every field is present,
+ * including fresh cells. Mint with `tx.reserve` before insert.
  */
 
 import * as errors from "@superbuilders/errors"
 import { type AnyField, assertDeclarationOrderKey, assertDeclarationRecord, type Infer, literalOf } from "#fields.ts"
 import { type LiteralSetSpec, type LiteralSpec, renderLiteral } from "#spec.ts"
 
-/** Flattens an intersection into one displayed object type (hover legibility). */
-type Flatten<T> = { [K in keyof T]: T[K] }
-
-/**
- * An optional property that may be omitted OR explicitly `undefined`.
- * `Partial<T>` under `exactOptionalPropertyTypes` is omit-only (`key?: T`),
- * which rejects `key: T | undefined` — insert must accept both (omit-to-mint,
- * and a host binding that is already `bigint | undefined`).
- */
-type ExactOptional<T> = {
-	[K in keyof T]?: T[K] | undefined
-}
-
 /**
  * Resolves one selection entry to its lowered literal set: a plain ARRAY
  * (detected by `Array.isArray` — no field's value type is an array;
@@ -187,16 +173,6 @@ type FreshKeys<R extends AnyRelation> = {
 	[K in keyof RelationFields<R>]: RelationFields<R>[K] extends { readonly fresh: true } ? K : never
 }[keyof RelationFields<R>]
 
-/**
- * The inferred row object type of a relation as INSERTED: fresh fields
- * optional — omitted, the engine mints; supplied, identity is preserved
- * (the ETL resupply idiom). Explicit `undefined` is the same as omit
- * (`exactOptionalPropertyTypes`: `id?: bigint | undefined`, not omit-only).
- */
-type InsertFact<R extends AnyRelation> = Flatten<
-	Omit<Fact<R>, FreshKeys<R>> & ExactOptional<Pick<Fact<R>, FreshKeys<R>>>
->
-
 /**
  * Declares one relation: `relation("Account", { id: u64.fresh,
  * holder: u64, kind: Kind.id, ... })` — every field is a pure-structure
@@ -241,7 +217,6 @@ export type {
 	Fact,
 	FieldsShape,
 	FreshKeys,
-	InsertFact,
 	Relation,
 	RelationData,
 	RelationField,

package/dist/exhume.d.ts

@@ -1,143 +0,0 @@
-/**
- * The exhume surface — the SDK's ONE schema-independent read path
- * (docs/course-serialization/prd-02-sdk-exhume-surface.md; engine
- * 70-api.md § exhume): a read-only, theory-less open returning the store's
- * SELF-DESCRIBED relation shapes and raw facts by relation name. The
- * sighting it exists for: a run store whose creating schema has since
- * evolved — the record outlives the schema, and exhume is how the record
- * is read back for rebirth (exhume the old store, create the successor
- * under the new theory, copy by NAME, re-derive).
- *
- * DELIBERATELY SCHEMA-FREE: no schema type appears anywhere on this
- * surface. The caller's schema is the wrong theory for an exhumed store BY
- * DEFINITION (a store the current theory could open would never need
- * exhuming), so every value crosses TYPED at its bare structural form
- * ({@link FactValue} — bigint/string/boolean/bytes/interval, never
- * `unknown`) and every fact is keyed by field NAME. The SDK never
- * reconstructs a `Schema` value from the descriptor — that inverse mapping
- * is deliberately out of scope; the rebirth tool keys by name.
- *
- * LIFETIMES ARE DISPOSABLES, never `close()` (ruled 2026-07-23, R12): the
- * `Exhumed` value implements `Symbol.dispose` — teardown is synchronous
- * (one environment close) — and `using` is the documented idiom:
- *
- *   using exhumed = await Db.exhume(path)
- *
- * Disposal releases the engine handle AND the store's exclusive advisory
- * lock deterministically, scope-shaped in the language's own syntax, so a
- * same-path reopen (retry after a half-failed migration, a second forensic
- * read) never waits on an unforceable GC finalizer. Every verb after
- * disposal is a typed used-after-dispose refusal. The engine-side drop
- * remains the reclamation-only backstop for a collected-but-undisposed
- * value; the store is never written through this surface, so there is
- * nothing to flush.
- */
-import type { FactValue } from "./native.js";
-import type { ValueTypeSpec } from "./spec.js";
-/**
- * The typed `descriptorMissing` refusal: the store predates self-describing
- * stores and has not been adopted. The remedy is in the message — one
- * fingerprint-matching `Db.open` under the creating schema back-fills the
- * descriptor (engine 50-storage.md § the `_meta` block) and the store is
- * self-describing forever. Match with `errors.is`.
- */
-declare const ErrExhumeNoDescriptor: Error;
-/**
- * The typed `formatMismatch` refusal: the store's on-disk format version is
- * not this engine's (no migration path exists, as everywhere). Match with
- * `errors.is`.
- */
-declare const ErrExhumeFormatMismatch: Error;
-/**
- * The typed `corruption` refusal: the persisted descriptor fails its
- * integrity gates (the stored bytes hash to something other than the stored
- * fingerprint, or the bytes do not decode and re-encode faithfully). Match
- * with `errors.is`.
- */
-declare const ErrExhumeCorruption: Error;
-/**
- * One exhumed fact as a plain name-keyed record of bare structural values
- * — deliberately schema-free (module doc): `bigint` for u64/i64, `string`
- * for str, `boolean` for bool, `Uint8Array` for bytes<N>, a `{ start, end }`
- * bigint pair for intervals. Closed-relation rows open with the synthetic
- * `id` field, exactly as the descriptor's sealed field list declares.
- */
-type ExhumedFact = Readonly<Record<string, FactValue>>;
-/**
- * One field of an exhumed relation, exactly as the store's creator declared
- * it: the name and the structural type tag (byte width on `fixedBytes`,
- * element and optional width on `interval`).
- */
-interface ExhumedField {
-    readonly name: string;
-    readonly valueType: ValueTypeSpec;
-}
-/**
- * One ground axiom of an exhumed closed relation: the handle (the row's
- * identity, never a column), the declaration-order row id, and the declared
- * payload columns by name.
- */
-interface ExhumedAxiom {
-    readonly handle: string;
-    readonly id: bigint;
-    readonly values: ExhumedFact;
-}
-/**
- * One relation of an exhumed store: the name, the SEALED field list in
- * declaration order (a closed relation opens with the synthetic (`id`,
- * u64) handle field), and — exactly on closed relations — the roster of
- * ground axioms. Scan rows come back in this field order, so pairing a
- * row's positions against `fields` is the name-keyed reading `scan`
- * performs.
- */
-interface ExhumedRelation {
-    readonly name: string;
-    readonly fields: readonly ExhumedField[];
-    readonly roster: readonly ExhumedAxiom[] | undefined;
-}
-/**
- * The exhumed store's schema as declared, decoded from the store's own
- * persisted descriptor: relations in engine-id order (declaration order
- * mints every id), each with its ordered field descriptions and closed
- * roster — enough for a caller to key facts by name and re-insert them
- * into a differently-fingerprinted successor store. No schema type appears
- * here (module doc: the surface is schema-free; rows are typed bare).
- */
-interface ExhumedDescriptor {
-    readonly relations: readonly ExhumedRelation[];
-}
-/**
- * One exhumed store: the self-described relation shapes and the raw facts
- * by relation name. Read-only by construction — no write verb, no prepare
- * verb. A DISPOSABLE lifetime (R12): `Symbol.dispose` releases the engine
- * handle and the store's exclusive lock deterministically; `using` is the
- * idiom, and a disposed value's verbs are typed refusals.
- */
-interface Exhumed extends Disposable {
-    /** The store's own persisted schema, as its creator declared it. */
-    readonly descriptor: ExhumedDescriptor;
-    /**
-     * Full-relation export in row-id order, each row decoded per the
-     * STORED descriptor to a name-keyed record of natural values (str
-     * resolved through the engine's `_dict` before crossing; a closed
-     * relation scans its sealed roster). Each call reads one consistent
-     * snapshot. An unknown relation name is a typed error — the
-     * descriptor is the caller's roster.
-     */
-    scan(relation: string): readonly ExhumedFact[];
-}
-/**
- * Opens one exhumed store at an ALREADY-CANONICAL path (`Db.exhume` is the
- * public spelling — the path law lives in db.ts beside `open`/`create`).
- * The bridge's three domain refusals become the typed error constants
- * ({@link ErrExhumeNoDescriptor}, {@link ErrExhumeFormatMismatch},
- * {@link ErrExhumeCorruption}), each carrying the engine's message in its
- * wrap. The returned value is NOT cached: exhume is a forensic read whose
- * lifetime is the caller's `using` scope — disposal releases the store's
- * exclusive lock deterministically (R12), so the path is reusable the
- * moment the scope exits.
- */
-declare function exhumeStore(canonical: string): Exhumed;
-export type { Exhumed, ExhumedAxiom, ExhumedDescriptor, ExhumedFact, ExhumedField, ExhumedRelation };
-export { ErrExhumeCorruption, ErrExhumeFormatMismatch, ErrExhumeNoDescriptor, exhumeStore };
-//# sourceMappingURL=exhume.d.ts.map

package/dist/exhume.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"exhume.d.ts","sourceRoot":"","sources":["../src/exhume.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAY,MAAM,YAAY,CAAA;AAErD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAE7C;;;;;;GAMG;AACH,QAAA,MAAM,qBAAqB,OAE1B,CAAA;AAED;;;;GAIG;AACH,QAAA,MAAM,uBAAuB,OAE5B,CAAA;AAED;;;;;GAKG;AACH,QAAA,MAAM,mBAAmB,OAA2F,CAAA;AAEpH;;;;;;GAMG;AACH,KAAK,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAA;AAEtD;;;;GAIG;AACH,UAAU,YAAY;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAA;CACjC;AAED;;;;GAIG;AACH,UAAU,YAAY;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;CAC5B;AAED;;;;;;;GAOG;AACH,UAAU,eAAe;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAA;IACxC,QAAQ,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,SAAS,CAAA;CACpD;AAED;;;;;;;GAOG;AACH,UAAU,iBAAiB;IAC1B,QAAQ,CAAC,SAAS,EAAE,SAAS,eAAe,EAAE,CAAA;CAC9C;AAED;;;;;;GAMG;AACH,UAAU,OAAQ,SAAQ,UAAU;IACnC,oEAAoE;IACpE,QAAQ,CAAC,UAAU,EAAE,iBAAiB,CAAA;IACtC;;;;;;;OAOG;IACH,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,WAAW,EAAE,CAAA;CAC9C;AA+BD;;;;;;;;;;GAUG;AACH,iBAAS,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CA8E/C;AAED,YAAY,EAAE,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,WAAW,EAAE,YAAY,EAAE,eAAe,EAAE,CAAA;AACpG,OAAO,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,WAAW,EAAE,CAAA"}

package/dist/exhume.js

@@ -1,166 +0,0 @@
-/**
- * The exhume surface — the SDK's ONE schema-independent read path
- * (docs/course-serialization/prd-02-sdk-exhume-surface.md; engine
- * 70-api.md § exhume): a read-only, theory-less open returning the store's
- * SELF-DESCRIBED relation shapes and raw facts by relation name. The
- * sighting it exists for: a run store whose creating schema has since
- * evolved — the record outlives the schema, and exhume is how the record
- * is read back for rebirth (exhume the old store, create the successor
- * under the new theory, copy by NAME, re-derive).
- *
- * DELIBERATELY SCHEMA-FREE: no schema type appears anywhere on this
- * surface. The caller's schema is the wrong theory for an exhumed store BY
- * DEFINITION (a store the current theory could open would never need
- * exhuming), so every value crosses TYPED at its bare structural form
- * ({@link FactValue} — bigint/string/boolean/bytes/interval, never
- * `unknown`) and every fact is keyed by field NAME. The SDK never
- * reconstructs a `Schema` value from the descriptor — that inverse mapping
- * is deliberately out of scope; the rebirth tool keys by name.
- *
- * LIFETIMES ARE DISPOSABLES, never `close()` (ruled 2026-07-23, R12): the
- * `Exhumed` value implements `Symbol.dispose` — teardown is synchronous
- * (one environment close) — and `using` is the documented idiom:
- *
- *   using exhumed = await Db.exhume(path)
- *
- * Disposal releases the engine handle AND the store's exclusive advisory
- * lock deterministically, scope-shaped in the language's own syntax, so a
- * same-path reopen (retry after a half-failed migration, a second forensic
- * read) never waits on an unforceable GC finalizer. Every verb after
- * disposal is a typed used-after-dispose refusal. The engine-side drop
- * remains the reclamation-only backstop for a collected-but-undisposed
- * value; the store is never written through this surface, so there is
- * nothing to flush.
- */
-import * as errors from "@superbuilders/errors";
-import { bridged, native } from "#native.ts";
-/**
- * The typed `descriptorMissing` refusal: the store predates self-describing
- * stores and has not been adopted. The remedy is in the message — one
- * fingerprint-matching `Db.open` under the creating schema back-fills the
- * descriptor (engine 50-storage.md § the `_meta` block) and the store is
- * self-describing forever. Match with `errors.is`.
- */
-const ErrExhumeNoDescriptor = errors.new("bumbledb exhume: the store carries no schema descriptor (not yet adopted) — open it once under its creating schema (one fingerprint-matching Db.open back-fills the descriptor; engine 50-storage.md)");
-/**
- * The typed `formatMismatch` refusal: the store's on-disk format version is
- * not this engine's (no migration path exists, as everywhere). Match with
- * `errors.is`.
- */
-const ErrExhumeFormatMismatch = errors.new("bumbledb exhume: storage format version mismatch — the store was written by a different engine format");
-/**
- * The typed `corruption` refusal: the persisted descriptor fails its
- * integrity gates (the stored bytes hash to something other than the stored
- * fingerprint, or the bytes do not decode and re-encode faithfully). Match
- * with `errors.is`.
- */
-const ErrExhumeCorruption = errors.new("bumbledb exhume: the persisted schema descriptor fails its integrity gates");
-/**
- * Shapes the bridge's manifest rendering of the stored descriptor into the
- * SDK's {@link ExhumedDescriptor}: same relations in the same engine-id
- * order, extension rows re-keyed by column name. Pure reshaping — no
- * re-validation of engine-decoded values happens here (the bridge stays
- * dumb and so does this).
- */
-function descriptorOf(manifest) {
-    const relations = manifest.relations.map(function relationOf(relation) {
-        const fields = relation.fields.map(function fieldOf(field) {
-            return Object.freeze({ name: field.name, valueType: field.valueType });
-        });
-        let roster;
-        if (relation.extension !== undefined) {
-            roster = Object.freeze(relation.extension.map(function axiomOf(row) {
-                const values = {};
-                for (const cell of row.values) {
-                    values[cell.name] = cell.value;
-                }
-                return Object.freeze({ handle: row.handle, id: row.id, values: Object.freeze(values) });
-            }));
-        }
-        return Object.freeze({ name: relation.name, fields: Object.freeze(fields), roster });
-    });
-    return Object.freeze({ relations: Object.freeze(relations) });
-}
-/**
- * Opens one exhumed store at an ALREADY-CANONICAL path (`Db.exhume` is the
- * public spelling — the path law lives in db.ts beside `open`/`create`).
- * The bridge's three domain refusals become the typed error constants
- * ({@link ErrExhumeNoDescriptor}, {@link ErrExhumeFormatMismatch},
- * {@link ErrExhumeCorruption}), each carrying the engine's message in its
- * wrap. The returned value is NOT cached: exhume is a forensic read whose
- * lifetime is the caller's `using` scope — disposal releases the store's
- * exclusive lock deterministically (R12), so the path is reusable the
- * moment the scope exits.
- */
-function exhumeStore(canonical) {
-    const outcome = bridged(`exhume bumbledb store at ${canonical}`, function callExhume() {
-        return native.dbExhume(canonical);
-    });
-    if (!outcome.ok) {
-        switch (outcome.kind) {
-            case "descriptorMissing":
-                throw errors.wrap(ErrExhumeNoDescriptor, `exhume ${canonical}: ${outcome.message}`);
-            case "formatMismatch":
-                throw errors.wrap(ErrExhumeFormatMismatch, `exhume ${canonical}: ${outcome.message}`);
-            case "corruption":
-                throw errors.wrap(ErrExhumeCorruption, `exhume ${canonical}: ${outcome.message}`);
-        }
-    }
-    const handle = outcome.exhume;
-    const manifest = bridged("read bumbledb exhumed descriptor", function callDescriptor() {
-        return native.exhumeDescriptor(handle);
-    });
-    const descriptor = descriptorOf(manifest);
-    const fieldNames = new Map();
-    for (const relation of descriptor.relations) {
-        fieldNames.set(relation.name, relation.fields.map(function nameOf(field) {
-            return field.name;
-        }));
-    }
-    /** The lifetime record: flipped once by {@link dispose}, judged by every verb. */
-    const lifetime = { live: true };
-    /**
-     * The `Symbol.dispose` teardown (R12): idempotent — a manual call inside
-     * a `using` scope must not double-close — and deterministic: the engine
-     * handle and the store's exclusive lock release HERE, never on a GC
-     * schedule.
-     */
-    function dispose() {
-        if (!lifetime.live) {
-            return;
-        }
-        lifetime.live = false;
-        bridged(`close bumbledb exhumed store at ${canonical}`, function close() {
-            native.exhumeClose(handle);
-        });
-    }
-    function scan(relation) {
-        if (!lifetime.live) {
-            throw errors.new("bumbledb exhumed store is disposed — its using scope already exited");
-        }
-        const names = fieldNames.get(relation);
-        if (names === undefined) {
-            throw errors.new(`bumbledb exhume: the store's descriptor declares no relation ${relation}`);
-        }
-        const rows = bridged(`scan bumbledb exhumed relation ${relation}`, function callScan() {
-            return native.exhumeScan(handle, relation);
-        });
-        return Object.freeze(rows.map(function factOf(row) {
-            if (row.length !== names.length) {
-                throw errors.new(`bumbledb exhume drift: relation ${relation} row arity ${row.length} does not match the ${names.length} descriptor fields`);
-            }
-            const fact = {};
-            names.forEach(function pair(name, index) {
-                const cell = row[index];
-                if (cell === undefined) {
-                    throw errors.new(`bumbledb exhume drift: relation ${relation} row has no value at position ${index} (${name})`);
-                }
-                fact[name] = cell;
-            });
-            return Object.freeze(fact);
-        }));
-    }
-    return Object.freeze({ descriptor, scan, [Symbol.dispose]: dispose });
-}
-export { ErrExhumeCorruption, ErrExhumeFormatMismatch, ErrExhumeNoDescriptor, exhumeStore };
-//# sourceMappingURL=exhume.js.map

package/dist/exhume.js.map

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