toiljs 0.0.59 → 0.0.61

package/build/devserver/{host.js → runtime/host.js}

@@ -1,9 +1,9 @@
+import { devEnvGet, devEnvGetSecure } from '../config/env.js';
+import { ratelimitCheck } from '../config/ratelimit.js';
+import { buildDatabaseImports, freshDbState } from '../db/index.js';
+import { EmailStatus, getEmailService } from '../email/index.js';
+import { parseEmailBlob } from '../email/wire.js';
 import { buildCryptoImports, freshCryptoState } from './crypto.js';
-import { buildDatabaseImports, freshDbState } from './database.js';
-import { EmailStatus, getEmailService } from './email/index.js';
-import { parseEmailBlob } from './email/wire.js';
-import { devEnvGet, devEnvGetSecure } from './env.js';
-import { ratelimitCheck } from './ratelimit.js';
 const MAX_TOTAL_HEADERS_BYTES = 64 * 1024;
 const MAX_HEADER_NAME_LEN = 256;
 const MAX_HEADER_VALUE_LEN = 8192;
@@ -32,12 +32,21 @@ function mem(ref) {
         throw new Error('host import called before memory was bound');
     return Buffer.from(ref.memory.buffer);
 }
-function readBytes(ref, ptr, len) {
+export function readBytes(ref, ptr, len) {
     const m = mem(ref);
     if (ptr < 0 || len < 0 || ptr + len > m.length)
         throw new Error(`host import read out of bounds: ptr=${String(ptr)} len=${String(len)}`);
     return m.subarray(ptr, ptr + len);
 }
+export function writeBytesOut(ref, bytes, outPtr, outCap) {
+    if (bytes.length > outCap)
+        return -1;
+    const m = mem(ref);
+    if (outPtr < 0 || outPtr + bytes.length > m.length)
+        throw new Error('host import write out of bounds');
+    bytes.copy(m, outPtr);
+    return bytes.length;
+}
 function readGuestString(ref, ptr) {
     if (ptr === 0)
         return '';
@@ -80,6 +89,41 @@ function envLookup(ref, keyPtr, keyLen, outPtr, outCap, secure) {
     bytes.copy(m, outPtr);
     return bytes.length;
 }
+export function buildEnvImports(ref, _state) {
+    return {
+        abort: (msgPtr, filePtr, line, col) => {
+            throw new WasmAbortError(readGuestString(ref, msgPtr), readGuestString(ref, filePtr), line, col);
+        },
+        env_get: (keyPtr, keyLen, outPtr, outCap) => envLookup(ref, keyPtr, keyLen, outPtr, outCap, false),
+        env_get_secure: (keyPtr, keyLen, outPtr, outCap) => envLookup(ref, keyPtr, keyLen, outPtr, outCap, true),
+        thread_spawn: (_startArg) => -1,
+        'Date.now': () => BigInt(Date.now()),
+        email_send: (reqPtr, reqLen) => {
+            const raw = readBytes(ref, reqPtr, reqLen);
+            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`);
+                return EmailStatus.Sent;
+            }
+            const { status, parsed } = svc.prepare(raw);
+            if (parsed === null) {
+                process.stdout.write(`  ✉ dev email_send -> ${EmailStatus[status]}\n`);
+                return status;
+            }
+            void svc
+                .deliver(parsed)
+                .then((s) => {
+                const label = s === EmailStatus.Sent ? 'sent' : EmailStatus[s];
+                process.stdout.write(`  ✉ dev email_send -> ${parsed.to} (${label})\n`);
+            })
+                .catch((e) => {
+                process.stdout.write(`  ✉ dev email_send -> ${parsed.to} (error: ${String(e)})\n`);
+            });
+            return EmailStatus.Sent;
+        },
+    };
+}
 export function buildHostImports(ref, state) {
     return {
         env: {
@@ -157,7 +201,7 @@ export function buildHostImports(ref, state) {
             env_get: (keyPtr, keyLen, outPtr, outCap) => envLookup(ref, keyPtr, keyLen, outPtr, outCap, false),
             env_get_secure: (keyPtr, keyLen, outPtr, outCap) => envLookup(ref, keyPtr, keyLen, outPtr, outCap, true),
             thread_spawn: (_startArg) => -1,
-            'Date.now': () => Date.now(),
+            'Date.now': () => BigInt(Date.now()),
             ...buildCryptoImports(ref, state.crypto),
             ...buildDatabaseImports(ref, state.db),
         },

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

@@ -1,4 +1,4 @@
-import { type EnvelopeRequest } from './envelope.js';
+import { type EnvelopeRequest } from '../http/envelope.js';
 export { WasmAbortError } from './host.js';
 export declare const UNHANDLED_HEADER = "x-toil-unhandled";
 export interface WasmDispatchResult {
@@ -12,6 +12,7 @@ export declare class WasmServerModule {
     private readonly wasmPath;
     private module;
     private loadedMtimeMs;
+    private routeKinds;
     constructor(wasmPath: string);
     get available(): boolean;
     refresh(): boolean;

package/build/devserver/{module.js → runtime/module.js}

@@ -1,9 +1,25 @@
 import fs from 'node:fs';
-import { decodeResponseEnvelope, encodeRequestEnvelope, unpackHandleResult, } from './envelope.js';
+import { DbFunctionKind, persistDb, setDbCatalog } from '../db/index.js';
+import { parseRouteKinds, routeKindForRequest } from '../db/routeKinds.js';
+import { decodeResponseEnvelope, encodeRequestEnvelope, unpackHandleResult, } from '../http/envelope.js';
 import { buildHostImports, freshDispatchState } from './host.js';
 export { WasmAbortError } from './host.js';
 export const UNHANDLED_HEADER = 'x-toil-unhandled';
 const WASM_PAGE = 65536;
+function dbKindForHttpMethod(method) {
+    switch (method.toUpperCase()) {
+        case 'GET':
+        case 'HEAD':
+        case 'OPTIONS':
+            return DbFunctionKind.Query;
+        case 'POST':
+        case 'PUT':
+        case 'PATCH':
+        case 'DELETE':
+        default:
+            return DbFunctionKind.Action;
+    }
+}
 const PROVIDED_IMPORTS = new Set([
     'abort',
     'set_status',
@@ -50,6 +66,8 @@ const PROVIDED_IMPORTS = new Set([
     'data.counter_get',
     'data.counter_add',
     'data.append',
+    'data.append_once',
+    'data.enqueue',
     'data.latest',
     'data.capacity_set_total',
     'data.capacity_available',
@@ -57,11 +75,14 @@ const PROVIDED_IMPORTS = new Set([
     'data.capacity_confirm',
     'data.capacity_cancel',
     'data.take_result',
+    'data.result_schema_version',
+    'data.write_allowed',
 ]);
 export class WasmServerModule {
     wasmPath;
     module = null;
     loadedMtimeMs = -1;
+    routeKinds = [];
     constructor(wasmPath) {
         this.wasmPath = wasmPath;
     }
@@ -75,6 +96,7 @@ export class WasmServerModule {
         }
         catch {
             this.module = null;
+            this.routeKinds = [];
             this.loadedMtimeMs = -1;
             return false;
         }
@@ -84,6 +106,8 @@ export class WasmServerModule {
         const module = new WebAssembly.Module(bytes);
         this.assertImportSurface(module);
         this.assertExportSurface(module);
+        setDbCatalog(bytes);
+        this.routeKinds = parseRouteKinds(bytes);
         this.module = module;
         this.loadedMtimeMs = mtimeMs;
         return true;
@@ -95,6 +119,13 @@ export class WasmServerModule {
         const ref = { memory: null };
         const state = freshDispatchState();
         state.clientIp = req.clientIp ?? '';
+        const routeKind = routeKindForRequest(this.routeKinds, req.method, req.path);
+        state.db.functionKind =
+            this.routeKinds.length === 0
+                ? DbFunctionKind.Job
+                : routeKind === DbFunctionKind.Query
+                    ? DbFunctionKind.Query
+                    : dbKindForHttpMethod(req.method);
         const instance = new WebAssembly.Instance(this.module, buildHostImports(ref, state));
         const exports = instance.exports;
         ref.memory = exports.memory;
@@ -110,6 +141,7 @@ export class WasmServerModule {
         const headers = [...resp.headers, ...state.headers];
         const status = state.status ?? resp.status;
         const unhandled = headers.some(([n]) => n.toLowerCase() === UNHANDLED_HEADER);
+        persistDb();
         return {
             status,
             headers: headers.filter(([n]) => n.toLowerCase() !== UNHANDLED_HEADER),
@@ -125,6 +157,7 @@ export class WasmServerModule {
         const ref = { memory: null };
         const state = freshDispatchState();
         state.clientIp = req.clientIp ?? '';
+        state.db.functionKind = DbFunctionKind.Query;
         const instance = new WebAssembly.Instance(this.module, buildHostImports(ref, state));
         const exports = instance.exports;
         if (typeof exports.render !== 'function')

package/build/devserver/server.d.ts

@@ -0,0 +1,23 @@
+import type { EmailBackendConfig } from 'toiljs/shared';
+import type { ResolvedDaemonConfig } from './daemon/host.js';
+import { type ViteTarget } from './http/proxy.js';
+import { type DevSsrTemplate } from './ssr.js';
+export interface DevServerOptions {
+    readonly root: string;
+    readonly port: number;
+    readonly host?: string;
+    readonly wasmFile: string;
+    readonly coldWasmFile?: string;
+    readonly nodeMode?: string;
+    readonly daemon?: ResolvedDaemonConfig;
+    readonly vite: ViteTarget;
+    readonly maxBodyLength?: number;
+    readonly email?: EmailBackendConfig;
+    readonly ssrTemplates?: readonly DevSsrTemplate[];
+}
+export interface RunningDevServer {
+    readonly port: number;
+    readonly host: string;
+    close(): Promise<void>;
+}
+export declare function startDevServer(options: DevServerOptions): Promise<RunningDevServer>;

package/build/devserver/server.js

@@ -0,0 +1,223 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { Server } from '@dacely/hyper-express';
+import pc from 'picocolors';
+import { DaemonHost, daemonEmulationEnabled } from './daemon/index.js';
+import { configureDbPersistence } from './db/index.js';
+import { initEmailService } from './email/index.js';
+import { applyCacheRule, lookupCache } from './http/cache.js';
+import { METHOD_CODES } from './http/envelope.js';
+import { proxyToVite, wireWebsocketProxy } from './http/proxy.js';
+import { WasmServerModule } from './runtime/module.js';
+import { assembleSsr, buildSsrRoutes, pathnameOf, } from './ssr.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));
+}
+function sendSsr(response, out, headOnly) {
+    response.status(out.status);
+    let hasContentType = false;
+    for (const [name, value] of out.headers) {
+        if (name.toLowerCase() === 'content-type')
+            hasContentType = true;
+        response.header(name, value);
+    }
+    if (!hasContentType)
+        response.header('content-type', 'text/html; charset=utf-8');
+    response.header('server', 'toil-dev');
+    if (headOnly) {
+        response.send('');
+        return;
+    }
+    response.send(Buffer.from(out.html.buffer, out.html.byteOffset, out.html.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);
+    const ssrRoutes = buildSsrRoutes(options.ssrTemplates ?? []);
+    if (ssrRoutes.length > 0) {
+        process.stdout.write(pc.dim(`  edge SSR: ${String(ssrRoutes.length)} route(s) served server-side`) + '\n');
+    }
+    configureDbPersistence(path.join(root, '.toil', 'devdata.json'));
+    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);
+    const nodeMode = options.nodeMode ?? 'all';
+    let daemonHost = null;
+    let daemonTimer = null;
+    if (options.coldWasmFile !== undefined && daemonEmulationEnabled(nodeMode) && options.daemon) {
+        daemonHost = new DaemonHost(options.coldWasmFile, options.daemon, nodeMode);
+        const pollDaemon = () => {
+            try {
+                daemonHost?.refresh();
+            }
+            catch (e) {
+                process.stdout.write(pc.red(`  ✗ daemon reload failed: ${String(e)}`) + '\n');
+            }
+        };
+        pollDaemon();
+        daemonTimer = setInterval(pollDaemon, 500);
+        daemonTimer.unref?.();
+    }
+    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;
+            }
+            if ((request.method === 'GET' || request.method === 'HEAD') &&
+                ssrRoutes.length > 0) {
+                const route = ssrRoutes.find((r) => r.test(pathnameOf(request.url)));
+                if (route) {
+                    try {
+                        const out = assembleSsr(route, module.dispatchRender(envelopeReq));
+                        if (out !== null) {
+                            sendSsr(response, out, request.method === 'HEAD');
+                            return;
+                        }
+                    }
+                    catch (e) {
+                        process.stdout.write(pc.red(`  ✗ SSR ${request.path}: ${String(e)}`) + '\n');
+                    }
+                }
+            }
+        }
+        await proxyToVite(request, response, options.vite);
+    });
+    await app.listen(options.port, host);
+    return {
+        port: options.port,
+        host,
+        close: async () => {
+            if (daemonTimer !== null)
+                clearInterval(daemonTimer);
+            daemonHost?.close();
+            await app.shutdown();
+        },
+    };
+}

package/build/devserver/ssr.d.ts

@@ -0,0 +1,25 @@
+export interface DevSsrTemplate {
+    pattern: string;
+    name: string;
+    tmpl: Uint8Array;
+    entries: {
+        id: number;
+        offset: number;
+    }[];
+}
+export interface SsrRoute {
+    test: (pathname: string) => boolean;
+    tmpl: Uint8Array;
+    entries: {
+        id: number;
+        offset: number;
+    }[];
+}
+export declare function pathnameOf(url: string): string;
+export declare function buildSsrRoutes(templates: readonly DevSsrTemplate[]): SsrRoute[];
+export interface SsrResult {
+    status: number;
+    headers: [string, string][];
+    html: Uint8Array;
+}
+export declare function assembleSsr(route: SsrRoute, envelope: Uint8Array): SsrResult | null;

package/build/devserver/ssr.js

@@ -0,0 +1,114 @@
+export function pathnameOf(url) {
+    const q = url.indexOf('?');
+    return q < 0 ? url : url.slice(0, q);
+}
+function patternToTest(pattern) {
+    const norm = (p) => (p.length > 1 && p.endsWith('/') ? p.slice(0, -1) : p);
+    let re = '';
+    let i = 0;
+    while (i < pattern.length) {
+        const ch = pattern[i];
+        if (ch === ':') {
+            i++;
+            while (i < pattern.length && /[A-Za-z0-9_]/.test(pattern[i]))
+                i++;
+            re += '[^/]+';
+        }
+        else if (ch === '*') {
+            re += '.*';
+            i++;
+        }
+        else if (ch === '[') {
+            const end = pattern.indexOf(']', i);
+            const inner = end < 0 ? '' : pattern.slice(i + 1, end);
+            re += inner.startsWith('...') ? '.*' : '[^/]+';
+            i = end < 0 ? pattern.length : end + 1;
+        }
+        else {
+            re += ch.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            i++;
+        }
+    }
+    const compiled = new RegExp(`^${re}$`);
+    return (pathname) => compiled.test(norm(pathname));
+}
+export function buildSsrRoutes(templates) {
+    return templates.map((t) => ({ test: patternToTest(t.pattern), tmpl: t.tmpl, entries: t.entries }));
+}
+function decodeValues(buf) {
+    const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    let o = 0;
+    const need = (n) => o + n <= buf.byteLength;
+    try {
+        if (!need(2 + 32 + 2))
+            return null;
+        const status = dv.getUint16(o, true);
+        o += 2;
+        o += 32;
+        const nHeaders = dv.getUint16(o, true);
+        o += 2;
+        const headers = [];
+        const dec = new TextDecoder();
+        for (let i = 0; i < nHeaders; i++) {
+            if (!need(4))
+                return null;
+            const nameLen = dv.getUint16(o, true);
+            const valLen = dv.getUint16(o + 2, true);
+            o += 4;
+            if (!need(nameLen + valLen))
+                return null;
+            const name = dec.decode(buf.subarray(o, o + nameLen));
+            o += nameLen;
+            const val = dec.decode(buf.subarray(o, o + valLen));
+            o += valLen;
+            headers.push([name, val]);
+        }
+        if (!need(2))
+            return null;
+        const nSlots = dv.getUint16(o, true);
+        o += 2;
+        const values = new Map();
+        for (let i = 0; i < nSlots; i++) {
+            if (!need(2 + 1 + 4))
+                return null;
+            const id = dv.getUint16(o, true);
+            o += 2;
+            o += 1;
+            const len = dv.getUint32(o, true);
+            o += 4;
+            if (!need(len))
+                return null;
+            values.set(id, buf.subarray(o, o + len));
+            o += len;
+        }
+        return { status, headers, values };
+    }
+    catch {
+        return null;
+    }
+}
+function splice(tmpl, inserts) {
+    const parts = [];
+    let prev = 0;
+    for (const ins of inserts) {
+        if (ins.offset > prev)
+            parts.push(tmpl.subarray(prev, ins.offset));
+        if (ins.value.length > 0)
+            parts.push(ins.value);
+        prev = ins.offset;
+    }
+    if (tmpl.length > prev)
+        parts.push(tmpl.subarray(prev));
+    return Buffer.concat(parts.map((p) => Buffer.from(p.buffer, p.byteOffset, p.byteLength)));
+}
+export function assembleSsr(route, envelope) {
+    const decoded = decodeValues(envelope);
+    if (decoded === null)
+        return null;
+    if (decoded.status >= 500 || decoded.values.size === 0)
+        return null;
+    const inserts = route.entries
+        .map((e) => ({ offset: e.offset, value: decoded.values.get(e.id) ?? new Uint8Array(0) }))
+        .sort((a, b) => a.offset - b.offset);
+    return { status: decoded.status, headers: decoded.headers, html: splice(route.tmpl, inserts) };
+}

package/build/devserver/wasm/sections.d.ts

@@ -0,0 +1,2 @@
+export declare function leb(buf: Buffer, pos: number): [number, number];
+export declare function customSection(wasm: Buffer, want: string): Buffer | null;

package/build/devserver/wasm/sections.js

@@ -0,0 +1,42 @@
+export 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];
+}
+export function customSection(wasm, want) {
+    if (wasm.length < 8 ||
+        wasm[0] !== 0x00 ||
+        wasm[1] !== 0x61 ||
+        wasm[2] !== 0x73 ||
+        wasm[3] !== 0x6d)
+        return null;
+    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) {
+            const [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;
+}

package/build/devserver/wasm/surface.d.ts

@@ -0,0 +1,18 @@
+export interface SurfaceFlags {
+    readonly rest: boolean;
+    readonly stream: boolean;
+    readonly daemon: boolean;
+    readonly scheduled: boolean;
+    readonly database: boolean;
+    readonly render: boolean;
+}
+export interface Surface {
+    readonly targetMode: 'hot' | 'cold';
+    readonly flags: SurfaceFlags;
+    readonly abiVersion: number;
+    readonly buildId: string;
+    readonly fingerprint: number;
+    readonly dataCoherenceHash: number;
+    readonly pairCoherenceHash: number;
+}
+export declare function parseSurface(wasm: Buffer): Surface | 'absent' | 'invalid';