toiljs 0.0.54 → 0.0.56

package/src/devserver/envelope.ts

@@ -69,15 +69,15 @@ export function encodeRequestEnvelope(req: EnvelopeRequest): Buffer {
     if (path.length > U16_MAX) throw new Error(`path too long: ${String(path.length)} bytes`);
     if (req.headers.length > U16_MAX)
         throw new Error(`too many headers: ${String(req.headers.length)}`);
-    if (req.body.length > U32_MAX) throw new Error(`body too long: ${String(req.body.length)} bytes`);
+    if (req.body.length > U32_MAX)
+        throw new Error(`body too long: ${String(req.body.length)} bytes`);
 
     const headers: { name: Buffer; value: Buffer }[] = [];
     let headersSize = 0;
     for (const [name, value] of req.headers) {
         const n = Buffer.from(name, 'utf8');
         const v = Buffer.from(value, 'utf8');
-        if (n.length > U16_MAX || v.length > U16_MAX)
-            throw new Error(`header too long: ${name}`);
+        if (n.length > U16_MAX || v.length > U16_MAX) throw new Error(`header too long: ${name}`);
         headers.push({ name: n, value: v });
         headersSize += 4 + n.length + v.length;
     }

package/src/devserver/host.ts

@@ -17,8 +17,8 @@
  * `WebAssembly.Instance`, so offering the full surface costs nothing.
  */
 
-import { buildCryptoImports, freshCryptoState, type CryptoState } from './crypto.js';
-import { buildKvImports } from './kv.js';
+import { buildCryptoImports, type CryptoState, freshCryptoState } from './crypto.js';
+import { buildDatabaseImports, type DbDevState, freshDbState } from './database.js';
 import { EmailStatus, getEmailService } from './email/index.js';
 import { parseEmailBlob } from './email/wire.js';
 import { devEnvGet, devEnvGetSecure } from './env.js';
@@ -59,6 +59,8 @@ export interface DispatchState {
     clientIp: string;
     /** Per-dispatch Web Crypto keystore + result scratch (mirrors the edge). */
     crypto: CryptoState;
+    /** Per-dispatch ToilDB state: resolved collection handles + result stash. */
+    db: DbDevState;
 }
 
 /** A fresh, zeroed per-dispatch state (the edge resets the same way before each request). */
@@ -70,6 +72,7 @@ export function freshDispatchState(): DispatchState {
         sendfile: null,
         clientIp: '',
         crypto: freshCryptoState(),
+        db: freshDbState(),
     };
 }
 
@@ -155,7 +158,12 @@ export function buildHostImports(ref: MemoryRef, state: DispatchState): WebAssem
                 state.status = code >= 100 && code <= 599 ? code : 500;
             },
 
-            set_header: (namePtr: number, nameLen: number, valPtr: number, valLen: number): void => {
+            set_header: (
+                namePtr: number,
+                nameLen: number,
+                valPtr: number,
+                valLen: number,
+            ): void => {
                 if (nameLen > MAX_HEADER_NAME_LEN)
                     throw new Error(`header name too long: ${String(nameLen)} bytes`);
                 if (valLen > MAX_HEADER_VALUE_LEN)
@@ -225,7 +233,9 @@ export function buildHostImports(ref: MemoryRef, state: DispatchState): WebAssem
                 const svc = getEmailService();
                 if (svc === null) {
                     const to = parseEmailBlob(raw)?.to ?? '<unparsed>';
-                    process.stdout.write(`  ✉ dev email_send -> ${to} (no email config; not sent)\n`);
+                    process.stdout.write(
+                        `  ✉ dev email_send -> ${to} (no email config; not sent)\n`,
+                    );
                     return EmailStatus.Sent;
                 }
                 const { status, parsed } = svc.prepare(raw);
@@ -240,7 +250,9 @@ export function buildHostImports(ref: MemoryRef, state: DispatchState): WebAssem
                         process.stdout.write(`  ✉ dev email_send -> ${parsed.to} (${label})\n`);
                     })
                     .catch((e: unknown) => {
-                        process.stdout.write(`  ✉ dev email_send -> ${parsed.to} (error: ${String(e)})\n`);
+                        process.stdout.write(
+                            `  ✉ dev email_send -> ${parsed.to} (error: ${String(e)})\n`,
+                        );
                     });
                 return EmailStatus.Sent; // optimistic; sync wasm can't await the send
             },
@@ -270,10 +282,11 @@ export function buildHostImports(ref: MemoryRef, state: DispatchState): WebAssem
             // `crypto`. The dev server skips metering, so these charge nothing.
             ...buildCryptoImports(ref, state.crypto),
 
-            // DEV-ONLY persistent KV (`env.kv.*`). REMOVE LATER — scaffolding so
-            // the auth example's register/login chain spans requests under
-            // `toiljs dev`; not present on the production edge (see ./kv.ts).
-            ...buildKvImports(ref),
+            // `env::data.*`: the ToilDB data API, emulated in process (see
+            // ./database.ts). Backs the auth example's accounts + login
+            // challenges so register/login spans requests under `toiljs dev`;
+            // the production edge backs the SAME imports with ScyllaDB.
+            ...buildDatabaseImports(ref, state.db),
         },
     };
 }

package/src/devserver/index.ts

@@ -22,18 +22,23 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
-import { Server, type Request, type Response } from '@dacely/hyper-express';
+import { type Request, type Response, Server } from '@dacely/hyper-express';
 import pc from 'picocolors';
 
 import type { EmailBackendConfig } from 'toiljs/shared';
 
 import { applyCacheRule, lookupCache } from './cache.js';
 import { initEmailService } from './email/index.js';
-import { METHOD_CODES, type EnvelopeRequest } from './envelope.js';
+import { type EnvelopeRequest, METHOD_CODES } from './envelope.js';
 import { WasmServerModule } from './module.js';
-import { proxyToVite, wireWebsocketProxy, type ViteTarget } from './proxy.js';
+import { proxyToVite, type ViteTarget, wireWebsocketProxy } from './proxy.js';
 
-export { METHOD_CODES, encodeRequestEnvelope, decodeResponseEnvelope, unpackHandleResult } from './envelope.js';
+export {
+    METHOD_CODES,
+    encodeRequestEnvelope,
+    decodeResponseEnvelope,
+    unpackHandleResult,
+} from './envelope.js';
 export type { EnvelopeRequest, EnvelopeResponse } from './envelope.js';
 export { WasmServerModule, WasmAbortError, UNHANDLED_HEADER } from './module.js';
 export type { WasmDispatchResult } from './module.js';
@@ -161,7 +166,10 @@ function sendWasmResponse(
         if (!hasContentType) {
             // The edge defaults file bodies to application/octet-stream; in dev we
             // guess from the extension so a guest-served asset renders in the browser.
-            response.header('content-type', MIME[path.extname(file).toLowerCase()] ?? 'application/octet-stream');
+            response.header(
+                'content-type',
+                MIME[path.extname(file).toLowerCase()] ?? 'application/octet-stream',
+            );
         }
         response.sendFile(file);
         return;
@@ -267,7 +275,8 @@ export async function startDevServer(options: DevServerOptions): Promise<Running
                 // A trap (ToilScript abort, OOB, malformed envelope) is isolated to
                 // this request, exactly like the edge poisoning one instance.
                 process.stdout.write(
-                    pc.red(`  ✗ ${request.method} ${request.path} server error: ${String(e)}`) + '\n',
+                    pc.red(`  ✗ ${request.method} ${request.path} server error: ${String(e)}`) +
+                        '\n',
                 );
                 response.status(500).send('internal error\n');
                 return;

package/src/devserver/module.ts

@@ -16,8 +16,8 @@ import fs from 'node:fs';
 import {
     decodeResponseEnvelope,
     encodeRequestEnvelope,
-    unpackHandleResult,
     type EnvelopeRequest,
+    unpackHandleResult,
 } from './envelope.js';
 import { buildHostImports, freshDispatchState, type MemoryRef } from './host.js';
 
@@ -52,16 +52,61 @@ interface HandleExports {
 
 /** Host functions the dev server provides under `env` (see `host.ts`). */
 const PROVIDED_IMPORTS = new Set([
-    'abort', 'set_status', 'set_header', 'respond_file', 'thread_spawn', 'Date.now',
-    'client_ip', 'ratelimit_check', 'email_send', 'env_get', 'env_get_secure',
+    'abort',
+    'set_status',
+    'set_header',
+    'respond_file',
+    'thread_spawn',
+    'Date.now',
+    'client_ip',
+    'ratelimit_check',
+    'email_send',
+    'env_get',
+    'env_get_secure',
     // Web Crypto host functions (see ./crypto.ts).
-    'crypto.fill_random', 'crypto.random_uuid', 'crypto.take_result', 'crypto.digest',
-    'crypto.import_key', 'crypto.export_key', 'crypto.encrypt', 'crypto.decrypt',
-    'crypto.sign', 'crypto.verify', 'crypto.derive_bits',
-    'crypto.mldsa_verify', 'crypto.mlkem_decapsulate', 'crypto.voprf_evaluate',
-    // DEV-ONLY persistent KV (see ./kv.ts). REMOVE once the example is backed by
-    // a real external store; never ship as a production storage path.
-    'kv.put', 'kv.get', 'kv.getdel',
+    'crypto.fill_random',
+    'crypto.random_uuid',
+    'crypto.take_result',
+    'crypto.digest',
+    'crypto.import_key',
+    'crypto.export_key',
+    'crypto.encrypt',
+    'crypto.decrypt',
+    'crypto.sign',
+    'crypto.verify',
+    'crypto.derive_bits',
+    'crypto.mldsa_verify',
+    'crypto.mlkem_decapsulate',
+    'crypto.voprf_evaluate',
+    // ToilDB data API (see ./database.ts). Backed by ScyllaDB on the production
+    // edge; backs the auth example's accounts + login challenges in dev.
+    'data.resolve_collection',
+    'data.get',
+    'data.get_many',
+    'data.exists',
+    'data.create',
+    'data.patch',
+    'data.delete',
+    'data.get_delete',
+    'data.unique_lookup',
+    'data.unique_claim',
+    'data.unique_release',
+    'data.view_get',
+    'data.view_publish',
+    'data.membership_contains',
+    'data.membership_add',
+    'data.membership_remove',
+    'data.membership_list',
+    'data.counter_get',
+    'data.counter_add',
+    'data.append',
+    'data.latest',
+    'data.capacity_set_total',
+    'data.capacity_available',
+    'data.capacity_reserve',
+    'data.capacity_confirm',
+    'data.capacity_cancel',
+    'data.take_result',
 ]);
 
 export class WasmServerModule {
@@ -198,7 +243,10 @@ export class WasmServerModule {
     /** Fail instantiation up front, with names, when the guest needs imports we do not provide. */
     private assertImportSurface(module: WebAssembly.Module): void {
         const missing = WebAssembly.Module.imports(module)
-            .filter((i) => i.kind === 'function' && (i.module !== 'env' || !PROVIDED_IMPORTS.has(i.name)))
+            .filter(
+                (i) =>
+                    i.kind === 'function' && (i.module !== 'env' || !PROVIDED_IMPORTS.has(i.name)),
+            )
             .map((i) => `${i.module}.${i.name}`);
         if (missing.length > 0)
             throw new Error(

package/src/devserver/proxy.ts

@@ -6,12 +6,7 @@
  * websocket through Node's built-in `WebSocket` client, both loopback-only.
  */
 
-import {
-    type Request,
-    type Response,
-    type Server,
-    type Websocket,
-} from '@dacely/hyper-express';
+import { type Request, type Response, type Server, type Websocket } from '@dacely/hyper-express';
 
 /** Where the internal Vite dev server listens (always loopback). */
 export interface ViteTarget {
@@ -151,7 +146,10 @@ export function wireWebsocketProxy(app: Server, target: ViteTarget): void {
                 else pending.push(m);
             });
             ws.on('close', () => {
-                if (upstream.readyState === WebSocket.OPEN || upstream.readyState === WebSocket.CONNECTING) {
+                if (
+                    upstream.readyState === WebSocket.OPEN ||
+                    upstream.readyState === WebSocket.CONNECTING
+                ) {
                     upstream.close();
                 }
             });

package/src/io/codec.ts

@@ -34,60 +34,81 @@ export class DataWriter {
         this.view = new DataView(this.buf.buffer);
     }
 
-    /**
-     * Ensures room for `extra` more bytes and returns the offset to write at. Grows
-     * (doubling) when needed, reassigning `buf`/`view`. Callers MUST read the returned
-     * offset into a local before touching `this.view`/`this.buf`, since a grow swaps
-     * them out from under a stale receiver.
-     */
-    private reserve(extra: number): number {
-        const need = this.off + extra;
-        if (need > this.buf.length) {
-            let n = this.buf.length;
-            while (n < need) n <<= 1;
-            const bigger = new Uint8Array(n);
-            bigger.set(this.buf.subarray(0, this.off));
-            this.buf = bigger;
-            this.view = new DataView(this.buf.buffer);
-        }
-        const at = this.off;
-        this.off += extra;
-        return at;
+    /** Writes an unsigned 8-bit byte (the low 8 bits of `v`). */
+    writeU8(v: number): this {
+        const at = this.reserve(1);
+        this.view.setUint8(at, v & 0xff);
+        return this;
     }
 
-    /** Writes an unsigned 8-bit byte (the low 8 bits of `v`). */
-    writeU8(v: number): this { const at = this.reserve(1); this.view.setUint8(at, v & 0xff); return this; }
     /** Writes an unsigned 16-bit integer. @param be - big-endian if true (default little-endian). */
-    writeU16(v: number, be?: boolean): this { const at = this.reserve(2); this.view.setUint16(at, v & 0xffff, !be); return this; }
+    writeU16(v: number, be?: boolean): this {
+        const at = this.reserve(2);
+        this.view.setUint16(at, v & 0xffff, !be);
+        return this;
+    }
+
     /** Writes an unsigned 32-bit integer. @param be - big-endian if true (default little-endian). */
-    writeU32(v: number, be?: boolean): this { const at = this.reserve(4); this.view.setUint32(at, v >>> 0, !be); return this; }
+    writeU32(v: number, be?: boolean): this {
+        const at = this.reserve(4);
+        this.view.setUint32(at, v >>> 0, !be);
+        return this;
+    }
+
     /** Writes an unsigned 64-bit integer (low 64 bits of `v`). @param be - big-endian if true. */
-    writeU64(v: bigint, be?: boolean): this { const at = this.reserve(8); this.view.setBigUint64(at, v & MASK64, !be); return this; }
+    writeU64(v: bigint, be?: boolean): this {
+        const at = this.reserve(8);
+        this.view.setBigUint64(at, v & MASK64, !be);
+        return this;
+    }
+
     /** Writes a signed 8-bit integer. */
-    writeI8(v: number): this { const at = this.reserve(1); this.view.setInt8(at, v); return this; }
+    writeI8(v: number): this {
+        const at = this.reserve(1);
+        this.view.setInt8(at, v);
+        return this;
+    }
+
     /** Writes a signed 16-bit integer. @param be - big-endian if true (default little-endian). */
-    writeI16(v: number, be?: boolean): this { const at = this.reserve(2); this.view.setInt16(at, v, !be); return this; }
+    writeI16(v: number, be?: boolean): this {
+        const at = this.reserve(2);
+        this.view.setInt16(at, v, !be);
+        return this;
+    }
+
     /** Writes a signed 32-bit integer. @param be - big-endian if true (default little-endian). */
-    writeI32(v: number, be?: boolean): this { const at = this.reserve(4); this.view.setInt32(at, v | 0, !be); return this; }
+    writeI32(v: number, be?: boolean): this {
+        const at = this.reserve(4);
+        this.view.setInt32(at, v | 0, !be);
+        return this;
+    }
+
     /** Writes a signed 64-bit integer. @param be - big-endian if true (default little-endian). */
-    writeI64(v: bigint, be?: boolean): this { const at = this.reserve(8); this.view.setBigInt64(at, BigInt.asIntN(64, v), !be); return this; }
+    writeI64(v: bigint, be?: boolean): this {
+        const at = this.reserve(8);
+        this.view.setBigInt64(at, BigInt.asIntN(64, v), !be);
+        return this;
+    }
+
     /** Writes a 32-bit float. @param be - big-endian if true (default little-endian). */
-    writeF32(v: number, be?: boolean): this { const at = this.reserve(4); this.view.setFloat32(at, v, !be); return this; }
-    /** Writes a 64-bit float. @param be - big-endian if true (default little-endian). */
-    writeF64(v: number, be?: boolean): this { const at = this.reserve(8); this.view.setFloat64(at, v, !be); return this; }
-    /** Writes a boolean as one byte (1 or 0). */
-    writeBool(v: boolean): this { return this.writeU8(v ? 1 : 0); }
+    writeF32(v: number, be?: boolean): this {
+        const at = this.reserve(4);
+        this.view.setFloat32(at, v, !be);
+        return this;
+    }
 
-    /** Writes the `count` 64-bit limbs of `u` (low limb first in LE, high limb first in BE). */
-    private writeLimbs(u: bigint, count: number, be: boolean): this {
-        if (be) {
-            for (let i = count - 1; i >= 0; i--) this.writeU64((u >> BigInt(i * 64)) & MASK64, true);
-        } else {
-            for (let i = 0; i < count; i++) this.writeU64((u >> BigInt(i * 64)) & MASK64, false);
-        }
+    /** Writes a 64-bit float. @param be - big-endian if true (default little-endian). */
+    writeF64(v: number, be?: boolean): this {
+        const at = this.reserve(8);
+        this.view.setFloat64(at, v, !be);
         return this;
     }
 
+    /** Writes a boolean as one byte (1 or 0). */
+    writeBool(v: boolean): this {
+        return this.writeU8(v ? 1 : 0);
+    }
+
     /** Writes a `u32` length prefix followed by the raw bytes. @param be - endianness of the prefix. */
     writeBytes(bytes: Uint8Array, be?: boolean): this {
         this.writeU32(bytes.length, be);
@@ -110,19 +131,66 @@ export class DataWriter {
     }
 
     /** Writes an unsigned 128-bit integer as two 64-bit limbs. @param be - big-endian if true. */
-    writeU128(v: bigint, be?: boolean): this { return this.writeLimbs(BigInt.asUintN(128, v), 2, !!be); }
+    writeU128(v: bigint, be?: boolean): this {
+        return this.writeLimbs(BigInt.asUintN(128, v), 2, !!be);
+    }
+
     /** Writes a signed 128-bit integer as two 64-bit limbs (two's complement). @param be - big-endian if true. */
-    writeI128(v: bigint, be?: boolean): this { return this.writeLimbs(BigInt.asUintN(128, v), 2, !!be); }
+    writeI128(v: bigint, be?: boolean): this {
+        return this.writeLimbs(BigInt.asUintN(128, v), 2, !!be);
+    }
+
     /** Writes an unsigned 256-bit integer as four 64-bit limbs. @param be - big-endian if true. */
-    writeU256(v: bigint, be?: boolean): this { return this.writeLimbs(BigInt.asUintN(256, v), 4, !!be); }
+    writeU256(v: bigint, be?: boolean): this {
+        return this.writeLimbs(BigInt.asUintN(256, v), 4, !!be);
+    }
+
     /** Writes a signed 256-bit integer as four 64-bit limbs (two's complement). @param be - big-endian if true. */
-    writeI256(v: bigint, be?: boolean): this { return this.writeLimbs(BigInt.asUintN(256, v), 4, !!be); }
+    writeI256(v: bigint, be?: boolean): this {
+        return this.writeLimbs(BigInt.asUintN(256, v), 4, !!be);
+    }
 
     /** Number of bytes written so far. */
-    length(): number { return this.off; }
+    length(): number {
+        return this.off;
+    }
 
     /** A fresh copy of exactly the bytes written. */
-    toBytes(): Uint8Array<ArrayBuffer> { return this.buf.slice(0, this.off); }
+    toBytes(): Uint8Array<ArrayBuffer> {
+        return this.buf.slice(0, this.off);
+    }
+
+    /**
+     * Ensures room for `extra` more bytes and returns the offset to write at. Grows
+     * (doubling) when needed, reassigning `buf`/`view`. Callers MUST read the returned
+     * offset into a local before touching `this.view`/`this.buf`, since a grow swaps
+     * them out from under a stale receiver.
+     */
+    private reserve(extra: number): number {
+        const need = this.off + extra;
+        if (need > this.buf.length) {
+            let n = this.buf.length;
+            while (n < need) n <<= 1;
+            const bigger = new Uint8Array(n);
+            bigger.set(this.buf.subarray(0, this.off));
+            this.buf = bigger;
+            this.view = new DataView(this.buf.buffer);
+        }
+        const at = this.off;
+        this.off += extra;
+        return at;
+    }
+
+    /** Writes the `count` 64-bit limbs of `u` (low limb first in LE, high limb first in BE). */
+    private writeLimbs(u: bigint, count: number, be: boolean): this {
+        if (be) {
+            for (let i = count - 1; i >= 0; i--)
+                this.writeU64((u >> BigInt(i * 64)) & MASK64, true);
+        } else {
+            for (let i = 0; i < count; i++) this.writeU64((u >> BigInt(i * 64)) & MASK64, false);
+        }
+        return this;
+    }
 }
 
 /**
@@ -132,11 +200,11 @@ export class DataWriter {
  * big-endian writer.
  */
 export class DataReader {
+    /** Cleared to false if any read ran past the end of the buffer. */
+    ok = true;
     private buf: Uint8Array;
     private view: DataView;
     private off = 0;
-    /** Cleared to false if any read ran past the end of the buffer. */
-    ok = true;
 
     /** @param bytes - the buffer to read from (its byteOffset/length are respected). */
     constructor(bytes: Uint8Array) {
@@ -144,47 +212,89 @@ export class DataReader {
         this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
     }
 
-    /** Returns true (and leaves `off` advanceable) if `n` more bytes are available; else clears `ok`. */
-    private has(n: number): boolean {
-        if (n < 0 || this.off + n > this.buf.length) {
-            this.ok = false;
-            return false;
-        }
-        return true;
+    /** Reads an unsigned 8-bit byte (0 past end). */
+    readU8(): number {
+        if (!this.has(1)) return 0;
+        const v = this.view.getUint8(this.off);
+        this.off += 1;
+        return v;
     }
 
-    /** Reads an unsigned 8-bit byte (0 past end). */
-    readU8(): number { if (!this.has(1)) return 0; const v = this.view.getUint8(this.off); this.off += 1; return v; }
     /** Reads an unsigned 16-bit integer. @param be - big-endian if true (default little-endian). */
-    readU16(be?: boolean): number { if (!this.has(2)) return 0; const v = this.view.getUint16(this.off, !be); this.off += 2; return v; }
+    readU16(be?: boolean): number {
+        if (!this.has(2)) return 0;
+        const v = this.view.getUint16(this.off, !be);
+        this.off += 2;
+        return v;
+    }
+
     /** Reads an unsigned 32-bit integer. @param be - big-endian if true (default little-endian). */
-    readU32(be?: boolean): number { if (!this.has(4)) return 0; const v = this.view.getUint32(this.off, !be); this.off += 4; return v >>> 0; }
+    readU32(be?: boolean): number {
+        if (!this.has(4)) return 0;
+        const v = this.view.getUint32(this.off, !be);
+        this.off += 4;
+        return v >>> 0;
+    }
+
     /** Reads an unsigned 64-bit integer. @param be - big-endian if true (default little-endian). */
-    readU64(be?: boolean): bigint { if (!this.has(8)) return 0n; const v = this.view.getBigUint64(this.off, !be); this.off += 8; return v; }
+    readU64(be?: boolean): bigint {
+        if (!this.has(8)) return 0n;
+        const v = this.view.getBigUint64(this.off, !be);
+        this.off += 8;
+        return v;
+    }
+
     /** Reads a signed 8-bit integer (0 past end). */
-    readI8(): number { if (!this.has(1)) return 0; const v = this.view.getInt8(this.off); this.off += 1; return v; }
+    readI8(): number {
+        if (!this.has(1)) return 0;
+        const v = this.view.getInt8(this.off);
+        this.off += 1;
+        return v;
+    }
+
     /** Reads a signed 16-bit integer. @param be - big-endian if true (default little-endian). */
-    readI16(be?: boolean): number { if (!this.has(2)) return 0; const v = this.view.getInt16(this.off, !be); this.off += 2; return v; }
+    readI16(be?: boolean): number {
+        if (!this.has(2)) return 0;
+        const v = this.view.getInt16(this.off, !be);
+        this.off += 2;
+        return v;
+    }
+
     /** Reads a signed 32-bit integer. @param be - big-endian if true (default little-endian). */
-    readI32(be?: boolean): number { if (!this.has(4)) return 0; const v = this.view.getInt32(this.off, !be); this.off += 4; return v; }
+    readI32(be?: boolean): number {
+        if (!this.has(4)) return 0;
+        const v = this.view.getInt32(this.off, !be);
+        this.off += 4;
+        return v;
+    }
+
     /** Reads a signed 64-bit integer. @param be - big-endian if true (default little-endian). */
-    readI64(be?: boolean): bigint { if (!this.has(8)) return 0n; const v = this.view.getBigInt64(this.off, !be); this.off += 8; return v; }
+    readI64(be?: boolean): bigint {
+        if (!this.has(8)) return 0n;
+        const v = this.view.getBigInt64(this.off, !be);
+        this.off += 8;
+        return v;
+    }
+
     /** Reads a 32-bit float. @param be - big-endian if true (default little-endian). */
-    readF32(be?: boolean): number { if (!this.has(4)) return 0; const v = this.view.getFloat32(this.off, !be); this.off += 4; return v; }
+    readF32(be?: boolean): number {
+        if (!this.has(4)) return 0;
+        const v = this.view.getFloat32(this.off, !be);
+        this.off += 4;
+        return v;
+    }
+
     /** Reads a 64-bit float. @param be - big-endian if true (default little-endian). */
-    readF64(be?: boolean): number { if (!this.has(8)) return 0; const v = this.view.getFloat64(this.off, !be); this.off += 8; return v; }
-    /** Reads a boolean (any non-zero byte is true). */
-    readBool(): boolean { return this.readU8() !== 0; }
+    readF64(be?: boolean): number {
+        if (!this.has(8)) return 0;
+        const v = this.view.getFloat64(this.off, !be);
+        this.off += 8;
+        return v;
+    }
 
-    /** Reads `count` 64-bit limbs and recombines them (low limb first in LE, high first in BE). */
-    private readLimbs(count: number, be: boolean): bigint {
-        let result = 0n;
-        if (be) {
-            for (let i = count - 1; i >= 0; i--) result |= this.readU64(true) << BigInt(i * 64);
-        } else {
-            for (let i = 0; i < count; i++) result |= this.readU64(false) << BigInt(i * 64);
-        }
-        return result;
+    /** Reads a boolean (any non-zero byte is true). */
+    readBool(): boolean {
+        return this.readU8() !== 0;
     }
 
     /** Reads a `u32`-length-prefixed byte blob (empty past end). @param be - endianness of the prefix. */
@@ -199,21 +309,54 @@ export class DataReader {
     /** Reads a `u32`-byte-length-prefixed UTF-8 string (empty past end). @param be - endianness of the prefix. */
     readString(be?: boolean): string {
         const len = this.readU32(be);
-        if (!this.has(len)) return "";
+        if (!this.has(len)) return '';
         const s = utf8Decoder.decode(this.buf.subarray(this.off, this.off + len));
         this.off += len;
         return s;
     }
 
     /** Reads an unsigned 128-bit integer. @param be - big-endian if true (default little-endian). */
-    readU128(be?: boolean): bigint { return this.readLimbs(2, !!be); }
+    readU128(be?: boolean): bigint {
+        return this.readLimbs(2, !!be);
+    }
+
     /** Reads a signed 128-bit integer (two's complement). @param be - big-endian if true. */
-    readI128(be?: boolean): bigint { return BigInt.asIntN(128, this.readLimbs(2, !!be)); }
+    readI128(be?: boolean): bigint {
+        return BigInt.asIntN(128, this.readLimbs(2, !!be));
+    }
+
     /** Reads an unsigned 256-bit integer. @param be - big-endian if true (default little-endian). */
-    readU256(be?: boolean): bigint { return this.readLimbs(4, !!be); }
+    readU256(be?: boolean): bigint {
+        return this.readLimbs(4, !!be);
+    }
+
     /** Reads a signed 256-bit integer (two's complement). @param be - big-endian if true. */
-    readI256(be?: boolean): bigint { return BigInt.asIntN(256, this.readLimbs(4, !!be)); }
+    readI256(be?: boolean): bigint {
+        return BigInt.asIntN(256, this.readLimbs(4, !!be));
+    }
 
     /** Bytes left to read. */
-    remaining(): number { return this.buf.length - this.off; }
+    remaining(): number {
+        return this.buf.length - this.off;
+    }
+
+    /** Returns true (and leaves `off` advanceable) if `n` more bytes are available; else clears `ok`. */
+    private has(n: number): boolean {
+        if (n < 0 || this.off + n > this.buf.length) {
+            this.ok = false;
+            return false;
+        }
+        return true;
+    }
+
+    /** Reads `count` 64-bit limbs and recombines them (low limb first in LE, high first in BE). */
+    private readLimbs(count: number, be: boolean): bigint {
+        let result = 0n;
+        if (be) {
+            for (let i = count - 1; i >= 0; i--) result |= this.readU64(true) << BigInt(i * 64);
+        } else {
+            for (let i = 0; i < count; i++) result |= this.readU64(false) << BigInt(i * 64);
+        }
+        return result;
+    }
 }