toiljs 0.0.59 → 0.0.61

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 { CollectionFamily, DbFunctionKind, 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 { CollectionFamily, DbFunctionKind, freshDbState } from './types.js';

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

@@ -0,0 +1,8 @@
+import { DbFunctionKind } from './types.js';
+export interface RouteKindEntry {
+    readonly method: number;
+    readonly kind: DbFunctionKind;
+    readonly pattern: string;
+}
+export declare function parseRouteKinds(wasm: Buffer): readonly RouteKindEntry[];
+export declare function routeKindForRequest(routes: readonly RouteKindEntry[], method: string, path: string): DbFunctionKind | null;

package/build/devserver/db/routeKinds.js

@@ -0,0 +1,139 @@
+import { customSection } from '../wasm/sections.js';
+import { DbFunctionKind } from './types.js';
+const SECTION = 'toildb.route_kinds';
+const VERSION = 1;
+const MAX_SECTION_BYTES = 128 * 1024;
+const MAX_ROUTES = 2048;
+const MAX_PATTERN_BYTES = 2048;
+const UTF8_DECODER = new TextDecoder('utf-8', { fatal: true });
+const METHOD_CODES = {
+    GET: 0,
+    POST: 1,
+    PUT: 2,
+    DELETE: 3,
+    PATCH: 4,
+    HEAD: 5,
+    OPTIONS: 6,
+};
+export function parseRouteKinds(wasm) {
+    let section;
+    try {
+        section = customSection(wasm, SECTION);
+    }
+    catch {
+        return [];
+    }
+    if (section === null)
+        return [];
+    if (section.length > MAX_SECTION_BYTES)
+        return [];
+    const r = new Reader(section);
+    const version = r.u16();
+    if (!r.ok || version !== VERSION)
+        return [];
+    const count = r.u16();
+    if (!r.ok || count > MAX_ROUTES)
+        return [];
+    const routes = [];
+    for (let i = 0; i < count && r.ok; i++) {
+        const method = r.u8();
+        const kindByte = r.u8();
+        const pattern = r.string();
+        const kind = kindByte === 0 ? DbFunctionKind.Query : kindByte === 1 ? DbFunctionKind.Action : null;
+        if (!r.ok || method < 0 || method > 6 || kind === null || !validPattern(pattern))
+            return [];
+        routes.push({ method, kind, pattern });
+    }
+    if (!r.ok || r.remaining() !== 0)
+        return [];
+    return routes;
+}
+export function routeKindForRequest(routes, method, path) {
+    const methodCode = METHOD_CODES[method.toUpperCase()];
+    if (methodCode === undefined)
+        return null;
+    for (const route of routes) {
+        if (route.method === methodCode && routeMatches(route.pattern, path))
+            return route.kind;
+    }
+    return null;
+}
+function validPattern(pattern) {
+    if (pattern.length === 0 || !pattern.startsWith('/'))
+        return false;
+    for (let i = 0; i < pattern.length; i++) {
+        const c = pattern.charCodeAt(i);
+        if (c < 0x20 || c > 0x7e)
+            return false;
+    }
+    return true;
+}
+function routeMatches(pattern, pathWithQuery) {
+    const q = pathWithQuery.indexOf('?');
+    const path = q >= 0 ? pathWithQuery.slice(0, q) : pathWithQuery;
+    const patternSegs = pattern.split('/').filter(Boolean);
+    const pathSegs = path.split('/').filter(Boolean);
+    if (patternSegs.length !== pathSegs.length)
+        return false;
+    for (let i = 0; i < patternSegs.length; i++) {
+        const p = patternSegs[i] ?? '';
+        const a = pathSegs[i] ?? '';
+        if (p.startsWith(':') && p.length > 1 && a.length > 0)
+            continue;
+        if (p !== a)
+            return false;
+    }
+    return true;
+}
+class Reader {
+    bytes;
+    pos = 0;
+    ok = true;
+    constructor(bytes) {
+        this.bytes = bytes;
+    }
+    remaining() {
+        return this.bytes.length - this.pos;
+    }
+    u8() {
+        if (!this.ok || this.pos + 1 > this.bytes.length) {
+            this.ok = false;
+            return 0;
+        }
+        return this.bytes[this.pos++] ?? 0;
+    }
+    u16() {
+        if (!this.ok || this.pos + 2 > this.bytes.length) {
+            this.ok = false;
+            return 0;
+        }
+        const out = this.bytes.readUInt16LE(this.pos);
+        this.pos += 2;
+        return out;
+    }
+    u32() {
+        if (!this.ok || this.pos + 4 > this.bytes.length) {
+            this.ok = false;
+            return 0;
+        }
+        const out = this.bytes.readUInt32LE(this.pos);
+        this.pos += 4;
+        return out;
+    }
+    string() {
+        const len = this.u32();
+        if (!this.ok || len > MAX_PATTERN_BYTES || this.pos + len > this.bytes.length) {
+            this.ok = false;
+            return '';
+        }
+        try {
+            const out = UTF8_DECODER.decode(this.bytes.subarray(this.pos, this.pos + len));
+            this.pos += len;
+            return out;
+        }
+        catch {
+            this.ok = false;
+            return '';
+        }
+    }
+}

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

@@ -0,0 +1,121 @@
+export declare enum CollectionFamily {
+    Record = 0,
+    View = 1,
+    Events = 2,
+    Counter = 3,
+    Membership = 4,
+    Unique = 5,
+    Capacity = 6
+}
+export declare enum DbFunctionKind {
+    Query = "query",
+    Action = "action",
+    Derive = "derive",
+    Job = "job",
+    Admin = "admin"
+}
+export declare function isCollectionFamily(value: number): value is CollectionFamily;
+export interface DevCollectionHandle {
+    name: string;
+    family: CollectionFamily;
+    schemaVersion: number;
+    replication: number;
+    placement: number;
+    fillMaxWaitMs: number;
+    fillAllowStale: boolean;
+}
+export type DbCatalogState = {
+    kind: 'no-section';
+} | {
+    kind: 'malformed';
+} | {
+    kind: 'present';
+    collections: Map<string, DevCollectionHandle>;
+};
+export interface DbDevState {
+    handles: DevCollectionHandle[];
+    lastResult: Buffer | null;
+    lastResultVersion: number;
+    functionKind: DbFunctionKind;
+}
+export declare function freshDbState(): DbDevState;
+export interface Reservation {
+    amount: bigint;
+    expiresMs: number;
+    confirmed: boolean;
+}
+export interface CapLedger {
+    total: bigint;
+    reservations: Map<bigint, Reservation>;
+    nextId: bigint;
+}
+export interface DbSnapshot {
+    store: Record<string, {
+        v: string;
+        sv: number;
+    }>;
+    recordIdem?: Record<string, {
+        requestHash: string;
+        state: 'pending' | 'done';
+        outcome?: RecordOutcomeSnapshot;
+    }>;
+    uniqueIdem?: Record<string, string>;
+    views: Record<string, {
+        v: string;
+        sv: number;
+    }>;
+    members: Record<string, Record<string, {
+        v: string;
+        sv: number;
+    }>>;
+    counters: Record<string, string>;
+    counterIdem?: Record<string, string>;
+    events: Record<string, {
+        v: string;
+        sv: number;
+    }[]>;
+    eventDedup: Record<string, string[]>;
+    capacity: Record<string, {
+        total: string;
+        nextId: string;
+        reservations: [string, {
+            amount: string;
+            expiresMs: number;
+            confirmed: boolean;
+        }][];
+    }>;
+}
+export type RecordOutcomeSnapshot = {
+    kind: 'unit';
+} | {
+    kind: 'value';
+    v: string;
+    sv: number;
+} | {
+    kind: 'absent';
+} | {
+    kind: 'already_exists';
+} | {
+    kind: 'not_found';
+} | {
+    kind: 'conflict';
+};
+export declare const MAX_RESERVATIONS = 4096;
+export declare const MAX_RESERVATION_TTL_MS = 86400000;
+export declare const MAX_NAME = 512;
+export declare const MAX_KEY = 4096;
+export declare const MAX_VALUE: number;
+export declare const DEFAULT_FILL_WAIT_MS = 50;
+export declare const MAX_FILL_WAIT_MS = 60000;
+export declare function satI64(v: bigint): bigint;
+export declare const ABSENT = -2;
+export declare const TOO_SMALL = -1;
+export declare const INVALID_HANDLE = -1001;
+export declare const ALREADY_EXISTS = -1003;
+export declare const CONFLICT = -1004;
+export declare const UNAVAILABLE = -1031;
+export declare const CODEC_ERR = -1006;
+export declare const OP_NOT_ALLOWED_FOR_FAMILY = -1010;
+export declare const OP_NOT_ALLOWED_IN_KIND = -1011;
+export declare const TOO_MANY_KEYS = -1020;
+export declare const SCHEMA_UNAVAILABLE = -1070;

package/build/devserver/db/types.js

@@ -0,0 +1,52 @@
+export var CollectionFamily;
+(function (CollectionFamily) {
+    CollectionFamily[CollectionFamily["Record"] = 0] = "Record";
+    CollectionFamily[CollectionFamily["View"] = 1] = "View";
+    CollectionFamily[CollectionFamily["Events"] = 2] = "Events";
+    CollectionFamily[CollectionFamily["Counter"] = 3] = "Counter";
+    CollectionFamily[CollectionFamily["Membership"] = 4] = "Membership";
+    CollectionFamily[CollectionFamily["Unique"] = 5] = "Unique";
+    CollectionFamily[CollectionFamily["Capacity"] = 6] = "Capacity";
+})(CollectionFamily || (CollectionFamily = {}));
+export var DbFunctionKind;
+(function (DbFunctionKind) {
+    DbFunctionKind["Query"] = "query";
+    DbFunctionKind["Action"] = "action";
+    DbFunctionKind["Derive"] = "derive";
+    DbFunctionKind["Job"] = "job";
+    DbFunctionKind["Admin"] = "admin";
+})(DbFunctionKind || (DbFunctionKind = {}));
+export function isCollectionFamily(value) {
+    return value >= CollectionFamily.Record && value <= CollectionFamily.Capacity;
+}
+export function freshDbState() {
+    return {
+        handles: [],
+        lastResult: null,
+        lastResultVersion: -1,
+        functionKind: DbFunctionKind.Job,
+    };
+}
+export const MAX_RESERVATIONS = 4096;
+export const MAX_RESERVATION_TTL_MS = 86_400_000;
+export const MAX_NAME = 512;
+export const MAX_KEY = 4096;
+export const MAX_VALUE = 256 * 1024;
+export const DEFAULT_FILL_WAIT_MS = 50;
+export const MAX_FILL_WAIT_MS = 60_000;
+const I64_MIN = -(2n ** 63n);
+const I64_MAX = 2n ** 63n - 1n;
+export function satI64(v) {
+    return v < I64_MIN ? I64_MIN : v > I64_MAX ? I64_MAX : v;
+}
+export const ABSENT = -2;
+export const TOO_SMALL = -1;
+export const INVALID_HANDLE = -1001;
+export const ALREADY_EXISTS = -1003;
+export const CONFLICT = -1004;
+export const UNAVAILABLE = -1031;
+export const CODEC_ERR = -1006;
+export const OP_NOT_ALLOWED_FOR_FAMILY = -1010;
+export const OP_NOT_ALLOWED_IN_KIND = -1011;
+export const TOO_MANY_KEYS = -1020;
+export const SCHEMA_UNAVAILABLE = -1070;

package/build/devserver/email/index.js

@@ -1,4 +1,4 @@
-import { loadEnvFiles } from '../dotenv.js';
+import { loadEnvFiles } from '../config/dotenv.js';
 import { EmailCaps } from './caps.js';
 import { resolveEmailConfig } from './config.js';
 import { sendVia } from './providers.js';

package/build/devserver/index.d.ts

@@ -1,24 +1,19 @@
-import type { EmailBackendConfig } from 'toiljs/shared';
-import { type ViteTarget } from './proxy.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';
-export { buildHostImports, freshDispatchState } from './host.js';
-export type { DispatchState, MemoryRef } from './host.js';
-export type { ViteTarget } from './proxy.js';
-export interface DevServerOptions {
-    readonly root: string;
-    readonly port: number;
-    readonly host?: string;
-    readonly wasmFile: string;
-    readonly vite: ViteTarget;
-    readonly maxBodyLength?: number;
-    readonly email?: EmailBackendConfig;
-}
-export interface RunningDevServer {
-    readonly port: number;
-    readonly host: string;
-    close(): Promise<void>;
-}
-export declare function startDevServer(options: DevServerOptions): Promise<RunningDevServer>;
+export { startDevServer } from './server.js';
+export type { DevServerOptions, RunningDevServer } from './server.js';
+export { METHOD_CODES, encodeRequestEnvelope, decodeResponseEnvelope, unpackHandleResult, } from './http/envelope.js';
+export type { EnvelopeRequest, EnvelopeResponse } from './http/envelope.js';
+export { WasmServerModule, WasmAbortError, UNHANDLED_HEADER } from './runtime/module.js';
+export type { WasmDispatchResult } from './runtime/module.js';
+export { buildHostImports, freshDispatchState } from './runtime/host.js';
+export type { DispatchState, MemoryRef } from './runtime/host.js';
+export type { ViteTarget } from './http/proxy.js';
+export { DaemonHost, daemonEmulationEnabled } from './daemon/index.js';
+export { parseDaemonCatalog } from './daemon/catalog.js';
+export type { DaemonCatalog, ScheduledTask, CronMasks } from './daemon/catalog.js';
+export { buildDaemonImports, freshDaemonState } from './daemon/host.js';
+export type { DaemonState, DaemonRuntime, ResolvedDaemonConfig } from './daemon/host.js';
+export { cronMatches, cronNeverFires, nextCronFireMs } from './daemon/cron.js';
+export { parseSurface } from './wasm/surface.js';
+export type { Surface, SurfaceFlags } from './wasm/surface.js';
+export { customSection } from './wasm/sections.js';
+export { DevMemoryStore, devMemoryStore } from './mstore/store.js';

package/build/devserver/index.js

@@ -1,165 +1,11 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { Server } from '@dacely/hyper-express';
-import pc from 'picocolors';
-import { applyCacheRule, lookupCache } from './cache.js';
-import { initEmailService } from './email/index.js';
-import { METHOD_CODES } from './envelope.js';
-import { WasmServerModule } from './module.js';
-import { proxyToVite, wireWebsocketProxy } from './proxy.js';
-export { METHOD_CODES, encodeRequestEnvelope, decodeResponseEnvelope, unpackHandleResult, } from './envelope.js';
-export { WasmServerModule, WasmAbortError, UNHANDLED_HEADER } from './module.js';
-export { buildHostImports, freshDispatchState } from './host.js';
-const DEFAULT_MAX_BODY_LENGTH = 1024 * 1024 * 8;
-const VITE_PREFIXES = ['/@', '/node_modules/', '/__toil/'];
-const MIME = {
-    '.html': 'text/html; charset=utf-8',
-    '.js': 'text/javascript; charset=utf-8',
-    '.mjs': 'text/javascript; charset=utf-8',
-    '.css': 'text/css; charset=utf-8',
-    '.json': 'application/json; charset=utf-8',
-    '.txt': 'text/plain; charset=utf-8',
-    '.svg': 'image/svg+xml',
-    '.png': 'image/png',
-    '.jpg': 'image/jpeg',
-    '.jpeg': 'image/jpeg',
-    '.webp': 'image/webp',
-    '.avif': 'image/avif',
-    '.gif': 'image/gif',
-    '.ico': 'image/x-icon',
-    '.wasm': 'application/wasm',
-    '.woff2': 'font/woff2',
-};
-function isViteInternal(url) {
-    return VITE_PREFIXES.some((p) => url.startsWith(p));
-}
-function resolveSendfile(root, file) {
-    const resolved = path.resolve(root, file);
-    if (resolved !== root && !resolved.startsWith(root + path.sep))
-        return null;
-    if (!fs.existsSync(resolved) || !fs.statSync(resolved).isFile())
-        return null;
-    return resolved;
-}
-async function toEnvelopeRequest(request) {
-    const hasBody = request.method !== 'GET' && request.method !== 'HEAD';
-    const body = hasBody ? new Uint8Array(await request.buffer()) : new Uint8Array(0);
-    const xff = request.headers['x-forwarded-for'];
-    const clientIp = typeof xff === 'string' && xff.length > 0 ? xff.split(',')[0].trim() : '127.0.0.1';
-    return {
-        method: request.method,
-        path: request.url,
-        headers: Object.entries(request.headers),
-        body,
-        clientIp,
-    };
-}
-function sendWasmResponse(response, root, result) {
-    response.status(result.status);
-    let hasContentType = false;
-    for (const [name, value] of result.headers) {
-        if (name.toLowerCase() === 'content-type')
-            hasContentType = true;
-        response.header(name, value);
-    }
-    response.header('server', 'toil-dev');
-    if (result.sendfile !== null) {
-        const file = resolveSendfile(root, result.sendfile);
-        if (file === null) {
-            response.status(404).send('not found\n');
-            return;
-        }
-        if (!hasContentType) {
-            response.header('content-type', MIME[path.extname(file).toLowerCase()] ?? 'application/octet-stream');
-        }
-        response.sendFile(file);
-        return;
-    }
-    if (!hasContentType)
-        response.header('content-type', 'text/plain; charset=utf-8');
-    response.send(Buffer.from(result.body.buffer, result.body.byteOffset, result.body.length));
-}
-export async function startDevServer(options) {
-    const host = options.host ?? '127.0.0.1';
-    const root = path.resolve(options.root);
-    const emailInit = initEmailService(root, options.email);
-    if (emailInit.service !== null) {
-        process.stdout.write(pc.dim(`  ✉ email enabled: ${emailInit.note}`) + '\n');
-    }
-    else if (emailInit.note !== null) {
-        process.stdout.write(pc.yellow('  ! ') + pc.dim(`email off: ${emailInit.note}`) + '\n');
-    }
-    const module = new WasmServerModule(options.wasmFile);
-    let warnedMissing = false;
-    let loadedOnce = false;
-    const refresh = () => {
-        try {
-            if (module.refresh() && loadedOnce) {
-                process.stdout.write(pc.green('  ✓ ') + pc.dim('server module reloaded') + '\n');
-            }
-            loadedOnce ||= module.available;
-        }
-        catch (e) {
-            process.stdout.write(pc.red(`  ✗ server wasm failed to load: ${String(e)}`) + '\n');
-        }
-        if (!module.available && !warnedMissing) {
-            warnedMissing = true;
-            process.stdout.write(pc.yellow('  ! ') +
-                pc.dim(`server wasm not found at ${options.wasmFile}; serving client only`) +
-                '\n');
-        }
-    };
-    refresh();
-    const app = new Server({
-        max_body_length: options.maxBodyLength ?? DEFAULT_MAX_BODY_LENGTH,
-        max_body_buffer: 1024 * 32,
-        fast_abort: true,
-    });
-    app.set_error_handler((_request, response, error) => {
-        if (response.completed)
-            return;
-        response.atomic(() => {
-            response.status(500).send(`internal error: ${error.message}\n`);
-        });
-    });
-    wireWebsocketProxy(app, options.vite);
-    app.any('/*', async (request, response) => {
-        response.removeHeader('uWebSockets');
-        const dispatchable = !isViteInternal(request.url) && METHOD_CODES[request.method] !== undefined;
-        if (dispatchable)
-            refresh();
-        if (dispatchable && module.available) {
-            const envelopeReq = await toEnvelopeRequest(request);
-            const cacheHost = request.headers.host ?? 'dev';
-            const hasAuth = request.headers.cookie !== undefined || request.headers.authorization !== undefined;
-            const cached = lookupCache(cacheHost, request.method, request.url, envelopeReq.body);
-            if (cached !== null) {
-                sendWasmResponse(response, root, cached);
-                return;
-            }
-            try {
-                const result = module.dispatch(envelopeReq);
-                if (!result.unhandled) {
-                    const finalized = applyCacheRule(cacheHost, request.method, request.url, envelopeReq.body, hasAuth, result);
-                    sendWasmResponse(response, root, finalized);
-                    return;
-                }
-            }
-            catch (e) {
-                process.stdout.write(pc.red(`  ✗ ${request.method} ${request.path} server error: ${String(e)}`) +
-                    '\n');
-                response.status(500).send('internal error\n');
-                return;
-            }
-        }
-        await proxyToVite(request, response, options.vite);
-    });
-    await app.listen(options.port, host);
-    return {
-        port: options.port,
-        host,
-        close: async () => {
-            await app.shutdown();
-        },
-    };
-}
+export { startDevServer } from './server.js';
+export { METHOD_CODES, encodeRequestEnvelope, decodeResponseEnvelope, unpackHandleResult, } from './http/envelope.js';
+export { WasmServerModule, WasmAbortError, UNHANDLED_HEADER } from './runtime/module.js';
+export { buildHostImports, freshDispatchState } from './runtime/host.js';
+export { DaemonHost, daemonEmulationEnabled } from './daemon/index.js';
+export { parseDaemonCatalog } from './daemon/catalog.js';
+export { buildDaemonImports, freshDaemonState } from './daemon/host.js';
+export { cronMatches, cronNeverFires, nextCronFireMs } from './daemon/cron.js';
+export { parseSurface } from './wasm/surface.js';
+export { customSection } from './wasm/sections.js';
+export { DevMemoryStore, devMemoryStore } from './mstore/store.js';

package/build/devserver/mstore/store.d.ts

@@ -0,0 +1,18 @@
+export declare class DevMemoryStore {
+    private readonly map;
+    private now;
+    private live;
+    private exp;
+    get(key: string): Buffer | null;
+    set(key: string, value: Buffer, ttlSecs: number): void;
+    delete(key: string): boolean;
+    incr(key: string, delta: bigint, ttlSecs: number): bigint | null;
+    cas(key: string, expect: Buffer | null, next: Buffer, ttlSecs: number): boolean;
+    expire(key: string, ttlSecs: number): boolean;
+    scan(prefix: string, cursor: bigint): {
+        next: bigint;
+        keys: string[];
+    } | null;
+    __reset(): void;
+}
+export declare const devMemoryStore: DevMemoryStore;

package/build/devserver/mstore/store.js

@@ -0,0 +1,82 @@
+export class DevMemoryStore {
+    map = new Map();
+    now() {
+        return Date.now();
+    }
+    live(key) {
+        const e = this.map.get(key);
+        if (e === undefined)
+            return null;
+        if (e.expiresAtMs !== 0 && e.expiresAtMs <= this.now()) {
+            this.map.delete(key);
+            return null;
+        }
+        return e;
+    }
+    exp(ttlSecs) {
+        return ttlSecs > 0 ? this.now() + ttlSecs * 1000 : 0;
+    }
+    get(key) {
+        const e = this.live(key);
+        return e ? e.value : null;
+    }
+    set(key, value, ttlSecs) {
+        this.map.set(key, { value: Buffer.from(value), expiresAtMs: this.exp(ttlSecs) });
+    }
+    delete(key) {
+        return this.map.delete(key);
+    }
+    incr(key, delta, ttlSecs) {
+        const e = this.live(key);
+        let cur = 0n;
+        if (e !== null) {
+            const s = e.value.toString('utf8').trim();
+            if (!/^-?\d+$/.test(s))
+                return null;
+            try {
+                cur = BigInt(s);
+            }
+            catch {
+                return null;
+            }
+        }
+        const next = BigInt.asIntN(64, cur + delta);
+        this.map.set(key, {
+            value: Buffer.from(next.toString(), 'utf8'),
+            expiresAtMs: ttlSecs > 0 ? this.exp(ttlSecs) : (e?.expiresAtMs ?? 0),
+        });
+        return next;
+    }
+    cas(key, expect, next, ttlSecs) {
+        const e = this.live(key);
+        if (expect === null) {
+            if (e !== null)
+                return false;
+        }
+        else if (e === null || !e.value.equals(expect)) {
+            return false;
+        }
+        this.map.set(key, { value: Buffer.from(next), expiresAtMs: this.exp(ttlSecs) });
+        return true;
+    }
+    expire(key, ttlSecs) {
+        const e = this.live(key);
+        if (!e)
+            return false;
+        e.expiresAtMs = this.exp(ttlSecs);
+        return true;
+    }
+    scan(prefix, cursor) {
+        const live = [...this.map.keys()].filter((k) => this.live(k) !== null && k.startsWith(prefix));
+        live.sort();
+        const start = Number(cursor);
+        if (start < 0 || start > live.length)
+            return null;
+        const batch = live.slice(start);
+        return { next: BigInt(live.length), keys: batch };
+    }
+    __reset() {
+        this.map.clear();
+    }
+}
+export const devMemoryStore = new DevMemoryStore();

package/build/devserver/{host.d.ts → runtime/host.d.ts}

@@ -1,5 +1,5 @@
+import { type DbDevState } from '../db/index.js';
 import { type CryptoState } from './crypto.js';
-import { type DbDevState } from './database.js';
 export declare class WasmAbortError extends Error {
     constructor(message: string, fileName: string, line: number, column: number);
 }
@@ -16,4 +16,10 @@ export declare function freshDispatchState(): DispatchState;
 export interface MemoryRef {
     memory: WebAssembly.Memory | null;
 }
+export declare function readBytes(ref: MemoryRef, ptr: number, len: number): Buffer;
+export declare function writeBytesOut(ref: MemoryRef, bytes: Buffer, outPtr: number, outCap: number): number;
+export declare function buildEnvImports(ref: MemoryRef, _state: {
+    crypto: CryptoState;
+    db: DbDevState;
+}): Record<string, (...a: never[]) => unknown>;
 export declare function buildHostImports(ref: MemoryRef, state: DispatchState): WebAssembly.Imports;