@bjornpagen/bumbledb 1.0.1 → 1.1.0

package/src/result.ts

@@ -5,31 +5,22 @@ 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 { nativeOperationWith } from "#runtime.ts"
 import type { CloseReport, DbError } from "#runtime-errors.ts"
 
 /**
- * `CompleteResult<A>` — the sealed owner of one completed query answer:
- * published only after all evaluation/finalization succeeded,
- * possibly backed by temporary LMDB scratch. Owned and independent of its
- * source snapshot/session.
+ * One complete answer set, sealed after evaluation and independent of its
+ * source snapshot. collect() explicitly materializes all rows into JS and
+ * leaves the result available. pages() consumes it once through bounded
+ * delivery batches; it does not stream query execution.
  *
- * `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 a 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.
+ * The stream owns its cursor through Effect scope. Early termination,
+ * failure, interruption and EOF close/drain it. Creating the stream does
+ * not spend the result; running it twice fails with SpentHandle.
  */
 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>
+	collect(): Effect.Effect<ReadonlyArray<A>, DbError>
+	pages(): Stream.Stream<ReadonlyArray<A>, DbError>
 	close(): Effect.Effect<CloseReport>
 }
 
@@ -52,42 +43,27 @@ function decodePage<A>(finds: readonly FindColumn[], rows: readonly (readonly Ce
 
 /**
  * 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.
+ * execution completes. Each delivery has independent cooperative cancellation.
  */
 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) {
+		collect() {
 			return Effect.suspend(() =>
 				nativeOperationWith(
 					"CompleteResult.collect",
-					(callback) =>
-						dbNative.runtimeResultCollect(
-							handle,
-							deliveryWire("CompleteResult.collect", work, options.maxBytes),
-							callback
-						),
+					(callback) => dbNative.runtimeResultCollect(handle, callback),
 					dbNative.runtimeRowsTake,
 					(rows) => decodePage<A>(finds, rows)
 				)
 			)
 		},
-		pages(options, work) {
+		pages() {
 			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
-								),
+							(callback) => dbNative.runtimeResultCursor(handle, callback),
 							dbNative.runtimeCursorTake,
 							(taken) => taken
 						),
@@ -97,12 +73,7 @@ function makeCompleteResult<A>(handle: ResultHandle, finds: readonly FindColumn[
 					return Stream.paginate(undefined, () =>
 						nativeOperationWith(
 							"CompleteResult.page",
-							(callback) =>
-								dbNative.runtimeCursorNext(
-									cursor,
-									deliveryWire("CompleteResult.page", work, options.pageBytes),
-									callback
-								),
+							(callback) => dbNative.runtimeCursorNext(cursor, callback),
 							dbNative.runtimePageTake,
 							(page) => page
 						).pipe(

package/src/rows.ts

@@ -21,9 +21,6 @@ import { isFloatIntervalValue, isIntervalValue, literalShapeError, rosterOf } fr
 import type { AnyRelation, Fact, RelationData } from "#relation.ts"
 import { Uuid } from "#uuid.ts"
 
-/** Converter-granularity host cell wall (64 KiB). One oversize cell refuses. */
-const HOST_CELL_MAX = 65536n
-
 /**
  * One owned cell at the private bridge boundary. The declared sealed field
  * type disambiguates the union: `string` is text, an `uuid` in its
@@ -44,8 +41,6 @@ type CellValue =
 interface FlatRows {
 	readonly rows: bigint
 	readonly cells: readonly CellValue[]
-	/** Conservative charged byte size of the owned cells (input accounting). */
-	readonly bytes: bigint
 }
 
 function recordOf(fact: object): Readonly<Record<string, unknown>> {
@@ -64,9 +59,8 @@ function refuseShared(context: string, value: Uint8Array): void {
 }
 
 /**
- * Cheap host charge before any string scan or byte copy. Strings charge
- * two bytes per UTF-16 code unit, not their UTF-8 wire size. Native admission
- * measures and bounds UTF-8 separately; byte views charge their length.
+ * Approximate payload size for host batching, not a memory allowance.
+ * Strings use two bytes per UTF-16 code unit, not their UTF-8 wire size.
  */
 function hostCellCharge(value: unknown): bigint {
 	if (typeof value === "string") {
@@ -87,16 +81,6 @@ function hostCellCharge(value: unknown): bigint {
 	return 0n
 }
 
-function assertHostCellFits(context: string, value: unknown, limit: bigint): bigint {
-	const charge = hostCellCharge(value)
-	if (charge > limit) {
-		throw new AuthoringError({
-			message: `${context}: host cell of ${charge} bytes exceeds the ${limit}-byte converter bound — refuse before copy or scan`
-		})
-	}
-	return charge
-}
-
 /**
  * The write half of the closed bijection: one handle NAME to its u64 row
  * id (declaration order = row ids). An unknown name is a pointed refusal
@@ -125,25 +109,6 @@ function handleOf(context: string, closed: AnyClosedRoster, cell: unknown): stri
 	return handle
 }
 
-/** Conservative owned-byte charge of one cell (host accounting, not wire). */
-function cellBytes(cell: CellValue): bigint {
-	if (typeof cell === "boolean") {
-		return 1n
-	}
-	if (typeof cell === "bigint" || typeof cell === "number") {
-		return 8n
-	}
-	if (typeof cell === "string") {
-		// Account for the host string here; native admission separately
-		// checks and charges its exact UTF-8 encoding.
-		return BigInt(cell.length) * 2n
-	}
-	if (cell instanceof Uint8Array) {
-		return BigInt(cell.byteLength)
-	}
-	return 16n
-}
-
 function cellOf(context: string, field: AnyField, value: unknown): CellValue {
 	const roster = rosterOf(field)
 	if (roster !== undefined) {
@@ -170,7 +135,6 @@ function cellOf(context: string, field: AnyField, value: unknown): CellValue {
 			if (typeof value !== "string") {
 				throw literalShapeError(context, "string", value)
 			}
-			assertHostCellFits(context, value, HOST_CELL_MAX)
 			if (!value.isWellFormed()) {
 				throw literalShapeError(context, "well-formed string", value)
 			}
@@ -194,7 +158,6 @@ function cellOf(context: string, field: AnyField, value: unknown): CellValue {
 				throw literalShapeError(context, "Uint8Array", value)
 			}
 			refuseShared(context, value)
-			assertHostCellFits(context, value, HOST_CELL_MAX)
 			if (value.byteLength !== field.width) {
 				throw new AuthoringError({
 					message: `${context}: bytes<${field.width}> takes exactly ${field.width} bytes (got ${value.byteLength})`
@@ -231,14 +194,13 @@ function cellOf(context: string, field: AnyField, value: unknown): CellValue {
 
 /**
  * The flat projector: every fact's cells land in ONE row-major cell array
- * (length rows × arity) with the row count and charged byte size counted
- * while projecting. Missing-field refusal and per-cell judgment are
+ * (length rows × arity), counting rows while projecting.
+ * Missing-field refusal and per-cell judgment are
  * {@link cellOf}'s, byte for byte.
  */
 function flatRowsOf(data: RelationData, facts: Iterable<object>): FlatRows {
 	const cells: CellValue[] = []
 	let rows = 0n
-	let bytes = 0n
 	for (const fact of facts) {
 		rows += 1n
 		const record = recordOf(fact)
@@ -248,11 +210,10 @@ function flatRowsOf(data: RelationData, facts: Iterable<object>): FlatRows {
 				throw new AuthoringError({ message: `relation ${data.name}: fact is missing field ${declared.name}` })
 			}
 			const cell = cellOf(`relation ${data.name} field ${declared.name}`, declared.field, value)
-			bytes += cellBytes(cell)
 			cells.push(cell)
 		}
 	}
-	return { rows, cells, bytes }
+	return { rows, cells }
 }
 
 function keyCellsOf(
@@ -387,15 +348,4 @@ function factOfCells<R extends AnyRelation>(relation: R, row: readonly unknown[]
 }
 
 export type { CellValue, FlatRows }
-export {
-	assertHostCellFits,
-	cellBytes,
-	cellOf,
-	decodeCell,
-	factOfCells,
-	flatRowsOf,
-	handleOf,
-	hostCellCharge,
-	keyCellsOf,
-	recordOf
-}
+export { cellOf, decodeCell, factOfCells, flatRowsOf, handleOf, hostCellCharge, keyCellsOf, recordOf }

package/src/runtime-codes.ts

@@ -13,6 +13,5 @@ export const runtimeErrorCodes = [
 	"Io",
 	"ResourceLimit",
 	"Engine",
-	"Cancelled",
-	"DeadlineExceeded"
+	"Cancelled"
 ] as const

package/src/runtime-errors.ts

@@ -49,11 +49,7 @@ const Outstanding = Schema.Struct({
 	retained: Schema.BigInt,
 	owners: Schema.BigInt,
 	databases: Schema.BigInt,
-	natives: Schema.BigInt,
-	inputBytes: Schema.BigInt,
-	workingBytes: Schema.BigInt,
-	scratchBytes: Schema.BigInt,
-	resultBytes: Schema.BigInt
+	natives: Schema.BigInt
 })
 export type OutstandingWork = typeof Outstanding.Type
 const Close = Schema.Union([

package/src/runtime-native.ts

@@ -34,7 +34,7 @@ export interface RepositoryLockHandle {
 }
 
 /** Resource kinds installed in native worker tables. */
-export type NativeKind = "snapshot" | "result" | "cursor" | "draft" | "changes" | "repository-lock"
+export type NativeKind = "snapshot" | "prepared" | "result" | "cursor" | "draft" | "changes" | "repository-lock"
 
 /**
  * Checked capability into the native registry. JS tokens validate
@@ -96,28 +96,13 @@ export type LogTakeWire =
 			readonly digest: Uint8Array
 	  }
 
-export interface PolicyWire {
-	readonly inputBytes: bigint
-	readonly workingBytes: bigint
-	readonly scratchBytes: bigint
-	readonly resultBytes: bigint
-	readonly rows: bigint
-	readonly workUnits: bigint
-	readonly timeoutMs: number
-}
-
 export interface OptionsWire {
-	readonly workers: number
-	readonly queueCapacity: number
-	readonly cleanupCapacity: number
-	readonly ownerCapacity: number
-	readonly nativeHandleCapacity: number
-	readonly inputBytes: bigint
-	readonly workingBytes: bigint
-	readonly scratchBytes: bigint
-	readonly resultBytes: bigint
-	readonly chunkBytes: bigint
-	readonly cleanupTimeoutMs: number
+	readonly workers?: number | undefined
+	readonly queueCapacity?: number | undefined
+	readonly cleanupCapacity?: number | undefined
+	readonly ownerCapacity?: number | undefined
+	readonly nativeHandleCapacity?: number | undefined
+	readonly cleanupTimeoutMs?: number | undefined
 }
 
 export interface InspectionWire {
@@ -128,10 +113,6 @@ export interface InspectionWire {
 	readonly owners: bigint
 	readonly databases: bigint
 	readonly natives: bigint
-	readonly inputBytes: bigint
-	readonly workingBytes: bigint
-	readonly scratchBytes: bigint
-	readonly resultBytes: bigint
 }
 
 export type CloseWire =
@@ -142,8 +123,8 @@ export type CloseWire =
 interface RuntimeNative {
 	runtimeErrorCodes(): readonly string[]
 	runtimeOpen(options: OptionsWire): RuntimeHandle
-	runtimeReady(runtime: RuntimeHandle, policy: PolicyWire, callback: () => void): OperationHandle
-	runtimeHash(runtime: RuntimeHandle, policy: PolicyWire, bytes: Uint8Array, callback: () => void): OperationHandle
+	runtimeReady(runtime: RuntimeHandle, callback: () => void): OperationHandle
+	runtimeHash(runtime: RuntimeHandle, bytes: Uint8Array, callback: () => void): OperationHandle
 	runtimeTake(operation: OperationHandle): Uint8Array | null
 	runtimeCancel(operation: OperationHandle, callback: (report: CloseWire) => void): void
 	runtimeClose(runtime: RuntimeHandle, callback: (report: CloseWire) => void): void
@@ -156,20 +137,14 @@ interface RuntimeNative {
 	 * Predelivery: no JS take; cursor stays on row1 so retry does not skip.
 	 */
 	runtimeArmPublicationCancel(runtime: RuntimeHandle): void
-	runtimeDirectoryAcquire(
-		runtime: RuntimeHandle,
-		policy: PolicyWire,
-		path: string,
-		callback: () => void
-	): OperationHandle
+	runtimeDirectoryAcquire(runtime: RuntimeHandle, path: string, callback: () => void): OperationHandle
 	runtimeDirectoryTake(operation: OperationHandle): DirectoryHandle
-	runtimeDirectoryBegin(owner: DirectoryHandle, policy: PolicyWire): OperationHandle
+	runtimeDirectoryBegin(owner: DirectoryHandle): OperationHandle
 	runtimeDirectoryCheck(operation: OperationHandle): void
 	runtimeDirectoryEnd(operation: OperationHandle): void
 	runtimeDirectoryClose(owner: DirectoryHandle, remove: boolean, callback: (report: CloseWire) => void): void
 	runtimeDirectoryDbOpen(
 		owner: DirectoryHandle,
-		policy: PolicyWire,
 		childName: string,
 		spec: SchemaSpec,
 		create: boolean,
@@ -178,12 +153,11 @@ interface RuntimeNative {
 	runtimeDbTake(operation: OperationHandle): ManagedDbOutcome
 	runtimeManagedDbClose(db: DbHandle, callback: (report: CloseWire) => void): void
 
-	// --- successor log grammar on the executor (charged hashing over
+	// --- successor log grammar on the executor (hashing over
 	// whole canonical change payloads; C06 through C09) ---
 	runtimeLogCommandSeal(
 		runtime: RuntimeHandle,
 		schema: LogSchemaHandle,
-		policy: PolicyWire,
 		metadata: LogCommandMetadata,
 		changes: Uint8Array,
 		result: Uint8Array | null,
@@ -193,14 +167,12 @@ interface RuntimeNative {
 	runtimeLogCommandParse(
 		runtime: RuntimeHandle,
 		schema: LogSchemaHandle,
-		policy: PolicyWire,
 		bytes: Uint8Array,
 		limits: LogLimits,
 		callback: () => void
 	): OperationHandle
 	runtimeLogDecisionDecode(
 		runtime: RuntimeHandle,
-		policy: PolicyWire,
 		bytes: Uint8Array,
 		parent: LogDecisionStamp | null,
 		limits: LogLimits,
@@ -208,12 +180,7 @@ interface RuntimeNative {
 	): OperationHandle
 	runtimeLogTake(operation: OperationHandle): LogTakeWire
 	/** L14 mint: `Runtime::mint_repository_lock` stamps `NativeKind::RepositoryLock` at take. */
-	logRepositoryLockAcquire(
-		runtime: RuntimeHandle,
-		policy: PolicyWire,
-		directory: string,
-		callback: () => void
-	): OperationHandle
+	logRepositoryLockAcquire(runtime: RuntimeHandle, directory: string, callback: () => void): OperationHandle
 	logRepositoryLockTake(operation: OperationHandle): RepositoryLockHandle
 	logRepositoryLockRelease(owner: RepositoryLockHandle, callback: (report: CloseWire) => void): void
 }

package/src/runtime.ts

@@ -1,43 +1,21 @@
 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,
-	PolicyWire,
-	RepositoryLockHandle,
-	RuntimeHandle
-} from "#runtime-native.ts"
+import type { CloseWire, OperationHandle, OptionsWire, RepositoryLockHandle, RuntimeHandle } from "#runtime-native.ts"
 import { runtimeNative } from "#runtime-native.ts"
 
-export interface ExecutionPolicy {
-	readonly inputBytes: bigint
-	readonly workingBytes: bigint
-	readonly scratchBytes: bigint
-	readonly resultBytes: bigint
-	readonly rows: bigint
-	readonly workUnits: bigint
-	readonly timeout: Duration.Input
-}
-
 export interface NativeRuntimeOptions {
-	readonly workers: number
-	readonly queueCapacity: number
-	readonly cleanupCapacity: number
-	readonly ownerCapacity: number
-	readonly nativeHandleCapacity: number
-	readonly inputBytes: bigint
-	readonly workingBytes: bigint
-	readonly scratchBytes: bigint
-	readonly resultBytes: bigint
-	readonly chunkBytes: bigint
-	readonly cleanupTimeout: Duration.Input
+	readonly workers?: number
+	readonly queueCapacity?: number
+	readonly cleanupCapacity?: number
+	readonly ownerCapacity?: number
+	readonly nativeHandleCapacity?: number
+	readonly cleanupTimeout?: Duration.Input
 }
 
 interface RuntimeService {
 	readonly close: () => Effect.Effect<CloseReport>
-	readonly inspect: (work: ExecutionPolicy) => Effect.Effect<OutstandingWork, DbError>
+	readonly inspect: () => Effect.Effect<OutstandingWork, DbError>
 }
 
 const owners = new WeakMap<RuntimeService, RuntimeHandle>()
@@ -51,43 +29,23 @@ function count(value: number, operation: string): number {
 	return value
 }
 
-function bytes(value: bigint, operation: string): bigint {
-	if (typeof value !== "bigint" || value < 0n || value > 0xffffffffffffffffn) throw invalid(operation)
-	return value
-}
-
 function millis(value: Duration.Input, operation: string): number {
 	const duration = Duration.toMillis(value)
 	if (!Number.isFinite(duration) || duration < 0 || duration > 0xffffffff) throw invalid(operation)
 	return Math.ceil(duration)
 }
 
-export function policyWire(work: ExecutionPolicy, operation: string): PolicyWire {
-	return {
-		inputBytes: bytes(work.inputBytes, operation),
-		workingBytes: bytes(work.workingBytes, operation),
-		scratchBytes: bytes(work.scratchBytes, operation),
-		resultBytes: bytes(work.resultBytes, operation),
-		rows: bytes(work.rows, operation),
-		workUnits: bytes(work.workUnits, operation),
-		timeoutMs: millis(work.timeout, operation)
-	}
-}
-
 function options(value: NativeRuntimeOptions): OptionsWire {
 	const operation = "NativeRuntime.acquire"
 	return {
-		workers: count(value.workers, operation),
-		queueCapacity: count(value.queueCapacity, operation),
-		cleanupCapacity: count(value.cleanupCapacity, operation),
-		ownerCapacity: count(value.ownerCapacity, operation),
-		nativeHandleCapacity: count(value.nativeHandleCapacity, operation),
-		inputBytes: bytes(value.inputBytes, operation),
-		workingBytes: bytes(value.workingBytes, operation),
-		scratchBytes: bytes(value.scratchBytes, operation),
-		resultBytes: bytes(value.resultBytes, operation),
-		chunkBytes: bytes(value.chunkBytes, operation),
-		cleanupTimeoutMs: count(millis(value.cleanupTimeout, operation), operation)
+		workers: value.workers === undefined ? undefined : count(value.workers, operation),
+		queueCapacity: value.queueCapacity === undefined ? undefined : count(value.queueCapacity, operation),
+		cleanupCapacity: value.cleanupCapacity === undefined ? undefined : count(value.cleanupCapacity, operation),
+		ownerCapacity: value.ownerCapacity === undefined ? undefined : count(value.ownerCapacity, operation),
+		nativeHandleCapacity:
+			value.nativeHandleCapacity === undefined ? undefined : count(value.nativeHandleCapacity, operation),
+		cleanupTimeoutMs:
+			value.cleanupTimeout === undefined ? undefined : count(millis(value.cleanupTimeout, operation), operation)
 	}
 }
 
@@ -169,14 +127,6 @@ function afterClose<A, E, R>(
 	return effect.pipe(Effect.onExit(() => Effect.die(new CloseFailure({ operation, report }))))
 }
 
-/** Independent caps intersect: a delivery request cannot enlarge `work.resultBytes`. */
-export function deliveryResultBytes(requested: bigint, work: ExecutionPolicy): bigint {
-	if (typeof requested !== "bigint" || requested < 0n) {
-		throw invalid("deliveryResultBytes")
-	}
-	return requested < work.resultBytes ? requested : work.resultBytes
-}
-
 function close(handle: RuntimeHandle): Effect.Effect<CloseReport> {
 	return drain("NativeRuntime.close", (callback) => runtimeNative.runtimeClose(handle, callback))
 }
@@ -257,54 +207,41 @@ const acquire = Effect.fn("NativeRuntime.acquire")(function* (configuration: Nat
 						const wire = options(configuration)
 						handle = runtimeNative.runtimeOpen(wire)
 						const owner = handle
-						const lease = runtimeNative.runtimeReady(
-							owner,
-							{
-								inputBytes: 0n,
-								workingBytes: 0n,
-								scratchBytes: 0n,
-								resultBytes: 0n,
-								rows: 0n,
-								workUnits: 1n,
-								timeoutMs: wire.cleanupTimeoutMs
-							},
-							() => {
-								if (signal.aborted) {
-									try {
-										runtimeNative.runtimeClose(owner, (report) => {
-											stash.report = closeReport("NativeRuntime.acquire.cancel", report)
-										})
-									} catch (cause) {
-										stash.report = { kind: "failed", error: failure("NativeRuntime.acquire.cancel", cause) }
-									}
-									return
-								}
+						const lease = runtimeNative.runtimeReady(owner, () => {
+							if (signal.aborted) {
 								try {
-									runtimeNative.runtimeTake(lease)
-									const service: RuntimeService = {
-										close: () => close(owner),
-										inspect: Effect.fn("NativeRuntime.inspect")(function* (work) {
-											yield* nativeOperation(
-												"NativeRuntime.inspect",
-												(callback) =>
-													runtimeNative.runtimeReady(owner, policyWire(work, "NativeRuntime.inspect"), callback),
-												() => undefined
-											)
-											return runtimeNative.runtimeInspect(owner)
-										})
-									}
-									owners.set(service, owner)
-									resume(Effect.succeed(service))
+									runtimeNative.runtimeClose(owner, (report) => {
+										stash.report = closeReport("NativeRuntime.acquire.cancel", report)
+									})
 								} catch (cause) {
-									const error = failure("NativeRuntime.acquire", cause)
-									resume(
-										close(owner).pipe(
-											Effect.flatMap((report) => afterClose("NativeRuntime.acquire", report, Effect.fail(error)))
+									stash.report = { kind: "failed", error: failure("NativeRuntime.acquire.cancel", cause) }
+								}
+								return
+							}
+							try {
+								runtimeNative.runtimeTake(lease)
+								const service: RuntimeService = {
+									close: () => close(owner),
+									inspect: Effect.fn("NativeRuntime.inspect")(function* () {
+										yield* nativeOperation(
+											"NativeRuntime.inspect",
+											(callback) => runtimeNative.runtimeReady(owner, callback),
+											() => undefined
 										)
-									)
+										return runtimeNative.runtimeInspect(owner)
+									})
 								}
+								owners.set(service, owner)
+								resume(Effect.succeed(service))
+							} catch (cause) {
+								const error = failure("NativeRuntime.acquire", cause)
+								resume(
+									close(owner).pipe(
+										Effect.flatMap((report) => afterClose("NativeRuntime.acquire", report, Effect.fail(error)))
+									)
+								)
 							}
-						)
+						})
 					} catch (cause) {
 						const error = failure("NativeRuntime.acquire", cause)
 						resume(
@@ -333,7 +270,7 @@ const acquire = Effect.fn("NativeRuntime.acquire")(function* (configuration: Nat
 export class NativeRuntime extends Context.Service<NativeRuntime, RuntimeService>()(
 	"@bjornpagen/bumbledb/NativeRuntime"
 ) {
-	static layer(options: NativeRuntimeOptions): Layer.Layer<NativeRuntime, DbError> {
+	static layer(options: NativeRuntimeOptions = {}): Layer.Layer<NativeRuntime, DbError> {
 		return Layer.effect(NativeRuntime, acquire(options))
 	}
 }
@@ -374,17 +311,12 @@ function joinLockRelease(operation: string, owner: RepositoryLockHandle): Effect
  */
 export const internalAcquireRepositoryLock = Effect.fn("internalAcquireRepositoryLock")(function* (
 	operation: string,
-	directory: string,
-	work: ExecutionPolicy
+	directory: string
 ) {
 	if (directory.length === 0) {
 		return yield* Effect.fail(invalid(operation))
 	}
 	const runtime = yield* runtimeHandle()
-	const wire = yield* Effect.try({
-		try: () => policyWire(work, operation),
-		catch: () => invalid(operation)
-	})
 	const closeOp = `${operation}.repositoryLock`
 	return yield* Effect.uninterruptibleMask((restore) =>
 		Effect.gen(function* () {
@@ -406,7 +338,7 @@ export const internalAcquireRepositoryLock = Effect.fn("internalAcquireRepositor
 			const owner = yield* restore(
 				nativeOperationWith(
 					operation,
-					(callback) => runtimeNative.logRepositoryLockAcquire(runtime, wire, directory, callback),
+					(callback) => runtimeNative.logRepositoryLockAcquire(runtime, directory, callback),
 					runtimeNative.logRepositoryLockTake,
 					(value) => value
 				)
@@ -421,7 +353,7 @@ export const internalAcquireRepositoryLock = Effect.fn("internalAcquireRepositor
 })
 
 /** Internal first executor consumer; not a replacement row codec or public hash API. */
-export const hashChunk = Effect.fn("bumbledb.hashChunk")(function* (input: Uint8Array, work: ExecutionPolicy) {
+export const hashChunk = Effect.fn("bumbledb.hashChunk")(function* (input: Uint8Array) {
 	const runtime = yield* NativeRuntime
 	const handle = owners.get(runtime)
 	if (handle === undefined) return yield* Effect.fail(invalid("hashChunk"))
@@ -429,7 +361,7 @@ export const hashChunk = Effect.fn("bumbledb.hashChunk")(function* (input: Uint8
 		"hashChunk",
 		(callback) => {
 			if (!(input instanceof Uint8Array) || !(input.buffer instanceof ArrayBuffer)) throw invalid("hashChunk")
-			return runtimeNative.runtimeHash(handle, policyWire(work, "hashChunk"), input, callback)
+			return runtimeNative.runtimeHash(handle, input, callback)
 		},
 		(value) => {
 			if (value === null) throw dbError("hashChunk", { _tag: "Internal" })