wasm-idle 0.6.1 → 0.7.1

package/README.md

@@ -2,7 +2,7 @@
 
 ![wasm-idle](static/image.jpeg)
 
-Executes C++, Python, Java, and Rust code with working stdio.
+Executes C++, Python, Java, Rust, and TinyGo code with working stdio.
 
 Refer to src/lib/clang.
 
@@ -29,26 +29,64 @@ The built-in Rust route now supports both `wasm32-wasip1` and `wasm32-wasip2`. T
 target selector when Rust is active, defaults to `wasm32-wasip1`, and persists that choice in local
 storage.
 
+## TinyGo browser integration
+
+The demo app can also vendor the sibling `wasm-tinygo` browser build under `static/wasm-tinygo/`
+and load its `runtime.js` entry directly inside the TinyGo playground sandbox. The example page
+only auto-discovers a host-assisted `/api/tinygo/compile` endpoint when the browser itself is
+running on `localhost` during `vite dev` / `vite preview`. Non-local and static deployments do not
+probe that path implicitly anymore; set `PUBLIC_WASM_TINYGO_HOST_COMPILE_URL` or
+`runtimeAssets.tinygo.hostCompileUrl` explicitly if you want to use a real TinyGo compile service.
+Refresh the
+bundled runtime assets after rebuilding the sibling `wasm-tinygo` project with:
+
+```bash
+cd wasm-tinygo
+npm run build
+
+cd ../wasm-idle
+pnpm run sync:wasm-tinygo
+```
+
+TinyGo currently exposes a single `wasm` target through the example page. The browser pipeline
+still lives inside `wasm-tinygo`; `wasm-idle` now imports its reusable `runtime.js` library entry
+directly, then runs the emitted artifact with browser WASI so terminal stdin/EOF behavior stays
+consistent with the other runtimes. When host compile is unavailable, the bundled browser fallback
+now loads the vendored TinyGo runtime in `direct` mode, skips the old bootstrap-only compile step,
+and runs the resulting WASI artifact locally. A host compile service is still useful when you want
+an explicit remote compile seam or broader compatibility than the shipped browser bundle.
+
 ## Browser regression commands
 
-Browser-level Rust checks are reproducible from this repo:
+Browser-level Rust and TinyGo checks are reproducible from this repo:
 
 ```bash
 cd wasm-idle
 pnpm run probe:rust-browser
 pnpm run test:browser:playwright
+pnpm run probe:tinygo-browser
+pnpm run test:browser:tinygo
 
 WASM_IDLE_BROWSER_URL='http://localhost:5173/absproxy/5173/' \
 WASM_IDLE_REUSE_LOCAL_PREVIEW=1 \
 pnpm run probe:rust-browser
 
+WASM_IDLE_BROWSER_URL='http://localhost:5173/absproxy/5173/' \
+WASM_IDLE_REUSE_LOCAL_PREVIEW=1 \
+pnpm run probe:tinygo-browser
+
 WASM_IDLE_RUN_REAL_BROWSER_RUST=1 \
 WASM_IDLE_BROWSER_URL='http://localhost:5173/absproxy/5173/' \
 WASM_IDLE_REUSE_LOCAL_PREVIEW=1 \
 pnpm exec vitest run src/lib/playground/rust.playwright.test.ts
+
+WASM_IDLE_RUN_REAL_BROWSER_TINYGO=1 \
+WASM_IDLE_BROWSER_URL='http://localhost:5173/absproxy/5173/' \
+WASM_IDLE_REUSE_LOCAL_PREVIEW=1 \
+pnpm exec vitest run src/lib/playground/tinygo.playwright.test.ts
 ```
 
-Both commands exercise the real Chromium page path. The default Rust probe now feeds stdin with a
+Both runtime probes exercise the real Chromium page path. The default Rust probe now feeds stdin with a
 single line (`5\n`) and expects the page to finish without sending EOF, which keeps the regression
 aligned with the default Rust sample and proves that pressing Enter is enough for line-based stdin.
 Programs that intentionally read stdin until EOF can still be finished with `Ctrl+D` or the toolbar
@@ -56,6 +94,10 @@ Programs that intentionally read stdin until EOF can still be finished with `Ctr
 The browser helper writes stdin through the page-owned `window.__wasmIdleDebug.writeTerminalInput(...)`
 hook instead of trying to click xterm's hidden helper textarea, which proved too flaky for repeatable
 Playwright runs.
+The TinyGo probe follows the same pattern. The host-assisted path still looks for
+`tinygo host compile ready: target=wasip1`, while the browser-only path should load the vendored
+runtime in `direct` mode and avoid the old bootstrap compile command altogether.
+The TinyGo browser commands currently default to `vite dev`.
 If Rust ever reports `invalid metadata files for crate core` or `Unsupported archive identifier`,
 the browser almost always fetched a stale or wrong `wasm-rust` sysroot asset. Hard refresh the page
 and resync `static/wasm-rust/` from the sibling `wasm-rust/dist/`.
@@ -74,6 +116,13 @@ session; the repo-owned regression target is the local preview path above.
 ## Runtime expectations
 
 Rust still supports an external browser compiler module for library consumers. Point `PUBLIC_WASM_RUST_COMPILER_URL` at a built `wasm-rust` ESM entry such as `.../wasm-rust/dist/index.js`, or pass `runtimeAssets.rust.compilerUrl` at runtime.
+TinyGo can use a host compile service when one is configured explicitly. Point
+`PUBLIC_WASM_TINYGO_HOST_COMPILE_URL` at an endpoint that accepts `POST { source }` and returns the
+compiled wasm artifact payload, or pass `runtimeAssets.tinygo.hostCompileUrl` at runtime. The
+bundled browser fallback still expects a browser-loadable `wasm-tinygo` runtime module. Point
+`PUBLIC_WASM_TINYGO_MODULE_URL` at a built entry such as `.../wasm-tinygo/dist/runtime.js`, or
+pass `runtimeAssets.tinygo.moduleUrl` at runtime. The older `PUBLIC_WASM_TINYGO_APP_URL` /
+`runtimeAssets.tinygo.appUrl` document path is still accepted and normalized to `runtime.js`.
 
 The Rust browser path now executes returned artifacts through the target-appropriate runtime inside
 the Rust worker:
@@ -99,23 +148,39 @@ const runtimeAssets: PlaygroundRuntimeAssets = {
 	},
 	rust: {
 		compilerUrl: 'https://cdn.example.com/wasm-rust/index.js'
+	},
+	tinygo: {
+		hostCompileUrl: 'https://tinygo.example.com/api/compile',
+		moduleUrl: 'https://cdn.example.com/wasm-tinygo/runtime.js'
 	}
 };
 ```
 
-Python custom loaders receive file names under the Pyodide asset root and can serve both core assets and package files. TeaVM custom loaders receive file names under the TeaVM asset root. Rust expects a browser-loadable compiler module URL; that module is responsible for serving its own nested runtime assets. Compressed TeaVM runtime assets are no longer unpacked inside the library; provide the final file URL or handle decompression in your own loader.
+Python custom loaders receive file names under the Pyodide asset root and can serve both core assets and package files. TeaVM custom loaders receive file names under the TeaVM asset root. Rust expects a browser-loadable compiler module URL; that module is responsible for serving its own nested runtime assets. TinyGo can use either an explicit host compile URL or a browser-loadable runtime module. The browser runtime now ships a direct-mode fallback that can produce and run the bundled TinyGo WASI artifact locally, alongside its sibling `tools/go-probe.wasm` and vendored emception assets. A host compile service remains useful when you want a dedicated remote compile seam or compatibility beyond the shipped browser bundle. TinyGo also accepts a runtime asset loader + pack bundle in `runtimeAssets.tinygo` when you need to serve runtime assets out of a single compressed archive. Compressed TeaVM runtime assets are no longer unpacked inside the library; provide the final file URL or handle decompression in your own loader.
 
 If you want a host app to reuse the same runtime asset configuration for both `<Terminal>` and direct `playground(...)` access, bind it once:
 
 ```ts
 import Terminal, { createPlaygroundBinding } from 'wasm-idle';
 
-const wasmIdle = createPlaygroundBinding({
-	rootUrl: 'https://cdn.example.com/repl',
-	rust: {
-		compilerUrl: 'https://cdn.example.com/wasm-rust/index.js'
-	}
-});
+	const wasmIdle = createPlaygroundBinding({
+		rootUrl: 'https://cdn.example.com/repl',
+		rust: {
+			compilerUrl: 'https://cdn.example.com/wasm-rust/index.js'
+		},
+		tinygo: {
+			hostCompileUrl: 'https://tinygo.example.com/api/compile',
+			moduleUrl: 'https://cdn.example.com/wasm-tinygo/runtime.js',
+			assetPacks: [
+				{
+					index: 'https://cdn.example.com/wasm-tinygo/runtime-pack/runtime-pack.index.json',
+					asset: 'https://cdn.example.com/wasm-tinygo/runtime-pack/runtime-pack.bin',
+					fileCount: 12,
+					totalBytes: 123456
+				}
+			]
+		}
+	});
 
 const sandbox = await wasmIdle.load('PYTHON');
 await sandbox.load('print("hi")', false);
@@ -125,4 +190,5 @@ await sandbox.load('print("hi")', false);
 <Terminal {...wasmIdle.terminalProps} bind:terminal />
 ```
 
-Powered by [wasm-clang](https://github.com/binji/wasm-clang), Pyodide, TeaVM, and `wasm-rust`.
+Powered by [wasm-clang](https://github.com/binji/wasm-clang), Pyodide, TeaVM, `wasm-rust`, and
+`wasm-tinygo`.

package/dist/clangd/session.js

@@ -1,7 +1,7 @@
 import { CloseAction, ErrorAction, MonacoLanguageClient, MonacoServices } from '@hancomac/monaco-languageclient';
-import { BrowserMessageReader, BrowserMessageWriter } from 'vscode-jsonrpc/browser';
 import { CLANGD_CPP_FILE_URI, CLANGD_WORKSPACE_URI, normalizeClangdBaseUrl } from './config';
 import ClangdWorker from './worker?worker';
+import { BrowserMessageReader, BrowserMessageWriter } from '../utils/vscodeJsonrpcBrowser';
 let servicesInstalled = false;
 export class ClangdSession {
     Monaco;

package/dist/clangd/worker.js

@@ -1,7 +1,7 @@
 /// <reference lib="WebWorker" />
 import { CLANGD_CPP_FILE_PATH, CLANGD_WORKSPACE_PATH, createClangdCompileFlags, normalizeClangdBaseUrl } from './config';
 import { JsonStream } from './jsonStream';
-import { BrowserMessageReader, BrowserMessageWriter } from 'vscode-jsonrpc/browser';
+import { BrowserMessageReader, BrowserMessageWriter } from '../utils/vscodeJsonrpcBrowser';
 const textEncoder = new TextEncoder();
 const jsonStream = new JsonStream();
 let resolveStdinReady = () => { };

package/dist/lsp/cpp/server.js

@@ -1,6 +1,6 @@
 import { resolveCppLanguageServerBaseUrl } from '../runtime';
 import ClangdWorker from '../../clangd/worker?worker';
-import { BrowserMessageReader, BrowserMessageWriter } from 'vscode-jsonrpc/browser';
+import { BrowserMessageReader, BrowserMessageWriter } from '../../utils/vscodeJsonrpcBrowser';
 const currentUrl = () => globalThis.location?.href || '';
 async function createServer(baseUrl) {
     let resolveReady = () => { };

package/dist/lsp/python/server.js

@@ -1,6 +1,6 @@
 import { resolvePythonLanguageServerBaseUrl } from '../runtime';
 import PythonLspWorker from './main.worker?worker';
-import { BrowserMessageReader, BrowserMessageWriter } from 'vscode-jsonrpc/browser';
+import { BrowserMessageReader, BrowserMessageWriter } from '../../utils/vscodeJsonrpcBrowser';
 const currentUrl = () => globalThis.location?.href || '';
 async function createServer(pyodideBaseUrl) {
     let resolveReady = () => { };

package/dist/playground/assets.d.ts

@@ -20,12 +20,47 @@ export interface RuntimeAssetConfig {
 export interface RustRuntimeAssetConfig {
     compilerUrl?: string;
 }
+export interface GoRuntimeAssetConfig {
+    compilerUrl?: string;
+}
+export interface OcamlRuntimeAssetConfig {
+    moduleUrl?: string;
+    manifestUrl?: string;
+}
+export interface TinyGoRuntimeAssetConfig {
+    moduleUrl?: string;
+    appUrl?: string;
+    hostCompileUrl?: string;
+    disableHostCompile?: boolean;
+    assetLoader?: TinyGoRuntimeAssetLoader;
+    assetPacks?: TinyGoRuntimeAssetPackReference[];
+}
+export interface ElixirRuntimeAssetConfig {
+    bundleUrl?: string;
+}
 export interface PlaygroundRuntimeAssets {
     rootUrl?: string;
     python?: RuntimeAssetConfig;
     java?: RuntimeAssetConfig;
     rust?: RustRuntimeAssetConfig;
+    go?: GoRuntimeAssetConfig;
+    ocaml?: OcamlRuntimeAssetConfig;
+    tinygo?: TinyGoRuntimeAssetConfig;
+    elixir?: ElixirRuntimeAssetConfig;
+}
+export interface TinyGoRuntimeAssetLoaderRequest {
+    assetPath: string;
+    assetUrl: string;
+    label: string;
+}
+export interface TinyGoRuntimeAssetPackReference {
+    index: string;
+    asset: string;
+    fileCount: number;
+    totalBytes: number;
 }
+export type TinyGoRuntimeAssetLoaderResult = RuntimeAssetDataResult | RuntimeAssetUrlResult | string | URL | ArrayBuffer | Uint8Array | Blob | null | undefined;
+export type TinyGoRuntimeAssetLoader = (request: TinyGoRuntimeAssetLoaderRequest) => TinyGoRuntimeAssetLoaderResult | Promise<TinyGoRuntimeAssetLoaderResult>;
 export interface ResolvedRuntimeAssetConfig {
     baseUrl: string;
     loader?: RuntimeAssetLoader;
@@ -35,3 +70,11 @@ export declare const PYTHON_RUNTIME_LOAD_ASSETS: readonly ["pyodide.asm.js", "py
 export declare const JAVA_RUNTIME_LOAD_ASSETS: readonly ["compiler.wasm-runtime.js", "compiler.wasm", "compile-classlib-teavm.bin", "runtime-classlib-teavm.bin"];
 export declare function resolveRuntimeAssetConfig(runtime: RuntimeAssetRuntime, options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): ResolvedRuntimeAssetConfig;
 export declare function resolveRustCompilerUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): any;
+export declare function resolveGoCompilerUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): any;
+export declare function resolveOcamlModuleUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): any;
+export declare function resolveOcamlManifestUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): any;
+export declare function resolveTinyGoAppUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
+export declare function resolveTinyGoModuleUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
+export declare function resolveTinyGoHostCompileUrls(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string[];
+export declare function resolveTinyGoHostCompileUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;
+export declare function resolveElixirBundleUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): string;

package/dist/playground/assets.js

@@ -18,7 +18,9 @@ const normalizeBaseUrl = (baseUrl, currentUrl = '') => {
     const normalized = baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
     return currentUrl ? new URL(normalized, currentUrl).href : normalized;
 };
+const resolveConfiguredUrl = (url, currentUrl = '') => currentUrl ? new URL(url, currentUrl).href : url;
 const normalizeRootUrl = (rootUrl) => rootUrl.endsWith('/') ? rootUrl.slice(0, -1) : rootUrl;
+const isLocalHostname = (hostname) => hostname === 'localhost' || hostname === '127.0.0.1';
 const resolvePythonBaseUrl = (rootUrl = '', currentUrl = '') => normalizeBaseUrl(`${normalizeRootUrl(rootUrl) || ''}/pyodide/`, currentUrl);
 const resolvePythonRuntimeAssetConfig = (options, currentUrl = '') => {
     if (typeof options === 'string') {
@@ -103,3 +105,165 @@ export function resolveRustCompilerUrl(options, currentUrl = '') {
         return '';
     return currentUrl ? new URL(configuredCompilerUrl, currentUrl).href : configuredCompilerUrl;
 }
+export function resolveGoCompilerUrl(options, currentUrl = '') {
+    const configuredCompilerUrl = (typeof options === 'object' && options?.go?.compilerUrl) ||
+        (publicEnv.PUBLIC_WASM_GO_COMPILER_URL || '').trim();
+    if (!configuredCompilerUrl)
+        return '';
+    return currentUrl ? new URL(configuredCompilerUrl, currentUrl).href : configuredCompilerUrl;
+}
+export function resolveOcamlModuleUrl(options, currentUrl = '') {
+    const configuredModuleUrl = (typeof options === 'object' && options?.ocaml?.moduleUrl) ||
+        (publicEnv.PUBLIC_WASM_OCAML_MODULE_URL || '').trim();
+    if (configuredModuleUrl) {
+        return currentUrl ? new URL(configuredModuleUrl, currentUrl).href : configuredModuleUrl;
+    }
+    if (typeof options === 'string') {
+        return currentUrl
+            ? new URL(`${normalizeRootUrl(options)}/wasm-of-js-of-ocaml/browser-native/src/index.js`, currentUrl).href
+            : `${normalizeRootUrl(options)}/wasm-of-js-of-ocaml/browser-native/src/index.js`;
+    }
+    if (options?.rootUrl) {
+        return currentUrl
+            ? new URL(`${normalizeRootUrl(options.rootUrl)}/wasm-of-js-of-ocaml/browser-native/src/index.js`, currentUrl).href
+            : `${normalizeRootUrl(options.rootUrl)}/wasm-of-js-of-ocaml/browser-native/src/index.js`;
+    }
+    return '';
+}
+export function resolveOcamlManifestUrl(options, currentUrl = '') {
+    const configuredManifestUrl = (typeof options === 'object' && options?.ocaml?.manifestUrl) ||
+        (publicEnv.PUBLIC_WASM_OCAML_MANIFEST_URL || '').trim();
+    if (configuredManifestUrl) {
+        return currentUrl ? new URL(configuredManifestUrl, currentUrl).href : configuredManifestUrl;
+    }
+    if (typeof options === 'string') {
+        return currentUrl
+            ? new URL(`${normalizeRootUrl(options)}/wasm-of-js-of-ocaml/browser-native-bundle/browser-native-manifest.v1.json`, currentUrl).href
+            : `${normalizeRootUrl(options)}/wasm-of-js-of-ocaml/browser-native-bundle/browser-native-manifest.v1.json`;
+    }
+    if (options?.rootUrl) {
+        return currentUrl
+            ? new URL(`${normalizeRootUrl(options.rootUrl)}/wasm-of-js-of-ocaml/browser-native-bundle/browser-native-manifest.v1.json`, currentUrl).href
+            : `${normalizeRootUrl(options.rootUrl)}/wasm-of-js-of-ocaml/browser-native-bundle/browser-native-manifest.v1.json`;
+    }
+    return '';
+}
+export function resolveTinyGoAppUrl(options, currentUrl = '') {
+    const configuredAppUrl = (typeof options === 'object' && options?.tinygo?.appUrl) ||
+        (publicEnv.PUBLIC_WASM_TINYGO_APP_URL || '').trim();
+    if (configuredAppUrl) {
+        return resolveConfiguredUrl(configuredAppUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-tinygo/index.html`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-tinygo/index.html`, currentUrl);
+    }
+    return '';
+}
+function deriveTinyGoModuleUrlFromAppUrl(appUrl, currentUrl = '') {
+    const resolvedAppUrl = resolveConfiguredUrl(appUrl, currentUrl);
+    const [withoutHash, hash = ''] = resolvedAppUrl.split('#', 2);
+    const [withoutQuery, query = ''] = withoutHash.split('?', 2);
+    let moduleUrlPath = withoutQuery;
+    if (moduleUrlPath.endsWith('/index.html')) {
+        moduleUrlPath = `${moduleUrlPath.slice(0, -'index.html'.length)}runtime.js`;
+    }
+    else if (moduleUrlPath.endsWith('/')) {
+        moduleUrlPath = `${moduleUrlPath}runtime.js`;
+    }
+    else {
+        moduleUrlPath = `${moduleUrlPath.replace(/\/$/, '')}/runtime.js`;
+    }
+    return `${moduleUrlPath}${query ? `?${query}` : ''}${hash ? `#${hash}` : ''}`;
+}
+export function resolveTinyGoModuleUrl(options, currentUrl = '') {
+    const configuredModuleUrl = (typeof options === 'object' && options?.tinygo?.moduleUrl) ||
+        (publicEnv.PUBLIC_WASM_TINYGO_MODULE_URL || '').trim();
+    if (configuredModuleUrl) {
+        return resolveConfiguredUrl(configuredModuleUrl, currentUrl);
+    }
+    const configuredLegacyAppUrl = (typeof options === 'object' && options?.tinygo?.appUrl) ||
+        (publicEnv.PUBLIC_WASM_TINYGO_APP_URL || '').trim();
+    if (configuredLegacyAppUrl) {
+        return deriveTinyGoModuleUrlFromAppUrl(configuredLegacyAppUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-tinygo/runtime.js`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-tinygo/runtime.js`, currentUrl);
+    }
+    return '';
+}
+export function resolveTinyGoHostCompileUrls(options, currentUrl = '') {
+    if (typeof options === 'object' && options?.tinygo?.disableHostCompile) {
+        return [];
+    }
+    const configuredHostCompileUrl = (typeof options === 'object' && options?.tinygo?.hostCompileUrl) ||
+        (publicEnv.PUBLIC_WASM_TINYGO_HOST_COMPILE_URL || '').trim();
+    if (configuredHostCompileUrl) {
+        return [resolveConfiguredUrl(configuredHostCompileUrl, currentUrl)];
+    }
+    const urls = [];
+    const pushUrl = (url) => {
+        const resolvedUrl = resolveConfiguredUrl(url, currentUrl);
+        if (!urls.includes(resolvedUrl)) {
+            urls.push(resolvedUrl);
+        }
+    };
+    let currentPageUrl = null;
+    try {
+        currentPageUrl = currentUrl ? new URL(currentUrl) : null;
+    }
+    catch {
+        currentPageUrl = null;
+    }
+    const canAutoDeriveHostCompileUrls = currentPageUrl !== null &&
+        isLocalHostname(currentPageUrl.hostname) &&
+        (currentPageUrl.protocol === 'http:' || currentPageUrl.protocol === 'https:');
+    if (!canAutoDeriveHostCompileUrls || currentPageUrl === null) {
+        return urls;
+    }
+    if (typeof options === 'string') {
+        pushUrl(`${normalizeRootUrl(options) || ''}/api/tinygo/compile`);
+    }
+    else if (options?.rootUrl) {
+        pushUrl(`${normalizeRootUrl(options.rootUrl) || ''}/api/tinygo/compile`);
+    }
+    else {
+        const currentPathname = currentPageUrl.pathname.endsWith('/')
+            ? currentPageUrl.pathname
+            : `${currentPageUrl.pathname}/`;
+        pushUrl(`${currentPageUrl.origin}${currentPathname}api/tinygo/compile`);
+    }
+    const moduleUrl = resolveTinyGoModuleUrl(options, currentUrl);
+    if (moduleUrl) {
+        const moduleAssetUrl = new URL(moduleUrl, currentUrl || undefined);
+        if (moduleAssetUrl.protocol === 'http:' || moduleAssetUrl.protocol === 'https:') {
+            pushUrl(new URL('../api/tinygo/compile', moduleAssetUrl).toString());
+        }
+    }
+    if (currentPageUrl.port !== '4175') {
+        pushUrl(`${currentPageUrl.protocol}//${currentPageUrl.hostname}:4175/api/tinygo/compile`);
+    }
+    return urls;
+}
+export function resolveTinyGoHostCompileUrl(options, currentUrl = '') {
+    return resolveTinyGoHostCompileUrls(options, currentUrl)[0] || '';
+}
+export function resolveElixirBundleUrl(options, currentUrl = '') {
+    const configuredBundleUrl = (typeof options === 'object' && options?.elixir?.bundleUrl) ||
+        (publicEnv.PUBLIC_WASM_ELIXIR_BUNDLE_URL || '').trim();
+    if (configuredBundleUrl) {
+        return resolveConfiguredUrl(configuredBundleUrl, currentUrl);
+    }
+    if (typeof options === 'string') {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options) || ''}/wasm-elixir/bundle.avm`, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveConfiguredUrl(`${normalizeRootUrl(options.rootUrl) || ''}/wasm-elixir/bundle.avm`, currentUrl);
+    }
+    return '';
+}

package/dist/playground/elixir.d.ts

@@ -0,0 +1,32 @@
+import { type PlaygroundRuntimeAssets } from './assets';
+import type { SandboxExecutionOptions } from './options';
+import type { Sandbox } from './sandbox';
+declare class Elixir implements Sandbox {
+    output: any;
+    worker?: Worker;
+    buffer: SharedArrayBuffer;
+    pendingInput: string[];
+    begin: number;
+    elapse: number;
+    uid: number;
+    exit: boolean;
+    bundleUrl: string;
+    activeReject: ((reason: string) => void) | null;
+    prepared: boolean;
+    hasExecuted: boolean;
+    waitingForInput: boolean;
+    pendingEof: boolean;
+    load(runtimeAssets?: string | PlaygroundRuntimeAssets, _code?: string, log?: boolean, _args?: string[], _options?: SandboxExecutionOptions, progress?: {
+        set?: (value: number) => void;
+    } | import('svelte/store').Writable<number>): Promise<void>;
+    write(input: string): void;
+    eof(): void;
+    private flushPendingInput;
+    run(code: string, prepare: boolean, log?: boolean, _prog?: {
+        set?: (value: number) => void;
+    } | import('svelte/store').Writable<number>): Promise<boolean | string>;
+    kill(): void;
+    terminate(): void;
+    clear(): Promise<void>;
+}
+export default Elixir;

package/dist/playground/elixir.js

@@ -0,0 +1,173 @@
+import { resolveElixirBundleUrl } from './assets';
+import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
+class Elixir {
+    output = null;
+    worker = null;
+    buffer = new SharedArrayBuffer(1024);
+    pendingInput = [];
+    begin = 0;
+    elapse = 0;
+    uid = 0;
+    exit = true;
+    bundleUrl = '';
+    activeReject = null;
+    prepared = false;
+    hasExecuted = false;
+    waitingForInput = false;
+    pendingEof = false;
+    load(runtimeAssets = '', _code = '', log = true, _args = [], _options = {}, progress) {
+        return new Promise(async (resolve, reject) => {
+            this.pendingInput = [];
+            this.waitingForInput = false;
+            this.pendingEof = false;
+            const currentUrl = typeof window !== 'undefined' ? window.location.href : '';
+            const nextBundleUrl = resolveElixirBundleUrl(runtimeAssets, currentUrl);
+            if (!nextBundleUrl) {
+                return reject('Elixir runtime is not configured. Set PUBLIC_WASM_ELIXIR_BUNDLE_URL or runtimeAssets.elixir.bundleUrl.');
+            }
+            const needsWorkerReset = !this.worker || this.bundleUrl !== nextBundleUrl;
+            this.bundleUrl = nextBundleUrl;
+            if (needsWorkerReset && this.worker) {
+                this.worker.terminate();
+                delete this.worker;
+            }
+            if (!this.worker) {
+                progress?.set?.(0.2);
+                this.worker = new (await import('./worker/elixir?worker')).default();
+                progress?.set?.(0.5);
+                this.worker.onerror = (event) => {
+                    const location = event.filename && event.lineno
+                        ? ` (${event.filename}:${event.lineno}:${event.colno})`
+                        : '';
+                    reject(`Elixir worker script error: ${event.message || 'unknown error'}${location}`);
+                };
+                this.worker.onmessageerror = () => {
+                    reject('Elixir worker message deserialization failed');
+                };
+                this.worker.onmessage = (event) => {
+                    if (event.data?.load) {
+                        progress?.set?.(1);
+                        resolve();
+                    }
+                    if (event.data?.error)
+                        reject(event.data.error);
+                };
+                this.worker.postMessage({
+                    load: true,
+                    bundleUrl: this.bundleUrl,
+                    log
+                });
+            }
+            else {
+                progress?.set?.(1);
+                resolve();
+            }
+        });
+    }
+    write(input) {
+        this.pendingInput.push(input);
+        this.pendingEof = false;
+        this.flushPendingInput();
+    }
+    eof() {
+        this.pendingEof = true;
+        this.flushPendingInput();
+    }
+    flushPendingInput() {
+        if (!this.waitingForInput)
+            return;
+        if (flushQueuedStdin(this.pendingInput, this.buffer)) {
+            this.waitingForInput = false;
+            return;
+        }
+        if (this.pendingEof) {
+            flushBufferedEof(this.buffer);
+            this.pendingEof = false;
+            this.waitingForInput = false;
+        }
+    }
+    run(code, prepare, log = true, _prog) {
+        this.exit = false;
+        return new Promise((resolve, reject) => {
+            if (!this.worker)
+                return reject('Worker not loaded');
+            const activeUid = ++this.uid;
+            this.activeReject = reject;
+            const handler = (event) => {
+                if (!this.worker)
+                    return reject('Worker not loaded');
+                if (activeUid !== this.uid)
+                    return (this.worker.onmessage = null);
+                const { output, error, buffer } = event.data;
+                const hasResults = Object.prototype.hasOwnProperty.call(event.data || {}, 'results');
+                if (buffer) {
+                    this.waitingForInput = true;
+                    this.flushPendingInput();
+                }
+                if (output) {
+                    this.output?.(output);
+                }
+                if (hasResults) {
+                    const { results } = event.data;
+                    this.elapse = Date.now() - this.begin;
+                    this.exit = true;
+                    this.waitingForInput = false;
+                    this.pendingEof = false;
+                    this.activeReject = null;
+                    this.prepared = prepare;
+                    this.hasExecuted = !prepare;
+                    if (!prepare && typeof results === 'string' && results) {
+                        this.output?.(`=> ${results}\n`);
+                    }
+                    resolve(results || true);
+                }
+                if (error) {
+                    this.elapse = Date.now() - this.begin;
+                    this.exit = true;
+                    this.waitingForInput = false;
+                    this.pendingEof = false;
+                    this.activeReject = null;
+                    this.prepared = false;
+                    this.hasExecuted = false;
+                    reject(error);
+                }
+            };
+            this.worker.onmessage = handler;
+            this.begin = Date.now();
+            this.worker.postMessage({
+                code,
+                prepare,
+                buffer: this.buffer,
+                log
+            });
+        });
+    }
+    kill() {
+        this.terminate();
+    }
+    terminate() {
+        this.activeReject?.('Process terminated');
+        this.activeReject = null;
+        this.uid += 1;
+        this.prepared = false;
+        this.hasExecuted = false;
+        this.waitingForInput = false;
+        this.pendingEof = false;
+        this.worker?.terminate?.();
+        delete this.worker;
+        this.exit = true;
+    }
+    async clear() {
+        this.pendingInput = [];
+        this.waitingForInput = false;
+        this.pendingEof = false;
+        if (this.worker) {
+            this.worker.onmessage = null;
+        }
+        resetBufferedStdin(this.buffer);
+        if (!this.exit || this.hasExecuted) {
+            this.terminate();
+        }
+    }
+}
+export default Elixir;

package/dist/playground/go.d.ts

@@ -0,0 +1,31 @@
+import { type PlaygroundRuntimeAssets } from './assets';
+import { type CompilerDiagnostic, type SandboxExecutionOptions } from './options';
+import type { Sandbox } from './sandbox';
+declare class Go implements Sandbox {
+    output: any;
+    worker?: Worker;
+    buffer: SharedArrayBuffer;
+    pendingInput: string[];
+    begin: number;
+    elapse: number;
+    uid: number;
+    exit: boolean;
+    compilerUrl: string;
+    activeReject: ((reason: string) => void) | null;
+    oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
+    waitingForInput: boolean;
+    pendingEof: boolean;
+    load(runtimeAssets?: string | PlaygroundRuntimeAssets, _code?: string, _log?: boolean, _args?: string[], _options?: SandboxExecutionOptions, progress?: {
+        set?: (value: number) => void;
+    } | import('svelte/store').Writable<number>): Promise<void>;
+    write(input: string): void;
+    eof(): void;
+    private flushPendingInput;
+    run(code: string, prepare: boolean, _log?: boolean, _prog?: {
+        set?: (value: number) => void;
+    } | import('svelte/store').Writable<number>, args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
+    kill(): void;
+    terminate(): void;
+    clear(): Promise<void>;
+}
+export default Go;