wasm-idle 0.7.1 → 0.7.2

package/dist/playground/clang.js

@@ -1,3 +1,5 @@
+import { WorkerAssetBridge } from './assetBridge';
+import { resolveRuntimeAssetConfig } from './assets';
 import { resolveSandboxExecutionArgs } from './options';
 import { bufferedSequence, flushBufferedEof, flushQueuedStdin, resetBufferedStdin, waitForBufferedSequenceChange } from './stdinBuffer';
 const debugBreakpointBufferInts = 1028;
@@ -20,23 +22,48 @@ class Clang {
     waitingForInput = false;
     pendingEof = false;
     exit = true;
+    assetBridge = null;
     activeReject = null;
     constructor(language) {
         this.language = language;
     }
-    load(runtimeAssets = '', code = '', log = true, args = [], _options = {}, _progress) {
+    load(runtimeAssets = '', code = '', log = true, args = [], _options = {}, progress) {
         return new Promise(async (resolve) => {
             this.log = log;
             this.pendingInput = [];
             this.waitingForInput = false;
             this.pendingEof = false;
-            const path = typeof runtimeAssets === 'string' ? runtimeAssets : runtimeAssets?.rootUrl || '';
+            const assetConfig = resolveRuntimeAssetConfig('clang', runtimeAssets, typeof window !== 'undefined' ? window.location.href : '');
+            const needsWorkerReset = !this.worker || !this.assetBridge || !this.assetBridge.matches(assetConfig);
+            if (needsWorkerReset && this.worker) {
+                this.worker.terminate();
+                delete this.worker;
+                this.assetBridge = null;
+            }
             if (!this.worker) {
                 this.worker = new (await import('./worker/clang?worker')).default();
-                this.worker.onmessage = () => resolve();
-                this.worker.postMessage({ load: true, path, log, code, args });
+                this.assetBridge = new WorkerAssetBridge(this.worker, 'clang', assetConfig, progress);
+                this.worker.onmessage = (event) => {
+                    if (this.assetBridge?.handleMessage(event))
+                        return;
+                    if (event.data?.progress != null)
+                        progress?.set?.(event.data.progress);
+                    if (event.data?.load)
+                        resolve();
+                };
+                this.worker.postMessage({
+                    load: true,
+                    log,
+                    code,
+                    args,
+                    assets: {
+                        baseUrl: assetConfig.baseUrl,
+                        useAssetBridge: assetConfig.useAssetBridge
+                    }
+                });
             }
             else {
+                this.assetBridge?.rebind(this.worker, assetConfig, progress);
                 this.worker.postMessage({ log });
                 resolve();
             }
@@ -74,6 +101,8 @@ class Clang {
             this.setBreakpoints(options.debug ? [...(options.breakpoints || [])] : []);
             const interrupt = new Uint8Array(this.interruptBuffer), _uid = ++this.uid;
             const handler = (event) => {
+                if (this.assetBridge?.handleMessage(event))
+                    return;
                 if (!this.worker)
                     return reject('Worker not loaded');
                 if (_uid !== this.uid)
@@ -180,6 +209,7 @@ class Clang {
         Atomics.notify(control, 0);
         this.worker?.terminate?.();
         delete this.worker;
+        this.assetBridge = null;
         this.exit = true;
     }
     async clear() {
@@ -198,6 +228,7 @@ class Clang {
         if (!this.exit) {
             this.worker?.terminate?.();
             delete this.worker;
+            this.assetBridge = null;
             this.exit = true;
         }
     }

package/dist/playground/ocaml.js

@@ -96,6 +96,7 @@ class Ocaml {
             if (!this.worker)
                 return reject('Worker not loaded');
             const target = options.ocamlBackend || 'wasm';
+            const wasmBinaryenMode = options.ocamlWasmBinaryenMode || 'fast';
             const _uid = ++this.uid;
             this.activeReject = reject;
             const handler = async (event) => {
@@ -308,6 +309,7 @@ class Ocaml {
                 code,
                 prepare,
                 target,
+                wasmBinaryenMode,
                 log: _log,
                 buffer: this.buffer
             });

package/dist/playground/options.d.ts

@@ -15,7 +15,9 @@ export interface CompilerDiagnostic {
 }
 export type RustTargetTriple = 'wasm32-wasip1' | 'wasm32-wasip2' | 'wasm32-wasip3';
 export type GoTarget = 'wasip1/wasm' | 'wasip2/wasm' | 'wasip3/wasm' | 'js/wasm';
+export type TinyGoTarget = 'wasm' | 'wasip1' | 'wasip2' | 'wasip3';
 export type OcamlBackend = 'js' | 'wasm';
+export type OcamlWasmBinaryenMode = 'fast' | 'full';
 export type DebugVariableKind = 'number' | 'bool' | 'array' | 'text';
 export type DebugArrayElementKind = 'int' | 'float' | 'double' | 'bool' | 'char';
 export interface DebugStructFieldMetadata {
@@ -62,7 +64,9 @@ export interface SandboxExecutionOptions {
     cVersion?: string;
     rustTargetTriple?: RustTargetTriple;
     goTarget?: GoTarget;
+    tinygoTarget?: TinyGoTarget;
     ocamlBackend?: OcamlBackend;
+    ocamlWasmBinaryenMode?: OcamlWasmBinaryenMode;
 }
 export interface ResolvedSandboxExecutionArgs {
     compileArgs: string[];

package/dist/playground/tinygo.d.ts

@@ -1,5 +1,5 @@
 import { type PlaygroundRuntimeAssets, type TinyGoRuntimeAssetLoader, type TinyGoRuntimeAssetPackReference } from './assets';
-import { type SandboxExecutionOptions } from './options';
+import { type SandboxExecutionOptions, type TinyGoTarget } from './options';
 import type { Sandbox } from './sandbox';
 type TinyGoRuntimeHooks = {
     boot(): Promise<void>;
@@ -15,6 +15,9 @@ type TinyGoRuntimeHooks = {
         entrypoint?: '_start' | '_initialize' | 'main' | null;
         reason?: 'bootstrap-artifact' | 'missing-wasi-entrypoint';
     } | null;
+    setBuildRequestOverrides?(overrides: {
+        target?: TinyGoTarget;
+    } | null): void;
     setWorkspaceFiles(files: Record<string, string> | null): void;
     dispose?(): void;
 };

package/dist/playground/tinygo.js

@@ -146,7 +146,8 @@ class TinyGo {
         }
         const moduleUrl = this.moduleUrl;
         this.runtimePromise = (async () => {
-            const runtimeModule = (await import(/* @vite-ignore */ moduleUrl));
+            const runtimeModule = (await import(
+            /* @vite-ignore */ moduleUrl));
             if (typeof runtimeModule.createBundledTinyGoRuntime === 'function') {
                 this.runtime = runtimeModule.createBundledTinyGoRuntime({
                     assetLoader: this.assetLoader,
@@ -212,7 +213,6 @@ class TinyGo {
                 });
                 return this.runtime;
             }
-            ;
             throw new Error('TinyGo runtime module must export createBundledTinyGoRuntime or createTinyGoRuntime');
         })().catch((error) => {
             this.disposeRuntime();
@@ -245,11 +245,13 @@ class TinyGo {
         }
         return 'TinyGo compilation failed';
     }
-    async compileArtifact(code, log = true, prog) {
+    async compileArtifact(code, target = 'wasm', log = true, prog) {
+        const hostCompileTarget = target === 'wasm' ? 'wasip1' : target;
         const compileCacheKey = JSON.stringify({
             code,
             hostCompileUrls: this.hostCompileUrls,
-            moduleUrl: this.moduleUrl
+            moduleUrl: this.moduleUrl,
+            target
         });
         if (this.compiledArtifact && this.compiledCacheKey === compileCacheKey) {
             return;
@@ -266,7 +268,8 @@ class TinyGo {
                             'content-type': 'application/json'
                         },
                         body: JSON.stringify({
-                            source: code
+                            source: code,
+                            target: hostCompileTarget
                         })
                     });
                 }
@@ -337,6 +340,7 @@ class TinyGo {
         runtime.reset();
         this.lastActivityLog = runtime.readActivityLog();
         runtime.setWorkspaceFiles({ 'main.go': code });
+        runtime.setBuildRequestOverrides?.({ target });
         this.runtimeProgress = prog;
         this.runtimeProgressAssets.clear();
         this.runtimeProgressStart = 0.05;
@@ -420,7 +424,8 @@ class TinyGo {
             try {
                 this.begin = Date.now();
                 await this.ensureWorker();
-                await this.compileArtifact(code, _log, prepare ? _prog : undefined);
+                const target = options.tinygoTarget || 'wasm';
+                await this.compileArtifact(code, target, _log, prepare ? _prog : undefined);
                 if (prepare) {
                     this.elapse = Date.now() - this.begin;
                     this.exit = true;

package/dist/playground/wasmOcamlVersion.d.ts

@@ -1 +1 @@
-export declare const WASM_OCAML_ASSET_VERSION = "bd4c85620ead3426";
+export declare const WASM_OCAML_ASSET_VERSION = "5215e843db69fc28";

package/dist/playground/wasmOcamlVersion.js

@@ -1 +1 @@
-export const WASM_OCAML_ASSET_VERSION = "bd4c85620ead3426";
+export const WASM_OCAML_ASSET_VERSION = "5215e843db69fc28";

package/dist/playground/wasmTinyGoVersion.d.ts

@@ -1 +1 @@
-export declare const WASM_TINYGO_ASSET_VERSION = "c45e1d6b3e297250";
+export declare const WASM_TINYGO_ASSET_VERSION = "be561e38c81e2e23";

package/dist/playground/wasmTinyGoVersion.js

@@ -1 +1 @@
-export const WASM_TINYGO_ASSET_VERSION = "c45e1d6b3e297250";
+export const WASM_TINYGO_ASSET_VERSION = 'be561e38c81e2e23';

package/dist/playground/worker/clang.js

@@ -1,4 +1,5 @@
 import { waitForBufferedStdin } from '../stdinBuffer';
+import { configureWorkerRuntimeAssets, handleWorkerAssetMessage } from './assets';
 self.document = {
     querySelectorAll() {
         return [];
@@ -17,9 +18,13 @@ async function loadClang(path, log) {
     });
 }
 self.onmessage = async (event) => {
-    const { code, buffer, debugBuffer, watchBuffer, watchResultBuffer, load, interrupt, log, path, prepare, language, compileArgs, programArgs, cppVersion, cVersion, debug, breakpoints, pauseOnEntry } = event.data;
+    if (handleWorkerAssetMessage(event.data))
+        return;
+    const { code, buffer, debugBuffer, watchBuffer, watchResultBuffer, load, interrupt, log, path, assets, prepare, language, compileArgs, programArgs, cppVersion, cVersion, debug, breakpoints, pauseOnEntry } = event.data;
     if (load) {
-        await loadClang(path, log);
+        const runtimeAssets = assets;
+        configureWorkerRuntimeAssets(runtimeAssets || null);
+        await loadClang(runtimeAssets?.baseUrl || path || '', log);
         postMessage({ load: true });
     }
     else if (prepare) {

package/dist/playground/worker/ocaml.js

@@ -363,7 +363,7 @@ async function executeCompileResult(result, log = false) {
     }
 }
 self.onmessage = async (event) => {
-    const { load, moduleUrl: nextModuleUrl, manifestUrl: nextManifestUrl, code, prepare, target = 'wasm', log = true, buffer } = event.data;
+    const { load, moduleUrl: nextModuleUrl, manifestUrl: nextManifestUrl, code, prepare, target = 'wasm', wasmBinaryenMode = 'fast', log = true, buffer } = event.data;
     try {
         if (load) {
             moduleUrl = nextModuleUrl;
@@ -374,7 +374,7 @@ self.onmessage = async (event) => {
         }
         stdinBufferOcaml = buffer ? new Int32Array(buffer) : null;
         if (log) {
-            console.log(`[wasm-idle:ocaml-worker] compile start prepare=${prepare} target=${target}`);
+            console.log(`[wasm-idle:ocaml-worker] compile start prepare=${prepare} target=${target} binaryen=${wasmBinaryenMode}`);
         }
         postMessage({ progress: { stage: 'compile-bootstrap', percent: 10 } });
         const [compilerModule, manifest] = await Promise.all([
@@ -382,7 +382,7 @@ self.onmessage = async (event) => {
             loadManifest(manifestUrl)
         ]);
         postMessage({ progress: { stage: 'compile-ready', percent: 25 } });
-        const compileKey = `${target}\n${code}`;
+        const compileKey = `${target}\n${wasmBinaryenMode}\n${code}`;
         let compiledFresh = false;
         if (!compiledResult || compiledCacheKey !== compileKey) {
             const result = await compilerModule.compile({
@@ -391,7 +391,8 @@ self.onmessage = async (event) => {
                 },
                 entry: 'main.ml',
                 target,
-                effectsMode: 'cps'
+                effectsMode: 'cps',
+                wasmBinaryenMode
             }, {
                 system: compilerModule.createBrowserWorkerSystemDispatcher({
                     manifest

package/dist/terminal/Terminal.svelte

@@ -107,6 +107,10 @@
 						hasPythonLoader: !!currentRuntimeAssets?.python?.loader,
 						javaBaseUrl: currentRuntimeAssets?.java?.baseUrl || '',
 						hasJavaLoader: !!currentRuntimeAssets?.java?.loader,
+						clangBaseUrl: currentRuntimeAssets?.clang?.baseUrl || '',
+						hasClangLoader: !!currentRuntimeAssets?.clang?.loader,
+						clangdBaseUrl: currentRuntimeAssets?.clangd?.baseUrl || '',
+						hasClangdLoader: !!currentRuntimeAssets?.clangd?.loader,
 						rustCompilerUrl: currentRuntimeAssets?.rust?.compilerUrl || '',
 						goCompilerUrl: currentRuntimeAssets?.go?.compilerUrl || '',
 						elixirBundleUrl: currentRuntimeAssets?.elixir?.bundleUrl || '',

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wasm-idle",
-	"version": "0.7.1",
+	"version": "0.7.2",
 	"description": "A simple web app to run code in the browser",
 	"license": "MIT",
 	"type": "module",