Function createWorker

runtime/src/index.js:7–132

(opts)

import { DEFAULT_HOST, DEFAULT_IMPORTS } from './defaults.js';

export async function createWorker(opts) {
    // Chromium blocks `new Worker(crossOriginUrl)` even with `type:'module'`; cross-origin runtimes need the Blob bootstrap below.
    const workerUrl = new URL('../worker/worker.js', import.meta.url);
    const sameOrigin = workerUrl.origin === self.location.origin;
    const worker = sameOrigin
        ? new Worker(workerUrl, { type: 'module' })
        : spawnCrossOriginWorker(workerUrl.href);

    let reqIdCounter = 0;
    const pending = new Map();
    let outputHandler = null;

    /* Fire a string into the running script's `receive()` queue. Defined early so main-thread module factories can capture it. */
    const pushEvent = (message) => worker.postMessage({ type: 'push-event', message: String(message) });

    /* Resolve each `mainThreadModules[name]` (factory or object) into a flat handler map keyed `module:name`. */
    const mainThreadHandlers = {};
    const manifests = [];
    for (const [modName, src] of Object.entries(opts?.mainThreadModules || {})) {
        const handlers = typeof src === 'function' ? src({ pushEvent }) : src;
        manifests.push({ name: modName, exports: Object.keys(handlers) });
        for (const [fnName, handler] of Object.entries(handlers)) {
            mainThreadHandlers[`${modName}:${fnName}`] = handler;
        }
    }

    /* Lazy host modules: name -> ESM url, imported only when the worker reports the bare name is used. Base defaults sit under user entries; `defaults:false` opts out. */
    const hostUrls = { ...(opts?.defaults !== false ? DEFAULT_HOST : {}), ...(opts?.hostModules || {}) };
    const loadedHosts = new Map(); // name -> export names, memoized across runs
    const loadHostModule = async (name) => {
        if (loadedHosts.has(name)) return loadedHosts.get(name);
        const url = hostUrls[name];
        if (!url) throw new Error(`no host module registered for '${name}'`);
        const mod = await import(url);
        const factory = mod[name] ?? mod.default;
        const handlers = typeof factory === 'function' ? factory({ pushEvent }) : factory;
        for (const [fnName, handler] of Object.entries(handlers)) {
            mainThreadHandlers[`${name}:${fnName}`] = handler;
        }
        const exports = Object.keys(handlers);
        loadedHosts.set(name, exports);
        return exports;
    };

    worker.onmessage = async ({ data }) => {
        if (data.type === 'line') {
            if (outputHandler) outputHandler(data.text);
            return;
        }
        if (data.type === 'host-call') {
            const handler = mainThreadHandlers[`${data.module}:${data.name}`];
            if (!handler) {
                worker.postMessage({ type: 'host-call-response', reqId: data.reqId, error: `no main-thread handler for '${data.module}.${data.name}'` });
                return;
            }
            try {
                const value = await handler(...data.args);
                worker.postMessage({ type: 'host-call-response', reqId: data.reqId, value });