@bjornpagen/bumbledb 1.3.0 → 1.3.1

package/src/native.ts

@@ -82,7 +82,7 @@ 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.
  */
@@ -294,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 =
@@ -311,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
 				  }
 	  }
 
@@ -327,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 {
@@ -341,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/compute.ts

@@ -1,13 +1,5 @@
-/**
- * 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"
@@ -32,13 +24,13 @@ import {
 	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">
 
@@ -65,7 +57,6 @@ type OperandKind<O> =
 function isComputeExpr(value: unknown): value is AnyComputeExpr {
 	return (
 		isScalarNode(value) &&
-		value.scope === "query-var" &&
 		(value.result === "u64" || value.result === "i64" || value.result === "f64" || value.result === "bool")
 	)
 }
@@ -99,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"> {

package/src/query/description.ts

@@ -269,13 +269,13 @@ 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")
 				}

package/src/query/lower.ts

@@ -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,
@@ -103,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 }
@@ -412,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>
@@ -1542,20 +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 === "segments") return `${column.name}:compute`
-	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 {
@@ -1692,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) {
@@ -1710,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)
@@ -2211,7 +2243,6 @@ function lowerComputeNode(node: QueryNode, ids: VarIds): ScalarExprIr {
 
 function lowerComputeGrammar(node: QueryNode, ids: VarIds): ScalarExprIr {
 	return scalarWire(node, (leaf) => {
-		if (leaf.kind !== "var") throw new AuthoringError({ message: "query expressions require bound variables" })
 		return ids.of(leaf.ref as AnyVar)
 	})
 }

package/src/query/parse-ir.ts

@@ -231,9 +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 plainFamily = find.kind === "var" || find.kind === "compute" ? find.kind : "aggregate"
-			const family = find.kind === "segments" ? "compute" : plainFamily
-			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
@@ -280,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/runtime-codes.ts

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

package/src/runtime-errors.ts

@@ -32,11 +32,18 @@ const Io = Schema.Struct({
 	kind: Schema.String,
 	osCode: Schema.optional(Schema.Number)
 })
-/** A typed engine refusal crossing the executor: core family tag + message. */
+const StatementDiagnostic = Schema.Struct({ id: Schema.Number, descriptor: Schema.String })
+const SchemaDiagnostic = Schema.Struct({
+	statement: StatementDiagnostic,
+	conflict: Schema.optional(StatementDiagnostic)
+})
+
+/** A typed engine refusal, including native statement coordinates when known. */
 const Engine = Schema.Struct({
 	_tag: Schema.Literal("Engine"),
 	kind: Schema.String,
-	message: Schema.String
+	message: Schema.String,
+	diagnostic: Schema.optional(SchemaDiagnostic)
 })
 export const DbReason = Schema.Union([ResourceLimit, Io, Engine, InvalidArgument, PlainReason])
 export class DbError extends Schema.TaggedError<DbError>()("DbError", {
@@ -68,7 +75,13 @@ export function dbError(operation: string, cause: unknown): DbError {
 		"message" in cause &&
 		typeof cause.message === "string"
 	) {
-		return new DbError({ operation, reason: { _tag: "Engine", kind: cause.kind, message: cause.message } })
+		const reason = decodeReason({
+			_tag: "Engine",
+			kind: cause.kind,
+			message: cause.message,
+			diagnostic: "diagnostic" in cause ? cause.diagnostic : undefined
+		})
+		if (reason._tag === "Some") return new DbError({ operation, reason: reason.value })
 	}
 	return new DbError({ operation, reason: { _tag: "Internal" } })
 }

package/src/runtime-native.ts

@@ -28,11 +28,6 @@ export interface DirectoryHandle {
 	readonly __directory: unique symbol
 }
 
-/** Stamped `NativeKind::RepositoryLock` mint — not a directory-owner twin. */
-export interface RepositoryLockHandle {
-	readonly __repositoryLock: unique symbol
-}
-
 /** Resource kinds installed in native worker tables. */
 export type NativeKind = "snapshot" | "prepared" | "result" | "cursor" | "draft" | "changes" | "repository-lock"
 
@@ -55,6 +50,7 @@ export type ManagedDbOutcome =
 			readonly tag: "refused"
 			readonly kind: "schemaError" | "newtypeMismatch" | "fingerprintMismatch" | "destinationExists"
 			readonly message: string
+			readonly diagnostic?: Extract<import("#runtime-errors.ts").DbError["reason"], { _tag: "Engine" }>["diagnostic"]
 	  }
 
 export type LogTakeWire =
@@ -179,10 +175,6 @@ interface RuntimeNative {
 		callback: () => void
 	): OperationHandle
 	runtimeLogTake(operation: OperationHandle): LogTakeWire
-	/** L14 mint: `Runtime::mint_repository_lock` stamps `NativeKind::RepositoryLock` at take. */
-	logRepositoryLockAcquire(runtime: RuntimeHandle, directory: string, callback: () => void): OperationHandle
-	logRepositoryLockTake(operation: OperationHandle): RepositoryLockHandle
-	logRepositoryLockRelease(owner: RepositoryLockHandle, callback: (report: CloseWire) => void): void
 }
 
 // The checked source/fresh-addon roster test pins this private declaration.

package/src/runtime.ts

@@ -1,7 +1,7 @@
 import { Context, Duration, Effect, Exit, Layer } from "effect"
 import type { CloseReport, OutstandingWork } from "#runtime-errors.ts"
 import { CloseFailure, DbError, dbError } from "#runtime-errors.ts"
-import type { CloseWire, OperationHandle, OptionsWire, RepositoryLockHandle, RuntimeHandle } from "#runtime-native.ts"
+import type { CloseWire, OperationHandle, OptionsWire, RuntimeHandle } from "#runtime-native.ts"
 import { runtimeNative } from "#runtime-native.ts"
 
 export interface NativeRuntimeOptions {
@@ -283,75 +283,6 @@ export const runtimeHandle = Effect.fn("NativeRuntime.handle")(function* () {
 	return handle
 })
 
-/**
- * Opaque kernel fence (C8). Backed by L14 `log_repository_lock_*` and
- * L12 `mint_repository_lock` (`NativeKind::RepositoryLock`). Native
- * exclusion is the owner — there is no JS occupancy table. `release`
- * is the one close: it joins `logRepositoryLockRelease` then clears
- * `slot.owner` so the Scope finalizer is a no-op. Callers join host
- * I/O first (`joinPendingIo.pipe(Effect.andThen(lock.release))`).
- */
-export interface RepositoryLock {
-	readonly directory: string
-	readonly release: Effect.Effect<void>
-}
-
-function joinLockRelease(operation: string, owner: RepositoryLockHandle): Effect.Effect<void> {
-	return drain(operation, (callback) => runtimeNative.logRepositoryLockRelease(owner, callback)).pipe(
-		Effect.flatMap((report) => finalizeClose(operation, report))
-	)
-}
-
-/**
- * Internal log seam: stamped mint only. Cleanup is registered before
- * the interruptible acquire: `acquireRelease({ interruptible })`
- * installs the finalizer only after acquire succeeds. Interrupt, defect,
- * and acquire failure all run the same slot finalizer — empty slot is
- * a no-op. No `runtimeDirectoryAcquire`, no core `Db`, no JS bookkeeping.
- */
-export const internalAcquireRepositoryLock = Effect.fn("internalAcquireRepositoryLock")(function* (
-	operation: string,
-	directory: string
-) {
-	if (directory.length === 0) {
-		return yield* Effect.fail(invalid(operation))
-	}
-	const runtime = yield* runtimeHandle()
-	const closeOp = `${operation}.repositoryLock`
-	return yield* Effect.uninterruptibleMask((restore) =>
-		Effect.gen(function* () {
-			const slot: { owner: RepositoryLockHandle | undefined } = { owner: undefined }
-			const release = Effect.suspend(() => {
-				const held = slot.owner
-				if (held === undefined) {
-					return Effect.void
-				}
-				return joinLockRelease(closeOp, held).pipe(
-					Effect.ensuring(
-						Effect.sync(() => {
-							slot.owner = undefined
-						})
-					)
-				)
-			})
-			yield* Effect.addFinalizer(() => release)
-			const owner = yield* restore(
-				nativeOperationWith(
-					operation,
-					(callback) => runtimeNative.logRepositoryLockAcquire(runtime, directory, callback),
-					runtimeNative.logRepositoryLockTake,
-					(value) => value
-				)
-			)
-			slot.owner = owner
-			return Object.freeze({
-				directory,
-				release
-			})
-		})
-	)
-})
-
 /** Internal first executor consumer; not a replacement row codec or public hash API. */
 export const hashChunk = Effect.fn("bumbledb.hashChunk")(function* (input: Uint8Array) {
 	const runtime = yield* NativeRuntime