toiljs 0.0.60 → 0.0.61

package/build/devserver/daemon/host.js

@@ -0,0 +1,94 @@
+import { buildDatabaseImports, freshDbState } from '../db/index.js';
+import { buildCryptoImports, freshCryptoState } from '../runtime/crypto.js';
+import { buildEnvImports, readBytes, writeBytesOut, } from '../runtime/host.js';
+export var AbiError;
+(function (AbiError) {
+    AbiError[AbiError["MstoreNotFound"] = 769] = "MstoreNotFound";
+    AbiError[AbiError["MstoreNotANumber"] = 774] = "MstoreNotANumber";
+    AbiError[AbiError["MstoreScanBusy"] = 775] = "MstoreScanBusy";
+    AbiError[AbiError["MstoreConflict"] = 772] = "MstoreConflict";
+    AbiError[AbiError["DaemonScheduleRejected"] = 1027] = "DaemonScheduleRejected";
+    AbiError[AbiError["DaemonCallFailed"] = 1029] = "DaemonCallFailed";
+})(AbiError || (AbiError = {}));
+export function encodeAbiError(code) {
+    return -(0x10000 + code);
+}
+export function buildMstoreImports(ref, store) {
+    const key = (p, l) => readBytes(ref, p, l).toString('utf8');
+    return {
+        'mstore.get': (keyPtr, keyLen, outPtr, outCap) => {
+            const v = store.get(key(keyPtr, keyLen));
+            if (v === null)
+                return encodeAbiError(769);
+            return writeBytesOut(ref, v, outPtr, outCap);
+        },
+        'mstore.set': (keyPtr, keyLen, valPtr, valLen, ttlSecs) => {
+            store.set(key(keyPtr, keyLen), readBytes(ref, valPtr, valLen), ttlSecs);
+            return 0;
+        },
+        'mstore.delete': (keyPtr, keyLen) => store.delete(key(keyPtr, keyLen)) ? 0 : encodeAbiError(769),
+        'mstore.incr': (keyPtr, keyLen, delta, ttlSecs) => {
+            const d = typeof delta === 'bigint' ? delta : BigInt(delta);
+            const next = store.incr(key(keyPtr, keyLen), d, ttlSecs);
+            return next === null ? BigInt(encodeAbiError(774)) : next;
+        },
+        'mstore.cas': (keyPtr, keyLen, expectPtr, expectLen, newPtr, newLen, ttlSecs) => {
+            const expect = expectLen === 0 ? null : readBytes(ref, expectPtr, expectLen);
+            const ok = store.cas(key(keyPtr, keyLen), expect, readBytes(ref, newPtr, newLen), ttlSecs);
+            return ok ? 0 : encodeAbiError(772);
+        },
+        'mstore.expire': (keyPtr, keyLen, ttlSecs) => store.expire(key(keyPtr, keyLen), ttlSecs)
+            ? 0
+            : encodeAbiError(769),
+        'mstore.scan': (prefixPtr, prefixLen, cursor, outPtr, outCap) => {
+            const cur = typeof cursor === 'bigint' ? cursor : BigInt(cursor);
+            const res = store.scan(key(prefixPtr, prefixLen), cur);
+            if (res === null)
+                return BigInt(encodeAbiError(775));
+            let total = 4;
+            for (const k of res.keys)
+                total += 4 + Buffer.byteLength(k, 'utf8');
+            const frame = Buffer.alloc(total);
+            let o = frame.writeUInt32LE(res.keys.length, 0);
+            for (const k of res.keys) {
+                const kb = Buffer.from(k, 'utf8');
+                o = frame.writeUInt32LE(kb.length, o);
+                kb.copy(frame, o);
+                o += kb.length;
+            }
+            const len = writeBytesOut(ref, frame, outPtr, outCap);
+            if (len < 0)
+                return BigInt(len);
+            return (res.next << 32n) | BigInt(len);
+        },
+    };
+}
+export function buildDaemonNamespace(rt) {
+    return {
+        'daemon.is_leader': () => (rt.isLeader() ? 1 : 0),
+        'daemon.current_epoch': () => rt.epoch(),
+        'daemon.yield': () => 0,
+        'daemon.sleep_ms': (_ms) => 0,
+        'daemon.task_count': () => rt.taskCount(),
+        'daemon.next_fire_ms': (taskId) => {
+            const at = rt.nextFireMs(taskId);
+            return at === null ? BigInt(encodeAbiError(1027)) : BigInt(at);
+        },
+        'daemon.http_call': (_reqPtr, _reqLen, _outPtr, _outCap) => BigInt(encodeAbiError(1029)),
+        'daemon.remote_call': (_svcId, _reqPtr, _reqLen, _outPtr, _outCap) => BigInt(encodeAbiError(1029)),
+    };
+}
+export function freshDaemonState() {
+    return { crypto: freshCryptoState(), db: freshDbState() };
+}
+export function buildDaemonImports(ref, state, rt, store) {
+    return {
+        env: {
+            ...buildEnvImports(ref, state),
+            ...buildCryptoImports(ref, state.crypto),
+            ...buildDatabaseImports(ref, state.db),
+            ...buildDaemonNamespace(rt),
+            ...buildMstoreImports(ref, store),
+        },
+    };
+}

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

@@ -0,0 +1,34 @@
+import { type ScheduledTask } from './catalog.js';
+import { type DaemonRuntime, type ResolvedDaemonConfig } from './host.js';
+export declare function daemonEmulationEnabled(nodeMode: string): boolean;
+export declare class DaemonHost implements DaemonRuntime {
+    private readonly coldWasmPath;
+    private readonly cfg;
+    private readonly nodeMode;
+    private readonly log;
+    private module;
+    private instance;
+    private exports;
+    private state;
+    private catalog;
+    private loadedMtimeMs;
+    private running;
+    private epochValue;
+    private timers;
+    private nextFire;
+    private ticking;
+    constructor(coldWasmPath: string, cfg: ResolvedDaemonConfig, nodeMode: string, log?: (s: string) => void);
+    get active(): boolean;
+    get tasks(): readonly ScheduledTask[];
+    isLeader(): boolean;
+    epoch(): bigint;
+    taskCount(): number;
+    nextFireMs(taskId: number): number | null;
+    refresh(): boolean;
+    private start;
+    private stop;
+    private registerTask;
+    private armCron;
+    private runTick;
+    close(): void;
+}

package/build/devserver/daemon/index.js

@@ -0,0 +1,241 @@
+import fs from 'node:fs';
+import pc from 'picocolors';
+import { devMemoryStore } from '../mstore/store.js';
+import { parseSurface } from '../wasm/surface.js';
+import { parseDaemonCatalog, } from './catalog.js';
+import { cronMatches, cronNeverFires, nextCronFireMs } from './cron.js';
+import { buildDaemonImports, freshDaemonState, } from './host.js';
+function decodeAbiError(ret) {
+    if (ret >= 0n)
+        return 'ok';
+    if (ret === -1n)
+        return 'STATUS_TOO_SMALL';
+    if (ret === -2n)
+        return 'STATUS_ABSENT';
+    if (ret <= -0x10000n)
+        return '0x' + ((-ret - 0x10000n) & 0xffffn).toString(16).padStart(4, '0');
+    if (ret <= -1000n)
+        return 'DB(TDL ' + String(-ret - 1000n) + ')';
+    return String(ret);
+}
+export function daemonEmulationEnabled(nodeMode) {
+    return nodeMode === 'daemon' || nodeMode === 'all';
+}
+export class DaemonHost {
+    coldWasmPath;
+    cfg;
+    nodeMode;
+    log;
+    module = null;
+    instance = null;
+    exports = null;
+    state = freshDaemonState();
+    catalog = null;
+    loadedMtimeMs = -1;
+    running = false;
+    epochValue = 0n;
+    timers = new Map();
+    nextFire = new Map();
+    ticking = new Set();
+    constructor(coldWasmPath, cfg, nodeMode, log = (s) => process.stdout.write(s)) {
+        this.coldWasmPath = coldWasmPath;
+        this.cfg = cfg;
+        this.nodeMode = nodeMode;
+        this.log = log;
+    }
+    get active() {
+        return this.running;
+    }
+    get tasks() {
+        return this.catalog?.tasks ?? [];
+    }
+    isLeader() {
+        return true;
+    }
+    epoch() {
+        return this.epochValue;
+    }
+    taskCount() {
+        return this.catalog?.tasks.length ?? 0;
+    }
+    nextFireMs(taskId) {
+        return this.nextFire.get(taskId) ?? null;
+    }
+    refresh() {
+        if (!daemonEmulationEnabled(this.nodeMode))
+            return false;
+        let mtimeMs;
+        try {
+            mtimeMs = fs.statSync(this.coldWasmPath).mtimeMs;
+        }
+        catch {
+            if (this.running)
+                this.stop();
+            this.module = null;
+            this.loadedMtimeMs = -1;
+            return false;
+        }
+        if (this.module !== null && mtimeMs === this.loadedMtimeMs)
+            return false;
+        const bytes = fs.readFileSync(this.coldWasmPath);
+        const surface = parseSurface(bytes);
+        if (surface === 'invalid') {
+            this.log(pc.red('  ✗ cold artifact toil.surface is corrupt; daemon not started') + '\n');
+            if (this.running)
+                this.stop();
+            this.loadedMtimeMs = mtimeMs;
+            return false;
+        }
+        if (surface !== 'absent' && surface.targetMode !== 'cold')
+            this.log(pc.yellow('  ! ') +
+                pc.dim('cold slot holds a hot-mode artifact; ignoring daemon emulator') +
+                '\n');
+        const catalog = parseDaemonCatalog(bytes);
+        const declaresDaemon = (surface === 'absent' ? false : surface.flags.daemon) || (catalog?.hasDaemon ?? false);
+        if (this.running)
+            this.stop();
+        if (!declaresDaemon || catalog === null || !catalog.hasDaemon) {
+            this.module = null;
+            this.catalog = null;
+            this.loadedMtimeMs = mtimeMs;
+            return false;
+        }
+        this.module = new WebAssembly.Module(bytes);
+        this.catalog = catalog;
+        this.loadedMtimeMs = mtimeMs;
+        this.epochValue += 1n;
+        this.start();
+        return true;
+    }
+    start() {
+        if (this.module === null || this.catalog === null)
+            return;
+        const ref = { memory: null };
+        this.state = freshDaemonState();
+        const imports = buildDaemonImports(ref, this.state, this, devMemoryStore);
+        const provided = new Set(Object.keys(imports.env));
+        const missing = WebAssembly.Module.imports(this.module)
+            .filter((i) => i.kind === 'function' && (i.module !== 'env' || !provided.has(i.name)))
+            .map((i) => `${i.module}.${i.name}`);
+        if (missing.length > 0) {
+            this.log(pc.red(`  ✗ cold daemon wasm imports unsupported host functions: ${missing.join(', ')}`) + '\n');
+            this.module = null;
+            return;
+        }
+        this.instance = new WebAssembly.Instance(this.module, imports);
+        this.exports = this.instance.exports;
+        ref.memory = this.exports.memory;
+        try {
+            if (typeof this.exports.init === 'function')
+                this.exports.init();
+            const rc = this.exports.daemon_start();
+            if (rc !== 0) {
+                this.log(pc.red(`  ✗ daemon_start() returned ${String(rc)}; daemon not running`) + '\n');
+                this.instance = null;
+                this.exports = null;
+                return;
+            }
+        }
+        catch (e) {
+            this.log(pc.red(`  ✗ daemon_start() trapped: ${String(e)}`) + '\n');
+            this.instance = null;
+            this.exports = null;
+            return;
+        }
+        this.running = true;
+        const limited = this.catalog.tasks.slice(0, this.cfg.maxTasks);
+        for (const task of limited)
+            this.registerTask(task);
+        this.log(pc.green('  ⏱ ') +
+            pc.dim(`daemon started (epoch ${String(this.epochValue)}, ${String(limited.length)} task${limited.length === 1 ? '' : 's'})`) +
+            '\n');
+    }
+    stop() {
+        for (const t of this.timers.values())
+            clearTimeout(t);
+        this.timers.clear();
+        this.nextFire.clear();
+        const stop = this.exports?.daemon_stop;
+        if (typeof stop === 'function') {
+            try {
+                stop();
+            }
+            catch {
+            }
+        }
+        this.instance = null;
+        this.exports = null;
+        this.running = false;
+    }
+    registerTask(task) {
+        if (task.schedule.kind === 'interval') {
+            const ms = Math.max(1000, task.schedule.ms || this.cfg.defaultIntervalMs);
+            this.nextFire.set(task.taskIndex, Date.now() + ms);
+            const handle = setInterval(() => {
+                this.nextFire.set(task.taskIndex, Date.now() + ms);
+                this.runTick(task);
+            }, ms);
+            handle.unref?.();
+            this.timers.set(task.taskIndex, handle);
+        }
+        else {
+            const masks = task.schedule.masks;
+            if (cronNeverFires(masks)) {
+                this.log(pc.yellow('  ! ') +
+                    pc.dim(`@scheduled ${task.name} has an unsatisfiable cron mask; skipping (DAEMON_SCHEDULE_REJECTED)`) +
+                    '\n');
+                return;
+            }
+            this.armCron(task, masks);
+        }
+    }
+    armCron(task, masks) {
+        const next = nextCronFireMs(masks, Date.now());
+        if (next === null) {
+            this.nextFire.delete(task.taskIndex);
+            return;
+        }
+        this.nextFire.set(task.taskIndex, next);
+        const delay = Math.max(0, next - Date.now());
+        const handle = setTimeout(() => {
+            if (cronMatches(masks, new Date()))
+                this.runTick(task);
+            if (this.running)
+                this.armCron(task, masks);
+        }, delay);
+        handle.unref?.();
+        this.timers.set(task.taskIndex, handle);
+    }
+    runTick(task) {
+        if (!this.running || this.exports === null)
+            return;
+        if (this.ticking.has(task.taskIndex)) {
+            this.log(pc.dim(`  ⏱ @scheduled ${task.name} overran its interval; skipping a tick`) + '\n');
+            return;
+        }
+        if (!this.isLeader())
+            return;
+        this.ticking.add(task.taskIndex);
+        const startedAt = Date.now();
+        try {
+            const ret = this.exports.scheduled_tick(task.taskIndex);
+            if (ret < 0n)
+                this.log(pc.yellow(`  ⏱ @scheduled ${task.name} returned error ${decodeAbiError(ret)}`) + '\n');
+        }
+        catch (e) {
+            this.log(pc.red(`  ✗ @scheduled ${task.name} trapped: ${String(e)}`) + '\n');
+        }
+        finally {
+            const took = Date.now() - startedAt;
+            if (took > this.cfg.tickBudgetMs)
+                this.log(pc.yellow(`  ⏱ @scheduled ${task.name} took ${String(took)}ms (> tickBudgetMs ${String(this.cfg.tickBudgetMs)})`) + '\n');
+            this.ticking.delete(task.taskIndex);
+        }
+    }
+    close() {
+        if (this.running)
+            this.stop();
+        this.module = null;
+        this.catalog = null;
+    }
+}

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

@@ -1 +1,2 @@
-export declare function parseCatalog(wasm: Buffer): Map<string, number>;
+import { type DbCatalogState } from './types.js';
+export declare function parseCatalog(wasm: Buffer): DbCatalogState;

package/build/devserver/db/catalog.js

@@ -1,68 +1,51 @@
 import { DataReader } from 'toiljs/io';
-function leb(buf, pos) {
-    let result = 0;
-    let shift = 0;
-    let p = pos;
-    for (;;) {
-        if (p >= buf.length)
-            throw new RangeError('leb128 past end of buffer');
-        const b = buf[p++];
-        result |= (b & 0x7f) << shift;
-        if ((b & 0x80) === 0)
-            break;
-        shift += 7;
-        if (shift > 35)
-            throw new RangeError('leb128 too long');
-    }
-    return [result >>> 0, p];
+import { customSection } from '../wasm/sections.js';
+import { DEFAULT_FILL_WAIT_MS, isCollectionFamily, MAX_FILL_WAIT_MS, } from './types.js';
+function validReplication(value) {
+    return value >= 0 && value <= 5;
 }
-function customSection(wasm, want) {
-    let pos = 8;
-    while (pos < wasm.length) {
-        const id = wasm[pos++];
-        let size;
-        [size, pos] = leb(wasm, pos);
-        const end = pos + size;
-        if (end > wasm.length || end < pos)
-            return null;
-        if (id === 0) {
-            let nameLen;
-            let namePos;
-            [nameLen, namePos] = leb(wasm, pos);
-            if (namePos + nameLen <= end && wasm.toString('latin1', namePos, namePos + nameLen) === want)
-                return wasm.subarray(namePos + nameLen, end);
-        }
-        pos = end;
-    }
-    return null;
+function validPlacement(value) {
+    return value === 0 || value === 1;
 }
 export function parseCatalog(wasm) {
-    const out = new Map();
+    const collections = new Map();
     let sec;
     try {
         sec = customSection(wasm, 'toildb.catalog');
     }
     catch {
-        return out;
+        return { kind: 'no-section' };
     }
     if (sec === null)
-        return out;
+        return { kind: 'no-section' };
     const r = new DataReader(sec);
-    r.readU16();
+    const version = r.readU16();
+    if (!r.ok || (version !== 1 && version !== 2))
+        return { kind: 'malformed' };
     const ndb = r.readU16();
     for (let d = 0; d < ndb && r.ok; d++) {
         const db = r.readString();
         const nc = r.readU16();
         for (let c = 0; c < nc && r.ok; c++) {
             const name = r.readString();
-            r.readU8();
+            const family = r.readU8();
             r.readString();
             r.readString();
             r.readU32();
             const schemaVersion = r.readU32();
             r.readU32();
-            r.readU8();
-            r.readU8();
+            const replication = r.readU8();
+            const placement = r.readU8();
+            let fillMaxWaitMs = DEFAULT_FILL_WAIT_MS;
+            let fillAllowStale = true;
+            if (version >= 2) {
+                fillMaxWaitMs = r.readU32();
+                const fillAllowStaleByte = r.readU8();
+                if (fillMaxWaitMs > MAX_FILL_WAIT_MS ||
+                    (fillAllowStaleByte !== 0 && fillAllowStaleByte !== 1))
+                    return { kind: 'malformed' };
+                fillAllowStale = fillAllowStaleByte === 1;
+            }
             const nFields = r.readU16();
             for (let f = 0; f < nFields; f++) {
                 r.readString();
@@ -72,9 +55,26 @@ export function parseCatalog(wasm) {
             const nMig = r.readU16();
             for (let m = 0; m < nMig; m++)
                 r.readU32();
+            if (!isCollectionFamily(family) ||
+                !validReplication(replication) ||
+                !validPlacement(placement))
+                return { kind: 'malformed' };
+            const key = db + '/' + name;
+            if (collections.has(key))
+                return { kind: 'malformed' };
             if (r.ok)
-                out.set(db + '/' + name, schemaVersion >>> 0);
+                collections.set(key, {
+                    name: key,
+                    family: family,
+                    schemaVersion: schemaVersion >>> 0,
+                    replication,
+                    placement,
+                    fillMaxWaitMs,
+                    fillAllowStale,
+                });
         }
     }
-    return out;
+    if (!r.ok || r.remaining() !== 0)
+        return { kind: 'malformed' };
+    return { kind: 'present', collections };
 }

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

@@ -1,10 +1,21 @@
 import type { MemoryRef } from '../runtime/host.js';
 import { type DbDevState } from './types.js';
+type CatalogSeedEntry = number | {
+    family?: number;
+    schemaVersion?: number;
+    replication?: number;
+    placement?: number;
+    fillMaxWaitMs?: number;
+    fillAllowStale?: boolean;
+};
 export declare class DevDatabase {
     private readonly store;
+    private readonly recordIdem;
+    private readonly uniqueIdem;
     private readonly views;
     private readonly members;
     private readonly counters;
+    private readonly counterIdem;
     private readonly events;
     private readonly eventDedup;
     private readonly capacity;
@@ -14,7 +25,11 @@ export declare class DevDatabase {
     private catalog;
     private persistPath;
     setCatalog(wasm: Buffer): void;
+    private currentSchemaVersion;
     private stampVersion;
+    private recordIdemStart;
+    private recordIdemFinish;
+    private replayRecordOutcome;
     configurePersistence(filePath: string): void;
     persist(): void;
     private load;
@@ -26,12 +41,12 @@ export declare class DevDatabase {
     get(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number): number;
     getMany(ref: MemoryRef, db: DbDevState, handle: number, keysPtr: number, keysLen: number): number;
     exists(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number): number;
-    create(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number, valPtr: number, valLen: number): number;
-    patch(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number, patchPtr: number, patchLen: number): number;
-    delete(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number): number;
-    getDelete(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number): number;
+    create(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number, valPtr: number, valLen: number, idemPtr: number): number;
+    patch(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number, patchPtr: number, patchLen: number, idemPtr: number): number;
+    delete(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number, idemPtr: number): number;
+    getDelete(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number, idemPtr: number): number;
     uniqueLookup(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number): number;
-    uniqueClaim(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number, valPtr: number, valLen: number): number;
+    uniqueClaim(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number, valPtr: number, valLen: number, idemPtr: number): number;
     uniqueRelease(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number, valPtr: number, valLen: number): number;
     membershipContains(ref: MemoryRef, db: DbDevState, handle: number, setPtr: number, setLen: number, memberPtr: number, memberLen: number): number;
     membershipAdd(ref: MemoryRef, db: DbDevState, handle: number, setPtr: number, setLen: number, memberPtr: number, memberLen: number): number;
@@ -40,20 +55,20 @@ export declare class DevDatabase {
     viewGet(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number): number;
     viewPublish(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number, valPtr: number, valLen: number): number;
     counterGet(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number): number;
-    counterAdd(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number, delta: number | bigint): number;
-    append(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number, evPtr: number, evLen: number): number;
+    counterAdd(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number, delta: number | bigint, idemPtr: number): number;
+    append(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number, evPtr: number, evLen: number, idemPtr: number): number;
     appendOnce(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number, evidPtr: number, evidLen: number, evPtr: number, evLen: number): number;
-    enqueue(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number, valPtr: number, valLen: number): number;
+    enqueue(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number, valPtr: number, valLen: number, idemPtr: number): number;
     latest(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number, limit: number): number;
     capacitySetTotal(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number, total: number | bigint): number;
     capacityAvailable(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number): number;
-    capacityReserve(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number, amount: number | bigint, ttlMs: number | bigint): number;
+    capacityReserve(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number, amount: number | bigint, ttlMs: number | bigint, idemPtr: number): number;
     capacityConfirm(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number, reservationId: number | bigint): number;
     capacityCancel(ref: MemoryRef, db: DbDevState, handle: number, keyPtr: number, keyLen: number, reservationId: number | bigint): number;
     takeResult(ref: MemoryRef, db: DbDevState, outPtr: number, outCap: number): number;
     resultSchemaVersion(db: DbDevState): bigint;
     resetForTests(): void;
-    setCatalogForTests(entries: Record<string, number>): void;
+    setCatalogForTests(entries: Record<string, CatalogSeedEntry>): void;
 }
 export declare const devDb: DevDatabase;
 export declare function setDbCatalog(wasm: Buffer): void;
@@ -61,4 +76,5 @@ export declare function configureDbPersistence(filePath: string): void;
 export declare function persistDb(): void;
 export declare function buildDatabaseImports(ref: MemoryRef, db: DbDevState): Record<string, (...args: number[]) => number | bigint>;
 export declare function __resetDbForTests(): void;
-export declare function __setDbCatalogForTests(entries: Record<string, number>): void;
+export declare function __setDbCatalogForTests(entries: Record<string, CatalogSeedEntry>): void;
+export {};