lumbda/wasm/asm/lumbda-asm.loader.js

// wasm/asm/lumbda-asm.loader.js
// Asm tier loader — instantiates lumbda-asm.wasm and exposes evalLisp.
//
// Memory layout (mirrors lumbda.wat):
//   0x10000  output buffer (read after each call)
//   0x20000  source buffer (write before each call)
//   0x40000  bend response scratch (host writes here when JS dispatches)

async function _bootstrap() {
    const wasmURL = new URL("./lumbda-asm.wasm", import.meta.url).href;
    const resp = await fetch(wasmURL);
    const bytes = await resp.arrayBuffer();

    // Closure-captured holder so the imported function can see the
    // instance's memory after instantiation completes.
    const refs = { instance: null, bendUrl: null, currentOnChunk: null };

    const importObj = {
        env: {
            // bend_call(src_ptr, src_len, resp_ptr) -> resp_len.
            // Synchronous XHR is the only sync HTTP available in workers;
            // perfect for the WAT tier's blocking eval model.
            bend_call(srcPtr, srcLen, respPtr) {
                if (!refs.bendUrl) {
                    const msg = "no bend URL configured";
                    const mem = new Uint8Array(refs.instance.exports.memory.buffer);
                    mem.set(new TextEncoder().encode(msg), respPtr);
                    return msg.length;
                }
                const mem = new Uint8Array(refs.instance.exports.memory.buffer);
                const payload = new TextDecoder().decode(mem.slice(srcPtr, srcPtr + srcLen));
                try {
                    const xhr = new XMLHttpRequest();
                    xhr.open("POST", refs.bendUrl, false);  // sync
                    xhr.setRequestHeader("Content-Type", "text/plain; charset=utf-8");
                    xhr.send(payload);
                    const respText = xhr.responseText || "";
                    const respBytes = new TextEncoder().encode(respText);
                    new Uint8Array(refs.instance.exports.memory.buffer).set(respBytes, respPtr);
                    return respBytes.length;
                } catch (e) {
                    const err = "bend error: " + (e.message || String(e));
                    new Uint8Array(refs.instance.exports.memory.buffer)
                        .set(new TextEncoder().encode(err), respPtr);
                    return err.length;
                }
            },
            // emit_chunk(ptr, len) — WAT's out_char calls this on every
            // newline (and lumbda_eval calls it once more at the end for
            // trailing non-newline content) so the worker can postMessage
            // a chunk to the playground panel as work happens, matching
            // the C-tier Module.print + pyodide _StreamingStdout streams.
            emit_chunk(ptr, len) {
                if (!refs.currentOnChunk || len <= 0) return;
                const mem = new Uint8Array(refs.instance.exports.memory.buffer, ptr, len);
                refs.currentOnChunk(new TextDecoder().decode(mem));
            },
        },
    };

    const { instance } = await WebAssembly.instantiate(bytes, importObj);
    refs.instance = instance;
    instance.exports.lumbda_init();

    const enc = new TextEncoder();
    const dec = new TextDecoder();
    const exp = instance.exports;

    return {
        async evalLisp(src, onChunk) {
            const srcBytes = enc.encode(src);
            const srcPtr = exp.lumbda_source_ptr();
            const mem = new Uint8Array(exp.memory.buffer);
            mem.set(srcBytes, srcPtr);
            refs.currentOnChunk = onChunk || null;
            try {
                exp.lumbda_eval(srcBytes.length);
            } catch (e) {
                refs.currentOnChunk = null;
                return `error: ${e.message}`;
            }
            refs.currentOnChunk = null;
            const outPtr = exp.lumbda_output_ptr();
            const outLen = exp.lumbda_output_len();
            return dec.decode(new Uint8Array(exp.memory.buffer, outPtr, outLen));
        },
        setBendUrl(url) { refs.bendUrl = url || null; },
        heapStats() {
            return {
                used: exp.lumbda_heap_used(),
                total: exp.lumbda_heap_total(),
            };
        },
    };
}

// Closure-encapsulated singleton (see lumbda-c.loader.js for rationale).
export const createAsmTier = (() => {
    let tier = null;
    return async () => {
        if (!tier) tier = await _bootstrap();
        return tier;
    };
})();