wasm-idle 0.7.2 → 1.0.0

package/dist/playground/octave.js

@@ -0,0 +1,783 @@
+import { resolveOctaveRuntimeAssetConfig } from './assets';
+import {} from './options';
+import { BusyError, CancelledError, DEFAULT_WORKSPACE_LIMITS, OutputLimitError, RuntimeConfigurationError, TimeoutError, resolveExecutionLimits, validateExecutionWorkspace } from '@wasm-idle/core';
+import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
+import { createWasmIdleSharedBuffer } from './sharedBuffer';
+import { WorkerSession } from './workerSession';
+import { reportWorkerProgress } from './workerProgress';
+const OUTPUT_ENCODER = new TextEncoder();
+class Octave {
+    output = null;
+    worker = null;
+    buffer = createWasmIdleSharedBuffer(1024);
+    pendingInput = [];
+    begin = 0;
+    elapse = 0;
+    uid = 0;
+    exit = true;
+    baseUrl = '';
+    workerUrl = '';
+    manifestUrl = '';
+    oncompilerdiagnostic;
+    waitingForInput = false;
+    pendingEof = false;
+    stdinWaiters = [];
+    activeLoad = null;
+    activeRun = null;
+    disposed = false;
+    disposePromise = null;
+    disposeCancellation = new CancelledError('Octave sandbox disposed', {
+        phase: 'dispose',
+        runtimeId: 'OCTAVE',
+        recoverable: false
+    });
+    workerSession = new WorkerSession({
+        label: 'Octave',
+        onDispose: (worker) => {
+            if (this.worker === worker)
+                delete this.worker;
+            this.exit = true;
+            this.waitingForInput = false;
+            this.pendingEof = false;
+        }
+    });
+    disposedConfigurationError() {
+        return new RuntimeConfigurationError('Octave sandbox is disposed', {
+            phase: 'dispose',
+            runtimeId: 'OCTAVE'
+        });
+    }
+    abortReason(signal, phase) {
+        const reason = signal.reason;
+        if (reason !== undefined)
+            return reason;
+        return new DOMException(phase === 'startup' ? 'Octave runtime startup aborted' : 'Octave execution aborted', 'AbortError');
+    }
+    load(runtimeAssets = '', _code = '', _log = true, _args = [], options = {}, progress) {
+        if (this.disposed)
+            return Promise.reject(this.disposedConfigurationError());
+        if (this.activeLoad || this.activeRun) {
+            return Promise.reject(new BusyError('Octave runtime already has an active operation', {
+                runtimeId: 'OCTAVE',
+                phase: this.activeLoad ? 'startup' : 'execute'
+            }));
+        }
+        const operation = {
+            token: Symbol('Octave load'),
+            phase: 'startup',
+            cancelled: false,
+            reject: () => undefined
+        };
+        this.activeLoad = operation;
+        let signal;
+        try {
+            signal = options.signal;
+            if (this.activeLoad?.token !== operation.token || operation.cancelled) {
+                return Promise.reject(operation.cancellationReason);
+            }
+            const signalAborted = signal?.aborted ?? false;
+            if (this.activeLoad?.token !== operation.token || operation.cancelled) {
+                return Promise.reject(operation.cancellationReason);
+            }
+            if (signalAborted && signal) {
+                const reason = this.abortReason(signal, 'startup');
+                if (this.activeLoad?.token !== operation.token || operation.cancelled) {
+                    return Promise.reject(operation.cancellationReason);
+                }
+                if (this.activeLoad?.token === operation.token)
+                    this.activeLoad = null;
+                return Promise.reject(reason);
+            }
+        }
+        catch (error) {
+            if (this.activeLoad?.token === operation.token)
+                this.activeLoad = null;
+            return Promise.reject(operation.cancelled ? operation.cancellationReason : error);
+        }
+        let cleanup = () => {
+            if (this.activeLoad?.token === operation.token)
+                this.activeLoad = null;
+        };
+        const loading = new Promise((resolve, reject) => {
+            let onAbort;
+            let listenerRegistered = false;
+            let cleanedUp = false;
+            const ownsLoad = () => this.activeLoad?.token === operation.token;
+            cleanup = () => {
+                if (cleanedUp)
+                    return;
+                cleanedUp = true;
+                if (ownsLoad())
+                    this.activeLoad = null;
+                if (signal && onAbort && listenerRegistered) {
+                    listenerRegistered = false;
+                    try {
+                        signal.removeEventListener('abort', onAbort);
+                    }
+                    catch {
+                        // Listener cleanup must not replace the startup result.
+                    }
+                }
+            };
+            const rejectLoad = (reason) => {
+                if (!ownsLoad()) {
+                    cleanup();
+                    return;
+                }
+                cleanup();
+                reject(reason);
+            };
+            operation.reject = rejectLoad;
+            onAbort = signal
+                ? () => {
+                    if (this.disposed || operation.cancelled || !ownsLoad())
+                        return;
+                    let reason;
+                    try {
+                        reason = this.abortReason(signal, 'startup');
+                    }
+                    catch (error) {
+                        reason = error;
+                    }
+                    rejectLoad(reason);
+                }
+                : undefined;
+            if (signal && onAbort) {
+                try {
+                    listenerRegistered = true;
+                    signal.addEventListener('abort', onAbort, { once: true });
+                }
+                catch (error) {
+                    rejectLoad(error);
+                    return;
+                }
+                if (!ownsLoad()) {
+                    cleanup();
+                    return;
+                }
+                let signalAborted;
+                try {
+                    signalAborted = signal.aborted;
+                }
+                catch (error) {
+                    rejectLoad(error);
+                    return;
+                }
+                if (!ownsLoad()) {
+                    cleanup();
+                    return;
+                }
+                if (signalAborted)
+                    onAbort();
+            }
+            if (!ownsLoad())
+                return;
+            try {
+                const currentUrl = typeof window !== 'undefined' ? window.location.href : '';
+                let resolverAssets = runtimeAssets;
+                if (typeof runtimeAssets === 'object') {
+                    const source = runtimeAssets.octave;
+                    if (!ownsLoad())
+                        return;
+                    let octave;
+                    if (source) {
+                        const baseUrl = source.baseUrl;
+                        if (!ownsLoad())
+                            return;
+                        const workerUrl = source.workerUrl;
+                        if (!ownsLoad())
+                            return;
+                        const manifestUrl = source.manifestUrl;
+                        if (!ownsLoad())
+                            return;
+                        octave = { baseUrl, workerUrl, manifestUrl };
+                    }
+                    let rootUrl;
+                    let rootUrlRead = false;
+                    resolverAssets = {
+                        get rootUrl() {
+                            if (!rootUrlRead) {
+                                rootUrlRead = true;
+                                rootUrl = runtimeAssets.rootUrl;
+                            }
+                            return rootUrl;
+                        },
+                        octave
+                    };
+                }
+                const config = resolveOctaveRuntimeAssetConfig(resolverAssets, currentUrl);
+                if (!ownsLoad())
+                    return;
+                progress?.set?.(1);
+                if (!ownsLoad())
+                    return;
+                this.pendingInput = [];
+                this.waitingForInput = false;
+                this.pendingEof = false;
+                this.baseUrl = config.baseUrl;
+                this.workerUrl = config.workerUrl;
+                this.manifestUrl = config.manifestUrl;
+                cleanup();
+                resolve();
+            }
+            catch (error) {
+                rejectLoad(error);
+            }
+        });
+        return loading.finally(() => cleanup());
+    }
+    write(input) {
+        if (this.disposed)
+            return;
+        this.pendingInput.push(input);
+        this.pendingEof = false;
+        this.resolveStdinWaiters();
+        this.flushPendingInput();
+    }
+    eof() {
+        if (this.disposed)
+            return;
+        this.pendingEof = true;
+        this.resolveStdinWaiters();
+        this.flushPendingInput();
+    }
+    resolveStdinWaiters() {
+        const waiters = this.stdinWaiters.splice(0);
+        for (const resolve of waiters) {
+            try {
+                resolve();
+            }
+            catch {
+                // A public waiter cannot prevent lifecycle cleanup.
+            }
+        }
+    }
+    readsOctaveStdin(code) {
+        return /\bstdin\b|\binput\s*\(/.test(code);
+    }
+    async collectStdinForRun(code, stdinOption, ownsRun, progress) {
+        if (typeof stdinOption !== 'string' &&
+            this.pendingInput.length === 0 &&
+            !this.pendingEof &&
+            this.readsOctaveStdin(code)) {
+            await new Promise((resolve) => {
+                this.stdinWaiters.push(resolve);
+                progress?.report?.({
+                    kind: 'ready',
+                    state: 'waiting-input',
+                    reason: 'stdin-request',
+                    label: 'Octave is waiting for terminal input before starting'
+                });
+            });
+        }
+        if (!ownsRun())
+            return undefined;
+        if (typeof stdinOption === 'string')
+            return stdinOption;
+        if (!this.readsOctaveStdin(code))
+            return undefined;
+        const stdin = this.pendingInput.join('');
+        this.pendingInput = [];
+        this.pendingEof = false;
+        return stdin;
+    }
+    flushPendingInput(buffer = this.activeRun?.buffer ?? this.buffer) {
+        if (!this.waitingForInput)
+            return;
+        if (flushQueuedStdin(this.pendingInput, buffer)) {
+            this.waitingForInput = false;
+            return;
+        }
+        if (this.pendingEof) {
+            flushBufferedEof(buffer);
+            this.pendingEof = false;
+            this.waitingForInput = false;
+        }
+    }
+    createWorker(workerUrl, ownsRun) {
+        if (this.worker) {
+            this.workerSession.reset();
+        }
+        if (!ownsRun())
+            return null;
+        this.exit = false;
+        const worker = new Worker(workerUrl);
+        if (!ownsRun()) {
+            worker.terminate();
+            return null;
+        }
+        this.worker = worker;
+        this.workerSession.attach(worker);
+        if (!ownsRun() || this.worker !== worker) {
+            if (this.worker === worker)
+                delete this.worker;
+            this.workerSession.release(worker);
+            return null;
+        }
+        return worker;
+    }
+    run(code, prepare, _log = true, _prog, args = [], options = {}) {
+        if (this.disposed)
+            return Promise.reject(this.disposedConfigurationError());
+        if (this.activeLoad || this.activeRun) {
+            return Promise.reject(new BusyError('Octave runtime already has an active operation', {
+                runtimeId: 'OCTAVE',
+                phase: this.activeLoad ? 'startup' : 'execute'
+            }));
+        }
+        if (prepare)
+            return Promise.resolve(true);
+        if (!this.baseUrl || !this.workerUrl || !this.manifestUrl) {
+            return Promise.reject('Octave runtime is not configured.');
+        }
+        const runOperation = {
+            token: Symbol('Octave run'),
+            phase: 'execute',
+            cancelled: false
+        };
+        this.activeRun = runOperation;
+        const ownsSnapshot = () => this.activeRun?.token === runOperation.token && !runOperation.cancelled;
+        let signal;
+        let programArgs;
+        let limits;
+        let workspace;
+        let stdinOption;
+        let baseUrl;
+        let workerUrl;
+        let manifestUrl;
+        let buffer;
+        try {
+            signal = options.signal;
+            if (!ownsSnapshot())
+                return Promise.reject(runOperation.cancellationReason);
+            const signalAborted = signal?.aborted ?? false;
+            if (!ownsSnapshot())
+                return Promise.reject(runOperation.cancellationReason);
+            if (signalAborted && signal) {
+                const reason = this.abortReason(signal, 'execute');
+                if (!ownsSnapshot())
+                    return Promise.reject(runOperation.cancellationReason);
+                if (this.activeRun?.token === runOperation.token)
+                    this.activeRun = null;
+                return Promise.reject(reason);
+            }
+            const configuredProgramArgs = options.programArgs;
+            if (!ownsSnapshot())
+                return Promise.reject(runOperation.cancellationReason);
+            const selectedProgramArgs = configuredProgramArgs ?? args;
+            programArgs = Array.isArray(selectedProgramArgs) ? [...selectedProgramArgs] : [];
+            if (!ownsSnapshot())
+                return Promise.reject(runOperation.cancellationReason);
+            const limitOverrides = options.limits;
+            if (!ownsSnapshot())
+                return Promise.reject(runOperation.cancellationReason);
+            limits = resolveExecutionLimits(limitOverrides);
+            if (!ownsSnapshot())
+                return Promise.reject(runOperation.cancellationReason);
+            const workspaceFiles = options.workspaceFiles ?? [];
+            if (!ownsSnapshot())
+                return Promise.reject(runOperation.cancellationReason);
+            const activePath = options.activePath ?? 'main.m';
+            if (!ownsSnapshot())
+                return Promise.reject(runOperation.cancellationReason);
+            const workspaceLimits = options.workspaceLimits;
+            if (!ownsSnapshot())
+                return Promise.reject(runOperation.cancellationReason);
+            workspace = validateExecutionWorkspace(code, workspaceFiles, activePath, {
+                ...workspaceLimits,
+                maxFileBytes: Math.min(workspaceLimits?.maxFileBytes ?? DEFAULT_WORKSPACE_LIMITS.maxFileBytes, limits.maxWorkspaceBytes),
+                maxTotalBytes: Math.min(workspaceLimits?.maxTotalBytes ?? DEFAULT_WORKSPACE_LIMITS.maxTotalBytes, limits.maxWorkspaceBytes)
+            });
+            if (!ownsSnapshot())
+                return Promise.reject(runOperation.cancellationReason);
+            stdinOption = options.stdin;
+            if (!ownsSnapshot())
+                return Promise.reject(runOperation.cancellationReason);
+            baseUrl = this.baseUrl;
+            if (!ownsSnapshot())
+                return Promise.reject(runOperation.cancellationReason);
+            workerUrl = this.workerUrl;
+            if (!ownsSnapshot())
+                return Promise.reject(runOperation.cancellationReason);
+            manifestUrl = this.manifestUrl;
+            if (!ownsSnapshot())
+                return Promise.reject(runOperation.cancellationReason);
+            buffer = this.buffer;
+            if (!ownsSnapshot())
+                return Promise.reject(runOperation.cancellationReason);
+            runOperation.buffer = buffer;
+        }
+        catch (error) {
+            if (this.activeRun?.token === runOperation.token)
+                this.activeRun = null;
+            return Promise.reject(runOperation.cancelled ? runOperation.cancellationReason : error);
+        }
+        const hasExplicitStdin = stdinOption !== undefined;
+        if (hasExplicitStdin) {
+            try {
+                resetBufferedStdin(buffer);
+                if (!ownsSnapshot())
+                    return Promise.reject(runOperation.cancellationReason);
+                runOperation.stdinBuffer = buffer;
+                this.pendingInput = [];
+                this.waitingForInput = false;
+                this.pendingEof = false;
+                this.resolveStdinWaiters();
+            }
+            catch (error) {
+                if (this.activeRun?.token === runOperation.token) {
+                    this.activeRun = null;
+                    this.pendingInput = [];
+                    this.waitingForInput = false;
+                    this.pendingEof = false;
+                    this.exit = true;
+                    this.resolveStdinWaiters();
+                }
+                return Promise.reject(runOperation.cancelled ? runOperation.cancellationReason : error);
+            }
+        }
+        const runToken = runOperation.token;
+        this.exit = false;
+        return new Promise((resolve, reject) => {
+            const _uid = ++this.uid;
+            let outputBytes = 0;
+            let onAbort;
+            let timeout;
+            let cleanedUp = false;
+            const cleanup = () => {
+                if (cleanedUp)
+                    return;
+                cleanedUp = true;
+                if (timeout !== undefined) {
+                    const ownedTimeout = timeout;
+                    timeout = undefined;
+                    try {
+                        clearTimeout(ownedTimeout);
+                    }
+                    catch {
+                        // Timer cleanup must not replace the execution result.
+                    }
+                }
+                const ownsRun = this.activeRun?.token === runToken;
+                if (ownsRun) {
+                    this.activeRun = null;
+                    this.exit = true;
+                    this.waitingForInput = false;
+                    this.pendingEof = false;
+                }
+                if (ownsRun && runOperation.stdinBuffer) {
+                    this.pendingInput = [];
+                    this.resolveStdinWaiters();
+                    try {
+                        resetBufferedStdin(runOperation.stdinBuffer);
+                    }
+                    catch {
+                        // Stdin cleanup must not replace the execution result.
+                    }
+                }
+                if (signal && onAbort) {
+                    try {
+                        signal.removeEventListener('abort', onAbort);
+                    }
+                    catch {
+                        // Cleanup must not replace the execution result.
+                    }
+                }
+            };
+            const rejectRun = (reason) => {
+                cleanup();
+                reject(reason);
+            };
+            const operation = this.workerSession.beginRun(null, rejectRun);
+            onAbort = signal
+                ? () => {
+                    if (this.disposed ||
+                        this.activeRun?.token !== runToken ||
+                        runOperation.cancelled ||
+                        _uid !== this.uid) {
+                        cleanup();
+                        return;
+                    }
+                    let reason;
+                    try {
+                        reason = this.abortReason(signal, 'execute');
+                    }
+                    catch (error) {
+                        reason = error;
+                    }
+                    if (this.activeRun?.token !== runToken ||
+                        runOperation.cancelled ||
+                        _uid !== this.uid) {
+                        cleanup();
+                        return;
+                    }
+                    this.terminate(reason);
+                }
+                : undefined;
+            if (signal && onAbort) {
+                try {
+                    signal.addEventListener('abort', onAbort, { once: true });
+                }
+                catch (error) {
+                    if (this.activeRun?.token === runToken &&
+                        !runOperation.cancelled &&
+                        _uid === this.uid) {
+                        this.terminate(error);
+                    }
+                    else {
+                        cleanup();
+                    }
+                }
+            }
+            if (this.activeRun?.token !== runToken || runOperation.cancelled || _uid !== this.uid) {
+                return;
+            }
+            if (signal && onAbort) {
+                let signalAborted;
+                try {
+                    signalAborted = signal.aborted;
+                }
+                catch (error) {
+                    if (this.activeRun?.token === runToken &&
+                        !runOperation.cancelled &&
+                        _uid === this.uid) {
+                        this.terminate(error);
+                    }
+                    else {
+                        cleanup();
+                    }
+                    return;
+                }
+                if (this.activeRun?.token !== runToken ||
+                    runOperation.cancelled ||
+                    _uid !== this.uid) {
+                    return;
+                }
+                if (signalAborted)
+                    onAbort();
+            }
+            if (this.activeRun?.token !== runToken || runOperation.cancelled || _uid !== this.uid) {
+                return;
+            }
+            const timeoutMs = Math.min(2_147_483_647, limits.assetTimeoutMs +
+                limits.startupTimeoutMs +
+                limits.compileTimeoutMs +
+                limits.runTimeoutMs);
+            try {
+                timeout = setTimeout(() => {
+                    if (this.activeRun?.token !== runToken ||
+                        runOperation.cancelled ||
+                        _uid !== this.uid) {
+                        return;
+                    }
+                    this.terminate(new TimeoutError(`Octave execution timed out after ${timeoutMs} ms`, {
+                        phase: 'execute',
+                        runtimeId: 'OCTAVE',
+                        timeoutMs
+                    }));
+                }, timeoutMs);
+            }
+            catch (error) {
+                if (this.activeRun?.token === runToken &&
+                    !runOperation.cancelled &&
+                    _uid === this.uid) {
+                    this.terminate(error);
+                }
+                else {
+                    cleanup();
+                }
+                return;
+            }
+            this.begin = Date.now();
+            this.collectStdinForRun(code, stdinOption, ownsSnapshot, _prog)
+                .then((stdin) => {
+                if (this.activeRun?.token !== runToken ||
+                    runOperation.cancelled ||
+                    _uid !== this.uid) {
+                    return;
+                }
+                const ownsCreation = () => this.activeRun?.token === runToken &&
+                    !runOperation.cancelled &&
+                    _uid === this.uid;
+                const worker = this.createWorker(workerUrl, ownsCreation);
+                if (!worker)
+                    return;
+                let handler;
+                const ownsRun = () => this.activeRun?.token === runToken &&
+                    !runOperation.cancelled &&
+                    this.worker === worker &&
+                    worker.onmessage === handler &&
+                    _uid === this.uid;
+                const failRun = (error) => {
+                    if (!ownsRun())
+                        return;
+                    this.workerSession.terminate(error);
+                };
+                handler = (event) => {
+                    if (!ownsRun())
+                        return;
+                    try {
+                        const { output, results, error, buffer, progress } = event.data;
+                        if (buffer) {
+                            if (!prepare) {
+                                _prog?.report?.({
+                                    kind: 'ready',
+                                    state: 'waiting-input',
+                                    reason: 'stdin-request',
+                                    label: 'Octave program is waiting for input'
+                                });
+                            }
+                            this.waitingForInput = true;
+                            this.flushPendingInput();
+                            if (!ownsRun())
+                                return;
+                        }
+                        reportWorkerProgress(_prog, progress);
+                        if (!ownsRun())
+                            return;
+                        if (output) {
+                            const actual = outputBytes + OUTPUT_ENCODER.encode(String(output)).byteLength;
+                            if (actual > limits.maxOutputBytes) {
+                                failRun(new OutputLimitError(`Octave output exceeded ${limits.maxOutputBytes} bytes`, {
+                                    actual,
+                                    limit: limits.maxOutputBytes,
+                                    phase: 'execute',
+                                    runtimeId: 'OCTAVE'
+                                }));
+                                return;
+                            }
+                            outputBytes = actual;
+                            this.output?.(output);
+                        }
+                        if (!ownsRun())
+                            return;
+                        if (results) {
+                            if (worker.onmessage === handler)
+                                worker.onmessage = null;
+                            this.workerSession.complete(operation);
+                            this.elapse = Date.now() - this.begin;
+                            cleanup();
+                            resolve(true);
+                            return;
+                        }
+                        if (error) {
+                            if (worker.onmessage === handler)
+                                worker.onmessage = null;
+                            this.workerSession.complete(operation);
+                            this.elapse = Date.now() - this.begin;
+                            cleanup();
+                            reject(error);
+                            return;
+                        }
+                    }
+                    catch (error) {
+                        failRun(error);
+                    }
+                };
+                worker.onmessage = handler;
+                worker.postMessage({
+                    run: true,
+                    baseUrl,
+                    manifestUrl,
+                    buffer,
+                    code,
+                    args: programArgs,
+                    stdin,
+                    activePath: workspace.activePath,
+                    workspaceFiles: workspace.workspaceFiles,
+                    log: _log
+                });
+            })
+                .catch((error) => {
+                if (this.activeRun?.token !== runToken ||
+                    runOperation.cancelled ||
+                    _uid !== this.uid) {
+                    return;
+                }
+                this.terminate(error);
+            });
+        });
+    }
+    kill() {
+        this.terminate();
+    }
+    terminateOwned(reason) {
+        const activeLoad = this.activeLoad;
+        const activeRun = this.activeRun;
+        if (activeLoad) {
+            activeLoad.cancelled = true;
+            activeLoad.cancellationReason = reason;
+        }
+        if (activeRun) {
+            activeRun.cancelled = true;
+            activeRun.cancellationReason = reason;
+            if (this.activeRun?.token === activeRun.token)
+                this.activeRun = null;
+        }
+        if (activeRun?.stdinBuffer) {
+            this.pendingInput = [];
+        }
+        if (activeRun?.buffer) {
+            try {
+                resetBufferedStdin(activeRun.buffer);
+            }
+            catch {
+                // Stdin cleanup must not replace the termination result.
+            }
+        }
+        this.waitingForInput = false;
+        this.pendingEof = false;
+        this.uid += 1;
+        this.resolveStdinWaiters();
+        this.exit = true;
+        this.workerSession.terminate(reason);
+        if (activeLoad) {
+            activeLoad.reject(reason);
+            if (this.activeLoad?.token === activeLoad.token)
+                this.activeLoad = null;
+        }
+    }
+    terminate(reason = 'Process terminated') {
+        if (this.disposed)
+            return;
+        this.terminateOwned(reason);
+    }
+    async clear() {
+        if (this.disposed)
+            return;
+        this.pendingInput = [];
+        this.waitingForInput = false;
+        this.pendingEof = false;
+        this.resolveStdinWaiters();
+        if (this.worker)
+            this.worker.onmessage = null;
+        resetBufferedStdin(this.buffer);
+        if (!this.exit || this.activeLoad || this.activeRun) {
+            this.terminate();
+        }
+    }
+    dispose() {
+        if (this.disposePromise)
+            return this.disposePromise;
+        this.disposed = true;
+        this.disposePromise = Promise.resolve();
+        delete this.worker;
+        this.baseUrl = '';
+        this.workerUrl = '';
+        this.manifestUrl = '';
+        this.output = undefined;
+        this.oncompilerdiagnostic = undefined;
+        this.pendingInput = [];
+        this.waitingForInput = false;
+        this.pendingEof = false;
+        try {
+            resetBufferedStdin(this.buffer);
+        }
+        catch {
+            // The shared stdin buffer is already outside the live host state.
+        }
+        this.terminateOwned(this.disposeCancellation);
+        return this.disposePromise;
+    }
+}
+export default Octave;