wasm-idle 0.7.2 → 1.0.0

package/dist/playground/haskellAssets.js

@@ -0,0 +1,93 @@
+import { HASKELL_RUNTIME_ASSET_NAMES, snapshotHaskellRuntimeAssetReceipts, verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
+import { fetchRuntimeAssetBytes, resolveRuntimeAssetUrl } from './worker/runtimeAssetFetch';
+export function snapshotHaskellRuntimeAssetConfig(config) {
+    if (!config || typeof config !== 'object') {
+        throw new TypeError('Haskell runtime asset configuration is required');
+    }
+    const moduleUrl = config.moduleUrl;
+    const rootfsUrl = config.rootfsUrl;
+    const bsdtarUrl = config.bsdtarUrl;
+    const integrityInput = config.integrity;
+    const maxAssetBytes = config.maxAssetBytes;
+    if (!Number.isSafeInteger(maxAssetBytes) || maxAssetBytes <= 0) {
+        throw new TypeError('Haskell runtime maxAssetBytes must be a positive safe integer');
+    }
+    const integrity = snapshotHaskellRuntimeAssetReceipts(integrityInput);
+    for (const asset of HASKELL_RUNTIME_ASSET_NAMES) {
+        if (integrity[asset].bytes > maxAssetBytes) {
+            throw new TypeError(`Haskell runtime receipt exceeds its limit for ${asset}`);
+        }
+    }
+    return Object.freeze({
+        moduleUrl: resolveRuntimeAssetUrl(moduleUrl, 'Haskell runtime module').href,
+        rootfsUrl: resolveRuntimeAssetUrl(rootfsUrl, 'Haskell GHC rootfs').href,
+        bsdtarUrl: resolveRuntimeAssetUrl(bsdtarUrl, 'Haskell rootfs extractor').href,
+        integrity,
+        maxAssetBytes
+    });
+}
+const decoder = new TextDecoder('utf-8', { fatal: true });
+export async function loadVerifiedHaskellRuntimeAssets(config, options = {}) {
+    const snapshot = snapshotHaskellRuntimeAssetConfig(config);
+    const controller = new AbortController();
+    const forwardAbort = () => controller.abort(options.signal?.reason ??
+        new DOMException('Haskell runtime asset loading was aborted', 'AbortError'));
+    options.signal?.addEventListener('abort', forwardAbort, { once: true });
+    if (options.signal?.aborted)
+        forwardAbort();
+    try {
+        const [moduleBytes, rootfsBytes, bsdtarBytes] = await Promise.all(HASKELL_RUNTIME_ASSET_NAMES.map(async (asset) => {
+            const url = asset === 'dyld.mjs'
+                ? snapshot.moduleUrl
+                : asset === 'rootfs.tar.zst'
+                    ? snapshot.rootfsUrl
+                    : snapshot.bsdtarUrl;
+            const receipt = snapshot.integrity[asset];
+            const bytes = await fetchRuntimeAssetBytes({
+                url,
+                label: asset === 'dyld.mjs'
+                    ? 'Haskell runtime module'
+                    : asset === 'rootfs.tar.zst'
+                        ? 'Haskell GHC rootfs'
+                        : 'Haskell rootfs extractor',
+                cache: 'no-store',
+                maxAssetBytes: Math.min(receipt.bytes, snapshot.maxAssetBytes),
+                signal: controller.signal,
+                onProgress(progress) {
+                    options.onProgress?.({ asset, ...progress });
+                }
+            });
+            if (controller.signal.aborted)
+                throw controller.signal.reason;
+            await verifyRuntimeAssetIntegrity({
+                asset,
+                bytes,
+                expected: receipt,
+                runtimeId: 'HASKELL'
+            });
+            if (controller.signal.aborted)
+                throw controller.signal.reason;
+            return bytes;
+        }));
+        let moduleSource;
+        try {
+            moduleSource = decoder.decode(moduleBytes);
+        }
+        catch (error) {
+            throw new TypeError('Haskell runtime module is not valid UTF-8', { cause: error });
+        }
+        return Object.freeze({
+            config: snapshot,
+            moduleSource,
+            rootfsBytes: rootfsBytes,
+            bsdtarBytes: bsdtarBytes
+        });
+    }
+    catch (error) {
+        controller.abort(error);
+        throw error;
+    }
+    finally {
+        options.signal?.removeEventListener('abort', forwardAbort);
+    }
+}

package/dist/playground/index.d.ts

@@ -1,5 +1,5 @@
 import type { BoundSandbox, PlaygroundBinding, Sandbox, SandboxRuntimeAssets } from './sandbox';
-export declare const supportedLanguages: string[];
+export declare const supportedLanguages: ("C" | "CPP" | "OBJC" | "D" | "TINYGO" | "RUBY" | "PERL" | "TCL" | "AWK" | "PASCAL" | "JANET" | "JULIA" | "NIM" | "BASH" | "BQN" | "CLOJURESCRIPT" | "FORTH" | "J" | "PROLOG" | "C3" | "PYTHON3" | "JAVA" | "RUST" | "GO" | "CSHARP" | "FSHARP" | "VBNET" | "ELIXIR" | "ERLANG" | "GLEAM" | "FORTRAN" | "LFORTRAN" | "COBOL" | "OCAML" | "JAVASCRIPT" | "TYPESCRIPT" | "ASSEMBLYSCRIPT" | "WAT" | "WASM" | "LUA" | "ZIG" | "LISP" | "HASKELL" | "R" | "OCTAVE" | "DUCKDB" | "SQLITE" | "PHP")[];
 export declare function createPlaygroundBinding(runtimeAssets: SandboxRuntimeAssets): PlaygroundBinding;
 declare function playground(language: string): Promise<Sandbox>;
 declare function playground(language: string, runtimeAssets: SandboxRuntimeAssets): Promise<BoundSandbox>;

package/dist/playground/index.js

@@ -1,119 +1,368 @@
-import Clang from './clang';
-import Elixir from './elixir';
-import Go from './go';
-import Java from './java';
-import Ocaml from './ocaml';
-import Python from './python';
-import Rust from './rust';
-import TinyGo from './tinygo';
-const sandboxCache = {};
-export const supportedLanguages = [
-    'PYTHON3',
-    'PYPY3',
-    'C',
-    'CPP',
-    'JAVA',
-    'RUST',
-    'GO',
-    'ELIXIR',
-    'TINYGO',
-    'OCAML'
+import { createPlaygroundBinding as createCorePlaygroundBinding, isSupportedLanguageId, normalizeLanguageId, supportedLanguageIds } from '@wasm-idle/core';
+const sandboxRoutes = [
+    {
+        languageId: 'C3',
+        load: async () => {
+            const { default: C3 } = await import('./c3');
+            return new C3();
+        }
+    },
+    {
+        languageId: 'PYTHON3',
+        load: async () => {
+            const { default: Python } = await import('./python');
+            return new Python();
+        }
+    },
+    {
+        languageId: 'C',
+        load: async () => {
+            const { default: Clang } = await import('./clang');
+            return new Clang('C');
+        }
+    },
+    {
+        languageId: 'CPP',
+        load: async () => {
+            const { default: Clang } = await import('./clang');
+            return new Clang('CPP');
+        }
+    },
+    {
+        languageId: 'OBJC',
+        load: async () => {
+            const { default: ObjectiveC } = await import('./objectivec');
+            return new ObjectiveC();
+        }
+    },
+    {
+        languageId: 'JAVA',
+        load: async () => {
+            const { default: Java } = await import('./java');
+            return new Java();
+        }
+    },
+    {
+        languageId: 'RUST',
+        load: async () => {
+            const { default: Rust } = await import('./rust');
+            return new Rust();
+        }
+    },
+    {
+        languageId: 'GO',
+        load: async () => {
+            const { default: Go } = await import('./go');
+            return new Go();
+        }
+    },
+    {
+        languageId: 'D',
+        load: async () => {
+            const { default: D } = await import('./d');
+            return new D();
+        }
+    },
+    {
+        languageId: 'CSHARP',
+        load: async () => {
+            const { default: Dotnet } = await import('./dotnet');
+            return new Dotnet('CSHARP');
+        }
+    },
+    {
+        languageId: 'FSHARP',
+        load: async () => {
+            const { default: Dotnet } = await import('./dotnet');
+            return new Dotnet('FSHARP');
+        }
+    },
+    {
+        languageId: 'VBNET',
+        load: async () => {
+            const { default: Dotnet } = await import('./dotnet');
+            return new Dotnet('VBNET');
+        }
+    },
+    {
+        languageId: 'ELIXIR',
+        load: async () => {
+            const { default: Elixir } = await import('./elixir');
+            return new Elixir();
+        }
+    },
+    {
+        languageId: 'ERLANG',
+        load: async () => {
+            const { default: Elixir } = await import('./elixir');
+            return new Elixir('ERLANG');
+        }
+    },
+    {
+        languageId: 'PROLOG',
+        load: async () => {
+            const { default: Prolog } = await import('./prolog');
+            return new Prolog();
+        }
+    },
+    {
+        languageId: 'GLEAM',
+        load: async () => {
+            const { default: Gleam } = await import('./gleam');
+            return new Gleam();
+        }
+    },
+    {
+        languageId: 'PERL',
+        load: async () => {
+            const { default: Perl } = await import('./perl');
+            return new Perl();
+        }
+    },
+    {
+        languageId: 'TCL',
+        load: async () => {
+            const { default: Tcl } = await import('./tcl');
+            return new Tcl();
+        }
+    },
+    {
+        languageId: 'AWK',
+        load: async () => {
+            const { default: Awk } = await import('./awk');
+            return new Awk();
+        }
+    },
+    {
+        languageId: 'PASCAL',
+        load: async () => {
+            const { default: Pascal } = await import('./pascal');
+            return new Pascal();
+        }
+    },
+    {
+        languageId: 'CLOJURESCRIPT',
+        load: async () => {
+            const { default: ClojureScript } = await import('./clojurescript');
+            return new ClojureScript();
+        }
+    },
+    {
+        languageId: 'FORTH',
+        load: async () => {
+            const { default: Forth } = await import('./forth');
+            return new Forth();
+        }
+    },
+    {
+        languageId: 'J',
+        load: async () => {
+            const { default: J } = await import('./j');
+            return new J();
+        }
+    },
+    {
+        languageId: 'BQN',
+        load: async () => {
+            const { default: Bqn } = await import('./bqn');
+            return new Bqn();
+        }
+    },
+    {
+        languageId: 'JANET',
+        load: async () => {
+            const { default: Janet } = await import('./janet');
+            return new Janet();
+        }
+    },
+    {
+        languageId: 'JULIA',
+        load: async () => {
+            const { default: Julia } = await import('./julia');
+            return new Julia();
+        }
+    },
+    {
+        languageId: 'NIM',
+        load: async () => {
+            const { default: Nim } = await import('./nim');
+            return new Nim();
+        }
+    },
+    {
+        languageId: 'BASH',
+        load: async () => {
+            const { default: Bash } = await import('./bash');
+            return new Bash();
+        }
+    },
+    {
+        languageId: 'LFORTRAN',
+        load: async () => {
+            const { default: LFortran } = await import('./lfortran');
+            return new LFortran();
+        }
+    },
+    {
+        languageId: 'FORTRAN',
+        load: async () => {
+            const { default: Fortran } = await import('./fortran');
+            return new Fortran();
+        }
+    },
+    {
+        languageId: 'COBOL',
+        load: async () => {
+            const { default: Cobol } = await import('./cobol');
+            return new Cobol();
+        }
+    },
+    {
+        languageId: 'TINYGO',
+        load: async () => {
+            const { default: TinyGo } = await import('./tinygo');
+            return new TinyGo();
+        }
+    },
+    {
+        languageId: 'OCAML',
+        load: async () => {
+            const { default: Ocaml } = await import('./ocaml');
+            return new Ocaml();
+        }
+    },
+    {
+        languageId: 'JAVASCRIPT',
+        load: async () => {
+            const { default: TypeScriptSandbox } = await import('./typescript');
+            return new TypeScriptSandbox('JAVASCRIPT');
+        }
+    },
+    {
+        languageId: 'TYPESCRIPT',
+        load: async () => {
+            const { default: TypeScriptSandbox } = await import('./typescript');
+            return new TypeScriptSandbox('TYPESCRIPT');
+        }
+    },
+    {
+        languageId: 'ASSEMBLYSCRIPT',
+        load: async () => {
+            const { default: AssemblyScript } = await import('./assemblyscript');
+            return new AssemblyScript();
+        }
+    },
+    {
+        languageId: 'WAT',
+        load: async () => {
+            const { default: Wat } = await import('./wat');
+            return new Wat();
+        }
+    },
+    {
+        languageId: 'WASM',
+        load: async () => {
+            const { default: Wasm } = await import('./wasm');
+            return new Wasm();
+        }
+    },
+    {
+        languageId: 'LUA',
+        load: async () => {
+            const { default: Lua } = await import('./lua');
+            return new Lua();
+        }
+    },
+    {
+        languageId: 'ZIG',
+        load: async () => {
+            const { default: Zig } = await import('./zig');
+            return new Zig();
+        }
+    },
+    {
+        languageId: 'LISP',
+        load: async () => {
+            const { default: Lisp } = await import('./lisp');
+            return new Lisp();
+        }
+    },
+    {
+        languageId: 'RUBY',
+        load: async () => {
+            const { default: Ruby } = await import('./ruby');
+            return new Ruby();
+        }
+    },
+    {
+        languageId: 'HASKELL',
+        load: async () => {
+            const { default: Haskell } = await import('./haskell');
+            return new Haskell();
+        }
+    },
+    {
+        languageId: 'R',
+        load: async () => {
+            const { default: R } = await import('./r');
+            return new R();
+        }
+    },
+    {
+        languageId: 'OCTAVE',
+        load: async () => {
+            const { default: Octave } = await import('./octave');
+            return new Octave();
+        }
+    },
+    {
+        languageId: 'DUCKDB',
+        load: async () => {
+            const { default: DuckDB } = await import('./duckdb');
+            return new DuckDB();
+        }
+    },
+    {
+        languageId: 'SQLITE',
+        load: async () => {
+            const { default: Sqlite } = await import('./sqlite');
+            return new Sqlite();
+        }
+    },
+    {
+        languageId: 'PHP',
+        load: async () => {
+            const { default: Php } = await import('./php');
+            return new Php();
+        }
+    }
 ];
-function bindRuntimeAssets(sandbox, runtimeAssets) {
-    return new Proxy(sandbox, {
-        get(target, prop, receiver) {
-            if (prop === 'runtimeAssets')
-                return runtimeAssets;
-            if (prop === 'load') {
-                return (code = '', log = true, args = [], options = {}, progress) => target.load(runtimeAssets, code, log, args, options, progress);
-            }
-            const value = Reflect.get(target, prop, receiver);
-            return typeof value === 'function' ? value.bind(target) : value;
-        },
-        set(target, prop, value, receiver) {
-            return Reflect.set(target, prop, value, receiver);
-        }
-    });
+const sandboxRouteByLanguage = new Map();
+for (const route of sandboxRoutes) {
+    if (sandboxRouteByLanguage.has(route.languageId)) {
+        throw new Error(`Duplicate sandbox route: ${route.languageId}`);
+    }
+    sandboxRouteByLanguage.set(route.languageId, route);
+}
+for (const languageId of supportedLanguageIds) {
+    if (!sandboxRouteByLanguage.has(languageId)) {
+        throw new Error(`Missing sandbox route: ${languageId}`);
+    }
 }
+export const supportedLanguages = [...supportedLanguageIds];
 export function createPlaygroundBinding(runtimeAssets) {
-    const binding = {
-        runtimeAssets,
-        terminalProps: {},
-        async load(language) {
-            return bindRuntimeAssets(await playground(language), runtimeAssets);
-        }
-    };
-    binding.terminalProps = {
-        playground: binding,
-        runtimeAssets
-    };
-    return binding;
+    return createCorePlaygroundBinding(runtimeAssets, playground);
 }
 async function playground(language, runtimeAssets) {
-    if (sandboxCache[language]) {
-        return runtimeAssets
-            ? bindRuntimeAssets(sandboxCache[language], runtimeAssets)
-            : sandboxCache[language];
-    }
-    let sandbox;
-    switch (language) {
-        case 'PYTHON3':
-        case 'PYTHON':
-        case 'PYPY3':
-            sandbox = new Python();
-            break;
-        case 'C':
-            sandbox = new Clang('C');
-            break;
-        case 'CPP':
-            sandbox = new Clang('CPP');
-            break;
-        case 'JAVA':
-            sandbox = new Java();
-            break;
-        case 'RUST':
-            sandbox = new Rust();
-            break;
-        case 'GO':
-            sandbox = new Go();
-            break;
-        case 'ELIXIR':
-            sandbox = new Elixir();
-            break;
-        case 'TINYGO':
-            sandbox = new TinyGo();
-            break;
-        case 'OCAML':
-            sandbox = new Ocaml();
-            break;
-        default:
-            throw new Error(`Unsupported language: ${language}`);
-    }
-    sandboxCache[language] = sandbox;
-    if (sandbox) {
-        if (language === 'PYTHON3')
-            sandboxCache['PYPY3'] = sandboxCache['PYTHON'] = sandbox;
-        if (language === 'PYTHON')
-            sandboxCache['PYTHON3'] = sandboxCache['PYPY3'] = sandbox;
-        if (language === 'PYPY3')
-            sandboxCache['PYTHON3'] = sandboxCache['PYTHON'] = sandbox;
-        if (language === 'C')
-            sandboxCache['C'] = sandbox;
-        if (language === 'CPP')
-            sandboxCache['CPP'] = sandbox;
-        if (language === 'JAVA')
-            sandboxCache['JAVA'] = sandbox;
-        if (language === 'RUST')
-            sandboxCache['RUST'] = sandbox;
-        if (language === 'GO')
-            sandboxCache['GO'] = sandbox;
-        if (language === 'ELIXIR')
-            sandboxCache['ELIXIR'] = sandbox;
-        if (language === 'TINYGO')
-            sandboxCache['TINYGO'] = sandbox;
-        if (language === 'OCAML')
-            sandboxCache['OCAML'] = sandbox;
+    const normalizedLanguage = normalizeLanguageId(language);
+    if (!isSupportedLanguageId(normalizedLanguage)) {
+        throw new Error(`Unsupported language: ${language}`);
     }
-    return runtimeAssets ? bindRuntimeAssets(sandbox, runtimeAssets) : sandbox;
+    const route = sandboxRouteByLanguage.get(normalizedLanguage);
+    if (!route)
+        throw new Error(`Missing sandbox route: ${normalizedLanguage}`);
+    return runtimeAssets
+        ? createPlaygroundBinding(runtimeAssets).load(normalizedLanguage)
+        : route.load();
 }
 export default playground;

package/dist/playground/j.d.ts

@@ -0,0 +1,5 @@
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+declare class J extends StaticWorkerRuntimeSandbox {
+    constructor();
+}
+export default J;

package/dist/playground/j.js

@@ -0,0 +1,60 @@
+import { resolveJRuntimeAssetConfig } from './assets';
+import { preflightStaticRuntimeAssetsInWorker } from './staticRuntimePreflight';
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+import { RuntimeConfigurationError } from '@wasm-idle/core';
+class J extends StaticWorkerRuntimeSandbox {
+    constructor() {
+        super({
+            languageId: 'J',
+            displayName: 'J',
+            defaultActivePath: 'main.ijs',
+            moduleWorker: true,
+            inlineVerifiedWorker: true,
+            runtimePreflightDelivery: 'transfer-owned',
+            stdin: {
+                mode: 'streaming',
+                sourceHintPattern: /1!:\s*1|\/dev\/stdin|\bstdin\b/iu
+            },
+            resolveRuntimeAssets(runtimeAssets, currentUrl) {
+                const resolved = resolveJRuntimeAssetConfig(runtimeAssets, currentUrl);
+                const profile = resolved.preflightProfile;
+                if (!/^[a-f0-9]{64}$/u.test(resolved.manifestFingerprint || '') ||
+                    profile.manifestFingerprint !== resolved.manifestFingerprint ||
+                    !resolved.workerReceipt) {
+                    throw new RuntimeConfigurationError('J runtime requires one coherent preflight profile, manifest fingerprint, and worker receipt.', { runtimeId: 'J' });
+                }
+                return resolved;
+            },
+            async preflightRuntimeAssets(urls, context) {
+                const profile = urls.preflightProfile;
+                const loadedByAsset = new Map();
+                const totalDownloadBytes = (profile.manifestReceipt?.bytes ?? 0) +
+                    (profile.moduleReceipt?.bytes ?? 0) +
+                    (profile.wasmReceipt?.bytes ?? 0);
+                const payload = await preflightStaticRuntimeAssetsInWorker({
+                    runtimeId: 'J',
+                    displayName: 'J',
+                    baseUrl: urls.baseUrl,
+                    manifestUrl: urls.manifestUrl || '',
+                    profile,
+                    limits: context.limits,
+                    signal: context.signal,
+                    reportProgress(progress) {
+                        if (progress.kind === 'asset') {
+                            loadedByAsset.set(progress.progress.assetKey, progress.progress.loadedBytes);
+                            const loadedBytes = [...loadedByAsset.values()].reduce((total, loaded) => total + loaded, 0);
+                            const fraction = totalDownloadBytes > 0 ? loadedBytes / totalDownloadBytes : 0;
+                            context.reportProgress(0.04 + Math.min(1, fraction) * 0.11, `Preflighting J asset ${progress.progress.assetKey}`);
+                            return;
+                        }
+                        const { loadedBytes, totalBytes } = progress;
+                        const fraction = totalBytes > 0 ? loadedBytes / totalBytes : 0;
+                        context.reportProgress(0.15 + Math.min(1, fraction) * 0.02, 'Decompressing verified J Wasm');
+                    }
+                });
+                return context.createOwnedDelivery(payload);
+            }
+        });
+    }
+}
+export default J;

package/dist/playground/jPreflight.d.ts

@@ -0,0 +1,26 @@
+import type { JRuntimePreflightProfile } from './assets';
+import { type ExecutionLimits, type RuntimeAssetPreflightProgress } from '@wasm-idle/core';
+export declare const J_PREFLIGHT_PROTOCOL: "wasm-idle-j-preflight";
+export declare const J_PREFLIGHT_PROTOCOL_VERSION: 1;
+export declare const J_PREFLIGHT_RUNTIME_ID: "J";
+export interface JRuntimePreflightRequest {
+    readonly baseUrl: string;
+    readonly manifestUrl: string;
+    readonly profile: JRuntimePreflightProfile;
+    readonly limits?: Partial<ExecutionLimits>;
+    readonly signal?: AbortSignal;
+    readonly fetch?: typeof globalThis.fetch;
+    readonly reportProgress?: (progress: RuntimeAssetPreflightProgress) => void;
+    readonly reportDecompressionProgress?: (loadedBytes: number, totalBytes: number) => void;
+}
+export interface JRuntimePreflightPayload {
+    readonly protocol: typeof J_PREFLIGHT_PROTOCOL;
+    readonly protocolVersion: typeof J_PREFLIGHT_PROTOCOL_VERSION;
+    readonly profileId: string;
+    readonly sourceRevision: string;
+    readonly manifestFingerprint: string;
+    readonly manifestBytes: Uint8Array;
+    readonly moduleBytes: Uint8Array;
+    readonly wasmBytes: Uint8Array;
+}
+export declare function preflightJRuntimeAssets(request: JRuntimePreflightRequest): Promise<JRuntimePreflightPayload>;