wasm-idle 0.7.2 → 1.0.0

package/dist/playground/javaSource.d.ts

@@ -0,0 +1,5 @@
+export interface JavaSourceIdentity {
+    mainClass: string;
+    sourcePath: string;
+}
+export declare function resolveJavaSourceIdentity(code: string): JavaSourceIdentity;

package/dist/playground/javaSource.js

@@ -0,0 +1,16 @@
+export function resolveJavaSourceIdentity(code) {
+    const packageMatch = code.match(/^\s*package\s+([A-Za-z_][\w.]*)\s*;/m);
+    const typeMatch = code.match(/^\s*public\s+(?:final\s+|abstract\s+)?(?:class|record|enum|interface)\s+([A-Za-z_]\w*)\b/m) ||
+        code.match(/^\s*(?:final\s+|abstract\s+)?(?:class|record|enum|interface)\s+([A-Za-z_]\w*)\b/m);
+    const className = typeMatch?.[1];
+    if (!className) {
+        throw new Error('Java source must define a top-level class, record, enum, or interface');
+    }
+    const packageName = packageMatch?.[1] || '';
+    return {
+        sourcePath: packageName
+            ? `${packageName.replaceAll('.', '/')}/${className}.java`
+            : `${className}.java`,
+        mainClass: packageName ? `${packageName}.${className}` : className
+    };
+}

package/dist/playground/javaStdin.d.ts

@@ -5,4 +5,4 @@ export interface PreparedJavaStdinInjection {
     helperSourcePath: string | null;
     helperSource: string | null;
 }
-export declare const prepareJavaStdinInjection: (code: string, stdin: string) => PreparedJavaStdinInjection;
+export declare const prepareJavaStdinInjection: (code: string, stdin: string, hasExplicitStdin: boolean) => PreparedJavaStdinInjection;

package/dist/playground/javaStdin.js

@@ -210,7 +210,7 @@ final class Scanner implements AutoCloseable {
         }
     }
 }`;
-export const prepareJavaStdinInjection = (code, stdin) => {
+export const prepareJavaStdinInjection = (code, stdin, hasExplicitStdin) => {
     const usesStdin = code.includes('System.in');
     const usesScanner = /\bScanner\b/.test(code) &&
         !code.includes(JAVA_SCANNER_COMPAT_SENTINEL) &&
@@ -249,10 +249,12 @@ export const prepareJavaStdinInjection = (code, stdin) => {
             .replaceAll(/\bjava\.util\.Scanner\b/g, 'Scanner');
         transformedCode = `${transformedCode.trimEnd()}\n\n${JAVA_SCANNER_COMPAT_SHIM}\n`;
     }
-    const encodedBytes = [...new TextEncoder().encode(stdin)].join(', ');
+    const encodedBytes = [...new TextEncoder().encode(stdin)]
+        .map((byte) => (byte > 0x7f ? byte - 0x100 : byte))
+        .join(', ');
     return {
         usesStdin: true,
-        stdinCacheKey: stdin,
+        stdinCacheKey: JSON.stringify([hasExplicitStdin, stdin]),
         transformedCode,
         helperSourcePath,
         helperSource: `${packageName ? `package ${packageName};\n\n` : ''}import java.io.InputStream;
@@ -263,6 +265,7 @@ import org.teavm.jso.core.JSMapLike;
 
 final class ${JAVA_STDIN_HELPER_CLASS} extends InputStream {
     private static final byte[] INITIAL_DATA = new byte[] { ${encodedBytes} };
+    private static final boolean HAS_EXPLICIT_INPUT = ${hasExplicitStdin ? 'true' : 'false'};
     private static final ${JAVA_STDIN_HELPER_CLASS} INSTANCE = new ${JAVA_STDIN_HELPER_CLASS}();
     private int position = 0;
 
@@ -305,6 +308,9 @@ final class ${JAVA_STDIN_HELPER_CLASS} extends InputStream {
             position += count;
             return count;
         }
+        if (HAS_EXPLICIT_INPUT) {
+            return -1;
+        }
         int next = readFromHost();
         if (next == -1) {
             return -1;
@@ -315,7 +321,10 @@ final class ${JAVA_STDIN_HELPER_CLASS} extends InputStream {
 
     @Override
     public int read() {
-        return position < INITIAL_DATA.length ? INITIAL_DATA[position++] & 0xff : readFromHost();
+        if (position < INITIAL_DATA.length) {
+            return INITIAL_DATA[position++] & 0xff;
+        }
+        return HAS_EXPLICIT_INPUT ? -1 : readFromHost();
     }
 }
 `

package/dist/playground/julia.d.ts

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

package/dist/playground/julia.js

@@ -0,0 +1,64 @@
+import { resolveJuliaRuntimeAssetConfig } from './assets';
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+import { RuntimeConfigurationError, preflightJuliaRuntimeAssets, snapshotJuliaRuntimePreflightProfile } from '@wasm-idle/core';
+class Julia extends StaticWorkerRuntimeSandbox {
+    constructor() {
+        super({
+            displayName: 'Julia',
+            languageId: 'JULIA',
+            defaultActivePath: 'main.jl',
+            workerLifetime: { mode: 'per-run' },
+            runtimePreflightDelivery: 'transfer-owned',
+            stdin: {
+                mode: 'streaming',
+                sourceHintPattern: /\b(?:readline|readlines|read|eachline|stdin)\b/i
+            },
+            inlineVerifiedWorker: true,
+            resolveRuntimeAssets(runtimeAssets, currentUrl) {
+                const resolved = resolveJuliaRuntimeAssetConfig(runtimeAssets, currentUrl);
+                const profile = snapshotJuliaRuntimePreflightProfile(resolved.preflightProfile);
+                if (!/^[a-f0-9]{64}$/u.test(resolved.manifestFingerprint || '') ||
+                    profile.manifestFingerprint !== resolved.manifestFingerprint ||
+                    !resolved.workerReceipt) {
+                    throw new RuntimeConfigurationError('Julia runtime requires one coherent preflight profile, manifest fingerprint, and worker receipt.', { runtimeId: 'JULIA' });
+                }
+                return { ...resolved, preflightProfile: profile };
+            },
+            async preflightRuntimeAssets(urls, context) {
+                const profile = urls.preflightProfile;
+                const loadedByAsset = new Map();
+                const decompressedByAsset = new Map();
+                const totalDownloadBytes = (profile.manifestReceipt.bytes ?? 0) +
+                    (profile.javascriptReceipt.bytes ?? 0) +
+                    (profile.wasmReceipt.bytes ?? 0) +
+                    (profile.dataReceipt.bytes ?? 0);
+                const totalDecompressedBytes = (profile.javascriptReceipt.uncompressedBytes ?? 0) +
+                    (profile.wasmReceipt.uncompressedBytes ?? 0) +
+                    (profile.dataReceipt.uncompressedBytes ?? 0);
+                const payload = await preflightJuliaRuntimeAssets({
+                    baseUrl: urls.baseUrl,
+                    manifestUrl: urls.manifestUrl || '',
+                    profile,
+                    limits: context.limits,
+                    signal: context.signal,
+                    reportProgress(progress) {
+                        loadedByAsset.set(progress.assetKey, 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.1, `Preflighting Julia asset ${progress.assetKey}`);
+                    },
+                    reportDecompressionProgress(asset, loadedBytes) {
+                        decompressedByAsset.set(asset, loadedBytes);
+                        const decompressedBytes = [...decompressedByAsset.values()].reduce((total, loaded) => total + loaded, 0);
+                        const fraction = totalDecompressedBytes > 0
+                            ? decompressedBytes / totalDecompressedBytes
+                            : 0;
+                        context.reportProgress(0.14 + Math.min(1, fraction) * 0.03, `Decompressing verified Julia ${asset}`);
+                    }
+                });
+                return context.createOwnedDelivery(payload);
+            }
+        });
+    }
+}
+export default Julia;

package/dist/playground/lfortran.d.ts

@@ -0,0 +1,8 @@
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+/** Real upstream FortranEvaluator using LLVM and Emscripten dynamic side modules. */
+export default class LFortran extends StaticWorkerRuntimeSandbox {
+    readonly memoryEvidence: {
+        current: unknown;
+    };
+    constructor();
+}

package/dist/playground/lfortran.js

@@ -0,0 +1,30 @@
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+import { preflightLfortranRuntimeAssets, resolveLfortranRuntimeAssetConfig } from './lfortranAssets';
+/** Real upstream FortranEvaluator using LLVM and Emscripten dynamic side modules. */
+export default class LFortran extends StaticWorkerRuntimeSandbox {
+    memoryEvidence;
+    constructor() {
+        const memoryEvidence = { current: undefined };
+        super({
+            displayName: 'LFortran',
+            languageId: 'LFORTRAN',
+            defaultActivePath: 'main.f90',
+            workerLifetime: { mode: 'per-run' },
+            runtimePreflightDelivery: 'transfer-owned',
+            inlineVerifiedWorker: true,
+            requireExactWorkerResponseUrl: true,
+            moduleWorker: true,
+            includeExecutionLimits: true,
+            onEvidence(evidence) {
+                memoryEvidence.current = evidence;
+            },
+            stdin: { mode: 'streaming', sourceHintPattern: /\bread\b/i },
+            resolveRuntimeAssets: resolveLfortranRuntimeAssetConfig,
+            async preflightRuntimeAssets(urls, context) {
+                memoryEvidence.current = undefined;
+                return context.createOwnedDelivery(await preflightLfortranRuntimeAssets(urls.baseUrl, context));
+            }
+        });
+        this.memoryEvidence = memoryEvidence;
+    }
+}

package/dist/playground/lfortranAssets.d.ts

@@ -0,0 +1,21 @@
+import { type ExecutionLimits } from '@wasm-idle/core';
+import type { PlaygroundRuntimeAssets } from './assets';
+export declare const LFORTRAN_INITIAL_MEMORY_BYTES: number;
+export declare const LFORTRAN_RUNTIME_MANIFEST: import("@wasm-idle/core").RuntimeRegistryManifest;
+export declare function resolveLfortranRuntimeAssetConfig(assets: string | PlaygroundRuntimeAssets, currentUrl: string): {
+    baseUrl: string;
+    workerUrl: string;
+    manifestFingerprint: "11c9baef85c5221440edc4462690312cda62b48998a133b9a397ce32c6a97c45";
+    workerReceipt: {
+        readonly bytes: 11569;
+        readonly sha256: "e801cbf4dca7be9fc6fd1205dc4e6ab17af4530f42527dcc8e544eb8373a1469";
+    };
+};
+export declare function preflightLfortranRuntimeAssets(baseUrl: string, options: {
+    limits: ExecutionLimits;
+    signal?: AbortSignal;
+    reportProgress?: (value: number, stage: string) => void;
+    fetch?: typeof globalThis.fetch;
+}): Promise<Readonly<{
+    fingerprint: "11c9baef85c5221440edc4462690312cda62b48998a133b9a397ce32c6a97c45";
+}>>;

package/dist/playground/lfortranAssets.js

@@ -0,0 +1,118 @@
+import { defineRuntimeRegistryManifest, preflightRuntimeAssets, ResourceLimitError, RuntimeConfigurationError } from '@wasm-idle/core';
+import { WASM_LFORTRAN_PROFILE as profile } from './wasmLfortranVersion';
+export const LFORTRAN_INITIAL_MEMORY_BYTES = 128 * 1024 * 1024;
+export const LFORTRAN_RUNTIME_MANIFEST = defineRuntimeRegistryManifest({
+    schemaVersion: 2,
+    manifestId: 'wasm-idle/lfortran',
+    revision: profile.assets['producer-receipt.json'].sha256,
+    runtimes: [
+        {
+            runtimeId: 'LFORTRAN',
+            identity: {
+                languageId: 'LFORTRAN',
+                implementationId: 'lfortran-llvm-emscripten',
+                implementationVersion: profile.version,
+                profile: {
+                    profileId: profile.profileId,
+                    manifestSchemaVersion: 1,
+                    manifestSha256: profile.assets['producer-receipt.json'].sha256,
+                    protocolVersion: 1,
+                    trustProfileId: profile.profileId,
+                    trustProfileSchemaVersion: 1
+                }
+            },
+            capabilities: {
+                stdin: 'streaming',
+                workspace: true,
+                abort: true,
+                artifacts: false,
+                streamingOutput: true
+            },
+            workerLifetime: { mode: 'per-run' },
+            requiredBrowserFeatures: ['wasm', 'wasm-exceptions', 'shared-array-buffer'],
+            assetRoot: '.',
+            assets: Object.entries(profile.assets).map(([name, receipt]) => ({
+                key: name,
+                path: name === 'lfortran.data' ? 'lfortran.data.bin' : name,
+                compressedSha256: receipt.sha256,
+                uncompressedSha256: receipt.sha256,
+                compressedBytes: receipt.bytes,
+                uncompressedBytes: receipt.bytes,
+                encoding: 'identity',
+                mediaType: name.endsWith('.wasm')
+                    ? 'application/wasm'
+                    : name.endsWith('.js')
+                        ? 'text/javascript'
+                        : name.endsWith('.json')
+                            ? 'application/json'
+                            : 'application/octet-stream'
+            })),
+            contracts: {
+                routeId: 'LFORTRAN',
+                runtimeAssetKey: 'lfortran',
+                documentationId: 'lfortran',
+                syncTarget: 'wasm-lfortran',
+                browserTestId: 'LFORTRAN'
+            }
+        }
+    ]
+});
+export function resolveLfortranRuntimeAssetConfig(assets, currentUrl) {
+    const root = typeof assets === 'string' ? assets : assets.rootUrl || '';
+    const override = typeof assets === 'string' ? undefined : assets.lfortran?.baseUrl;
+    const baseUrl = new URL(override ?? `${root.replace(/\/+$/, '')}/wasm-lfortran/`, currentUrl);
+    if (!['http:', 'https:'].includes(baseUrl.protocol) ||
+        baseUrl.username ||
+        baseUrl.password ||
+        baseUrl.search ||
+        baseUrl.hash) {
+        throw new RuntimeConfigurationError('LFortran requires a credential-free HTTP(S) asset directory.', { runtimeId: 'LFORTRAN' });
+    }
+    if (!baseUrl.pathname.endsWith('/'))
+        baseUrl.pathname += '/';
+    const workerUrl = new URL('runner-worker.js', baseUrl);
+    workerUrl.searchParams.set('v', profile.workerReceipt.sha256);
+    return {
+        baseUrl: baseUrl.href,
+        workerUrl: workerUrl.href,
+        manifestFingerprint: profile.assets['producer-receipt.json'].sha256,
+        workerReceipt: profile.workerReceipt
+    };
+}
+export async function preflightLfortranRuntimeAssets(baseUrl, options) {
+    if (options.limits.maxWasmMemoryBytes < LFORTRAN_INITIAL_MEMORY_BYTES) {
+        throw new ResourceLimitError('LFortran needs at least 128 MiB of Wasm memory.', {
+            runtimeId: 'LFORTRAN',
+            phase: 'asset',
+            resource: 'wasm-memory',
+            actual: LFORTRAN_INITIAL_MEMORY_BYTES,
+            limit: options.limits.maxWasmMemoryBytes
+        });
+    }
+    const loaded = new Map();
+    const total = Object.values(profile.assets).reduce((sum, asset) => sum + asset.bytes, 0);
+    const result = await preflightRuntimeAssets({
+        manifest: LFORTRAN_RUNTIME_MANIFEST,
+        runtimeId: 'LFORTRAN',
+        rootUrl: baseUrl,
+        assetUrls: Object.fromEntries(Object.entries(profile.assets).map(([name, asset]) => [
+            name,
+            new URL(`${name === 'lfortran.data' ? 'lfortran.data.bin' : name}?v=${asset.sha256}`, baseUrl)
+        ])),
+        limits: options.limits,
+        signal: options.signal,
+        fetch: options.fetch,
+        redirect: 'error',
+        requireExactResponseUrl: true,
+        maxConcurrentDownloads: 2,
+        maxTotalDeliveryBytes: total,
+        reportProgress(progress) {
+            loaded.set(progress.assetKey, progress.loadedBytes);
+            options.reportProgress?.(0.04 + (0.13 * [...loaded.values()].reduce((a, b) => a + b, 0)) / total, `Verifying LFortran ${progress.assetKey}`);
+        }
+    });
+    return Object.freeze({
+        fingerprint: profile.assets['producer-receipt.json'].sha256,
+        ...Object.fromEntries(Object.entries(result.assets).map(([name, asset]) => [name, asset.bytes]))
+    });
+}

package/dist/playground/lisp.d.ts

@@ -0,0 +1,45 @@
+import { type PlaygroundRuntimeAssets } from './assets';
+import { type CompilerDiagnostic, type SandboxExecutionOptions } from './options';
+import type { Sandbox, SandboxProgress } from './sandbox';
+declare class Lisp implements Sandbox {
+    output: any;
+    worker?: Worker;
+    buffer: import("./sharedBuffer").WasmIdleSharedBuffer;
+    pendingInput: string[];
+    begin: number;
+    elapse: number;
+    uid: number;
+    exit: boolean;
+    moduleUrl: string;
+    private runtimeConfigKey;
+    oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
+    waitingForInput: boolean;
+    pendingEof: boolean;
+    private activeOperation;
+    private disposed;
+    private disposePromise;
+    private readonly disposeCancellation;
+    private readonly workerSession;
+    private requireOperationIdle;
+    private beginOperation;
+    private isOperationActive;
+    private releaseOperation;
+    private cleanupOperation;
+    private releaseBeforeSession;
+    private bindPreSessionAbort;
+    private bindAbortSignal;
+    private bindOperationTimeout;
+    private resetExplicitStdinState;
+    private finishExplicitStdin;
+    load(runtimeAssets?: string | PlaygroundRuntimeAssets, _code?: string, _log?: boolean, _args?: string[], options?: SandboxExecutionOptions, progress?: SandboxProgress): Promise<void>;
+    write(input: string): void;
+    eof(): void;
+    private flushPendingInput;
+    run(code: string, prepare: boolean, _log?: boolean, _prog?: SandboxProgress, args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
+    private cancelOperation;
+    kill(): void;
+    terminate(reason?: unknown): void;
+    clear(): Promise<void>;
+    dispose(): Promise<void>;
+}
+export default Lisp;