@bjornpagen/bumbledb 1.2.1 → 1.3.1

package/src/scalar.ts

@@ -1,31 +1,17 @@
-/**
- * The ONE leaf-scoped scalar AST (C1/C8): one tagged literal grammar and
- * operator roster, parameterized by {@link ScalarLeafScope}. TypeScript never
- * evaluates — the native compiler binds source fields and the engine
- * `ScalarEvaluator` executes. Construction is constant work against cached
- * depth/kind summaries; it does not re-walk the tree.
- *
- * Query-var leaves carry a known schema kind. Source-field leaves stay
- * `unresolved` until native snapshot binding. A result kind is recorded only
- * when it is derivable from known operands; otherwise it stays unresolved.
- * Known incompatible kinds refuse here. Unresolved trees are inert metadata,
- * not typechecked programs.
- *
- * Wire spellings (the grammar arms, not a second flattened interpretation):
- *   migration plan JSON — field/literal/operator nodes; one-arm literals (`{ u64: n }`)
- *   query IR — `{ kind: "literal", value: ValueSpec }` via `literalWireOf`
- */
+/** Query scalar nodes, with cached kind and depth. Construction is constant
+ * work; native preparation binds variables and evaluates the expressions. */
 import { AuthoringError } from "#errors.ts"
+import type { ScalarExprIr } from "#native.ts"
 import type { ValueSpec } from "#spec.ts"
 
-/** F0: leaf scope for the shared AST (C1). Query vars are typed; source fields stay unresolved. */
-export type ScalarLeafScope = "query-var" | "source-field"
-
 /** The engine's scalar result vocabulary — distinct at the type level. */
 type ScalarKind = "u64" | "i64" | "f64" | "bool"
 
 /** Cached result kind: known only when derivable; otherwise honestly unresolved. */
-type ScalarResultKind = ScalarKind | "unresolved"
+type IntervalKind = "intervalU64" | "intervalI64" | "intervalF64"
+type ScalarInputKind = ScalarKind | IntervalKind
+type ScalarResultKind = ScalarInputKind
+type Rounding = "towardZero" | "nearestTiesAwayFromZero" | "nearestTiesToEven"
 
 /** Host value for a derived scalar kind. */
 type ScalarValue<K extends ScalarKind> = K extends "f64" ? number : K extends "bool" ? boolean : bigint
@@ -34,33 +20,24 @@ type NumericCast = "toF64" | "toF64Exact" | "toI64Exact" | "toU64Exact"
 
 type NumericKind = "u64" | "i64" | "f64"
 
-type NumericOrUnresolved = NumericKind | "unresolved"
-
-/**
- * Combine known numeric kinds, or stay unresolved when a source-field leaf
- * still needs native binding. Distinct known kinds collapse to `never`
- * (static refusal) and throw at the constructor.
- */
-type CombineNumeric<L, R> = L extends "unresolved"
-	? R extends "bool"
-		? never
-		: "unresolved"
-	: R extends "unresolved"
-		? L extends "bool"
-			? never
-			: "unresolved"
-		: L extends R
-			? L
-			: never
-
-/** The tagged literal subset shared by every leaf scope. */
 type ScalarLiteral =
 	| { readonly bool: boolean }
 	| { readonly u64: bigint }
 	| { readonly i64: bigint }
 	| { readonly f64: number }
 
-type ScalarOpKind = "literal" | "negate" | "isNaN" | "isFinite" | "add" | "subtract" | "multiply" | "divide" | "cast"
+type ScalarOpKind =
+	| "literal"
+	| "negate"
+	| "isNaN"
+	| "isFinite"
+	| "add"
+	| "subtract"
+	| "multiply"
+	| "divide"
+	| "cast"
+	| "mulDiv"
+	| "measure"
 
 /**
  * Structural query-variable leaf. The query layer supplies a bound variable
@@ -74,46 +51,32 @@ interface ScalarQueryVar {
 
 type QueryVarLeaf = { readonly kind: "var"; readonly ref: ScalarQueryVar }
 
-type SourceFieldLeaf = { readonly kind: "field"; readonly name: string }
-
-type ScalarLeaf<S extends ScalarLeafScope> = S extends "query-var" ? QueryVarLeaf : SourceFieldLeaf
-
-type ScalarNodeBody<S extends ScalarLeafScope> =
-	| ScalarLeaf<S>
+type ScalarNodeBody =
+	| { readonly kind: "measure"; readonly expr: ScalarNode }
+	| {
+			readonly kind: "mulDiv"
+			readonly a: ScalarNode
+			readonly b: ScalarNode
+			readonly divisor: ScalarNode
+			readonly rounding: Rounding
+	  }
+	| QueryVarLeaf
 	| { readonly kind: "literal"; readonly value: ScalarLiteral }
-	| { readonly kind: "negate"; readonly expr: ScalarNode<S> }
-	| { readonly kind: "isNaN"; readonly expr: ScalarNode<S> }
-	| { readonly kind: "isFinite"; readonly expr: ScalarNode<S> }
-	| { readonly kind: "add"; readonly left: ScalarNode<S>; readonly right: ScalarNode<S> }
-	| { readonly kind: "subtract"; readonly left: ScalarNode<S>; readonly right: ScalarNode<S> }
-	| { readonly kind: "multiply"; readonly left: ScalarNode<S>; readonly right: ScalarNode<S> }
-	| { readonly kind: "divide"; readonly left: ScalarNode<S>; readonly right: ScalarNode<S> }
-	| { readonly kind: "cast"; readonly cast: NumericCast; readonly expr: ScalarNode<S> }
-
-/**
- * One authored node: roster arms plus cached `scope` / `result` / `depth`.
- * Summaries are construction metadata; lowering and L17 serialization read
- * the grammar arms and ignore the summaries.
- */
-type ScalarNode<
-	S extends ScalarLeafScope = ScalarLeafScope,
-	K extends ScalarResultKind = ScalarResultKind
-> = ScalarNodeBody<S> & {
-	readonly scope: S
+	| { readonly kind: "negate"; readonly expr: ScalarNode }
+	| { readonly kind: "isNaN"; readonly expr: ScalarNode }
+	| { readonly kind: "isFinite"; readonly expr: ScalarNode }
+	| { readonly kind: "add"; readonly left: ScalarNode; readonly right: ScalarNode }
+	| { readonly kind: "subtract"; readonly left: ScalarNode; readonly right: ScalarNode }
+	| { readonly kind: "multiply"; readonly left: ScalarNode; readonly right: ScalarNode }
+	| { readonly kind: "divide"; readonly left: ScalarNode; readonly right: ScalarNode }
+	| { readonly kind: "cast"; readonly cast: NumericCast; readonly expr: ScalarNode }
+
+/** Cached summaries never replace the expression grammar. */
+type ScalarNode<K extends ScalarResultKind = ScalarResultKind> = ScalarNodeBody & {
 	readonly result: K
 	readonly depth: number
 }
 
-/**
- * Migration authoring expression (source-field scope). `K` is the cached
- * result kind, not a host value type: I64 and U64 remain distinct even
- * though both use bigint in JavaScript.
- */
-type ScalarExpr<K extends ScalarResultKind = ScalarResultKind> = ScalarNode<"source-field", K>
-
-/** A migration field read: unresolved until native snapshot binding. */
-type ScalarFieldRef = ScalarNode<"source-field", "unresolved"> & SourceFieldLeaf
-
 const MAX_SCALAR_DEPTH = 128
 const U64_MAX = (1n << 64n) - 1n
 const I64_MIN = -(1n << 63n)
@@ -126,9 +89,10 @@ function scalarAuthoringWork(): number {
 	return authoringWork
 }
 
-function admit<
-	const Node extends { readonly scope: ScalarLeafScope; readonly result: ScalarResultKind; readonly depth: number }
->(where: string, node: Node): Readonly<Node> {
+function admit<const Node extends { readonly result: ScalarResultKind; readonly depth: number }>(
+	where: string,
+	node: Node
+): Readonly<Node> {
 	authoringWork += 1
 	assertDepth(where, node.depth)
 	return Object.freeze(node)
@@ -197,49 +161,28 @@ function assertDepth(where: string, depth: number): void {
 	}
 }
 
-function assertNumeric(where: string, kind: ScalarKind): void {
-	if (kind === "bool") {
+function assertNumeric(where: string, kind: ScalarInputKind): asserts kind is NumericKind {
+	if (kind !== "u64" && kind !== "i64" && kind !== "f64") {
 		throw new AuthoringError({ message: `${where}: the operand is bool, not numeric (u64/i64/f64)` })
 	}
 }
 
-function assertSameKind(where: string, left: ScalarKind, right: ScalarKind): ScalarKind {
+function assertSameKind(where: string, left: ScalarInputKind, right: ScalarInputKind): ScalarInputKind {
 	if (left !== right) {
 		throw new AuthoringError({
-			message: `${where}: operand kinds differ (${left} vs ${right}) — the engine has no mixed promotion; cast explicitly (Scalar.toF64/ toF64Exact/ toI64Exact/ toU64Exact)`
+			message: `${where}: operand kinds differ (${left} vs ${right}) — the engine has no mixed promotion; cast explicitly (Compute.toF64/ toF64Exact/ toI64Exact/ toU64Exact)`
 		})
 	}
 	return left
 }
 
-function assertScope<S extends ScalarLeafScope>(where: string, left: ScalarNode<S>, right: ScalarNode<S>): S {
-	if (left.scope !== right.scope) {
-		throw new AuthoringError({
-			message: `${where}: leaf scopes differ (${left.scope} vs ${right.scope}) — query-var and source-field trees do not mix`
-		})
-	}
-	return left.scope
-}
-
 function combineNumeric(where: string, left: ScalarResultKind, right: ScalarResultKind): ScalarResultKind {
-	if (left === "unresolved" || right === "unresolved") {
-		if (left !== "unresolved") {
-			assertNumeric(where, left)
-		}
-		if (right !== "unresolved") {
-			assertNumeric(where, right)
-		}
-		return "unresolved"
-	}
 	assertNumeric(where, left)
 	assertNumeric(where, right)
 	return assertSameKind(where, left, right)
 }
 
 function negateKind(where: string, inner: ScalarResultKind): ScalarResultKind {
-	if (inner === "unresolved") {
-		return "unresolved"
-	}
 	if (inner !== "i64" && inner !== "f64") {
 		throw new AuthoringError({
 			message: `${where}: the operand is ${inner} — negation is defined over i64 and f64 only`
@@ -249,137 +192,127 @@ function negateKind(where: string, inner: ScalarResultKind): ScalarResultKind {
 }
 
 function assertCastOperand(where: string, inner: ScalarResultKind): void {
-	if (inner === "unresolved") {
-		return
-	}
 	assertNumeric(where, inner)
 }
 
 function assertFloatOperand(where: string, inner: ScalarResultKind): void {
-	if (inner === "unresolved") {
-		return
-	}
 	if (inner !== "f64") {
 		throw new AuthoringError({ message: `${where}: the operand is ${inner} — the float predicates read f64` })
 	}
 }
 
 function isScalarNode(value: unknown): value is ScalarNode {
-	return (
-		typeof value === "object" &&
-		value !== null &&
-		"kind" in value &&
-		"scope" in value &&
-		"result" in value &&
-		"depth" in value
-	)
-}
-
-function isUnresolvedScalar(node: ScalarNode): boolean {
-	return node.result === "unresolved"
-}
-
-/** Source-field leaf — unresolved until L14 binds it against the verified snapshot. */
-function sourceField(name: string): ScalarFieldRef {
-	if (typeof name !== "string" || name.length === 0) {
-		throw new AuthoringError({ message: "scalar field(...) names a nonempty source field" })
-	}
-	return admit("Scalar.field", {
-		kind: "field",
-		name,
-		scope: "source-field",
-		result: "unresolved",
-		depth: 1
-	})
+	return typeof value === "object" && value !== null && "kind" in value && "result" in value && "depth" in value
 }
 
 /** Query-var leaf — kind is the variable's schema kind, already known. */
-function queryVarLeaf<K extends ScalarKind>(ref: ScalarQueryVar, kind: K): ScalarNode<"query-var", K> {
-	return admit("Scalar.queryVar", {
+function queryVarLeaf<K extends ScalarInputKind>(ref: ScalarQueryVar, kind: K): ScalarNode<K> {
+	return admit("Compute.variable", {
 		kind: "var",
 		ref,
-		scope: "query-var",
 		result: kind,
 		depth: 1
 	})
 }
 
-function scalarLiteral<S extends ScalarLeafScope>(scope: S, value: ScalarLiteral): ScalarNode<S, ScalarKind> {
+function scalarLiteral(value: ScalarLiteral): ScalarNode<ScalarKind> {
 	const kind = literalKindOf(value)
-	return admit("Scalar.literal", {
+	return admit("Compute.literal", {
 		kind: "literal",
 		value: literalValue(value),
-		scope,
 		result: kind,
 		depth: 1
-	}) as ScalarNode<S, ScalarKind>
+	}) as ScalarNode<ScalarKind>
 }
 
 type BinaryOp = "add" | "subtract" | "multiply" | "divide"
 
-function scalarBinary<S extends ScalarLeafScope>(
-	where: string,
-	op: BinaryOp,
-	left: ScalarNode<S>,
-	right: ScalarNode<S>
-): ScalarNode<S, ScalarResultKind> {
-	const scope = assertScope(where, left, right)
+function scalarBinary(where: string, op: BinaryOp, left: ScalarNode, right: ScalarNode): ScalarNode {
 	return admit(where, {
 		kind: op,
 		left,
 		right,
-		scope,
 		result: combineNumeric(where, left.result, right.result),
 		depth: Math.max(left.depth, right.depth) + 1
 	})
 }
 
-function scalarNegate<S extends ScalarLeafScope>(where: string, expr: ScalarNode<S>): ScalarNode<S, ScalarResultKind> {
+function roundingMode(value: unknown): Rounding {
+	if (value !== "towardZero" && value !== "nearestTiesAwayFromZero" && value !== "nearestTiesToEven")
+		throw new AuthoringError({ message: "unknown integer rounding mode" })
+	return value
+}
+
+function scalarMulDiv(
+	where: string,
+	a: ScalarNode,
+	b: ScalarNode,
+	divisor: ScalarNode,
+	rounding: Rounding
+): ScalarNode {
+	let known: "i64" | "u64" | undefined
+	for (const operand of [a, b, divisor]) {
+		if ((operand.result !== "i64" && operand.result !== "u64") || (known !== undefined && known !== operand.result))
+			throw new AuthoringError({ message: `${where}: operands must have one matching integer kind` })
+		known = operand.result
+	}
+	return admit(where, {
+		kind: "mulDiv",
+		a,
+		b,
+		divisor,
+		rounding: roundingMode(rounding),
+		result: a.result,
+		depth: Math.max(a.depth, b.depth, divisor.depth) + 1
+	})
+}
+
+function scalarMeasure(where: string, expr: ScalarNode): ScalarNode {
+	const kind = expr.result
+	if (kind !== "intervalU64" && kind !== "intervalI64" && kind !== "intervalF64")
+		throw new AuthoringError({ message: `${where}: measure requires an interval` })
+	return admit(where, {
+		kind: "measure",
+		expr,
+		result: ({ intervalF64: "f64", intervalI64: "u64", intervalU64: "u64" } as const)[kind],
+		depth: expr.depth + 1
+	})
+}
+
+function scalarNegate(where: string, expr: ScalarNode): ScalarNode {
 	return admit(where, {
 		kind: "negate",
 		expr,
-		scope: expr.scope,
 		result: negateKind(where, expr.result),
 		depth: expr.depth + 1
 	})
 }
 
-function scalarCast<S extends ScalarLeafScope>(
-	where: string,
-	cast: NumericCast,
-	result: ScalarKind,
-	expr: ScalarNode<S>
-): ScalarNode<S, ScalarKind> {
+function scalarCast(where: string, cast: NumericCast, result: ScalarKind, expr: ScalarNode): ScalarNode<ScalarKind> {
 	assertCastOperand(where, expr.result)
 	return admit(where, {
 		kind: "cast",
 		cast,
 		expr,
-		scope: expr.scope,
 		result,
 		depth: expr.depth + 1
 	})
 }
 
-function scalarFloatPredicate<S extends ScalarLeafScope>(
-	where: string,
-	op: "isNaN" | "isFinite",
-	expr: ScalarNode<S>
-): ScalarNode<S, "bool"> {
+function scalarFloatPredicate(where: string, op: "isNaN" | "isFinite", expr: ScalarNode): ScalarNode<"bool"> {
 	assertFloatOperand(where, expr.result)
 	return admit(where, {
 		kind: op,
 		expr,
-		scope: expr.scope,
 		result: "bool",
 		depth: expr.depth + 1
 	})
 }
 
 /** Query-var leaves collected once at find-binding time — not during construction. */
-function queryVarsOf(node: ScalarNode<"query-var">): readonly ScalarQueryVar[] {
+function queryVarsOf(node: ScalarNode): readonly ScalarQueryVar[] {
 	const vars: ScalarQueryVar[] = []
-	const pending: ScalarNode<"query-var">[] = [node]
+	const pending: ScalarNode[] = [node]
 	while (pending.length > 0) {
 		const next = pending.pop()
 		if (next === undefined) {
@@ -391,148 +324,66 @@ function queryVarsOf(node: ScalarNode<"query-var">): readonly ScalarQueryVar[] {
 				break
 			case "literal":
 				break
+			case "measure":
 			case "negate":
 			case "isNaN":
 			case "isFinite":
 			case "cast":
 				pending.push(next.expr)
 				break
+			case "mulDiv":
+				pending.push(next.a, next.b, next.divisor)
+				break
 			case "add":
 			case "subtract":
 			case "multiply":
 			case "divide":
 				pending.push(next.left, next.right)
 				break
-			default:
-				throw new AuthoringError({
-					message: "queryVarsOf: a query-var tree cannot carry a source-field leaf"
-				})
 		}
 	}
 	return vars
 }
 
-function field(name: string): ScalarFieldRef {
-	return sourceField(name)
-}
-
-function literal(value: ScalarLiteral): ScalarExpr<ScalarKind> {
-	return scalarLiteral("source-field", value)
-}
-
-function u64(value: bigint): ScalarExpr<"u64"> {
-	checkU64(value, "Scalar.u64")
-	return scalarLiteral("source-field", { u64: value }) as ScalarExpr<"u64">
-}
-
-function i64(value: bigint): ScalarExpr<"i64"> {
-	checkI64(value, "Scalar.i64")
-	return scalarLiteral("source-field", { i64: value }) as ScalarExpr<"i64">
-}
-
-function f64(value: number): ScalarExpr<"f64"> {
-	checkF64(value, "Scalar.f64")
-	return scalarLiteral("source-field", { f64: value }) as ScalarExpr<"f64">
-}
-
-function bool(value: boolean): ScalarExpr<"bool"> {
-	checkBool(value, "Scalar.bool")
-	return scalarLiteral("source-field", { bool: value }) as ScalarExpr<"bool">
-}
-
-function negate<K extends "i64" | "f64" | "unresolved">(expr: ScalarExpr<K>): ScalarExpr<K> {
-	return scalarNegate("Scalar.negate", expr) as ScalarExpr<K>
-}
-
-function add<L extends NumericOrUnresolved, R extends CombineNumeric<L, R> extends never ? never : NumericOrUnresolved>(
-	left: ScalarExpr<L>,
-	right: ScalarExpr<R>
-): ScalarExpr<CombineNumeric<L, R>> {
-	return scalarBinary("Scalar.add", "add", left, right) as ScalarExpr<CombineNumeric<L, R>>
-}
-
-function subtract<
-	L extends NumericOrUnresolved,
-	R extends CombineNumeric<L, R> extends never ? never : NumericOrUnresolved
->(left: ScalarExpr<L>, right: ScalarExpr<R>): ScalarExpr<CombineNumeric<L, R>> {
-	return scalarBinary("Scalar.subtract", "subtract", left, right) as ScalarExpr<CombineNumeric<L, R>>
-}
-
-function multiply<
-	L extends NumericOrUnresolved,
-	R extends CombineNumeric<L, R> extends never ? never : NumericOrUnresolved
->(left: ScalarExpr<L>, right: ScalarExpr<R>): ScalarExpr<CombineNumeric<L, R>> {
-	return scalarBinary("Scalar.multiply", "multiply", left, right) as ScalarExpr<CombineNumeric<L, R>>
-}
-
-function divide<
-	L extends NumericOrUnresolved,
-	R extends CombineNumeric<L, R> extends never ? never : NumericOrUnresolved
->(left: ScalarExpr<L>, right: ScalarExpr<R>): ScalarExpr<CombineNumeric<L, R>> {
-	return scalarBinary("Scalar.divide", "divide", left, right) as ScalarExpr<CombineNumeric<L, R>>
-}
-
-function toF64(expr: ScalarExpr<NumericOrUnresolved>): ScalarExpr<"f64"> {
-	return scalarCast("Scalar.toF64", "toF64", "f64", expr) as ScalarExpr<"f64">
-}
-
-function toF64Exact(expr: ScalarExpr<NumericOrUnresolved>): ScalarExpr<"f64"> {
-	return scalarCast("Scalar.toF64Exact", "toF64Exact", "f64", expr) as ScalarExpr<"f64">
-}
-
-function toI64Exact(expr: ScalarExpr<NumericOrUnresolved>): ScalarExpr<"i64"> {
-	return scalarCast("Scalar.toI64Exact", "toI64Exact", "i64", expr) as ScalarExpr<"i64">
-}
-
-function toU64Exact(expr: ScalarExpr<NumericOrUnresolved>): ScalarExpr<"u64"> {
-	return scalarCast("Scalar.toU64Exact", "toU64Exact", "u64", expr) as ScalarExpr<"u64">
-}
-
-function isNaNExpr(expr: ScalarExpr<"f64" | "unresolved">): ScalarExpr<"bool"> {
-	return scalarFloatPredicate("Scalar.isNaN", "isNaN", expr)
-}
-
-function isFiniteExpr(expr: ScalarExpr<"f64" | "unresolved">): ScalarExpr<"bool"> {
-	return scalarFloatPredicate("Scalar.isFinite", "isFinite", expr)
+/** Lower each query variable through its existing binding. */
+function scalarWire(node: ScalarNode, leaf: (node: QueryVarLeaf) => number): ScalarExprIr {
+	const walk = (expr: ScalarNode): ScalarExprIr => scalarWire(expr, leaf)
+	switch (node.kind) {
+		case "var":
+			return { kind: "var", var: leaf(node) }
+		case "literal":
+			return { kind: "literal", value: literalWireOf(node.value) }
+		case "measure":
+		case "negate":
+		case "isNaN":
+		case "isFinite":
+			return { kind: node.kind, expr: walk(node.expr) }
+		case "cast":
+			return { kind: node.kind, cast: node.cast, expr: walk(node.expr) }
+		case "mulDiv":
+			return { kind: node.kind, a: walk(node.a), b: walk(node.b), divisor: walk(node.divisor), rounding: node.rounding }
+		case "add":
+		case "subtract":
+		case "multiply":
+		case "divide":
+			return { kind: node.kind, left: walk(node.left), right: walk(node.right) }
+	}
 }
 
-/** The authoring namespace: `Scalar.field("units")`, `Scalar.add(...)`. */
-const Scalar = Object.freeze({
-	field,
-	literal,
-	u64,
-	i64,
-	f64,
-	bool,
-	negate,
-	add,
-	subtract,
-	multiply,
-	divide,
-	toF64,
-	toF64Exact,
-	toI64Exact,
-	toU64Exact,
-	isNaN: isNaNExpr,
-	isFinite: isFiniteExpr
-})
-
 export type {
-	CombineNumeric,
+	IntervalKind,
 	NumericCast,
 	NumericKind,
-	NumericOrUnresolved,
 	QueryVarLeaf,
-	ScalarExpr,
-	ScalarFieldRef,
+	Rounding,
+	ScalarInputKind,
 	ScalarKind,
 	ScalarLiteral,
 	ScalarNode,
 	ScalarOpKind,
 	ScalarQueryVar,
 	ScalarResultKind,
-	ScalarValue,
-	SourceFieldLeaf
+	ScalarValue
 }
 export {
 	assertDepth,
@@ -543,18 +394,20 @@ export {
 	checkI64,
 	checkU64,
 	isScalarNode,
-	isUnresolvedScalar,
 	literalKindOf,
 	literalValue,
 	literalWireOf,
 	MAX_SCALAR_DEPTH,
 	queryVarLeaf,
 	queryVarsOf,
-	Scalar,
+	roundingMode,
 	scalarAuthoringWork,
 	scalarBinary,
 	scalarCast,
 	scalarFloatPredicate,
 	scalarLiteral,
-	scalarNegate
+	scalarMeasure,
+	scalarMulDiv,
+	scalarNegate,
+	scalarWire
 }

package/src/schema-file.ts

@@ -0,0 +1,38 @@
+import { Effect } from "effect"
+import { dbNative } from "#db-native.ts"
+import { nativeOperationWith, runtimeHandle } from "#runtime.ts"
+import { DbError, dbError } from "#runtime-errors.ts"
+import type { SchemaSpec } from "#spec.ts"
+
+const decoder = new TextDecoder("utf-8", { fatal: true })
+
+function text(operation: string, bytes: Uint8Array | null): string {
+	if (bytes === null) throw dbError(operation, { _tag: "Internal" })
+	return decoder.decode(bytes)
+}
+
+const internalSchemaSnapshot = Effect.fn("internalSchemaSnapshot")(function* (spec: SchemaSpec) {
+	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: string) {
+	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 }

package/dist/migration.d.ts

@@ -1,31 +0,0 @@
-/**
- * Private log-migration integration entrypoints: the two read-only
- * native migration-codec verbs the `@bjornpagen/bumbledb-log/migrations`
- * generator imports, wired over the shared executor onto the native
- * `schema_file`, `migration::plan` and `migration::manifest` modules.
- *
- * Both follow `hashChunk`'s shape: bounded owned input, bounded owned JSON
- * response bytes, ONE registered cancellable operation under the acquired
- * `NativeRuntime`. The schema verb takes the SDK `SchemaSpec` object — the
- * same wire that already crosses the bridge for open/create — never a
- * respelled text form. Neither verb opens, initializes, freezes or migrates
- * a database; the durable migrate/activate/abort workflow is the log's
- * admin surface, not this seam.
- */
-import { Effect } from "effect";
-import { DbError } from "./runtime-errors.js";
-import type { SchemaSpec } from "./spec.js";
-/**
- * Canonical schema admission for the migration generator: validates the
- * spec natively and yields bounded JSON bytes carrying the canonical
- * `schemaId` and the rendered schema snapshot.
- */
-declare const internalMigrationSchema: (spec: SchemaSpec) => Effect.Effect<Uint8Array<ArrayBufferLike>, DbError, import("./runtime.js").NativeRuntime>;
-/**
- * One bounded read-only migration-codec request (plan parse/validate/
- * render/digest, manifest verify/append preview, plan-set digests): owned
- * JSON request bytes in, owned JSON response bytes out.
- */
-declare const internalMigrationRead: (request: Uint8Array<ArrayBufferLike>) => Effect.Effect<Uint8Array<ArrayBufferLike>, DbError, import("./runtime.js").NativeRuntime>;
-export { internalMigrationRead, internalMigrationSchema };
-//# sourceMappingURL=migration.d.ts.map