wasm-idle 0.7.2 → 1.0.0

package/dist/playground/workerSession.js

@@ -0,0 +1,164 @@
+const scriptErrorMessage = (label, event) => {
+    const location = event.filename && event.lineno ? ` (${event.filename}:${event.lineno}:${event.colno})` : '';
+    return `${label} worker script error: ${event.message || 'unknown error'}${location}`;
+};
+export class WorkerSession {
+    options;
+    worker = null;
+    activeOperation = null;
+    constructor(options) {
+        this.options = options;
+    }
+    attach(worker, operation) {
+        if (operation !== undefined && !this.isActive(operation)) {
+            // A retired initializer must never replace the current operation's worker.
+            if (this.worker !== worker)
+                this.retireWorker(worker);
+            return null;
+        }
+        if (this.worker === worker)
+            return worker;
+        if (this.worker) {
+            const replacedWorker = this.disposeWorker();
+            if (replacedWorker)
+                this.notifyDisposed(replacedWorker);
+        }
+        if (operation !== undefined && !this.isActive(operation)) {
+            if (this.worker !== worker)
+                this.retireWorker(worker);
+            return null;
+        }
+        this.worker = worker;
+        worker.onerror = (event) => {
+            if (this.worker !== worker)
+                return;
+            this.fail(scriptErrorMessage(this.label, event));
+        };
+        worker.onmessageerror = () => {
+            if (this.worker !== worker)
+                return;
+            this.fail(`${this.label} worker message deserialization failed`);
+        };
+        return worker;
+    }
+    load(initialize) {
+        return new Promise((resolve, reject) => {
+            const token = this.startOperation('load', reject);
+            const resolveLoad = () => {
+                if (!this.complete(token))
+                    return;
+                resolve();
+            };
+            const rejectLoad = (reason) => {
+                if (!this.isActive(token))
+                    return;
+                this.fail(reason);
+            };
+            Promise.resolve()
+                .then(() => {
+                if (!this.isActive(token))
+                    return;
+                return initialize(resolveLoad, rejectLoad, token);
+            })
+                .catch(rejectLoad);
+        });
+    }
+    waitForLoad(worker, initialize) {
+        this.attach(worker);
+        return this.load(initialize);
+    }
+    beginRun(worker, reject) {
+        if (worker)
+            this.attach(worker);
+        return this.startOperation('run', reject);
+    }
+    complete(operation) {
+        if (!this.isActive(operation))
+            return false;
+        this.activeOperation = null;
+        return true;
+    }
+    release(worker) {
+        if (this.worker !== worker)
+            return false;
+        this.worker = null;
+        this.retireWorker(worker);
+        return true;
+    }
+    reset() {
+        const worker = this.disposeWorker();
+        if (worker)
+            this.notifyDisposed(worker);
+    }
+    terminate(reason = 'Process terminated') {
+        const activeOperation = this.activeOperation;
+        this.activeOperation = null;
+        const worker = this.disposeWorker();
+        if (worker)
+            this.notifyDisposed(worker);
+        activeOperation?.reject(reason);
+    }
+    get label() {
+        return typeof this.options.label === 'function' ? this.options.label() : this.options.label;
+    }
+    startOperation(kind, reject) {
+        const previousOperation = this.activeOperation;
+        const token = Symbol(kind);
+        this.activeOperation = { kind, token, reject };
+        previousOperation?.reject('Worker operation superseded');
+        return token;
+    }
+    isActive(operation) {
+        return this.activeOperation?.token === operation;
+    }
+    fail(reason) {
+        const activeOperation = this.activeOperation;
+        this.activeOperation = null;
+        const worker = this.disposeWorker();
+        if (worker)
+            this.notifyDisposed(worker);
+        activeOperation?.reject(reason);
+    }
+    notifyDisposed(worker) {
+        try {
+            this.options.onDispose?.(worker);
+        }
+        catch {
+            // Cleanup must not replace the worker operation result.
+        }
+    }
+    disposeWorker() {
+        const worker = this.worker;
+        if (!worker)
+            return null;
+        this.worker = null;
+        this.retireWorker(worker);
+        return worker;
+    }
+    retireWorker(worker) {
+        try {
+            worker.onmessage = null;
+        }
+        catch {
+            // Handler cleanup is best effort; the active operation must still settle.
+        }
+        try {
+            worker.onerror = null;
+        }
+        catch {
+            // Handler cleanup is best effort; the active operation must still settle.
+        }
+        try {
+            worker.onmessageerror = null;
+        }
+        catch {
+            // Handler cleanup is best effort; the active operation must still settle.
+        }
+        try {
+            worker.terminate();
+        }
+        catch {
+            // The worker is already detached; cleanup remains best effort.
+        }
+    }
+}

package/dist/playground/zig.d.ts

@@ -0,0 +1,46 @@
+import { type CompilerDiagnostic, type SandboxExecutionOptions } from './options';
+import { type PlaygroundRuntimeAssets } from './assets';
+import type { Sandbox, SandboxProgress } from './sandbox';
+declare class Zig implements Sandbox {
+    output: any;
+    worker?: Worker;
+    buffer: import("./sharedBuffer").WasmIdleSharedBuffer;
+    pendingInput: string[];
+    begin: number;
+    elapse: number;
+    uid: number;
+    exit: boolean;
+    compilerUrl: string;
+    stdlibUrl: string;
+    assetKey: string;
+    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 Zig;