toiljs 0.0.58 → 0.0.60

package/build/devserver/db/database.js

@@ -0,0 +1,662 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { DataReader, DataWriter } from 'toiljs/io';
+import { parseCatalog } from './catalog.js';
+import { ABSENT, ALREADY_EXISTS, CODEC_ERR, CONFLICT, INVALID_HANDLE, MAX_KEY, MAX_NAME, MAX_RESERVATION_TTL_MS, MAX_RESERVATIONS, MAX_VALUE, satI64, TOO_MANY_KEYS, TOO_SMALL, } from './types.js';
+function mem(ref) {
+    if (!ref.memory)
+        throw new Error('data host import called before memory was bound');
+    return Buffer.from(ref.memory.buffer);
+}
+function readCopy(ref, ptr, len) {
+    const m = mem(ref);
+    if (ptr < 0 || len < 0 || ptr + len > m.length)
+        throw new Error(`data read out of bounds: ptr=${String(ptr)} len=${String(len)}`);
+    return Buffer.from(m.subarray(ptr, ptr + len));
+}
+function readKey(ref, ptr, len) {
+    if (len > MAX_KEY)
+        throw new Error('data: key too long');
+    return readCopy(ref, ptr, len);
+}
+function storeKey(collection, key) {
+    return collection + '\0' + key.toString('latin1');
+}
+function collOf(db, handle) {
+    return handle >= 0 && handle < db.handles.length ? db.handles[handle] : null;
+}
+export class DevDatabase {
+    store = new Map();
+    views = new Map();
+    members = new Map();
+    counters = new Map();
+    events = new Map();
+    eventDedup = new Map();
+    capacity = new Map();
+    versions = new Map();
+    eventVersions = new Map();
+    memberVersions = new Map();
+    catalog = new Map();
+    persistPath = null;
+    setCatalog(wasm) {
+        this.catalog = parseCatalog(wasm);
+    }
+    stampVersion(coll, sk) {
+        this.versions.set(sk, this.catalog.get(coll) ?? 0);
+    }
+    configurePersistence(filePath) {
+        this.persistPath = filePath;
+        this.load();
+    }
+    persist() {
+        if (this.persistPath === null)
+            return;
+        const snap = {
+            store: {},
+            views: {},
+            members: {},
+            counters: {},
+            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, v] of this.views)
+            snap.views[k] = { v: v.toString('base64'), sv: this.versions.get(k) ?? 0 };
+        for (const [k, m] of this.members) {
+            const o = {};
+            const mv = this.memberVersions.get(k);
+            for (const [mk, mvb] of m)
+                o[mk] = { v: mvb.toString('base64'), sv: mv?.get(mk) ?? 0 };
+            snap.members[k] = o;
+        }
+        for (const [k, v] of this.counters)
+            snap.counters[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 }));
+        }
+        for (const [k, s] of this.eventDedup)
+            snap.eventDedup[k] = [...s];
+        for (const [k, l] of this.capacity)
+            snap.capacity[k] = {
+                total: l.total.toString(),
+                nextId: l.nextId.toString(),
+                reservations: [...l.reservations].map(([id, r]) => [
+                    id.toString(),
+                    { amount: r.amount.toString(), expiresMs: r.expiresMs, confirmed: r.confirmed },
+                ]),
+            };
+        try {
+            fs.mkdirSync(path.dirname(this.persistPath), { recursive: true });
+            const tmp = `${this.persistPath}.${process.pid}.tmp`;
+            fs.writeFileSync(tmp, JSON.stringify(snap));
+            fs.renameSync(tmp, this.persistPath);
+        }
+        catch {
+        }
+    }
+    load() {
+        if (this.persistPath === null)
+            return;
+        let snap;
+        try {
+            snap = JSON.parse(fs.readFileSync(this.persistPath, 'utf8'));
+        }
+        catch {
+            return;
+        }
+        this.clear();
+        for (const [k, e] of Object.entries(snap.store ?? {})) {
+            this.store.set(k, Buffer.from(e.v, 'base64'));
+            this.versions.set(k, e.sv);
+        }
+        for (const [k, e] of Object.entries(snap.views ?? {})) {
+            this.views.set(k, Buffer.from(e.v, 'base64'));
+            this.versions.set(k, e.sv);
+        }
+        for (const [k, m] of Object.entries(snap.members ?? {})) {
+            const map = new Map();
+            const ver = new Map();
+            for (const [mk, e] of Object.entries(m)) {
+                map.set(mk, Buffer.from(e.v, 'base64'));
+                ver.set(mk, e.sv);
+            }
+            this.members.set(k, map);
+            this.memberVersions.set(k, ver);
+        }
+        for (const [k, v] of Object.entries(snap.counters ?? {}))
+            this.counters.set(k, BigInt(v));
+        for (const [k, log] of Object.entries(snap.events ?? {})) {
+            this.events.set(k, log.map((e) => Buffer.from(e.v, 'base64')));
+            this.eventVersions.set(k, log.map((e) => e.sv));
+        }
+        for (const [k, ids] of Object.entries(snap.eventDedup ?? {}))
+            this.eventDedup.set(k, new Set(ids));
+        for (const [k, l] of Object.entries(snap.capacity ?? {})) {
+            const res = new Map();
+            for (const [id, r] of l.reservations)
+                res.set(BigInt(id), {
+                    amount: BigInt(r.amount),
+                    expiresMs: r.expiresMs,
+                    confirmed: r.confirmed,
+                });
+            this.capacity.set(k, {
+                total: BigInt(l.total),
+                nextId: BigInt(l.nextId),
+                reservations: res,
+            });
+        }
+    }
+    clear() {
+        this.store.clear();
+        this.versions.clear();
+        this.views.clear();
+        this.members.clear();
+        this.memberVersions.clear();
+        this.counters.clear();
+        this.eventVersions.clear();
+        this.events.clear();
+        this.eventDedup.clear();
+        this.capacity.clear();
+    }
+    capLedger(sk) {
+        let l = this.capacity.get(sk);
+        if (l === undefined) {
+            l = { total: 0n, reservations: new Map(), nextId: 1n };
+            this.capacity.set(sk, l);
+        }
+        return l;
+    }
+    capPrune(l, nowMs) {
+        for (const [id, r] of l.reservations)
+            if (!r.confirmed && r.expiresMs <= nowMs)
+                l.reservations.delete(id);
+    }
+    capReserved(l) {
+        let sum = 0n;
+        for (const r of l.reservations.values())
+            sum += r.amount;
+        return sum;
+    }
+    resolveCollection(ref, db, namePtr, nameLen, outHandlePtr) {
+        if (nameLen < 0 || nameLen > MAX_NAME)
+            throw new Error('data: collection name too long');
+        const name = readCopy(ref, namePtr, nameLen).toString('utf8');
+        const handle = db.handles.length;
+        db.handles.push(name);
+        const m = mem(ref);
+        if (outHandlePtr < 0 || outHandlePtr + 4 > m.length)
+            throw new Error('data: resolve out-handle out of bounds');
+        m.writeUInt32LE(handle, outHandlePtr);
+        return 0;
+    }
+    get(ref, db, handle, keyPtr, keyLen) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        if (keyLen > MAX_KEY)
+            throw new Error('data: key too long');
+        const sk = storeKey(coll, readKey(ref, keyPtr, keyLen));
+        const v = this.store.get(sk);
+        if (v === undefined)
+            return ABSENT;
+        db.lastResult = v;
+        db.lastResultVersion = this.versions.get(sk) ?? 0;
+        return v.length;
+    }
+    getMany(ref, db, handle, keysPtr, keysLen) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        if (keysLen > MAX_VALUE)
+            throw new Error('data: keys blob too large');
+        const r = new DataReader(readCopy(ref, keysPtr, keysLen));
+        const count = r.readU32();
+        if (count > 1024)
+            return TOO_MANY_KEYS;
+        const w = new DataWriter();
+        w.writeU32(count);
+        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);
+            if (v === undefined) {
+                w.writeU8(0);
+            }
+            else {
+                w.writeU8(1).writeU32(this.versions.get(sk) ?? 0).writeBytes(v);
+            }
+        }
+        db.lastResult = Buffer.from(w.toBytes());
+        return db.lastResult.length;
+    }
+    exists(ref, db, handle, keyPtr, keyLen) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        return this.store.has(storeKey(coll, readKey(ref, keyPtr, keyLen))) ? 1 : 0;
+    }
+    create(ref, db, handle, keyPtr, keyLen, valPtr, valLen) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        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);
+        return 0;
+    }
+    patch(ref, db, handle, keyPtr, keyLen, patchPtr, patchLen) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        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;
+        const v = readCopy(ref, patchPtr, patchLen);
+        this.store.set(sk, v);
+        this.stampVersion(coll, sk);
+        db.lastResult = v;
+        db.lastResultVersion = -1;
+        return v.length;
+    }
+    delete(ref, db, handle, keyPtr, keyLen) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        const sk = storeKey(coll, readKey(ref, keyPtr, keyLen));
+        this.store.delete(sk);
+        this.versions.delete(sk);
+        return 0;
+    }
+    getDelete(ref, db, handle, keyPtr, keyLen) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        const sk = storeKey(coll, readKey(ref, keyPtr, keyLen));
+        const v = this.store.get(sk);
+        if (v === undefined)
+            return ABSENT;
+        db.lastResultVersion = this.versions.get(sk) ?? 0;
+        this.store.delete(sk);
+        this.versions.delete(sk);
+        db.lastResult = v;
+        return v.length;
+    }
+    uniqueLookup(ref, db, handle, keyPtr, keyLen) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        const sk = storeKey(coll, readKey(ref, keyPtr, keyLen));
+        const v = this.store.get(sk);
+        if (v === undefined)
+            return ABSENT;
+        db.lastResult = v;
+        db.lastResultVersion = this.versions.get(sk) ?? 0;
+        return v.length;
+    }
+    uniqueClaim(ref, db, handle, keyPtr, keyLen, valPtr, valLen) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        if (keyLen > MAX_KEY || valLen > MAX_VALUE)
+            throw new Error('data: key/value too large');
+        const sk = storeKey(coll, readKey(ref, keyPtr, keyLen));
+        const owner = readCopy(ref, valPtr, valLen);
+        const existing = this.store.get(sk);
+        if (existing === undefined) {
+            this.store.set(sk, owner);
+            this.stampVersion(coll, sk);
+            return 0;
+        }
+        if (existing.equals(owner))
+            return 2;
+        db.lastResult = existing;
+        return 1;
+    }
+    uniqueRelease(ref, db, handle, keyPtr, keyLen, valPtr, valLen) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        const sk = storeKey(coll, readKey(ref, keyPtr, keyLen));
+        const existing = this.store.get(sk);
+        if (existing === undefined)
+            return 0;
+        if (!existing.equals(readCopy(ref, valPtr, valLen)))
+            return CONFLICT;
+        this.store.delete(sk);
+        this.versions.delete(sk);
+        return 0;
+    }
+    membershipContains(ref, db, handle, setPtr, setLen, memberPtr, memberLen) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        const set = this.members.get(storeKey(coll, readKey(ref, setPtr, setLen)));
+        if (set === undefined)
+            return 0;
+        return set.has(readCopy(ref, memberPtr, memberLen).toString('latin1')) ? 1 : 0;
+    }
+    membershipAdd(ref, db, handle, setPtr, setLen, memberPtr, memberLen) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        if (setLen > MAX_KEY || memberLen > MAX_VALUE)
+            throw new Error('data: set/member too large');
+        const sk = storeKey(coll, readKey(ref, setPtr, setLen));
+        const member = readCopy(ref, memberPtr, memberLen);
+        let set = this.members.get(sk);
+        if (set === undefined) {
+            set = new Map();
+            this.members.set(sk, set);
+        }
+        const ml = member.toString('latin1');
+        set.set(ml, member);
+        let mv = this.memberVersions.get(sk);
+        if (mv === undefined) {
+            mv = new Map();
+            this.memberVersions.set(sk, mv);
+        }
+        mv.set(ml, this.catalog.get(coll) ?? 0);
+        return 0;
+    }
+    membershipRemove(ref, db, handle, setPtr, setLen, memberPtr, memberLen) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        const sk = storeKey(coll, readKey(ref, setPtr, setLen));
+        const ml = readCopy(ref, memberPtr, memberLen).toString('latin1');
+        this.members.get(sk)?.delete(ml);
+        this.memberVersions.get(sk)?.delete(ml);
+        return 0;
+    }
+    membershipList(ref, db, handle, setPtr, setLen, limit) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        const sk = storeKey(coll, 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));
+        const members = set === undefined ? [] : Array.from(set.values()).sort(Buffer.compare).slice(0, n);
+        const w = new DataWriter();
+        w.writeU32(members.length);
+        for (const m of members) {
+            w.writeU32(mv?.get(m.toString('latin1')) ?? 0).writeBytes(m);
+        }
+        db.lastResult = Buffer.from(w.toBytes());
+        return db.lastResult.length;
+    }
+    viewGet(ref, db, handle, keyPtr, keyLen) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        const sk = storeKey(coll, readKey(ref, keyPtr, keyLen));
+        const v = this.views.get(sk);
+        if (v === undefined)
+            return ABSENT;
+        db.lastResult = v;
+        db.lastResultVersion = this.versions.get(sk) ?? 0;
+        return v.length;
+    }
+    viewPublish(ref, db, handle, keyPtr, keyLen, valPtr, valLen) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        if (keyLen > MAX_KEY || valLen > MAX_VALUE)
+            throw new Error('data: key/view too large');
+        const sk = storeKey(coll, readKey(ref, keyPtr, keyLen));
+        this.views.set(sk, readCopy(ref, valPtr, valLen));
+        this.stampVersion(coll, sk);
+        return 0;
+    }
+    counterGet(ref, db, handle, keyPtr, keyLen) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        const sum = this.counters.get(storeKey(coll, readKey(ref, keyPtr, keyLen))) ?? 0n;
+        const out = Buffer.alloc(8);
+        out.writeBigInt64LE(sum);
+        db.lastResult = out;
+        return out.length;
+    }
+    counterAdd(ref, db, handle, keyPtr, keyLen, delta) {
+        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)));
+        return 0;
+    }
+    append(ref, db, handle, keyPtr, keyLen, evPtr, evLen) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        if (keyLen > MAX_KEY || evLen > MAX_VALUE)
+            throw new Error('data: key/event too large');
+        const sk = storeKey(coll, readKey(ref, keyPtr, keyLen));
+        const log = this.events.get(sk);
+        const ev = readCopy(ref, evPtr, evLen);
+        const sv = this.catalog.get(coll) ?? 0;
+        if (log === undefined) {
+            this.events.set(sk, [ev]);
+            this.eventVersions.set(sk, [sv]);
+        }
+        else {
+            log.push(ev);
+            (this.eventVersions.get(sk) ?? this.eventVersions.set(sk, []).get(sk)).push(sv);
+        }
+        return 0;
+    }
+    appendOnce(ref, db, handle, keyPtr, keyLen, evidPtr, evidLen, evPtr, evLen) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        if (keyLen > MAX_KEY || evLen > MAX_VALUE)
+            throw new Error('data: key/event too large');
+        const sk = storeKey(coll, readKey(ref, keyPtr, keyLen));
+        const evid = readCopy(ref, evidPtr, evidLen).toString('latin1');
+        let seen = this.eventDedup.get(sk);
+        if (seen === undefined) {
+            seen = new Set();
+            this.eventDedup.set(sk, seen);
+        }
+        if (seen.has(evid))
+            return 0;
+        const ev = readCopy(ref, evPtr, evLen);
+        const sv = this.catalog.get(coll) ?? 0;
+        const log = this.events.get(sk);
+        if (log === undefined) {
+            this.events.set(sk, [ev]);
+            this.eventVersions.set(sk, [sv]);
+        }
+        else {
+            log.push(ev);
+            (this.eventVersions.get(sk) ?? this.eventVersions.set(sk, []).get(sk)).push(sv);
+        }
+        seen.add(evid);
+        return 1;
+    }
+    enqueue(ref, db, handle, keyPtr, keyLen, valPtr, valLen) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        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;
+        this.store.set(sk, readCopy(ref, valPtr, valLen));
+        this.stampVersion(coll, sk);
+        return 0;
+    }
+    latest(ref, db, handle, keyPtr, keyLen, limit) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        const sk = storeKey(coll, 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));
+        const start = Math.max(0, log.length - n);
+        const newest = log.slice(start).reverse();
+        const newestVers = vers.slice(start).reverse();
+        const w = new DataWriter();
+        w.writeU32(newest.length);
+        for (let i = 0; i < newest.length; i++) {
+            w.writeU32(newestVers[i] ?? 0).writeBytes(newest[i]);
+        }
+        db.lastResult = Buffer.from(w.toBytes());
+        return db.lastResult.length;
+    }
+    capacitySetTotal(ref, db, handle, keyPtr, keyLen, total) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        const l = this.capLedger(storeKey(coll, readKey(ref, keyPtr, keyLen)));
+        const t = BigInt(total);
+        l.total = satI64(t < 0n ? 0n : t);
+        return 0;
+    }
+    capacityAvailable(ref, db, handle, keyPtr, keyLen) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        const l = this.capLedger(storeKey(coll, readKey(ref, keyPtr, keyLen)));
+        this.capPrune(l, Date.now());
+        const avail = l.total - this.capReserved(l);
+        const out = Buffer.alloc(8);
+        out.writeBigInt64LE(avail < 0n ? 0n : avail);
+        db.lastResult = out;
+        return out.length;
+    }
+    capacityReserve(ref, db, handle, keyPtr, keyLen, amount, ttlMs) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        const want = BigInt(amount);
+        if (want <= 0n)
+            return CODEC_ERR;
+        const l = this.capLedger(storeKey(coll, readKey(ref, keyPtr, keyLen)));
+        const now = Date.now();
+        this.capPrune(l, now);
+        if (l.total - this.capReserved(l) < want || l.reservations.size >= MAX_RESERVATIONS)
+            return ABSENT;
+        const ttl = Math.min(Math.max(0, Number(ttlMs)), MAX_RESERVATION_TTL_MS);
+        const id = l.nextId++;
+        l.reservations.set(id, { amount: want, expiresMs: now + ttl, confirmed: false });
+        const out = Buffer.alloc(8);
+        out.writeBigUInt64LE(id);
+        db.lastResult = out;
+        return out.length;
+    }
+    capacityConfirm(ref, db, handle, keyPtr, keyLen, reservationId) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        const l = this.capLedger(storeKey(coll, readKey(ref, keyPtr, keyLen)));
+        this.capPrune(l, Date.now());
+        const r = l.reservations.get(BigInt(reservationId));
+        if (r === undefined)
+            return 0;
+        r.confirmed = true;
+        return 1;
+    }
+    capacityCancel(ref, db, handle, keyPtr, keyLen, reservationId) {
+        const coll = collOf(db, handle);
+        if (coll === null)
+            return INVALID_HANDLE;
+        const l = this.capLedger(storeKey(coll, readKey(ref, keyPtr, keyLen)));
+        this.capPrune(l, Date.now());
+        const id = BigInt(reservationId);
+        const r = l.reservations.get(id);
+        if (r === undefined || r.confirmed)
+            return 0;
+        l.reservations.delete(id);
+        return 1;
+    }
+    takeResult(ref, db, outPtr, outCap) {
+        const v = db.lastResult;
+        if (v === null)
+            return 0;
+        if (v.length > outCap)
+            return TOO_SMALL;
+        const m = mem(ref);
+        if (outPtr < 0 || outPtr + v.length > m.length)
+            throw new Error('data: take_result out of bounds');
+        v.copy(m, outPtr);
+        db.lastResult = null;
+        return v.length;
+    }
+    resultSchemaVersion(db) {
+        return BigInt(db.lastResultVersion);
+    }
+    resetForTests() {
+        this.clear();
+        this.catalog = new Map();
+        this.persistPath = null;
+    }
+    setCatalogForTests(entries) {
+        this.catalog = new Map(Object.entries(entries));
+    }
+}
+export const devDb = new DevDatabase();
+export function setDbCatalog(wasm) {
+    devDb.setCatalog(wasm);
+}
+export function configureDbPersistence(filePath) {
+    devDb.configurePersistence(filePath);
+}
+export function persistDb() {
+    devDb.persist();
+}
+export function buildDatabaseImports(ref, db) {
+    return {
+        'data.resolve_collection': (namePtr, nameLen, outHandlePtr) => devDb.resolveCollection(ref, db, namePtr, nameLen, outHandlePtr),
+        'data.get': (handle, keyPtr, keyLen) => devDb.get(ref, db, handle, keyPtr, keyLen),
+        'data.get_many': (handle, keysPtr, keysLen) => devDb.getMany(ref, db, handle, keysPtr, keysLen),
+        'data.exists': (handle, keyPtr, keyLen) => devDb.exists(ref, db, handle, keyPtr, keyLen),
+        'data.create': (handle, keyPtr, keyLen, valPtr, valLen, _idemPtr) => devDb.create(ref, db, handle, keyPtr, keyLen, valPtr, valLen),
+        'data.patch': (handle, keyPtr, keyLen, patchPtr, patchLen, _idemPtr) => devDb.patch(ref, db, handle, keyPtr, keyLen, patchPtr, patchLen),
+        'data.delete': (handle, keyPtr, keyLen, _idemPtr) => devDb.delete(ref, db, handle, keyPtr, keyLen),
+        'data.get_delete': (handle, keyPtr, keyLen, _idemPtr) => devDb.getDelete(ref, db, handle, keyPtr, keyLen),
+        'data.unique_lookup': (handle, keyPtr, keyLen) => devDb.uniqueLookup(ref, db, handle, keyPtr, keyLen),
+        'data.unique_claim': (handle, keyPtr, keyLen, valPtr, valLen, _idemPtr) => devDb.uniqueClaim(ref, db, handle, keyPtr, keyLen, valPtr, valLen),
+        'data.unique_release': (handle, keyPtr, keyLen, valPtr, valLen, _idemPtr) => devDb.uniqueRelease(ref, db, handle, keyPtr, keyLen, valPtr, valLen),
+        'data.membership_contains': (handle, setPtr, setLen, memberPtr, memberLen) => devDb.membershipContains(ref, db, handle, setPtr, setLen, memberPtr, memberLen),
+        'data.membership_add': (handle, setPtr, setLen, memberPtr, memberLen, _idemPtr) => devDb.membershipAdd(ref, db, handle, setPtr, setLen, memberPtr, memberLen),
+        'data.membership_remove': (handle, setPtr, setLen, memberPtr, memberLen, _idemPtr) => devDb.membershipRemove(ref, db, handle, setPtr, setLen, memberPtr, memberLen),
+        'data.membership_list': (handle, setPtr, setLen, limit) => devDb.membershipList(ref, db, handle, setPtr, setLen, limit),
+        'data.view_get': (handle, keyPtr, keyLen) => devDb.viewGet(ref, db, handle, keyPtr, keyLen),
+        'data.view_publish': (handle, keyPtr, keyLen, valPtr, valLen, _idemPtr) => devDb.viewPublish(ref, db, handle, keyPtr, keyLen, valPtr, valLen),
+        'data.counter_get': (handle, keyPtr, keyLen) => devDb.counterGet(ref, db, handle, keyPtr, keyLen),
+        'data.counter_add': (handle, keyPtr, keyLen, delta, _idemPtr) => devDb.counterAdd(ref, db, handle, keyPtr, keyLen, delta),
+        'data.append': (handle, keyPtr, keyLen, evPtr, evLen, _idemPtr) => devDb.append(ref, db, handle, keyPtr, keyLen, evPtr, evLen),
+        'data.append_once': (handle, keyPtr, keyLen, evidPtr, evidLen, evPtr, evLen) => devDb.appendOnce(ref, db, handle, keyPtr, keyLen, evidPtr, evidLen, evPtr, evLen),
+        'data.enqueue': (handle, keyPtr, keyLen, valPtr, valLen, _idemPtr) => devDb.enqueue(ref, db, handle, keyPtr, keyLen, valPtr, valLen),
+        'data.latest': (handle, keyPtr, keyLen, limit) => devDb.latest(ref, db, handle, keyPtr, keyLen, limit),
+        'data.capacity_set_total': (handle, keyPtr, keyLen, total, _idemPtr) => devDb.capacitySetTotal(ref, db, handle, keyPtr, keyLen, total),
+        'data.capacity_available': (handle, keyPtr, keyLen) => devDb.capacityAvailable(ref, db, handle, keyPtr, keyLen),
+        'data.capacity_reserve': (handle, keyPtr, keyLen, amount, ttlMs, _idemPtr) => devDb.capacityReserve(ref, db, handle, keyPtr, keyLen, amount, ttlMs),
+        'data.capacity_confirm': (handle, keyPtr, keyLen, reservationId, _idemPtr) => devDb.capacityConfirm(ref, db, handle, keyPtr, keyLen, reservationId),
+        'data.capacity_cancel': (handle, keyPtr, keyLen, reservationId, _idemPtr) => devDb.capacityCancel(ref, db, handle, keyPtr, keyLen, reservationId),
+        'data.take_result': (outPtr, outCap) => devDb.takeResult(ref, db, outPtr, outCap),
+        'data.result_schema_version': () => devDb.resultSchemaVersion(db),
+        'data.write_allowed': () => 1,
+    };
+}
+export function __resetDbForTests() {
+    devDb.resetForTests();
+}
+export function __setDbCatalogForTests(entries) {
+    devDb.setCatalogForTests(entries);
+}

package/build/devserver/db/index.d.ts

@@ -0,0 +1,3 @@
+export { __resetDbForTests, __setDbCatalogForTests, buildDatabaseImports, configureDbPersistence, DevDatabase, devDb, persistDb, setDbCatalog, } from './database.js';
+export { parseCatalog } from './catalog.js';
+export { type DbDevState, freshDbState } from './types.js';

package/build/devserver/db/index.js

@@ -0,0 +1,3 @@
+export { __resetDbForTests, __setDbCatalogForTests, buildDatabaseImports, configureDbPersistence, DevDatabase, devDb, persistDb, setDbCatalog, } from './database.js';
+export { parseCatalog } from './catalog.js';
+export { freshDbState } from './types.js';