@bjornpagen/bumbledb 0.20.2 → 1.0.0

package/dist/db.js

@@ -1,1101 +1,249 @@
-/**
- * `Db` — the living half of the SDK (PRD-07): open/create a store from a
- * `Schema`, write typed facts through delta transactions with race-free
- * final-state point reads, receive rejections as typed violation VALUES
- * keyed to statements, and read through a synchronous instance callback —
- * all typed by the schema's relations record.
- *
- * A store read is one callback: `db.read((instance, witness) => …)`. The
- * instance is invalid the moment the callback returns; the witness is a
- * cloneable token and may escape. There is no handle-shaped read and no
- * `using snap = db.read`. Builder, owned instance, and witness
- * implement `Symbol.dispose`. Prepared plans are plain values whose
- * engine-side half is reclaimed by a GC finalizer — reclamation only,
- * never correctness.
- *
- * PROCESS MODEL: one process, one exclusive-lock handle per store. The
- * `Db` value owns the LMDB environment's exclusive lock until process
- * exit (or until GC reclaims the native handle); a second engine-level
- * open of the same store is refused by the engine (`EnvironmentLocked`),
- * matching Rust. Resume = reopen in a fresh process, or hold the one `Db`
- * this process already opened. The host owns composition; retry is host
- * policy.
- *
- * REJECTION IS DATA: a rejected commit is a domain outcome (it becomes the
- * LLM repair prompt downstream), returned as a {@link WriteOutcome}
- * carrying {@link Violation} values. A moved generation on
- * {@link Db.writeFrom} is the `{ tag: "moved" }` arm, not an exception.
- * Genuine failures — I/O, used-after-scope, spent handle, marshal shape —
- * throw `@superbuilders/errors` wrapped errors instead.
- */
-import * as path from "node:path";
-import * as errors from "@superbuilders/errors";
-import { regex } from "arkregex";
-import { isClosedMember, sealedFieldsOf } from "#closed.ts";
-import { rosterOf } from "#fields.ts";
+import { Effect, Option } from "effect";
+import { internalChanges } from "#changes.ts";
+import { drainClose, releaseOwner } from "#close.ts";
+import { Schema as CoreSchema, schemaTables } from "#compile.ts";
+import { dbNative } from "#db-native.ts";
 import { lower } from "#lower.ts";
-import { cellOf, factOf, handleOf, isFreshField, keyRowOf, recordOf, rowOf } from "#marshal.ts";
-import { bridged, bridgedAsync, errorFromThrow, native } from "#native.ts";
 import { lowerQuery } from "#query/lower.ts";
-import { decodeAnswers, wireParams } from "#query/run.ts";
-import { isStatement } from "#statements.ts";
-const LEASED_FOR_PUBLISH = regex("leased for publish");
-/**
- * The flat projector: every fact's cells land in ONE row-major
- * `FactValue` array (length rows×arity) — no JS array per fact exists
- * anywhere between the caller's objects and the native crossing — and
- * the row count is counted
- * while projecting (the {@link FlatCollection} law: the stated count is
- * what the bridge verifies against `rows × arity`, exactly, for every
- * arity). The per-cell judgment is `cellOf` — the one cell judge `rowOf`
- * also speaks (closed handle→id, well-formedness, interval shape) — and
- * the missing-field refusal is `rowOf`'s, byte for byte; only the output
- * form differs (flat, never per-row).
- */
-function rowsOf(relation, facts) {
-    const data = relation.data;
-    const cells = [];
-    let rows = 0n;
-    for (const fact of facts) {
-        rows += 1n;
-        const record = recordOf(fact);
-        for (const declared of data.fields) {
-            const value = record[declared.name];
-            if (value === undefined) {
-                throw errors.new(`relation ${data.name}: fact is missing field ${declared.name}`);
-            }
-            cells.push(cellOf(`relation ${data.name} field ${declared.name}`, declared.field, value));
-        }
-    }
-    return { rows, cells };
-}
-function mutateCollection(relation, facts, apply) {
-    const flat = rowsOf(relation, facts);
-    const report = apply(flat.rows, flat.cells);
-    return Object.freeze({ submitted: report.submitted, changed: report.changed });
-}
-function freshRangeOf(wire) {
-    if (wire.empty) {
-        return Object.freeze({
-            empty: true,
-            count: 0n,
-            at(_index) {
-                return undefined;
-            },
-            *[Symbol.iterator]() { }
-        });
-    }
-    const start = wire.start;
-    const endExclusive = wire.endExclusive;
-    const count = endExclusive - start;
-    return Object.freeze({
-        empty: false,
-        start,
-        endExclusive,
-        get count() {
-            return count;
-        },
-        at(index) {
-            if (index < 0n || index >= count) {
-                return undefined;
-            }
-            return start + index;
-        },
-        *[Symbol.iterator]() {
-            for (let id = start; id < endExclusive; id++) {
-                yield id;
-            }
-        }
-    });
-}
-const abandonMark = Symbol("bumbledb.abandon");
-function abandon(payload) {
-    return Object.freeze({ [abandonMark]: true, payload });
-}
-function isAbandon(value) {
-    return typeof value === "object" && value !== null && abandonMark in value;
-}
-function isAbandonedOutcome(outcome, sentinel) {
-    return isAbandon(sentinel) && outcome.abandoned === sentinel.payload;
-}
-function abandonedOutcome(sentinel) {
-    const outcome = Object.freeze({ tag: "abandoned", abandoned: sentinel.payload });
-    if (!isAbandonedOutcome(outcome, sentinel)) {
-        throw errors.new("bumbledb abandon outcome construction incomplete");
-    }
-    return outcome;
-}
-const witnessTypes = Symbol("bumbledb.witness.types");
-const preparedTypes = Symbol("bumbledb.prepared.types");
-function decodeOffendingFact(member, relation, fact) {
-    const declared = sealedFieldsOf(member);
-    const decoded = {};
-    for (const cell of fact.fields) {
-        const cited = declared.find(function byName(candidate) {
-            return candidate.name === cell.name;
-        });
-        const roster = rosterOf(cited?.field);
-        decoded[cell.name] =
-            roster !== undefined
-                ? handleOf(`violation fact ${fact.relation} field ${cell.name}`, roster, cell.value)
-                : cell.value;
-    }
-    return Object.freeze({ relation, fact: Object.freeze(decoded) });
-}
-function violationFromEntry(entry, wire, facts) {
-    const canonical = wire.canonical;
-    if (entry.kind === "functionality") {
-        if (!("statement" in entry)) {
-            return Object.freeze({ kind: "functionality", statement: undefined, canonical, facts });
-        }
-        return Object.freeze({ kind: "functionality", statement: entry.statement, canonical, facts });
-    }
-    if (entry.kind === "capacity") {
-        if (wire.kind !== "capacity") {
-            throw errors.new(`bumbledb violation ${wire.statementId} is a capacity slot without a measure`);
-        }
-        return Object.freeze({
-            kind: "capacity",
-            statement: entry.statement,
-            canonical,
-            measure: wire.measure,
-            facts
-        });
-    }
-    if (wire.kind !== "containment") {
-        throw errors.new(`bumbledb violation ${wire.statementId} is a containment slot without a direction`);
-    }
-    if (entry.kind === "mirrors") {
-        return Object.freeze({
-            kind: "containment",
-            statement: entry.statement,
-            canonical,
-            direction: wire.direction,
-            orientation: entry.orientation,
-            facts
-        });
-    }
-    return Object.freeze({
-        kind: "containment",
-        statement: entry.statement,
-        canonical,
-        direction: wire.direction,
-        facts
-    });
-}
-function materializedEntries(theory) {
-    const entries = impliedKeyEntries(theory);
-    for (const statement of theory.statements) {
-        entries.push(...declaredEntries(statement));
-    }
-    return entries;
-}
-function impliedKeyEntries(theory) {
-    const entries = [];
-    for (const member of Object.values(theory.relations)) {
-        if (isClosedMember(member)) {
-            continue;
-        }
-        for (const declared of member.data.fields) {
-            if (isFreshField(declared.field)) {
-                entries.push({
-                    kind: "functionality",
-                    owner: member.name,
-                    projection: [declared.name]
-                });
-            }
-        }
-    }
-    for (const member of Object.values(theory.relations)) {
-        if (isClosedMember(member)) {
-            entries.push({
-                kind: "functionality",
-                owner: member.name,
-                projection: ["id"]
-            });
-        }
-    }
-    return entries;
-}
-function declaredEntries(statement) {
-    const data = statement.data;
-    switch (data.kind) {
-        case "key": {
-            return [
-                {
-                    kind: "functionality",
-                    statement,
-                    owner: data.owner.name,
-                    projection: data.projection
-                }
-            ];
-        }
-        case "containment": {
-            return [{ kind: "containment", statement }];
-        }
-        case "mirrors": {
-            return [
-                { kind: "mirrors", statement, orientation: "written" },
-                { kind: "mirrors", statement, orientation: "mirrored" }
-            ];
-        }
-        case "capacity": {
-            return [{ kind: "capacity", statement }];
-        }
+import { wireParams } from "#query/run.ts";
+import { internalResult, makeCompleteResult } from "#result.ts";
+import { factOfCells, keyCellsOf } from "#rows.ts";
+import { nativeOperationWith, policyWire, runtimeHandle } from "#runtime.ts";
+import { DbError } from "#runtime-errors.ts";
+import { runtimeNative } from "#runtime-native.ts";
+function refusal(operation, reason) {
+    return new DbError({ operation, reason: { _tag: reason } });
+}
+function witnessOf(wire) {
+    return Object.freeze({ store: wire.store, generation: wire.generation });
+}
+function outcomeOf(wire) {
+    switch (wire.tag) {
+        case "accepted":
+            return Object.freeze({ kind: "accepted", witness: witnessOf(wire.witness) });
+        case "no-change":
+            return Object.freeze({ kind: "no-change", witness: witnessOf(wire.witness) });
+        case "invariant-rejected":
+            return Object.freeze({ kind: "invariant-rejected", violations: wire.violations });
+        case "moved":
+            return Object.freeze({ kind: "moved", witnessed: witnessOf(wire.witnessed), current: witnessOf(wire.current) });
     }
 }
 /**
- * Narrows a callback result to a thenable — the async-callback probe both
- * commit sites share: an `async` build callback typechecks (`Promise<void>`
- * is assignable where a `void` return is expected), so the refusal has to
- * be a runtime probe on the returned value.
+ * Validates the query template's schema binding (identity, the membership
+ * rule) and lowers it to IR plus wire params. Pure host preparation; the
+ * engine's IR validation under budget remains the authority.
  */
-function isThenable(value) {
-    return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
-}
-function isStatementValue(value) {
-    return isStatement(value);
-}
-function selectKeyRead(keyOrStatement, declaredKey, byStatement, byPrimary) {
-    if (declaredKey !== undefined) {
-        if (!isStatementValue(keyOrStatement)) {
-            throw errors.new("keyed get takes a key() statement value as its second argument");
-        }
-        return byStatement(keyOrStatement, declaredKey);
-    }
-    if (isStatementValue(keyOrStatement)) {
-        throw errors.new("keyed get with a statement selector also takes the key object — get(relation, keyStatement, key)");
-    }
-    return byPrimary(keyOrStatement);
-}
-function tablesOf(theory, manifest) {
-    const entries = materializedEntries(theory);
-    if (entries.length !== manifest.statements.length) {
-        throw errors.new(`bumbledb manifest drift: the SDK lowering yields ${entries.length} materialized statements, the engine reports ${manifest.statements.length}`);
-    }
-    manifest.statements.forEach(function verifySlot(statement, index) {
-        const entry = entries[index];
-        if (entry === undefined || statement.id !== index) {
-            throw errors.new(`bumbledb manifest drift: statement ${statement.id} is ${statement.kind}, the SDK mirror at ${index} expected ${entry?.kind}`);
-        }
-        const engineKind = entry.kind === "mirrors" ? "containment" : entry.kind;
-        if (engineKind !== statement.kind) {
-            throw errors.new(`bumbledb manifest drift: statement ${statement.id} is ${statement.kind}, the SDK mirror at ${index} expected ${engineKind}`);
-        }
-    });
-    const relations = new Map();
-    for (const relation of manifest.relations) {
-        const member = theory.relations[relation.name];
-        if (member === undefined) {
-            throw errors.new(`bumbledb manifest drift: relation ${relation.name} is not in schema ${theory.name}`);
-        }
-        const fieldIds = new Map();
-        for (const field of relation.fields) {
-            fieldIds.set(field.name, field.id);
-        }
-        sealedFieldsOf(member).forEach(function verifyField(declared, fieldOrdinal) {
-            if (fieldIds.get(declared.name) !== fieldOrdinal) {
-                throw errors.new(`bumbledb manifest drift: ${relation.name}.${declared.name} has engine field id ${fieldIds.get(declared.name)}, its sealed ordinal is ${fieldOrdinal}`);
-            }
-        });
-        let primaryKey;
-        entries.forEach(function firstOwnedKey(entry, index) {
-            if (primaryKey === undefined && entry.kind === "functionality" && entry.owner === relation.name) {
-                primaryKey = Object.freeze({ statementId: index, projection: entry.projection });
-            }
-        });
-        relations.set(relation.name, Object.freeze({ id: relation.id, member, fieldIds, primaryKey }));
-    }
-    Object.keys(theory.relations).forEach(function verifyRelation(name, ordinal) {
-        const entry = relations.get(name);
-        if (entry === undefined) {
-            throw errors.new(`bumbledb manifest drift: schema relation ${name} is not in the manifest`);
-        }
-        if (entry.id !== ordinal) {
-            throw errors.new(`bumbledb manifest drift: relation ${name} has engine id ${entry.id}, its declaration ordinal is ${ordinal} — query lowering depends on declaration order = ids`);
-        }
-    });
-    return Object.freeze({ relations, statements: Object.freeze(entries) });
-}
-function tablesFromTheory(theory) {
-    const entries = materializedEntries(theory);
-    const relations = new Map();
-    Object.keys(theory.relations).forEach(function byOrdinal(name, ordinal) {
-        const member = theory.relations[name];
-        if (member === undefined) {
-            throw errors.new(`bumbledb theory has no relation ${name}`);
-        }
-        const fieldIds = new Map();
-        sealedFieldsOf(member).forEach(function byField(declared, fieldOrdinal) {
-            fieldIds.set(declared.name, fieldOrdinal);
-        });
-        let primaryKey;
-        entries.forEach(function firstOwnedKey(entry, index) {
-            if (primaryKey === undefined && entry.kind === "functionality" && entry.owner === name) {
-                primaryKey = Object.freeze({ statementId: index, projection: entry.projection });
-            }
-        });
-        relations.set(name, Object.freeze({ id: ordinal, member, fieldIds, primaryKey }));
-    });
-    return Object.freeze({ relations, statements: Object.freeze(entries) });
-}
-const instanceStates = new WeakMap();
-const witnessStates = new WeakMap();
-const witnessReclaimer = new FinalizationRegistry(function reclaimWitness(handle) {
-    const closed = errors.trySync(function closeWitness() {
-        native.witnessClose(handle);
-    });
-    if (closed.error) {
-        return;
-    }
-});
-const preparedPlans = new WeakMap();
-const planReclaimer = new FinalizationRegistry(function reclaimPlan(handle) {
-    const closed = errors.trySync(function closePlan() {
-        native.preparedClose(handle);
-    });
-    if (closed.error) {
-        return;
-    }
-});
-const ErrAsyncCallback = errors.new("bumbledb asyncCallback: a read or write callback returned a thenable — the callback is synchronous");
-const ErrSpentHandle = errors.new("bumbledb spentHandle: a consumed builder, instance, or witness was used");
-const ErrUseAfterScope = errors.new("bumbledb useAfterScope: a stashed read instance or write transaction was used after its callback returned");
-const ErrForeignPrepared = errors.new("bumbledb foreignPrepared: a prepared query met a foreign instance");
-const ErrForeignWitness = errors.new("bumbledb foreignWitness: a witness met a foreign store");
-function catalogMethods(theory, tables, owner, assertLive, ops) {
-    function planOf(prepared) {
-        const plan = preparedPlans.get(prepared);
-        if (plan === undefined) {
-            throw errors.wrap(ErrForeignPrepared, "bumbledb execute target is not a prepared value of this SDK");
-        }
-        if (plan.owner !== owner) {
-            throw errors.wrap(ErrForeignPrepared, `bumbledb prepared value was prepared by a different store than this one (schema ${theory.name})`);
-        }
-        return plan;
-    }
-    function contains(relation, fact) {
-        assertLive();
-        const entry = ordinaryEntry(tables, theory, relation);
-        return bridged("bumbledb instance contains", function readContains() {
-            return ops.contains(entry.id, rowOf(relation.data, recordOf(fact)));
-        });
-    }
-    function get(relation, keyOrStatement, declaredKey) {
-        assertLive();
-        const entry = ordinaryEntry(tables, theory, relation);
-        return selectKeyRead(keyOrStatement, declaredKey, function byStatement(statement, key) {
-            const selected = declaredKeyOf(tables, theory, relation, statement);
-            const row = bridged("bumbledb instance get", function readGet() {
-                return ops.get(entry.id, selected.statementId, keyRowOf(relation.data, selected.projection, recordOf(key)));
-            });
-            return row === null ? undefined : factOf(relation, row);
-        }, function byPrimary(key) {
-            const primaryKey = entry.primaryKey;
-            if (primaryKey === undefined) {
-                throw errors.new(`relation ${relation.name} has no candidate key — keyed get requires a fresh field or a declared key statement`);
-            }
-            const row = bridged("bumbledb instance get", function readGet() {
-                return ops.get(entry.id, primaryKey.statementId, keyRowOf(relation.data, primaryKey.projection, recordOf(key)));
-            });
-            return row === null ? undefined : factOf(relation, row);
-        });
-    }
-    function scan(relation) {
-        assertLive();
-        const entry = ordinaryEntry(tables, theory, relation);
-        const rows = bridged("bumbledb instance scan", function readScan() {
-            return ops.scan(entry.id);
-        });
-        return rows.map(function decodeRow(row) {
-            return factOf(relation, row);
-        });
-    }
-    function count(relation) {
-        assertLive();
-        const entry = ordinaryEntry(tables, theory, relation);
-        return bridged("bumbledb instance count", function readCount() {
-            return ops.count(entry.id);
-        });
-    }
-    function execute(prepared, params) {
-        assertLive();
-        const plan = planOf(prepared);
-        const wire = wireParams(plan.params, recordOf(params));
-        const rows = bridged("execute bumbledb prepared query", function callExecute() {
-            return ops.execute(plan.handle, wire);
-        });
-        return decodeAnswers(plan.finds, rows);
-    }
-    function prepare(q) {
-        assertLive();
-        if (q.schema !== theory) {
-            throw errors.new(`query was built against schema ${q.schema.name}, not the identical schema value this store opened with — schema identity is the membership rule`);
-        }
-        const queryIr = lowerQuery(q);
-        const outcome = bridged("prepare bumbledb query", function callPrepare() {
-            return ops.prepare(queryIr);
-        });
-        if (!outcome.ok) {
-            throwPrepareRefusal(outcome.message);
-        }
-        const prepared = Object.freeze({});
-        preparedPlans.set(prepared, Object.freeze({
-            handle: outcome.prepared,
-            owner,
-            params: q.data.params,
-            finds: q.data.finds
-        }));
-        planReclaimer.register(prepared, outcome.prepared);
-        return prepared;
-    }
-    return { scan, count, get, contains, execute, prepare };
-}
-function ordinaryEntry(tables, theory, relation) {
-    const entry = tables.relations.get(relation.name);
-    if (entry === undefined || entry.member !== relation) {
-        throw errors.new(`relation ${relation.name} is not a member of schema ${theory.name}`);
-    }
-    if (isClosedMember(relation)) {
-        throw errors.new(`relation ${relation.name} is closed — its extension is schema data (axioms), never scanned or written`);
-    }
-    return entry;
-}
-function declaredKeyOf(tables, theory, relation, statement) {
-    const statementId = tables.statements.findIndex(function byIdentity(candidate) {
-        return "statement" in candidate && candidate.statement === statement;
-    });
-    const entry = tables.statements[statementId];
-    if (entry === undefined) {
-        throw errors.new(`keyed get statement is not a declared statement of schema ${theory.name} — statement identity is the membership rule`);
-    }
-    if (entry.kind !== "functionality") {
-        throw errors.new("keyed get takes a key() statement — containments and capacity statements key nothing");
-    }
-    if (entry.owner !== relation.name) {
-        throw errors.new(`keyed get statement keys ${entry.owner}, not ${relation.name} — the statement must be a declared key of the relation it reads`);
-    }
-    return Object.freeze({ statementId, projection: entry.projection });
-}
-function overlayMethods(theory, tables, assertLive, reads) {
-    function contains(relation, fact) {
-        assertLive();
-        const entry = ordinaryEntry(tables, theory, relation);
-        return reads.contains(entry.id, rowOf(relation.data, recordOf(fact)));
-    }
-    function readThroughKey(relation, entry, selected, key) {
-        const row = reads.get(entry.id, selected.statementId, keyRowOf(relation.data, selected.projection, key));
+function preparedOf(theory, query, params) {
+    if (query.schema !== theory) {
+        throw refusal("QueryReader.execute", "InvalidArgument");
+    }
+    const ir = lowerQuery(query);
+    const wire = wireParams(query.data.params, params);
+    return { ir, wire, finds: query.data.finds };
+}
+function executeOn(state, session, query, params, work) {
+    return Effect.acquireRelease(Effect.gen(function* () {
+        const prepared = yield* Effect.try({
+            try: () => preparedOf(state.theory, query, params),
+            catch: (cause) => (cause instanceof DbError ? cause : refusal("QueryReader.execute", "InvalidArgument"))
+        });
+        const wire = policyWire(work, "QueryReader.execute");
+        const handle = yield* nativeOperationWith("QueryReader.execute", (callback) => session === undefined
+            ? dbNative.runtimeSnapshotExecute(state.handle, wire, prepared.ir, prepared.wire, callback)
+            : dbNative.runtimeSessionExecute(session, wire, prepared.ir, prepared.wire, callback), dbNative.runtimeResultTake, (value) => value);
+        return makeCompleteResult(handle, prepared.finds);
+    }), (result) => Effect.suspend(() => {
+        const internal = internalResultHandle(result);
+        if (internal === undefined) {
+            return Effect.void;
+        }
+        return releaseOwner("CompleteResult.close", (callback) => dbNative.runtimeResultClose(internal, callback));
+    }), { interruptible: true });
+}
+function internalResultHandle(result) {
+    return internalResult(result)?.handle;
+}
+function getOn(state, relation, key, work) {
+    return Effect.gen(function* () {
+        if (state.theory.relations[relation.name] !== relation) {
+            return yield* Effect.fail(refusal("QueryReader.get", "InvalidArgument"));
+        }
+        const tables = schemaTables(state.theory);
+        const relationId = tables.relationIds.get(relation.name);
+        const primary = tables.primaryKeys.get(relation.name);
+        if (relationId === undefined || primary === undefined) {
+            return yield* Effect.fail(refusal("QueryReader.get", "InvalidArgument"));
+        }
+        const cells = yield* Effect.try({
+            try: () => keyCellsOf(relation.data, primary.projection, key),
+            catch: (cause) => (cause instanceof DbError ? cause : refusal("QueryReader.get", "InvalidArgument"))
+        });
+        const row = yield* nativeOperationWith("QueryReader.get", (callback) => dbNative.runtimeSnapshotGet(state.handle, policyWire(work, "QueryReader.get"), relationId, primary.statementId, cells, callback), dbNative.runtimeRowTake, (value) => value);
         if (row === null) {
-            return undefined;
-        }
-        return factOf(relation, row);
-    }
-    function get(relation, keyOrStatement, declaredKey) {
-        assertLive();
-        const entry = ordinaryEntry(tables, theory, relation);
-        return selectKeyRead(keyOrStatement, declaredKey, function byStatement(statement, key) {
-            return readThroughKey(relation, entry, declaredKeyOf(tables, theory, relation, statement), recordOf(key));
-        }, function byPrimary(key) {
-            const primaryKey = entry.primaryKey;
-            if (primaryKey === undefined) {
-                throw errors.new(`relation ${relation.name} has no candidate key — keyed get requires a fresh field or a declared key statement`);
-            }
-            return readThroughKey(relation, entry, primaryKey, recordOf(key));
-        });
-    }
-    return { contains, get };
-}
-function createReadInstance(nativeHandle, theory, tables, owner) {
-    const state = { handle: nativeHandle, live: true, owner };
-    function assertLive() {
-        if (!state.live) {
-            throw errors.wrap(ErrUseAfterScope, "bumbledb read instance is invalidated — its owning callback already returned");
-        }
-    }
-    const methods = catalogMethods(theory, tables, owner, assertLive, {
-        scan(relationId) {
-            return native.instanceScan(state.handle, relationId);
-        },
-        count(relationId) {
-            return native.instanceCount(state.handle, relationId);
-        },
-        contains(relationId, values) {
-            return native.instanceContains(state.handle, relationId, values);
-        },
-        get(relationId, statementId, keyValues) {
-            return native.instanceGet(state.handle, relationId, statementId, keyValues);
-        },
-        prepare(query) {
-            return native.instancePrepare(state.handle, query);
-        },
-        execute(prepared, params) {
-            return native.preparedExecute(prepared, state.handle, params);
-        }
-    });
-    const instance = Object.freeze({
-        get generation() {
-            assertLive();
-            return bridged("bumbledb instance generation", function readGeneration() {
-                return native.instanceGeneration(state.handle);
-            });
-        },
-        ...methods
-    });
-    instanceStates.set(instance, state);
-    return instance;
-}
-function openDb(handle, theory, manifest) {
-    const tables = tablesOf(theory, manifest);
-    /** This store's identity token: read scopes and prepared values carry it, so cross-store use is a typed refusal. */
-    const owner = Object.freeze({});
-    function isMemberName(name) {
-        return tables.relations.has(name);
-    }
-    function violationOf(wire) {
-        const entry = tables.statements[wire.statementId];
-        if (entry === undefined) {
-            throw errors.new(`bumbledb violation cites unknown statement id ${wire.statementId}`);
-        }
-        const facts = Object.freeze(wire.facts.map(function offending(fact) {
-            const rel = tables.relations.get(fact.relation);
-            if (rel === undefined || !isMemberName(fact.relation)) {
-                throw errors.new(`bumbledb violation cites unknown relation ${fact.relation}`);
-            }
-            return decodeOffendingFact(rel.member, fact.relation, fact);
-        }));
-        return violationFromEntry(entry, wire, facts);
-    }
-    function pointReadsOf(assertLive, reads) {
-        function contains(relation, fact) {
-            assertLive();
-            const entry = ordinaryEntry(tables, theory, relation);
-            return reads.contains(entry.id, rowOf(relation.data, recordOf(fact)));
-        }
-        function readThroughKey(relation, entry, selected, key) {
-            const row = reads.get(entry.id, selected.statementId, keyRowOf(relation.data, selected.projection, key));
-            if (row === null) {
-                return undefined;
-            }
-            return factOf(relation, row);
-        }
-        function get(relation, keyOrStatement, declaredKey) {
-            assertLive();
-            const entry = ordinaryEntry(tables, theory, relation);
-            return selectKeyRead(keyOrStatement, declaredKey, function byStatement(statement, key) {
-                return readThroughKey(relation, entry, declaredKeyOf(tables, theory, relation, statement), recordOf(key));
-            }, function byPrimary(key) {
-                const primaryKey = entry.primaryKey;
-                if (primaryKey === undefined) {
-                    throw errors.new(`relation ${relation.name} has no candidate key — keyed get requires a fresh field or a declared key statement`);
-                }
-                return readThroughKey(relation, entry, primaryKey, recordOf(key));
-            });
-        }
-        return { contains, get };
-    }
-    function pinPrepared(preparedHandle, q) {
-        const prepared = Object.freeze({});
-        preparedPlans.set(prepared, Object.freeze({
-            handle: preparedHandle,
-            owner,
-            params: q.data.params,
-            finds: q.data.finds
-        }));
-        planReclaimer.register(prepared, preparedHandle);
-        return prepared;
-    }
-    function makeWitness(nativeHandle) {
-        const state = { handle: nativeHandle, spent: false, owner };
-        const witness = Object.freeze({
-            [Symbol.dispose]() {
-                if (state.spent) {
-                    return;
-                }
-                state.spent = true;
-                bridged("close bumbledb witness", function closeWitness() {
-                    native.witnessClose(nativeHandle);
-                });
-            }
-        });
-        witnessStates.set(witness, state);
-        witnessReclaimer.register(witness, nativeHandle);
-        return witness;
-    }
-    function makeInstance(nativeHandle) {
-        return createReadInstance(nativeHandle, theory, tables, owner);
-    }
-    function read(body) {
-        let captured;
-        const result = bridged("bumbledb read", function runRead() {
-            return native.dbRead(handle, function onRead(nativeInstance, nativeWitness) {
-                const instance = makeInstance(nativeInstance);
-                const witness = makeWitness(nativeWitness);
-                const value = body(instance, witness);
-                const state = instanceStates.get(instance);
-                if (state !== undefined) {
-                    state.live = false;
-                }
-                if (isThenable(value)) {
-                    throw errors.wrap(ErrAsyncCallback, "bumbledb read callback returned a thenable");
-                }
-                captured = value;
-                return value;
-            });
-        });
-        return (captured ?? result);
-    }
-    function makeTx(resolveTx) {
-        const txState = { spent: false };
-        function assertLive() {
-            if (txState.spent) {
-                throw errors.wrap(ErrUseAfterScope, "bumbledb write transaction is spent");
-            }
-        }
-        const reads = pointReadsOf(assertLive, {
-            contains(relationId, row) {
-                const txHandle = resolveTx();
-                return bridged("bumbledb tx contains", function readContains() {
-                    return native.txContains(txHandle, relationId, row);
-                });
-            },
-            get(relationId, statementId, key) {
-                const txHandle = resolveTx();
-                return bridged("bumbledb tx get", function readGet() {
-                    return native.txGet(txHandle, relationId, statementId, key);
-                });
-            }
-        });
-        function insert(relation, facts) {
-            assertLive();
-            const entry = ordinaryEntry(tables, theory, relation);
-            const txHandle = resolveTx();
-            return mutateCollection(relation, facts, function applyCells(rows, cells) {
-                return bridged("bumbledb tx insert", function record() {
-                    return native.txInsert(txHandle, entry.id, rows, cells);
-                });
-            });
-        }
-        function remove(relation, facts) {
-            assertLive();
-            const entry = ordinaryEntry(tables, theory, relation);
-            const txHandle = resolveTx();
-            const flat = rowsOf(relation, facts);
-            const report = bridged("bumbledb tx delete", function record() {
-                return native.txDelete(txHandle, entry.id, flat.rows, flat.cells);
-            });
-            return Object.freeze({ submitted: report.submitted, changed: report.changed });
-        }
-        function reserve(relation, field, count) {
-            assertLive();
-            const entry = ordinaryEntry(tables, theory, relation);
-            const declared = relation.data.fields.find(function byName(candidate) {
-                return candidate.name === field;
-            });
-            if (declared === undefined || !isFreshField(declared.field)) {
-                throw errors.new(`relation ${relation.name}: field ${field} is not a fresh cell`);
-            }
-            const fieldId = entry.fieldIds.get(field);
-            if (fieldId === undefined) {
-                throw errors.new(`bumbledb manifest drift: relation ${relation.name} has no field id for ${field}`);
-            }
-            const txHandle = resolveTx();
-            const range = bridged("bumbledb tx reserve", function mint() {
-                return native.txReserve(txHandle, entry.id, fieldId, count);
-            });
-            return freshRangeOf(range);
-        }
-        const tx = Object.freeze({
-            insert,
-            delete: remove,
-            reserve,
-            contains: reads.contains,
-            get: reads.get
-        });
-        function spend() {
-            txState.spent = true;
-        }
-        return { tx, spend };
-    }
-    function mapNativeWrite(nativeOutcome, built) {
-        if (nativeOutcome.tag === "moved") {
-            return Object.freeze({
-                tag: "moved",
-                witnessed: nativeOutcome.witnessed,
-                current: nativeOutcome.current
-            });
-        }
-        if (nativeOutcome.tag === "rejected") {
-            return Object.freeze({
-                tag: "rejected",
-                violations: Object.freeze(nativeOutcome.violations.map(violationOf))
-            });
-        }
-        if (nativeOutcome.tag === "abandoned") {
-            if (built === undefined || !isAbandon(built)) {
-                throw errors.new("bumbledb write abandoned without an abandon sentinel");
-            }
-            return abandonedOutcome(built);
-        }
-        return Object.freeze({
-            tag: "accepted",
-            value: Object.freeze({
-                value: built,
-                generation: nativeOutcome.generation
-            })
-        });
-    }
-    function runWrite(invoke, fn) {
-        let built;
-        const nativeOutcome = bridged("bumbledb write", function callWrite() {
-            return invoke(function onWrite(txHandle) {
-                const made = makeTx(function resolveTx() {
-                    return txHandle;
-                });
-                const result = errors.trySync(function buildDelta() {
-                    return fn(made.tx);
-                });
-                made.spend();
-                if (result.error) {
-                    throw errors.wrap(result.error, "build write delta");
+            return Option.none();
+        }
+        return Option.some(factOfCells(relation, row));
+    });
+}
+function makeSession(state, handle) {
+    const session = {
+        execute(query, params, work) {
+            return executeOn(state, handle, query, params, work);
+        },
+        close() {
+            return drainClose("ExecutionSession.close", (callback) => dbNative.runtimeSessionClose(handle, callback));
+        }
+    };
+    Object.freeze(session);
+    sessionHandles.set(session, handle);
+    return session;
+}
+function makeSnapshot(theory, handle, witness) {
+    const state = { theory, handle };
+    const snapshot = {
+        witness,
+        get(relation, key, work) {
+            return getOn(state, relation, key, work);
+        },
+        execute(query, params, work) {
+            return executeOn(state, undefined, query, params, work);
+        },
+        session(work) {
+            return Effect.acquireRelease(nativeOperationWith("Snapshot.session", (callback) => dbNative.runtimeSnapshotSession(handle, policyWire(work, "Snapshot.session"), callback), dbNative.runtimeSessionTake, (value) => makeSession(state, value)), (session) => Effect.suspend(() => releaseOwner("ExecutionSession.close", (callback) => dbNative.runtimeSessionClose(sessionHandles.get(session) ?? missingSession(), callback))), { interruptible: true });
+        },
+        close() {
+            return drainClose("Snapshot.close", (callback) => dbNative.runtimeSnapshotClose(handle, callback));
+        }
+    };
+    Object.freeze(snapshot);
+    snapshotHandles.set(snapshot, handle);
+    return snapshot;
+}
+const sessionHandles = new WeakMap();
+function missingSession() {
+    throw new DbError({ operation: "ExecutionSession.close", reason: { _tag: "Internal" } });
+}
+function makeDb(theory, state) {
+    const value = {
+        schemaId: state.schemaId,
+        snapshot(work) {
+            return Effect.acquireRelease(nativeOperationWith("Db.snapshot", (callback) => dbNative.runtimeDbSnapshot(state.db, policyWire(work, "Db.snapshot"), callback), dbNative.runtimeSnapshotTake, (wire) => makeSnapshot(theory, wire.snapshot, witnessOf(wire.witness))), (snapshot) => Effect.suspend(() => releaseOwner("Snapshot.close", (callback) => dbNative.runtimeSnapshotClose(snapshotHandles.get(snapshot) ?? missingSnapshot(), callback))), { interruptible: true });
+        },
+        apply(changes, options) {
+            return Effect.gen(function* () {
+                const internal = internalChanges(changes);
+                if (internal === undefined) {
+                    // A foreign object supplied dynamically refuses before
+                    // any native dispatch.
+                    return yield* Effect.fail(refusal("Db.apply", "InvalidArgument"));
                 }
-                if (isThenable(result.data)) {
-                    throw errors.wrap(ErrAsyncCallback, "bumbledb write callback returned a thenable");
+                if (internal.schemaId !== state.schemaId) {
+                    return yield* Effect.fail(refusal("Db.apply", "InvalidArgument"));
                 }
-                built = result.data;
-                return !isAbandon(result.data);
-            });
-        });
-        return mapNativeWrite(nativeOutcome, built);
-    }
-    function write(fn) {
-        const outcome = runWrite(function invoke(callback) {
-            return native.dbWrite(handle, callback);
-        }, fn);
-        if (outcome.tag === "moved") {
-            throw errors.new("bumbledb write reported moved — unconditional writes cannot move");
-        }
-        return outcome;
-    }
-    function writeFrom(witness, fn) {
-        const state = witnessStates.get(witness);
-        if (state === undefined) {
-            throw errors.wrap(ErrForeignWitness, "bumbledb writeFrom witness is not a witness of this SDK");
-        }
-        if (state.owner !== owner) {
-            throw errors.wrap(ErrForeignWitness, `bumbledb writeFrom witness belongs to a different store (schema ${theory.name})`);
-        }
-        if (state.spent) {
-            throw errors.wrap(ErrSpentHandle, "bumbledb writeFrom witness has been disposed");
-        }
-        return runWrite(function invoke(callback) {
-            return native.dbWriteFrom(handle, state.handle, callback);
-        }, fn);
-    }
-    function catalogDigest() {
-        return bridged("bumbledb catalog digest", function readCatalogDigest() {
-            return native.dbCatalogDigest(handle);
-        });
-    }
-    function prepare(q) {
-        if (q.schema !== theory) {
-            throw errors.new(`query was built against schema ${q.schema.name}, not the identical schema value this store opened with — schema identity is the membership rule`);
-        }
-        const queryIr = lowerQuery(q);
-        const outcome = bridged("prepare bumbledb query", function callPrepare() {
-            return native.dbPrepare(handle, queryIr);
-        });
-        if (!outcome.ok) {
-            throwPrepareRefusal(outcome.message);
-        }
-        return pinPrepared(outcome.prepared, q);
-    }
-    return Object.freeze({
-        schema: theory,
-        read,
-        write,
-        writeFrom,
-        catalogDigest,
-        prepare
-    });
-}
-const ErrNewtypeMismatch = errors.new("bumbledb newtypeMismatch: a statement pairs faces whose newtypes disagree — the faces of a dependency agree on their newtype, or neither carries one");
-const ErrSchemaError = errors.new("bumbledb schemaError: the declaration failed validation");
-const ErrFingerprintMismatch = errors.new("bumbledb fingerprintMismatch: the store's schema does not match this theory");
-const ErrIrError = errors.new("bumbledb irError: the query failed validation");
-function throwOpenRefusal(verb, canonical, kind, message) {
-    const detail = `${verb} ${canonical}: ${message}`;
-    if (kind === "newtypeMismatch") {
-        throw errors.wrap(ErrNewtypeMismatch, detail);
-    }
-    if (kind === "schemaError") {
-        throw errors.wrap(ErrSchemaError, detail);
-    }
-    throw errors.wrap(ErrFingerprintMismatch, detail);
-}
-function throwPrepareRefusal(message) {
-    throw errors.wrap(ErrIrError, `prepare: ${message}`);
-}
-function openFromHandle(dbHandle, theory) {
-    const manifest = bridged("fetch bumbledb manifest", function fetchManifest() {
-        return native.dbManifest(dbHandle);
-    });
-    return openDb(dbHandle, theory, manifest);
-}
-async function createStore(storePath, theory) {
-    const canonical = path.resolve(storePath);
-    const spec = lower(theory);
-    const created = await bridgedAsync(`create bumbledb store at ${canonical}`, function callBridge() {
-        return native.dbCreate(canonical, spec);
-    });
-    if (created.tag === "schemaError" || created.tag === "newtypeMismatch") {
-        throwOpenRefusal("create", canonical, created.tag, created.message);
-    }
-    if (created.tag === "rejected") {
-        return Object.freeze({
-            tag: "rejected",
-            violations: Object.freeze(created.violations.map(function mapWire(wire) {
-                return mapViolationWithoutStore(theory, wire);
-            }))
-        });
-    }
-    return Object.freeze({ tag: "accepted", value: openFromHandle(created.db, theory) });
-}
-function mapViolationWithoutStore(theory, wire) {
-    const entries = materializedEntries(theory);
-    const entry = entries[wire.statementId];
-    if (entry === undefined) {
-        throw errors.new(`bumbledb violation cites unknown statement id ${wire.statementId}`);
-    }
-    const facts = Object.freeze(wire.facts.map(function offending(fact) {
-        const member = theory.relations[fact.relation];
-        if (member === undefined || !(fact.relation in theory.relations)) {
-            throw errors.new(`bumbledb violation cites unknown relation ${fact.relation}`);
-        }
-        return decodeOffendingFact(member, fact.relation, fact);
-    }));
-    return violationFromEntry(entry, wire, facts);
-}
-async function openStore(storePath, theory) {
-    const canonical = path.resolve(storePath);
-    const spec = lower(theory);
-    const opened = await bridgedAsync(`open bumbledb store at ${canonical}`, function callBridge() {
-        return native.dbOpen(canonical, spec);
-    });
-    if (!opened.ok) {
-        throwOpenRefusal("open", canonical, opened.kind, opened.message);
-    }
-    return openFromHandle(opened.db, theory);
-}
-const ownedRecords = new WeakMap();
-const builderRecords = new WeakMap();
-const ownedReclaimer = new FinalizationRegistry(function reclaimOwned(handle) {
-    const closed = errors.trySync(function closeOwned() {
-        native.ownedInstanceClose(handle);
-    });
-    if (closed.error) {
-        return;
-    }
-});
-const builderReclaimer = new FinalizationRegistry(function reclaimBuilder(handle) {
-    const closed = errors.trySync(function closeBuilder() {
-        native.instanceBuilderClose(handle);
-    });
-    if (closed.error) {
-        return;
+                const expected = options.expected.kind === "any"
+                    ? { kind: "any" }
+                    : { kind: "exact", store: options.expected.at.store, generation: options.expected.at.generation };
+                return yield* nativeOperationWith("Db.apply", (callback) => dbNative.runtimeDbApply(state.db, policyWire(options, "Db.apply"), internal.handle, expected, callback), dbNative.runtimeApplyTake, outcomeOf);
+            });
+        },
+        inspect(work) {
+            return nativeOperationWith("Db.inspect", (callback) => dbNative.runtimeDbInspect(state.db, policyWire(work, "Db.inspect"), callback), dbNative.runtimeDbInspectTake, (wire) => Object.freeze({
+                schemaId: state.schemaId,
+                generation: wire.generation,
+                mapBytes: wire.mapBytes,
+                populatedBytes: wire.populatedBytes,
+                diskBytes: wire.diskBytes,
+                residentEstimateBytes: wire.residentEstimateBytes,
+                retainedOperations: wire.retainedOperations
+            }));
+        },
+        close() {
+            // The one close authority: database child first, then the
+            // directory owner releases its kernel lock LAST (C09). Both
+            // joins are idempotent natively.
+            return drainClose("Db.close", (callback) => runtimeNative.runtimeManagedDbClose(state.db, callback)).pipe(Effect.flatMap((report) => drainClose("Db.directoryClose", (callback) => runtimeNative.runtimeDirectoryClose(state.directory, false, callback)).pipe(Effect.map((directoryReport) => (report.kind === "closed" ? directoryReport : report)))));
+        }
+    };
+    Object.freeze(value);
+    return value;
+}
+const snapshotHandles = new WeakMap();
+function missingSnapshot() {
+    throw new DbError({ operation: "Snapshot.close", reason: { _tag: "Internal" } });
+}
+/** The managed child name under the database directory owner. */
+const CHILD = "store";
+function openDatabase(operation, path, schema, work, create) {
+    return Effect.gen(function* () {
+        const runtime = yield* runtimeHandle();
+        const compiled = yield* CoreSchema.compile(schema, work);
+        const spec = lower(schema);
+        const wire = yield* Effect.try({
+            try: () => policyWire(work, operation),
+            catch: () => refusal(operation, "InvalidArgument")
+        });
+        // Compound acquisition (TS-003): register the directory owner and
+        // its finalizer BEFORE any interruptible child-open step.
+        const directory = yield* Effect.acquireRelease(nativeOperationWith(operation, (callback) => runtimeNative.runtimeDirectoryAcquire(runtime, wire, path, callback), runtimeNative.runtimeDirectoryTake, (value) => value), (dir) => releaseOwner(`${operation}.directoryClose`, (callback) => runtimeNative.runtimeDirectoryClose(dir, false, callback)), { interruptible: true });
+        return yield* Effect.acquireRelease(Effect.gen(function* () {
+            const outcome = yield* nativeOperationWith(operation, (callback) => runtimeNative.runtimeDirectoryDbOpen(directory, wire, CHILD, spec, create, callback), runtimeNative.runtimeDbTake, (value) => value).pipe(Effect.catch((error) => drainClose(`${operation}.directoryClose`, (callback) => runtimeNative.runtimeDirectoryClose(directory, false, callback)).pipe(Effect.andThen(Effect.fail(error)))));
+            if (outcome.tag !== "accepted") {
+                yield* drainClose(`${operation}.directoryClose`, (callback) => runtimeNative.runtimeDirectoryClose(directory, false, callback));
+                return yield* Effect.fail(refusal(operation, "InvalidArgument"));
+            }
+            const state = { theory: schema, db: outcome.db, directory, schemaId: compiled.schemaId };
+            const db = makeDb(schema, state);
+            dbStates.set(db, state);
+            return db;
+        }), (db) => Effect.suspend(() => {
+            const state = dbStates.get(db);
+            if (state === undefined) {
+                return Effect.void;
+            }
+            return releaseOwner("Db.close", (callback) => runtimeNative.runtimeManagedDbClose(state.db, callback)).pipe(Effect.ensuring(releaseOwner("Db.directoryClose", (callback) => runtimeNative.runtimeDirectoryClose(state.directory, false, callback))));
+        }), { interruptible: true });
+    });
+}
+const dbStates = new WeakMap();
+/**
+ * `Db.create` is the explicit constructor and refuses existing authority;
+ * `Db.open` of a missing or unreadable database never creates an empty
+ * replacement (chapter 30). Both compile the schema through the same
+ * implementation as `Schema.compile` — prior compilation is optional.
+ */
+const Db = Object.freeze({
+    create(path, schema, work) {
+        return openDatabase("Db.create", path, schema, work, true);
+    },
+    open(path, schema, work) {
+        return openDatabase("Db.open", path, schema, work, false);
     }
 });
-function wrapOwned(nativeHandle, theory) {
-    const owner = Object.freeze({});
-    const rec = { handle: nativeHandle, theory, spent: false, owner };
-    const tables = tablesFromTheory(theory);
-    function assertLive() {
-        if (rec.spent) {
-            throw errors.wrap(ErrSpentHandle, "bumbledb owned instance has been disposed");
-        }
-    }
-    const methods = catalogMethods(theory, tables, owner, assertLive, {
-        scan(relationId) {
-            return native.ownedScan(nativeHandle, relationId);
-        },
-        count(relationId) {
-            return native.ownedCount(nativeHandle, relationId);
-        },
-        contains(relationId, values) {
-            return native.ownedContains(nativeHandle, relationId, values);
-        },
-        get(relationId, statementId, keyValues) {
-            return native.ownedGet(nativeHandle, relationId, statementId, keyValues);
-        },
-        prepare(query) {
-            return native.ownedPrepare(nativeHandle, query);
-        },
-        execute(prepared, params) {
-            return native.ownedExecute(prepared, nativeHandle, params);
-        }
-    });
-    const instance = Object.freeze({
-        ...methods,
-        [Symbol.dispose]() {
-            if (rec.spent) {
-                return;
-            }
-            try {
-                native.ownedInstanceClose(nativeHandle);
-            }
-            catch (caught) {
-                const error = errorFromThrow(caught);
-                if (LEASED_FOR_PUBLISH.test(error.message)) {
-                    throw errors.wrap(ErrSpentHandle, "bumbledb owned instance is leased for publish");
-                }
-                throw errors.wrap(error, "close bumbledb owned instance");
-            }
-            rec.spent = true;
-            ownedReclaimer.unregister(instance);
-        }
-    });
-    ownedRecords.set(instance, rec);
-    ownedReclaimer.register(instance, nativeHandle, instance);
-    return instance;
-}
-function wrapBuilder(nativeHandle, theory) {
-    const rec = { handle: nativeHandle, theory, spent: false };
-    const tables = tablesFromTheory(theory);
-    function assertLive() {
-        if (rec.spent) {
-            throw errors.wrap(ErrSpentHandle, "bumbledb instance builder has been spent");
-        }
-    }
-    const overlay = overlayMethods(theory, tables, assertLive, {
-        contains(relationId, row) {
-            return bridged("bumbledb builder contains", function readContains() {
-                return native.instanceBuilderContains(nativeHandle, relationId, row);
-            });
-        },
-        get(relationId, statementId, key) {
-            return bridged("bumbledb builder get", function readGet() {
-                return native.instanceBuilderGet(nativeHandle, relationId, statementId, key);
-            });
-        }
-    });
-    const builder = Object.freeze({
-        load(relation, facts) {
-            assertLive();
-            const entry = ordinaryEntry(tables, theory, relation);
-            return mutateCollection(relation, facts, function applyCells(rows, cells) {
-                return bridged("bumbledb builder load", function loadCells() {
-                    return native.instanceBuilderLoad(nativeHandle, entry.id, rows, cells);
-                });
-            });
-        },
-        delete(relation, facts) {
-            assertLive();
-            const entry = ordinaryEntry(tables, theory, relation);
-            const flat = rowsOf(relation, facts);
-            const report = bridged("bumbledb builder delete", function remove() {
-                return native.instanceBuilderDelete(nativeHandle, entry.id, flat.rows, flat.cells);
-            });
-            return Object.freeze({ submitted: report.submitted, changed: report.changed });
-        },
-        reserve(relation, field, count) {
-            assertLive();
-            const entry = ordinaryEntry(tables, theory, relation);
-            const declared = relation.data.fields.find(function byName(candidate) {
-                return candidate.name === field;
-            });
-            if (declared === undefined || !isFreshField(declared.field)) {
-                throw errors.new(`relation ${relation.name}: field ${field} is not a fresh cell`);
-            }
-            const fieldId = entry.fieldIds.get(field);
-            if (fieldId === undefined) {
-                throw errors.new(`bumbledb manifest drift: relation ${relation.name} has no field id for ${field}`);
-            }
-            const range = bridged("bumbledb builder reserve", function mint() {
-                return native.instanceBuilderReserve(nativeHandle, entry.id, fieldId, count);
-            });
-            return freshRangeOf(range);
+/**
+ * Private log-integration seam (C10): wraps a PUBLISHED core snapshot
+ * handle — minted by the internal log machine's native open/snapshot verbs
+ * — in the exact core `QueryReader` plus the scoped session acquisition
+ * (`PublishedSnapshot extends QueryReader` in chapter 35; the log adds
+ * identity/stamps/freshness AROUND this capability, never a second reader).
+ * The argument is the log package's branded handle for the same native
+ * registry entry, so the one cast below is a cross-package respelling of
+ * one native capability — the native side re-judges kind/generation/owner
+ * on every verb, so a forged object refuses there, typed.
+ */
+function internalPublishedReader(core, theory) {
+    const state = { theory, handle: core };
+    return Object.freeze({
+        get(relation, key, work) {
+            return getOn(state, relation, key, work);
         },
-        contains: overlay.contains,
-        get: overlay.get,
-        async admit() {
-            if (rec.spent) {
-                throw errors.wrap(ErrSpentHandle, "bumbledb instance builder has been spent");
-            }
-            rec.spent = true;
-            builderReclaimer.unregister(builder);
-            let outcome;
-            try {
-                outcome = await native.instanceBuilderAdmit(nativeHandle);
-            }
-            catch (caught) {
-                throw errors.wrap(errorFromThrow(caught), "admit bumbledb instance");
-            }
-            if (outcome.tag === "rejected") {
-                return Object.freeze({
-                    tag: "rejected",
-                    violations: Object.freeze(outcome.violations.map(function mapWire(wire) {
-                        return mapViolationWithoutStore(theory, wire);
-                    }))
-                });
-            }
-            return Object.freeze({
-                tag: "accepted",
-                value: wrapOwned(outcome.value, theory)
-            });
+        execute(queryValue, params, work) {
+            return executeOn(state, undefined, queryValue, params, work);
         },
-        [Symbol.dispose]() {
-            if (rec.spent) {
-                return;
-            }
-            rec.spent = true;
-            builderReclaimer.unregister(builder);
-            bridged("close bumbledb instance builder", function closeBuilder() {
-                native.instanceBuilderClose(nativeHandle);
-            });
+        session(work) {
+            return Effect.acquireRelease(nativeOperationWith("Snapshot.session", (callback) => dbNative.runtimeSnapshotSession(state.handle, policyWire(work, "Snapshot.session"), callback), dbNative.runtimeSessionTake, (value) => makeSession(state, value)), (session) => Effect.suspend(() => releaseOwner("ExecutionSession.close", (callback) => dbNative.runtimeSessionClose(sessionHandles.get(session) ?? missingSession(), callback))), { interruptible: true });
         }
     });
-    builderRecords.set(builder, rec);
-    builderReclaimer.register(builder, nativeHandle, builder);
-    return builder;
 }
-const InstanceBuilder = Object.freeze({
-    create(theory) {
-        const spec = lower(theory);
-        const handle = bridged("create bumbledb instance builder", function make() {
-            return native.instanceBuilderNew(spec);
-        });
-        return wrapBuilder(handle, theory);
-    }
-});
-/**
- * The store lifecycle — `Db.create(path, schema)` / `Db.open(path, schema)`.
- * Create refuses an already-initialized directory; open verifies format
- * version and the schema fingerprint. A second live handle on the same
- * path is the engine's `EnvironmentLocked`. There is no close anywhere:
- * the process owns the environment until GC/exit (durability is the
- * engine's per-commit fsync). Resume = reopen in a fresh process, or
- * hold the `Db` this process opened.
- */
-const Db = Object.freeze({
-    async create(storePath, theory) {
-        return createStore(storePath, theory);
-    },
-    async open(storePath, theory) {
-        return openStore(storePath, theory);
-    },
-    async fromInstance(storePath, instance) {
-        const rec = ownedRecords.get(instance);
-        if (rec === undefined) {
-            throw errors.wrap(ErrSpentHandle, "bumbledb fromInstance target is not an owned instance of this SDK");
-        }
-        if (rec.spent) {
-            throw errors.wrap(ErrSpentHandle, "bumbledb fromInstance target has been disposed");
-        }
-        const canonical = path.resolve(storePath);
-        const dbHandle = await bridgedAsync(`publish bumbledb instance at ${canonical}`, function publish() {
-            return native.dbFromInstance(canonical, rec.handle);
-        });
-        return openFromHandle(dbHandle, rec.theory);
-    }
-});
-export { abandon, Db, ErrAsyncCallback, ErrFingerprintMismatch, ErrForeignPrepared, ErrForeignWitness, ErrIrError, ErrNewtypeMismatch, ErrSchemaError, ErrSpentHandle, ErrUseAfterScope, InstanceBuilder };
+export { Db, internalPublishedReader };
 //# sourceMappingURL=db.js.map