@bjornpagen/bumbledb 0.19.0 → 0.19.2

package/src/query/lower.ts

@@ -1,6 +1,6 @@
 import * as errors from "@superbuilders/errors"
 import { sealedFieldsOf } from "#closed.ts"
-import type { AnyField, ClosedRoster } from "#fields.ts"
+import type { AnyClosedRoster, AnyField } from "#fields.ts"
 import { assertDeclarationOrderKey, isIntervalValue, literalShapeError, rosterOf } from "#fields.ts"
 import type { ClassRecordOf, SchemaClasses } from "#law.ts"
 import type {
@@ -58,7 +58,16 @@ import type {
 	ShapeOf,
 	VarsOf
 } from "#query/scope.ts"
-import { fieldJoins, inferred, isTerm, makeParam, makeSetParam, renderFieldKind, term } from "#query/scope.ts"
+import {
+	fieldAntiJoins,
+	fieldJoins,
+	inferred,
+	isTerm,
+	makeParam,
+	makeSetParam,
+	renderFieldKind,
+	term
+} from "#query/scope.ts"
 import type { AnySchema, Schema, SchemaRelations } from "#schema.ts"
 
 type QueryRelation<Rels extends SchemaRelations> = Extract<Rels[keyof Rels], MatchOwner>
@@ -469,7 +478,8 @@ function resolveBindings(
 	context: ChainContext,
 	label: string,
 	relation: MatchOwner,
-	bindings: Readonly<Record<string, unknown>>
+	bindings: Readonly<Record<string, unknown>>,
+	joins: (a: ClassedField, b: ClassedField) => boolean = fieldJoins
 ): ResolvedBindings {
 	const entries: BindingEntry[] = []
 	const vars: AnyVar[] = []
@@ -494,7 +504,7 @@ function resolveBindings(
 					const ref = value
 					const mint = mintSlotOf(context, ref)
 					const positionSlot: ClassedField = { field: declared.field, class: fieldClass }
-					if (!fieldJoins(mint, positionSlot)) {
+					if (!joins(mint, positionSlot)) {
 						throw errors.new(
 							`${label}: the variable ${ref.label} joins domain-unequal fields — minted at ${renderFieldKind(mint)}, reused at ${renderFieldKind(positionSlot)} (a var joins only class-equal slots; bare pairs only with bare)`
 						)
@@ -648,7 +658,7 @@ function advanceWhere(context: ChainContext, state: RuleBuildState, cond: AnyCon
 				return value !== undefined
 			})
 		)
-		const resolved = resolveBindings(context, `negated relation ${relation.name}`, relation, bindings)
+		const resolved = resolveBindings(context, `negated relation ${relation.name}`, relation, bindings, fieldAntiJoins)
 		return Object.freeze({
 			items: Object.freeze([...state.items, Object.freeze({ kind: "negated" as const, atom: resolved.atom })]),
 			bound: state.bound,
@@ -1161,7 +1171,7 @@ function makeRecRuleScope<Rels extends SchemaRelations, Classes extends SchemaCl
 	return raw
 }
 
-function renderClosedSlice(closed: ClosedRoster | undefined): string {
+function renderClosedSlice(closed: AnyClosedRoster | undefined): string {
 	return closed === undefined ? "a bare value" : `a ${closed.name} reference`
 }
 
@@ -1177,7 +1187,7 @@ function headSignature(column: FindColumn): string {
 	return `${column.name}:${agg.op}`
 }
 
-function renderParamAnchor(roster: ClosedRoster | undefined): string {
+function renderParamAnchor(roster: AnyClosedRoster | undefined): string {
 	return roster === undefined ? "a non-closed position" : `a ${roster.name} reference`
 }
 

package/src/query/scope.ts

@@ -1,8 +1,9 @@
 import * as errors from "@superbuilders/errors"
 import type { AnyClosed } from "#closed.ts"
 import { sealedFieldsOf } from "#closed.ts"
-import type { AnyField, Infer } from "#fields.ts"
-import { rosterOf } from "#fields.ts"
+import type { AnyField, Infer, SignatureOf } from "#fields.ts"
+import { rosterOf, signaturesAgree } from "#fields.ts"
+import type { Same, SameLen } from "#judgment.ts"
 import type { ClassLookup, ClassRecordOf, SchemaClasses } from "#law.ts"
 import type { QueryParam } from "#native.ts"
 import type { AnyRelation, RelationFields } from "#relation.ts"
@@ -19,7 +20,7 @@ type MatchFields<R extends MatchOwner> = R extends AnyClosed
 		? RelationFields<R>
 		: never
 
-interface Var<F extends AnyField = AnyField, RN extends string = string, K extends string = string> {
+interface Var<F extends AnyField, RN extends string, K extends string> {
 	readonly [term]: "var"
 	readonly owner: MatchOwner & { readonly name: RN }
 	readonly column: K
@@ -27,19 +28,19 @@ interface Var<F extends AnyField = AnyField, RN extends string = string, K exten
 	readonly label: string
 }
 
-type AnyVar = Var
+type AnyVar = Var<AnyField, string, string>
 
-interface Param<Name extends string = string> {
+interface Param<Name extends string> {
 	readonly [term]: "param"
 	readonly name: Name
 }
 
-interface SetParam<Name extends string = string> {
+interface SetParam<Name extends string> {
 	readonly [term]: "setParam"
 	readonly name: Name
 }
 
-type AnyTerm = Var | Param | SetParam
+type AnyTerm = AnyVar | Param<string> | SetParam<string>
 
 function isTerm(value: unknown): value is AnyTerm {
 	return typeof value === "object" && value !== null && term in value
@@ -147,48 +148,78 @@ type UnionToIntersection<U> = (U extends unknown ? (member: U) => void : never)
 
 type ShapeOf<U> = [U] extends [never] ? Record<never, never> : Flatten<UnionToIntersection<U>>
 
-type WidthOf<F extends AnyField> = F extends { readonly width: infer W } ? W : undefined
-
-type ElementOf<F extends AnyField> = F extends { readonly element: infer E } ? E : undefined
-
-type RosterOf<F extends AnyField> = F extends {
-	readonly closed: { readonly name: infer N extends string; readonly handles: readonly (infer H extends string)[] }
-}
-	? readonly [N, H]
-	: undefined
-
-type JoinOk<A extends ClassedField, B extends ClassedField> = [
-	A["field"]["kind"],
-	A["class"],
-	WidthOf<A["field"]>,
-	ElementOf<A["field"]>,
-	RosterOf<A["field"]>
-] extends [B["field"]["kind"], B["class"], WidthOf<B["field"]>, ElementOf<B["field"]>, RosterOf<B["field"]>]
-	? [B["field"]["kind"], B["class"], WidthOf<B["field"]>, ElementOf<B["field"]>, RosterOf<B["field"]>] extends [
-			A["field"]["kind"],
-			A["class"],
-			WidthOf<A["field"]>,
-			ElementOf<A["field"]>,
-			RosterOf<A["field"]>
-		]
-		? true
-		: false
+/**
+ * A slot's identity for the positive-join judgment: the field's structural
+ * signature ({@link SignatureOf} — the ONE interpreter, shared with the
+ * face pairing wall) plus the slot's law class.
+ */
+type SlotSignature<S extends ClassedField> = readonly [SignatureOf<S["field"]>, S["class"]]
+
+type JoinOk<A extends ClassedField, B extends ClassedField> = Same<SlotSignature<A>, SlotSignature<B>>
+
+type U64Wire<F extends AnyField> = F extends { readonly kind: "u64" }
+	? F extends { readonly closed: unknown }
+		? false
+		: true
 	: false
 
+type ClosedHandles<F extends AnyField> = F extends {
+	readonly closed: { readonly handles: infer H extends readonly string[] }
+}
+	? H
+	: never
+
+/**
+ * Two closed ids anti-join when their handle vectors carry the same Peano
+ * length ({@link SameLen}: zero equals zero, successor recurses on
+ * successor). A bare field has no vector and proves nothing.
+ */
+type ClosedIdOk<A extends AnyField, B extends AnyField> = [ClosedHandles<A>] extends [never]
+	? false
+	: [ClosedHandles<B>] extends [never]
+		? false
+		: SameLen<ClosedHandles<A>, ClosedHandles<B>>
+
+/**
+ * Anti-join class safety: class-equal slots, plus same-identity u64
+ * (fresh mint, foreign-key copy, or bare u64) when one side is bare,
+ * plus two closed-id fields whose handle tuples have the same length.
+ * Two distinct generators stay refused.
+ */
+type AntiJoinOk<A extends ClassedField, B extends ClassedField> =
+	JoinOk<A, B> extends true
+		? true
+		: ClosedIdOk<A["field"], B["field"]> extends true
+			? true
+			: U64Wire<A["field"]> extends true
+				? U64Wire<B["field"]> extends true
+					? [A["class"]] extends [undefined]
+						? true
+						: [B["class"]] extends [undefined]
+							? true
+							: false
+					: false
+				: false
+
 function fieldJoins(a: ClassedField, b: ClassedField): boolean {
-	const widthA = "width" in a.field ? a.field.width : undefined
-	const widthB = "width" in b.field ? b.field.width : undefined
-	const elementA = "element" in a.field ? a.field.element : undefined
-	const elementB = "element" in b.field ? b.field.element : undefined
-	const rosterA = rosterOf(a.field)
-	const rosterB = rosterOf(b.field)
-	return (
-		a.field.kind === b.field.kind &&
-		a.class === b.class &&
-		widthA === widthB &&
-		elementA === elementB &&
-		rosterA === rosterB
-	)
+	return a.class === b.class && signaturesAgree(a.field, b.field)
+}
+
+function u64Wire(field: AnyField): boolean {
+	return field.kind === "u64" && rosterOf(field) === undefined
+}
+
+function closedIdAntiJoins(a: AnyField, b: AnyField): boolean {
+	const rosterA = rosterOf(a)
+	const rosterB = rosterOf(b)
+	return rosterA !== undefined && rosterB !== undefined && rosterA.handles.length === rosterB.handles.length
+}
+
+function fieldAntiJoins(a: ClassedField, b: ClassedField): boolean {
+	if (fieldJoins(a, b) || closedIdAntiJoins(a.field, b.field)) {
+		return true
+	}
+	return u64Wire(a.field) && u64Wire(b.field) && (a.class === undefined || b.class === undefined)
 }
 
 function renderFieldKind(slot: ClassedField): string {
@@ -220,6 +251,7 @@ interface ParamEntry {
 }
 
 export type {
+	AntiJoinOk,
 	AnyTerm,
 	AnyVar,
 	ClassedField,
@@ -241,4 +273,4 @@ export type {
 	Var,
 	VarsOf
 }
-export { fieldJoins, inferred, isTerm, makeParam, makeSetParam, renderFieldKind, term, v }
+export { fieldAntiJoins, fieldJoins, inferred, isTerm, makeParam, makeSetParam, renderFieldKind, term, v }

package/src/statements.ts

@@ -12,7 +12,7 @@ import {
 } from "#capacity.ts"
 import { isClosedMember, sealedFieldOf } from "#closed.ts"
 import { type AnyFace, type FaceData, renderFace, type SameArity, type SameShapes } from "#face.ts"
-import { type ClosedRoster, rosterOf } from "#fields.ts"
+import { type AnyClosedRoster, rosterOf, rostersAgree } from "#fields.ts"
 import type { AnyRelation, RelationFields } from "#relation.ts"
 import { type CapacityWindowSpec, renderCapacityWindow, renderWeight, type WeightSpec } from "#spec.ts"
 
@@ -67,7 +67,7 @@ interface KeyStatement<R extends AnyRelation, Projection extends readonly string
 	readonly data: KeyData<R, Projection>
 }
 
-function renderRosterSide(roster: ClosedRoster | undefined): string {
+function renderRosterSide(roster: AnyClosedRoster | undefined): string {
 	return roster === undefined ? "a bare column" : `a ${roster.name} reference`
 }
 
@@ -96,7 +96,7 @@ function assertRosterAgreement(source: FaceData, target: FaceData, statement: St
 		}
 		const sourceRoster = rosterOf(sealedFieldOf(source.owner, fieldName))
 		const targetRoster = rosterOf(sealedFieldOf(target.owner, targetField))
-		if (sourceRoster !== targetRoster) {
+		if (!rostersAgree(sourceRoster, targetRoster)) {
 			throw errors.new(
 				`${source.owner.name}.${fieldName} is ${renderRosterSide(sourceRoster)} but ${target.owner.name}.${targetField} is ${renderRosterSide(targetRoster)} — closedness rides the descriptor: a closed reference is spelled with the vocabulary's own id descriptor (one meaning, one spelling), so faces pair closed-with-closed through one roster or bare-with-bare, never across — ${renderStatement(statement)}`
 			)