wasm-idle 0.6.1 → 0.7.0

package/dist/playground/worker/ocaml.js

@@ -0,0 +1,449 @@
+import { waitForBufferedStdin } from '../stdinBuffer';
+let moduleUrl = '';
+let manifestUrl = '';
+let loadedModuleUrl = '';
+let loadedManifestUrl = '';
+let compilerPromise = null;
+let manifestPromise = null;
+let compiledResult = null;
+let compiledCacheKey = '';
+let stdinBufferOcaml = null;
+function appendTrailingNewline(text) {
+    return text.endsWith('\n') ? text : `${text}\n`;
+}
+function normalizeAssetLoader(programSource, runtimePromiseKey) {
+    let normalizedSource = programSource.includes('($=>async a=>{')
+        ? programSource.replace('($=>async a=>{', `globalThis.${runtimePromiseKey}=($=>async a=>{`)
+        : programSource;
+    const assetLoaderPattern = /function ([A-Za-z$_][\w$]*)\(([A-Za-z$_][\w$]*)\)\{const ([A-Za-z$_][\w$]*)=([A-Za-z$_][\w$]*)\?new URL\(\2,\4\):\2;return fetch\(\3\)\}/;
+    const matchedLoader = normalizedSource.match(assetLoaderPattern);
+    if (!matchedLoader) {
+        return normalizedSource;
+    }
+    const loaderName = matchedLoader[1] || 'loadAsset';
+    const argumentName = matchedLoader[2] || 'assetPath';
+    const resolvedName = matchedLoader[3] || 'resolvedUrl';
+    const baseName = matchedLoader[4] || 'scriptUrl';
+    return normalizedSource.replace(assetLoaderPattern, `function ${loaderName}(${argumentName}){if(globalThis.__wasm_of_js_of_ocaml_resolve_asset){const resolvedAsset=globalThis.__wasm_of_js_of_ocaml_resolve_asset(${argumentName});if(resolvedAsset)return fetch(resolvedAsset)}const ${resolvedName}=${baseName}?new URL(${argumentName},${baseName}):${argumentName};return fetch(${resolvedName})}`);
+}
+function rewriteAbsoluteBundleUrl(url, currentManifestUrl) {
+    if (!url || /^[a-z]+:/i.test(url)) {
+        return url;
+    }
+    const manifestLocation = new URL(currentManifestUrl, self.location.href);
+    const basePath = manifestLocation.pathname.replace(/\/wasm-of-js-of-ocaml\/browser-native-bundle\/browser-native-manifest\.v1\.json$/, '');
+    return new URL(`${basePath}${url}`, manifestLocation.origin).toString();
+}
+function rewriteManifest(manifest, currentManifestUrl) {
+    return {
+        ...manifest,
+        findlibConf: rewriteAbsoluteBundleUrl(manifest.findlibConf, currentManifestUrl),
+        tools: {
+            ocamlc: rewriteAbsoluteBundleUrl(manifest.tools.ocamlc, currentManifestUrl),
+            js_of_ocaml: rewriteAbsoluteBundleUrl(manifest.tools.js_of_ocaml, currentManifestUrl),
+            wasm_of_ocaml: rewriteAbsoluteBundleUrl(manifest.tools.wasm_of_ocaml, currentManifestUrl)
+        },
+        ...(manifest.binaryenTools
+            ? {
+                binaryenTools: {
+                    wasm_opt: rewriteAbsoluteBundleUrl(manifest.binaryenTools.wasm_opt, currentManifestUrl),
+                    wasm_merge: rewriteAbsoluteBundleUrl(manifest.binaryenTools.wasm_merge, currentManifestUrl),
+                    wasm_metadce: rewriteAbsoluteBundleUrl(manifest.binaryenTools.wasm_metadce, currentManifestUrl)
+                }
+            }
+            : {}),
+        ...(manifest.runtimePack
+            ? {
+                runtimePack: {
+                    ...manifest.runtimePack,
+                    asset: rewriteAbsoluteBundleUrl(manifest.runtimePack.asset, currentManifestUrl),
+                    index: rewriteAbsoluteBundleUrl(manifest.runtimePack.index, currentManifestUrl)
+                }
+            }
+            : {}),
+        ocamlLibFiles: manifest.ocamlLibFiles.map((file) => ({
+            ...file,
+            ...(file.url ? { url: rewriteAbsoluteBundleUrl(file.url, currentManifestUrl) } : {})
+        })),
+        packages: manifest.packages.map((manifestPackage) => ({
+            ...manifestPackage,
+            files: manifestPackage.files.map((file) => ({
+                ...file,
+                ...(file.url ? { url: rewriteAbsoluteBundleUrl(file.url, currentManifestUrl) } : {})
+            }))
+        }))
+    };
+}
+async function loadCompiler(nextModuleUrl) {
+    if (!nextModuleUrl) {
+        throw new Error('OCaml runtime is not configured. Set runtimeAssets.ocaml.moduleUrl and runtimeAssets.ocaml.manifestUrl or sync the bundled wasm-of-js-of-ocaml assets.');
+    }
+    if (loadedModuleUrl === nextModuleUrl && compilerPromise) {
+        return await compilerPromise;
+    }
+    loadedModuleUrl = nextModuleUrl;
+    compiledResult = null;
+    compiledCacheKey = '';
+    compilerPromise = (async () => {
+        const module = (await import(/* @vite-ignore */ nextModuleUrl));
+        if (typeof module.compile !== 'function') {
+            throw new Error('wasm-of-js-of-ocaml bundle must export compile');
+        }
+        if (typeof module.createBrowserWorkerSystemDispatcher !== 'function') {
+            throw new Error('wasm-of-js-of-ocaml bundle must export createBrowserWorkerSystemDispatcher');
+        }
+        return module;
+    })();
+    return await compilerPromise;
+}
+async function loadManifest(nextManifestUrl) {
+    if (!nextManifestUrl) {
+        throw new Error('OCaml runtime is not configured. Set runtimeAssets.ocaml.moduleUrl and runtimeAssets.ocaml.manifestUrl or sync the bundled wasm-of-js-of-ocaml assets.');
+    }
+    if (loadedManifestUrl === nextManifestUrl && manifestPromise) {
+        return await manifestPromise;
+    }
+    loadedManifestUrl = nextManifestUrl;
+    compiledResult = null;
+    compiledCacheKey = '';
+    manifestPromise = (async () => {
+        const response = await fetch(nextManifestUrl, { cache: 'no-store' });
+        if (!response.ok) {
+            throw new Error(`failed to fetch OCaml manifest: ${response.status}`);
+        }
+        return rewriteManifest((await response.json()), nextManifestUrl);
+    })();
+    return await manifestPromise;
+}
+function getJsArtifact(result) {
+    const programArtifact = result.artifacts.find((artifact) => artifact.kind === 'js' && typeof artifact.data === 'string');
+    if (!programArtifact || typeof programArtifact.data !== 'string') {
+        throw new Error('OCaml compile result did not include a JavaScript artifact');
+    }
+    return programArtifact;
+}
+async function executeCompileResult(result, log = false) {
+    const programArtifact = getJsArtifact(result);
+    const assetFiles = result.artifacts.filter((artifact) => artifact.kind === 'wasm' || artifact.kind === 'asset');
+    const assetResolverKey = '__wasm_of_js_of_ocaml_resolve_asset';
+    const runtimePromiseKey = '__wasm_of_js_of_ocaml_runtime_promise';
+    const stdinHookKey = '__wasmIdleOcamlReadStdin';
+    const sourceDir = programArtifact.path.replace(/\/[^/]+$/, '');
+    const createdObjectUrls = [];
+    const stdinEncoder = new TextEncoder();
+    let stdinChunkOcaml = new Uint8Array(0);
+    let stdinChunkOffsetOcaml = 0;
+    const originalConsole = globalThis.console;
+    const originalFetch = globalThis.fetch.bind(globalThis);
+    const originalInstantiate = WebAssembly.instantiate.bind(WebAssembly);
+    const originalInstantiateStreaming = WebAssembly.instantiateStreaming
+        ? WebAssembly.instantiateStreaming.bind(WebAssembly)
+        : undefined;
+    const runtimeGlobal = globalThis;
+    const hadProcess = Object.prototype.hasOwnProperty.call(runtimeGlobal, 'process');
+    const hadRequire = Object.prototype.hasOwnProperty.call(runtimeGlobal, 'require');
+    const hadModule = Object.prototype.hasOwnProperty.call(runtimeGlobal, 'module');
+    const hadExports = Object.prototype.hasOwnProperty.call(runtimeGlobal, 'exports');
+    const hadFs = Object.prototype.hasOwnProperty.call(runtimeGlobal, 'fs');
+    const originalProcess = runtimeGlobal.process;
+    const originalRequire = runtimeGlobal.require;
+    const originalModule = runtimeGlobal.module;
+    const originalExports = runtimeGlobal.exports;
+    const originalFs = runtimeGlobal.fs;
+    const hadStdinHook = Object.prototype.hasOwnProperty.call(runtimeGlobal, stdinHookKey);
+    const originalStdinHook = runtimeGlobal[stdinHookKey];
+    const assetEntries = assetFiles
+        .filter((artifact) => artifact.data instanceof Uint8Array)
+        .map((assetFile) => {
+        const copiedAssetData = new Uint8Array(assetFile.data.byteLength);
+        copiedAssetData.set(assetFile.data);
+        const objectUrl = URL.createObjectURL(new Blob([copiedAssetData], {
+            type: assetFile.path.endsWith('.wasm')
+                ? 'application/wasm'
+                : 'application/octet-stream'
+        }));
+        createdObjectUrls.push(objectUrl);
+        const relativeFromSourceDir = assetFile.path.startsWith(`${sourceDir}/`)
+            ? assetFile.path.slice(sourceDir.length + 1)
+            : assetFile.path.replace(/^\/+/, '');
+        return {
+            path: assetFile.path,
+            basename: assetFile.path.split('/').at(-1) || assetFile.path,
+            relativeFromSourceDir,
+            objectUrl
+        };
+    });
+    const resolveAsset = (requestedAsset) => {
+        const candidates = [String(requestedAsset)];
+        try {
+            candidates.push(new URL(String(requestedAsset), self.location.href).pathname);
+        }
+        catch {
+            // ignore
+        }
+        for (const assetEntry of assetEntries) {
+            if (candidates.some((candidate) => candidate === assetEntry.path ||
+                candidate === assetEntry.relativeFromSourceDir ||
+                candidate.endsWith(`/${assetEntry.relativeFromSourceDir}`) ||
+                candidate.endsWith(`/${assetEntry.basename}`))) {
+                return assetEntry.objectUrl;
+            }
+        }
+        return null;
+    };
+    const readOcamlStdinBytes = (requestedBytes) => {
+        if (!stdinBufferOcaml) {
+            return null;
+        }
+        if (requestedBytes <= 0) {
+            return new Uint8Array(0);
+        }
+        while (stdinChunkOffsetOcaml >= stdinChunkOcaml.length) {
+            const chunk = waitForBufferedStdin(stdinBufferOcaml, () => postMessage({ buffer: true }));
+            if (chunk == null) {
+                stdinChunkOcaml = new Uint8Array(0);
+                stdinChunkOffsetOcaml = 0;
+                return null;
+            }
+            stdinChunkOcaml = stdinEncoder.encode(chunk);
+            stdinChunkOffsetOcaml = 0;
+        }
+        const end = Math.min(stdinChunkOffsetOcaml + requestedBytes, stdinChunkOcaml.length);
+        const bytes = stdinChunkOcaml.slice(stdinChunkOffsetOcaml, end);
+        stdinChunkOffsetOcaml = end;
+        return bytes;
+    };
+    globalThis.console = {
+        ...originalConsole,
+        log: (...args) => {
+            postMessage({
+                output: appendTrailingNewline(args.map((value) => String(value)).join(' '))
+            });
+            originalConsole.log(...args);
+        },
+        info: (...args) => {
+            postMessage({
+                output: appendTrailingNewline(args.map((value) => String(value)).join(' '))
+            });
+            originalConsole.info(...args);
+        },
+        warn: (...args) => {
+            postMessage({
+                output: appendTrailingNewline(args.map((value) => String(value)).join(' '))
+            });
+            originalConsole.warn(...args);
+        },
+        error: (...args) => {
+            postMessage({
+                output: appendTrailingNewline(args.map((value) => String(value)).join(' '))
+            });
+            originalConsole.error(...args);
+        }
+    };
+    WebAssembly.instantiate = (async (source, importObject) => {
+        return await originalInstantiate(source, importObject);
+    });
+    if (originalInstantiateStreaming) {
+        WebAssembly.instantiateStreaming = (async (source, importObject) => {
+            return await originalInstantiateStreaming(source, importObject);
+        });
+    }
+    globalThis[assetResolverKey] = resolveAsset;
+    globalThis.fetch = (async (input, init) => {
+        const requestUrl = typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url;
+        const resolvedAssetUrl = resolveAsset(requestUrl);
+        if (resolvedAssetUrl) {
+            return await originalFetch(resolvedAssetUrl, init);
+        }
+        return await originalFetch(input, init);
+    });
+    runtimeGlobal.process = undefined;
+    runtimeGlobal[stdinHookKey] = (requestedBytes = Number.MAX_SAFE_INTEGER) => {
+        const encoded = readOcamlStdinBytes(requestedBytes);
+        if (encoded == null) {
+            return null;
+        }
+        let byteString = '';
+        for (const byte of encoded) {
+            byteString += String.fromCharCode(byte);
+        }
+        return byteString;
+    };
+    const stdinFsShim = {
+        readSync(fileDescriptor, buffer, offset = 0, length = buffer.byteLength - offset) {
+            if (fileDescriptor !== 0 || !stdinBufferOcaml) {
+                return 0;
+            }
+            const encoded = readOcamlStdinBytes(length);
+            if (encoded == null) {
+                return 0;
+            }
+            buffer.set(encoded, offset);
+            return encoded.byteLength;
+        }
+    };
+    runtimeGlobal.fs = stdinFsShim;
+    runtimeGlobal.require = (specifier) => {
+        if (specifier === 'fs' || specifier === 'node:fs') {
+            return stdinFsShim;
+        }
+        throw new Error(`unsupported OCaml runtime require: ${specifier}`);
+    };
+    runtimeGlobal.module = { exports: {} };
+    runtimeGlobal.exports = runtimeGlobal.module.exports;
+    try {
+        let normalizedSource = normalizeAssetLoader(programArtifact.data, runtimePromiseKey);
+        const stdinReadReplacement = 'read($1,$2,$3,$4){var e=globalThis.__wasmIdleOcamlReadStdin?globalThis.__wasmIdleOcamlReadStdin($3):null;if(e==null)return 0;var h=e.length,f=new Uint8Array(h),i=0;for(;i<h;i++)f[i]=e.charCodeAt(i);var g=f.length<$3?f.length:$3;$1.set(f.subarray(0,g),$2);return g}';
+        const patchedSource = normalizedSource.replace(/read\(([A-Za-z$_][\w$]*),([A-Za-z$_][\w$]*),([A-Za-z$_][\w$]*),([A-Za-z$_][\w$]*)\)\{cz\(\4,mc,aha,ow\)\}/, stdinReadReplacement);
+        normalizedSource =
+            patchedSource !== normalizedSource
+                ? patchedSource
+                : normalizedSource.replace(/read\(([A-Za-z$_][\w$]*),([A-Za-z$_][\w$]*),([A-Za-z$_][\w$]*),([A-Za-z$_][\w$]*)\)\{[^{}]+\}(?=seek\([A-Za-z$_][\w$]*,[A-Za-z$_][\w$]*,[A-Za-z$_][\w$]*\)\{[^{}]+\}pos\(\)\{return-1\}close\(\)\{this\.log=undefined\}check_stream_semantics\([A-Za-z$_][\w$]*\)\{\})/, stdinReadReplacement);
+        normalizedSource = normalizedSource
+            .replace(/\bfs\.readSync\(/g, 'globalThis.fs.readSync(')
+            .replace(/read:\(([^)]*)\)=>[A-Za-z$_][\w$]*\.readSync\(/g, 'read:($1)=>globalThis.fs.readSync(');
+        if (log && normalizedSource === programArtifact.data) {
+            console.warn('[wasm-idle:ocaml-worker] stdin runtime patch did not match generated JS');
+        }
+        new Function(`${normalizedSource}\n//# sourceURL=${programArtifact.path}`)();
+        const runtimePromise = globalThis[runtimePromiseKey];
+        if (runtimePromise instanceof Promise) {
+            await runtimePromise;
+        }
+        postMessage({ results: true });
+    }
+    finally {
+        globalThis.console = originalConsole;
+        globalThis.fetch = originalFetch;
+        WebAssembly.instantiate = originalInstantiate;
+        if (originalInstantiateStreaming) {
+            WebAssembly.instantiateStreaming = originalInstantiateStreaming;
+        }
+        delete globalThis[runtimePromiseKey];
+        delete globalThis[assetResolverKey];
+        if (!hadProcess) {
+            delete runtimeGlobal.process;
+        }
+        else {
+            runtimeGlobal.process = originalProcess;
+        }
+        if (!hadRequire) {
+            delete runtimeGlobal.require;
+        }
+        else {
+            runtimeGlobal.require = originalRequire;
+        }
+        if (!hadModule) {
+            delete runtimeGlobal.module;
+        }
+        else {
+            runtimeGlobal.module = originalModule;
+        }
+        if (!hadExports) {
+            delete runtimeGlobal.exports;
+        }
+        else {
+            runtimeGlobal.exports = originalExports;
+        }
+        if (!hadFs) {
+            delete runtimeGlobal.fs;
+        }
+        else {
+            runtimeGlobal.fs = originalFs;
+        }
+        if (!hadStdinHook) {
+            delete runtimeGlobal[stdinHookKey];
+        }
+        else {
+            runtimeGlobal[stdinHookKey] = originalStdinHook;
+        }
+        for (const objectUrl of createdObjectUrls) {
+            URL.revokeObjectURL(objectUrl);
+        }
+    }
+}
+self.onmessage = async (event) => {
+    const { load, moduleUrl: nextModuleUrl, manifestUrl: nextManifestUrl, code, prepare, target = 'wasm', log = true, buffer } = event.data;
+    try {
+        if (load) {
+            moduleUrl = nextModuleUrl;
+            manifestUrl = nextManifestUrl;
+            await Promise.all([loadCompiler(moduleUrl), loadManifest(manifestUrl)]);
+            postMessage({ load: true });
+            return;
+        }
+        stdinBufferOcaml = buffer ? new Int32Array(buffer) : null;
+        if (log) {
+            console.log(`[wasm-idle:ocaml-worker] compile start prepare=${prepare} target=${target}`);
+        }
+        postMessage({ progress: { stage: 'compile-bootstrap', percent: 10 } });
+        const [compilerModule, manifest] = await Promise.all([
+            loadCompiler(moduleUrl),
+            loadManifest(manifestUrl)
+        ]);
+        postMessage({ progress: { stage: 'compile-ready', percent: 25 } });
+        const compileKey = `${target}\n${code}`;
+        let compiledFresh = false;
+        if (!compiledResult || compiledCacheKey !== compileKey) {
+            const result = await compilerModule.compile({
+                files: {
+                    'main.ml': code
+                },
+                entry: 'main.ml',
+                target,
+                effectsMode: 'cps'
+            }, {
+                system: compilerModule.createBrowserWorkerSystemDispatcher({
+                    manifest
+                }),
+                toolchainRoot: '/static/toolchain'
+            });
+            compiledResult = result;
+            compiledCacheKey = compileKey;
+            compiledFresh = true;
+        }
+        const result = compiledResult;
+        if (log) {
+            console.log(`[wasm-idle:ocaml-worker] compile settled success=${result.success} diagnostics=${result.diagnostics?.length || 0}`);
+        }
+        if (compiledFresh && result.stdout) {
+            postMessage({ output: result.stdout });
+        }
+        if ((compiledFresh || !result.success) && result.stderr) {
+            postMessage({ output: result.stderr });
+        }
+        for (const diagnostic of result.diagnostics || []) {
+            postMessage({
+                diagnostic: {
+                    fileName: diagnostic.file ?? null,
+                    lineNumber: Math.max(1, Number(diagnostic.line || 1)),
+                    columnNumber: typeof diagnostic.column === 'number'
+                        ? Math.max(1, diagnostic.column)
+                        : undefined,
+                    severity: diagnostic.severity === 'warning' || diagnostic.severity === 'other'
+                        ? diagnostic.severity
+                        : 'error',
+                    message: String(diagnostic.message || '')
+                }
+            });
+        }
+        postMessage({ progress: { stage: 'compile-finished', percent: 90 } });
+        if (!result.success) {
+            throw new Error(result.stderr ||
+                result.diagnostics?.map((diagnostic) => diagnostic.message || '').join('\n') ||
+                'OCaml compilation failed');
+        }
+        if (prepare) {
+            postMessage({ results: true });
+            return;
+        }
+        postMessage({ progress: { stage: 'runtime-start', percent: 95 } });
+        await executeCompileResult(result, log);
+    }
+    catch (error) {
+        if (log) {
+            console.error('[wasm-idle:ocaml-worker] failed', error);
+        }
+        postMessage({ error: error?.message || String(error) });
+    }
+};

package/dist/playground/worker/tinygo.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/playground/worker/tinygo.js

@@ -0,0 +1,137 @@
+import { ConsoleStdout, Fd, WASI, WASIProcExit, wasi } from '@bjorn3/browser_wasi_shim';
+import { waitForBufferedStdin } from '../stdinBuffer';
+self.document = {
+    querySelectorAll() {
+        return [];
+    }
+};
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+let stdinBufferTinyGo = null;
+let stdinChunkTinyGo = new Uint8Array(0);
+let stdinChunkOffsetTinyGo = 0;
+class TinyGoStdin extends Fd {
+    fd_fdstat_get() {
+        const fdstat = new wasi.Fdstat(wasi.FILETYPE_CHARACTER_DEVICE, 0);
+        fdstat.fs_rights_base = BigInt(wasi.RIGHTS_FD_READ);
+        fdstat.fs_rights_inherited = 0n;
+        return { ret: wasi.ERRNO_SUCCESS, fdstat };
+    }
+    fd_filestat_get() {
+        return {
+            ret: wasi.ERRNO_SUCCESS,
+            filestat: new wasi.Filestat(0n, wasi.FILETYPE_CHARACTER_DEVICE, 0n)
+        };
+    }
+    fd_read(size) {
+        if (stdinBufferTinyGo === null) {
+            return {
+                ret: wasi.ERRNO_SUCCESS,
+                data: new Uint8Array(0)
+            };
+        }
+        if (stdinChunkOffsetTinyGo >= stdinChunkTinyGo.length) {
+            const nextChunk = waitForBufferedStdin(stdinBufferTinyGo, () => postMessage({ buffer: true }));
+            if (nextChunk === null) {
+                stdinChunkTinyGo = new Uint8Array(0);
+                stdinChunkOffsetTinyGo = 0;
+                return {
+                    ret: wasi.ERRNO_SUCCESS,
+                    data: new Uint8Array(0)
+                };
+            }
+            stdinChunkTinyGo = encoder.encode(nextChunk);
+            stdinChunkOffsetTinyGo = 0;
+        }
+        const end = Math.min(stdinChunkOffsetTinyGo + size, stdinChunkTinyGo.length);
+        const data = stdinChunkTinyGo.slice(stdinChunkOffsetTinyGo, end);
+        stdinChunkOffsetTinyGo = end;
+        return {
+            ret: wasi.ERRNO_SUCCESS,
+            data
+        };
+    }
+}
+self.onmessage = async (event) => {
+    const { load, artifact, buffer, args = [], log } = event.data;
+    try {
+        if (load) {
+            postMessage({ load: true });
+            return;
+        }
+        const bytes = artifact instanceof Uint8Array
+            ? artifact
+            : artifact instanceof ArrayBuffer
+                ? new Uint8Array(artifact)
+                : ArrayBuffer.isView(artifact)
+                    ? new Uint8Array(artifact.buffer, artifact.byteOffset, artifact.byteLength)
+                    : null;
+        if (!bytes) {
+            throw new Error('TinyGo worker expected a wasm artifact');
+        }
+        stdinBufferTinyGo = new Int32Array(buffer);
+        stdinChunkTinyGo = new Uint8Array(0);
+        stdinChunkOffsetTinyGo = 0;
+        const stdout = new ConsoleStdout((chunk) => {
+            const text = decoder.decode(chunk);
+            if (text)
+                postMessage({ output: text });
+        });
+        const stderr = new ConsoleStdout((chunk) => {
+            const text = decoder.decode(chunk);
+            if (text)
+                postMessage({ output: text });
+        });
+        const wasiRuntime = new WASI(args, ['USER=jungol'], [new TinyGoStdin(), stdout, stderr]);
+        const wasmModule = (await WebAssembly.instantiate(bytes, {
+            wasi_snapshot_preview1: wasiRuntime.wasiImport,
+            wasi_unstable: wasiRuntime.wasiImport
+        }));
+        const instance = typeof WebAssembly.Instance === 'function' && wasmModule instanceof WebAssembly.Instance
+            ? wasmModule
+            : 'instance' in wasmModule
+                ? wasmModule.instance
+                : wasmModule;
+        const exportsObject = instance.exports;
+        let exitCode = 0;
+        try {
+            if (typeof exportsObject._start === 'function') {
+                exitCode = wasiRuntime.start(instance);
+            }
+            else if (typeof exportsObject.memory === 'object' &&
+                typeof exportsObject.main === 'function') {
+                wasiRuntime.initialize(instance);
+                if (typeof exportsObject._initialize !== 'function' &&
+                    typeof exportsObject.__wasm_call_ctors === 'function') {
+                    exportsObject.__wasm_call_ctors();
+                }
+                const mainResult = exportsObject.main();
+                exitCode = typeof mainResult === 'number' ? mainResult : 0;
+            }
+            else {
+                throw new Error('TinyGo worker expected a WASI artifact with _start or a reactor artifact with main');
+            }
+        }
+        catch (error) {
+            if (error instanceof WASIProcExit) {
+                exitCode = error.code;
+            }
+            else {
+                throw error;
+            }
+        }
+        if (log) {
+            console.log(`[wasm-idle:tinygo-worker] wasi run complete exitCode=${String(exitCode)}`);
+        }
+        if (exitCode !== 0) {
+            throw new Error(`TinyGo program exited with code ${exitCode}`);
+        }
+        postMessage({ results: true });
+    }
+    catch (error) {
+        if (log) {
+            console.error('[wasm-idle:tinygo-worker] failed', error);
+        }
+        postMessage({ error: error?.message || String(error) });
+    }
+};