@bjornpagen/bumbledb 0.15.0 → 0.17.0

package/dist/db.js

@@ -8,7 +8,7 @@
  * 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
+ * `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.
@@ -38,43 +38,38 @@ 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";
-function isColumnBatch(value) {
-    return !(Symbol.iterator in value);
-}
-function rowsOf(relation, facts) {
-    const rows = [];
-    for (const fact of facts) {
-        rows.push(rowOf(relation.data, recordOf(fact)));
-    }
-    return rows;
-}
 /**
- * Lowers a column batch to per-field wire arrays in sealed field order.
- * Allocates one array per field — never a JS array per row.
+ * 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
+ * (proposals/one-representation/20, V1) — 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 columnsOf(relation, batch) {
-    const record = recordOf(batch);
-    let count;
-    return relation.data.fields.map(function marshalColumn(declared) {
-        const raw = record[declared.name];
-        if (!Array.isArray(raw)) {
-            throw errors.new(`relation ${relation.name}: column ${declared.name} is not an array`);
-        }
-        if (count === undefined) {
-            count = raw.length;
-        }
-        else if (raw.length !== count) {
-            throw errors.new(`relation ${relation.name}: column ${declared.name} has length ${raw.length}, expected ${count}`);
+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 raw.map(function marshalCell(value) {
-            return cellOf(`relation ${relation.name} field ${declared.name}`, declared.field, value);
-        });
-    });
+    }
+    return { rows, cells };
 }
-function mutateCollection(relation, facts, applyRows, applyColumns) {
-    const report = isColumnBatch(facts)
-        ? applyColumns(columnsOf(relation, facts))
-        : applyRows(rowsOf(relation, facts));
+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) {
@@ -111,43 +106,16 @@ function freshRangeOf(wire) {
         }
     });
 }
-/**
- * The runtime discriminant of {@link Abandon} values — a property probe is
- * how `write`/`writeFrom` distinguish "abort without committing" from an
- * ordinary callback result, never a guess about the host's own value shapes.
- */
 const abandonMark = Symbol("bumbledb.abandon");
-/**
- * Wraps a payload in the {@link Abandon} sentinel — the one way a write
- * callback declines to commit: `return abandon(payload)` aborts the delta
- * (nothing is committed, not even an empty commit) and the write resolves
- * to `{ tag: "abandoned", abandoned: payload }`, from `write` and `writeFrom`
- * alike (R10).
- */
 function abandon(payload) {
     return Object.freeze({ [abandonMark]: true, payload });
 }
-/**
- * Narrows a write callback result to the abandon sentinel. The probe is
- * the private {@link abandonMark} symbol only {@link abandon} sets, and
- * `R`'s `Abandon` arm is the only way a sentinel can flow out of the
- * callback — so the narrowed payload type is sound by construction.
- */
 function isAbandon(value) {
     return typeof value === "object" && value !== null && abandonMark in value;
 }
-/**
- * The abandon outcome's trusted admission seam: the value's shape is the
- * checkable half (the sentinel mark only {@link abandon} mints, and the
- * outcome carrying that sentinel's own payload), and the sentinel's
- * existence IS the proof `R` carries an `Abandon` arm — so the outcome is
- * admitted at the conditional {@link AbandonedArm} face the type tier
- * cannot resolve over an open `R`.
- */
 function isAbandonedOutcome(outcome, sentinel) {
     return isAbandon(sentinel) && outcome.abandoned === sentinel.payload;
 }
-/** Builds the abandoned write outcome from the callback's own sentinel (the R10 arm's one mint). */
 function abandonedOutcome(sentinel) {
     const outcome = Object.freeze({ tag: "abandoned", abandoned: sentinel.payload });
     if (!isAbandonedOutcome(outcome, sentinel)) {
@@ -156,26 +124,63 @@ function abandonedOutcome(sentinel) {
     return outcome;
 }
 const witnessTypes = Symbol("bumbledb.witness.types");
-/**
- * The module-private inference slot of {@link Prepared}: an optional symbol
- * property (never set at runtime) that keeps the prepared value's `Row` and
- * `Params` type arguments load-bearing, so `execute` infers the typed rows
- * and the typed params object from the value alone — the query module's
- * `inferred` pattern, local to this module. A type-level carrier only:
- * values stay bare, nothing is asserted.
- */
 const preparedTypes = Symbol("bumbledb.prepared.types");
-/**
- * Mirrors the engine's materialized statement order
- * (`SchemaDescriptor::materialized_statements`, pinned by the fingerprint):
- * one auto-key per fresh field (relation declaration order, then field
- * order), one closed auto-key per closed relation (declaration order),
- * then the declared statements in declaration order — a `mirrors`
- * statement occupying TWO adjacent slots (the engine lowers `==` to two
- * containments, `source <= target` first), both owned by the one SDK
- * value. This positional match is how statement ids resolve back to SDK
- * statement values without the engine ever learning a wire format.
- */
+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) {
@@ -183,13 +188,6 @@ function materializedEntries(theory) {
     }
     return entries;
 }
-/**
- * The engine-materialized implied keys, in the engine's pinned order: one
- * auto-key per fresh field (relation declaration order, then field order),
- * then one closed auto-key `R(id) -> R` per closed relation (declaration
- * order). These slots carry no SDK statement value — the engine owns them
- * (`schema()` rejects an explicit duplicate).
- */
 function impliedKeyEntries(theory) {
     const entries = [];
     for (const member of Object.values(theory.relations)) {
@@ -217,12 +215,6 @@ function impliedKeyEntries(theory) {
     }
     return entries;
 }
-/**
- * One declared statement's materialized slots: a key or capacity statement
- * occupies one, a `mirrors` occupies two adjacent slots (the engine lowers
- * `==` to two containments, `source <= target` first), both owned by the
- * one SDK value.
- */
 function declaredEntries(statement) {
     const data = statement.data;
     switch (data.kind) {
@@ -259,26 +251,9 @@ function declaredEntries(statement) {
 function isThenable(value) {
     return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
 }
-/**
- * Narrows a keyed-get middle argument to a statement value (vs a key
- * object) through the statement module's admission brand — a
- * REPRESENTATION, never a shape probe: fact cell shapes are structurally
- * OPEN (an interval value carrying an excess `kind` property is a legal
- * cell), so no property probe could ever be sound here, but no host-built
- * key object can spell the module-private brand symbol.
- */
 function isStatementValue(value) {
     return isStatement(value);
 }
-/**
- * THE one selector dispatch of the `get` overload pair (primary-key vs
- * key-statement, `docs/architecture/70-api.md` § the freeze): judges the
- * middle argument once and hands the narrowed pieces to the chosen
- * continuation. `Db.get` and the read scope's `get` both dispatch through
- * here, so the two mismatch refusals speak with one voice and the symmetry
- * rule (`db.get(...) === db.read(snap => snap.get(...))`) holds by
- * construction.
- */
 function selectKeyRead(keyOrStatement, declaredKey, byStatement, byPrimary) {
     if (declaredKey !== undefined) {
         if (!isStatementValue(keyOrStatement)) {
@@ -291,16 +266,6 @@ function selectKeyRead(keyOrStatement, declaredKey, byStatement, byPrimary) {
     }
     return byPrimary(keyOrStatement);
 }
-/**
- * Builds the id-resolution tables from the manifest, verifying the SDK's
- * positional mirror against the engine's reported order — any drift
- * (count, kind, id, or membership) is a construction-time failure, never a
- * silent misattribution of a violation to the wrong statement value. The
- * declaration-ordinal law the query lowering leans on is verified in the
- * same walks: relation ids and sealed field ids both equal declaration
- * order, so a constructed `Tables` IS the proof and `prepare` inherits it
- * structurally — never a silently misaddressed query.
- */
 function tablesOf(theory, manifest) {
     const entries = materializedEntries(theory);
     if (entries.length !== manifest.statements.length) {
@@ -382,14 +347,7 @@ const witnessReclaimer = new FinalizationRegistry(function reclaimWitness(handle
         return;
     }
 });
-/** The private engine halves of this module's prepared values. */
 const preparedPlans = new WeakMap();
-/**
- * Reclaims the engine-side plan of a garbage-collected {@link Prepared}
- * value. RECLAMATION ONLY, never correctness: a plan the collector never
- * visits is idle engine memory until process exit, and a failure to close
- * is swallowed (there is no one left to care — the owning value is gone).
- */
 const planReclaimer = new FinalizationRegistry(function reclaimPlan(handle) {
     const closed = errors.trySync(function closePlan() {
         native.preparedClose(handle);
@@ -404,32 +362,6 @@ const ErrUseAfterScope = errors.new("bumbledb useAfterScope: a stashed read inst
 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 resolveOrdinary(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(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 planOf(prepared) {
         const plan = preparedPlans.get(prepared);
         if (plan === undefined) {
@@ -442,16 +374,16 @@ function catalogMethods(theory, tables, owner, assertLive, ops) {
     }
     function contains(relation, fact) {
         assertLive();
-        const entry = resolveOrdinary(relation);
+        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 = resolveOrdinary(relation);
+        const entry = ordinaryEntry(tables, theory, relation);
         return selectKeyRead(keyOrStatement, declaredKey, function byStatement(statement, key) {
-            const selected = declaredKeyOf(relation, statement);
+            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)));
             });
@@ -469,7 +401,7 @@ function catalogMethods(theory, tables, owner, assertLive, ops) {
     }
     function scan(relation) {
         assertLive();
-        const entry = resolveOrdinary(relation);
+        const entry = ordinaryEntry(tables, theory, relation);
         const rows = bridged("bumbledb instance scan", function readScan() {
             return ops.scan(entry.id);
         });
@@ -477,6 +409,13 @@ function catalogMethods(theory, tables, owner, assertLive, ops) {
             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);
@@ -508,7 +447,7 @@ function catalogMethods(theory, tables, owner, assertLive, ops) {
         planReclaimer.register(prepared, outcome.prepared);
         return prepared;
     }
-    return { scan, get, contains, execute, prepare };
+    return { scan, count, get, contains, execute, prepare };
 }
 function ordinaryEntry(tables, theory, relation) {
     const entry = tables.relations.get(relation.name);
@@ -520,23 +459,23 @@ function ordinaryEntry(tables, theory, relation) {
     }
     return entry;
 }
-function overlayMethods(theory, tables, assertLive, reads) {
-    function declaredKeyOf(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 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);
@@ -553,7 +492,7 @@ function overlayMethods(theory, tables, assertLive, reads) {
         assertLive();
         const entry = ordinaryEntry(tables, theory, relation);
         return selectKeyRead(keyOrStatement, declaredKey, function byStatement(statement, key) {
-            return readThroughKey(relation, entry, declaredKeyOf(relation, statement), recordOf(key));
+            return readThroughKey(relation, entry, declaredKeyOf(tables, theory, relation, statement), recordOf(key));
         }, function byPrimary(key) {
             const primaryKey = entry.primaryKey;
             if (primaryKey === undefined) {
@@ -575,6 +514,9 @@ function createReadInstance(nativeHandle, theory, tables, owner) {
         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);
         },
@@ -600,12 +542,6 @@ function createReadInstance(nativeHandle, theory, tables, owner) {
     instanceStates.set(instance, state);
     return instance;
 }
-/**
- * Constructs one open `Db` over an already-admitted handle: builds the
- * id-resolution tables once and closes over them — the `Db` owns handle
- * and tables and nothing else. Handle lifetime is the process's: the store
- * cache holds the environment handle until the exit hook closes it.
- */
 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. */
@@ -613,111 +549,26 @@ function openDb(handle, theory, manifest) {
     function isMemberName(name) {
         return tables.relations.has(name);
     }
-    function resolveOrdinary(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 offendingFactOf(fact) {
-        const entry = tables.relations.get(fact.relation);
-        if (entry === undefined || !isMemberName(fact.relation)) {
-            throw errors.new(`bumbledb violation cites unknown relation ${fact.relation}`);
-        }
-        const declared = sealedFieldsOf(entry.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.relation, fact: Object.freeze(decoded) });
-    }
     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(offendingFactOf));
-        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`);
+        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 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
-        });
-    }
-    /**
-     * Resolves a key-statement-selected read: the statement must be the
-     * IDENTICAL `key()` value this schema declared (identity is the
-     * membership rule) and must key `relation` — its materialized statement
-     * id comes from the positional mirror, so the engine point-reads through
-     * exactly the declared projection.
-     */
-    function declaredKeyOf(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 });
+            return decodeOffendingFact(rel.member, fact.relation, fact);
+        }));
+        return violationFromEntry(entry, wire, facts);
     }
     function pointReadsOf(assertLive, reads) {
         function contains(relation, fact) {
             assertLive();
-            const entry = resolveOrdinary(relation);
+            const entry = ordinaryEntry(tables, theory, relation);
             return reads.contains(entry.id, rowOf(relation.data, recordOf(fact)));
         }
-        /** One keyed point read through an already-resolved key, decoded to a fact (`undefined` on a miss). */
         function readThroughKey(relation, entry, selected, key) {
             const row = reads.get(entry.id, selected.statementId, keyRowOf(relation.data, selected.projection, key));
             if (row === null) {
@@ -727,9 +578,9 @@ function openDb(handle, theory, manifest) {
         }
         function get(relation, keyOrStatement, declaredKey) {
             assertLive();
-            const entry = resolveOrdinary(relation);
+            const entry = ordinaryEntry(tables, theory, relation);
             return selectKeyRead(keyOrStatement, declaredKey, function byStatement(statement, key) {
-                return readThroughKey(relation, entry, declaredKeyOf(relation, statement), recordOf(key));
+                return readThroughKey(relation, entry, declaredKeyOf(tables, theory, relation, statement), recordOf(key));
             }, function byPrimary(key) {
                 const primaryKey = entry.primaryKey;
                 if (primaryKey === undefined) {
@@ -791,32 +642,6 @@ function openDb(handle, theory, manifest) {
         });
         return (captured ?? result);
     }
-    function scan(relation) {
-        return read(function scanInScope(instance) {
-            return instance.scan(relation);
-        });
-    }
-    function get(relation, keyOrStatement, declaredKey) {
-        let found;
-        read(function getInScope(instance) {
-            found = selectKeyRead(keyOrStatement, declaredKey, function byStatement(statement, key) {
-                return instance.get(relation, statement, key);
-            }, function byPrimary(key) {
-                return instance.get(relation, key);
-            });
-        });
-        return found;
-    }
-    function contains(relation, fact) {
-        return read(function containsInScope(instance) {
-            return instance.contains(relation, fact);
-        });
-    }
-    function execute(prepared, params) {
-        return read(function executeInScope(instance) {
-            return instance.execute(prepared, params);
-        });
-    }
     function makeTx(resolveTx) {
         const txState = { spent: false };
         function assertLive() {
@@ -840,30 +665,27 @@ function openDb(handle, theory, manifest) {
         });
         function insert(relation, facts) {
             assertLive();
-            const entry = resolveOrdinary(relation);
+            const entry = ordinaryEntry(tables, theory, relation);
             const txHandle = resolveTx();
-            return mutateCollection(relation, facts, function applyRows(rows) {
+            return mutateCollection(relation, facts, function applyCells(rows, cells) {
                 return bridged("bumbledb tx insert", function record() {
-                    return native.txInsert(txHandle, entry.id, rows);
-                });
-            }, function applyColumns(columns) {
-                return bridged("bumbledb tx insert", function recordColumns() {
-                    return native.txInsertColumns(txHandle, entry.id, columns);
+                    return native.txInsert(txHandle, entry.id, rows, cells);
                 });
             });
         }
         function remove(relation, facts) {
             assertLive();
-            const entry = resolveOrdinary(relation);
+            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, rowsOf(relation, facts));
+                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 = resolveOrdinary(relation);
+            const entry = ordinaryEntry(tables, theory, relation);
             const declared = relation.data.fields.find(function byName(candidate) {
                 return candidate.name === field;
             });
@@ -983,25 +805,11 @@ function openDb(handle, theory, manifest) {
     return Object.freeze({
         schema: theory,
         read,
-        scan,
-        get,
-        contains,
-        execute,
         write,
         writeFrom,
         prepare
     });
 }
-/**
- * The engine twin of the schema-level class wall, as a matchable value
- * (`errors.is`): the shared lowering rejected a spec whose statement pairs
- * faces with disagreeing newtype labels — the faces of a dependency agree
- * on their newtype, or neither carries one. UNREACHABLE through the typed
- * builder (the SDK computes every label from the laws, so its lowered
- * specs cohere by construction); a raw spec handed to the bridge is the
- * one road here, and the runtime referee that proves the engine judges
- * what the types claim.
- */
 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");
@@ -1050,65 +858,14 @@ function mapViolationWithoutStore(theory, wire) {
     if (entry === undefined) {
         throw errors.new(`bumbledb violation cites unknown statement id ${wire.statementId}`);
     }
-    function offending(fact) {
+    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}`);
         }
-        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.relation, fact: Object.freeze(decoded) });
-    }
-    const facts = Object.freeze(wire.facts.map(offending));
-    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
-    });
+        return decodeOffendingFact(member, fact.relation, fact);
+    }));
+    return violationFromEntry(entry, wire, facts);
 }
 async function openStore(storePath, theory) {
     const canonical = path.resolve(storePath);
@@ -1152,6 +909,9 @@ function wrapOwned(nativeHandle, theory) {
         scan(relationId) {
             return native.ownedScan(nativeHandle, relationId);
         },
+        count(relationId) {
+            return native.ownedCount(nativeHandle, relationId);
+        },
         contains(relationId, values) {
             return native.ownedContains(nativeHandle, relationId, values);
         },
@@ -1213,21 +973,18 @@ function wrapBuilder(nativeHandle, theory) {
         load(relation, facts) {
             assertLive();
             const entry = ordinaryEntry(tables, theory, relation);
-            return mutateCollection(relation, facts, function applyRows(rows) {
-                return bridged("bumbledb builder load", function loadRows() {
-                    return native.instanceBuilderLoad(nativeHandle, entry.id, rows);
-                });
-            }, function applyColumns(columns) {
-                return bridged("bumbledb builder load", function loadColumns() {
-                    return native.instanceBuilderLoadColumns(nativeHandle, entry.id, columns);
+            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, rowsOf(relation, facts));
+                return native.instanceBuilderDelete(nativeHandle, entry.id, flat.rows, flat.cells);
             });
             return Object.freeze({ submitted: report.submitted, changed: report.changed });
         },
@@ -1311,15 +1068,9 @@ const InstanceBuilder = Object.freeze({
  * hold the `Db` this process opened.
  */
 const Db = Object.freeze({
-    /** Creates a fresh durable store at `path` from the schema. */
     async create(storePath, theory) {
         return createStore(storePath, theory);
     },
-    /**
-     * Opens an existing durable store at `path` with the same theory.
-     * Format 8 open never back-fills a descriptor. A second open of a
-     * still-live path is `EnvironmentLocked`.
-     */
     async open(storePath, theory) {
         return openStore(storePath, theory);
     },
@@ -1338,5 +1089,5 @@ const Db = Object.freeze({
         return openFromHandle(dbHandle, rec.theory);
     }
 });
-export { abandon, Db, ErrAsyncCallback, ErrForeignPrepared, ErrForeignWitness, ErrFingerprintMismatch, ErrIrError, ErrNewtypeMismatch, ErrSchemaError, ErrSpentHandle, ErrUseAfterScope, InstanceBuilder };
+export { abandon, Db, ErrAsyncCallback, ErrFingerprintMismatch, ErrForeignPrepared, ErrForeignWitness, ErrIrError, ErrNewtypeMismatch, ErrSchemaError, ErrSpentHandle, ErrUseAfterScope, InstanceBuilder };
 //# sourceMappingURL=db.js.map