@bjornpagen/bumbledb 0.20.2 → 1.0.0

package/src/query/parse-ir.ts

@@ -1,9 +1,9 @@
-import * as errors from "@superbuilders/errors"
+import { AuthoringError } from "#errors.ts"
 import type { FindTermIr, HeadTermIr, ParsedQuery, QueryIr, RuleIr } from "#native.ts"
 
 function parseQueryIr(ir: QueryIr): ParsedQuery {
 	if (ir.rules.length === 0) {
-		throw errors.new("parseQueryIr: main rules are empty")
+		throw new AuthoringError({ message: "parseQueryIr: main rules are empty" })
 	}
 	align("query", ir.head, ir.rules)
 	ir.interiors.forEach(function checkInterior(interior, index) {
@@ -11,10 +11,10 @@ function parseQueryIr(ir: QueryIr): ParsedQuery {
 	})
 	if (ir.kind === "reach") {
 		if (ir.rec.base.length === 0) {
-			throw errors.new("parseQueryIr: rec base is empty")
+			throw new AuthoringError({ message: "parseQueryIr: rec base is empty" })
 		}
 		if (ir.rec.rec.length === 0) {
-			throw errors.new("parseQueryIr: rec step is empty")
+			throw new AuthoringError({ message: "parseQueryIr: rec step is empty" })
 		}
 		align("rec base", ir.rec.head, ir.rec.base)
 		align("rec step", ir.rec.head, ir.rec.rec)
@@ -25,17 +25,17 @@ function parseQueryIr(ir: QueryIr): ParsedQuery {
 function align(context: string, head: readonly HeadTermIr[], rules: readonly RuleIr[]): void {
 	for (const [ruleIndex, rule] of rules.entries()) {
 		if (rule.finds.length !== head.length) {
-			throw errors.new(
-				`${context}: rule ${ruleIndex} finds width ${rule.finds.length} does not match head width ${head.length}`
-			)
+			throw new AuthoringError({
+				message: `${context}: rule ${ruleIndex} finds width ${rule.finds.length} does not match head width ${head.length}`
+			})
 		}
 		rule.finds.forEach(function checkFind(find, position) {
 			parseFind(`${context} rule ${ruleIndex} find ${position}`, find)
 			const family = findFamily(find)
 			if (family !== head[position]?.kind) {
-				throw errors.new(
-					`${context}: rule ${ruleIndex} find ${position} is ${family}, not head ${head[position]?.kind}`
-				)
+				throw new AuthoringError({
+					message: `${context}: rule ${ruleIndex} find ${position} is ${family}, not head ${head[position]?.kind}`
+				})
 			}
 		})
 	}
@@ -45,21 +45,26 @@ function parseFind(context: string, find: FindTermIr): void {
 	const raw = find as Record<string, unknown>
 	if (find.kind === "count") {
 		if ("over" in raw) {
-			throw errors.new(`${context}: Count carries no over`)
+			throw new AuthoringError({ message: `${context}: Count carries no over` })
 		}
 		return
 	}
 	if (find.kind === "pack" || find.kind === "aggregate") {
 		if (!("over" in raw)) {
-			throw errors.new(`${context}: ${find.kind} requires over`)
+			throw new AuthoringError({ message: `${context}: ${find.kind} requires over` })
 		}
 	}
+	if (find.kind === "compute" && !("expr" in raw)) {
+		throw new AuthoringError({ message: `${context}: compute requires expr` })
+	}
 }
 
-function findFamily(find: FindTermIr): "var" | "aggregate" {
+function findFamily(find: FindTermIr): "var" | "aggregate" | "compute" {
 	switch (find.kind) {
 		case "var":
 			return "var"
+		case "compute":
+			return "compute"
 		case "count":
 		case "pack":
 		case "aggregate":

package/src/query/run.ts

@@ -1,15 +1,16 @@
-import * as errors from "@superbuilders/errors"
-import { handleOf } from "#marshal.ts"
-import type { FactValue, QueryParam, TaggedValue } from "#native.ts"
+import { AuthoringError, SdkInvariantError } from "#errors.ts"
+import type { QueryParam, TaggedValue } from "#native.ts"
 import type { FindColumn } from "#query/atom.ts"
 import { taggedCmpLiteral } from "#query/lower.ts"
 import type { ParamEntry } from "#query/scope.ts"
+import type { CellValue } from "#rows.ts"
+import { decodeCell, handleOf } from "#rows.ts"
 
 function wireValue(entry: ParamEntry, context: string, value: unknown): TaggedValue {
 	if (entry.anchor === undefined) {
-		throw errors.new(
-			`param ${entry.name} has no field-anchored use — bind it in an atom or compare it against a bound variable`
-		)
+		throw new AuthoringError({
+			message: `param ${entry.name} has no field-anchored use — bind it in an atom or compare it against a bound variable`
+		})
 	}
 	return taggedCmpLiteral(context, entry.anchor, value, entry.op)
 }
@@ -21,11 +22,11 @@ function wireParams(entries: readonly ParamEntry[], supplied: Readonly<Record<st
 		}
 		const value = supplied[entry.name]
 		if (value === undefined) {
-			throw errors.new(`execute params object is missing param ${entry.name}`)
+			throw new AuthoringError({ message: `execute params object is missing param ${entry.name}` })
 		}
 		if (entry.shape === "set") {
 			if (!Array.isArray(value)) {
-				throw errors.new(`param ${entry.name}: a set param binds a readonly array of values`)
+				throw new AuthoringError({ message: `param ${entry.name}: a set param binds a readonly array of values` })
 			}
 			return {
 				kind: "set",
@@ -40,30 +41,45 @@ function wireParams(entries: readonly ParamEntry[], supplied: Readonly<Record<st
 
 function isAnswerRow<Row>(
 	finds: readonly FindColumn[],
-	decoded: Readonly<Record<string, FactValue>>
-): decoded is Readonly<Record<string, FactValue>> & Row {
+	decoded: Readonly<Record<string, unknown>>
+): decoded is Readonly<Record<string, unknown>> & Row {
 	return finds.every(function present(column) {
 		return decoded[column.name] !== undefined
 	})
 }
 
-function decodeAnswers<Row>(finds: readonly FindColumn[], rows: FactValue[][]): Row[] {
+/**
+ * The one answer-row decoder: owned positional cells into a plain frozen
+ * record keyed by the find columns — the SAME fields and shapes across
+ * every row and page (stable row shape). A column carrying its mint slot
+ * decodes through the full value roster (uuid bytes lift to canonical
+ * hex, closed ids lift to handle names, float intervals stay owned plain
+ * objects); an aggregate column without a slot passes the engine's owned
+ * scalar through, with the closed lift when the column is closed-typed.
+ */
+function decodeAnswers<Row>(finds: readonly FindColumn[], rows: readonly (readonly CellValue[])[]): Row[] {
 	return rows.map(function decodeRow(row) {
 		if (row.length !== finds.length) {
-			throw errors.new(`query answer arity ${row.length} does not match the ${finds.length} find columns`)
+			throw new SdkInvariantError({
+				message: `query answer arity ${row.length} does not match the ${finds.length} find columns`
+			})
 		}
-		const decoded: Record<string, FactValue> = {}
-		finds.forEach(function decodeCell(column, ordinal) {
+		const decoded: Record<string, unknown> = {}
+		finds.forEach(function decodeColumn(column, ordinal) {
 			const cell = row[ordinal]
 			if (cell === undefined) {
-				throw errors.new(`query answer cell ${ordinal} (${column.name}) is absent`)
+				throw new SdkInvariantError({ message: `query answer cell ${ordinal} (${column.name}) is absent` })
+			}
+			if (column.slot !== undefined) {
+				decoded[column.name] = decodeCell(`query answer column ${column.name}`, column.slot.field, cell)
+				return
 			}
 			decoded[column.name] =
 				column.closed === undefined ? cell : handleOf(`query answer column ${column.name}`, column.closed, cell)
 		})
 		Object.freeze(decoded)
 		if (!isAnswerRow<Row>(finds, decoded)) {
-			throw errors.new("query answer row is not a complete find record")
+			throw new SdkInvariantError({ message: "query answer row is not a complete find record" })
 		}
 		return decoded
 	})

package/src/query/scope.ts

@@ -1,11 +1,12 @@
-import * as errors from "@superbuilders/errors"
 import type { AnyClosed } from "#closed.ts"
 import { sealedFieldsOf } from "#closed.ts"
+import { AuthoringError, SdkInvariantError } from "#errors.ts"
 import type { AnyField, Infer, SignatureOf } from "#fields.ts"
 import { rosterOf, signaturesAgree } from "#fields.ts"
 import type { Same, SameLen } from "#judgment.ts"
 import type { ClassLookup, ClassRecordOf, SchemaClasses } from "#law.ts"
 import type { QueryParam } from "#native.ts"
+import type { FindColumn } from "#query/atom.ts"
 import type { AnyRelation, RelationFields } from "#relation.ts"
 
 const term: unique symbol = Symbol("bumbledb.query.term")
@@ -94,21 +95,136 @@ function varsMinted<R extends MatchOwner>(owner: R, record: Readonly<Record<stri
  * what you need (`const { id, holder } = v(Account)`) and reuse a value
  * across binding positions to join.
  */
-function v<R extends MatchOwner>(owner: R): VarsOf<R> {
+/**
+ * A schema-bound query template used as a relation-expression source
+ * (chapter 34's nonrecursive composition): structurally, the query value's
+ * own frozen data. Detection is structural so `scope.ts` needs no runtime
+ * import of the query module.
+ */
+interface ImportedSource {
+	readonly schema: object
+	readonly data: {
+		readonly kind: "cq" | "reach"
+		readonly finds: readonly FindColumn[]
+	}
+}
+
+function isImportedSource(value: unknown): value is ImportedSource {
+	if (typeof value !== "object" || value === null || !("data" in value) || !("schema" in value)) {
+		return false
+	}
+	const data = (value as { readonly data: unknown }).data
+	return (
+		typeof data === "object" &&
+		data !== null &&
+		"kind" in data &&
+		((data as { readonly kind: unknown }).kind === "cq" || (data as { readonly kind: unknown }).kind === "reach") &&
+		"finds" in data
+	)
+}
+
+type RowOfImport<Q> = InferredOf<Q> extends { readonly row: infer R } ? R : never
+
+type ImportVars<Q> = [RowOfImport<Q>] extends [never]
+	? Readonly<Record<string, Var<AnyField, string, string>>>
+	: { readonly [K in keyof RowOfImport<Q> & string]: Var<AnyField, string, K> }
+
+interface ImportFacade {
+	/** The pseudo-owner every import var carries (structurally an owner). */
+	readonly owner: MatchOwner & { readonly name: string }
+	readonly source: ImportedSource
+	/** Column name → the imported head column (field + carrier class). */
+	readonly columns: ReadonlyMap<string, FindColumn>
+}
+
+const facadeBySource = new WeakMap<object, ImportFacade>()
+const facadeByOwner = new WeakMap<object, ImportFacade>()
+
+let importOrdinal = 0
+
+const importLabels = new WeakMap<object, string>()
+
+/** `.named(label)` registration — a diagnostic name, never a schema relation. */
+function labelImport(source: object, label: string): void {
+	importLabels.set(source, label)
+}
+
+function importFacadeOf(source: ImportedSource): ImportFacade {
+	const cached = facadeBySource.get(source)
+	if (cached !== undefined) {
+		return cached
+	}
+	importOrdinal += 1
+	const name = importLabels.get(source) ?? `\u0000import:${importOrdinal}`
+	const columns = new Map<string, FindColumn>()
+	const fields: Array<{ readonly name: string; readonly field: AnyField }> = []
+	for (const column of source.data.finds) {
+		if (column.slot === undefined) {
+			throw new AuthoringError({
+				message: `v(query): the imported head column ${column.name} carries no descriptor — the imported query is not a mintable relation expression`
+			})
+		}
+		columns.set(column.name, column)
+		fields.push(Object.freeze({ name: column.name, field: column.slot.field }))
+	}
+	const data = Object.freeze({ name, fields: Object.freeze(fields) })
+	const owner = Object.freeze({
+		name,
+		data,
+		where(): never {
+			throw new AuthoringError({
+				message: `imported query ${name}: an imported relation expression takes no selection — filter through where() in the consuming rule`
+			})
+		}
+	}) as unknown as MatchOwner & { readonly name: string }
+	const facade: ImportFacade = Object.freeze({ owner, source, columns })
+	facadeBySource.set(source, facade)
+	facadeByOwner.set(owner, facade)
+	return facade
+}
+
+/** The import awareness the lowering's mint judgment reads. */
+function importFacadeOfOwner(owner: object): ImportFacade | undefined {
+	return facadeByOwner.get(owner)
+}
+
+function v<R extends MatchOwner>(owner: R): VarsOf<R>
+function v<Q extends ImportedSource>(imported: Q): ImportVars<Q>
+function v(owner: MatchOwner | ImportedSource): Readonly<Record<string, AnyVar>> {
+	if (isImportedSource(owner) && !("name" in owner)) {
+		const facade = importFacadeOf(owner)
+		const record: Record<string, AnyVar> = {}
+		for (const [columnName, column] of facade.columns) {
+			const slot = column.slot
+			if (slot === undefined) {
+				throw new SdkInvariantError({ message: `v(query): facade column ${columnName} lost its slot` })
+			}
+			const variable: AnyVar = Object.freeze({
+				[term]: "var" as const,
+				owner: facade.owner,
+				column: columnName,
+				field: slot.field,
+				label: `${facade.owner.name}.${columnName}`
+			})
+			Object.defineProperty(record, columnName, { value: variable, enumerable: true })
+		}
+		return Object.freeze(record)
+	}
+	const member = owner as MatchOwner
 	const record: Record<string, AnyVar> = {}
-	for (const declared of sealedFieldsOf(owner)) {
+	for (const declared of sealedFieldsOf(member)) {
 		const variable: AnyVar = Object.freeze({
 			[term]: "var" as const,
-			owner,
+			owner: member,
 			column: declared.name,
 			field: declared.field,
-			label: `${owner.name}.${declared.name}`
+			label: `${member.name}.${declared.name}`
 		})
 		Object.defineProperty(record, declared.name, { value: variable, enumerable: true })
 	}
 	Object.freeze(record)
-	if (!varsMinted(owner, record)) {
-		throw errors.new(`v(${owner.name}): variable-record minting incomplete`)
+	if (!varsMinted(member, record)) {
+		throw new SdkInvariantError({ message: `v(${member.name}): variable-record minting incomplete` })
 	}
 	return record
 }
@@ -155,7 +271,17 @@ type ShapeOf<U> = [U] extends [never] ? Record<never, never> : Flatten<UnionToIn
  */
 type SlotSignature<S extends ClassedField> = readonly [SignatureOf<S["field"]>, S["class"]]
 
-type JoinOk<A extends ClassedField, B extends ClassedField> = Same<SlotSignature<A>, SlotSignature<B>>
+/**
+ * A widened slot — a variable minted from an imported query template (its
+ * facade columns carry `AnyField`) or fully generic code — cannot be judged
+ * at the type tier. The degradation law applies: best effort degrades to
+ * SILENT, never to a wrong refusal; the runtime join judgment (real
+ * descriptors off the imported head's slots) stays authoritative.
+ */
+type WidenedSlot<S extends ClassedField> = [AnyField] extends [S["field"]] ? true : false
+
+type JoinOk<A extends ClassedField, B extends ClassedField> =
+	WidenedSlot<A> extends true ? true : WidenedSlot<B> extends true ? true : Same<SlotSignature<A>, SlotSignature<B>>
 
 type U64Wire<F extends AnyField> = F extends { readonly kind: "u64" }
 	? F extends { readonly closed: unknown }
@@ -272,6 +398,8 @@ export type {
 	ClassedField,
 	ExactVars,
 	Flatten,
+	ImportedSource,
+	ImportVars,
 	InferredOf,
 	JoinOk,
 	MatchFields,
@@ -290,8 +418,12 @@ export {
 	fieldAntiJoins,
 	fieldJoins,
 	headFieldJoins,
+	importFacadeOf,
+	importFacadeOfOwner,
 	inferred,
+	isImportedSource,
 	isTerm,
+	labelImport,
 	makeParam,
 	makeSetParam,
 	renderFieldKind,

package/src/relation.ts

@@ -1,3 +1,4 @@
+import { AuthoringError } from "#errors.ts"
 /**
  * `relation` — the ordinary-relation half of the theory's signature. A
  * relation value is a frozen plain object carrying its name, its ordered
@@ -8,31 +9,31 @@
  * NAME everywhere — statements (`on(R, "holder")`), selections, and match
  * records all spell the field's own name, checked by type
  * (`FaceFields`/`MatchShape`). `Fact<>` is the inferred row object type
- * at BARE structural value types (no brands): every field is present,
- * including fresh cells. Mint with `tx.reserve` before insert.
+ * at BARE structural value types: every field is present. Identities are
+ * ordinary application-owned values (`Uuid`); the database mints none.
  */
 
-import * as errors from "@superbuilders/errors"
 import { type AnyField, assertDeclarationOrderKey, assertDeclarationRecord, type Infer, literalOf } from "#fields.ts"
 import { type LiteralSetSpec, type LiteralSpec, renderLiteral } from "#spec.ts"
 
 function resolveEntry(context: string, field: AnyField, entry: unknown): LiteralSetSpec {
 	if (Array.isArray(entry)) {
 		if (entry.length < 2) {
-			throw errors.new(
-				entry.length === 0
-					? `${context}: an empty literal set selects nothing — write the selection you mean`
-					: `${context}: a one-element literal set is the bare literal respelled — write the literal (the canonical-utterance law: one meaning, one spelling)`
-			)
+			throw new AuthoringError({
+				message:
+					entry.length === 0
+						? `${context}: an empty literal set selects nothing — write the selection you mean`
+						: `${context}: a one-element literal set is the bare literal respelled — write the literal (the canonical-utterance law: one meaning, one spelling)`
+			})
 		}
 		const seen = new Set<string>()
 		const literals: LiteralSpec[] = entry.map(function lowerSetLiteral(literal: unknown) {
 			const lowered = Object.freeze(literalOf(field, literal))
 			const rendered = renderLiteral(lowered)
 			if (seen.has(rendered)) {
-				throw errors.new(
-					`${context}: the literal set spells ${rendered} twice — write it once (the canonical-utterance law: one meaning, one spelling)`
-				)
+				throw new AuthoringError({
+					message: `${context}: the literal set spells ${rendered} twice — write it once (the canonical-utterance law: one meaning, one spelling)`
+				})
 			}
 			seen.add(rendered)
 			return lowered
@@ -56,16 +57,16 @@ function resolveSelection(
 			return candidate.name === fieldName
 		})
 		if (declared === undefined) {
-			throw errors.new(`relation ${name} has no field ${fieldName}`)
+			throw new AuthoringError({ message: `relation ${name} has no field ${fieldName}` })
 		}
 		bindings.push(
 			Object.freeze({ field: fieldName, set: resolveEntry(`relation ${name}.${fieldName}`, declared.field, entry) })
 		)
 	}
 	if (bindings.length === 0) {
-		throw errors.new(
-			`relation ${name}: an empty selection is the bare relation respelled — pass the relation itself (the canonical-utterance law: one meaning, one spelling)`
-		)
+		throw new AuthoringError({
+			message: `relation ${name}: an empty selection is the bare relation respelled — pass the relation itself (the canonical-utterance law: one meaning, one spelling)`
+		})
 	}
 	return Object.freeze(bindings)
 }
@@ -115,10 +116,6 @@ type Fact<R extends AnyRelation> = {
 	[K in keyof RelationFields<R>]: Infer<RelationFields<R>[K]>
 }
 
-type FreshKeys<R extends AnyRelation> = {
-	[K in keyof RelationFields<R>]: RelationFields<R>[K] extends { readonly fresh: true } ? K : never
-}[keyof RelationFields<R>]
-
 function relation<const Name extends string, Fields extends FieldsShape>(
 	name: Name,
 	fields: Fields
@@ -135,7 +132,7 @@ function relation<const Name extends string, Fields extends FieldsShape>(
 	function where(selection: SelectionInput<Fields>): Selected<Name, Fields> {
 		const owner = holder.value
 		if (owner === undefined) {
-			throw errors.new(`relation ${name}: self-reference read before construction completed`)
+			throw new AuthoringError({ message: `relation ${name}: self-reference read before construction completed` })
 		}
 		return Object.freeze({
 			relation: owner,
@@ -152,7 +149,6 @@ export type {
 	AnySelected,
 	Fact,
 	FieldsShape,
-	FreshKeys,
 	Relation,
 	RelationData,
 	RelationField,

package/src/result.ts

@@ -0,0 +1,130 @@
+import { Effect, Option, Stream } from "effect"
+import { drainClose, releaseOwner } from "#close.ts"
+import type { CursorHandle, ResultHandle } from "#db-native.ts"
+import { dbNative } from "#db-native.ts"
+import type { FindColumn } from "#query/atom.ts"
+import { decodeAnswers } from "#query/run.ts"
+import type { CellValue } from "#rows.ts"
+import type { ExecutionPolicy } from "#runtime.ts"
+import { deliveryResultBytes, nativeOperationWith, policyWire } from "#runtime.ts"
+import type { CloseReport, DbError } from "#runtime-errors.ts"
+
+/**
+ * `CompleteResult<A>` — the sealed owner of one COMPLETED query answer
+ * (C05): published only after all evaluation/finalization succeeded,
+ * possibly backed by temporary LMDB scratch. Owned and independent of its
+ * source snapshot/session.
+ *
+ * `collect` materializes a bounded owned array and leaves the result
+ * available; it refuses (`ResourceLimit`) before allocating past
+ * `maxBytes`, and a cap failure leaves the sealed backing available for
+ * `pages`. `pages` is chapter 35's ONE-SHOT consuming stream over the
+ * completed result: its first execution atomically spends the result and
+ * moves the backing storage into a private cursor owned by the stream's
+ * scope — construction alone spends nothing, a second run fails
+ * `SpentHandle`, and a run after the result's scope closed fails
+ * `ClosedHandle`. Early take, downstream failure and interruption all
+ * close/drain the private cursor; EOF cleanup is identical. There is no
+ * public cursor, `next`, AsyncIterable, clone or second streaming API.
+ */
+interface CompleteResult<A> {
+	collect(options: { readonly maxBytes: bigint }, work: ExecutionPolicy): Effect.Effect<ReadonlyArray<A>, DbError>
+	pages(options: { readonly pageBytes: bigint }, work: ExecutionPolicy): Stream.Stream<ReadonlyArray<A>, DbError>
+	close(): Effect.Effect<CloseReport>
+}
+
+interface ResultInternal {
+	readonly handle: ResultHandle
+}
+
+const resultInternals = new WeakMap<object, ResultInternal>()
+
+/** Private cross-module accessor (scope finalizers in db.ts reach the handle). */
+function internalResult(value: object): ResultInternal | undefined {
+	return resultInternals.get(value)
+}
+
+function decodePage<A>(finds: readonly FindColumn[], rows: readonly (readonly CellValue[])[]): ReadonlyArray<A> {
+	// Owned ordinary records in declared column order — the same fields and
+	// shapes on every page (stable row shape; no Proxy, no per-row fiber).
+	return Object.freeze(decodeAnswers<A>(finds, rows))
+}
+
+/**
+ * Internal constructor: `db.ts` publishes results through this after
+ * execution completes. Delivery (`collect`/`pages`) starts a fresh bounded
+ * operation under the caller's delivery policy — never the completed query's
+ * expired execution deadline.
+ */
+function makeCompleteResult<A>(handle: ResultHandle, finds: readonly FindColumn[]): CompleteResult<A> {
+	function deliveryWire(operation: string, delivery: ExecutionPolicy, requested: bigint) {
+		return policyWire({ ...delivery, resultBytes: deliveryResultBytes(requested, delivery) }, operation)
+	}
+	const value: CompleteResult<A> = {
+		collect(options, work) {
+			return Effect.suspend(() =>
+				nativeOperationWith(
+					"CompleteResult.collect",
+					(callback) =>
+						dbNative.runtimeResultCollect(
+							handle,
+							deliveryWire("CompleteResult.collect", work, options.maxBytes),
+							callback
+						),
+					dbNative.runtimeRowsTake,
+					(rows) => decodePage<A>(finds, rows)
+				)
+			)
+		},
+		pages(options, work) {
+			return Stream.unwrap(
+				Effect.gen(function* () {
+					const cursor: CursorHandle = yield* Effect.acquireRelease(
+						nativeOperationWith(
+							"CompleteResult.pages",
+							(callback) =>
+								dbNative.runtimeResultCursor(
+									handle,
+									deliveryWire("CompleteResult.pages", work, options.pageBytes),
+									callback
+								),
+							dbNative.runtimeCursorTake,
+							(taken) => taken
+						),
+						(taken) => releaseOwner("ResultCursor.close", (callback) => dbNative.runtimeCursorClose(taken, callback)),
+						{ interruptible: true }
+					)
+					return Stream.paginate(undefined, () =>
+						nativeOperationWith(
+							"CompleteResult.page",
+							(callback) =>
+								dbNative.runtimeCursorNext(
+									cursor,
+									deliveryWire("CompleteResult.page", work, options.pageBytes),
+									callback
+								),
+							dbNative.runtimePageTake,
+							(page) => page
+						).pipe(
+							Effect.map((page) => {
+								if (page === null) {
+									return [[], Option.none<undefined>()] as const
+								}
+								return [[decodePage<A>(finds, page)], Option.some(undefined)] as const
+							})
+						)
+					)
+				})
+			)
+		},
+		close() {
+			return drainClose("CompleteResult.close", (callback) => dbNative.runtimeResultClose(handle, callback))
+		}
+	}
+	Object.freeze(value)
+	resultInternals.set(value, { handle })
+	return value
+}
+
+export type { CompleteResult }
+export { internalResult, makeCompleteResult }