@bjornpagen/bumbledb 1.2.0 → 1.3.0

package/src/native.ts

@@ -89,6 +89,14 @@ type HeadOpIr = "sum" | "mean" | "min" | "max" | "count" | "pack"
 type NumericCastIr = "toF64" | "toF64Exact" | "toI64Exact" | "toU64Exact"
 
 type ScalarExprIr =
+	| { readonly kind: "measure"; readonly expr: ScalarExprIr }
+	| {
+			readonly kind: "mulDiv"
+			readonly a: ScalarExprIr
+			readonly b: ScalarExprIr
+			readonly divisor: ScalarExprIr
+			readonly rounding: import("#scalar.ts").Rounding
+	  }
 	| { readonly kind: "var"; readonly var: number }
 	| { readonly kind: "literal"; readonly value: TaggedValue }
 	| { readonly kind: "negate"; readonly expr: ScalarExprIr }
@@ -114,6 +122,12 @@ type FoldOpIr =
 	| { readonly kind: "max" }
 
 type FindTermIr =
+	| {
+			readonly kind: "segments"
+			readonly op: import("#query/segments.ts").SegmentOp
+			readonly left: number
+			readonly right: number
+	  }
 	| { readonly kind: "var"; readonly var: number }
 	| { readonly kind: "compute"; readonly expr: ScalarExprIr }
 	| { readonly kind: "count" }

package/src/query/atom.ts

@@ -16,6 +16,7 @@ import type {
 	ShapeOf
 } from "#query/scope.ts"
 import { isTerm, term } from "#query/scope.ts"
+import type { Segments } from "#query/segments.ts"
 import type { FieldsShape } from "#relation.ts"
 import type { ScalarKind } from "#scalar.ts"
 import type { Uuid } from "#uuid.ts"
@@ -75,6 +76,7 @@ type AggData =
 
 /** Compute `expr` is the shared `#scalar.ts` query-var node (one grammar). */
 type FindEntryData =
+	| Segments
 	| { readonly kind: "var"; readonly over: AnyVar }
 	| { readonly kind: "aggregate"; readonly agg: AggData }
 	| { readonly kind: "compute"; readonly expr: QueryNode; readonly result: ScalarKind }

package/src/query/compute.ts

@@ -13,7 +13,7 @@ import type { AnyField } from "#fields.ts"
 import { bool as boolField, f64 as f64Field, i64 as i64Field, rosterOf, u64 as u64Field } from "#fields.ts"
 import type { AnyVar } from "#query/scope.ts"
 import { isTerm, term } from "#query/scope.ts"
-import type { ScalarKind, ScalarLiteral, ScalarNode } from "#scalar.ts"
+import type { Rounding, ScalarKind, ScalarLiteral, ScalarNode } from "#scalar.ts"
 import {
 	checkBool,
 	checkF64,
@@ -27,6 +27,8 @@ import {
 	scalarCast,
 	scalarFloatPredicate,
 	scalarLiteral,
+	scalarMeasure,
+	scalarMulDiv,
 	scalarNegate
 } from "#scalar.ts"
 
@@ -61,7 +63,11 @@ type OperandKind<O> =
 			: never
 
 function isComputeExpr(value: unknown): value is AnyComputeExpr {
-	return isScalarNode(value) && value.scope === "query-var" && value.result !== "unresolved"
+	return (
+		isScalarNode(value) &&
+		value.scope === "query-var" &&
+		(value.result === "u64" || value.result === "i64" || value.result === "f64" || value.result === "bool")
+	)
 }
 
 function varKindOf(where: string, ref: AnyVar): ScalarKind {
@@ -167,6 +173,37 @@ function negate<O extends SignedOperand>(operand: O): ComputeExpr<OperandKind<O>
 	return scalarNegate(where, asQueryNode(where, operand)) as ComputeExpr<OperandKind<O> & ("i64" | "f64")>
 }
 
+type IntegerOperand =
+	| ComputeExpr<"u64">
+	| ComputeExpr<"i64">
+	| (AnyVar & { readonly field: { readonly kind: "i64" | "u64" } })
+
+function mulDiv<A extends IntegerOperand, B extends IntegerOperand, D extends IntegerOperand>(
+	a: A,
+	b: B & (OperandKind<A> extends OperandKind<B> ? unknown : never),
+	divisor: D & (OperandKind<A> extends OperandKind<D> ? unknown : never),
+	rounding: Rounding
+): ComputeExpr<OperandKind<A>> {
+	return scalarMulDiv(
+		"Compute.mulDiv",
+		asQueryNode("Compute.mulDiv", a),
+		asQueryNode("Compute.mulDiv", b),
+		asQueryNode("Compute.mulDiv", divisor),
+		rounding
+	) as ComputeExpr<OperandKind<A>>
+}
+
+function measure<V extends AnyVar & { readonly field: { readonly kind: "interval" } }>(
+	interval: V
+): ComputeExpr<V["field"] extends { readonly element: "f64" } ? "f64" : "u64"> {
+	if (!isTerm(interval) || interval[term] !== "var" || interval.field.kind !== "interval")
+		throw new AuthoringError({ message: "Compute.measure: expected an interval variable" })
+	const kind = { u64: "intervalU64", i64: "intervalI64", f64: "intervalF64" } as const
+	return scalarMeasure("Compute.measure", queryVarLeaf(interval, kind[interval.field.element])) as ComputeExpr<
+		V["field"] extends { readonly element: "f64" } ? "f64" : "u64"
+	>
+}
+
 function toF64(operand: ArithmeticOperand): ComputeExpr<"f64"> {
 	const where = "Compute.toF64"
 	return scalarCast(where, "toF64", "f64", asQueryNode(where, operand)) as ComputeExpr<"f64">
@@ -225,6 +262,8 @@ const Compute = Object.freeze({
 	subtract,
 	multiply,
 	divide,
+	mulDiv,
+	measure,
 	toF64,
 	toF64Exact,
 	toI64Exact,

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")
@@ -259,6 +280,10 @@ function replayRule(
 						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 { AnyField, Infer } 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,31 +82,54 @@ 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]> }
 
+type ComputeFields = {
+	readonly u64: U64Field
+	readonly i64: I64Field
+	readonly f64: F64Field
+	readonly bool: BoolField
+}
+
 /**
- * The head signature of a recursive rule's find record as classed mint
- * slots (descriptor + law-computed class), keyed by column name — the
- * signature an interior join pairs against (`F` is variable-only there).
+ * The head signature as classed slots, shared by derived-stage and imported
+ * query variables. Projection preserves its carrier; aggregates/computations
+ * 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 AnyComputeExpr
-			? { readonly field: AnyField; 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,
@@ -87,7 +87,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"
@@ -100,6 +101,8 @@ type RowOf<T> = InferredOf<T> extends { readonly row: infer R } ? R : never
 
 type HeadShape = Readonly<Record<string, ClassedField>> | undefined
 
+type HeadOf<T> = InferredOf<T> extends { readonly head: infer H extends HeadShape } ? H : 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 }
@@ -145,6 +148,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
 }
 
@@ -225,7 +230,12 @@ interface QueryRuleChain<
 		bindings: B & CheckInteriorBindings<B>
 	): QueryRuleChain<Rels, P, Classes>
 
-	find<const F extends FindShape>(entries: F & CheckFind<F>): RuleValue<RowOfFind<F>, P>
+	/** A record of variables is already a valid projection, including v(rel)
+	 * for a generic relation. Aggregate judgments remain on the general form. */
+	find<const F extends Readonly<Record<string, AnyVar>>>(
+		entries: F
+	): RuleValue<RowOfFind<F>, P, HeadRecordOf<Classes, F>>
+	find<const F extends FindShape>(entries: F & CheckFind<F>): RuleValue<RowOfFind<F>, P, HeadRecordOf<Classes, F>>
 }
 
 interface InteriorRuleScope<Rels extends SchemaRelations, Classes extends SchemaClasses = SchemaClasses>
@@ -292,6 +302,9 @@ interface InteriorRuleChain<
 	 * Nonrecursive derived stages emit aggregate/computed outputs too
 	 * (C05): only the RECURSIVE head stays projection-only.
 	 */
+	find<const F extends Readonly<Record<string, AnyVar>>>(
+		entries: F
+	): RuleValue<RowOfFind<F>, P, HeadRecordOf<Classes, F>>
 	find<const F extends FindShape>(entries: F & CheckFind<F>): RuleValue<RowOfFind<F>, P, HeadRecordOf<Classes, F>>
 }
 
@@ -355,6 +368,9 @@ interface RecRuleChain<
 		name: string,
 		bindings: B & CheckInteriorBindings<B>
 	): RecRuleChain<Rels, P, Classes>
+	find<const F extends Readonly<Record<string, AnyVar>>>(
+		entries: F
+	): RuleValue<RowOfFind<F>, P, HeadRecordOf<Classes, F>>
 	find<const F extends FindShape>(entries: F & CheckRecFind<F>): RuleValue<RowOfFind<F>, P, HeadRecordOf<Classes, F>>
 }
 
@@ -388,22 +404,23 @@ interface Query<
 	Rels extends SchemaRelations,
 	Row,
 	Params extends ParamsRecord,
-	Classes extends SchemaClasses = SchemaClasses
+	Classes extends SchemaClasses = SchemaClasses,
+	Head extends HeadShape = HeadShape
 > {
 	readonly schema: Schema<Rels, Classes>
 	readonly data: QueryData
 
 	rule<RV extends AnyRuleValue>(
 		build: (r: QueryRuleScope<Rels, Classes>) => RV
-	): Query<Rels, Row | RowOf<RV>, Flatten<Params & ParamsOf<RV>>, Classes>
+	): Query<Rels, Row | RowOf<RV>, Flatten<Params & ParamsOf<RV>>, Classes, Head | HeadOf<RV>>
 
 	/** A diagnostic name for composition/tracing — never a schema relation. */
-	named(label: string): Query<Rels, Row, Params, Classes>
+	named(label: string): Query<Rels, Row, Params, Classes, Head>
 
 	interior(name: string, ...builds: never[]): never
 
 	reach(name: string, arms: never): never
-	readonly [inferred]?: { readonly row: Row; readonly params: Params }
+	readonly [inferred]?: { readonly row: Row; readonly params: Params; readonly head: Head }
 }
 
 interface AnyQuery {
@@ -422,7 +439,7 @@ type QueryStart<
 > = {
 	rule<RV extends AnyRuleValue>(
 		build: (r: QueryRuleScope<Rels, Classes>) => RV
-	): Query<Rels, RowOf<RV>, Flatten<P & ParamsOf<RV>>, Classes>
+	): Query<Rels, RowOf<RV>, Flatten<P & ParamsOf<RV>>, Classes, HeadOf<RV>>
 	interior<const Builds extends readonly InteriorBuild<Rels, Classes>[]>(
 		name: string,
 		...builds: Builds
@@ -440,7 +457,7 @@ type QueryReachStart<
 > = {
 	rule<RV extends AnyRuleValue>(
 		build: (r: QueryRuleScope<Rels, Classes>) => RV
-	): Query<Rels, RowOf<RV>, Flatten<P & ParamsOf<RV>>, Classes>
+	): Query<Rels, RowOf<RV>, Flatten<P & ParamsOf<RV>>, Classes, HeadOf<RV>>
 }
 
 const termOps: TermOps = Object.freeze({
@@ -462,7 +479,9 @@ const termOps: TermOps = Object.freeze({
 	mean,
 	min,
 	max,
-	pack
+	pack,
+	intersection,
+	difference
 })
 
 interface RuleBuildState {
@@ -851,6 +870,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,
@@ -926,6 +947,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)
 	}
@@ -943,13 +965,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
@@ -1071,6 +1101,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)
@@ -1507,6 +1544,7 @@ function renderClosedSlice(closed: AnyClosedRoster | undefined): string {
 
 function headSignature(column: FindColumn): string {
 	const entry = column.entry
+	if (entry.kind === "segments") return `${column.name}:compute`
 	if (entry.kind === "var") {
 		return `${column.name}:var`
 	}
@@ -1774,13 +1812,19 @@ function makeRawQuery(
 	return value
 }
 
-function makeQuery<Rels extends SchemaRelations, Row, P extends ParamsRecord, Classes extends SchemaClasses>(
+function makeQuery<
+	Rels extends SchemaRelations,
+	Row,
+	P extends ParamsRecord,
+	Classes extends SchemaClasses,
+	Head extends HeadShape
+>(
 	theory: Schema<Rels, Classes>,
 	interiors: readonly InteriorData[],
 	rec: RecData | undefined,
 	rules: readonly RuleData[]
-): Query<Rels, Row, P, Classes> {
-	return makeRawQuery(theory, interiors, rec, rules) as unknown as Query<Rels, Row, P, Classes>
+): Query<Rels, Row, P, Classes, Head> {
+	return makeRawQuery(theory, interiors, rec, rules) as unknown as Query<Rels, Row, P, Classes, Head>
 }
 
 function collectInterior<Rels extends SchemaRelations, Classes extends SchemaClasses>(
@@ -1899,9 +1943,11 @@ function makeQueryStart<Rels extends SchemaRelations, Classes extends SchemaClas
 		},
 		rule<RV extends AnyRuleValue>(
 			build: (r: QueryRuleScope<Rels, Classes>) => RV
-		): Query<Rels, RowOf<RV>, Flatten<P & ParamsOf<RV>>, Classes> {
+		): Query<Rels, RowOf<RV>, Flatten<P & ParamsOf<RV>>, Classes, HeadOf<RV>> {
 			const built = build(makeQueryRuleScope<Rels, Classes>(theory, env))
-			return makeQuery<Rels, RowOf<RV>, Flatten<P & ParamsOf<RV>>, Classes>(theory, interiors, undefined, [built.rule])
+			return makeQuery<Rels, RowOf<RV>, Flatten<P & ParamsOf<RV>>, Classes, HeadOf<RV>>(theory, interiors, undefined, [
+				built.rule
+			])
 		}
 	}
 	Object.freeze(start)
@@ -1917,9 +1963,11 @@ function makeQueryReachStart<Rels extends SchemaRelations, Classes extends Schem
 	const start = {
 		rule<RV extends AnyRuleValue>(
 			build: (r: QueryRuleScope<Rels, Classes>) => RV
-		): Query<Rels, RowOf<RV>, Flatten<P & ParamsOf<RV>>, Classes> {
+		): Query<Rels, RowOf<RV>, Flatten<P & ParamsOf<RV>>, Classes, HeadOf<RV>> {
 			const built = build(makeQueryRuleScope<Rels, Classes>(theory, env))
-			return makeQuery<Rels, RowOf<RV>, Flatten<P & ParamsOf<RV>>, Classes>(theory, interiors, rec, [built.rule])
+			return makeQuery<Rels, RowOf<RV>, Flatten<P & ParamsOf<RV>>, Classes, HeadOf<RV>>(theory, interiors, rec, [
+				built.rule
+			])
 		}
 	}
 	Object.freeze(start)
@@ -2162,34 +2210,15 @@ 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) => {
+		if (leaf.kind !== "var") throw new AuthoringError({ message: "query expressions require bound variables" })
+		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) }
 	}
@@ -2220,6 +2249,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,7 +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"
+			const plainFamily = find.kind === "var" || find.kind === "compute" ? find.kind : "aggregate"
+			const family = find.kind === "segments" ? "compute" : plainFamily
 			if (term?.kind !== family)
 				fail(`${context}.rules[${index}].finds[${position}]`, "find family does not match head")
 			if (term.kind === "aggregate") {