Function makeCompilerEnv

runtime/src/env.js:11–98

({ getExports, onLine, fetchedSources, lockfile, integrityActive, rt, captureHostCall })

const ERR_RUNTIME = 2; // wasm-abi/src/lib.rs error_kind::RUNTIME

export function makeCompilerEnv({ getExports, onLine, fetchedSources, lockfile, integrityActive, rt, captureHostCall }) {
    const readStr = (ptr, len) => TD.decode(new Uint8Array(getExports().memory.buffer, ptr, len));
    const setU32 = (ptr, v) => new DataView(getExports().memory.buffer).setUint32(ptr, v, true);

    return {
        host_print: (ptr, len) => onLine(readStr(ptr, len)),

        /* wasmpdk stages argv in guest memory; capability calls a JS handler directly. */
        host_call_native: (id, call_id, argv_ptr, argc, out_ptr) => {
            const fn = nativeTable[id];
            if (!fn) {
                stashError(getExports(), `native id ${id} not registered`);
                return 1;
            }

            const exports = getExports();

            if (fn.__edge_kind === 'capability') {
                /* Host appends a trailing kwargs handle (0 = no kwargs); JS capabilities don't model kwargs so drop it. */
                const handles = Array.from(new Uint32Array(exports.memory.buffer, argv_ptr, Math.max(0, argc - 1)));
                /* Marked main-thread: decode args to JS, defer via captureHostCall; driver wakes us with set_host_result_by_id. */
                if (fn.__edge_main_thread) {
                    if (!captureHostCall || !rt) {
                        stashError(exports, `native '${fn.__edge_module}.${fn.__edge_name}' marked main-thread but no host-call delegate wired`);
                        return 1;
                    }
                    try {
                        const args = handles.map((h) => rt.decodeAny(h));
                        captureHostCall(call_id, { module: fn.__edge_module, name: fn.__edge_name, args });
                        return 2;
                    } catch (e) {
                        stashError(exports, e?.message ?? String(e));
                        return 1;
                    }
                }
                try {
                    const resultHandle = fn(handles);
                    new DataView(exports.memory.buffer).setUint32(out_ptr, resultHandle, true);
                    return 0;
                } catch (e) {
                    stashError(exports, e?.message ?? String(e));
                    return 1;
                }
            }

            // wasmpdk: stage argv, call, copy back. Views as fns because `fn(...)` can re-enter `wasm_alloc` and detach a cached view.
            const guestView = () => new DataView(fn.__edge_memory.buffer);
            const compView = () => new DataView(exports.memory.buffer);

            const g_argv = fn.__edge_alloc(Math.max(4, argc * 4));
            const g_out = fn.__edge_alloc(4);
            for (let i = 0; i < argc; i++) {
                guestView().setUint32(g_argv + i * 4, compView().getUint32(argv_ptr + i * 4, true), true);
            }

            const status = fn(g_argv, argc, g_out);
            if (status === 0) {
                compView().setUint32(out_ptr, guestView().getUint32(g_out, true), true);