@bjornpagen/bumbledb 1.2.1 → 1.3.1

package/dist/schema-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-file.d.ts","sourceRoot":"","sources":["../src/schema-file.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAG/B,OAAO,EAAE,OAAO,EAAW,MAAM,oBAAoB,CAAA;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAS1C,QAAA,MAAM,sBAAsB,2FAQ1B,CAAA;AAEF,QAAA,MAAM,sBAAsB,2FAY1B,CAAA;AAEF,OAAO,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,CAAA"}

package/dist/schema-file.js

@@ -0,0 +1,24 @@
+import { Effect } from "effect";
+import { dbNative } from "#db-native.ts";
+import { nativeOperationWith, runtimeHandle } from "#runtime.ts";
+import { DbError, dbError } from "#runtime-errors.ts";
+const decoder = new TextDecoder("utf-8", { fatal: true });
+function text(operation, bytes) {
+    if (bytes === null)
+        throw dbError(operation, { _tag: "Internal" });
+    return decoder.decode(bytes);
+}
+const internalSchemaSnapshot = Effect.fn("internalSchemaSnapshot")(function* (spec) {
+    const runtime = yield* runtimeHandle();
+    return yield* nativeOperationWith("internalSchemaSnapshot", (callback) => dbNative.runtimeSchemaSnapshot(runtime, spec, callback), dbNative.runtimeBytesTake, (bytes) => text("internalSchemaSnapshot", bytes));
+});
+const internalSchemaBindings = Effect.fn("internalSchemaBindings")(function* (snapshot) {
+    if (typeof snapshot !== "string" || !snapshot.isWellFormed()) {
+        return yield* Effect.fail(new DbError({ operation: "internalSchemaBindings", reason: { _tag: "InvalidArgument" } }));
+    }
+    const runtime = yield* runtimeHandle();
+    const bytes = new TextEncoder().encode(snapshot);
+    return yield* nativeOperationWith("internalSchemaBindings", (callback) => dbNative.runtimeSchemaBindings(runtime, bytes, callback), dbNative.runtimeBytesTake, (bytes) => text("internalSchemaBindings", bytes));
+});
+export { internalSchemaBindings, internalSchemaSnapshot };
+//# sourceMappingURL=schema-file.js.map

package/dist/schema-file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-file.js","sourceRoot":"","sources":["../src/schema-file.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAChE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAGrD,MAAM,OAAO,GAAG,IAAI,WAAW,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAA;AAEzD,SAAS,IAAI,CAAC,SAAiB,EAAE,KAAwB;IACxD,IAAI,KAAK,KAAK,IAAI;QAAE,MAAM,OAAO,CAAC,SAAS,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAA;IAClE,OAAO,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;AAC7B,CAAC;AAED,MAAM,sBAAsB,GAAG,MAAM,CAAC,EAAE,CAAC,wBAAwB,CAAC,CAAC,QAAQ,CAAC,EAAE,IAAgB;IAC7F,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,aAAa,EAAE,CAAA;IACtC,OAAO,KAAK,CAAC,CAAC,mBAAmB,CAChC,wBAAwB,EACxB,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,qBAAqB,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,CAAC,EACrE,QAAQ,CAAC,gBAAgB,EACzB,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,wBAAwB,EAAE,KAAK,CAAC,CAChD,CAAA;AACF,CAAC,CAAC,CAAA;AAEF,MAAM,sBAAsB,GAAG,MAAM,CAAC,EAAE,CAAC,wBAAwB,CAAC,CAAC,QAAQ,CAAC,EAAE,QAAgB;IAC7F,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,EAAE,CAAC;QAC9D,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,EAAE,SAAS,EAAE,wBAAwB,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE,EAAE,CAAC,CAAC,CAAA;IACrH,CAAC;IACD,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,aAAa,EAAE,CAAA;IACtC,MAAM,KAAK,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;IAChD,OAAO,KAAK,CAAC,CAAC,mBAAmB,CAChC,wBAAwB,EACxB,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,qBAAqB,CAAC,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,EACtE,QAAQ,CAAC,gBAAgB,EACzB,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,wBAAwB,EAAE,KAAK,CAAC,CAChD,CAAA;AACF,CAAC,CAAC,CAAA;AAEF,OAAO,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,CAAA"}

package/pack-provenance.json

@@ -1,7 +1,7 @@
 {
-	"candidateSourceDigest": "ca9592096bd15b3f2a56e586a074505ae6695befdad7ed4df816af59a0ae1bf5",
-	"specificationRevision": "87e9a83ee21d1f843c73ac6e7057b2b740db75aae70a553b8053b4f38e87bd2d",
-	"stagedAt": "2026-09-11T13:37:03.509Z",
+	"candidateSourceDigest": "7109ef17978c17a195301260c8b4cd2736ce785646c46c61d61bf7850c4299da",
+	"specificationRevision": "91f64ebf5ccf285a072aeff41ca364d1e837259e4273f9be12a0a5959c38a45e",
+	"stagedAt": "2026-09-12T00:04:00.990Z",
 	"package": "@bjornpagen/bumbledb",
-	"version": "1.2.1"
+	"version": "1.3.1"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bjornpagen/bumbledb",
-  "version": "1.2.1",
+  "version": "1.3.1",
   "description": "Effect-native embedded relational database for TypeScript: typed schemas and queries, exact floats, commit-time constraints",
   "type": "module",
   "exports": {
@@ -57,8 +57,8 @@
   },
   "private": false,
   "optionalDependencies": {
-    "@bjornpagen/bumbledb-darwin-arm64": "1.2.1",
-    "@bjornpagen/bumbledb-linux-arm64": "1.2.1",
-    "@bjornpagen/bumbledb-linux-x64": "1.2.1"
+    "@bjornpagen/bumbledb-darwin-arm64": "1.3.1",
+    "@bjornpagen/bumbledb-linux-arm64": "1.3.1",
+    "@bjornpagen/bumbledb-linux-x64": "1.3.1"
   }
 }

package/src/alternatives.ts

@@ -0,0 +1,95 @@
+import { type AnyClosed, closedDescriptor, closedId, sealedFieldOf } from "#closed.ts"
+import { AuthoringError } from "#errors.ts"
+import type { Face, SameArity, SameShapes } from "#face.ts"
+import { type ClosedIdField, signaturesAgree } from "#fields.ts"
+import type { RelationFields } from "#relation.ts"
+import {
+	type ContainmentStatement,
+	type KeyStatement,
+	type MirrorsStatement,
+	statementDescriptor
+} from "#statements.ts"
+import { recordValue } from "#values.ts"
+
+type KeyFace<K extends KeyStatement> = Face<K["owner"], K["projection"]>
+type ScalarKey<K extends KeyStatement> =
+	Extract<RelationFields<K["owner"]>[K["projection"][number]], { readonly kind: "interval" }> extends never
+		? unknown
+		: { readonly "alternative identity keys must be scalar": never }
+type Discriminator<P extends KeyStatement, C extends AnyClosed> = {
+	[F in keyof RelationFields<P["owner"]>]: RelationFields<P["owner"]>[F] extends ClosedIdField<C["name"], C["handles"]>
+		? F
+		: never
+}[keyof RelationFields<P["owner"]>] &
+	string
+
+function scalarKey(input: KeyStatement): KeyStatement {
+	const checked = statementDescriptor(input)
+	if (checked.kind !== "key") throw new AuthoringError({ message: "alternatives: expected a key statement" })
+	for (const name of checked.projection) {
+		if (sealedFieldOf(checked.owner, name)?.kind === "interval")
+			throw new AuthoringError({
+				message: "alternatives: identity keys must be scalar; interval keys prove point coverage"
+			})
+	}
+	return checked
+}
+
+/**
+ * Exhaustive closed alternatives, expanded into ordinary laws. Declare the
+ * supplied keys in the schema once; this helper emits only the discriminator
+ * containment followed by one mirrors statement per handle in roster order.
+ * No new statement kind or assembled payload representation is introduced.
+ */
+function alternatives<
+	P extends KeyStatement,
+	C extends AnyClosed,
+	const Arms extends Record<C["handles"][number], KeyStatement>
+>(
+	parent: P & ScalarKey<P>,
+	discriminator: Discriminator<NoInfer<P>, NoInfer<C>>,
+	roster: C,
+	arms: Arms &
+		Record<Exclude<keyof Arms, C["handles"][number]>, never> & {
+			readonly [H in C["handles"][number]]: ScalarKey<Arms[H]> &
+				SameArity<KeyFace<P>, KeyFace<Arms[H]>> &
+				SameShapes<KeyFace<P>, KeyFace<Arms[H]>>
+		}
+): readonly (ContainmentStatement | MirrorsStatement)[] {
+	const primary = scalarKey(parent)
+	const closed = closedDescriptor(roster)
+	const field = sealedFieldOf(primary.owner, discriminator)
+	if (field === undefined || !signaturesAgree(field, closedId(closed)))
+		throw new AuthoringError({ message: "alternatives: discriminator must reference the supplied closed roster" })
+	const payloads = recordValue("alternative arms", arms, closed.handles)
+	const statements: (ContainmentStatement | MirrorsStatement)[] = [
+		statementDescriptor({
+			kind: "containment",
+			source: { owner: primary.owner, projection: [discriminator], selection: [] },
+			target: { owner: closed, projection: ["id"], selection: [] }
+		})
+	]
+	const children = new Set<string>([primary.owner.name])
+	for (const handle of closed.handles) {
+		const child = scalarKey(payloads[handle] as KeyStatement)
+		if (children.has(child.owner.name))
+			throw new AuthoringError({
+				message: `alternatives: each arm needs its own payload relation (${child.owner.name})`
+			})
+		children.add(child.owner.name)
+		statements.push(
+			statementDescriptor({
+				kind: "mirrors",
+				source: {
+					owner: primary.owner,
+					projection: primary.projection,
+					selection: [{ field: discriminator, set: { kind: "one", literal: { kind: "handle", handle } } }]
+				},
+				target: { owner: child.owner, projection: child.projection, selection: [] }
+			})
+		)
+	}
+	return Object.freeze(statements)
+}
+
+export { alternatives }

package/src/changes.ts

@@ -93,7 +93,6 @@ interface DraftState {
 interface ChangesInternal {
 	readonly handle: ChangesHandle
 	readonly schemaId: SchemaId
-	closed: boolean
 }
 
 const changesInternals = new WeakMap<object, ChangesInternal>()
@@ -320,7 +319,6 @@ function acquireChanges<S extends AnySchema>(
 			Effect.suspend(() => {
 				const internal = changesInternals.get(changes)
 				if (internal === undefined) return Effect.void
-				internal.closed = true
 				return releaseOwner("ChangeSet.close", (callback) => dbNative.runtimeChangesClose(internal.handle, callback))
 			}),
 		{ interruptible: true }
@@ -330,7 +328,7 @@ function acquireChanges<S extends AnySchema>(
 function makeChangeSet<S extends AnySchema>(theory: S, wire: ChangesWire, schemaId: SchemaId): ChangeSet<S> {
 	const handle = wire.changes
 	const relations = Object.values(theory.relations)
-	const internal: ChangesInternal = { handle, schemaId, closed: false }
+	const internal: ChangesInternal = { handle, schemaId }
 	const value: ChangeSet<S> = {
 		schemaId,
 		counts: Object.freeze({ ...wire.counts }),
@@ -351,7 +349,6 @@ function makeChangeSet<S extends AnySchema>(theory: S, wire: ChangesWire, schema
 				const right = internalChanges(other)
 				if (right === undefined || right.schemaId !== schemaId)
 					return Effect.fail(refusal("ChangeSet.compose", "InvalidArgument"))
-				if (internal.closed || right.closed) return Effect.fail(refusal("ChangeSet.compose", "ClosedHandle"))
 				return acquireChanges(
 					theory,
 					schemaId,
@@ -365,10 +362,7 @@ function makeChangeSet<S extends AnySchema>(theory: S, wire: ChangesWire, schema
 			})
 		},
 		close() {
-			return Effect.suspend(() => {
-				internal.closed = true
-				return drainClose("ChangeSet.close", (callback) => dbNative.runtimeChangesClose(handle, callback))
-			})
+			return drainClose("ChangeSet.close", (callback) => dbNative.runtimeChangesClose(handle, callback))
 		}
 	}
 	Object.freeze(value)

package/src/codec.ts

@@ -3,7 +3,7 @@ import { membersAgree } from "#closed.ts"
 import { schemaTables } from "#compile.ts"
 import { dbNative } from "#db-native.ts"
 import { AuthoringError } from "#errors.ts"
-import type { AnyField } from "#fields.ts"
+import { type AnyField, fieldDescriptor, type Infer } from "#fields.ts"
 import { lower } from "#lower.ts"
 import { type AnyRelation, type Fact, relationDescriptor, relationFields } from "#relation.ts"
 import type { CellValue } from "#rows.ts"
@@ -141,7 +141,8 @@ function decodeTaggedF64(value: unknown): number | undefined {
 }
 
 /** Decode representation, then judge the value through the shared interpreter. */
-function decodeBoundaryValue(context: string, field: AnyField, input: unknown): unknown {
+function decodeBoundaryValue<F extends AnyField>(context: string, field: F, input: unknown): Infer<F>
+function decodeBoundaryValue(context: string, field: AnyField, input: unknown): Infer<AnyField> {
 	if ("closed" in field) return fieldValue(context, field, input)
 	let decoded: unknown = input
 	switch (field.kind) {
@@ -167,6 +168,35 @@ function decodeBoundaryValue(context: string, field: AnyField, input: unknown):
 	return fieldValue(context, field, decoded)
 }
 
+/** The host-value schema, using the same interpreter as facts and row codecs. */
+function fieldSchema<F extends AnyField>(field: F) {
+	const descriptor = fieldDescriptor("fieldSchema", field)
+	return EffectSchema.declare((value: unknown): value is Infer<F> => {
+		try {
+			fieldValue("fieldSchema", descriptor, value)
+			return true
+		} catch {
+			return false
+		}
+	})
+}
+
+/** Encode one field's host value in the canonical JSON-boundary form. */
+function encodeBoundaryField<F extends AnyField>(field: F, value: Infer<F>): Result.Result<unknown, DbError> {
+	return Result.try({
+		try: () => encodeBoundaryValue("encodeBoundaryField", fieldDescriptor("encodeBoundaryField", field), value),
+		catch: (cause) => argumentError("encodeBoundaryField", cause)
+	})
+}
+
+/** Strict JSON-boundary decoding, returning the field's canonical host value. */
+function decodeBoundaryField<F extends AnyField>(field: F, input: unknown): Result.Result<Infer<F>, DbError> {
+	return Result.try({
+		try: () => decodeBoundaryValue("decodeBoundaryField", fieldDescriptor("decodeBoundaryField", field), input),
+		catch: (cause) => argumentError("decodeBoundaryField", cause)
+	})
+}
+
 /** Pure schema-tagged JSON encoding of complete rows. */
 function encodeBoundaryRows<R extends AnyRelation>(
 	relation: R,
@@ -286,4 +316,14 @@ const decodeRows = Effect.fn("decodeRows")(function* <R extends AnyRelation>(sha
 })
 
 export type { RowShape }
-export { decodeBoundaryRows, decodeRows, encodeBoundaryRows, encodeRows, rowSchema, rowShape }
+export {
+	decodeBoundaryField,
+	decodeBoundaryRows,
+	decodeRows,
+	encodeBoundaryField,
+	encodeBoundaryRows,
+	encodeRows,
+	fieldSchema,
+	rowSchema,
+	rowShape
+}

package/src/db-native.ts

@@ -226,16 +226,8 @@ interface DbBridge {
 		bytes: Uint8Array,
 		callback: () => void
 	): OperationHandle
-
-	/**
-	 * Read-only migration-codec integration over native `schema_file` and
-	 * `migration::{plan, manifest}` through the shared executor: bounded
-	 * owned input, bounded owned JSON response bytes, one registered
-	 * cancellable operation. Neither verb opens, initializes, freezes or
-	 * migrates a database.
-	 */
-	runtimeMigrationSchema(runtime: RuntimeHandle, spec: SchemaSpec, callback: () => void): OperationHandle
-	runtimeMigrationRead(runtime: RuntimeHandle, request: Uint8Array, callback: () => void): OperationHandle
+	runtimeSchemaSnapshot(runtime: RuntimeHandle, spec: SchemaSpec, callback: () => void): OperationHandle
+	runtimeSchemaBindings(runtime: RuntimeHandle, snapshot: Uint8Array, callback: () => void): OperationHandle
 }
 
 // The fresh-addon roster test pins this private declaration exactly as it

package/src/index.ts

@@ -6,6 +6,7 @@
  * or disposal twin. The raw native bridge is not exported from this barrel.
  */
 
+export { alternatives } from "#alternatives.ts"
 export type {
 	BoundsOnTarget,
 	CapacityWeight,
@@ -27,7 +28,17 @@ export type {
 } from "#closed.ts"
 export { closed, closedId } from "#closed.ts"
 export type { RowShape } from "#codec.ts"
-export { decodeBoundaryRows, decodeRows, encodeBoundaryRows, encodeRows, rowSchema, rowShape } from "#codec.ts"
+export {
+	decodeBoundaryField,
+	decodeBoundaryRows,
+	decodeRows,
+	encodeBoundaryField,
+	encodeBoundaryRows,
+	encodeRows,
+	fieldSchema,
+	rowSchema,
+	rowShape
+} from "#codec.ts"
 export type { CompiledSchema, SchemaId } from "#compile.ts"
 export { Schema } from "#compile.ts"
 export type {
@@ -112,7 +123,13 @@ export type { FindColumn } from "#query/atom.ts"
 export { ALLEN } from "#query/atom.ts"
 export type { AnyComputeExpr, ComputeExpr, ComputeValue, QueryNode } from "#query/compute.ts"
 export { Compute } from "#query/compute.ts"
-export type { DescriptionParameter, DescriptionRow, DescriptionTable, QueryDescription } from "#query/description.ts"
+export type {
+	DescriptionHead,
+	DescriptionParameter,
+	DescriptionRow,
+	DescriptionTable,
+	QueryDescription
+} from "#query/description.ts"
 export { describeQuery, queryFromDescription } from "#query/description.ts"
 export type { Agg, HeadRecordOf, RowOfFind } from "#query/find.ts"
 export type {
@@ -147,6 +164,7 @@ export type {
 	VarsOf
 } from "#query/scope.ts"
 export { v } from "#query/scope.ts"
+export type { IntervalVar, SegmentOp, Segments } from "#query/segments.ts"
 export type {
 	AnyRelation,
 	Fact,
@@ -164,17 +182,16 @@ export { NativeRuntime } from "#runtime.ts"
 export type { CloseReport, OutstandingWork } from "#runtime-errors.ts"
 export { CloseFailure, DbError, dbError, runtimeErrorCodes } from "#runtime-errors.ts"
 export type {
+	IntervalKind,
 	NumericCast,
-	ScalarExpr,
-	ScalarFieldRef,
+	Rounding,
+	ScalarInputKind,
 	ScalarKind,
-	ScalarLeafScope,
 	ScalarLiteral,
 	ScalarNode,
 	ScalarResultKind,
 	ScalarValue
 } from "#scalar.ts"
-export { Scalar } from "#scalar.ts"
 export type { AnySchema, Schema as SchemaDeclaration, SchemaRelation, SchemaRelations } from "#schema.ts"
 export { schema } from "#schema.ts"
 export type { AnySelected, FieldsOf, Selected, SelectionBinding, SelectionInput } from "#selection.ts"

package/src/internal/log.ts

@@ -12,7 +12,6 @@ export type { PreparedQuery, QueryReader } from "#db.ts"
 export { Db, internalPublishedReader } from "#db.ts"
 export type { SnapshotHandle } from "#db-native.ts"
 export { lower } from "#lower.ts"
-export { internalMigrationRead, internalMigrationSchema } from "#migration.ts"
 export {
 	internalBlake3,
 	internalDescriptor,
@@ -22,11 +21,10 @@ export {
 } from "#native.ts"
 export type { CompleteResult } from "#result.ts"
 export { factCellsOf } from "#rows.ts"
-export type { NativeRuntimeOptions, RepositoryLock } from "#runtime.ts"
+export type { NativeRuntimeOptions } from "#runtime.ts"
 export {
 	finalizeClose,
 	hashChunk,
-	internalAcquireRepositoryLock,
 	NativeRuntime,
 	nativeOperation,
 	nativeOperationWith,
@@ -41,8 +39,8 @@ export type {
 	InspectionWire,
 	NativeKind,
 	OperationHandle,
-	RepositoryLockHandle,
 	RuntimeHandle
 } from "#runtime-native.ts"
 export { runtimeNative } from "#runtime-native.ts"
 export { schemasAgree } from "#schema.ts"
+export { internalSchemaBindings, internalSchemaSnapshot } from "#schema-file.ts"

package/src/native.ts

@@ -82,13 +82,21 @@ type HeadOpIr = "sum" | "mean" | "min" | "max" | "count" | "pack"
 
 /**
  * The computed-find scalar expression (C05 `FindTerm::Compute(ScalarExpr)`):
- * exactly the frozen core roster, spelled as the migration plan JSON spells
+ * exactly the frozen core roster, spelled as the canonical scalar JSON spells
  * the same expressions (one grammar, no second evaluator). `var` binds a
  * rule variable ordinal on this lane.
  */
 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" }
@@ -280,7 +294,7 @@ type LogAccess =
 			readonly operation: string
 			readonly intent:
 				| { readonly kind: "erasure" }
-				| { readonly kind: "migration"; readonly planSetDigest: Uint8Array; readonly target: string }
+				| { readonly kind: "transition"; readonly contractDigest: Uint8Array; readonly target: string }
 	  }
 
 type LogLifecycle =
@@ -297,10 +311,10 @@ type LogLifecycle =
 			readonly reason:
 				| { readonly kind: "erasure" }
 				| {
-						readonly kind: "migrationAborted"
+						readonly kind: "transitionAborted"
 						readonly sourceDatabase: string
 						readonly sourceIncarnation: string
-						readonly planSetDigest: Uint8Array
+						readonly contractDigest: Uint8Array
 				  }
 	  }
 
@@ -313,7 +327,7 @@ type LogActivation =
 			readonly cause:
 				| { readonly kind: "create" }
 				| { readonly kind: "restore" }
-				| { readonly kind: "migration"; readonly planSetDigest: Uint8Array }
+				| { readonly kind: "transition"; readonly contractDigest: Uint8Array }
 	  }
 
 interface LogAuthority {
@@ -327,10 +341,10 @@ type LogGenesisProvenance =
 	| { readonly kind: "create" }
 	| { readonly kind: "restore"; readonly sourceEvidence: Uint8Array }
 	| {
-			readonly kind: "migration"
+			readonly kind: "transition"
 			readonly sourceDatabase: string
 			readonly sourceIncarnation: string
-			readonly planSetDigest: Uint8Array
+			readonly contractDigest: Uint8Array
 	  }
 
 interface LogGenesis {

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

@@ -1,19 +1,11 @@
-/**
- * Query-scoped scalar expressions (C05 `FindTerm::Compute`): the
- * variable-addressed leaf scope over the ONE shared operator roster in
- * `#scalar.ts`. Leaves are bound query variables that lower to `VarId`s.
- * Operators are the shared constructors — this module only admits known
- * schema kinds at query-var leaves.
- *
- * `ComputeExpr<K>` is a `ScalarNode<"query-var", K>`. Distinct I64 and U64
- * survive host inference; they do not collapse to plain `bigint`.
- */
+/** Query scalar expressions use the same nodes that native preparation reads.
+ * Distinct i64 and u64 kinds survive TypeScript's shared bigint carrier. */
 import { AuthoringError } from "#errors.ts"
 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,16 +19,18 @@ import {
 	scalarCast,
 	scalarFloatPredicate,
 	scalarLiteral,
+	scalarMeasure,
+	scalarMulDiv,
 	scalarNegate
 } from "#scalar.ts"
 
-/** Query-var tree: the shared AST restricted to this leaf scope. */
-type QueryNode = ScalarNode<"query-var">
+/** Query expression, including interval leaves consumed by measure. */
+type QueryNode = ScalarNode
 
 /** Host value for a derived query compute kind. */
 type ComputeValue<K extends ScalarKind> = K extends "f64" ? number : K extends "bool" ? boolean : bigint
 
-type ComputeExpr<K extends ScalarKind> = ScalarNode<"query-var", K>
+type ComputeExpr<K extends ScalarKind> = ScalarNode<K>
 
 type AnyComputeExpr = ComputeExpr<"u64"> | ComputeExpr<"i64"> | ComputeExpr<"f64"> | ComputeExpr<"bool">
 
@@ -61,7 +55,10 @@ 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.result === "u64" || value.result === "i64" || value.result === "f64" || value.result === "bool")
+	)
 }
 
 function varKindOf(where: string, ref: AnyVar): ScalarKind {
@@ -93,7 +90,7 @@ function asQueryNode(where: string, operand: Operand): QueryNode {
 }
 
 function literal<K extends ScalarKind>(value: ScalarLiteral): ComputeExpr<K> {
-	return scalarLiteral("query-var", value) as ComputeExpr<K>
+	return scalarLiteral(value) as ComputeExpr<K>
 }
 
 function u64(value: bigint): ComputeExpr<"u64"> {
@@ -167,6 +164,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 +253,8 @@ const Compute = Object.freeze({
 	subtract,
 	multiply,
 	divide,
+	mulDiv,
+	measure,
 	toF64,
 	toF64Exact,
 	toI64Exact,