toiljs 0.0.60 → 0.0.61

package/src/devserver/db/database.ts

@@ -17,6 +17,7 @@
  */
 
 import fs from 'node:fs';
+import { createHash } from 'node:crypto';
 import path from 'node:path';
 
 import { DataReader, DataWriter } from 'toiljs/io';
@@ -27,19 +28,31 @@ import {
     ALREADY_EXISTS,
     type CapLedger,
     CODEC_ERR,
+    CollectionFamily,
     CONFLICT,
+    type DbCatalogState,
     type DbDevState,
     type DbSnapshot,
+    DbFunctionKind,
+    DEFAULT_FILL_WAIT_MS,
+    type DevCollectionHandle,
     INVALID_HANDLE,
     MAX_KEY,
+    MAX_FILL_WAIT_MS,
     MAX_NAME,
     MAX_RESERVATION_TTL_MS,
     MAX_RESERVATIONS,
     MAX_VALUE,
+    OP_NOT_ALLOWED_FOR_FAMILY,
+    OP_NOT_ALLOWED_IN_KIND,
+    type RecordOutcomeSnapshot,
     type Reservation,
     satI64,
+    SCHEMA_UNAVAILABLE,
     TOO_MANY_KEYS,
     TOO_SMALL,
+    UNAVAILABLE,
+    isCollectionFamily,
 } from './types.js';
 
 // ---- schema versions: the dev equivalent of the edge binding the row's
@@ -73,10 +86,201 @@ function storeKey(collection: string, key: Buffer): string {
     return collection + '\0' + key.toString('latin1');
 }
 
-function collOf(db: DbDevState, handle: number): string | null {
+type RecordOutcome =
+    | { kind: 'unit' }
+    | { kind: 'value'; value: Buffer; schemaVersion: number }
+    | { kind: 'absent' }
+    | { kind: 'already_exists' }
+    | { kind: 'not_found' }
+    | { kind: 'conflict' };
+
+interface RecordIdemRow {
+    requestHash: string;
+    outcome: RecordOutcome | null;
+}
+
+function readIdem(ref: MemoryRef, ptr: number): Buffer | null {
+    if (ptr === 0) return null;
+    return readCopy(ref, ptr, 16);
+}
+
+function u64le(n: number): Buffer {
+    const b = Buffer.allocUnsafe(8);
+    b.writeBigUInt64LE(BigInt(n));
+    return b;
+}
+
+const RECORD_OP_CREATE = 4;
+const RECORD_OP_PATCH = 5;
+const RECORD_OP_DELETE = 6;
+const RECORD_OP_GET_DELETE = 7;
+const RECORD_OP_ENQUEUE = 8;
+
+function recordRequestHash(op: number, key: Buffer, value: Buffer): string {
+    return createHash('sha256')
+        .update('toildb/record-idempotency/request/v1')
+        .update(Buffer.from([op]))
+        .update(u64le(key.length))
+        .update(key)
+        .update(u64le(value.length))
+        .update(value)
+        .digest('hex');
+}
+
+function idemKey(coll: DevCollectionHandle, key: Buffer, op: string, idem: Buffer): string {
+    return `${storeKey(coll.name, key)}\0${op}\0${idem.toString('hex')}`;
+}
+
+function reservationIdFromIdem(coll: DevCollectionHandle, key: Buffer, idem: Buffer): bigint {
+    const digest = createHash('sha256')
+        .update('toildb/capacity-reservation-id/v1')
+        .update(coll.name)
+        .update('\0')
+        .update(key)
+        .update(idem)
+        .digest();
+    return digest.readBigUInt64LE(0) | (1n << 63n);
+}
+
+function snapshotOutcome(outcome: RecordOutcome): RecordOutcomeSnapshot {
+    switch (outcome.kind) {
+        case 'value':
+            return {
+                kind: 'value',
+                v: outcome.value.toString('base64'),
+                sv: outcome.schemaVersion,
+            };
+        default:
+            return { kind: outcome.kind };
+    }
+}
+
+function loadOutcome(outcome: RecordOutcomeSnapshot): RecordOutcome {
+    if (outcome.kind === 'value') {
+        return {
+            kind: 'value',
+            value: Buffer.from(outcome.v, 'base64'),
+            schemaVersion: outcome.sv,
+        };
+    }
+    return { kind: outcome.kind };
+}
+
+function collOf(db: DbDevState, handle: number): DevCollectionHandle | null {
     return handle >= 0 && handle < db.handles.length ? db.handles[handle] : null;
 }
 
+function collOfFamily(
+    db: DbDevState,
+    handle: number,
+    ...families: CollectionFamily[]
+): DevCollectionHandle | number {
+    const coll = collOf(db, handle);
+    if (coll === null) return INVALID_HANDLE;
+    return families.includes(coll.family) ? coll : OP_NOT_ALLOWED_FOR_FAMILY;
+}
+
+enum DbOp {
+    Get,
+    GetMany,
+    Exists,
+    Create,
+    Patch,
+    Delete,
+    GetDelete,
+    Enqueue,
+    Append,
+    AppendOnce,
+    Latest,
+    CounterGet,
+    CounterAdd,
+    MembershipContains,
+    MembershipAdd,
+    MembershipRemove,
+    MembershipList,
+    UniqueLookup,
+    UniqueClaim,
+    UniqueRelease,
+    CapacityAvailable,
+    CapacityReserve,
+    CapacityConfirm,
+    CapacityCancel,
+    ViewGet,
+    ViewPublish,
+    CapacitySetTotal,
+}
+
+function isReadOp(op: DbOp): boolean {
+    return (
+        op === DbOp.Get ||
+        op === DbOp.GetMany ||
+        op === DbOp.Exists ||
+        op === DbOp.ViewGet ||
+        op === DbOp.CounterGet ||
+        op === DbOp.MembershipContains ||
+        op === DbOp.MembershipList ||
+        op === DbOp.UniqueLookup ||
+        op === DbOp.Latest ||
+        op === DbOp.CapacityAvailable
+    );
+}
+
+function isScanOp(op: DbOp): boolean {
+    return op === DbOp.Latest || op === DbOp.MembershipList;
+}
+
+function kindAllows(kind: DbFunctionKind, op: DbOp): boolean {
+    if (kind === DbFunctionKind.Query) return isReadOp(op) && !isScanOp(op);
+    if (kind === DbFunctionKind.Action) {
+        return (
+            (isReadOp(op) && !isScanOp(op)) ||
+            op === DbOp.Create ||
+            op === DbOp.Patch ||
+            op === DbOp.Delete ||
+            op === DbOp.GetDelete ||
+            op === DbOp.Enqueue ||
+            op === DbOp.Append ||
+            op === DbOp.AppendOnce ||
+            op === DbOp.CounterAdd ||
+            op === DbOp.MembershipAdd ||
+            op === DbOp.MembershipRemove ||
+            op === DbOp.UniqueClaim ||
+            op === DbOp.UniqueRelease ||
+            op === DbOp.CapacityReserve ||
+            op === DbOp.CapacityConfirm ||
+            op === DbOp.CapacityCancel
+        );
+    }
+    if (kind === DbFunctionKind.Derive)
+        return (
+            isReadOp(op) || op === DbOp.ViewPublish || op === DbOp.Append || op === DbOp.CounterAdd
+        );
+    if (kind === DbFunctionKind.Job) return true;
+    return false;
+}
+
+function collForOp(
+    db: DbDevState,
+    handle: number,
+    op: DbOp,
+    ...families: CollectionFamily[]
+): DevCollectionHandle | number {
+    const coll = collOfFamily(db, handle, ...families);
+    if (typeof coll === 'number') return coll;
+    return kindAllows(db.functionKind, op) ? coll : OP_NOT_ALLOWED_IN_KIND;
+}
+
+type CatalogSeedEntry =
+    | number
+    | {
+          family?: number;
+          schemaVersion?: number;
+          replication?: number;
+          placement?: number;
+          fillMaxWaitMs?: number;
+          fillAllowStale?: boolean;
+      };
+
 /**
  * The single-process dev data store: the seven ToilDB families, their per-row
  * schema_versions, the loaded wasm's catalog, and optional on-disk persistence.
@@ -85,19 +289,24 @@ function collOf(db: DbDevState, handle: number): string | null {
 export class DevDatabase {
     /** Process-lifetime store: `"collection\0keyLatin1"` -> value. Shared across dispatches. */
     private readonly store = new Map<string, Buffer>();
+    /** Record-family idempotency claims/outcomes: collection+key+op+idem -> row. */
+    private readonly recordIdem = new Map<string, RecordIdemRow>();
+    /** Unique-claim request idempotency bytes: `"collection\0key"` -> hex idem. */
+    private readonly uniqueIdem = new Map<string, string>();
     /** View family: `"collection\0key"` -> the latest published view blob. */
     private readonly views = new Map<string, Buffer>();
     /** Membership family: `"collection\0setKey"` -> (memberLatin1 -> member bytes). */
     private readonly members = new Map<string, Map<string, Buffer>>();
     /** Counter family: `"collection\0key"` -> saturating i64 sum of deltas. */
     private readonly counters = new Map<string, bigint>();
+    /** Counter idempotency: collection+key+idem -> original delta. */
+    private readonly counterIdem = new Map<string, bigint>();
     /** Events family: `"collection\0key"` -> append-ordered event blobs (oldest first). */
     private readonly events = new Map<string, Buffer[]>();
     /** append_once dedup: `"collection\0key"` -> set of eventIds already appended. */
     private readonly eventDedup = new Map<string, Set<string>>();
     /** Capacity family: `"collection\0key"` -> an escrow ledger (ceiling + reservations). */
     private readonly capacity = new Map<string, CapLedger>();
-
     /** `"collection\0key"` -> the schema_version the record/view/unique-owner was last
      *  written under (single-value families; the edge stores it per StoredValue). */
     private readonly versions = new Map<string, number>();
@@ -105,22 +314,79 @@ export class DevDatabase {
     private readonly eventVersions = new Map<string, number[]>();
     /** Per-member schema_version: `sk` -> (memberLatin1 -> version), parallel to `members`. */
     private readonly memberVersions = new Map<string, Map<string, number>>();
-    /** `"<Db>/<collection>"` -> the CURRENT schema_version, from the loaded wasm catalog. */
-    private catalog = new Map<string, number>();
+    /** The decoded catalog from the loaded wasm, including family + current schema_version. */
+    private catalog: DbCatalogState = { kind: 'no-section' };
 
     // ---- on-disk persistence: dev data + its versions survive restarts, so a
     // developer can write rows, evolve a @data type, restart, and watch the @migrate
     // run. Delete the file to reset the dev database. JSON with base64 buffers.
     private persistPath: string | null = null;
 
-    /** (Re)load the collection -> current-schema_version map from a server wasm. The
-     *  module loader calls this on every (re)compile so writes stamp the live version. */
+    /** (Re)load the catalog capability metadata from a server wasm. The module
+     *  loader calls this on every (re)compile so writes stamp the live version. */
     setCatalog(wasm: Buffer): void {
         this.catalog = parseCatalog(wasm);
     }
 
-    private stampVersion(coll: string, sk: string): void {
-        this.versions.set(sk, this.catalog.get(coll) ?? 0); // stamp the value type's current version
+    private currentSchemaVersion(coll: DevCollectionHandle): number {
+        if (this.catalog.kind !== 'present') return coll.schemaVersion;
+        return this.catalog.collections.get(coll.name)?.schemaVersion ?? coll.schemaVersion;
+    }
+
+    private stampVersion(coll: DevCollectionHandle, sk: string): void {
+        this.versions.set(sk, this.currentSchemaVersion(coll)); // stamp the value type's current version
+    }
+
+    private recordIdemStart(
+        coll: DevCollectionHandle,
+        key: Buffer,
+        op: string,
+        idem: Buffer | null,
+        requestHash: string,
+    ): { fresh: true } | { fresh: false; status: number; outcome?: RecordOutcome } {
+        if (idem === null) return { fresh: true };
+        const ik = idemKey(coll, key, op, idem);
+        const row = this.recordIdem.get(ik);
+        if (row === undefined) {
+            this.recordIdem.set(ik, { requestHash, outcome: null });
+            return { fresh: true };
+        }
+        if (row.requestHash !== requestHash) return { fresh: false, status: CONFLICT };
+        if (row.outcome === null) return { fresh: false, status: UNAVAILABLE };
+        return { fresh: false, status: 0, outcome: row.outcome };
+    }
+
+    private recordIdemFinish(
+        coll: DevCollectionHandle,
+        key: Buffer,
+        op: string,
+        idem: Buffer | null,
+        requestHash: string,
+        outcome: RecordOutcome,
+    ): void {
+        if (idem === null) return;
+        const ik = idemKey(coll, key, op, idem);
+        const row = this.recordIdem.get(ik);
+        if (row === undefined || row.requestHash !== requestHash) return;
+        if (row.outcome === null) row.outcome = outcome;
+    }
+
+    private replayRecordOutcome(db: DbDevState, outcome: RecordOutcome): number {
+        switch (outcome.kind) {
+            case 'unit':
+                return 0;
+            case 'value':
+                db.lastResult = outcome.value;
+                db.lastResultVersion = outcome.schemaVersion;
+                return outcome.value.length;
+            case 'absent':
+            case 'not_found':
+                return ABSENT;
+            case 'already_exists':
+                return ALREADY_EXISTS;
+            case 'conflict':
+                return CONFLICT;
+        }
     }
 
     /** Point the dev DB at an on-disk file and load any existing snapshot. Call once at
@@ -136,15 +402,25 @@ export class DevDatabase {
         if (this.persistPath === null) return;
         const snap: DbSnapshot = {
             store: {},
+            recordIdem: {},
+            uniqueIdem: {},
             views: {},
             members: {},
             counters: {},
+            counterIdem: {},
             events: {},
             eventDedup: {},
             capacity: {},
         };
         for (const [k, v] of this.store)
             snap.store[k] = { v: v.toString('base64'), sv: this.versions.get(k) ?? 0 };
+        for (const [k, row] of this.recordIdem)
+            snap.recordIdem![k] = {
+                requestHash: row.requestHash,
+                state: row.outcome === null ? 'pending' : 'done',
+                outcome: row.outcome === null ? undefined : snapshotOutcome(row.outcome),
+            };
+        for (const [k, v] of this.uniqueIdem) snap.uniqueIdem![k] = v;
         for (const [k, v] of this.views)
             snap.views[k] = { v: v.toString('base64'), sv: this.versions.get(k) ?? 0 };
         for (const [k, m] of this.members) {
@@ -154,6 +430,7 @@ export class DevDatabase {
             snap.members[k] = o;
         }
         for (const [k, v] of this.counters) snap.counters[k] = v.toString();
+        for (const [k, v] of this.counterIdem) snap.counterIdem![k] = v.toString();
         for (const [k, log] of this.events) {
             const ver = this.eventVersions.get(k) ?? [];
             snap.events[k] = log.map((b, i) => ({ v: b.toString('base64'), sv: ver[i] ?? 0 }));
@@ -194,6 +471,16 @@ export class DevDatabase {
             this.store.set(k, Buffer.from(e.v, 'base64'));
             this.versions.set(k, e.sv);
         }
+        for (const [k, row] of Object.entries(snap.recordIdem ?? {})) {
+            this.recordIdem.set(k, {
+                requestHash: row.requestHash,
+                outcome:
+                    row.state === 'done' && row.outcome !== undefined
+                        ? loadOutcome(row.outcome)
+                        : null,
+            });
+        }
+        for (const [k, v] of Object.entries(snap.uniqueIdem ?? {})) this.uniqueIdem.set(k, v);
         for (const [k, e] of Object.entries(snap.views ?? {})) {
             this.views.set(k, Buffer.from(e.v, 'base64'));
             this.versions.set(k, e.sv);
@@ -209,6 +496,8 @@ export class DevDatabase {
             this.memberVersions.set(k, ver);
         }
         for (const [k, v] of Object.entries(snap.counters ?? {})) this.counters.set(k, BigInt(v));
+        for (const [k, v] of Object.entries(snap.counterIdem ?? {}))
+            this.counterIdem.set(k, BigInt(v));
         for (const [k, log] of Object.entries(snap.events ?? {})) {
             this.events.set(
                 k,
@@ -239,11 +528,14 @@ export class DevDatabase {
 
     private clear(): void {
         this.store.clear();
+        this.recordIdem.clear();
+        this.uniqueIdem.clear();
         this.versions.clear();
         this.views.clear();
         this.members.clear();
         this.memberVersions.clear();
         this.counters.clear();
+        this.counterIdem.clear();
         this.eventVersions.clear();
         this.events.clear();
         this.eventDedup.clear();
@@ -284,8 +576,30 @@ export class DevDatabase {
     ): number {
         if (nameLen < 0 || nameLen > MAX_NAME) throw new Error('data: collection name too long');
         const name = readCopy(ref, namePtr, nameLen).toString('utf8');
+        let coll: DevCollectionHandle;
+        switch (this.catalog.kind) {
+            case 'present': {
+                const found = this.catalog.collections.get(name);
+                if (found === undefined) return SCHEMA_UNAVAILABLE;
+                coll = { ...found };
+                break;
+            }
+            case 'malformed':
+                return SCHEMA_UNAVAILABLE;
+            case 'no-section':
+                coll = {
+                    name,
+                    family: CollectionFamily.Record,
+                    schemaVersion: 0,
+                    replication: 0,
+                    placement: 0,
+                    fillMaxWaitMs: DEFAULT_FILL_WAIT_MS,
+                    fillAllowStale: true,
+                };
+                break;
+        }
         const handle = db.handles.length;
-        db.handles.push(name);
+        db.handles.push(coll);
         const m = mem(ref);
         if (outHandlePtr < 0 || outHandlePtr + 4 > m.length)
             throw new Error('data: resolve out-handle out of bounds');
@@ -294,10 +608,10 @@ export class DevDatabase {
     }
 
     get(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
+        const coll = collForOp(db, handle, DbOp.Get, CollectionFamily.Record);
+        if (typeof coll === 'number') return coll;
         if (keyLen > MAX_KEY) throw new Error('data: key too long');
-        const sk = storeKey(coll, readKey(ref, keyPtr, keyLen));
+        const sk = storeKey(coll.name, readKey(ref, keyPtr, keyLen));
         const v = this.store.get(sk);
         if (v === undefined) return ABSENT;
         db.lastResult = v;
@@ -315,9 +629,16 @@ export class DevDatabase {
         keysPtr: number,
         keysLen: number,
     ): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
+        const coll = collForOp(
+            db,
+            handle,
+            DbOp.GetMany,
+            CollectionFamily.Record,
+            CollectionFamily.View,
+        );
+        if (typeof coll === 'number') return coll;
         if (keysLen > MAX_VALUE) throw new Error('data: keys blob too large');
+        const table = coll.family === CollectionFamily.View ? this.views : this.store;
         // Keys blob: u32 count, then per key a u32-length-prefixed blob. The shared
         // DataReader is bounds-safe (empty past end), so a malformed/truncated blob
         // can't over-read; cap each key at MAX_KEY like the edge's prepare_key.
@@ -332,12 +653,14 @@ export class DevDatabase {
         for (let i = 0; i < count; i++) {
             const key = r.readBytes();
             if (key.length > MAX_KEY) throw new Error('data: key too long');
-            const sk = storeKey(coll, Buffer.from(key));
-            const v = this.store.get(sk);
+            const sk = storeKey(coll.name, Buffer.from(key));
+            const v = table.get(sk);
             if (v === undefined) {
                 w.writeU8(0);
             } else {
-                w.writeU8(1).writeU32(this.versions.get(sk) ?? 0).writeBytes(v);
+                w.writeU8(1)
+                    .writeU32(this.versions.get(sk) ?? 0)
+                    .writeBytes(v);
             }
         }
         db.lastResult = Buffer.from(w.toBytes());
@@ -345,9 +668,9 @@ export class DevDatabase {
     }
 
     exists(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
-        return this.store.has(storeKey(coll, readKey(ref, keyPtr, keyLen))) ? 1 : 0;
+        const coll = collForOp(db, handle, DbOp.Exists, CollectionFamily.Record);
+        if (typeof coll === 'number') return coll;
+        return this.store.has(storeKey(coll.name, readKey(ref, keyPtr, keyLen))) ? 1 : 0;
     }
 
     create(
@@ -358,15 +681,28 @@ export class DevDatabase {
         keyLen: number,
         valPtr: number,
         valLen: number,
+        idemPtr: number,
     ): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
+        const coll = collForOp(db, handle, DbOp.Create, CollectionFamily.Record);
+        if (typeof coll === 'number') return coll;
         if (keyLen > MAX_KEY || valLen > MAX_VALUE) throw new Error('data: key/value too large');
-        const sk = storeKey(coll, readKey(ref, keyPtr, keyLen));
-        if (this.store.has(sk)) return ALREADY_EXISTS;
-        this.store.set(sk, readCopy(ref, valPtr, valLen));
-        this.stampVersion(coll, sk); // stamp the value type's current schema version
-        return 0;
+        const key = readKey(ref, keyPtr, keyLen);
+        const value = readCopy(ref, valPtr, valLen);
+        const idem = readIdem(ref, idemPtr);
+        const requestHash = recordRequestHash(RECORD_OP_CREATE, key, value);
+        const start = this.recordIdemStart(coll, key, 'C', idem, requestHash);
+        if (!start.fresh)
+            return start.outcome ? this.replayRecordOutcome(db, start.outcome) : start.status;
+        const sk = storeKey(coll.name, key);
+        const outcome: RecordOutcome = this.store.has(sk)
+            ? { kind: 'already_exists' }
+            : { kind: 'unit' };
+        if (outcome.kind === 'unit') {
+            this.store.set(sk, value);
+            this.stampVersion(coll, sk); // stamp the value type's current schema version
+        }
+        this.recordIdemFinish(coll, key, 'C', idem, requestHash, outcome);
+        return this.replayRecordOutcome(db, outcome);
     }
 
     patch(
@@ -377,27 +713,52 @@ export class DevDatabase {
         keyLen: number,
         patchPtr: number,
         patchLen: number,
+        idemPtr: number,
     ): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
+        const coll = collForOp(db, handle, DbOp.Patch, CollectionFamily.Record);
+        if (typeof coll === 'number') return coll;
         if (keyLen > MAX_KEY || patchLen > MAX_VALUE) throw new Error('data: key/patch too large');
-        const sk = storeKey(coll, readKey(ref, keyPtr, keyLen));
-        if (!this.store.has(sk)) return ABSENT; // NotFound -> ABSENT on the edge
+        const key = readKey(ref, keyPtr, keyLen);
         const v = readCopy(ref, patchPtr, patchLen);
-        this.store.set(sk, v);
-        this.stampVersion(coll, sk); // a patch rewrites the row at the current version
-        db.lastResult = v; // patch returns the stored record
-        db.lastResultVersion = -1; // the just-written value is current; never migrate it (matches the edge's LenStash None)
-        return v.length;
+        const idem = readIdem(ref, idemPtr);
+        const requestHash = recordRequestHash(RECORD_OP_PATCH, key, v);
+        const start = this.recordIdemStart(coll, key, 'P', idem, requestHash);
+        if (!start.fresh)
+            return start.outcome ? this.replayRecordOutcome(db, start.outcome) : start.status;
+        const sk = storeKey(coll.name, key);
+        const outcome: RecordOutcome = this.store.has(sk)
+            ? { kind: 'value', value: v, schemaVersion: -1 }
+            : { kind: 'not_found' };
+        if (outcome.kind === 'value') {
+            this.store.set(sk, v);
+            this.stampVersion(coll, sk); // a patch rewrites the row at the current version
+        }
+        this.recordIdemFinish(coll, key, 'P', idem, requestHash, outcome);
+        return this.replayRecordOutcome(db, outcome);
     }
 
-    delete(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
-        const sk = storeKey(coll, readKey(ref, keyPtr, keyLen));
+    delete(
+        ref: MemoryRef,
+        db: DbDevState,
+        handle: number,
+        keyPtr: number,
+        keyLen: number,
+        idemPtr: number,
+    ): number {
+        const coll = collForOp(db, handle, DbOp.Delete, CollectionFamily.Record);
+        if (typeof coll === 'number') return coll;
+        const key = readKey(ref, keyPtr, keyLen);
+        const idem = readIdem(ref, idemPtr);
+        const requestHash = recordRequestHash(RECORD_OP_DELETE, key, Buffer.alloc(0));
+        const start = this.recordIdemStart(coll, key, 'D', idem, requestHash);
+        if (!start.fresh)
+            return start.outcome ? this.replayRecordOutcome(db, start.outcome) : start.status;
+        const sk = storeKey(coll.name, key);
         this.store.delete(sk);
         this.versions.delete(sk);
-        return 0;
+        const outcome: RecordOutcome = { kind: 'unit' };
+        this.recordIdemFinish(coll, key, 'D', idem, requestHash, outcome);
+        return this.replayRecordOutcome(db, outcome);
     }
 
     // Atomic fetch-and-delete (consume-once); deletes only on a real read.
@@ -407,17 +768,32 @@ export class DevDatabase {
         handle: number,
         keyPtr: number,
         keyLen: number,
+        idemPtr: number,
     ): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
-        const sk = storeKey(coll, readKey(ref, keyPtr, keyLen));
+        const coll = collForOp(db, handle, DbOp.GetDelete, CollectionFamily.Record);
+        if (typeof coll === 'number') return coll;
+        const key = readKey(ref, keyPtr, keyLen);
+        const idem = readIdem(ref, idemPtr);
+        const requestHash = recordRequestHash(RECORD_OP_GET_DELETE, key, Buffer.alloc(0));
+        const start = this.recordIdemStart(coll, key, 'G', idem, requestHash);
+        if (!start.fresh)
+            return start.outcome ? this.replayRecordOutcome(db, start.outcome) : start.status;
+        const sk = storeKey(coll.name, key);
         const v = this.store.get(sk);
-        if (v === undefined) return ABSENT;
-        db.lastResultVersion = this.versions.get(sk) ?? 0; // surface before consuming
-        this.store.delete(sk);
-        this.versions.delete(sk);
-        db.lastResult = v;
-        return v.length;
+        const outcome: RecordOutcome =
+            v === undefined
+                ? { kind: 'absent' }
+                : {
+                      kind: 'value',
+                      value: v,
+                      schemaVersion: this.versions.get(sk) ?? 0,
+                  };
+        if (outcome.kind === 'value') {
+            this.store.delete(sk);
+            this.versions.delete(sk);
+        }
+        this.recordIdemFinish(coll, key, 'G', idem, requestHash, outcome);
+        return this.replayRecordOutcome(db, outcome);
     }
 
     // --- unique family (lookup / claim / release) ---
@@ -429,9 +805,9 @@ export class DevDatabase {
         keyPtr: number,
         keyLen: number,
     ): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
-        const sk = storeKey(coll, readKey(ref, keyPtr, keyLen));
+        const coll = collForOp(db, handle, DbOp.UniqueLookup, CollectionFamily.Unique);
+        if (typeof coll === 'number') return coll;
+        const sk = storeKey(coll.name, readKey(ref, keyPtr, keyLen));
         const v = this.store.get(sk);
         if (v === undefined) return ABSENT;
         db.lastResult = v;
@@ -448,19 +824,24 @@ export class DevDatabase {
         keyLen: number,
         valPtr: number,
         valLen: number,
+        idemPtr: number,
     ): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
+        const coll = collForOp(db, handle, DbOp.UniqueClaim, CollectionFamily.Unique);
+        if (typeof coll === 'number') return coll;
         if (keyLen > MAX_KEY || valLen > MAX_VALUE) throw new Error('data: key/value too large');
-        const sk = storeKey(coll, readKey(ref, keyPtr, keyLen));
+        const sk = storeKey(coll.name, readKey(ref, keyPtr, keyLen));
         const owner = readCopy(ref, valPtr, valLen);
+        const idem = readIdem(ref, idemPtr)?.toString('hex') ?? '';
         const existing = this.store.get(sk);
         if (existing === undefined) {
             this.store.set(sk, owner);
+            this.uniqueIdem.set(sk, idem);
             this.stampVersion(coll, sk);
             return 0; // Claimed
         }
-        if (existing.equals(owner)) return 2; // AlreadyOwnedByCaller
+        if (existing.equals(owner)) {
+            return (this.uniqueIdem.get(sk) ?? '') === idem ? 2 : CONFLICT;
+        }
         db.lastResult = existing;
         return 1; // AlreadyClaimed (current owner stashed)
     }
@@ -474,13 +855,14 @@ export class DevDatabase {
         valPtr: number,
         valLen: number,
     ): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
-        const sk = storeKey(coll, readKey(ref, keyPtr, keyLen));
+        const coll = collForOp(db, handle, DbOp.UniqueRelease, CollectionFamily.Unique);
+        if (typeof coll === 'number') return coll;
+        const sk = storeKey(coll.name, readKey(ref, keyPtr, keyLen));
         const existing = this.store.get(sk);
         if (existing === undefined) return 0; // idempotent
         if (!existing.equals(readCopy(ref, valPtr, valLen))) return CONFLICT; // not the owner
         this.store.delete(sk);
+        this.uniqueIdem.delete(sk);
         this.versions.delete(sk);
         return 0;
     }
@@ -496,9 +878,9 @@ export class DevDatabase {
         memberPtr: number,
         memberLen: number,
     ): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
-        const set = this.members.get(storeKey(coll, readKey(ref, setPtr, setLen)));
+        const coll = collForOp(db, handle, DbOp.MembershipContains, CollectionFamily.Membership);
+        if (typeof coll === 'number') return coll;
+        const set = this.members.get(storeKey(coll.name, readKey(ref, setPtr, setLen)));
         if (set === undefined) return 0;
         return set.has(readCopy(ref, memberPtr, memberLen).toString('latin1')) ? 1 : 0;
     }
@@ -512,11 +894,11 @@ export class DevDatabase {
         memberPtr: number,
         memberLen: number,
     ): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
+        const coll = collForOp(db, handle, DbOp.MembershipAdd, CollectionFamily.Membership);
+        if (typeof coll === 'number') return coll;
         if (setLen > MAX_KEY || memberLen > MAX_VALUE)
             throw new Error('data: set/member too large');
-        const sk = storeKey(coll, readKey(ref, setPtr, setLen));
+        const sk = storeKey(coll.name, readKey(ref, setPtr, setLen));
         const member = readCopy(ref, memberPtr, memberLen);
         let set = this.members.get(sk);
         if (set === undefined) {
@@ -530,7 +912,7 @@ export class DevDatabase {
             mv = new Map();
             this.memberVersions.set(sk, mv);
         }
-        mv.set(ml, this.catalog.get(coll) ?? 0);
+        mv.set(ml, this.currentSchemaVersion(coll));
         return 0;
     }
 
@@ -543,9 +925,9 @@ export class DevDatabase {
         memberPtr: number,
         memberLen: number,
     ): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
-        const sk = storeKey(coll, readKey(ref, setPtr, setLen));
+        const coll = collForOp(db, handle, DbOp.MembershipRemove, CollectionFamily.Membership);
+        if (typeof coll === 'number') return coll;
+        const sk = storeKey(coll.name, readKey(ref, setPtr, setLen));
         const ml = readCopy(ref, memberPtr, memberLen).toString('latin1');
         this.members.get(sk)?.delete(ml);
         this.memberVersions.get(sk)?.delete(ml);
@@ -562,9 +944,9 @@ export class DevDatabase {
         setLen: number,
         limit: number,
     ): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
-        const sk = storeKey(coll, readKey(ref, setPtr, setLen));
+        const coll = collForOp(db, handle, DbOp.MembershipList, CollectionFamily.Membership);
+        if (typeof coll === 'number') return coll;
+        const sk = storeKey(coll.name, readKey(ref, setPtr, setLen));
         const set = this.members.get(sk);
         const mv = this.memberVersions.get(sk);
         const n = Math.max(0, Math.min(limit, 0xffff));
@@ -590,9 +972,9 @@ export class DevDatabase {
         keyPtr: number,
         keyLen: number,
     ): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
-        const sk = storeKey(coll, readKey(ref, keyPtr, keyLen));
+        const coll = collForOp(db, handle, DbOp.ViewGet, CollectionFamily.View);
+        if (typeof coll === 'number') return coll;
+        const sk = storeKey(coll.name, readKey(ref, keyPtr, keyLen));
         const v = this.views.get(sk);
         if (v === undefined) return ABSENT;
         db.lastResult = v;
@@ -610,10 +992,10 @@ export class DevDatabase {
         valPtr: number,
         valLen: number,
     ): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
+        const coll = collForOp(db, handle, DbOp.ViewPublish, CollectionFamily.View);
+        if (typeof coll === 'number') return coll;
         if (keyLen > MAX_KEY || valLen > MAX_VALUE) throw new Error('data: key/view too large');
-        const sk = storeKey(coll, readKey(ref, keyPtr, keyLen));
+        const sk = storeKey(coll.name, readKey(ref, keyPtr, keyLen));
         this.views.set(sk, readCopy(ref, valPtr, valLen));
         this.stampVersion(coll, sk);
         return 0;
@@ -630,9 +1012,9 @@ export class DevDatabase {
         keyPtr: number,
         keyLen: number,
     ): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
-        const sum = this.counters.get(storeKey(coll, readKey(ref, keyPtr, keyLen))) ?? 0n;
+        const coll = collForOp(db, handle, DbOp.CounterGet, CollectionFamily.Counter);
+        if (typeof coll === 'number') return coll;
+        const sum = this.counters.get(storeKey(coll.name, readKey(ref, keyPtr, keyLen))) ?? 0n;
         const out = Buffer.alloc(8);
         out.writeBigInt64LE(sum);
         db.lastResult = out;
@@ -648,11 +1030,21 @@ export class DevDatabase {
         keyPtr: number,
         keyLen: number,
         delta: number | bigint,
+        idemPtr: number,
     ): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
-        const sk = storeKey(coll, readKey(ref, keyPtr, keyLen));
-        this.counters.set(sk, satI64((this.counters.get(sk) ?? 0n) + BigInt(delta)));
+        const coll = collForOp(db, handle, DbOp.CounterAdd, CollectionFamily.Counter);
+        if (typeof coll === 'number') return coll;
+        const key = readKey(ref, keyPtr, keyLen);
+        const idem = readIdem(ref, idemPtr);
+        const d = BigInt(delta);
+        if (idem !== null) {
+            const ik = idemKey(coll, key, 'A', idem);
+            const seen = this.counterIdem.get(ik);
+            if (seen !== undefined) return seen === d ? 0 : CONFLICT;
+            this.counterIdem.set(ik, d);
+        }
+        const sk = storeKey(coll.name, key);
+        this.counters.set(sk, satI64((this.counters.get(sk) ?? 0n) + d));
         return 0;
     }
 
@@ -666,14 +1058,27 @@ export class DevDatabase {
         keyLen: number,
         evPtr: number,
         evLen: number,
+        idemPtr: number,
     ): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
+        const coll = collForOp(db, handle, DbOp.Append, CollectionFamily.Events);
+        if (typeof coll === 'number') return coll;
         if (keyLen > MAX_KEY || evLen > MAX_VALUE) throw new Error('data: key/event too large');
-        const sk = storeKey(coll, readKey(ref, keyPtr, keyLen));
+        const key = readKey(ref, keyPtr, keyLen);
+        const sk = storeKey(coll.name, key);
+        const idem = readIdem(ref, idemPtr);
+        if (idem !== null) {
+            let seen = this.eventDedup.get(sk);
+            if (seen === undefined) {
+                seen = new Set();
+                this.eventDedup.set(sk, seen);
+            }
+            const eventId = idem.toString('latin1');
+            if (seen.has(eventId)) return 0;
+            seen.add(eventId);
+        }
         const log = this.events.get(sk);
         const ev = readCopy(ref, evPtr, evLen);
-        const sv = this.catalog.get(coll) ?? 0;
+        const sv = this.currentSchemaVersion(coll);
         if (log === undefined) {
             this.events.set(sk, [ev]);
             this.eventVersions.set(sk, [sv]);
@@ -697,10 +1102,10 @@ export class DevDatabase {
         evPtr: number,
         evLen: number,
     ): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
+        const coll = collForOp(db, handle, DbOp.AppendOnce, CollectionFamily.Events);
+        if (typeof coll === 'number') return coll;
         if (keyLen > MAX_KEY || evLen > MAX_VALUE) throw new Error('data: key/event too large');
-        const sk = storeKey(coll, readKey(ref, keyPtr, keyLen));
+        const sk = storeKey(coll.name, readKey(ref, keyPtr, keyLen));
         const evid = readCopy(ref, evidPtr, evidLen).toString('latin1');
         let seen = this.eventDedup.get(sk);
         if (seen === undefined) {
@@ -709,7 +1114,7 @@ export class DevDatabase {
         }
         if (seen.has(evid)) return 0; // already appended under this id
         const ev = readCopy(ref, evPtr, evLen);
-        const sv = this.catalog.get(coll) ?? 0;
+        const sv = this.currentSchemaVersion(coll);
         const log = this.events.get(sk);
         if (log === undefined) {
             this.events.set(sk, [ev]);
@@ -733,15 +1138,28 @@ export class DevDatabase {
         keyLen: number,
         valPtr: number,
         valLen: number,
+        idemPtr: number,
     ): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
+        const coll = collForOp(db, handle, DbOp.Enqueue, CollectionFamily.Record);
+        if (typeof coll === 'number') return coll;
         if (keyLen > MAX_KEY || valLen > MAX_VALUE) throw new Error('data: key/value too large');
-        const sk = storeKey(coll, readKey(ref, keyPtr, keyLen));
-        if (!this.store.has(sk)) return ABSENT; // enqueue replaces an existing record
-        this.store.set(sk, readCopy(ref, valPtr, valLen));
-        this.stampVersion(coll, sk);
-        return 0;
+        const key = readKey(ref, keyPtr, keyLen);
+        const value = readCopy(ref, valPtr, valLen);
+        const idem = readIdem(ref, idemPtr);
+        const requestHash = recordRequestHash(RECORD_OP_ENQUEUE, key, value);
+        const start = this.recordIdemStart(coll, key, 'E', idem, requestHash);
+        if (!start.fresh)
+            return start.outcome ? this.replayRecordOutcome(db, start.outcome) : start.status;
+        const sk = storeKey(coll.name, key);
+        const outcome: RecordOutcome = this.store.has(sk)
+            ? { kind: 'unit' }
+            : { kind: 'not_found' };
+        if (outcome.kind === 'unit') {
+            this.store.set(sk, value);
+            this.stampVersion(coll, sk);
+        }
+        this.recordIdemFinish(coll, key, 'E', idem, requestHash, outcome);
+        return this.replayRecordOutcome(db, outcome);
     }
 
     // Frame the newest-`limit` events as `u32 count` then per event a
@@ -755,9 +1173,9 @@ export class DevDatabase {
         keyLen: number,
         limit: number,
     ): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
-        const sk = storeKey(coll, readKey(ref, keyPtr, keyLen));
+        const coll = collForOp(db, handle, DbOp.Latest, CollectionFamily.Events);
+        if (typeof coll === 'number') return coll;
+        const sk = storeKey(coll.name, readKey(ref, keyPtr, keyLen));
         const log = this.events.get(sk) ?? [];
         const vers = this.eventVersions.get(sk) ?? [];
         const n = Math.max(0, Math.min(limit, 0xffff));
@@ -787,9 +1205,9 @@ export class DevDatabase {
         keyLen: number,
         total: number | bigint,
     ): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
-        const l = this.capLedger(storeKey(coll, readKey(ref, keyPtr, keyLen)));
+        const coll = collForOp(db, handle, DbOp.CapacitySetTotal, CollectionFamily.Capacity);
+        if (typeof coll === 'number') return coll;
+        const l = this.capLedger(storeKey(coll.name, readKey(ref, keyPtr, keyLen)));
         const t = BigInt(total);
         l.total = satI64(t < 0n ? 0n : t);
         return 0;
@@ -803,9 +1221,9 @@ export class DevDatabase {
         keyPtr: number,
         keyLen: number,
     ): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
-        const l = this.capLedger(storeKey(coll, readKey(ref, keyPtr, keyLen)));
+        const coll = collForOp(db, handle, DbOp.CapacityAvailable, CollectionFamily.Capacity);
+        if (typeof coll === 'number') return coll;
+        const l = this.capLedger(storeKey(coll.name, readKey(ref, keyPtr, keyLen)));
         this.capPrune(l, Date.now());
         const avail = l.total - this.capReserved(l);
         const out = Buffer.alloc(8);
@@ -827,18 +1245,32 @@ export class DevDatabase {
         keyLen: number,
         amount: number | bigint,
         ttlMs: number | bigint,
+        idemPtr: number,
     ): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
+        const coll = collForOp(db, handle, DbOp.CapacityReserve, CollectionFamily.Capacity);
+        if (typeof coll === 'number') return coll;
         const want = BigInt(amount);
         if (want <= 0n) return CODEC_ERR; // BadAmount (edge: -1006)
-        const l = this.capLedger(storeKey(coll, readKey(ref, keyPtr, keyLen)));
+        const key = readKey(ref, keyPtr, keyLen);
+        const idem = readIdem(ref, idemPtr);
+        const ttl = Math.min(Math.max(0, Number(ttlMs)), MAX_RESERVATION_TTL_MS);
+        const requestedId = idem === null ? null : reservationIdFromIdem(coll, key, idem);
+        const l = this.capLedger(storeKey(coll.name, key));
         const now = Date.now();
         this.capPrune(l, now);
+        if (requestedId !== null) {
+            const existing = l.reservations.get(requestedId);
+            if (existing !== undefined) {
+                if (existing.amount !== want) return CONFLICT;
+                const out = Buffer.alloc(8);
+                out.writeBigUInt64LE(requestedId);
+                db.lastResult = out;
+                return out.length;
+            }
+        }
         if (l.total - this.capReserved(l) < want || l.reservations.size >= MAX_RESERVATIONS)
             return ABSENT; // never oversell; bound the reservation count
-        const ttl = Math.min(Math.max(0, Number(ttlMs)), MAX_RESERVATION_TTL_MS);
-        const id = l.nextId++;
+        const id = requestedId ?? l.nextId++;
         l.reservations.set(id, { amount: want, expiresMs: now + ttl, confirmed: false });
         const out = Buffer.alloc(8);
         out.writeBigUInt64LE(id);
@@ -857,9 +1289,9 @@ export class DevDatabase {
         keyLen: number,
         reservationId: number | bigint,
     ): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
-        const l = this.capLedger(storeKey(coll, readKey(ref, keyPtr, keyLen)));
+        const coll = collForOp(db, handle, DbOp.CapacityConfirm, CollectionFamily.Capacity);
+        if (typeof coll === 'number') return coll;
+        const l = this.capLedger(storeKey(coll.name, readKey(ref, keyPtr, keyLen)));
         this.capPrune(l, Date.now());
         const r = l.reservations.get(BigInt(reservationId));
         if (r === undefined) return 0;
@@ -877,9 +1309,9 @@ export class DevDatabase {
         keyLen: number,
         reservationId: number | bigint,
     ): number {
-        const coll = collOf(db, handle);
-        if (coll === null) return INVALID_HANDLE;
-        const l = this.capLedger(storeKey(coll, readKey(ref, keyPtr, keyLen)));
+        const coll = collForOp(db, handle, DbOp.CapacityCancel, CollectionFamily.Capacity);
+        if (typeof coll === 'number') return coll;
+        const l = this.capLedger(storeKey(coll.name, readKey(ref, keyPtr, keyLen)));
         this.capPrune(l, Date.now());
         const id = BigInt(reservationId);
         const r = l.reservations.get(id);
@@ -919,13 +1351,46 @@ export class DevDatabase {
     /** Test-only: clear the stores + catalog + persistence between unit tests. */
     resetForTests(): void {
         this.clear();
-        this.catalog = new Map();
+        this.catalog = { kind: 'no-section' };
         this.persistPath = null;
     }
 
-    /** Test-only: seed the catalog (collection -> current schema_version) directly. */
-    setCatalogForTests(entries: Record<string, number>): void {
-        this.catalog = new Map(Object.entries(entries));
+    /** Test-only: seed the catalog directly. Number values default to record-family entries. */
+    setCatalogForTests(entries: Record<string, CatalogSeedEntry>): void {
+        const collections = new Map<string, DevCollectionHandle>();
+        for (const [name, entry] of Object.entries(entries)) {
+            const schemaVersion = typeof entry === 'number' ? entry : (entry.schemaVersion ?? 0);
+            const family =
+                typeof entry === 'number'
+                    ? CollectionFamily.Record
+                    : (entry.family ?? CollectionFamily.Record);
+            const replication = typeof entry === 'number' ? 0 : (entry.replication ?? 0);
+            const placement = typeof entry === 'number' ? 0 : (entry.placement ?? 0);
+            const fillMaxWaitMs =
+                typeof entry === 'number'
+                    ? DEFAULT_FILL_WAIT_MS
+                    : (entry.fillMaxWaitMs ?? DEFAULT_FILL_WAIT_MS);
+            const fillAllowStale =
+                typeof entry === 'number' ? true : (entry.fillAllowStale ?? true);
+            if (!isCollectionFamily(family)) {
+                this.catalog = { kind: 'malformed' };
+                return;
+            }
+            if (fillMaxWaitMs > MAX_FILL_WAIT_MS) {
+                this.catalog = { kind: 'malformed' };
+                return;
+            }
+            collections.set(name, {
+                name,
+                family,
+                schemaVersion: schemaVersion >>> 0,
+                replication,
+                placement,
+                fillMaxWaitMs,
+                fillAllowStale,
+            });
+        }
+        this.catalog = { kind: 'present', collections };
     }
 }
 
@@ -978,8 +1443,8 @@ export function buildDatabaseImports(
             keyLen: number,
             valPtr: number,
             valLen: number,
-            _idemPtr: number,
-        ): number => devDb.create(ref, db, handle, keyPtr, keyLen, valPtr, valLen),
+            idemPtr: number,
+        ): number => devDb.create(ref, db, handle, keyPtr, keyLen, valPtr, valLen, idemPtr),
 
         'data.patch': (
             handle: number,
@@ -987,18 +1452,18 @@ export function buildDatabaseImports(
             keyLen: number,
             patchPtr: number,
             patchLen: number,
-            _idemPtr: number,
-        ): number => devDb.patch(ref, db, handle, keyPtr, keyLen, patchPtr, patchLen),
+            idemPtr: number,
+        ): number => devDb.patch(ref, db, handle, keyPtr, keyLen, patchPtr, patchLen, idemPtr),
 
-        'data.delete': (handle: number, keyPtr: number, keyLen: number, _idemPtr: number): number =>
-            devDb.delete(ref, db, handle, keyPtr, keyLen),
+        'data.delete': (handle: number, keyPtr: number, keyLen: number, idemPtr: number): number =>
+            devDb.delete(ref, db, handle, keyPtr, keyLen, idemPtr),
 
         'data.get_delete': (
             handle: number,
             keyPtr: number,
             keyLen: number,
-            _idemPtr: number,
-        ): number => devDb.getDelete(ref, db, handle, keyPtr, keyLen),
+            idemPtr: number,
+        ): number => devDb.getDelete(ref, db, handle, keyPtr, keyLen, idemPtr),
 
         'data.unique_lookup': (handle: number, keyPtr: number, keyLen: number): number =>
             devDb.uniqueLookup(ref, db, handle, keyPtr, keyLen),
@@ -1009,8 +1474,8 @@ export function buildDatabaseImports(
             keyLen: number,
             valPtr: number,
             valLen: number,
-            _idemPtr: number,
-        ): number => devDb.uniqueClaim(ref, db, handle, keyPtr, keyLen, valPtr, valLen),
+            idemPtr: number,
+        ): number => devDb.uniqueClaim(ref, db, handle, keyPtr, keyLen, valPtr, valLen, idemPtr),
 
         'data.unique_release': (
             handle: number,
@@ -1075,8 +1540,8 @@ export function buildDatabaseImports(
             keyPtr: number,
             keyLen: number,
             delta: number | bigint,
-            _idemPtr: number,
-        ): number => devDb.counterAdd(ref, db, handle, keyPtr, keyLen, delta),
+            idemPtr: number,
+        ): number => devDb.counterAdd(ref, db, handle, keyPtr, keyLen, delta, idemPtr),
 
         'data.append': (
             handle: number,
@@ -1084,8 +1549,8 @@ export function buildDatabaseImports(
             keyLen: number,
             evPtr: number,
             evLen: number,
-            _idemPtr: number,
-        ): number => devDb.append(ref, db, handle, keyPtr, keyLen, evPtr, evLen),
+            idemPtr: number,
+        ): number => devDb.append(ref, db, handle, keyPtr, keyLen, evPtr, evLen, idemPtr),
 
         'data.append_once': (
             handle: number,
@@ -1104,8 +1569,8 @@ export function buildDatabaseImports(
             keyLen: number,
             valPtr: number,
             valLen: number,
-            _idemPtr: number,
-        ): number => devDb.enqueue(ref, db, handle, keyPtr, keyLen, valPtr, valLen),
+            idemPtr: number,
+        ): number => devDb.enqueue(ref, db, handle, keyPtr, keyLen, valPtr, valLen, idemPtr),
 
         'data.latest': (handle: number, keyPtr: number, keyLen: number, limit: number): number =>
             devDb.latest(ref, db, handle, keyPtr, keyLen, limit),
@@ -1127,8 +1592,8 @@ export function buildDatabaseImports(
             keyLen: number,
             amount: number | bigint,
             ttlMs: number | bigint,
-            _idemPtr: number,
-        ): number => devDb.capacityReserve(ref, db, handle, keyPtr, keyLen, amount, ttlMs),
+            idemPtr: number,
+        ): number => devDb.capacityReserve(ref, db, handle, keyPtr, keyLen, amount, ttlMs, idemPtr),
 
         'data.capacity_confirm': (
             handle: number,
@@ -1151,10 +1616,9 @@ export function buildDatabaseImports(
 
         'data.result_schema_version': (): bigint => devDb.resultSchemaVersion(db),
 
-        // `data.write_allowed() -> i32`: 1 if the current call may write. Used by the
-        // rewrite-on-read convergence after a lazy migration to persist the converged
-        // row. The dev store permits writes, so return 1.
-        'data.write_allowed': (): number => 1,
+        // `data.write_allowed() -> i32`: 1 if the current call may issue the
+        // record patch used by rewrite-on-read migration convergence.
+        'data.write_allowed': (): number => (kindAllows(db.functionKind, DbOp.Patch) ? 1 : 0),
     };
 }
 
@@ -1163,7 +1627,7 @@ export function __resetDbForTests(): void {
     devDb.resetForTests();
 }
 
-/** Test-only: seed the catalog (collection -> current schema_version) directly. */
-export function __setDbCatalogForTests(entries: Record<string, number>): void {
+/** Test-only: seed the catalog directly. Number values default to record-family entries. */
+export function __setDbCatalogForTests(entries: Record<string, CatalogSeedEntry>): void {
     devDb.setCatalogForTests(entries);
 }