@bjornpagen/bumbledb 0.10.0 → 0.12.0

package/src/query/parse-ir.ts

@@ -0,0 +1,82 @@
+/**
+ * Host shape parse for the wire `QueryIr`: CQ/Reach eliminator, rec/main
+ * nonempty, aggregate finds split (Count has no `over`; folds require
+ * it), head/find alignment. The engine validator remains the one roster
+ * authority — this parse refuses only shape the host type can see.
+ */
+
+import * as errors from "@superbuilders/errors"
+import type { FindTermIr, HeadTermIr, ParsedQuery, QueryIr, RuleIr } from "#native.ts"
+
+/** Brands a shape-checked wire query so {@link Native.dbPrepare} will accept it. */
+function parseQueryIr(ir: QueryIr): ParsedQuery {
+	if (ir.rules.length === 0) {
+		throw errors.new("parseQueryIr: main rules are empty")
+	}
+	align("query", ir.head, ir.rules)
+	ir.interiors.forEach(function checkInterior(interior, index) {
+		align(`interior ${index}`, interior.head, interior.rules)
+	})
+	if (ir.kind === "reach") {
+		if (ir.rec.base.length === 0) {
+			throw errors.new("parseQueryIr: rec base is empty")
+		}
+		if (ir.rec.rec.length === 0) {
+			throw errors.new("parseQueryIr: rec step is empty")
+		}
+		align("rec base", ir.rec.head, ir.rec.base)
+		align("rec step", ir.rec.head, ir.rec.rec)
+	}
+	return ir as ParsedQuery
+}
+
+/** One rule list must share the head's width and var/aggregate family. */
+function align(context: string, head: readonly HeadTermIr[], rules: readonly RuleIr[]): void {
+	for (const [ruleIndex, rule] of rules.entries()) {
+		if (rule.finds.length !== head.length) {
+			throw errors.new(
+				`${context}: rule ${ruleIndex} finds width ${rule.finds.length} does not match head width ${head.length}`
+			)
+		}
+		rule.finds.forEach(function checkFind(find, position) {
+			parseFind(`${context} rule ${ruleIndex} find ${position}`, find)
+			const family = findFamily(find)
+			if (family !== head[position]?.kind) {
+				throw errors.new(
+					`${context}: rule ${ruleIndex} find ${position} is ${family}, not head ${head[position]?.kind}`
+				)
+			}
+		})
+	}
+}
+
+/** Count forbids `over`; every other aggregate requires it. */
+function parseFind(context: string, find: FindTermIr): void {
+	if (find.kind !== "aggregate") {
+		return
+	}
+	if (find.op.kind === "count") {
+		if ("over" in find) {
+			throw errors.new(`${context}: Count carries no over`)
+		}
+		return
+	}
+	if (!("over" in find)) {
+		throw errors.new(`${context}: fold aggregate requires over`)
+	}
+}
+
+/** Head family of one find term: measure is a var slot; measure-folds are aggregates. */
+function findFamily(find: FindTermIr): "var" | "aggregate" {
+	switch (find.kind) {
+		case "var":
+		case "measure":
+			return "var"
+		case "aggregate":
+		case "aggregateMeasure":
+			return "aggregate"
+	}
+}
+
+export type { ParsedQuery }
+export { parseQueryIr }

package/src/query/run.ts

@@ -20,18 +20,9 @@ import * as errors from "@superbuilders/errors"
 import { handleOf } from "#marshal.ts"
 import type { FactValue, QueryParam, TaggedValue } from "#native.ts"
 import type { FindColumn } from "#query/atom.ts"
-import { ALLEN_ALL_BITS } from "#query/atom.ts"
 import { taggedCmpLiteral } from "#query/lower.ts"
 import type { ParamEntry } from "#query/scope.ts"
 
-/** Tags one supplied mask-param value. */
-function wireMask(name: string, value: unknown): TaggedValue {
-	if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > ALLEN_ALL_BITS) {
-		throw errors.new(`param ${name}: an Allen-mask param binds a 13-bit mask number built from the ALLEN constants`)
-	}
-	return { kind: "allenMask", mask: value }
-}
-
 /** Tags one supplied value-param cell by its anchoring use. */
 function wireValue(entry: ParamEntry, context: string, value: unknown): TaggedValue {
 	if (entry.anchor === undefined) {
@@ -48,7 +39,7 @@ function wireValue(entry: ParamEntry, context: string, value: unknown): TaggedVa
  * is a typed error naming the param; values tag by the anchoring use's
  * structural type; a set param takes a readonly array (the empty set is
  * legal and matches nothing — the engine's rule). A MEMBERSHIP-ARRAY
- * entry (`membership` present — a literal set folded into the program) is
+ * entry (`membership` present — a literal set folded into the query) is
  * a program constant the registry already resolved through the one
  * roster-verification point at BUILD time: it crosses as its prebuilt
  * frozen `{ kind: "set", values }` by reference — the host's params object
@@ -63,9 +54,6 @@ function wireParams(entries: readonly ParamEntry[], supplied: Readonly<Record<st
 		if (value === undefined) {
 			throw errors.new(`execute params object is missing param ${entry.name}`)
 		}
-		if (entry.shape === "mask") {
-			return wireMask(entry.name, value)
-		}
 		if (entry.shape === "set") {
 			if (!Array.isArray(value)) {
 				throw errors.new(`param ${entry.name}: a set param binds a readonly array of values`)
@@ -98,7 +86,7 @@ function isAnswerRow<Row>(
 }
 
 /**
- * Decodes positional answer rows (column order = the program's head order
+ * Decodes positional answer rows (column order = the query's head order
  * = the select's written order) to named, frozen row objects of bare
  * structural values. A closed column lifts its row id back to the handle
  * NAME through the marshal's bijection — an out-of-roster id is the same

package/src/query/scope.ts

@@ -119,17 +119,6 @@ interface SetParam<Name extends string = string> {
 	readonly name: Name
 }
 
-/**
- * An Allen-mask parameter (the IR's `MaskTerm::Param`) — the temporal
- * relation as a bind-time argument: one prepared query answers any of the
- * mask questions per execution. Bound to a 13-bit mask number built from
- * the `ALLEN` constants.
- */
-interface MaskParam<Name extends string = string> {
-	readonly [term]: "maskParam"
-	readonly name: Name
-}
-
 /**
  * The measure of an interval-typed variable (`ir::Term::Measure`):
  * `|[s, e)| = e − s`, u64 — legal as one side of an order comparison, as a
@@ -143,7 +132,7 @@ interface Duration<V extends AnyVar = AnyVar> {
 }
 
 /** Any scope term value. */
-type AnyTerm = Var | Param | SetParam | MaskParam | Duration
+type AnyTerm = Var | Param | SetParam | Duration
 
 /** Narrows an unknown position value to a scope term (vs a host literal). */
 function isTerm(value: unknown): value is AnyTerm {
@@ -213,12 +202,6 @@ function makeSetParam<const Name extends string>(name: Name): SetParam<Name> {
 	return Object.freeze(value)
 }
 
-/** Builds one Allen-mask-parameter term. */
-function makeMaskParam<const Name extends string>(name: Name): MaskParam<Name> {
-	const value: MaskParam<Name> = { [term]: "maskParam", name }
-	return Object.freeze(value)
-}
-
 /** Builds one measure term over an interval-typed variable reference. */
 function makeDuration<const V extends AnyVar>(over: V): Duration<V> {
 	const value: Duration<V> = { [term]: "duration", over }
@@ -391,7 +374,7 @@ type InferredOf<T> = T extends { readonly [inferred]?: infer S } ? Exclude<S, un
  */
 interface ParamEntry {
 	readonly name: string
-	readonly shape: "value" | "set" | "mask"
+	readonly shape: "value" | "set"
 	readonly anchor: AnyField | "measure" | undefined
 	readonly op: "binding" | "eq" | "ne" | "lt" | "le" | "gt" | "ge" | "pointIn" | "allen"
 	readonly membership: QueryParam | undefined
@@ -405,7 +388,6 @@ export type {
 	Flatten,
 	InferredOf,
 	JoinOk,
-	MaskParam,
 	MatchFields,
 	MatchOwner,
 	MintClassOf,
@@ -420,4 +402,4 @@ export type {
 	Var,
 	VarsOf
 }
-export { fieldJoins, inferred, isTerm, makeDuration, makeMaskParam, makeParam, makeSetParam, renderFieldKind, term, v }
+export { fieldJoins, inferred, isTerm, makeDuration, makeParam, makeSetParam, renderFieldKind, term, v }

package/src/schema.ts

@@ -138,11 +138,11 @@ function verifyHandles(name: string, statement: Statement, rendered: string): vo
 function closedTargetOf(statements: readonly Statement[], owner: string, field: string): string | undefined {
 	for (const statement of statements) {
 		const data = statement.data
-		if (data.kind !== "containment") {
+		if (data.kind !== "containment" && data.kind !== "mirrors") {
 			continue
 		}
 		const pairs: Array<readonly [FaceData, FaceData]> = [[data.source, data.target]]
-		if (data.bidirectional) {
+		if (data.kind === "mirrors") {
 			pairs.push([data.target, data.source])
 		}
 		for (const [source, target] of pairs) {

package/src/statements.ts

@@ -70,7 +70,12 @@ interface ContainmentData<Src extends FaceData = FaceData, Tgt extends FaceData
 	readonly kind: "containment"
 	readonly source: Src
 	readonly target: Tgt
-	readonly bidirectional: boolean
+}
+
+interface MirrorsData<Src extends FaceData = FaceData, Tgt extends FaceData = FaceData> {
+	readonly kind: "mirrors"
+	readonly source: Src
+	readonly target: Tgt
 }
 
 /**
@@ -88,7 +93,7 @@ interface CapacityData<Tgt extends FaceData = FaceData, Src extends FaceData = F
 }
 
 /** One statement's runtime description, tagged by form. */
-type StatementData = KeyData<AnyRelation, readonly string[]> | ContainmentData | CapacityData
+type StatementData = KeyData<AnyRelation, readonly string[]> | ContainmentData | MirrorsData | CapacityData
 
 /**
  * The admission brand — a module-private symbol, deliberately unexported
@@ -128,7 +133,7 @@ function isStatement(value: unknown): value is Statement {
  * {@link Statement}.
  */
 interface ContainedStatement<Src extends FaceData, Tgt extends FaceData> extends Statement {
-	readonly data: ContainmentData<Src, Tgt>
+	readonly data: ContainmentData<Src, Tgt> | MirrorsData<Src, Tgt>
 }
 
 /** A capacity statement as a TYPED value — the {@link ContainedStatement} of the capacity form. */
@@ -247,8 +252,7 @@ function contained<A extends AnyFace, B extends AnyFace>(
 	const data: ContainmentData<A["data"], B["data"]> = Object.freeze({
 		kind: "containment",
 		source: source.data,
-		target: target.data,
-		bidirectional: false
+		target: target.data
 	})
 	const statement = Object.freeze({ data, [admitted]: true as const })
 	assertArityAgreement(data.source, data.target, statement)
@@ -269,11 +273,10 @@ function mirrors<A extends AnyFace, B extends AnyFace>(
 	source: A,
 	target: B & SameArity<A, B> & SameShapes<A, B>
 ): ContainedStatement<A["data"], B["data"]> {
-	const data: ContainmentData<A["data"], B["data"]> = Object.freeze({
-		kind: "containment",
+	const data: MirrorsData<A["data"], B["data"]> = Object.freeze({
+		kind: "mirrors",
 		source: source.data,
-		target: target.data,
-		bidirectional: true
+		target: target.data
 	})
 	const statement = Object.freeze({ data, [admitted]: true as const })
 	assertArityAgreement(data.source, data.target, statement)
@@ -445,10 +448,10 @@ function renderStatement(statement: Statement): string {
 	switch (data.kind) {
 		case "key":
 			return `${data.owner.name}(${data.projection.join(", ")}) -> ${data.owner.name}`
-		case "containment": {
-			const operator = data.bidirectional ? "==" : "<="
-			return `${renderFace(data.source)} ${operator} ${renderFace(data.target)}`
-		}
+		case "containment":
+			return `${renderFace(data.source)} <= ${renderFace(data.target)}`
+		case "mirrors":
+			return `${renderFace(data.source)} == ${renderFace(data.target)}`
 		case "capacity":
 			return `${renderFace(data.target)} <=${renderWeight(data.weight)}${renderCapacityWindow(data.window)} ${renderFace(data.source)}`
 	}
@@ -461,6 +464,7 @@ export type {
 	ContainmentData,
 	KeyData,
 	KeyStatement,
+	MirrorsData,
 	Statement,
 	StatementData
 }

package/dist/order.d.ts

@@ -1,87 +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 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").
- */
-declare function desc(): <T extends EngineOrderable>(left: T, right: T) => number;
-declare function desc<const K extends string>(key: K): Desc<K>;
-/**
- * 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.
- */
-declare function by(): <T extends EngineOrderable>(left: T, right: T) => number;
-declare function by<const K extends string>(first: SortKey<K>, ...rest: ReadonlyArray<SortKey<K>>): <Row extends Readonly<Record<K, FactValue>>>(left: Row, right: Row) => number;
-export type { Desc, EngineOrderable, SortKey };
-export { by, desc };
-//# sourceMappingURL=order.d.ts.map

package/dist/order.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"order.d.ts","sourceRoot":"","sources":["../src/order.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAE3C,mEAAmE;AACnE,UAAU,IAAI,CAAC,CAAC,SAAS,MAAM;IAC9B,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAA;IACf,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;CACnB;AAED,2FAA2F;AAC3F,KAAK,OAAO,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AAE5C;;;;;;;;;;;;;;GAcG;AACH,KAAK,eAAe,GAAG,MAAM,GAAG,OAAO,CAAA;AA6GvC;;;;;;;;;;;GAWG;AACH,iBAAS,IAAI,IAAI,CAAC,CAAC,SAAS,eAAe,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,MAAM,CAAA;AACzE,iBAAS,IAAI,CAAC,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AAStD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,iBAAS,EAAE,IAAI,CAAC,CAAC,SAAS,eAAe,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,MAAM,CAAA;AACvE,iBAAS,EAAE,CAAC,KAAK,CAAC,CAAC,SAAS,MAAM,EACjC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,EACjB,GAAG,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAChC,CAAC,GAAG,SAAS,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,KAAK,MAAM,CAAA;AA0BhF,YAAY,EAAE,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,CAAA;AAC9C,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,CAAA"}

package/dist/order.js

@@ -1,153 +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.
- */
-/**
- * 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) {
-    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, right) {
-    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(left, right) {
-    return cellCmp(left, right);
-}
-/** The descending identity comparator `desc()` returns — the same owner, sides flipped. */
-function identityDescending(left, right) {
-    return cellCmp(right, left);
-}
-function desc(key) {
-    if (key === undefined) {
-        return identityDescending;
-    }
-    const marker = { key, desc: true };
-    return Object.freeze(marker);
-}
-function by(...keys) {
-    if (keys.length === 0) {
-        return identityAscending;
-    }
-    const entries = keys.map(function normalizeKey(sortKey) {
-        if (typeof sortKey === "string") {
-            return { key: sortKey, factor: 1 };
-        }
-        return { key: sortKey.key, factor: -1 };
-    });
-    return function compare(left, right) {
-        for (const entry of entries) {
-            const order = cellCmp(left[entry.key], right[entry.key]) * entry.factor;
-            if (order !== 0) {
-                return order;
-            }
-        }
-        return 0;
-    };
-}
-export { by, desc };
-//# sourceMappingURL=order.js.map

package/dist/order.js.map

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

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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"}