@bjornpagen/bumbledb 1.2.1 → 1.3.1

package/src/query/description.ts

@@ -10,9 +10,19 @@ import type { AnyQuery, ChainContext, Query } from "#query/lower.ts"
 import { alignedHeadOf, EMPTY_RULE, lowerQuery, makeRawChain, makeRawQuery, taggedCmpLiteral } from "#query/lower.ts"
 import { parseQueryIr } from "#query/parse-ir.ts"
 import { type AnyVar, type MatchOwner, makeParam, makeSetParam, type ParamsRecord, v } from "#query/scope.ts"
+import { difference, type IntervalVar, intersection } from "#query/segments.ts"
 import type { FieldsShape } from "#relation.ts"
 import { handleOf } from "#rows.ts"
-import { queryVarLeaf, scalarBinary, scalarCast, scalarFloatPredicate, scalarLiteral, scalarNegate } from "#scalar.ts"
+import {
+	queryVarLeaf,
+	scalarBinary,
+	scalarCast,
+	scalarFloatPredicate,
+	scalarLiteral,
+	scalarMeasure,
+	scalarMulDiv,
+	scalarNegate
+} from "#scalar.ts"
 import type { Schema, SchemaRelations } from "#schema.ts"
 import { schemaDescriptor } from "#schema.ts"
 import { arrayValue, recordValue, valueDescriptor } from "#values.ts"
@@ -39,6 +49,12 @@ interface DescriptionParameter {
 
 type DescriptionRow<F extends FieldsShape> = { readonly [K in keyof F]: Infer<F[K]> }
 
+/** Checked result fields remain exact through v(imported), just as at runtime.
+ * Carrier classes come from the replayed head and remain runtime-checked. */
+type DescriptionHead<F extends FieldsShape> = {
+	readonly [K in keyof F]: { readonly field: F[K]; readonly class: string | undefined }
+}
+
 function refused(context: string, expected: string): never {
 	throw new AuthoringError({
 		message: `${context}: ${expected}`,
@@ -237,6 +253,11 @@ function replayRule(
 			case "var": {
 				const variable = variableAt(input.var)
 				const kind = variable.field.kind
+				if (variable.field.kind === "interval")
+					return queryVarLeaf(
+						variable,
+						({ u64: "intervalU64", i64: "intervalI64", f64: "intervalF64" } as const)[variable.field.element]
+					)
 				if (
 					rosterOf(variable.field) !== undefined ||
 					(kind !== "bool" && kind !== "u64" && kind !== "i64" && kind !== "f64")
@@ -248,17 +269,21 @@ function replayRule(
 				const value = input.value
 				switch (value.kind) {
 					case "u64":
-						return scalarLiteral("query-var", { u64: value.value })
+						return scalarLiteral({ u64: value.value })
 					case "i64":
-						return scalarLiteral("query-var", { i64: value.value })
+						return scalarLiteral({ i64: value.value })
 					case "f64":
-						return scalarLiteral("query-var", { f64: value.value })
+						return scalarLiteral({ f64: value.value })
 					case "bool":
-						return scalarLiteral("query-var", { bool: value.value })
+						return scalarLiteral({ bool: value.value })
 					default:
 						return refused("query compute", "requires a scalar literal")
 				}
 			}
+			case "measure":
+				return scalarMeasure("query compute", scalar(input.expr))
+			case "mulDiv":
+				return scalarMulDiv("query compute", scalar(input.a), scalar(input.b), scalar(input.divisor), input.rounding)
 			case "negate":
 				return scalarNegate("query compute", scalar(input.expr))
 			case "isNaN":
@@ -281,6 +306,11 @@ function replayRule(
 			let value: unknown
 			if (find.kind === "var") value = variableAt(find.var)
 			else if (find.kind === "compute") value = scalar(find.expr)
+			else if (find.kind === "segments")
+				value = (find.op === "intersection" ? intersection : difference)(
+					variableAt(find.left) as IntervalVar,
+					variableAt(find.right) as IntervalVar
+				)
 			else if (find.kind === "count") value = { agg: "count" }
 			else value = { agg: find.kind === "pack" ? "pack" : find.op.kind, over: variableAt(find.over) }
 			return [column, value]
@@ -293,7 +323,7 @@ function queryFromDescription<Rels extends SchemaRelations, Classes extends Sche
 	schema: Schema<Rels, Classes>,
 	input: unknown,
 	result: F
-): Query<Rels, DescriptionRow<F>, ParamsRecord, Classes> {
+): Query<Rels, DescriptionRow<F>, ParamsRecord, Classes, DescriptionHead<F>> {
 	const theory = schemaDescriptor(schema)
 	const description = checkedDescription(input)
 	const resultRecord = recordValue(
@@ -387,8 +417,8 @@ function queryFromDescription<Rels extends SchemaRelations, Classes extends Sche
 	if (usedParameters.size !== description.parameters.length) refused("query parameters", "declared parameter is unused")
 	// Complete shared lowering also checks tagged literals and ordinal bounds.
 	lowerQuery(value)
-	return value as unknown as Query<Rels, DescriptionRow<F>, ParamsRecord, Classes>
+	return value as unknown as Query<Rels, DescriptionRow<F>, ParamsRecord, Classes, DescriptionHead<F>>
 }
 
-export type { DescriptionParameter, DescriptionRow, DescriptionTable, QueryDescription }
+export type { DescriptionHead, DescriptionParameter, DescriptionRow, DescriptionTable, QueryDescription }
 export { describeQuery, queryFromDescription }

package/src/query/find.ts

@@ -1,8 +1,9 @@
-import type { BoolField, F64Field, I64Field, Infer, U64Field } from "#fields.ts"
+import type { BoolField, F64Field, I64Field, Infer, IntervalField, U64Field } from "#fields.ts"
 import type { SchemaClasses } from "#law.ts"
 import type { IntervalVarOk, NumericVarOk } from "#query/atom.ts"
 import type { AnyComputeExpr, ComputeExpr, ComputeValue } from "#query/compute.ts"
 import type { AnyVar, MintSlotOf } from "#query/scope.ts"
+import type { Segments } from "#query/segments.ts"
 import type { ScalarKind } from "#scalar.ts"
 
 type FoldOpName = "sum" | "mean" | "min" | "max" | "pack"
@@ -18,7 +19,7 @@ interface Agg<Op extends FoldOpName, Over extends AnyVar> {
 
 type AnyAgg = CountAgg | Agg<FoldOpName, AnyVar>
 
-type FindEntry = AnyVar | AnyAgg | AnyComputeExpr
+type FindEntry = AnyVar | AnyAgg | AnyComputeExpr | Segments
 
 type FindShape = Readonly<Record<string, FindEntry>>
 
@@ -33,7 +34,7 @@ function count(): CountAgg {
 /**
  * Exact checked sum over a NUMERIC (u64/i64/f64) variable — wide accumulator,
  * one finalize range check; overflow is the engine's typed runtime error —
- * or over the measure (`r.sum(r.duration(w))`). Bool stays refused: a
+ * of a measured interval in a following stage. Bool stays refused: a
  * quantifier is not an addition (R3).
  */
 function sum<const O extends AnyVar>(over: O): Agg<"sum", O> {
@@ -69,7 +70,7 @@ type FindEntryOk<E> = E extends AnyVar
 				? NumericVarOk<O>
 				: E extends Agg<"pack", infer V extends AnyVar>
 					? IntervalVarOk<V>
-					: E extends AnyComputeExpr
+					: E extends AnyComputeExpr | Segments
 						? true
 						: false
 
@@ -81,17 +82,20 @@ type CheckRecFind<F extends FindShape> = {
 	readonly [K in keyof F]: F[K] extends AnyVar ? F[K] : never
 }
 
-type FindValue<E> = E extends AnyVar
-	? Infer<E["field"]>
-	: E extends CountAgg
-		? bigint
-		: E extends Agg<"sum" | "mean" | "min" | "max", infer O extends AnyVar>
-			? Infer<O["field"]>
-			: E extends Agg<"pack", infer V extends AnyVar>
-				? Infer<V["field"]>
-				: E extends ComputeExpr<infer K extends ScalarKind>
-					? ComputeValue<K>
-					: never
+type FindValue<E> =
+	E extends Segments<infer Element>
+		? Infer<IntervalField<Element, undefined>>
+		: E extends AnyVar
+			? Infer<E["field"]>
+			: E extends CountAgg
+				? bigint
+				: E extends Agg<"sum" | "mean" | "min" | "max", infer O extends AnyVar>
+					? Infer<O["field"]>
+					: E extends Agg<"pack", infer V extends AnyVar>
+						? Infer<V["field"]>
+						: E extends ComputeExpr<infer K extends ScalarKind>
+							? ComputeValue<K>
+							: never
 
 type RowOfFind<F extends FindShape> = { readonly [K in keyof F]: FindValue<F[K]> }
 
@@ -108,17 +112,24 @@ type ComputeFields = {
  * produce bare values, matching findColumnSlotOf at runtime.
  */
 type HeadRecordOf<Classes extends SchemaClasses, F extends FindShape> = {
-	readonly [K in keyof F]: F[K] extends AnyVar
-		? MintSlotOf<Classes, F[K]>
-		: F[K] extends ComputeExpr<infer Kind extends ScalarKind>
-			? { readonly field: ComputeFields[Kind]; readonly class: undefined }
-			: F[K] extends CountAgg
-				? { readonly field: U64Field; readonly class: undefined }
-				: F[K] extends Agg<"mean", AnyVar>
-					? { readonly field: F64Field; readonly class: undefined }
-					: F[K] extends Agg<FoldOpName, infer Over extends AnyVar>
-						? { readonly field: Over["field"]; readonly class: undefined }
-						: never
+	readonly [K in keyof F]: F[K] extends Segments<infer Element>
+		? { readonly field: IntervalField<Element, undefined>; readonly class: undefined }
+		: F[K] extends AnyVar
+			? MintSlotOf<Classes, F[K]>
+			: F[K] extends ComputeExpr<infer Kind extends ScalarKind>
+				? { readonly field: ComputeFields[Kind]; readonly class: undefined }
+				: F[K] extends CountAgg
+					? { readonly field: U64Field; readonly class: undefined }
+					: F[K] extends Agg<"mean", AnyVar>
+						? { readonly field: F64Field; readonly class: undefined }
+						: F[K] extends Agg<"pack", infer Over extends AnyVar>
+							? {
+									readonly field: IntervalField<Over["field"] extends IntervalField<infer E> ? E : never, undefined>
+									readonly class: undefined
+								}
+							: F[K] extends Agg<FoldOpName, infer Over extends AnyVar>
+								? { readonly field: Over["field"]; readonly class: undefined }
+								: never
 }
 
 export type { Agg, CheckFind, CheckRecFind, FindEntry, FindShape, HeadRecordOf, RowOfFind }

package/src/query/lower.ts

@@ -1,6 +1,6 @@
 import { membersAgree, sealedFieldsOf } from "#closed.ts"
 import { AuthoringError, SdkInvariantError } from "#errors.ts"
-import type { AnyClosedRoster, AnyField } from "#fields.ts"
+import type { AnyClosedRoster, AnyField, IntervalField } from "#fields.ts"
 import {
 	assertDeclarationOrderKey,
 	f64 as f64Field,
@@ -13,6 +13,7 @@ import {
 	u64 as u64Field
 } from "#fields.ts"
 import { snapshotData } from "#immutable.ts"
+import type { Same } from "#judgment.ts"
 import type { ClassRecordOf, SchemaClasses } from "#law.ts"
 import type {
 	AtomIr,
@@ -87,7 +88,8 @@ import {
 	renderFieldKind,
 	term
 } from "#query/scope.ts"
-import { literalWireOf } from "#scalar.ts"
+import { difference, intersection, isSegments, segmentField } from "#query/segments.ts"
+import { scalarWire } from "#scalar.ts"
 import type { AnySchema, Schema, SchemaRelations } from "#schema.ts"
 import { schemaDescriptor, schemasAgree } from "#schema.ts"
 import { arrayValue, recordValue, taggedValueOf } from "#values.ts"
@@ -102,6 +104,25 @@ type HeadShape = Readonly<Record<string, ClassedField>> | undefined
 
 type HeadOf<T> = InferredOf<T> extends { readonly head: infer H extends HeadShape } ? H : HeadShape
 
+type HeadFieldMeet<A extends AnyField, B extends AnyField> = A extends IntervalField
+	? B extends IntervalField
+		? IntervalField<A["element"], Same<A["width"], B["width"]> extends true ? A["width"] : undefined>
+		: A
+	: A
+
+/** The common refinements of the same output column across union arms. */
+type HeadMeet<A extends HeadShape, B extends HeadShape> =
+	A extends Readonly<Record<string, ClassedField>>
+		? B extends Readonly<Record<string, ClassedField>>
+			? {
+					readonly [K in keyof A & keyof B]: {
+						readonly field: HeadFieldMeet<A[K]["field"], B[K]["field"]>
+						readonly class: Same<A[K]["class"], B[K]["class"]> extends true ? A[K]["class"] : undefined
+					}
+				}
+			: HeadShape
+		: HeadShape
+
 interface RuleValue<Row, P extends ParamsRecord, Head extends HeadShape = undefined> {
 	readonly rule: RuleData
 	readonly [inferred]?: { readonly row: Row; readonly params: P; readonly head: Head }
@@ -147,6 +168,8 @@ interface TermOps {
 	readonly mean: typeof mean
 	readonly min: typeof min
 	readonly max: typeof max
+	readonly intersection: typeof intersection
+	readonly difference: typeof difference
 	readonly pack: typeof pack
 }
 
@@ -409,7 +432,7 @@ interface Query<
 
 	rule<RV extends AnyRuleValue>(
 		build: (r: QueryRuleScope<Rels, Classes>) => RV
-	): Query<Rels, Row | RowOf<RV>, Flatten<Params & ParamsOf<RV>>, Classes, Head | HeadOf<RV>>
+	): Query<Rels, Row | RowOf<RV>, Flatten<Params & ParamsOf<RV>>, Classes, HeadMeet<Head, HeadOf<RV>>>
 
 	/** A diagnostic name for composition/tracing — never a schema relation. */
 	named(label: string): Query<Rels, Row, Params, Classes, Head>
@@ -476,7 +499,9 @@ const termOps: TermOps = Object.freeze({
 	mean,
 	min,
 	max,
-	pack
+	pack,
+	intersection,
+	difference
 })
 
 interface RuleBuildState {
@@ -865,6 +890,8 @@ function findColumnOf(name: string, entry: unknown): FindColumn {
 			message: `find ${name}: a ${entry[term]} is not projectable — find takes variables, aggregates or Compute expressions`
 		})
 	}
+	if (isSegments(entry))
+		return Object.freeze({ name, entry: Object.freeze({ ...entry }), closed: undefined, slot: undefined })
 	if (isComputeExpr(entry)) {
 		return Object.freeze({
 			name,
@@ -940,6 +967,7 @@ function assertNumeric(where: string, position: string, ref: AnyVar): void {
  */
 function findColumnSlotOf(context: ChainContext, column: FindColumn): ClassedField | undefined {
 	const entry = column.entry
+	if (entry.kind === "segments") return { field: segmentField(entry), class: undefined }
 	if (entry.kind === "var") {
 		return mintSlotOf(context, entry.over)
 	}
@@ -957,13 +985,21 @@ function findColumnSlotOf(context: ChainContext, column: FindColumn): ClassedFie
 			return { field: agg.over.field, class: undefined }
 		}
 		case "pack":
-			return { field: agg.over.field, class: undefined }
+			return {
+				field: { kind: "interval", element: (agg.over.field as IntervalField).element, width: undefined },
+				class: undefined
+			}
 	}
 }
 
 function validateColumn(context: ChainContext, bound: ReadonlySet<AnyVar>, column: FindColumn): void {
 	const where = `${contextLabel(context)} find ${column.name}`
 	const entry = column.entry
+	if (entry.kind === "segments") {
+		assertBound(where, bound, entry.left)
+		assertBound(where, bound, entry.right)
+		return
+	}
 	if (entry.kind === "var") {
 		assertBound(where, bound, entry.over)
 		return
@@ -1085,6 +1121,13 @@ function completeRule(context: ChainContext, state: RuleBuildState, rawColumns:
 	if (rawColumns.length === 0) {
 		throw new AuthoringError({ message: `${label}: a find needs at least one entry` })
 	}
+	const aggregates = rawColumns.flatMap((column) => (column.entry.kind === "aggregate" ? [column.entry.agg] : []))
+	const packs = aggregates.filter((agg) => agg.op === "pack").length
+	if (packs > 1) throw new AuthoringError({ message: "a query stage can pack one interval column" })
+	if (packs !== 0 && aggregates.length !== packs)
+		throw new AuthoringError({ message: "pack intervals and compute numeric aggregates in separate query stages" })
+	if (rawColumns.some((c) => c.entry.kind === "segments") && aggregates.length !== 0)
+		throw new AuthoringError({ message: "aggregate generated segments in a following query stage" })
 	const columns = rawColumns.map(function enrichColumn(column): FindColumn {
 		assertDeclarationOrderKey(`${label} find column`, column.name)
 		validateColumn(context, state.bound, column)
@@ -1519,19 +1562,8 @@ function renderClosedSlice(closed: AnyClosedRoster | undefined): string {
 	return closed === undefined ? "a bare value" : `a ${closed.name} reference`
 }
 
-function headSignature(column: FindColumn): string {
-	const entry = column.entry
-	if (entry.kind === "var") {
-		return `${column.name}:var`
-	}
-	if (entry.kind === "compute") {
-		return `${column.name}:compute`
-	}
-	const agg = entry.agg
-	if (agg.op === "fold") {
-		return `${column.name}:${agg.fold}`
-	}
-	return `${column.name}:${agg.op}`
+function headOperation(column: FindColumn): HeadOpIr | undefined {
+	return column.entry.kind === "aggregate" ? headOpOf(column.entry.agg) : undefined
 }
 
 function renderParamAnchor(roster: AnyClosedRoster | undefined): string {
@@ -1668,12 +1700,22 @@ function alignedHeadOf(label: string, rules: readonly RuleData[]): readonly Find
 	if (first === undefined) {
 		throw new AuthoringError({ message: `${label} needs at least one rule` })
 	}
-	const signature = first.finds.map(headSignature).join(", ")
+	// Bare u64 admits either carrier, but does not make two different
+	// carriers compatible. Retain one original classed slot per column;
+	// checking only the first arm (or its weakened meet) loses that proof.
+	const classed = new Map<number, { readonly slot: ClassedField; readonly rule: number }>()
 	rules.forEach(function verifyHead(rule, index) {
-		const candidate = rule.finds.map(headSignature).join(", ")
-		if (candidate !== signature) {
+		if (
+			rule.finds.length !== first.finds.length ||
+			rule.finds.some((column, position) => {
+				const lead = first.finds[position]
+				return lead === undefined || lead.name !== column.name || headOperation(lead) !== headOperation(column)
+			})
+		) {
+			const render = (columns: readonly FindColumn[]) =>
+				columns.map((column) => `${column.name}:${headOperation(column) ?? "project"}`).join(", ")
 			throw new AuthoringError({
-				message: `every rule of ${label} derives the same head — rule 0 finds (${signature}), rule ${index} finds (${candidate})`
+				message: `every rule of ${label} derives the same head — rule 0 finds (${render(first.finds)}), rule ${index} finds (${render(rule.finds)})`
 			})
 		}
 		rule.finds.forEach(function verifyClosedSlice(column, position) {
@@ -1686,30 +1728,44 @@ function alignedHeadOf(label: string, rules: readonly RuleData[]): readonly Find
 			if (lead === undefined) {
 				return
 			}
-			if (lead.slot !== undefined && column.slot !== undefined && !headFieldJoins(lead.slot, column.slot)) {
+			const prior = classed.get(position) ?? (lead.slot === undefined ? undefined : { slot: lead.slot, rule: 0 })
+			if (prior !== undefined && column.slot !== undefined && !headFieldJoins(prior.slot, column.slot)) {
 				throw new AuthoringError({
-					message: `every rule of ${label} derives the same head — the head column ${lead.name} is bound at ${renderFieldKind(lead.slot)} in rule 0 but at ${renderFieldKind(column.slot)} in rule ${index} (a head column joins class-equal slots; same-wire u64 admits a bare side, and the merged head is bare)`
+					message: `every rule of ${label} derives the same head — the head column ${lead.name} is bound at ${renderFieldKind(prior.slot)} in rule ${prior.rule} but at ${renderFieldKind(column.slot)} in rule ${index} (a head column joins class-equal slots; same-wire u64 admits a bare side, and the merged head is bare)`
 				})
 			}
+			if (column.slot?.class !== undefined && !classed.has(position)) {
+				classed.set(position, { slot: column.slot, rule: index })
+			}
 		})
 	})
 	const merged = first.finds.map(function meetColumn(lead, position) {
 		const slot = lead.slot
-		if (slot === undefined || slot.class === undefined) {
+		if (slot === undefined) {
 			return lead
 		}
 		const demoted = rules.some(function bareElsewhere(rule) {
 			const column = rule.finds[position]
 			return column !== undefined && column.slot !== undefined && column.slot.class !== slot.class
 		})
-		if (!demoted) {
+		const field = slot.field
+		const widened =
+			field.kind === "interval" &&
+			rules.some((rule) => {
+				const other = rule.finds[position]?.slot?.field
+				return other?.kind === "interval" && other.width !== field.width
+			})
+		if (!demoted && !widened) {
 			return lead
 		}
 		return Object.freeze({
 			name: lead.name,
 			entry: lead.entry,
 			closed: lead.closed,
-			slot: Object.freeze({ field: slot.field, class: undefined })
+			slot: Object.freeze({
+				field: widened ? Object.freeze({ ...field, width: undefined }) : field,
+				class: demoted ? undefined : slot.class
+			})
 		})
 	})
 	return Object.freeze(merged)
@@ -2186,34 +2242,14 @@ function lowerComputeNode(node: QueryNode, ids: VarIds): ScalarExprIr {
 }
 
 function lowerComputeGrammar(node: QueryNode, ids: VarIds): ScalarExprIr {
-	switch (node.kind) {
-		case "var":
-			return { kind: "var", var: ids.of(node.ref as AnyVar) }
-		case "literal":
-			return { kind: "literal", value: literalWireOf(node.value) }
-		case "negate":
-		case "isNaN":
-		case "isFinite":
-			return { kind: node.kind, expr: lowerComputeGrammar(node.expr, ids) }
-		case "cast":
-			return { kind: "cast", cast: node.cast, expr: lowerComputeGrammar(node.expr, ids) }
-		case "add":
-		case "subtract":
-		case "multiply":
-		case "divide":
-			return {
-				kind: node.kind,
-				left: lowerComputeGrammar(node.left, ids),
-				right: lowerComputeGrammar(node.right, ids)
-			}
-		default:
-			throw new AuthoringError({
-				message: "query lowering: a query-var tree cannot carry a source-field leaf — use Compute over bound variables"
-			})
-	}
+	return scalarWire(node, (leaf) => {
+		return ids.of(leaf.ref as AnyVar)
+	})
 }
 
 function lowerFind(entry: FindEntryData, ids: VarIds): FindTermIr {
+	if (entry.kind === "segments")
+		return { kind: entry.kind, op: entry.op, left: ids.of(entry.left), right: ids.of(entry.right) }
 	if (entry.kind === "var") {
 		return { kind: "var", var: ids.of(entry.over) }
 	}
@@ -2244,6 +2280,7 @@ function headOpOf(agg: AggData): HeadOpIr {
 
 function headTermOf(column: FindColumn): HeadTermIr {
 	const entry = column.entry
+	if (entry.kind === "segments") return { kind: "compute" }
 	if (entry.kind === "var") {
 		return { kind: "var" }
 	}

package/src/query/parse-ir.ts

@@ -11,6 +11,7 @@ import type {
 	ScalarExprIr,
 	TermIr
 } from "#native.ts"
+import { roundingMode } from "#scalar.ts"
 import { arrayValue as array, recordValue, valueDescriptor } from "#values.ts"
 
 function fail(context: string, expected: string): never {
@@ -59,6 +60,7 @@ function scalar(context: string, input: unknown, depth = 1): ScalarExprIr {
 		case "literal":
 			recordValue(context, raw, ["kind", "value"])
 			return Object.freeze({ kind: raw.kind, value: valueDescriptor(`${context}.value`, raw.value) })
+		case "measure":
 		case "negate":
 		case "isNaN":
 		case "isFinite":
@@ -74,6 +76,15 @@ function scalar(context: string, input: unknown, depth = 1): ScalarExprIr {
 				left: scalar(`${context}.left`, raw.left, depth + 1),
 				right: scalar(`${context}.right`, raw.right, depth + 1)
 			})
+		case "mulDiv":
+			recordValue(context, raw, ["kind", "a", "b", "divisor", "rounding"])
+			return Object.freeze({
+				kind: raw.kind,
+				a: scalar(`${context}.a`, raw.a, depth + 1),
+				b: scalar(`${context}.b`, raw.b, depth + 1),
+				divisor: scalar(`${context}.divisor`, raw.divisor, depth + 1),
+				rounding: roundingMode(raw.rounding)
+			})
 		case "cast": {
 			recordValue(context, raw, ["kind", "cast", "expr"])
 			const cast = raw.cast
@@ -102,6 +113,16 @@ function headTerm(context: string, input: unknown): HeadTermIr {
 
 function find(context: string, input: unknown): FindTermIr {
 	const raw = tagged(context, input)
+	if (raw.kind === "segments") {
+		recordValue(context, raw, ["kind", "op", "left", "right"])
+		if (raw.op !== "intersection" && raw.op !== "difference") return fail(context, "unknown segment operator")
+		return Object.freeze({
+			kind: raw.kind,
+			op: raw.op,
+			left: ordinal(context, raw.left),
+			right: ordinal(context, raw.right)
+		})
+	}
 	switch (raw.kind) {
 		case "var":
 			recordValue(context, raw, ["kind", "var"])
@@ -210,8 +231,8 @@ function align(context: string, head: readonly HeadTermIr[], rules: readonly Rul
 		if (rule.finds.length !== head.length) fail(`${context}.rules[${index}]`, "finds width does not match head width")
 		for (const [position, find] of rule.finds.entries()) {
 			const term = head[position]
-			const family = find.kind === "var" || find.kind === "compute" ? find.kind : "aggregate"
-			if (term?.kind !== family)
+			const projects = find.kind === "var" || find.kind === "compute" || find.kind === "segments"
+			if (term === undefined || (term.kind === "aggregate") === projects)
 				fail(`${context}.rules[${index}].finds[${position}]`, "find family does not match head")
 			if (term.kind === "aggregate") {
 				const op = find.kind === "aggregate" ? find.op.kind : find.kind
@@ -258,7 +279,10 @@ function parseQueryIr(input: unknown): ParsedQuery {
 		if (rec.length === 0) return fail("parseQueryIr", "rec step is empty")
 		align("rec base", headRec, base)
 		align("rec step", headRec, rec)
-		if (headRec.some((term) => term.kind !== "var") || [...base, ...rec].some((rule) => rule.negated.length !== 0))
+		if (
+			headRec.some((term) => term.kind !== "var") ||
+			[...base, ...rec].some((rule) => rule.negated.length !== 0 || rule.finds.some((find) => find.kind !== "var"))
+		)
 			return fail("query.rec", "recursion requires projection-only heads and no negation")
 		owned = { kind: raw.kind, interiors, head, rules, rec: Object.freeze({ head: headRec, base, rec }) }
 	}

package/src/query/scope.ts

@@ -369,7 +369,14 @@ function fieldAntiJoins(a: ClassedField, b: ClassedField): boolean {
  * joins cannot inherit provenance a rule never proved.
  */
 function headFieldJoins(a: ClassedField, b: ClassedField): boolean {
-	return fieldJoins(a, b) || u64BareWirePair(a, b)
+	return (
+		fieldJoins(a, b) ||
+		u64BareWirePair(a, b) ||
+		(a.class === b.class &&
+			a.field.kind === "interval" &&
+			b.field.kind === "interval" &&
+			a.field.element === b.field.element)
+	)
 }
 
 function renderFieldKind(slot: ClassedField): string {

package/src/query/segments.ts

@@ -0,0 +1,61 @@
+import { AuthoringError } from "#errors.ts"
+import type { IntervalElementKind, IntervalField } from "#fields.ts"
+import { type AnyVar, isTerm, term } from "#query/scope.ts"
+import { recordValue } from "#values.ts"
+
+type IntervalVar<E extends IntervalElementKind = IntervalElementKind> = AnyVar & { readonly field: IntervalField<E> }
+type SegmentOp = "intersection" | "difference"
+
+/** A relational find output, using the native binary segment operator directly. */
+interface Segments<E extends IntervalElementKind = IntervalElementKind> {
+	readonly kind: "segments"
+	readonly op: SegmentOp
+	readonly left: IntervalVar<E>
+	readonly right: IntervalVar<E>
+}
+
+function segments<E extends IntervalElementKind>(
+	op: SegmentOp,
+	left: IntervalVar<E>,
+	right: IntervalVar<NoInfer<E>>
+): Segments<E> {
+	if (
+		!isTerm(left) ||
+		left[term] !== "var" ||
+		!isTerm(right) ||
+		right[term] !== "var" ||
+		left.field.kind !== "interval" ||
+		right.field.kind !== "interval" ||
+		left.field.element !== right.field.element
+	)
+		throw new AuthoringError({ message: `${op}: expected interval variables of the same element kind` })
+	return Object.freeze({ kind: "segments", op, left, right })
+}
+
+function intersection<E extends IntervalElementKind>(
+	left: IntervalVar<E>,
+	right: IntervalVar<NoInfer<E>>
+): Segments<E> {
+	return segments("intersection", left, right)
+}
+
+function difference<E extends IntervalElementKind>(left: IntervalVar<E>, right: IntervalVar<NoInfer<E>>): Segments<E> {
+	return segments("difference", left, right)
+}
+
+function isSegments(input: unknown): input is Segments {
+	if (typeof input !== "object" || input === null || !("kind" in input) || input.kind !== "segments") return false
+	recordValue("segments", input, ["kind", "op", "left", "right"])
+	const value = input as Segments
+	if (value.op !== "intersection" && value.op !== "difference")
+		throw new AuthoringError({ message: "unknown segment operator" })
+	segments(value.op, value.left, value.right)
+	return true
+}
+
+function segmentField(value: Segments): IntervalField<IntervalElementKind, undefined> {
+	return Object.freeze({ kind: "interval", element: value.left.field.element, width: undefined })
+}
+
+export type { IntervalVar, SegmentOp, Segments }
+export { difference, intersection, isSegments, segmentField }

package/src/runtime-codes.ts

@@ -3,6 +3,7 @@ export const runtimeErrorCodes = [
 	"RuntimeAlreadyLive",
 	"ForeignRuntime",
 	"ClosedHandle",
+	"HandleBusy",
 	"SpentHandle",
 	"QueueFull",
 	"InvalidArgument",