wasm-idle 0.7.2 → 1.0.0

package/dist/playground/fortran.js

@@ -0,0 +1,651 @@
+import { WorkerAssetBridge } from './assetBridge';
+import { resolveFortranRuntimeAssetConfig, resolveRuntimeAssetConfig } from './assets';
+import { AssetTooLargeError, BusyError, CancelledError, DEFAULT_WORKSPACE_LIMITS, OutputLimitError, RuntimeConfigurationError, TimeoutError, resolveExecutionLimits, validateExecutionWorkspace } from '@wasm-idle/core';
+import { FORTRAN_EXECUTION_ASSET_NAMES } from './fortranAssets';
+import { resolveSandboxExecutionArgs } from './options';
+import { createWasmIdleSharedBuffer } from './sharedBuffer';
+import { WorkerSession } from './workerSession';
+import { reportWorkerInputReady } from './workerProgress';
+import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
+const fortranAssetsKey = (assets) => JSON.stringify({
+    baseUrl: assets.baseUrl,
+    f2cWasmUrl: assets.f2cWasmUrl,
+    libf2cUrl: assets.libf2cUrl,
+    f2cHeaderUrl: assets.f2cHeaderUrl,
+    analyzerUrl: assets.analyzerUrl,
+    integrity: assets.integrity
+});
+const OUTPUT_ENCODER = new TextEncoder();
+const abortReason = (signal, phase) => signal.reason !== undefined
+    ? signal.reason
+    : new DOMException(phase === 'startup'
+        ? 'Fortran runtime startup aborted'
+        : 'Fortran execution aborted', 'AbortError');
+class Fortran {
+    language = 'FORTRAN';
+    output;
+    worker = null;
+    buffer = createWasmIdleSharedBuffer(4096);
+    pendingInput = [];
+    begin = 0;
+    elapse = 0;
+    uid = 0;
+    log = true;
+    waitingForInput = false;
+    pendingEof = false;
+    exit = true;
+    assetBridge = null;
+    activeFortranAssetsKey = '';
+    activeOperation = null;
+    preserveOperationOnWorkerDispose = false;
+    disposed = false;
+    disposePromise = null;
+    disposeCancellation = new CancelledError('Fortran sandbox disposed', {
+        phase: 'dispose',
+        runtimeId: 'FORTRAN',
+        recoverable: false
+    });
+    workerSession = new WorkerSession({
+        label: 'Fortran',
+        onDispose: (worker) => {
+            if (this.worker === worker) {
+                const assetBridge = this.assetBridge;
+                delete this.worker;
+                this.assetBridge = null;
+                this.activeFortranAssetsKey = '';
+                if (!this.preserveOperationOnWorkerDispose && this.activeOperation) {
+                    const operation = this.activeOperation;
+                    this.finishExplicitStdin(operation);
+                    operation.cancelled = true;
+                    this.releaseOperation(operation);
+                    this.cleanupOperation(operation);
+                }
+                try {
+                    assetBridge?.dispose();
+                }
+                catch {
+                    // Asset cleanup must not replace the worker operation result.
+                }
+            }
+            this.exit = true;
+            this.waitingForInput = false;
+            this.pendingEof = false;
+        }
+    });
+    disposedConfigurationError() {
+        return new RuntimeConfigurationError('Fortran sandbox is disposed', {
+            phase: 'dispose',
+            runtimeId: this.language
+        });
+    }
+    requireOperationIdle() {
+        if (this.disposed)
+            throw this.disposedConfigurationError();
+        if (this.activeOperation) {
+            throw new BusyError('Fortran runtime already has an active operation', {
+                runtimeId: this.language,
+                phase: this.activeOperation.phase
+            });
+        }
+    }
+    beginOperation(phase) {
+        this.requireOperationIdle();
+        const operation = {
+            token: Symbol(phase),
+            phase,
+            cancelled: false,
+            explicitStdin: false,
+            cleanedUp: false,
+            cleanups: []
+        };
+        this.activeOperation = operation;
+        return operation;
+    }
+    isOperationActive(operation) {
+        return this.activeOperation?.token === operation.token && !operation.cancelled;
+    }
+    releaseOperation(operation) {
+        if (this.activeOperation?.token !== operation.token)
+            return false;
+        this.activeOperation = null;
+        return true;
+    }
+    cleanupOperation(operation) {
+        if (operation.cleanedUp)
+            return;
+        operation.cleanedUp = true;
+        const cleanups = operation.cleanups.splice(0);
+        for (const cleanup of cleanups) {
+            try {
+                cleanup();
+            }
+            catch {
+                // Caller-owned lifecycle cleanup must not replace the operation result.
+            }
+        }
+    }
+    bindAbortSignal(operation, signal) {
+        if (!signal)
+            return;
+        let registered = false;
+        const onAbort = () => {
+            if (!this.isOperationActive(operation))
+                return;
+            this.cancelOperation(operation, abortReason(signal, operation.phase));
+        };
+        operation.cleanups.push(() => {
+            if (registered)
+                signal.removeEventListener('abort', onAbort);
+        });
+        try {
+            signal.addEventListener('abort', onAbort, { once: true });
+            registered = true;
+        }
+        catch (error) {
+            this.cancelOperation(operation, error);
+            return;
+        }
+        if (signal.aborted)
+            onAbort();
+    }
+    bindOperationTimeout(operation, timeoutMs) {
+        const timeout = setTimeout(() => {
+            if (!this.isOperationActive(operation))
+                return;
+            const label = operation.phase === 'startup' ? 'startup' : 'execution';
+            this.cancelOperation(operation, new TimeoutError(`Fortran ${label} timed out after ${timeoutMs} ms`, {
+                phase: operation.phase,
+                runtimeId: this.language,
+                timeoutMs
+            }));
+        }, timeoutMs);
+        operation.cleanups.push(() => clearTimeout(timeout));
+    }
+    resetExplicitStdinState() {
+        this.pendingInput = [];
+        this.pendingEof = false;
+        this.waitingForInput = false;
+        try {
+            resetBufferedStdin(this.buffer);
+        }
+        catch {
+            // Explicit stdin never consumes the shared terminal buffer.
+        }
+    }
+    finishExplicitStdin(operation) {
+        if (!operation.explicitStdin)
+            return;
+        operation.explicitStdin = false;
+        this.resetExplicitStdinState();
+    }
+    load(runtimeAssets = '', code = '', log = true, args = [], options = {}, progress) {
+        if (this.disposed)
+            return Promise.reject(this.disposedConfigurationError());
+        let limits;
+        try {
+            limits = resolveExecutionLimits(options.limits);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        if (options.signal?.aborted) {
+            return Promise.reject(abortReason(options.signal, 'startup'));
+        }
+        let operation;
+        try {
+            operation = this.beginOperation('startup');
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        let clangAssets;
+        let fortranAssets;
+        let nextFortranAssetsKey;
+        let needsWorkerReset;
+        try {
+            const currentUrl = typeof window !== 'undefined' ? window.location.href : '';
+            clangAssets = resolveRuntimeAssetConfig('clang', runtimeAssets, currentUrl);
+            if (!this.isOperationActive(operation)) {
+                return Promise.reject(operation.cancellation?.reason);
+            }
+            fortranAssets = resolveFortranRuntimeAssetConfig(runtimeAssets, currentUrl);
+            if (!this.isOperationActive(operation)) {
+                return Promise.reject(operation.cancellation?.reason);
+            }
+            for (const asset of FORTRAN_EXECUTION_ASSET_NAMES) {
+                const receipt = fortranAssets.integrity[asset];
+                if (receipt.bytes > limits.maxAssetBytes) {
+                    throw new AssetTooLargeError(`Fortran execution asset ${asset} exceeds the ${limits.maxAssetBytes} byte limit`, {
+                        actual: receipt.bytes,
+                        limit: limits.maxAssetBytes,
+                        runtimeId: this.language
+                    });
+                }
+            }
+            nextFortranAssetsKey = fortranAssetsKey(fortranAssets);
+            needsWorkerReset =
+                !this.worker ||
+                    !this.assetBridge ||
+                    !this.assetBridge.matches(clangAssets, limits.maxAssetBytes) ||
+                    this.activeFortranAssetsKey !== nextFortranAssetsKey;
+        }
+        catch (error) {
+            const failure = operation.cancellation ? operation.cancellation.reason : error;
+            this.releaseOperation(operation);
+            this.cleanupOperation(operation);
+            return Promise.reject(failure);
+        }
+        const timeoutMs = Math.min(2_147_483_647, limits.assetTimeoutMs + limits.startupTimeoutMs);
+        this.bindOperationTimeout(operation, timeoutMs);
+        this.bindAbortSignal(operation, options.signal);
+        if (!this.isOperationActive(operation)) {
+            return Promise.reject(operation.cancellation?.reason);
+        }
+        const loading = this.workerSession.load(async (resolve, reject) => {
+            const resolveOperation = () => {
+                if (!this.releaseOperation(operation))
+                    return;
+                resolve();
+                this.cleanupOperation(operation);
+            };
+            const rejectOperation = (reason) => {
+                if (!this.releaseOperation(operation))
+                    return;
+                reject(reason);
+                this.cleanupOperation(operation);
+            };
+            try {
+                if (!this.isOperationActive(operation))
+                    return;
+                this.pendingInput = [];
+                this.waitingForInput = false;
+                this.pendingEof = false;
+                if (needsWorkerReset && this.worker) {
+                    this.preserveOperationOnWorkerDispose = true;
+                    try {
+                        this.workerSession.reset();
+                    }
+                    finally {
+                        this.preserveOperationOnWorkerDispose = false;
+                    }
+                    if (!this.isOperationActive(operation))
+                        return;
+                }
+                if (!this.worker) {
+                    const WorkerConstructor = (await import('./worker/fortran?worker')).default;
+                    if (!this.isOperationActive(operation))
+                        return;
+                    const worker = new WorkerConstructor();
+                    if (!this.isOperationActive(operation)) {
+                        try {
+                            worker.terminate();
+                        }
+                        catch {
+                            // The unattached worker is already detached.
+                        }
+                        return;
+                    }
+                    let assetBridge;
+                    try {
+                        assetBridge = new WorkerAssetBridge(worker, 'clang', clangAssets, progress, limits.maxAssetBytes);
+                    }
+                    catch (error) {
+                        try {
+                            worker.terminate();
+                        }
+                        catch {
+                            // Worker cleanup must not replace the progress callback error.
+                        }
+                        throw error;
+                    }
+                    if (!this.isOperationActive(operation)) {
+                        try {
+                            assetBridge.dispose();
+                        }
+                        catch {
+                            // Stale asset cleanup is best effort.
+                        }
+                        try {
+                            worker.terminate();
+                        }
+                        catch {
+                            // The unattached worker is already detached.
+                        }
+                        return;
+                    }
+                    this.worker = worker;
+                    this.assetBridge = assetBridge;
+                    this.workerSession.attach(worker);
+                    const handler = (event) => {
+                        if (this.worker !== worker ||
+                            this.assetBridge !== assetBridge ||
+                            worker.onmessage !== handler) {
+                            return;
+                        }
+                        try {
+                            if (assetBridge.handleMessage(event))
+                                return;
+                            if (!this.isOperationActive(operation))
+                                return;
+                            if (event.data?.progress != null) {
+                                progress?.set?.(event.data.progress);
+                                if (!this.isOperationActive(operation) ||
+                                    this.worker !== worker ||
+                                    this.assetBridge !== assetBridge ||
+                                    worker.onmessage !== handler) {
+                                    return;
+                                }
+                            }
+                            if (event.data?.load) {
+                                this.log = log;
+                                this.activeFortranAssetsKey = nextFortranAssetsKey;
+                                resolveOperation();
+                                return;
+                            }
+                            if (event.data?.error !== undefined) {
+                                rejectOperation(event.data.error);
+                            }
+                        }
+                        catch (error) {
+                            rejectOperation(error);
+                        }
+                    };
+                    worker.onmessage = handler;
+                    worker.postMessage({
+                        load: true,
+                        log,
+                        code,
+                        args,
+                        clangAssets: {
+                            baseUrl: clangAssets.baseUrl,
+                            maxAssetBytes: limits.maxAssetBytes,
+                            useAssetBridge: clangAssets.useAssetBridge
+                        },
+                        fortranAssets: {
+                            ...fortranAssets,
+                            maxAssetBytes: limits.maxAssetBytes
+                        }
+                    });
+                }
+                else {
+                    const worker = this.worker;
+                    const assetBridge = this.assetBridge;
+                    if (!assetBridge)
+                        return rejectOperation('Fortran asset bridge is not loaded');
+                    assetBridge.rebind(worker, clangAssets, progress, limits.maxAssetBytes);
+                    if (!this.isOperationActive(operation) ||
+                        this.worker !== worker ||
+                        this.assetBridge !== assetBridge) {
+                        return;
+                    }
+                    worker.postMessage({ log });
+                    this.log = log;
+                    this.activeFortranAssetsKey = nextFortranAssetsKey;
+                    resolveOperation();
+                }
+            }
+            catch (error) {
+                rejectOperation(error);
+            }
+        });
+        return loading.finally(() => {
+            this.releaseOperation(operation);
+            this.cleanupOperation(operation);
+        });
+    }
+    write(input) {
+        if (this.disposed)
+            return;
+        this.pendingInput.push(input);
+        this.pendingEof = false;
+        this.flushPendingInput();
+    }
+    eof() {
+        if (this.disposed)
+            return;
+        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 run(code, prepare, log = this.log, prog, args = [], options = {}) {
+        if (options.debug)
+            return Promise.reject('Fortran debugging is not supported yet.');
+        this.requireOperationIdle();
+        const limits = resolveExecutionLimits(options.limits);
+        const signal = options.signal;
+        if (signal?.aborted) {
+            return Promise.reject(abortReason(signal, 'execute'));
+        }
+        const { compileArgs, programArgs } = resolveSandboxExecutionArgs(this.language, args, options);
+        const stdin = options.stdin;
+        const workspace = validateExecutionWorkspace(code, options.workspaceFiles ?? [], options.activePath ?? 'main.f', {
+            ...options.workspaceLimits,
+            maxFileBytes: Math.min(options.workspaceLimits?.maxFileBytes ?? DEFAULT_WORKSPACE_LIMITS.maxFileBytes, limits.maxWorkspaceBytes),
+            maxTotalBytes: Math.min(options.workspaceLimits?.maxTotalBytes ??
+                DEFAULT_WORKSPACE_LIMITS.maxTotalBytes, limits.maxWorkspaceBytes)
+        });
+        const activeOperation = this.beginOperation('execute');
+        try {
+            const worker = this.worker;
+            if (!worker)
+                throw 'Worker not loaded';
+            const assetBridge = this.assetBridge;
+            if (!assetBridge)
+                throw 'Fortran asset bridge is not loaded';
+            const hasExplicitStdin = stdin !== undefined;
+            if (hasExplicitStdin) {
+                activeOperation.explicitStdin = true;
+                this.resetExplicitStdinState();
+            }
+            this.exit = false;
+            return await new Promise((resolve, reject) => {
+                let outputBytes = 0;
+                const workerOperation = this.workerSession.beginRun(worker, reject);
+                const timeoutMs = Math.min(2_147_483_647, limits.compileTimeoutMs + limits.runTimeoutMs);
+                this.bindOperationTimeout(activeOperation, timeoutMs);
+                this.bindAbortSignal(activeOperation, signal);
+                if (!this.isOperationActive(activeOperation))
+                    return;
+                const runUid = ++this.uid;
+                let handler;
+                const ownsRun = () => this.isOperationActive(activeOperation) &&
+                    this.worker === worker &&
+                    this.assetBridge === assetBridge &&
+                    worker.onmessage === handler &&
+                    runUid === this.uid;
+                const settleRunState = () => {
+                    this.finishExplicitStdin(activeOperation);
+                    this.elapse = Date.now() - this.begin;
+                    this.exit = true;
+                    this.waitingForInput = false;
+                    this.pendingEof = false;
+                };
+                const failRun = (error, disposeWorker = false) => {
+                    if (!ownsRun())
+                        return;
+                    settleRunState();
+                    this.workerSession.complete(workerOperation);
+                    this.releaseOperation(activeOperation);
+                    if (disposeWorker && this.worker === worker)
+                        this.workerSession.reset();
+                    this.cleanupOperation(activeOperation);
+                    reject(error);
+                };
+                handler = (event) => {
+                    if (this.worker !== worker ||
+                        this.assetBridge !== assetBridge ||
+                        worker.onmessage !== handler) {
+                        return;
+                    }
+                    try {
+                        if (assetBridge.handleMessage(event))
+                            return;
+                        if (!ownsRun())
+                            return;
+                        const { output, results, log: workerLog, error, buffer, progress } = event.data;
+                        if (buffer && !hasExplicitStdin) {
+                            this.waitingForInput = true;
+                            if (!prepare) {
+                                reportWorkerInputReady(prog, 'Fortran runtime ready for input');
+                                if (!ownsRun())
+                                    return;
+                            }
+                            this.flushPendingInput();
+                            if (!ownsRun())
+                                return;
+                        }
+                        if (typeof output === 'string' && output.length > 0) {
+                            const actual = outputBytes + OUTPUT_ENCODER.encode(output).byteLength;
+                            if (actual > limits.maxOutputBytes) {
+                                failRun(new OutputLimitError(`Fortran output exceeded ${limits.maxOutputBytes} bytes`, {
+                                    actual,
+                                    limit: limits.maxOutputBytes,
+                                    phase: 'execute',
+                                    runtimeId: this.language
+                                }), true);
+                                return;
+                            }
+                            outputBytes = actual;
+                            this.output?.(output);
+                            if (!ownsRun())
+                                return;
+                        }
+                        if (results !== undefined) {
+                            if (!ownsRun())
+                                return;
+                            settleRunState();
+                            this.workerSession.complete(workerOperation);
+                            this.releaseOperation(activeOperation);
+                            this.cleanupOperation(activeOperation);
+                            resolve(results);
+                            return;
+                        }
+                        if (workerLog) {
+                            console.log(workerLog);
+                            if (!ownsRun())
+                                return;
+                        }
+                        if (error !== undefined) {
+                            failRun(error);
+                            return;
+                        }
+                        if (progress != null) {
+                            prog?.set?.(progress);
+                            if (!ownsRun())
+                                return;
+                        }
+                    }
+                    catch (error) {
+                        failRun(error, true);
+                    }
+                };
+                worker.onmessage = handler;
+                this.begin = Date.now();
+                try {
+                    worker.postMessage({
+                        code,
+                        prepare,
+                        buffer: this.buffer,
+                        stdin,
+                        log,
+                        compileArgs,
+                        programArgs,
+                        activePath: workspace.activePath,
+                        workspaceFiles: workspace.workspaceFiles
+                    });
+                }
+                catch (error) {
+                    failRun(error);
+                }
+            });
+        }
+        finally {
+            this.finishExplicitStdin(activeOperation);
+            this.releaseOperation(activeOperation);
+            this.cleanupOperation(activeOperation);
+        }
+    }
+    cancelOperation(operation, reason) {
+        if (!this.isOperationActive(operation))
+            return;
+        this.finishExplicitStdin(operation);
+        operation.cancelled = true;
+        operation.cancellation = { reason };
+        this.activeOperation = null;
+        this.waitingForInput = false;
+        this.pendingEof = false;
+        this.uid += 1;
+        this.exit = true;
+        this.workerSession.terminate(reason);
+        this.cleanupOperation(operation);
+    }
+    kill() {
+        this.terminate();
+    }
+    terminate(reason = 'Process terminated') {
+        if (this.disposed)
+            return;
+        const operation = this.activeOperation;
+        if (operation) {
+            this.cancelOperation(operation, reason);
+            return;
+        }
+        this.waitingForInput = false;
+        this.pendingEof = false;
+        this.uid += 1;
+        this.workerSession.terminate(reason);
+        this.exit = true;
+    }
+    async clear() {
+        if (this.disposed)
+            return;
+        this.terminate();
+        this.pendingInput = [];
+        this.waitingForInput = false;
+        this.pendingEof = false;
+        resetBufferedStdin(this.buffer);
+        await new Promise((resolve) => setTimeout(resolve, 200));
+    }
+    dispose() {
+        if (this.disposePromise)
+            return this.disposePromise;
+        this.disposed = true;
+        this.disposePromise = Promise.resolve();
+        const activeOperation = this.activeOperation;
+        const assetBridge = this.assetBridge;
+        this.preserveOperationOnWorkerDispose = false;
+        delete this.worker;
+        this.assetBridge = null;
+        this.activeFortranAssetsKey = '';
+        this.output = undefined;
+        this.resetExplicitStdinState();
+        try {
+            assetBridge?.dispose();
+        }
+        catch {
+            // Asset cleanup is best effort after host state becomes unreachable.
+        }
+        if (activeOperation) {
+            this.cancelOperation(activeOperation, this.disposeCancellation);
+        }
+        else {
+            this.uid += 1;
+            this.workerSession.terminate(this.disposeCancellation);
+            this.exit = true;
+        }
+        return this.disposePromise;
+    }
+}
+export default Fortran;

package/dist/playground/fortranAssets.d.ts

@@ -0,0 +1,6 @@
+import type { RuntimeAssetIntegrityEntry } from '@wasm-idle/core';
+export declare const FORTRAN_EXECUTION_ASSET_NAMES: readonly ["f2c.wasm", "libf2c.a", "f2c.h"];
+export type FortranExecutionAssetName = (typeof FORTRAN_EXECUTION_ASSET_NAMES)[number];
+export type FortranExecutionAssetReceipt = Readonly<Required<Pick<RuntimeAssetIntegrityEntry, 'bytes' | 'sha256'>>>;
+export type FortranExecutionAssetReceipts = Readonly<Record<FortranExecutionAssetName, FortranExecutionAssetReceipt>>;
+export declare function snapshotFortranExecutionAssetReceipts(value: FortranExecutionAssetReceipts | undefined): FortranExecutionAssetReceipts;

package/dist/playground/fortranAssets.js

@@ -0,0 +1,27 @@
+export const FORTRAN_EXECUTION_ASSET_NAMES = ['f2c.wasm', 'libf2c.a', 'f2c.h'];
+export function snapshotFortranExecutionAssetReceipts(value) {
+    const receivedAssets = Object.keys(value || {}).sort();
+    const expectedAssets = [...FORTRAN_EXECUTION_ASSET_NAMES].sort();
+    if (receivedAssets.length !== expectedAssets.length ||
+        receivedAssets.some((asset, index) => asset !== expectedAssets[index])) {
+        throw new TypeError('Fortran execution requires exactly three asset receipts');
+    }
+    const receipts = Object.fromEntries(FORTRAN_EXECUTION_ASSET_NAMES.map((asset) => {
+        const receipt = value?.[asset];
+        if (!receipt ||
+            !Number.isSafeInteger(receipt.bytes) ||
+            receipt.bytes <= 0 ||
+            typeof receipt.sha256 !== 'string' ||
+            !/^[a-f0-9]{64}$/u.test(receipt.sha256)) {
+            throw new TypeError(`Fortran execution asset receipt is invalid for ${asset}`);
+        }
+        return [
+            asset,
+            Object.freeze({
+                bytes: receipt.bytes,
+                sha256: receipt.sha256
+            })
+        ];
+    }));
+    return Object.freeze(receipts);
+}

package/dist/playground/gleam.d.ts

@@ -0,0 +1,6 @@
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+export declare const GLEAM_WORKER_IDLE_TIMEOUT_MS = 60000;
+declare class Gleam extends StaticWorkerRuntimeSandbox {
+    constructor();
+}
+export default Gleam;