@bjornpagen/bumbledb 0.4.0 → 0.6.0

package/src/fields.ts

@@ -172,15 +172,31 @@ type Infer<F extends AnyField> = F extends { readonly kind: "bool" }
 							: never
 
 /**
- * The typed shape refusal of the selection-literal machine — reached only
+ * The typed shape refusal shared by every literal machine — the selection
+ * lowering here, the row marshaler (`marshal.ts`), and the query-literal
+ * tagger (`query/lower.ts`) all throw through this ONE voice; reached only
  * through ill-typed input (the well-typed surfaces make it unrepresentable).
  */
-function literalShapeError(expected: string, value: unknown): Error {
-	return errors.new(`selection literal shape mismatch: expected ${expected}, got ${typeof value}`)
+function literalShapeError(context: string, expected: string, value: unknown): Error {
+	return errors.new(`${context}: expected ${expected}, got ${typeof value}`)
 }
 
-/** Narrows an interval literal: a plain object with bigint start/end. */
-function isIntervalLiteral(value: unknown): value is IntervalValue {
+/**
+ * The roster a field descriptor carries — THE one reader: present exactly
+ * on a closed-reference descriptor (the structural `closed` property of
+ * {@link ClosedIdField}), absent on every other field kind. Tolerates
+ * `undefined` so name-lookup misses flow through without a re-spelled
+ * probe at every call site.
+ */
+function rosterOf(field: AnyField | undefined): ClosedRoster | undefined {
+	if (field !== undefined && "closed" in field) {
+		return field.closed
+	}
+	return undefined
+}
+
+/** Narrows an interval-shaped value: a plain object with bigint start/end — THE one interval predicate. */
+function isIntervalValue(value: unknown): value is IntervalValue {
 	return (
 		typeof value === "object" &&
 		value !== null &&
@@ -202,7 +218,7 @@ function isIntervalLiteral(value: unknown): value is IntervalValue {
  */
 function handleLiteral(closed: ClosedRoster, value: unknown): LiteralSpec {
 	if (typeof value !== "string") {
-		throw literalShapeError(`a ${closed.name} handle name (string)`, value)
+		throw literalShapeError("selection literal", `a ${closed.name} handle name (string)`, value)
 	}
 	if (!closed.handles.includes(value)) {
 		throw errors.new(`"${value}" is not a handle of ${closed.name} — the roster is ${closed.handles.join(", ")}`)
@@ -212,8 +228,8 @@ function handleLiteral(closed: ClosedRoster, value: unknown): LiteralSpec {
 
 /** Lowers one interval literal at its element type. */
 function intervalLiteral(element: "u64" | "i64", value: unknown): LiteralSpec {
-	if (!isIntervalLiteral(value)) {
-		throw literalShapeError("interval ({ start, end } bigints)", value)
+	if (!isIntervalValue(value)) {
+		throw literalShapeError("selection literal", "interval ({ start, end } bigints)", value)
 	}
 	if (element === "u64") {
 		return { kind: "value", value: { kind: "intervalU64", start: value.start, end: value.end } }
@@ -306,37 +322,50 @@ function interval(element: U64Field | I64Field, width?: bigint): IntervalField<"
  * else lowers to a plain value tagged by the field's structural kind.
  */
 function literalOf(field: AnyField, value: unknown): LiteralSpec {
-	if ("closed" in field) {
-		return handleLiteral(field.closed, value)
+	const roster = rosterOf(field)
+	if (roster !== undefined) {
+		return handleLiteral(roster, value)
 	}
 	switch (field.kind) {
 		case "bool": {
 			if (typeof value !== "boolean") {
-				throw literalShapeError("boolean", value)
+				throw literalShapeError("selection literal", "boolean", value)
 			}
 			return { kind: "value", value: { kind: "bool", value } }
 		}
 		case "u64": {
 			if (typeof value !== "bigint") {
-				throw literalShapeError("bigint", value)
+				throw literalShapeError("selection literal", "bigint", value)
 			}
 			return { kind: "value", value: { kind: "u64", value } }
 		}
 		case "i64": {
 			if (typeof value !== "bigint") {
-				throw literalShapeError("bigint", value)
+				throw literalShapeError("selection literal", "bigint", value)
 			}
 			return { kind: "value", value: { kind: "i64", value } }
 		}
 		case "str": {
 			if (typeof value !== "string") {
-				throw literalShapeError("string", value)
+				throw literalShapeError("selection literal", "string", value)
+			}
+			/**
+			 * The marshal's bijection law at the schema-literal seam
+			 * (`marshal.ts` cellOf): a lone surrogate would cross dbCreate
+			 * lossily (stored as U+FFFD engine-side), collapsing two
+			 * distinct TS schema values into one stored theory/fingerprint
+			 * and splitting the canonical statement rendering from the
+			 * SDK's. All three string-admission seams — fact row, query
+			 * literal/param, schema literal — enforce the one law.
+			 */
+			if (!value.isWellFormed()) {
+				throw literalShapeError("selection literal", "well-formed string", value)
 			}
 			return { kind: "value", value: { kind: "string", value } }
 		}
 		case "bytes": {
 			if (!(value instanceof Uint8Array)) {
-				throw literalShapeError("Uint8Array", value)
+				throw literalShapeError("selection literal", "Uint8Array", value)
 			}
 			return { kind: "value", value: { kind: "fixedBytes", value } }
 		}
@@ -359,4 +388,17 @@ export type {
 	StrField,
 	U64Field
 }
-export { assertDeclarationOrderKey, bool, bytes, i64, interval, literalOf, span, str, u64 }
+export {
+	assertDeclarationOrderKey,
+	bool,
+	bytes,
+	i64,
+	interval,
+	isIntervalValue,
+	literalOf,
+	literalShapeError,
+	rosterOf,
+	span,
+	str,
+	u64
+}

package/src/index.ts

@@ -8,16 +8,21 @@
  * runtime (path-cached stores, transactions, typed violations, scoped
  * snapshot reads, the witnessed write loop with `abandon` — PRD-07, zero
  * closables), the query surface (Datalog as values, kysely-shaped:
- * `query(S).rule(r => r.match(...).where(...).select(...))` with
- * string-named domain-typed vars, params typed by use, negation,
+ * `query(S).rule(r => { const { id, name } = v(Holder); return r.match(Holder, { id, name }).find({ name }) })` —
+ * variables minted by `v()` and joined by OBJECT REFERENCE (reuse is the
+ * join), the head a `find` RECORD whose keys name the answer columns
+ * (renames are real), params still STRING-named, plus negation,
  * conditions, aggregates, and stratified recursion via `program()`/`rec` —
  * `db.prepare` as a plain value; the comparison/connective builders are
  * also free exports, and the free names `eq`/`not`/`and`/`or` collide with
  * common host identifiers — import aliasing is the answer; the SDK does
- * not rename for collision-avoidance), and the exhume surface
+ * not rename for collision-avoidance), the exhume surface
  * (`Db.exhume` — the one schema-independent read path: the store's
  * self-described shapes and raw facts by name, typed at bare structural
- * values, deliberately schema-free). The raw native bridge is not exported.
+ * values, deliberately schema-free), and the answer-ordering helpers
+ * (`by`/`desc` — sort keys as data for the language's own `.sort`; answers
+ * are sets, the engine never orders, and limit is the language's own
+ * `.slice`). The raw native bridge is not exported.
  */
 
 export type {
@@ -50,7 +55,7 @@ export type {
 	WitnessedWriteResult,
 	WriteResult
 } from "#db.ts"
-export { abandon, Db, ErrNewtypeMismatch } from "#db.ts"
+export { abandon, Db, ErrNewtypeMismatch, ErrWitnessedLivelock, WITNESSED_ATTEMPT_CAP } from "#db.ts"
 export type {
 	Exhumed,
 	ExhumedAxiom,
@@ -105,21 +110,22 @@ export type {
 	Staleness,
 	StatementKindTag
 } from "#native.ts"
+export type { Desc, SortKey } from "#order.ts"
+export { by, desc } from "#order.ts"
 
 export type {
 	AnyCond,
 	BindingInput,
 	Cmp,
-	MatchFields,
-	MatchOwner,
+	FindColumn,
 	MatchShape,
 	NotAtom,
 	RecData,
 	RuleData,
-	SelectColumn,
 	Tree
 } from "#query/atom.ts"
-export { ALLEN, allen, and, covers, eq, ge, gt, le, lt, ne, not, or, pointIn } from "#query/atom.ts"
+export { ALLEN, allen, and, eq, ge, gt, le, lt, ne, not, or, pointIn } from "#query/atom.ts"
+export type { Agg, FindEntry } from "#query/find.ts"
 export type {
 	AnyQuery,
 	AnyRuleValue,
@@ -146,20 +152,20 @@ export type {
 	ClassedField,
 	Duration,
 	MaskParam,
+	MatchFields,
+	MatchOwner,
 	Param,
 	ParamEntry,
 	ParamsRecord,
 	SetParam,
 	Var,
-	VarsRecord
+	VarsOf
 } from "#query/scope.ts"
-export type { Agg, SelectEntry } from "#query/select.ts"
+export { v } from "#query/scope.ts"
 export type {
 	AnyRelation,
 	AnySelected,
 	Fact,
-	FieldRef,
-	FieldRefs,
 	FieldsShape,
 	FreshKeys,
 	InsertFact,

package/src/law.ts

@@ -52,6 +52,7 @@
 
 import * as errors from "@superbuilders/errors"
 import type { AnyClosed } from "#closed.ts"
+import { isClosedMember, sealedFieldsOf } from "#closed.ts"
 import type { FaceData } from "#face.ts"
 import type { AnyRelation, RelationFields } from "#relation.ts"
 import type { SchemaRelation, SchemaRelations } from "#schema.ts"
@@ -328,22 +329,21 @@ interface MemberCoords {
 	readonly fields: ReadonlyArray<{ readonly name: string; readonly generator: boolean }>
 }
 
-/** Reads every member's coordinates off the relation record, declaration order throughout. */
+/**
+ * Reads every member's coordinates off the relation record, declaration
+ * order throughout — the sealed shape through THE one reader
+ * (`sealedFieldsOf`): a closed member's generator is its synthetic `id`
+ * (ordinal 0), an ordinary member's generators are its fresh-marked fields.
+ */
 function memberCoords(relations: SchemaRelations): MemberCoords[] {
 	const out: MemberCoords[] = []
 	for (const [relationName, member] of Object.entries(relations)) {
-		if ("handles" in member.data) {
-			const fields = [
-				{ name: "id", generator: true },
-				...member.data.columns.map(function columnCoord(column) {
-					return { name: column.name, generator: false }
-				})
-			]
-			out.push({ relation: relationName, fields })
-			continue
-		}
-		const fields = member.data.fields.map(function fieldCoord(declared) {
-			return { name: declared.name, generator: "fresh" in declared.field && declared.field.fresh === true }
+		const closed = isClosedMember(member)
+		const fields = sealedFieldsOf(member).map(function fieldCoord(declared) {
+			return {
+				name: declared.name,
+				generator: closed ? declared.name === "id" : "fresh" in declared.field && declared.field.fresh === true
+			}
 		})
 		out.push({ relation: relationName, fields })
 	}
@@ -490,7 +490,8 @@ function computeClasses(name: string, relations: SchemaRelations, statements: re
 }
 
 /**
- * The trusted seam of the class-map mint (the `refsComplete` pattern): the
+ * The trusted admission seam of the class-map mint (the pattern's home is
+ * `isTypedScope` in query/lower.ts): the
  * checkable facts — one own record per declared relation, one own entry
  * per declared field (the closed sealed shape's `id` included), everything
  * frozen — are verified before the runtime map is admitted at the computed

package/src/lower.ts

@@ -9,11 +9,12 @@
  */
 
 import type { AnyClosed } from "#closed.ts"
+import { isClosedMember } from "#closed.ts"
 import type { FaceData } from "#face.ts"
 import type { AnyField } from "#fields.ts"
 import type { RelationClasses } from "#law.ts"
 import type { AnyRelation } from "#relation.ts"
-import type { AnySchema, SchemaRelation } from "#schema.ts"
+import type { AnySchema } from "#schema.ts"
 import type {
 	FieldSpec,
 	LiteralSetSpec,
@@ -25,14 +26,6 @@ import type {
 } from "#spec.ts"
 import type { Statement } from "#statements.ts"
 
-/**
- * The relation-kind discriminant: a closed relation's runtime description
- * carries its handle roster, an ordinary relation's never does.
- */
-function isClosedMember(member: SchemaRelation): member is AnyClosed {
-	return "handles" in member.data
-}
-
 /**
  * Lowers one field descriptor's structural type to the wire
  * {@link ValueTypeSpec}: the S1 kind tags map 1:1 onto the `ValueType`

package/src/marshal.ts

@@ -29,6 +29,7 @@
 
 import * as errors from "@superbuilders/errors"
 import type { AnyField, ClosedRoster } from "#fields.ts"
+import { isIntervalValue, literalShapeError, rosterOf } from "#fields.ts"
 import type { FactValue } from "#native.ts"
 import type { AnyRelation, Fact, FreshKeys, RelationData } from "#relation.ts"
 
@@ -66,23 +67,6 @@ type KeyFact<R extends AnyRelation> = [FreshKeys<R>] extends [never]
 	? Partial<Fact<R>>
 	: { [K in FreshKeys<R>]: Fact<R>[K] }
 
-/** The typed shape refusal of the row marshaler — a genuine failure, never data. */
-function cellShapeError(context: string, expected: string, value: unknown): Error {
-	return errors.new(`${context}: expected ${expected}, got ${typeof value}`)
-}
-
-/** Narrows an interval cell: a plain object with bigint start/end. */
-function isIntervalCell(value: unknown): value is { readonly start: bigint; readonly end: bigint } {
-	return (
-		typeof value === "object" &&
-		value !== null &&
-		"start" in value &&
-		"end" in value &&
-		typeof value.start === "bigint" &&
-		typeof value.end === "bigint"
-	)
-}
-
 /**
  * Reprojects any host object to a string-indexed record — the boundary
  * through which generic fact objects (whose type parameters carry no index
@@ -121,7 +105,7 @@ function closedCellOf(context: string, closed: ClosedRoster, name: string): Fact
  */
 function handleOf(context: string, closed: ClosedRoster, cell: FactValue): string {
 	if (typeof cell !== "bigint") {
-		throw cellShapeError(context, `a ${closed.name} handle id (bigint)`, cell)
+		throw literalShapeError(context, `a ${closed.name} handle id (bigint)`, cell)
 	}
 	const handle = closed.handles[Number(cell)]
 	if (handle === undefined) {
@@ -144,29 +128,30 @@ function handleOf(context: string, closed: ClosedRoster, cell: FactValue): strin
  * boundary.
  */
 function cellOf(context: string, field: AnyField, value: unknown): FactValue {
-	if ("closed" in field) {
+	const roster = rosterOf(field)
+	if (roster !== undefined) {
 		if (typeof value !== "string") {
-			throw cellShapeError(context, `a ${field.closed.name} handle name (string)`, value)
+			throw literalShapeError(context, `a ${roster.name} handle name (string)`, value)
 		}
-		return closedCellOf(context, field.closed, value)
+		return closedCellOf(context, roster, value)
 	}
 	switch (field.kind) {
 		case "bool": {
 			if (typeof value !== "boolean") {
-				throw cellShapeError(context, "boolean", value)
+				throw literalShapeError(context, "boolean", value)
 			}
 			return value
 		}
 		case "u64":
 		case "i64": {
 			if (typeof value !== "bigint") {
-				throw cellShapeError(context, "bigint", value)
+				throw literalShapeError(context, "bigint", value)
 			}
 			return value
 		}
 		case "str": {
 			if (typeof value !== "string") {
-				throw cellShapeError(context, "string", value)
+				throw literalShapeError(context, "string", value)
 			}
 			/**
 			 * A lone surrogate would be lossily replaced with U+FFFD at the
@@ -176,19 +161,19 @@ function cellOf(context: string, field: AnyField, value: unknown): FactValue {
 			 * lookup lowers through.
 			 */
 			if (!value.isWellFormed()) {
-				throw cellShapeError(context, "well-formed string", value)
+				throw literalShapeError(context, "well-formed string", value)
 			}
 			return value
 		}
 		case "bytes": {
 			if (!(value instanceof Uint8Array)) {
-				throw cellShapeError(context, "Uint8Array", value)
+				throw literalShapeError(context, "Uint8Array", value)
 			}
 			return value
 		}
 		case "interval": {
-			if (!isIntervalCell(value)) {
-				throw cellShapeError(context, "interval ({ start, end } bigints)", value)
+			if (!isIntervalValue(value)) {
+				throw literalShapeError(context, "interval ({ start, end } bigints)", value)
 			}
 			return { start: value.start, end: value.end }
 		}
@@ -289,10 +274,9 @@ function factOf<R extends AnyRelation>(relation: R, row: readonly FactValue[]):
 		if (cell === undefined) {
 			throw errors.new(`relation ${data.name}: row cell ${ordinal} (${declared.name}) is absent`)
 		}
+		const roster = rosterOf(declared.field)
 		decoded[declared.name] =
-			"closed" in declared.field
-				? handleOf(`relation ${data.name} field ${declared.name}`, declared.field.closed, cell)
-				: cell
+			roster !== undefined ? handleOf(`relation ${data.name} field ${declared.name}`, roster, cell) : cell
 	})
 	Object.freeze(decoded)
 	if (!isCompleteFact(relation, decoded)) {

package/src/native.ts

@@ -241,7 +241,7 @@ interface Violation {
 }
 
 /**
- * `dbCreate`/`dbOpen`'s domain outcome. `schemaError` covers both spec
+ * `dbCreate`/`dbOpen`'s domain outcome. `schemaError` spans both spec
  * resolution (unresolvable names, banned spellings — every issue in one
  * message) and schema validation at the declaration boundary;
  * `newtypeMismatch` is the coherence wall's own kind — a spec whose
@@ -471,8 +471,12 @@ interface Native {
  * The sole platform this release ships (PRD-03 ruling 1: prebuilt-only,
  * darwin-arm64). The per-platform-package structure below makes adding
  * `darwin-x64`/`linux-*`/`win32-*` pure addition — one more `os`/`cpu`-gated
- * package plus a CI matrix — never a redesign, so this string is the only
- * place the shipped set is named for the unsupported-platform message.
+ * package plus a CI matrix — never a redesign. This constant names the
+ * shipped set for the unsupported-platform message; the build's
+ * `PUBLISH_PLATFORM` (`scripts/platform.ts` — src cannot import scripts,
+ * the packaging boundary) and the `ts/.gitignore` carve-out spell the same
+ * target, and the single-source pin in `test/build-platform.test.ts` holds
+ * all three in lockstep.
  */
 const SHIPPED_PLATFORMS = "darwin-arm64"
 
@@ -536,6 +540,20 @@ function loadNativeBinding(platform: string, arch: string): Native {
  */
 const native: Native = loadNativeBinding(process.platform, process.arch)
 
+/**
+ * The bridge guard — THE one wrapper every native call crosses (db.ts and
+ * exhume.ts both import it): runs one native call and wraps anything it
+ * throws, so marshal-shape refusals and handle-lifecycle refusals cross as
+ * genuine typed failures, never bare foreign errors.
+ */
+function bridged<T>(context: string, run: () => T): T {
+	const result = errors.trySync(run)
+	if (result.error) {
+		throw errors.wrap(result.error, context)
+	}
+	return result.data
+}
+
 export type {
 	AggOpIr,
 	AtomIr,
@@ -577,4 +595,4 @@ export type {
 	ViolationFact,
 	WriteFromResult
 }
-export { loadNativeBinding, native }
+export { bridged, loadNativeBinding, native, SHIPPED_PLATFORMS }

package/src/order.ts

@@ -0,0 +1,156 @@
+/**
+ * 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.
+ */
+
+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 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)
+}
+
+/** Marks one sort key DESCENDING — the single descending spelling (a bare name is already ascending). */
+function desc<const K extends string>(key: K): Desc<K> {
+	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.
+ */
+function by<const K extends string>(
+	first: SortKey<K>,
+	...rest: ReadonlyArray<SortKey<K>>
+): <Row extends Readonly<Record<K, FactValue>>>(left: Row, right: Row) => number {
+	const entries = [first, ...rest].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, SortKey }
+export { by, desc }