wasm-idle 0.7.2 → 1.0.0

package/dist/playground/nim.js

@@ -0,0 +1,76 @@
+import { resolveNimRuntimeAssetConfig } from './assets';
+import { StaticWorkerRuntimeSandbox } from './staticWorkerRuntime';
+import { RuntimeConfigurationError, preflightNimRuntimeAssets, snapshotNimRuntimePreflightProfile } from '@wasm-idle/core';
+class Nim extends StaticWorkerRuntimeSandbox {
+    constructor() {
+        super({
+            displayName: 'Nim',
+            languageId: 'NIM',
+            defaultActivePath: 'main.nim',
+            workerLifetime: { mode: 'per-run' },
+            runtimePreflightDelivery: 'transfer-owned',
+            stdin: {
+                mode: 'streaming',
+                sourceHintPattern: /\b(?:stdin|readLine|readAll|lines)\b/i
+            },
+            inlineVerifiedWorker: true,
+            resolveRuntimeAssets(runtimeAssets, currentUrl) {
+                const resolved = resolveNimRuntimeAssetConfig(runtimeAssets, currentUrl);
+                const profile = snapshotNimRuntimePreflightProfile(resolved.preflightProfile);
+                if (!/^[a-f0-9]{64}$/u.test(resolved.manifestFingerprint || '') ||
+                    profile.manifestFingerprint !== resolved.manifestFingerprint ||
+                    !resolved.workerReceipt) {
+                    throw new RuntimeConfigurationError('Nim runtime requires one coherent preflight profile, manifest fingerprint, and worker receipt.', { runtimeId: 'NIM' });
+                }
+                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,
+                    profile.nimJavaScriptReceipt.bytes,
+                    profile.nimWasmReceipt.bytes,
+                    profile.nimbaseReceipt.bytes,
+                    profile.clangJavaScriptReceipt.bytes,
+                    profile.clangWasmReceipt.bytes,
+                    profile.lldWasmReceipt.bytes,
+                    profile.memfsWasmReceipt.bytes,
+                    profile.sysrootReceipt.bytes
+                ].reduce((total, bytes) => total + (bytes ?? 0), 0);
+                const totalDecompressedBytes = [
+                    profile.nimJavaScriptReceipt.uncompressedBytes,
+                    profile.nimWasmReceipt.uncompressedBytes,
+                    profile.clangWasmReceipt.uncompressedBytes,
+                    profile.lldWasmReceipt.uncompressedBytes,
+                    profile.memfsWasmReceipt.uncompressedBytes,
+                    profile.sysrootReceipt.uncompressedBytes
+                ].reduce((total, bytes) => total + (bytes ?? 0), 0);
+                const payload = await preflightNimRuntimeAssets({
+                    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 Nim 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 Nim ${asset}`);
+                    }
+                });
+                return context.createOwnedDelivery(payload);
+            }
+        });
+    }
+}
+export default Nim;

package/dist/playground/objectivec.d.ts

@@ -0,0 +1,39 @@
+import { WorkerAssetBridge } from './assetBridge';
+import type { DebugCommand, DebugSessionEvent } from './options';
+import { type PlaygroundRuntimeAssets } from './assets';
+import type { SandboxExecutionOptions } from './options';
+import type { Sandbox, SandboxProgress } from './sandbox';
+declare class ObjectiveC implements Sandbox {
+    language: string;
+    output?: (data: string) => void;
+    ondebug?: (event: DebugSessionEvent) => void;
+    worker?: Worker;
+    buffer: import("./sharedBuffer").WasmIdleSharedBuffer;
+    debugBuffer: import("./sharedBuffer").WasmIdleSharedBuffer;
+    watchBuffer: import("./sharedBuffer").WasmIdleSharedBuffer;
+    watchResultBuffer: import("./sharedBuffer").WasmIdleSharedBuffer;
+    interruptBuffer: import("./sharedBuffer").WasmIdleSharedBuffer;
+    pendingInput: string[];
+    begin: number;
+    elapse: number;
+    uid: number;
+    log: boolean;
+    waitingForInput: boolean;
+    pendingEof: boolean;
+    exit: boolean;
+    assetBridge: WorkerAssetBridge | null;
+    activeObjectiveCAssetsKey: string;
+    private readonly workerSession;
+    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>;
+    debugCommand(command: DebugCommand): void;
+    setBreakpoints(lines: number[]): void;
+    debugEvaluate(expression: string): Promise<string>;
+    kill(): void;
+    terminate(): void;
+    clear(): Promise<void>;
+}
+export default ObjectiveC;

package/dist/playground/objectivec.js

@@ -0,0 +1,288 @@
+import { WorkerAssetBridge } from './assetBridge';
+import { resolveObjectiveCRuntimeAssetConfig, resolveRuntimeAssetConfig } from './assets';
+import { resolveSandboxExecutionArgs } from './options';
+import { createWasmIdleSharedBuffer, requireSharedArrayBuffer } from './sharedBuffer';
+import { WorkerSession } from './workerSession';
+import { reportWorkerInputReady } from './workerProgress';
+import { bufferedSequence, flushBufferedEof, flushQueuedStdin, resetBufferedStdin, waitForBufferedSequenceChange } from './stdinBuffer';
+import { AssetTooLargeError, createRuntimeAssetsKey, resolveExecutionLimits } from '@wasm-idle/core';
+const debugBreakpointBufferInts = 1028;
+const objectiveCAssetsKey = (assets) => createRuntimeAssetsKey({ objectivec: assets }) || '';
+class ObjectiveC {
+    language = 'OBJC';
+    output;
+    ondebug;
+    worker = null;
+    buffer = createWasmIdleSharedBuffer(4096);
+    debugBuffer = createWasmIdleSharedBuffer(Int32Array.BYTES_PER_ELEMENT * debugBreakpointBufferInts);
+    watchBuffer = createWasmIdleSharedBuffer(1024);
+    watchResultBuffer = createWasmIdleSharedBuffer(1024);
+    interruptBuffer = createWasmIdleSharedBuffer(1);
+    pendingInput = [];
+    begin = 0;
+    elapse = 0;
+    uid = 0;
+    log = true;
+    waitingForInput = false;
+    pendingEof = false;
+    exit = true;
+    assetBridge = null;
+    activeObjectiveCAssetsKey = '';
+    workerSession = new WorkerSession({
+        label: 'Objective-C',
+        onDispose: (worker) => {
+            if (this.worker === worker) {
+                const assetBridge = this.assetBridge;
+                delete this.worker;
+                this.assetBridge = null;
+                try {
+                    assetBridge?.dispose();
+                }
+                catch {
+                    // Asset cleanup must not replace the worker operation result.
+                }
+            }
+            this.activeObjectiveCAssetsKey = '';
+            this.exit = true;
+            this.waitingForInput = false;
+            this.pendingEof = false;
+            this.ondebug?.({ type: 'stop' });
+        }
+    });
+    load(runtimeAssets = '', code = '', log = true, args = [], options = {}, progress) {
+        let limits;
+        try {
+            limits = resolveExecutionLimits(options.limits);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        return this.workerSession.load(async (resolve, reject, operation) => {
+            this.log = log;
+            this.pendingInput = [];
+            this.waitingForInput = false;
+            this.pendingEof = false;
+            const currentUrl = typeof window !== 'undefined' ? window.location.href : '';
+            const clangAssets = resolveRuntimeAssetConfig('clang', runtimeAssets, currentUrl);
+            const objectivecAssets = resolveObjectiveCRuntimeAssetConfig(runtimeAssets, currentUrl);
+            for (const [asset, receipt] of Object.entries(objectivecAssets.integrity)) {
+                if (receipt.bytes > limits.maxAssetBytes) {
+                    throw new AssetTooLargeError(`Objective-C execution asset ${asset} exceeds the ${limits.maxAssetBytes} byte limit`, {
+                        actual: receipt.bytes,
+                        limit: limits.maxAssetBytes,
+                        runtimeId: this.language
+                    });
+                }
+            }
+            const nextObjectiveCAssetsKey = objectiveCAssetsKey(objectivecAssets);
+            const needsWorkerReset = !this.worker ||
+                !this.assetBridge ||
+                !this.assetBridge.matches(clangAssets, limits.maxAssetBytes) ||
+                this.activeObjectiveCAssetsKey !== nextObjectiveCAssetsKey;
+            if (needsWorkerReset && this.worker) {
+                this.workerSession.reset();
+            }
+            if (!this.worker) {
+                const { default: ObjectiveCWorker } = await import('./worker/objectivec?worker');
+                if (!this.workerSession.isActive(operation))
+                    return;
+                const worker = new ObjectiveCWorker();
+                if (!this.workerSession.attach(worker, operation))
+                    return;
+                this.worker = worker;
+                this.assetBridge = new WorkerAssetBridge(this.worker, 'clang', clangAssets, progress, limits.maxAssetBytes);
+                this.activeObjectiveCAssetsKey = nextObjectiveCAssetsKey;
+                this.worker.onmessage = (event) => {
+                    if (!this.workerSession.isActive(operation))
+                        return;
+                    if (this.assetBridge?.handleMessage(event))
+                        return;
+                    if (event.data?.progress != null)
+                        progress?.set?.(event.data.progress);
+                    if (event.data?.load)
+                        resolve();
+                    if (event.data?.error)
+                        reject(event.data.error);
+                };
+                this.worker.postMessage({
+                    load: true,
+                    log,
+                    code,
+                    args,
+                    clangAssets: {
+                        baseUrl: clangAssets.baseUrl,
+                        maxAssetBytes: limits.maxAssetBytes,
+                        useAssetBridge: clangAssets.useAssetBridge
+                    },
+                    objectivecAssets: {
+                        ...objectivecAssets,
+                        maxAssetBytes: limits.maxAssetBytes
+                    }
+                });
+            }
+            else {
+                this.assetBridge?.rebind(this.worker, clangAssets, progress, limits.maxAssetBytes);
+                this.worker.postMessage({ log });
+                resolve();
+            }
+        });
+    }
+    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;
+        }
+    }
+    run(code, prepare, log = this.log, prog, args = [], options = {}) {
+        if (options.debug)
+            requireSharedArrayBuffer('Objective-C debugging');
+        this.exit = false;
+        return new Promise((resolve, reject) => {
+            if (!this.worker)
+                return reject('Worker not loaded');
+            const operation = this.workerSession.beginRun(this.worker, reject);
+            const { compileArgs, programArgs } = resolveSandboxExecutionArgs(this.language, args, options);
+            this.setBreakpoints(options.debug ? [...(options.breakpoints || [])] : []);
+            const interrupt = new Uint8Array(this.interruptBuffer);
+            const _uid = ++this.uid;
+            const handler = (event) => {
+                if (!this.workerSession.isActive(operation))
+                    return;
+                if (this.assetBridge?.handleMessage(event))
+                    return;
+                if (!this.worker)
+                    return reject('Worker not loaded');
+                if (_uid !== this.uid)
+                    return (this.worker.onmessage = null);
+                const { output, results, log, error, buffer, progress, debugEvent } = event.data;
+                if (buffer) {
+                    this.waitingForInput = true;
+                    if (!prepare) {
+                        reportWorkerInputReady(prog, 'Objective-C runtime ready for input');
+                    }
+                    this.flushPendingInput();
+                }
+                if (output)
+                    this.output?.(output);
+                if (debugEvent)
+                    this.ondebug?.(debugEvent);
+                if (results) {
+                    this.elapse = Date.now() - this.begin;
+                    this.exit = true;
+                    this.waitingForInput = false;
+                    this.pendingEof = false;
+                    this.workerSession.complete(operation);
+                    this.ondebug?.({ type: 'stop' });
+                    resolve(results);
+                }
+                if (log)
+                    console.log(log);
+                if (error) {
+                    this.elapse = Date.now() - this.begin;
+                    this.waitingForInput = false;
+                    this.pendingEof = false;
+                    this.workerSession.complete(operation);
+                    this.exit = true;
+                    this.ondebug?.({ type: 'stop' });
+                    reject(error);
+                }
+                if (progress)
+                    prog?.set?.(progress);
+            };
+            this.worker.onmessage = handler;
+            interrupt[0] = 0;
+            this.begin = Date.now();
+            this.worker.postMessage({
+                code,
+                prepare,
+                buffer: this.buffer,
+                debugBuffer: this.debugBuffer,
+                watchBuffer: this.watchBuffer,
+                watchResultBuffer: this.watchResultBuffer,
+                interrupt: this.interruptBuffer,
+                stdin: options.stdin,
+                log,
+                compileArgs,
+                programArgs,
+                activePath: options.activePath,
+                workspaceFiles: options.workspaceFiles,
+                debug: !!options.debug,
+                breakpoints: [...(options.breakpoints || [])],
+                pauseOnEntry: !!options.pauseOnEntry
+            });
+        });
+    }
+    debugCommand(command) {
+        const control = new Int32Array(this.debugBuffer);
+        Atomics.store(control, 1, command === 'stepInto' ? 2 : command === 'nextLine' ? 3 : command === 'stepOut' ? 4 : 1);
+        Atomics.add(control, 0, 1);
+        Atomics.notify(control, 0);
+        this.ondebug?.({ type: 'resume', command });
+    }
+    setBreakpoints(lines) {
+        const control = new Int32Array(this.debugBuffer);
+        const next = [...new Set(lines.filter((line) => Number.isInteger(line) && line > 0))]
+            .sort((left, right) => left - right)
+            .slice(0, Math.max(0, control.length - 4));
+        for (let index = 4; index < control.length; index += 1) {
+            Atomics.store(control, index, next[index - 4] || 0);
+        }
+        Atomics.store(control, 3, next.length);
+        Atomics.add(control, 2, 1);
+    }
+    async debugEvaluate(expression) {
+        if (!this.worker)
+            throw new Error('Worker not loaded');
+        resetBufferedStdin(this.watchResultBuffer);
+        const previousSequence = bufferedSequence(this.watchResultBuffer);
+        flushQueuedStdin([expression], this.watchBuffer);
+        const control = new Int32Array(this.debugBuffer);
+        Atomics.store(control, 1, 5);
+        Atomics.add(control, 0, 1);
+        Atomics.notify(control, 0);
+        return ((await waitForBufferedSequenceChange(this.watchResultBuffer, previousSequence, 5000)) ??
+            '?');
+    }
+    kill() {
+        this.terminate();
+    }
+    terminate() {
+        this.waitingForInput = false;
+        this.pendingEof = false;
+        this.uid += 1;
+        new Uint8Array(this.interruptBuffer)[0] = 2;
+        const control = new Int32Array(this.debugBuffer);
+        Atomics.add(control, 0, 1);
+        Atomics.notify(control, 0);
+        this.workerSession.terminate();
+        this.exit = true;
+    }
+    async clear() {
+        this.terminate();
+        this.pendingInput = [];
+        this.waitingForInput = false;
+        this.pendingEof = false;
+        resetBufferedStdin(this.buffer);
+        resetBufferedStdin(this.watchBuffer);
+        resetBufferedStdin(this.watchResultBuffer);
+        new Int32Array(this.debugBuffer).fill(0);
+        await new Promise((resolve) => setTimeout(resolve, 200));
+    }
+}
+export default ObjectiveC;

package/dist/playground/ocaml.d.ts

@@ -1,10 +1,10 @@
 import { type PlaygroundRuntimeAssets } from './assets';
 import { type CompilerDiagnostic, type SandboxExecutionOptions } from './options';
-import type { Sandbox } from './sandbox';
+import type { Sandbox, SandboxProgress } from './sandbox';
 declare class Ocaml implements Sandbox {
     output: any;
     worker?: Worker;
-    buffer: SharedArrayBuffer;
+    buffer: import("./sharedBuffer").WasmIdleSharedBuffer;
     pendingInput: string[];
     begin: number;
     elapse: number;
@@ -12,21 +12,39 @@ declare class Ocaml implements Sandbox {
     exit: boolean;
     moduleUrl: string;
     manifestUrl: string;
-    activeReject: ((reason: string) => void) | null;
+    private moduleReceiptIdentity;
+    private manifestReceiptIdentity;
+    private maxAssetBytes;
     oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
     waitingForInput: boolean;
     pendingEof: boolean;
-    load(runtimeAssets?: string | PlaygroundRuntimeAssets, _code?: string, _log?: boolean, _args?: string[], _options?: SandboxExecutionOptions, progress?: {
-        set?: (value: number) => void;
-    } | import('svelte/store').Writable<number>): Promise<void>;
+    private activeOperation;
+    private disposed;
+    private disposePromise;
+    private readonly disposeCancellation;
+    private readonly workerSession;
+    private disposedConfigurationError;
+    private beginOperation;
+    private completeOperation;
+    private isOperationActive;
+    private ownsWorkerOperation;
+    private releaseBeforeSession;
+    private resolveOperationLimits;
+    private resetExplicitStdinState;
+    private finishExplicitStdin;
+    private abortReason;
+    private bindAbortSignal;
+    private bindOperationTimeout;
+    private cancelBeforeSession;
+    private abortOperation;
+    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?: {
-        set?: (value: number) => void;
-    } | import('svelte/store').Writable<number>, _args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
+    run(code: string, prepare: boolean, _log?: boolean, _prog?: SandboxProgress, _args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
     kill(): void;
-    terminate(): void;
+    terminate(reason?: unknown): void;
     clear(): Promise<void>;
+    dispose(): Promise<void>;
 }
 export default Ocaml;