wasm-idle 0.7.2 → 1.0.0

package/dist/playground/worker/sqlite.js

@@ -0,0 +1,112 @@
+import { importRuntimeModule } from '../runtimeModule';
+let wasmUrl = '';
+let loadedWasmUrl = '';
+let runtimeModuleUrl = '';
+let sqlPromise = null;
+function locateSqliteWasm(url) {
+    const maybeProcess = typeof process === 'undefined' ? null : process;
+    if (url.startsWith('/') && maybeProcess?.cwd) {
+        return `${maybeProcess.cwd()}${url}`;
+    }
+    return url;
+}
+async function loadSqlite(moduleUrl, url) {
+    if (!moduleUrl)
+        throw new Error('SQLite runtime module URL is not configured.');
+    const runtime = await importRuntimeModule(moduleUrl);
+    const nextUrl = url || runtime.sqliteWasmUrl;
+    if (runtimeModuleUrl === moduleUrl && loadedWasmUrl === nextUrl && sqlPromise) {
+        return await sqlPromise;
+    }
+    runtimeModuleUrl = moduleUrl;
+    loadedWasmUrl = nextUrl;
+    sqlPromise = runtime.default({
+        locateFile(file) {
+            return file.endsWith('.wasm') ? locateSqliteWasm(nextUrl) : file;
+        }
+    });
+    return await sqlPromise;
+}
+function stringifyCell(value) {
+    if (value == null)
+        return 'NULL';
+    if (value instanceof Uint8Array) {
+        return `x'${Array.from(value, (byte) => byte.toString(16).padStart(2, '0')).join('')}'`;
+    }
+    return String(value);
+}
+function formatResult(result) {
+    const lines = [result.columns.join('\t')];
+    for (const row of result.values) {
+        lines.push(row.map(stringifyCell).join('\t'));
+    }
+    return `${lines.join('\n')}\n`;
+}
+function normalizeWorkspacePath(path) {
+    return path
+        .replace(/^\/+/, '')
+        .split('/')
+        .filter((part) => part && part !== '.' && part !== '..' && !part.includes('\0'))
+        .join('/');
+}
+function loadWorkspaceFiles(db, workspaceFiles) {
+    for (const file of workspaceFiles) {
+        const normalizedPath = normalizeWorkspacePath(file.path);
+        if (!normalizedPath || !normalizedPath.endsWith('.sql'))
+            continue;
+        if (normalizedPath === 'main.sql')
+            continue;
+        db.exec(file.content);
+    }
+}
+self.onmessage = async (event) => {
+    const { load, moduleUrl: nextModuleUrl, wasmUrl: nextWasmUrl, code, prepare, activePath = 'main.sql', workspaceFiles = [], log } = event.data;
+    try {
+        if (load) {
+            const moduleUrl = nextModuleUrl || runtimeModuleUrl;
+            wasmUrl = nextWasmUrl || '';
+            if (log) {
+                console.log(`[wasm-idle:sqlite-worker] load moduleUrl=${moduleUrl} wasmUrl=${wasmUrl || 'default'}`);
+            }
+            await loadSqlite(moduleUrl, wasmUrl);
+            postMessage({ load: true });
+            return;
+        }
+        const SQL = await loadSqlite(runtimeModuleUrl, wasmUrl);
+        if (prepare) {
+            postMessage({ results: true });
+            return;
+        }
+        const db = new SQL.Database();
+        try {
+            loadWorkspaceFiles(db, workspaceFiles);
+            postMessage({
+                progress: {
+                    kind: 'ready',
+                    state: 'running',
+                    reason: 'started',
+                    label: 'SQLite query started'
+                }
+            });
+            if (log) {
+                console.log(`[wasm-idle:sqlite-worker] exec start bytes=${code.length} activePath=${activePath}`);
+            }
+            for (const result of db.exec(code)) {
+                postMessage({ output: formatResult(result) });
+            }
+            if (log) {
+                console.log('[wasm-idle:sqlite-worker] exec settled');
+            }
+        }
+        finally {
+            db.close();
+        }
+        postMessage({ results: true });
+    }
+    catch (error) {
+        if (log) {
+            console.error('[wasm-idle:sqlite-worker] failed', error);
+        }
+        postMessage({ error: error?.message || String(error) });
+    }
+};

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

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

package/dist/playground/worker/staticRuntimePreflight.js

@@ -0,0 +1,56 @@
+import { executeStaticRuntimePreflight } from '../staticRuntimePreflightExecute';
+import { STATIC_RUNTIME_PREFLIGHT_PROTOCOL_VERSION, collectStaticRuntimePreflightTransferables, serializeStaticRuntimePreflightError } from '../staticRuntimePreflightProtocol';
+const workerSelf = globalThis;
+let handled = false;
+function isRequest(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const request = value;
+    return (request.protocolVersion === STATIC_RUNTIME_PREFLIGHT_PROTOCOL_VERSION &&
+        request.type === 'preflight' &&
+        Number.isSafeInteger(request.requestId) &&
+        request.requestId > 0 &&
+        (request.runtimeId === 'BQN' ||
+            request.runtimeId === 'CLOJURESCRIPT' ||
+            request.runtimeId === 'FORTH' ||
+            request.runtimeId === 'J' ||
+            request.runtimeId === 'JANET' ||
+            request.runtimeId === 'PROLOG') &&
+        typeof request.baseUrl === 'string' &&
+        typeof request.manifestUrl === 'string' &&
+        request.profile !== null &&
+        typeof request.profile === 'object' &&
+        request.limits !== null &&
+        typeof request.limits === 'object');
+}
+workerSelf.onmessage = async (event) => {
+    const request = event.data;
+    if (handled || !isRequest(request))
+        return;
+    handled = true;
+    try {
+        const payload = await executeStaticRuntimePreflight(request, (progress) => {
+            workerSelf.postMessage({
+                protocolVersion: STATIC_RUNTIME_PREFLIGHT_PROTOCOL_VERSION,
+                type: 'progress',
+                requestId: request.requestId,
+                progress
+            });
+        });
+        const transferables = collectStaticRuntimePreflightTransferables(payload);
+        workerSelf.postMessage({
+            protocolVersion: STATIC_RUNTIME_PREFLIGHT_PROTOCOL_VERSION,
+            type: 'result',
+            requestId: request.requestId,
+            payload
+        }, transferables);
+    }
+    catch (error) {
+        workerSelf.postMessage({
+            protocolVersion: STATIC_RUNTIME_PREFLIGHT_PROTOCOL_VERSION,
+            type: 'error',
+            requestId: request.requestId,
+            error: serializeStaticRuntimePreflightError(error)
+        });
+    }
+};

package/dist/playground/worker/tinygo.js

@@ -7,6 +7,14 @@ self.document = {
 };
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
+const postExecutionReady = () => postMessage({
+    progress: {
+        kind: 'ready',
+        state: 'running',
+        reason: 'started',
+        label: 'TinyGo program started'
+    }
+});
 let stdinBufferTinyGo = null;
 let stdinChunkTinyGo = new Uint8Array(0);
 let stdinChunkOffsetTinyGo = 0;
@@ -24,13 +32,13 @@ class TinyGoStdin extends Fd {
         };
     }
     fd_read(size) {
-        if (stdinBufferTinyGo === null) {
-            return {
-                ret: wasi.ERRNO_SUCCESS,
-                data: new Uint8Array(0)
-            };
-        }
         if (stdinChunkOffsetTinyGo >= stdinChunkTinyGo.length) {
+            if (stdinBufferTinyGo === null) {
+                return {
+                    ret: wasi.ERRNO_SUCCESS,
+                    data: new Uint8Array(0)
+                };
+            }
             const nextChunk = waitForBufferedStdin(stdinBufferTinyGo, () => postMessage({ buffer: true }));
             if (nextChunk === null) {
                 stdinChunkTinyGo = new Uint8Array(0);
@@ -53,7 +61,7 @@ class TinyGoStdin extends Fd {
     }
 }
 self.onmessage = async (event) => {
-    const { load, artifact, buffer, args = [], log } = event.data;
+    const { load, artifact, buffer, stdin, args = [], log } = event.data;
     try {
         if (load) {
             postMessage({ load: true });
@@ -69,8 +77,11 @@ self.onmessage = async (event) => {
         if (!bytes) {
             throw new Error('TinyGo worker expected a wasm artifact');
         }
-        stdinBufferTinyGo = new Int32Array(buffer);
-        stdinChunkTinyGo = new Uint8Array(0);
+        if (stdin !== undefined && typeof stdin !== 'string') {
+            throw new Error('TinyGo worker expected stdin to be a string');
+        }
+        stdinBufferTinyGo = stdin === undefined ? new Int32Array(buffer) : null;
+        stdinChunkTinyGo = stdin === undefined ? new Uint8Array(0) : encoder.encode(stdin);
         stdinChunkOffsetTinyGo = 0;
         const stdout = new ConsoleStdout((chunk) => {
             const text = decoder.decode(chunk);
@@ -96,6 +107,7 @@ self.onmessage = async (event) => {
         let exitCode = 0;
         try {
             if (typeof exportsObject._start === 'function') {
+                postExecutionReady();
                 exitCode = wasiRuntime.start(instance);
             }
             else if (typeof exportsObject.memory === 'object' &&
@@ -107,6 +119,7 @@ self.onmessage = async (event) => {
                     exportsObject.__wasm_call_ctors();
                 }
                 if (typeof exportsObject.main === 'function') {
+                    postExecutionReady();
                     const mainResult = exportsObject.main();
                     exitCode = typeof mainResult === 'number' ? mainResult : 0;
                 }
@@ -137,4 +150,16 @@ self.onmessage = async (event) => {
         }
         postMessage({ error: error?.message || String(error) });
     }
+    finally {
+        const stdinChunk = stdinChunkTinyGo;
+        stdinBufferTinyGo = null;
+        stdinChunkTinyGo = new Uint8Array(0);
+        stdinChunkOffsetTinyGo = 0;
+        try {
+            stdinChunk.fill(0);
+        }
+        catch {
+            // Stdin cleanup must not replace the execution result.
+        }
+    }
 };

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

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

package/dist/playground/worker/typescript.js

@@ -0,0 +1,251 @@
+import { waitForBufferedStdin } from '../stdinBuffer';
+import { fetchRuntimeAssetBytes } from './runtimeAssetFetch';
+import { verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
+let stdinBufferTypeScript = null;
+let moduleUrl = '';
+let moduleReceipt = null;
+let maxAssetBytes = 0;
+let loadedModuleIdentity = '';
+let runtimePromise = null;
+let compiledArtifact = null;
+let compiledCacheKey = '';
+function snapshotModuleReceipt(value) {
+    if (!value || typeof value !== 'object') {
+        throw new Error('TypeScript runtime integrity receipt is required');
+    }
+    const bytes = value.bytes;
+    const sha256 = value.sha256;
+    if (!Number.isSafeInteger(bytes) || bytes <= 0) {
+        throw new Error('TypeScript runtime integrity receipt has an invalid byte size');
+    }
+    if (typeof sha256 !== 'string' || !/^[a-f0-9]{64}$/u.test(sha256)) {
+        throw new Error('TypeScript runtime integrity receipt has an invalid SHA-256 digest');
+    }
+    return Object.freeze({ bytes: bytes, sha256 });
+}
+function requireMaxAssetBytes(value) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new Error('TypeScript runtime maxAssetBytes must be a positive safe integer');
+    }
+    return value;
+}
+function requireModuleUrl(value) {
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new Error('TypeScript runtime is not configured. Set PUBLIC_WASM_TYPESCRIPT_MODULE_URL or runtimeAssets.typescript.moduleUrl.');
+    }
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new Error(`TypeScript runtime module URL is invalid: ${value}`);
+    }
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+        throw new Error(`TypeScript runtime module URL must use HTTP(S): ${value}`);
+    }
+    if (url.username || url.password || url.hash) {
+        throw new Error(`TypeScript runtime module URL must not include credentials or a fragment: ${value}`);
+    }
+    if (/%2f|%5c/iu.test(url.pathname)) {
+        throw new Error(`TypeScript runtime module URL must not include encoded path separators: ${value}`);
+    }
+    return url.href;
+}
+async function loadRuntime(urlValue, receiptValue, maxAssetBytesValue) {
+    const url = requireModuleUrl(urlValue);
+    const receipt = snapshotModuleReceipt(receiptValue);
+    const byteLimit = requireMaxAssetBytes(maxAssetBytesValue);
+    if (receipt.bytes > byteLimit) {
+        throw new Error(`TypeScript runtime module exceeds the ${byteLimit} byte limit`);
+    }
+    const identity = JSON.stringify([url, receipt.bytes, receipt.sha256]);
+    if (loadedModuleIdentity === identity && runtimePromise) {
+        return await runtimePromise;
+    }
+    loadedModuleIdentity = identity;
+    compiledArtifact = null;
+    compiledCacheKey = '';
+    runtimePromise = (async () => {
+        const bytes = await fetchRuntimeAssetBytes({
+            url,
+            label: 'TypeScript runtime module',
+            maxAssetBytes: receipt.bytes
+        });
+        await verifyRuntimeAssetIntegrity({
+            asset: url,
+            bytes,
+            expected: receipt,
+            runtimeId: 'TYPESCRIPT'
+        });
+        if (typeof URL.createObjectURL !== 'function' ||
+            typeof URL.revokeObjectURL !== 'function') {
+            throw new Error('TypeScript runtime requires Blob URL support');
+        }
+        const revokeObjectURL = URL.revokeObjectURL.bind(URL);
+        const verifiedModuleUrl = URL.createObjectURL(new Blob([bytes], { type: 'text/javascript' }));
+        let module;
+        try {
+            module = await import(/* @vite-ignore */ verifiedModuleUrl);
+        }
+        finally {
+            try {
+                revokeObjectURL(verifiedModuleUrl);
+            }
+            catch {
+                // Blob URL cleanup must not replace the verified module's import outcome.
+            }
+        }
+        const factory = typeof module.createTypeScriptCompiler === 'function'
+            ? module.createTypeScriptCompiler
+            : typeof module.default === 'function'
+                ? module.default
+                : null;
+        if (!factory) {
+            throw new Error('wasm-typescript module must export createTypeScriptCompiler or a default factory');
+        }
+        if (typeof module.executeBrowserTypeScriptArtifact !== 'function') {
+            throw new Error('wasm-typescript module must export executeBrowserTypeScriptArtifact');
+        }
+        return {
+            compiler: await factory(),
+            executeBrowserTypeScriptArtifact: module.executeBrowserTypeScriptArtifact
+        };
+    })();
+    return await runtimePromise;
+}
+function normalizeDiagnostic(diagnostic) {
+    return {
+        fileName: diagnostic?.fileName ?? null,
+        lineNumber: Math.max(1, Number(diagnostic?.lineNumber || 1)),
+        columnNumber: typeof diagnostic?.columnNumber === 'number'
+            ? Math.max(1, diagnostic.columnNumber)
+            : undefined,
+        endColumnNumber: typeof diagnostic?.endColumnNumber === 'number'
+            ? Math.max(1, diagnostic.endColumnNumber)
+            : undefined,
+        severity: diagnostic?.severity === 'warning' || diagnostic?.severity === 'other'
+            ? diagnostic.severity
+            : 'error',
+        message: String(diagnostic?.message || '')
+    };
+}
+self.onmessage = async (event) => {
+    const { load, moduleUrl: nextModuleUrl, moduleReceipt: nextModuleReceipt, maxAssetBytes: nextMaxAssetBytes, buffer, code, prepare, args = [], stdin, language = 'typescript', activePath = language === 'typescript' ? 'main.ts' : 'main.js', workspaceFiles = [], log } = event.data;
+    try {
+        if (load) {
+            const configuredModuleUrl = requireModuleUrl(nextModuleUrl);
+            const configuredModuleReceipt = snapshotModuleReceipt(nextModuleReceipt);
+            const configuredMaxAssetBytes = requireMaxAssetBytes(nextMaxAssetBytes);
+            if (log) {
+                console.log(`[wasm-idle:typescript-worker] load moduleUrl=${configuredModuleUrl}`);
+            }
+            await loadRuntime(configuredModuleUrl, configuredModuleReceipt, configuredMaxAssetBytes);
+            moduleUrl = configuredModuleUrl;
+            moduleReceipt = configuredModuleReceipt;
+            maxAssetBytes = configuredMaxAssetBytes;
+            postMessage({ load: true });
+            return;
+        }
+        stdinBufferTypeScript = new Int32Array(buffer);
+        const runtime = await loadRuntime(moduleUrl, moduleReceipt, maxAssetBytes);
+        const compileCacheKey = `${language}\n${activePath}\n${code}`;
+        if (!compiledArtifact || compiledCacheKey !== compileCacheKey) {
+            if (log) {
+                console.log(`[wasm-idle:typescript-worker] compile start language=${language} prepare=${String(prepare)} bytes=${code.length}`);
+            }
+            const result = await runtime.compiler.compile({
+                code,
+                language,
+                fileName: activePath,
+                log
+            });
+            if (log) {
+                console.log(`[wasm-idle:typescript-worker] compile settled success=${String(result.success)} stdout=${String(Boolean(result.stdout))} stderr=${String(Boolean(result.stderr))}`);
+            }
+            for (const diagnostic of result.diagnostics || []) {
+                postMessage({ diagnostic: normalizeDiagnostic(diagnostic) });
+            }
+            if (result.stdout)
+                postMessage({ output: result.stdout });
+            if (!result.success) {
+                throw new Error(result.stderr ||
+                    result.diagnostics
+                        ?.map((diagnostic) => diagnostic.message)
+                        .join('\n') ||
+                    'TypeScript compilation failed');
+            }
+            if (result.stderr)
+                postMessage({ output: result.stderr });
+            if (!result.artifact?.javascript) {
+                throw new Error('wasm-typescript did not return a JavaScript artifact');
+            }
+            compiledArtifact = result.artifact;
+            compiledCacheKey = compileCacheKey;
+        }
+        if (prepare) {
+            postMessage({ results: true });
+            return;
+        }
+        const hasInitialStdin = typeof stdin === 'string';
+        let initialStdin = hasInitialStdin ? stdin : null;
+        const execution = await runtime.executeBrowserTypeScriptArtifact(compiledArtifact, {
+            args,
+            env: {
+                USER: 'jungol'
+            },
+            onReady: () => postMessage({
+                progress: {
+                    kind: 'ready',
+                    state: 'running',
+                    reason: 'started',
+                    label: `${language === 'typescript' ? 'TypeScript' : 'JavaScript'} program started`
+                }
+            }),
+            files: workspaceFiles,
+            activePath,
+            stdin: () => {
+                if (hasInitialStdin) {
+                    const chunk = initialStdin;
+                    initialStdin = null;
+                    if (log) {
+                        console.log(chunk == null
+                            ? '[wasm-idle:typescript-stdin] read(bytes=0, eof=true)'
+                            : `[wasm-idle:typescript-stdin] read(bytes=${new TextEncoder().encode(chunk).byteLength}, text=${JSON.stringify(chunk)})`);
+                    }
+                    return chunk;
+                }
+                const chunk = waitForBufferedStdin(stdinBufferTypeScript, () => postMessage({ buffer: true }));
+                if (chunk == null) {
+                    if (log) {
+                        console.log('[wasm-idle:typescript-stdin] read(bytes=0, eof=true)');
+                    }
+                    return null;
+                }
+                if (log) {
+                    console.log(`[wasm-idle:typescript-stdin] read(bytes=${new TextEncoder().encode(chunk).byteLength}, text=${JSON.stringify(chunk)})`);
+                }
+                return chunk;
+            },
+            stdout: (output) => {
+                if (output)
+                    postMessage({ output });
+            },
+            stderr: (output) => {
+                if (output)
+                    postMessage({ output });
+            }
+        });
+        if (execution.exitCode !== 0) {
+            throw new Error(execution.stderr
+                ? `${language === 'typescript' ? 'TypeScript' : 'JavaScript'} program exited with code ${execution.exitCode}\n${execution.stderr}`
+                : `${language === 'typescript' ? 'TypeScript' : 'JavaScript'} program exited with code ${execution.exitCode}`);
+        }
+        postMessage({ results: true });
+    }
+    catch (error) {
+        if (log) {
+            console.error('[wasm-idle:typescript-worker] failed', error);
+        }
+        postMessage({ error: error?.message || String(error) });
+    }
+};

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

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