wasm-idle 0.6.0 → 0.7.0

package/dist/playground/tinygo.d.ts

@@ -0,0 +1,75 @@
+import { type PlaygroundRuntimeAssets, type TinyGoRuntimeAssetLoader, type TinyGoRuntimeAssetPackReference } from './assets';
+import { type SandboxExecutionOptions } from './options';
+import type { Sandbox } from './sandbox';
+type TinyGoRuntimeHooks = {
+    boot(): Promise<void>;
+    plan(): Promise<unknown>;
+    execute(): Promise<void>;
+    reset(): void;
+    readActivityLog(): string;
+    readBuildArtifact(): {
+        path: string;
+        bytes: Uint8Array;
+        artifactKind?: 'probe' | 'bootstrap' | 'execution';
+        runnable?: boolean;
+        entrypoint?: '_start' | '_initialize' | 'main' | null;
+        reason?: 'bootstrap-artifact' | 'missing-wasi-entrypoint';
+    } | null;
+    setWorkspaceFiles(files: Record<string, string> | null): void;
+    dispose?(): void;
+};
+declare class TinyGo implements Sandbox {
+    output: any;
+    worker?: Worker;
+    buffer: SharedArrayBuffer;
+    pendingInput: string[];
+    begin: number;
+    elapse: number;
+    uid: number;
+    exit: boolean;
+    moduleUrl: string;
+    hostCompileUrl: string;
+    hostCompileUrls: string[];
+    rustRuntimeBaseUrl: string;
+    assetLoader: TinyGoRuntimeAssetLoader | undefined;
+    assetPacks: TinyGoRuntimeAssetPackReference[] | undefined;
+    runtime: TinyGoRuntimeHooks | null;
+    runtimePromise: Promise<TinyGoRuntimeHooks> | null;
+    loadPromise: Promise<void> | null;
+    compiledArtifact: Uint8Array | null;
+    compiledArtifactExecutionError: string;
+    compiledCacheKey: string;
+    activeReject: ((reason: string) => void) | null;
+    waitingForInput: boolean;
+    pendingEof: boolean;
+    lastActivityLog: string;
+    runtimeProgress: {
+        set?: (value: number) => void;
+    } | import('svelte/store').Writable<number> | undefined;
+    runtimeProgressStart: number;
+    runtimeProgressEnd: number;
+    runtimeProgressValue: number;
+    runtimeProgressAssets: Map<string, {
+        loaded: number;
+        total: number;
+    }>;
+    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;
+    private ensureWorker;
+    private disposeRuntime;
+    private ensureRuntime;
+    private emitActivityLog;
+    private extractCompileFailure;
+    private compileArtifact;
+    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 TinyGo;

package/dist/playground/tinygo.js

@@ -0,0 +1,510 @@
+import { resolveRustCompilerUrl, resolveTinyGoHostCompileUrls, resolveTinyGoModuleUrl } from './assets';
+import { resolveSandboxExecutionArgs } from './options';
+import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
+const ACTIVITY_PREFIX_PATTERN = /^\[\d{2}:\d{2}:\d{2}\]\s?/gm;
+class TinyGo {
+    output = null;
+    worker = null;
+    buffer = new SharedArrayBuffer(1024);
+    pendingInput = [];
+    begin = 0;
+    elapse = 0;
+    uid = 0;
+    exit = true;
+    moduleUrl = '';
+    hostCompileUrl = '';
+    hostCompileUrls = [];
+    rustRuntimeBaseUrl = '';
+    assetLoader = undefined;
+    assetPacks = undefined;
+    runtime = null;
+    runtimePromise = null;
+    loadPromise = null;
+    compiledArtifact = null;
+    compiledArtifactExecutionError = '';
+    compiledCacheKey = '';
+    activeReject = null;
+    waitingForInput = false;
+    pendingEof = false;
+    lastActivityLog = '';
+    runtimeProgress = undefined;
+    runtimeProgressStart = 0;
+    runtimeProgressEnd = 0;
+    runtimeProgressValue = 0;
+    runtimeProgressAssets = new Map();
+    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 nextModuleUrl = resolveTinyGoModuleUrl(runtimeAssets, currentUrl);
+            const nextHostCompileUrls = resolveTinyGoHostCompileUrls(runtimeAssets, currentUrl);
+            const nextRustCompilerUrl = resolveRustCompilerUrl(runtimeAssets, currentUrl);
+            const nextRustRuntimeBaseUrl = nextRustCompilerUrl
+                ? new URL('./runtime/', nextRustCompilerUrl).toString()
+                : '';
+            if (!nextModuleUrl && nextHostCompileUrls.length === 0) {
+                return reject('TinyGo runtime is not configured. Set PUBLIC_WASM_TINYGO_MODULE_URL, PUBLIC_WASM_TINYGO_HOST_COMPILE_URL, runtimeAssets.tinygo.moduleUrl, or runtimeAssets.tinygo.hostCompileUrl.');
+            }
+            if ((this.moduleUrl && this.moduleUrl !== nextModuleUrl) ||
+                this.hostCompileUrls.join('\n') !== nextHostCompileUrls.join('\n') ||
+                this.rustRuntimeBaseUrl !== nextRustRuntimeBaseUrl) {
+                this.disposeRuntime();
+                this.compiledArtifact = null;
+                this.compiledArtifactExecutionError = '';
+                this.compiledCacheKey = '';
+            }
+            const nextAssetLoader = typeof runtimeAssets === 'object' ? runtimeAssets?.tinygo?.assetLoader : undefined;
+            const nextAssetPacks = typeof runtimeAssets === 'object' ? runtimeAssets?.tinygo?.assetPacks : undefined;
+            this.moduleUrl = nextModuleUrl;
+            this.hostCompileUrl = nextHostCompileUrls[0] || '';
+            this.hostCompileUrls = nextHostCompileUrls;
+            this.rustRuntimeBaseUrl = nextRustRuntimeBaseUrl;
+            this.assetLoader = nextAssetLoader;
+            this.assetPacks = nextAssetPacks;
+            try {
+                progress?.set?.(0.25);
+                await this.ensureWorker();
+                progress?.set?.(0.5);
+                if (nextHostCompileUrls.length === 0 && nextModuleUrl) {
+                    await this.ensureRuntime();
+                }
+                progress?.set?.(1);
+                resolve();
+            }
+            catch (error) {
+                reject(error instanceof Error ? error.message : String(error));
+            }
+        });
+    }
+    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;
+        }
+    }
+    async ensureWorker() {
+        if (this.worker)
+            return;
+        if (this.loadPromise) {
+            await this.loadPromise;
+            return;
+        }
+        this.loadPromise = new Promise(async (resolve, reject) => {
+            this.worker = new (await import('./worker/tinygo?worker')).default();
+            this.worker.onerror = (event) => {
+                const location = event.filename && event.lineno
+                    ? ` (${event.filename}:${event.lineno}:${event.colno})`
+                    : '';
+                reject(`TinyGo worker script error: ${event.message || 'unknown error'}${location}`);
+            };
+            this.worker.onmessageerror = () => {
+                reject('TinyGo worker message deserialization failed');
+            };
+            this.worker.onmessage = (event) => {
+                if (event.data?.load)
+                    resolve();
+                if (event.data?.error)
+                    reject(event.data.error);
+            };
+            this.worker.postMessage({ load: true });
+        }).finally(() => {
+            this.loadPromise = null;
+        });
+        await this.loadPromise;
+    }
+    disposeRuntime() {
+        this.runtime?.dispose?.();
+        this.runtime = null;
+        this.runtimePromise = null;
+        this.lastActivityLog = '';
+        this.compiledArtifactExecutionError = '';
+    }
+    async ensureRuntime() {
+        if (this.runtime) {
+            return this.runtime;
+        }
+        if (this.runtimePromise) {
+            return await this.runtimePromise;
+        }
+        const moduleUrl = this.moduleUrl;
+        this.runtimePromise = (async () => {
+            const runtimeModule = (await import(/* @vite-ignore */ moduleUrl));
+            if (typeof runtimeModule.createBundledTinyGoRuntime === 'function') {
+                this.runtime = runtimeModule.createBundledTinyGoRuntime({
+                    assetLoader: this.assetLoader,
+                    assetPacks: this.assetPacks,
+                    rustRuntimeBaseUrl: this.rustRuntimeBaseUrl || undefined,
+                    onProgress: (progress) => {
+                        if (!this.runtimeProgress)
+                            return;
+                        const total = progress.total && progress.total > 0 ? progress.total : progress.loaded;
+                        const key = progress.assetUrl || progress.assetPath;
+                        this.runtimeProgressAssets.set(key, {
+                            loaded: Math.max(0, progress.loaded),
+                            total: Math.max(1, total)
+                        });
+                        let loaded = 0;
+                        let size = 0;
+                        for (const entry of this.runtimeProgressAssets.values()) {
+                            loaded += Math.min(entry.loaded, entry.total);
+                            size += entry.total;
+                        }
+                        if (size <= 0)
+                            return;
+                        const nextValue = this.runtimeProgressStart +
+                            ((this.runtimeProgressEnd - this.runtimeProgressStart) * loaded) / size;
+                        if (nextValue <= this.runtimeProgressValue)
+                            return;
+                        this.runtimeProgressValue = nextValue;
+                        this.runtimeProgress.set?.(nextValue);
+                    }
+                });
+                return this.runtime;
+            }
+            if (typeof runtimeModule.createTinyGoRuntime === 'function') {
+                this.runtime = runtimeModule.createTinyGoRuntime({
+                    assetBaseUrl: new URL('./', moduleUrl).toString(),
+                    assetLoader: this.assetLoader,
+                    assetPacks: this.assetPacks,
+                    rustRuntimeBaseUrl: this.rustRuntimeBaseUrl || undefined,
+                    onProgress: (progress) => {
+                        if (!this.runtimeProgress)
+                            return;
+                        const total = progress.total && progress.total > 0 ? progress.total : progress.loaded;
+                        const key = progress.assetUrl || progress.assetPath;
+                        this.runtimeProgressAssets.set(key, {
+                            loaded: Math.max(0, progress.loaded),
+                            total: Math.max(1, total)
+                        });
+                        let loaded = 0;
+                        let size = 0;
+                        for (const entry of this.runtimeProgressAssets.values()) {
+                            loaded += Math.min(entry.loaded, entry.total);
+                            size += entry.total;
+                        }
+                        if (size <= 0)
+                            return;
+                        const nextValue = this.runtimeProgressStart +
+                            ((this.runtimeProgressEnd - this.runtimeProgressStart) * loaded) / size;
+                        if (nextValue <= this.runtimeProgressValue)
+                            return;
+                        this.runtimeProgressValue = nextValue;
+                        this.runtimeProgress.set?.(nextValue);
+                    }
+                });
+                return this.runtime;
+            }
+            ;
+            throw new Error('TinyGo runtime module must export createBundledTinyGoRuntime or createTinyGoRuntime');
+        })().catch((error) => {
+            this.disposeRuntime();
+            throw error;
+        });
+        return await this.runtimePromise;
+    }
+    emitActivityLog(hooks) {
+        const nextActivityLog = hooks.readActivityLog();
+        const delta = nextActivityLog.startsWith(this.lastActivityLog)
+            ? nextActivityLog.slice(this.lastActivityLog.length)
+            : nextActivityLog;
+        this.lastActivityLog = nextActivityLog;
+        if (!delta)
+            return;
+        const sanitized = delta.replace(ACTIVITY_PREFIX_PATTERN, '');
+        if (sanitized)
+            this.output?.(sanitized);
+    }
+    extractCompileFailure() {
+        const sanitized = this.lastActivityLog.replace(ACTIVITY_PREFIX_PATTERN, '');
+        const lines = sanitized
+            .split('\n')
+            .map((line) => line.trim())
+            .filter(Boolean);
+        for (let index = lines.length - 1; index >= 0; index -= 1) {
+            if (/(failed|error)/i.test(lines[index] || '')) {
+                return lines[index];
+            }
+        }
+        return 'TinyGo compilation failed';
+    }
+    async compileArtifact(code, log = true, prog) {
+        const compileCacheKey = JSON.stringify({
+            code,
+            hostCompileUrls: this.hostCompileUrls,
+            moduleUrl: this.moduleUrl
+        });
+        if (this.compiledArtifact && this.compiledCacheKey === compileCacheKey) {
+            return;
+        }
+        const unavailableHostCompileUrls = [];
+        if (this.hostCompileUrls.length > 0) {
+            prog?.set?.(0.05);
+            for (const hostCompileUrl of this.hostCompileUrls) {
+                let hostCompileResponse = null;
+                try {
+                    hostCompileResponse = await fetch(hostCompileUrl, {
+                        method: 'POST',
+                        headers: {
+                            'content-type': 'application/json'
+                        },
+                        body: JSON.stringify({
+                            source: code
+                        })
+                    });
+                }
+                catch (error) {
+                    unavailableHostCompileUrls.push(hostCompileUrl);
+                    if (!this.moduleUrl && hostCompileUrl === this.hostCompileUrls.at(-1)) {
+                        throw error;
+                    }
+                    continue;
+                }
+                if (hostCompileResponse?.ok) {
+                    const payload = (await hostCompileResponse.json());
+                    const artifactBase64 = payload.artifact?.bytesBase64 || '';
+                    if (!payload.artifact?.path || !artifactBase64) {
+                        throw new Error('TinyGo host compile did not return a wasm artifact');
+                    }
+                    const artifactBytes = Uint8Array.from(atob(artifactBase64), (char) => char.charCodeAt(0));
+                    this.compiledArtifact = artifactBytes;
+                    this.compiledArtifactExecutionError =
+                        payload.artifact.runnable === false
+                            ? payload.artifact.artifactKind === 'probe'
+                                ? 'TinyGo host compile returned a non-runnable probe artifact without a supported WASI entrypoint.'
+                                : payload.artifact.reason === 'bootstrap-artifact'
+                                    ? 'TinyGo host compile returned a bootstrap artifact and cannot execute it yet.'
+                                    : 'TinyGo host compile returned a non-runnable artifact without a supported WASI entrypoint.'
+                            : '';
+                    this.compiledCacheKey = compileCacheKey;
+                    prog?.set?.(0.95);
+                    if (log) {
+                        for (const line of payload.logs || []) {
+                            this.output?.(line.endsWith('\n') ? line : `${line}\n`);
+                        }
+                        this.output?.(`tinygo artifact ready: ${payload.artifact.path}\n`);
+                    }
+                    return;
+                }
+                if (hostCompileResponse &&
+                    hostCompileResponse.status !== 404 &&
+                    hostCompileResponse.status !== 405 &&
+                    hostCompileResponse.status !== 501) {
+                    let failureMessage = 'TinyGo host compile failed';
+                    try {
+                        const payload = await hostCompileResponse.json();
+                        if (typeof payload?.error === 'string' && payload.error) {
+                            failureMessage = payload.error;
+                        }
+                    }
+                    catch {
+                        const responseText = await hostCompileResponse.text();
+                        if (responseText.trim()) {
+                            failureMessage = responseText.trim();
+                        }
+                    }
+                    throw new Error(failureMessage);
+                }
+                if (hostCompileResponse) {
+                    unavailableHostCompileUrls.push(hostCompileUrl);
+                }
+            }
+        }
+        if (!this.moduleUrl) {
+            if (unavailableHostCompileUrls.length > 0) {
+                throw new Error(`TinyGo host compile endpoints were unavailable: ${unavailableHostCompileUrls.join(', ')}.`);
+            }
+            throw new Error('TinyGo host compile endpoint is unavailable.');
+        }
+        const runtime = await this.ensureRuntime();
+        runtime.reset();
+        this.lastActivityLog = runtime.readActivityLog();
+        runtime.setWorkspaceFiles({ 'main.go': code });
+        this.runtimeProgress = prog;
+        this.runtimeProgressAssets.clear();
+        this.runtimeProgressStart = 0.05;
+        this.runtimeProgressEnd = 0.35;
+        this.runtimeProgressValue = 0.05;
+        try {
+            prog?.set?.(0.05);
+            await runtime.boot();
+            this.emitActivityLog(runtime);
+            this.runtimeProgressAssets.clear();
+            this.runtimeProgressStart = 0.35;
+            this.runtimeProgressEnd = 0.65;
+            this.runtimeProgressValue = Math.max(this.runtimeProgressValue, 0.35);
+            prog?.set?.(this.runtimeProgressValue);
+            await runtime.plan();
+            this.emitActivityLog(runtime);
+            this.runtimeProgressAssets.clear();
+            this.runtimeProgressStart = 0.65;
+            this.runtimeProgressEnd = 0.92;
+            this.runtimeProgressValue = Math.max(this.runtimeProgressValue, 0.65);
+            prog?.set?.(this.runtimeProgressValue);
+            await runtime.execute();
+            this.emitActivityLog(runtime);
+            prog?.set?.(0.95);
+        }
+        finally {
+            this.runtimeProgress = undefined;
+            this.runtimeProgressAssets.clear();
+        }
+        const artifact = runtime.readBuildArtifact();
+        if (!artifact) {
+            const compileFailure = this.extractCompileFailure();
+            if (/(?:probe-only|supported WASI entrypoint|no host compile seam is configured)/i.test(compileFailure)) {
+                throw new Error(unavailableHostCompileUrls.length > 0
+                    ? `TinyGo host compile endpoints were unavailable: ${unavailableHostCompileUrls.join(', ')}. TinyGo browser runtime could not produce a runnable execution artifact: ${compileFailure}.`
+                    : `TinyGo browser runtime could not produce a runnable execution artifact: ${compileFailure}.`);
+            }
+            throw new Error(compileFailure);
+        }
+        const runtimeLogLines = runtime
+            .readActivityLog()
+            .replace(ACTIVITY_PREFIX_PATTERN, '')
+            .split('\n')
+            .map((line) => line.trim())
+            .filter(Boolean);
+        let browserRuntimeFailure = '';
+        for (let index = runtimeLogLines.length - 1; index >= 0; index -= 1) {
+            const line = runtimeLogLines[index] || '';
+            if (/^(?:build execution failed:|artifact probe failed:)/.test(line)) {
+                browserRuntimeFailure = line.replace(/^(?:build execution failed:|artifact probe failed:)\s*/, '');
+                break;
+            }
+        }
+        this.compiledArtifact = new Uint8Array(artifact.bytes);
+        this.compiledArtifactExecutionError =
+            artifact.runnable === false
+                ? browserRuntimeFailure !== ''
+                    ? unavailableHostCompileUrls.length > 0
+                        ? `TinyGo host compile endpoints were unavailable: ${unavailableHostCompileUrls.join(', ')}. TinyGo browser runtime could not produce a runnable execution artifact: ${browserRuntimeFailure}.`
+                        : `TinyGo browser runtime could not produce a runnable execution artifact: ${browserRuntimeFailure}.`
+                    : artifact.reason === 'bootstrap-artifact'
+                        ? unavailableHostCompileUrls.length > 0
+                            ? `TinyGo host compile endpoints were unavailable: ${unavailableHostCompileUrls.join(', ')}. TinyGo browser runtime produced a bootstrap artifact and cannot execute it yet.`
+                            : 'TinyGo browser runtime produced a bootstrap artifact and cannot execute it yet.'
+                        : artifact.artifactKind === 'probe'
+                            ? unavailableHostCompileUrls.length > 0
+                                ? `TinyGo host compile endpoints were unavailable: ${unavailableHostCompileUrls.join(', ')}. TinyGo browser runtime produced a non-runnable probe artifact without a supported WASI entrypoint.`
+                                : 'TinyGo browser runtime produced a non-runnable probe artifact without a supported WASI entrypoint.'
+                            : unavailableHostCompileUrls.length > 0
+                                ? `TinyGo host compile endpoints were unavailable: ${unavailableHostCompileUrls.join(', ')}. TinyGo browser runtime produced a non-runnable artifact without a supported WASI entrypoint.`
+                                : 'TinyGo browser runtime produced a non-runnable artifact without a supported WASI entrypoint.'
+                : '';
+        this.compiledCacheKey = compileCacheKey;
+        if (log) {
+            this.output?.(`tinygo artifact ready: ${artifact.path}\n`);
+        }
+    }
+    run(code, prepare, _log = true, _prog, args = [], options = {}) {
+        this.exit = false;
+        return new Promise(async (resolve, reject) => {
+            try {
+                this.begin = Date.now();
+                await this.ensureWorker();
+                await this.compileArtifact(code, _log, prepare ? _prog : undefined);
+                if (prepare) {
+                    this.elapse = Date.now() - this.begin;
+                    this.exit = true;
+                    resolve(true);
+                    return;
+                }
+                if (this.compiledArtifactExecutionError) {
+                    throw new Error(this.compiledArtifactExecutionError);
+                }
+                if (!this.worker || !this.compiledArtifact) {
+                    throw new Error('TinyGo runtime did not prepare an artifact');
+                }
+                const { programArgs } = resolveSandboxExecutionArgs('TINYGO', args, options);
+                const _uid = ++this.uid;
+                this.activeReject = reject;
+                this.worker.onmessage = (event) => {
+                    if (!this.worker)
+                        return reject('Worker not loaded');
+                    if (_uid !== this.uid)
+                        return (this.worker.onmessage = null);
+                    const { output, results, error, buffer } = event.data;
+                    if (buffer) {
+                        this.waitingForInput = true;
+                        this.flushPendingInput();
+                    }
+                    if (output)
+                        this.output?.(output);
+                    if (results) {
+                        this.elapse = Date.now() - this.begin;
+                        this.exit = true;
+                        this.waitingForInput = false;
+                        this.pendingEof = false;
+                        this.activeReject = null;
+                        resolve(results);
+                    }
+                    if (error) {
+                        this.elapse = Date.now() - this.begin;
+                        this.exit = true;
+                        this.waitingForInput = false;
+                        this.pendingEof = false;
+                        this.activeReject = null;
+                        reject(error);
+                    }
+                };
+                this.worker.postMessage({
+                    artifact: new Uint8Array(this.compiledArtifact),
+                    buffer: this.buffer,
+                    args: programArgs,
+                    log: _log
+                });
+            }
+            catch (error) {
+                this.elapse = Date.now() - this.begin;
+                this.exit = true;
+                this.waitingForInput = false;
+                this.pendingEof = false;
+                this.activeReject = null;
+                reject(error instanceof Error ? error.message : String(error));
+            }
+        });
+    }
+    kill() {
+        this.terminate();
+    }
+    terminate() {
+        this.activeReject?.('Process terminated');
+        this.activeReject = null;
+        this.waitingForInput = false;
+        this.pendingEof = false;
+        this.uid += 1;
+        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.terminate();
+        }
+    }
+}
+export default TinyGo;

package/dist/playground/wasmElixirVersion.d.ts

@@ -0,0 +1 @@
+export declare const WASM_ELIXIR_ASSET_VERSION = "e848c7b1e0d73af2";

package/dist/playground/wasmElixirVersion.js

@@ -0,0 +1 @@
+export const WASM_ELIXIR_ASSET_VERSION = 'e848c7b1e0d73af2';

package/dist/playground/wasmGoVersion.d.ts

@@ -0,0 +1 @@
+export declare const WASM_GO_ASSET_VERSION = "af750a633c515e0c";

package/dist/playground/wasmGoVersion.js

@@ -0,0 +1 @@
+export const WASM_GO_ASSET_VERSION = "af750a633c515e0c";

package/dist/playground/wasmOcamlVersion.d.ts

@@ -0,0 +1 @@
+export declare const WASM_OCAML_ASSET_VERSION = "bd4c85620ead3426";

package/dist/playground/wasmOcamlVersion.js

@@ -0,0 +1 @@
+export const WASM_OCAML_ASSET_VERSION = "bd4c85620ead3426";

package/dist/playground/wasmRustVersion.d.ts

@@ -1 +1 @@
-export declare const WASM_RUST_ASSET_VERSION = "2d36c8a3cd2cbbfd";
+export declare const WASM_RUST_ASSET_VERSION = "1179d35ef825e266";

package/dist/playground/wasmRustVersion.js

@@ -1 +1 @@
-export const WASM_RUST_ASSET_VERSION = "2d36c8a3cd2cbbfd";
+export const WASM_RUST_ASSET_VERSION = "1179d35ef825e266";

package/dist/playground/wasmTinyGoVersion.d.ts

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

package/dist/playground/wasmTinyGoVersion.js

@@ -0,0 +1 @@
+export const WASM_TINYGO_ASSET_VERSION = "c45e1d6b3e297250";

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

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