@bjornpagen/bumbledb 0.9.0 → 0.11.0

package/dist/query/predicate.d.ts

@@ -1,91 +0,0 @@
-/**
- * Stratified recursion — engine recursion as values, mirroring the IR's
- * cut exactly (`ir::Program`/`PredicateDef`/`AtomSource::Idb`;
- * `docs/architecture/20-query-ir.md` § engine recursion):
- *
- *   program(S, (p) => {
- *     const reach = p.rec("reach")
- *     reach.rule((r) => {
- *       const n = v(Node)
- *       return r.match(Node, { id: n.id }).where(r.eq(n.id, r.param("root"))).find({ c: n.id })
- *     })
- *     reach.rule((r) => {
- *       const e = v(Parent)
- *       return r.match(Parent, { child: e.child, parent: e.parent }).idb(reach, { c: e.parent }).find({ c: e.child })
- *     })
- *     return p.output((r) => {
- *       const post = v(Posting)
- *       return r.match(Posting, { account: post.account, minor: post.minor })
- *         .idb(reach, { c: post.account }).find({ total: r.sum(post.minor) })
- *     })
- *   })
- *
- * `p.rec(name)` declares one recursive predicate (declaration order = its
- * dense `PredId`); `rec.rule(...)` attaches one clause — its builder's
- * `idb` accepts ONLY the rec itself (the self-recursion cut as a
- * type-level boundary: mutual recursion is unwritable) and its `find` head
- * projects bound variables only (aggregation/measure through a cycle is
- * unrepresentable — the strata judge's roster, made unwritable);
- * `p.output(...)` seals the recs and builds the output rules, whose `idb`
- * folds any FINISHED stratum by NAMED record over its head keys (recipe
- * 25's form). The rec value `.rule` returns carries the params its rules
- * used — thread it into the output's `idb` and the program's inferred
- * `Params` stays exactly the params the rules use. Everything deeper —
- * strata legality, signature sealing, the three oracles — is the ENGINE's
- * judge, surfacing typed at prepare.
- */
-import type { SchemaClasses } from "#law.ts";
-import type { AnyRuleValue, HeadOf, HeadShape, OutputRuleScope, ParamsOf, Query, RecRef, RecRuleScope, RowOf } from "#query/lower.ts";
-import type { Flatten, ParamsRecord, ShapeOf } from "#query/scope.ts";
-import { inferred } from "#query/scope.ts";
-import type { Schema, SchemaRelations } from "#schema.ts";
-/**
- * One recursive predicate HANDLE: `rec.rule(...)` attaches a clause and
- * returns the SAME rec under a widened params type (the runtime data is
- * shared — either handle is the self-reference; the returned one carries
- * the rules' params for the output to thread) and under the head signature
- * the FIRST rule sealed (every later rule derives the same head — the
- * runtime alignment check's law), so a threaded handle's `idb` joins are
- * arity- and domain-checked against the head.
- */
-interface Rec<Rels extends SchemaRelations, Name extends string, P extends ParamsRecord, Head extends HeadShape = undefined, Classes extends SchemaClasses = SchemaClasses> extends RecRef<Name, P, Head> {
-    rule<RV extends AnyRuleValue>(build: (r: RecRuleScope<Rels, Name, Classes>) => RV): Rec<Rels, Name, Flatten<P & ParamsOf<RV>>, Head extends undefined ? HeadOf<RV> : Head, Classes>;
-    readonly [inferred]?: {
-        readonly params: P;
-        readonly head: Head;
-    };
-}
-/** One output-rule builder function. */
-type OutputBuild<Rels extends SchemaRelations, Classes extends SchemaClasses = SchemaClasses> = (r: OutputRuleScope<Rels, Classes>) => AnyRuleValue;
-/** A build function's rule value. */
-type BuiltRule<F> = F extends (r: never) => infer RV ? RV : never;
-/** The union row of a tuple of output builds. */
-type OutputRow<Builds extends readonly OutputBuild<SchemaRelations, SchemaClasses>[]> = RowOf<BuiltRule<Builds[number]>>;
-/** The intersected params record of a tuple of output builds. */
-type OutputParams<Builds extends readonly OutputBuild<SchemaRelations, SchemaClasses>[]> = ShapeOf<ParamsOf<BuiltRule<Builds[number]>>>;
-/**
- * The program scope: declare recs, attach their rules, then declare the
- * output — which seals the recs (a later `rec`/`rule` is a construction
- * error) and returns the program as an ordinary query value.
- */
-interface ProgramScope<Rels extends SchemaRelations, Classes extends SchemaClasses = SchemaClasses> {
-    /** Declares one recursive predicate; declaration order = its dense `PredId`. */
-    rec<const Name extends string>(name: Name): Rec<Rels, Name, Record<never, never>, undefined, Classes>;
-    /**
-     * Declares the output predicate (one rule per build; multiple rules =
-     * set union) and seals the program. Must be what the `program()`
-     * callback returns.
-     */
-    output<const Builds extends readonly OutputBuild<Rels, Classes>[]>(...builds: Builds): Query<Rels, OutputRow<Builds>, OutputParams<Builds>, Classes>;
-}
-/**
- * Builds a stratified program over a schema. The callback declares recs
- * and their rules through the scope and MUST return `p.output(...)` — the
- * sealed program is an ordinary query value: `db.prepare` lowers it to
- * the one `ProgramIr` shape the engine executes under the per-stratum
- * fixpoint driver.
- */
-declare function program<Rels extends SchemaRelations, Classes extends SchemaClasses, Q extends Query<Rels, unknown, ParamsRecord, Classes>>(theory: Schema<Rels, Classes>, build: (p: ProgramScope<Rels, Classes>) => Q): Q;
-export type { OutputBuild, ProgramScope, Rec };
-export { program };
-//# sourceMappingURL=predicate.d.ts.map

package/dist/query/predicate.d.ts.map

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

package/dist/query/predicate.js

@@ -1,156 +0,0 @@
-/**
- * Stratified recursion — engine recursion as values, mirroring the IR's
- * cut exactly (`ir::Program`/`PredicateDef`/`AtomSource::Idb`;
- * `docs/architecture/20-query-ir.md` § engine recursion):
- *
- *   program(S, (p) => {
- *     const reach = p.rec("reach")
- *     reach.rule((r) => {
- *       const n = v(Node)
- *       return r.match(Node, { id: n.id }).where(r.eq(n.id, r.param("root"))).find({ c: n.id })
- *     })
- *     reach.rule((r) => {
- *       const e = v(Parent)
- *       return r.match(Parent, { child: e.child, parent: e.parent }).idb(reach, { c: e.parent }).find({ c: e.child })
- *     })
- *     return p.output((r) => {
- *       const post = v(Posting)
- *       return r.match(Posting, { account: post.account, minor: post.minor })
- *         .idb(reach, { c: post.account }).find({ total: r.sum(post.minor) })
- *     })
- *   })
- *
- * `p.rec(name)` declares one recursive predicate (declaration order = its
- * dense `PredId`); `rec.rule(...)` attaches one clause — its builder's
- * `idb` accepts ONLY the rec itself (the self-recursion cut as a
- * type-level boundary: mutual recursion is unwritable) and its `find` head
- * projects bound variables only (aggregation/measure through a cycle is
- * unrepresentable — the strata judge's roster, made unwritable);
- * `p.output(...)` seals the recs and builds the output rules, whose `idb`
- * folds any FINISHED stratum by NAMED record over its head keys (recipe
- * 25's form). The rec value `.rule` returns carries the params its rules
- * used — thread it into the output's `idb` and the program's inferred
- * `Params` stays exactly the params the rules use. Everything deeper —
- * strata legality, signature sealing, the three oracles — is the ENGINE's
- * judge, surfacing typed at prepare.
- */
-import * as errors from "@superbuilders/errors";
-import { makeOutputRuleScope, makeQuery, makeRawScope } from "#query/lower.ts";
-import { fieldJoins, inferred, renderFieldKind } from "#query/scope.ts";
-/** Builds the runtime rec handle over shared rec data. */
-function makeRawRec(state, name, data) {
-    const rec = {
-        name,
-        data,
-        rule(build) {
-            if (state.sealed) {
-                throw errors.new(`rec ${name}: the program's output is already declared — recursive rules attach before p.output`);
-            }
-            const built = build(makeRawScope({ kind: "rec", self: data, classes: state.classes, theory: state.theory }));
-            const head = data.rules[0];
-            if (head !== undefined) {
-                const declared = head.finds.map(function columnName(column) {
-                    return column.name;
-                });
-                const candidate = built.rule.finds.map(function columnName(column) {
-                    return column.name;
-                });
-                if (declared.join(", ") !== candidate.join(", ")) {
-                    throw errors.new(`rec ${name}: every rule derives the same head — rule 0 projects (${declared.join(", ")}), this rule projects (${candidate.join(", ")})`);
-                }
-                // The law-class wall on the sealed head: names alone do not
-                // align value spaces. Every rule must bind each head column
-                // at a classed mint slot that JOINS rule 0's (the sealing rule
-                // — the one slot every downstream idb pairing class-checks
-                // against), under the same fieldJoins judgment every reuse
-                // site enforces; otherwise a later rule feeds (say) bare
-                // weights into a column the idb joins as Node ids.
-                built.rule.finds.forEach(function verifyHeadSlot(column, position) {
-                    const lead = head.finds[position];
-                    if (lead === undefined) {
-                        return;
-                    }
-                    if (lead.slot !== undefined && column.slot !== undefined && !fieldJoins(lead.slot, column.slot)) {
-                        throw errors.new(`rec ${name}: every rule derives the same head — the head column ${lead.name} is bound at ${renderFieldKind(lead.slot)} in rule 0 but at ${renderFieldKind(column.slot)} in this rule (a head column joins only class-equal slots; bare pairs only with bare)`);
-                    }
-                });
-            }
-            data.rules.push(built.rule);
-            return makeRawRec(state, name, data);
-        }
-    };
-    Object.freeze(rec);
-    return rec;
-}
-/**
- * The rec handles' trusted admission seam (the pattern's home is
- * `isTypedScope` in query/lower.ts):
- * the checkable fact — the handle owns exactly the rec data it names — is
- * verified before the raw handle is admitted at its typed face.
- */
-function isRecHandle(data, rec) {
-    return rec.data === data;
-}
-/** Builds one typed rec handle over shared rec data. */
-function makeRec(state, name, data) {
-    const raw = makeRawRec(state, name, data);
-    if (!isRecHandle(data, raw)) {
-        throw errors.new(`rec ${name}: handle construction incomplete`);
-    }
-    return raw;
-}
-/**
- * Builds a stratified program over a schema. The callback declares recs
- * and their rules through the scope and MUST return `p.output(...)` — the
- * sealed program is an ordinary query value: `db.prepare` lowers it to
- * the one `ProgramIr` shape the engine executes under the per-stratum
- * fixpoint driver.
- */
-function program(theory, build) {
-    const state = { recs: [], classes: theory.classes, theory, sealed: false };
-    const names = new Set();
-    const made = { query: undefined };
-    const scope = {
-        rec(name) {
-            if (state.sealed) {
-                throw errors.new(`program: the output is already declared — rec ${name} would be unreachable`);
-            }
-            if (names.has(name)) {
-                throw errors.new(`program: a rec named ${name} is already declared — rec names are the self-recursion cut's identity`);
-            }
-            names.add(name);
-            const data = { name, rules: [] };
-            state.recs.push(data);
-            return makeRec(state, name, data);
-        },
-        output(...builds) {
-            if (state.sealed) {
-                throw errors.new("program: output is declared once — multiple rules are multiple builds of the one output");
-            }
-            state.sealed = true;
-            for (const rec of state.recs) {
-                if (rec.rules.length === 0) {
-                    throw errors.new(`program: rec ${rec.name} has no rules — a predicate with no defining clause seals no signature`);
-                }
-                Object.freeze(rec.rules);
-            }
-            if (builds.length === 0) {
-                throw errors.new("program: the output needs at least one rule");
-            }
-            const rules = builds.map(function buildRule(buildOne) {
-                return buildOne(makeOutputRuleScope(state)).rule;
-            });
-            const q = makeQuery(theory, state.recs, rules);
-            made.query = q;
-            return q;
-        }
-    };
-    Object.freeze(scope);
-    const result = build(scope);
-    if (made.query !== result) {
-        throw errors.new("program: the build callback must return p.output(...) — the sealed program IS the query value");
-    }
-    return result;
-}
-export { program };
-//# sourceMappingURL=predicate.js.map

package/dist/query/predicate.js.map

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

package/src/order.ts

@@ -1,234 +0,0 @@
-/**
- * Host-side answer ordering — the census-fired convenience
- * (`docs/architecture/70-api.md` § the freeze ledger). Answers are SETS and
- * the ENGINE NEVER ORDERS; the language owns the sort (`rows.sort(...)`)
- * and the limit (`.slice(0, n)`) — the drizzle law. What JS lacks is a
- * number-returning comparator over the SDK's bigint-bearing cells, so the
- * SDK ships exactly that: sort keys are DATA — a bare column name is
- * ascending (the punning spelling; no `asc` wrapper exists — one spelling
- * per meaning) and `desc(name)` is the one descending spelling — folded by
- * `by(...)` into one row-typed comparator. Cross-type cells cannot arise
- * within one column (one column, one domain), and the cell order is TOTAL
- * anyway (the type-rank wall), so the comparator never throws.
- *
- * ZERO keys is the identity key (ruled 2026-07-25): `by()` / `desc()` are
- * the same two spellings over BARE scalar arrays (`bigint[]` of ids, map
- * keys) — with no column to name, the value itself is the key, there is
- * nothing to fold, and the comparator IS the result. One ordering
- * vocabulary, no sibling names. The identity arms are typed to EXACTLY the
- * engine-orderable roster ({@link EngineOrderable}) because a bare scalar
- * carries no decoded-row provenance — the type wall must carry the
- * orderability law itself, where the row arm's cells arrive under their
- * columns' law-typed proof.
- */
-
-import type { FactValue } from "#native.ts"
-
-/** One DESCENDING sort key, plain data — built by {@link desc}. */
-interface Desc<K extends string> {
-	readonly key: K
-	readonly desc: true
-}
-
-/** One sort key: a bare column name (ascending — the punning spelling) or `desc(name)`. */
-type SortKey<K extends string> = K | Desc<K>
-
-/**
- * The engine-orderable scalar roster in the SDK's representation — `bigint`
- * (U64/I64) and `boolean` (false < true — the strict 0/1 encoding IS the
- * order), EXACTLY as `docs/architecture/10-data-model.md` § "Orderability,
- * complete" admits it (ruled 2026-07-23, R3/R4), and nothing more:
- * `string` is deliberately absent (intern ids are meaningless to order — a
- * typed refusal, not a gap) and `number` is not an engine scalar at all.
- * The identity comparators `by()`/`desc()` constrain on this alias, so
- * sorting a `string[]` or `number[]` through them is a COMPILE error naming
- * this roster. ONE OWNER for scalar ordering semantics: both identity arms
- * route through the same cell order the row arm uses, whose bigint and
- * boolean arms mirror the engine's U64/I64/Bool order exactly — a host
- * sort over these values can never disagree with an engine order judgment
- * (`Lt`-family, `Min`/`Max`) over the same column.
- */
-type EngineOrderable = bigint | boolean
-
-/**
- * The type-rank wall: boolean 0, bigint 1, string 2, bytes 3, interval 4.
- * One column carries one domain, so a mixed pair never arises from decoded
- * answer rows — the wall exists to keep the cell order TOTAL (never a
- * throw), not to be reached.
- */
-function cellRank(value: FactValue): number {
-	if (typeof value === "boolean") {
-		return 0
-	}
-	if (typeof value === "bigint") {
-		return 1
-	}
-	if (typeof value === "string") {
-		return 2
-	}
-	if (value instanceof Uint8Array) {
-		return 3
-	}
-	return 4
-}
-
-/**
- * One cell against one cell. Same-type arms: boolean orders false < true;
- * bigint by `<`/`>`; string by the host language's own `<`/`>` (flavor,
- * recorded); bytes bytewise over the shared prefix, then by length;
- * intervals by start, then end. A mixed pair falls through to the
- * type-rank wall.
- */
-function cellCmp(left: FactValue, right: FactValue): number {
-	if (typeof left === "boolean" && typeof right === "boolean") {
-		if (left === right) {
-			return 0
-		}
-		if (left) {
-			return 1
-		}
-		return -1
-	}
-	if (typeof left === "bigint" && typeof right === "bigint") {
-		if (left < right) {
-			return -1
-		}
-		if (left > right) {
-			return 1
-		}
-		return 0
-	}
-	if (typeof left === "string" && typeof right === "string") {
-		if (left < right) {
-			return -1
-		}
-		if (left > right) {
-			return 1
-		}
-		return 0
-	}
-	if (left instanceof Uint8Array && right instanceof Uint8Array) {
-		const shared = Math.min(left.length, right.length)
-		for (let index = 0; index < shared; index += 1) {
-			const leftByte = left[index]
-			const rightByte = right[index]
-			// `index < shared` keeps both reads in bounds; the `undefined`
-			// arms are the checker's indexed-access tax, never taken.
-			if (leftByte !== undefined && rightByte !== undefined && leftByte !== rightByte) {
-				return leftByte - rightByte
-			}
-		}
-		return left.length - right.length
-	}
-	if (
-		typeof left === "object" &&
-		!(left instanceof Uint8Array) &&
-		typeof right === "object" &&
-		!(right instanceof Uint8Array)
-	) {
-		if (left.start < right.start) {
-			return -1
-		}
-		if (left.start > right.start) {
-			return 1
-		}
-		if (left.end < right.end) {
-			return -1
-		}
-		if (left.end > right.end) {
-			return 1
-		}
-		return 0
-	}
-	return cellRank(left) - cellRank(right)
-}
-
-/**
- * The ascending identity comparator `by()` returns — one value, minted
- * once (`by() === by()`), {@link cellCmp} narrowed to the engine-orderable
- * roster (the one owner of the cell order).
- */
-function identityAscending<T extends EngineOrderable>(left: T, right: T): number {
-	return cellCmp(left, right)
-}
-
-/** The descending identity comparator `desc()` returns — the same owner, sides flipped. */
-function identityDescending<T extends EngineOrderable>(left: T, right: T): number {
-	return cellCmp(right, left)
-}
-
-/**
- * The descending spelling — ONE name, both arities of one ordering
- * vocabulary. `desc(name)` marks one sort key DESCENDING: plain data for
- * {@link by} to fold (a bare name is already ascending). `desc()` — zero
- * keys, the identity key (ruled 2026-07-25) — is the descending comparator
- * over engine-orderable scalars themselves: a bare `bigint[]` or
- * `boolean[]` has no column to name, so the value IS the key, there is
- * nothing to fold, and the comparator is the result directly. The identity
- * arm covers EXACTLY the {@link EngineOrderable} roster — `string` and
- * `number` refuse at compile time, citing the orderability law
- * (`10-data-model.md` § "Orderability, complete").
- */
-function desc(): <T extends EngineOrderable>(left: T, right: T) => number
-function desc<const K extends string>(key: K): Desc<K>
-function desc<const K extends string>(key?: K): Desc<K> | (<T extends EngineOrderable>(left: T, right: T) => number) {
-	if (key === undefined) {
-		return identityDescending
-	}
-	const marker: Desc<K> = { key, desc: true }
-	return Object.freeze(marker)
-}
-
-/**
- * Folds sort keys into ONE comparator typed against the row —
- * `Row extends Readonly<Record<K, FactValue>>` — so a key the row lacks, or
- * a column typed `number` (outside the cell domain), is a COMPILE error at
- * the `.sort` call site: the laws typed the columns, and the row type
- * carries that proof here (parse-don't-validate). The generic RETURN is the
- * load-bearing trick: `rows.sort(by("rank"))` instantiates `Row` from the
- * array's own element type and checks the key set right there.
- *
- * ZERO keys is the identity key (ruled 2026-07-25): `by()` is the
- * ascending comparator over engine-orderable scalars themselves —
- * `ids.sort(by())` — for the bare arrays (`bigint[]`, map keys) the
- * row-typed arm cannot reach because they have no column to name. One
- * vocabulary, both arities. The identity arm is typed to EXACTLY the
- * {@link EngineOrderable} roster: with no law-typed column standing proof
- * over the values, the type wall carries the orderability law itself —
- * `string` ordering is deliberately refused and `number` is not an engine
- * scalar (`10-data-model.md` § "Orderability, complete"), so both refuse
- * at compile time and a host sort can never disagree with an engine order
- * judgment.
- */
-function by(): <T extends EngineOrderable>(left: T, right: T) => number
-function by<const K extends string>(
-	first: SortKey<K>,
-	...rest: ReadonlyArray<SortKey<K>>
-): <Row extends Readonly<Record<K, FactValue>>>(left: Row, right: Row) => number
-function by<const K extends string>(
-	...keys: ReadonlyArray<SortKey<K>>
-):
-	| (<T extends EngineOrderable>(left: T, right: T) => number)
-	| (<Row extends Readonly<Record<K, FactValue>>>(left: Row, right: Row) => number) {
-	if (keys.length === 0) {
-		return identityAscending
-	}
-	const entries = keys.map(function normalizeKey(sortKey): { readonly key: K; readonly factor: 1 | -1 } {
-		if (typeof sortKey === "string") {
-			return { key: sortKey, factor: 1 }
-		}
-		return { key: sortKey.key, factor: -1 }
-	})
-	return function compare<Row extends Readonly<Record<K, FactValue>>>(left: Row, right: Row): number {
-		for (const entry of entries) {
-			const order = cellCmp(left[entry.key], right[entry.key]) * entry.factor
-			if (order !== 0) {
-				return order
-			}
-		}
-		return 0
-	}
-}
-
-export type { Desc, EngineOrderable, SortKey }
-export { by, desc }