@bjornpagen/bumbledb 0.9.0 → 0.11.0

package/src/query/parse-ir.ts

@@ -0,0 +1,82 @@
+/**
+ * Host shape parse for the wire `QueryIr`: 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.rec !== null) {
+		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

@@ -41,6 +41,7 @@ import {
 	type CapacityWindow,
 	isCapacityWeight,
 	isCapacityWindow,
+	type UnitDimensionBan,
 	type UnitWindowBan,
 	unitWeight,
 	type WeightOnSource
@@ -69,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
 }
 
 /**
@@ -87,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
@@ -127,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. */
@@ -246,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)
@@ -268,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)
@@ -357,13 +361,15 @@ function assertBoundsOnTarget(window: CapacityWindowSpec, target: FaceData, stat
  * on(Device, "pool"))` bounds each pool's summed draw by the pool's own
  * row. The two faces pair by arity AND structural shape
  * ({@link SameShapes}), exactly as containment — the grouping join reads
- * the same positionwise field pairing. The weight-sensitive `{1..*}` ban
- * rides the UNIT overload only ({@link UnitWindowBan} — on a weighted
- * statement "positive total" is a different, weaker law than containment).
+ * the same positionwise field pairing. The weight-sensitive bans ride the
+ * UNIT overload only: `{1..*}` ({@link UnitWindowBan} — on a weighted
+ * statement "positive total" is a different, weaker law than containment)
+ * and the `duration()` bound ({@link UnitDimensionBan} — a count of facts
+ * bounded by a span of time mixes dimensions, C18).
  */
 function capacity<B extends AnyFace, W extends CapacityWindow, A extends AnyFace>(
 	target: B,
-	window: W & UnitWindowBan<W> & BoundsOnTarget<W, B>,
+	window: W & UnitWindowBan<W> & UnitDimensionBan<W> & BoundsOnTarget<W, B>,
 	source: A & SameArity<B, A> & SameShapes<B, A>
 ): CapacityStatement<B["data"], A["data"]>
 function capacity<B extends AnyFace, M extends CapacityWeight, W extends CapacityWindow, A extends AnyFace>(
@@ -401,6 +407,15 @@ function capacity(
 			"`{1..*}` on the unit instance says only what the bare containment says — drop the annotation and write the containment: contained(source, target)"
 		)
 	}
+	// The C18 dimension gate, unit instance (the engine's
+	// CapacityDimensionMixing twin — ruled 2026-07-24): a count of facts
+	// bounded by a span of time mixes dimensions. Judged here for untyped
+	// callers; the engine's validate_capacity stays the final authority.
+	if (weight.kind === "unit" && window.kind === "range" && window.hi.kind === "durationField") {
+		throw errors.new(
+			`a unit (count) window against the duration() bound on ${window.hi.field} mixes dimensions (C18) — weigh the source with weigh(duration(field)), or bound by a u64 field or literal`
+		)
+	}
 	const data: CapacityData = Object.freeze({
 		kind: "capacity",
 		target: target.data,
@@ -433,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)}`
 	}
@@ -449,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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"}