@bjornpagen/bumbledb 1.0.0 → 1.1.0

package/src/migration.ts

@@ -1,9 +1,8 @@
 /**
- * Private log-migration integration entrypoints (C11): the two read-only
+ * Private log-migration integration entrypoints: the two read-only
  * native migration-codec verbs the `@bjornpagen/bumbledb-log/migrations`
- * generator consumes literally (recorded contract in
- * implementation/packets/P10.md), wired over the P06 executor onto P09's
- * native `schema_file`/`migration::plan`/`migration::manifest` lanes.
+ * 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
@@ -15,8 +14,7 @@
  */
 import { Effect } from "effect"
 import { dbNative } from "#db-native.ts"
-import type { ExecutionPolicy } from "#runtime.ts"
-import { nativeOperationWith, policyWire, runtimeHandle } from "#runtime.ts"
+import { nativeOperationWith, runtimeHandle } from "#runtime.ts"
 import { DbError, dbError } from "#runtime-errors.ts"
 import type { SchemaSpec } from "#spec.ts"
 
@@ -32,14 +30,11 @@ function owned(operation: string, value: Uint8Array | null): Uint8Array {
  * spec natively and yields bounded JSON bytes carrying the canonical
  * `schemaId` and the rendered schema snapshot.
  */
-const internalMigrationSchema = Effect.fn("internalMigrationSchema")(function* (
-	spec: SchemaSpec,
-	work: ExecutionPolicy
-) {
+const internalMigrationSchema = Effect.fn("internalMigrationSchema")(function* (spec: SchemaSpec) {
 	const runtime = yield* runtimeHandle()
 	return yield* nativeOperationWith(
 		"internalMigrationSchema",
-		(callback) => dbNative.runtimeMigrationSchema(runtime, policyWire(work, "internalMigrationSchema"), spec, callback),
+		(callback) => dbNative.runtimeMigrationSchema(runtime, spec, callback),
 		dbNative.runtimeBytesTake,
 		(bytes) => owned("internalMigrationSchema", bytes)
 	)
@@ -50,17 +45,14 @@ const internalMigrationSchema = Effect.fn("internalMigrationSchema")(function* (
  * render/digest, manifest verify/append preview, plan-set digests): owned
  * JSON request bytes in, owned JSON response bytes out.
  */
-const internalMigrationRead = Effect.fn("internalMigrationRead")(function* (
-	request: Uint8Array,
-	work: ExecutionPolicy
-) {
+const internalMigrationRead = Effect.fn("internalMigrationRead")(function* (request: Uint8Array) {
 	if (!(request instanceof Uint8Array) || !(request.buffer instanceof ArrayBuffer)) {
 		return yield* Effect.fail(new DbError({ operation: "internalMigrationRead", reason: { _tag: "InvalidArgument" } }))
 	}
 	const runtime = yield* runtimeHandle()
 	return yield* nativeOperationWith(
 		"internalMigrationRead",
-		(callback) => dbNative.runtimeMigrationRead(runtime, policyWire(work, "internalMigrationRead"), request, callback),
+		(callback) => dbNative.runtimeMigrationRead(runtime, request, callback),
 		dbNative.runtimeBytesTake,
 		(bytes) => owned("internalMigrationRead", bytes)
 	)

package/src/native.ts

@@ -38,7 +38,7 @@ interface F64IntervalValue {
 
 /**
  * One marshalled cell. An application-owned Uuid crosses as its
- * canonical hyphenated UUID string (chapter 32); there is no fresh
+ * canonical hyphenated UUID string; there is no fresh
  * range, reservation counter or issuance value anywhere on this wire.
  */
 type FactValue = boolean | bigint | number | string | Uint8Array | IntervalValue | F64IntervalValue
@@ -438,7 +438,7 @@ type Violation =
 // #runtime-native.ts (accepted | rejected | refused); reads, writes and
 // queries are worker-affine session verbs there too. The historical
 // raw-pointer `dbRead`/`dbWrite`/`tx*`/`instance*`/`prepared*` synchronous
-// surface — a JS callback inside a native transaction — is deleted (P06),
+// surface — a JS callback inside a native transaction — is deleted,
 // as are the fresh/reserve issuance verbs (`WireFreshRange`).
 
 type ErrorFamilyKind =
@@ -461,7 +461,6 @@ type ErrorFamilyKind =
 	| "foreignWitness"
 	| "param"
 	| "capacityRayMeasure"
-	| "derivedBudgetExceeded"
 	| "overflow"
 	| "scalar"
 	| "resultBytesOverflow"

package/src/query/lower.ts

@@ -166,7 +166,7 @@ interface QueryRuleScope<Rels extends SchemaRelations, Classes extends SchemaCla
 	): QueryRuleChain<Rels, BindParamsShape<MatchFields<R>, B>, Classes>
 
 	/**
-	 * Nonrecursive composition (chapter 34): a typed query template of the
+	 * Nonrecursive composition: a typed query template of the
 	 * SAME schema is a relation expression — its whole body splices as a
 	 * derived stage; every head column must be bound to a variable minted
 	 * by `v(imported)`. Naming materializes nothing.

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
- * (C05): 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 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.
+ * 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

@@ -1,11 +1,11 @@
 import { AuthoringError, SdkInvariantError } from "#errors.ts"
 /**
- * The successor row codec: fact object ⇄ positional cell array by field
+ * The row codec: fact object ⇄ positional cell array by field
  * ordinal, schema-directed, in ONE place. The write side lowers named host
  * objects to rows in the relation's field-declaration order (declaration
  * order = ordinal ids); the read side decodes owned rows back to named
  * objects of BARE structural values. This module is the one fact⇄row
- * projector. It covers the COMPLETE successor value roster: bool, u64, i64,
+ * projector. It covers all value types: bool, u64, i64,
  * f64, uuid, str, bytes<N>, discrete intervals and dense float intervals,
  * plus the closed-handle bijection (name ⇄ declaration-order row id).
  *
@@ -14,20 +14,17 @@ import { AuthoringError, SdkInvariantError } from "#errors.ts"
  * the pure {@link AuthoringError}; the Effect ingestion boundary catches
  * and types it (never an untracked partial draft). SharedArrayBuffer-backed
  * views are refused before any copy. Host length is judged before string
- * scans and byte copies (TS-004).
+ * scans and byte copies.
  */
 import type { AnyClosedRoster, AnyField } from "#fields.ts"
 import { isFloatIntervalValue, isIntervalValue, literalShapeError, rosterOf } from "#fields.ts"
 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
- * canonical hyphenated UUID spelling (chapter 35), or a closed handle
+ * canonical hyphenated UUID spelling, or a closed handle
  * before lowering (closed handles cross as `bigint` row ids),
  * `Uint8Array` is `bytes<N>`, `{ start, end }` bigints are a discrete
  * interval and numbers a dense float interval.
@@ -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,8 +59,8 @@ function refuseShared(context: string, value: Uint8Array): void {
 }
 
 /**
- * Cheap host charge before any string scan or byte copy (TS-004). UTF-16
- * code units × 2 upper-bounds UTF-8; 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") {
@@ -86,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
@@ -124,26 +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") {
-		// UTF-16 code units × 2 is a cheap safe upper bound before exact
-		// UTF-8 conversion is charged natively (chapter 35: reject oversize
-		// cells with cheap length bounds before costly conversion).
-		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)
 			}
@@ -186,9 +150,7 @@ function cellOf(context: string, field: AnyField, value: unknown): CellValue {
 			if (!Uuid.isUuid(value)) {
 				throw literalShapeError(context, "a UUID (canonical UUID text)", value)
 			}
-			// Chapter 35: uuid crosses the bridge as the canonical
-			// canonical hyphenated UUID STRING (the native marshal's spelling),
-			// never as sixteen raw bytes.
+			// UUIDs cross as canonical hyphenated text, not raw bytes.
 			return value
 		}
 		case "bytes": {
@@ -196,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})`
@@ -233,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)
@@ -250,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(
@@ -362,8 +321,7 @@ function isCompleteFact<R extends AnyRelation>(
 
 /**
  * The read half: one owned positional row into a plain frozen record in
- * declared field order — the SAME fields and shapes on every row (chapter
- * 35's stable row shape rule; no Proxy, no per-cell closures).
+ * declared field order: stable field names and shapes, no Proxy or per-cell closures.
  */
 function factOfCells<R extends AnyRelation>(relation: R, row: readonly unknown[]): Fact<R> {
 	const data = relation.data
@@ -390,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

@@ -33,20 +33,11 @@ export interface RepositoryLockHandle {
 	readonly __repositoryLock: unique symbol
 }
 
-/** F0 C7 kind roster for worker-table resources. */
-export type NativeKind = "snapshot" | "result" | "cursor" | "draft" | "changes" | "repository-lock"
-
-/** Worker-routed capability header (C7). Never holds payload bytes. */
-export interface ResourceHeader {
-	readonly runtime: bigint
-	readonly worker: number
-	readonly kind: NativeKind
-	readonly id: bigint
-	readonly generation: bigint
-}
+/** Resource kinds installed in native worker tables. */
+export type NativeKind = "snapshot" | "prepared" | "result" | "cursor" | "draft" | "changes" | "repository-lock"
 
 /**
- * Checked capability into the native registry (C7). JS tokens validate
+ * Checked capability into the native registry. JS tokens validate
  * these five fields; native re-judges kind/generation/owner on every verb.
  */
 export interface Capability {
@@ -57,11 +48,6 @@ export interface Capability {
 	readonly generation: bigint
 }
 
-/** Coalesced close obligation — already-owned drain, not rejectable work. */
-export interface CloseDrain {
-	readonly header: ResourceHeader
-}
-
 export type ManagedDbOutcome =
 	| { readonly tag: "accepted"; readonly db: DbHandle }
 	| { readonly tag: "rejected"; readonly violations: readonly Violation[] }
@@ -71,12 +57,6 @@ export type ManagedDbOutcome =
 			readonly message: string
 	  }
 
-// The 0.x five-verb JS filesystem transport (`runtimeFs`/`runtimeFsTake`,
-// FsRequestWire/FsResultWire) is DELETED with the TS CAS authority: all
-// object-store work is native (C07, P05's store rewrite); the log machine
-// drives FsStore/S3Store inside `ts/crate` and no JS layer holds a
-// conditional-store verb anymore.
-
 export type LogTakeWire =
 	| { readonly ok: false; readonly kind: LogCommandKind | LogChainKind; readonly message: string }
 	| {
@@ -116,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 {
@@ -148,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 =
@@ -162,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
@@ -176,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,
@@ -198,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,
@@ -213,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,
@@ -228,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
 }