wasm-idle 0.7.2 → 1.0.0

package/dist/playground/worker/assemblyscript.js

@@ -0,0 +1,339 @@
+import { importRuntimeModule } from '../runtimeModule';
+import { waitForBufferedStdin } from '../stdinBuffer';
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+let loaded = false;
+let compilerPromise = null;
+let runtimePromise = null;
+let runtimeModuleUrl = '';
+let compiledWasm = null;
+let compiledCacheKey = '';
+let compiledReturnTypes = {};
+async function loadRuntime(url) {
+    if (!url)
+        throw new Error('AssemblyScript runtime module URL is not configured.');
+    if (!runtimePromise || runtimeModuleUrl !== url) {
+        runtimeModuleUrl = url;
+        runtimePromise = importRuntimeModule(url);
+        compilerPromise = null;
+    }
+    return await runtimePromise;
+}
+class AssemblyScriptStdin {
+    buffer;
+    log;
+    initialStdin;
+    fixedInitialStdin;
+    currentBytes = new Uint8Array(0);
+    currentOffset = 0;
+    constructor(initialStdin, buffer, log) {
+        this.buffer = buffer;
+        this.log = log;
+        this.initialStdin = typeof initialStdin === 'string' ? initialStdin : null;
+        this.fixedInitialStdin = typeof initialStdin === 'string';
+    }
+    readByte() {
+        while (this.currentOffset >= this.currentBytes.length) {
+            const chunk = this.readChunk();
+            if (chunk == null)
+                return -1;
+            if (!chunk)
+                continue;
+            this.currentBytes = encoder.encode(chunk);
+            this.currentOffset = 0;
+        }
+        return this.currentBytes[this.currentOffset++] ?? -1;
+    }
+    readLine() {
+        const bytes = [];
+        while (true) {
+            const byte = this.readByte();
+            if (byte < 0) {
+                return bytes.length ? decoder.decode(new Uint8Array(bytes)) : null;
+            }
+            if (byte === 10) {
+                if (bytes[bytes.length - 1] === 13)
+                    bytes.pop();
+                return decoder.decode(new Uint8Array(bytes));
+            }
+            bytes.push(byte);
+        }
+    }
+    readAll() {
+        const bytes = [];
+        while (true) {
+            const byte = this.readByte();
+            if (byte < 0)
+                return decoder.decode(new Uint8Array(bytes));
+            bytes.push(byte);
+        }
+    }
+    readChunk() {
+        if (this.initialStdin != null) {
+            const chunk = this.initialStdin;
+            this.initialStdin = null;
+            return chunk;
+        }
+        if (this.fixedInitialStdin || !this.buffer)
+            return null;
+        const chunk = waitForBufferedStdin(this.buffer, () => postMessage({ buffer: true }));
+        if (this.log) {
+            console.log(chunk == null
+                ? '[wasm-idle:assemblyscript-stdin] read(bytes=0, eof=true)'
+                : `[wasm-idle:assemblyscript-stdin] read(bytes=${encoder.encode(chunk).byteLength}, text=${JSON.stringify(chunk)})`);
+        }
+        return chunk;
+    }
+}
+self.onmessage = async (event) => {
+    const { load, moduleUrl: nextModuleUrl, code, prepare, buffer, stdin, activePath = 'main.as.ts', workspaceFiles = [], log } = event.data;
+    try {
+        if (load) {
+            loaded = true;
+            postMessage({ progress: { percent: 5, stage: 'Loading AssemblyScript runtime' } });
+            await loadRuntime(nextModuleUrl || runtimeModuleUrl);
+            if (log) {
+                console.log(`[wasm-idle:assemblyscript-worker] load runtime=${nextModuleUrl || runtimeModuleUrl}`);
+            }
+            postMessage({ progress: { percent: 100, stage: 'AssemblyScript runtime ready' } });
+            postMessage({ load: true });
+            return;
+        }
+        if (!loaded)
+            loaded = true;
+        const source = code || '';
+        const compileCacheKey = JSON.stringify({
+            activePath,
+            source,
+            workspaceFiles
+        });
+        if (!compiledWasm || compiledCacheKey !== compileCacheKey) {
+            if (log) {
+                console.log(`[wasm-idle:assemblyscript-worker] compile start prepare=${String(prepare)} activePath=${activePath} bytes=${source.length}`);
+            }
+            if (!compilerPromise) {
+                compilerPromise = (await loadRuntime(runtimeModuleUrl)).loadCompiler();
+            }
+            const files = {};
+            for (const file of workspaceFiles) {
+                files[file.path] = file.content;
+            }
+            files[activePath] = source;
+            const compiler = await compilerPromise;
+            if (!compiler.main) {
+                throw new Error('AssemblyScript compiler main export was not found.');
+            }
+            const outputFiles = {};
+            let stdoutText = '';
+            let stderrText = '';
+            const stdout = {
+                write(chunk) {
+                    stdoutText += typeof chunk === 'string' ? chunk : decoder.decode(chunk);
+                },
+                toString() {
+                    return stdoutText;
+                }
+            };
+            const stderr = {
+                write(chunk) {
+                    stderrText += typeof chunk === 'string' ? chunk : decoder.decode(chunk);
+                },
+                toString() {
+                    return stderrText;
+                }
+            };
+            const compileResult = await compiler.main([
+                activePath,
+                '--outFile',
+                'module.wasm',
+                '--runtime',
+                'incremental',
+                '--bindings',
+                'raw',
+                '--optimize',
+                '--exportRuntime'
+            ], {
+                stdout,
+                stderr,
+                readFile(filePath) {
+                    return files[filePath] ?? null;
+                },
+                writeFile(filePath, contents) {
+                    outputFiles[filePath] = contents;
+                },
+                listFiles(dirPath) {
+                    const prefix = dirPath.endsWith('/') ? dirPath : `${dirPath}/`;
+                    return Object.keys(files).filter((filePath) => filePath.startsWith(prefix));
+                }
+            });
+            const outputWasm = outputFiles['module.wasm'];
+            const result = {
+                error: compileResult.error,
+                stdout: String(compileResult.stdout ?? stdout),
+                stderr: String(compileResult.stderr ?? stderr),
+                wasm: typeof outputWasm === 'string' ? encoder.encode(outputWasm) : outputWasm,
+                files: outputFiles
+            };
+            if (log) {
+                console.log(`[wasm-idle:assemblyscript-worker] compile settled success=${String(!result.error && Boolean(result.wasm))} stdout=${String(Boolean(result.stdout))} stderr=${String(Boolean(result.stderr))}`);
+            }
+            if (result.stdout)
+                postMessage({ output: result.stdout });
+            if (result.stderr)
+                postMessage({ output: result.stderr });
+            if (result.error || !result.wasm) {
+                const message = result.stderr || result.error?.message || 'AssemblyScript compilation failed';
+                const locationMatch = message.match(/in ([^(]+)\((\d+),(\d+)\)/);
+                postMessage({
+                    diagnostic: {
+                        fileName: locationMatch?.[1] || activePath,
+                        lineNumber: Math.max(1, Number(locationMatch?.[2] || 1)),
+                        columnNumber: Math.max(1, Number(locationMatch?.[3] || 1)),
+                        severity: 'error',
+                        message
+                    }
+                });
+                throw new Error(message);
+            }
+            compiledWasm =
+                result.wasm instanceof Uint8Array ? result.wasm : new Uint8Array(result.wasm);
+            compiledCacheKey = compileCacheKey;
+            compiledReturnTypes = {};
+            const declarationFile = result.files['module.d.ts'];
+            if (typeof declarationFile === 'string') {
+                const exportPattern = /export function ([A-Za-z_$][\w$]*)\(([^)]*)\): ([^;]+);/g;
+                let match;
+                while ((match = exportPattern.exec(declarationFile))) {
+                    if (!match[2].trim())
+                        compiledReturnTypes[match[1]] = match[3].trim();
+                }
+            }
+        }
+        if (prepare) {
+            postMessage({ results: true });
+            return;
+        }
+        let activeExports = null;
+        const stdinReader = new AssemblyScriptStdin(stdin, buffer ? new Int32Array(buffer) : null, Boolean(log));
+        const createAssemblyScriptString = (value) => {
+            if (value == null)
+                return 0;
+            if (!activeExports?.__newString) {
+                throw new Error('AssemblyScript runtime string allocator is unavailable');
+            }
+            return activeExports.__newString(value);
+        };
+        const imports = {
+            env: {
+                seed() {
+                    return Math.floor(Math.random() * 0x7fffffff);
+                },
+                readByte() {
+                    return stdinReader.readByte();
+                },
+                readLine() {
+                    return createAssemblyScriptString(stdinReader.readLine());
+                },
+                readAll() {
+                    return createAssemblyScriptString(stdinReader.readAll());
+                },
+                abort(message, fileName, lineNumber, columnNumber) {
+                    const text = activeExports?.__getString
+                        ? activeExports.__getString(message >>> 0)
+                        : 'abort';
+                    const file = activeExports?.__getString
+                        ? activeExports.__getString(fileName >>> 0)
+                        : activePath;
+                    throw new Error(`${text || 'abort'} in ${file || activePath}:${lineNumber}:${columnNumber}`);
+                },
+                trace(message, numArgs = 0, ...args) {
+                    const text = activeExports?.__getString
+                        ? activeExports.__getString(message >>> 0)
+                        : 'trace';
+                    const suffix = args.slice(0, numArgs).map(String).join(', ');
+                    postMessage({ output: suffix ? `${text}: ${suffix}\n` : `${text}\n` });
+                }
+            }
+        };
+        const runtime = await loadRuntime(runtimeModuleUrl);
+        const instance = await runtime.instantiate(compiledWasm, imports);
+        activeExports = instance.exports;
+        const getString = activeExports.__getString;
+        const preferredExportName = typeof activeExports._start === 'function'
+            ? '_start'
+            : typeof activeExports.main === 'function'
+                ? 'main'
+                : '';
+        let printed = false;
+        postMessage({
+            progress: {
+                kind: 'ready',
+                state: 'running',
+                reason: 'started',
+                label: 'AssemblyScript program started'
+            }
+        });
+        if (preferredExportName) {
+            const value = activeExports[preferredExportName]();
+            const returnType = compiledReturnTypes[preferredExportName] || '';
+            if (returnType === 'string' && typeof value === 'number' && getString) {
+                postMessage({
+                    output: `${preferredExportName}=${getString(value >>> 0)}\n`
+                });
+                printed = true;
+            }
+            else if (returnType === 'boolean' && typeof value === 'number') {
+                postMessage({ output: `${preferredExportName}=${value !== 0}\n` });
+                printed = true;
+            }
+            else if (typeof value === 'number' || typeof value === 'bigint') {
+                postMessage({ output: `${preferredExportName}=${String(value)}\n` });
+                printed = true;
+            }
+        }
+        else {
+            for (const [name, value] of Object.entries(activeExports)) {
+                if (name.startsWith('_') ||
+                    name === 'memory' ||
+                    name === 'table' ||
+                    typeof value !== 'function') {
+                    continue;
+                }
+                try {
+                    const result = value();
+                    const returnType = compiledReturnTypes[name] || '';
+                    if (returnType === 'string' && typeof result === 'number' && getString) {
+                        postMessage({
+                            output: `${name}=${getString(result >>> 0)}\n`
+                        });
+                        printed = true;
+                    }
+                    else if (returnType === 'boolean' && typeof result === 'number') {
+                        postMessage({ output: `${name}=${result !== 0}\n` });
+                        printed = true;
+                    }
+                    else if (typeof result === 'number' || typeof result === 'bigint') {
+                        postMessage({ output: `${name}=${String(result)}\n` });
+                        printed = true;
+                    }
+                }
+                catch {
+                    // Exports that need parameters are valid but are not auto-run.
+                }
+            }
+        }
+        if (!printed && !preferredExportName) {
+            const exportNames = Object.keys(activeExports).sort().join(', ');
+            postMessage({
+                output: exportNames ? `exports: ${exportNames}\n` : 'compiled WebAssembly module\n'
+            });
+        }
+        postMessage({ results: true });
+    }
+    catch (error) {
+        if (log) {
+            console.error('[wasm-idle:assemblyscript-worker] failed', error);
+        }
+        postMessage({ error: error?.message || String(error) });
+    }
+};

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

@@ -1,12 +1,19 @@
 export interface WorkerRuntimeAssetConfig {
     baseUrl: string;
+    maxAssetBytes?: number;
     useAssetBridge: boolean;
 }
+export interface WorkerRuntimeAssetAllowlist {
+    baseUrl: string;
+    assets: readonly string[];
+    runtimeAssets?: readonly string[];
+}
 interface LoadedWorkerAsset {
     bytes: Uint8Array;
     mimeType?: string;
 }
 export declare function configureWorkerRuntimeAssets(config: WorkerRuntimeAssetConfig | null): void;
+export declare function configureWorkerRuntimeAssetAllowlist(allowlist: WorkerRuntimeAssetAllowlist | null): void;
 export declare function handleWorkerAssetMessage(data: any): boolean;
 export declare function loadWorkerRuntimeAsset(asset: string): Promise<LoadedWorkerAsset>;
 export {};