@bjornpagen/bumbledb 1.2.1 → 1.3.1

package/src/runtime-errors.ts

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

package/src/runtime-native.ts

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

package/src/runtime.ts

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