wasm-idle 1.1.0 → 1.1.2

package/dist/playground/container/shell-control.js

@@ -0,0 +1,303 @@
+export const SHELL_CONTROL_COMMAND = 'wasm-idle-shell-control';
+export const SHELL_CONTROL_FUNCTION_ENV = 'BASH_FUNC___wasm_idle_poll%%';
+export const SHELL_CONTROL_ROUTE = `/usr/local/bin/${SHELL_CONTROL_COMMAND}`;
+export const SHELL_CONTROL_MOUNT = '/usr/share/wasm-idle-shell-control';
+export const SHELL_CONTROL_RCFILE = `${SHELL_CONTROL_MOUNT}/rcfile`;
+export const SHELL_CONTROL_REQUEST = '/tmp/.wasm-idle-shell-control-request';
+const SHELL_INPUTRC = '/tmp/.wasm-idle-shell-inputrc';
+const ADAPTER = 'website-shell-control-v1';
+const MAX_GENERATION = 2147483647;
+const encoder = new TextEncoder();
+const abortError = (message) => new DOMException(message, 'AbortError');
+const canonicalDirectory = (path) => path.length <= 4096 &&
+    path.startsWith('/') &&
+    !path.includes('\0') &&
+    (path === '/' ||
+        path
+            .slice(1)
+            .split('/')
+            .every((part) => part && part !== '.' && part !== '..'));
+function rcfile(session, languages) {
+    return [
+        '# Trusted application rcfile. The mailbox is data and is never evaluated.',
+        '__wasm_idle_poll() {',
+        '  local __wic_version __wic_session __wic_generation __wic_language __wic_extra __wic_oldpwd __wic_fd',
+        `  local __wic_expected_session='${session}'`,
+        // WASIX dup2 restoration loses stdin's polling rights. Read through a fresh
+        // descriptor instead of temporarily replacing the live terminal's fd 0.
+        `  [[ -f '${SHELL_CONTROL_REQUEST}' && -r '${SHELL_CONTROL_REQUEST}' ]] || return 0`,
+        `  if builtin exec {__wic_fd}< '${SHELL_CONTROL_REQUEST}'; then :; else return 0; fi`,
+        '  if IFS=\' \' builtin read -r -n 160 -u "$__wic_fd" __wic_version __wic_session __wic_generation __wic_language __wic_extra; then',
+        '    builtin exec {__wic_fd}<&-',
+        '  else',
+        '    builtin exec {__wic_fd}<&-',
+        '    return 0',
+        '  fi',
+        '  [[ "$__wic_version" == 1 && "$__wic_session" == "$__wic_expected_session" && -z "$__wic_extra" ]] || return 0',
+        '  [[ "$__wic_generation" =~ ^[1-9][0-9]{0,9}$ ]] || return 0',
+        `  (( __wic_generation <= ${MAX_GENERATION} && __wic_generation > \${__wasm_idle_control_generation:-0} )) || return 0`,
+        `  case "$__wic_language" in ${languages.join('|')}) ;; *) return 0 ;; esac`,
+        '  __wasm_idle_control_generation=$__wic_generation',
+        '  __wic_oldpwd=$PWD',
+        '  if builtin cd -P -- "/workspace/$__wic_language"; then',
+        `    if '${SHELL_CONTROL_ROUTE}' 1 "$__wic_session" "$__wic_generation" "$__wic_language" ok; then :; else :; fi`,
+        '    [[ "$__wic_oldpwd" != "$PWD" ]] && return 124',
+        '  else',
+        `    if '${SHELL_CONTROL_ROUTE}' 1 "$__wic_session" "$__wic_generation" "$__wic_language" failed; then :; else :; fi`,
+        '  fi',
+        '  return 0',
+        '}',
+        // The native primary Readline hook preserves both $? and PIPESTATUS.
+        // A PROMPT_COMMAND wrapper cannot restore PIPESTATUS and must not own polling.
+        'readonly -f __wasm_idle_poll',
+        ''
+    ].join('\n');
+}
+/** Host directory requests are read only at the producer's real primary-prompt boundary. */
+export function createShellControl(options) {
+    const languages = [...new Set(options.languages)].sort();
+    if (!languages.length || languages.some((language) => !/^[A-Z][A-Z0-9_]{0,63}$/.test(language)))
+        throw new Error('Shell control requires a fixed language allowlist');
+    const allowed = new Set(languages);
+    const session = options.session ??
+        Array.from(crypto.getRandomValues(new Uint8Array(16)), (byte) => byte.toString(16).padStart(2, '0')).join('');
+    if (!/^[a-f0-9]{32}$/.test(session))
+        throw new Error('Invalid shell control session');
+    let cwd = options.initialDirectory ?? '/workspace';
+    if (cwd !== '/workspace' && !languages.some((language) => cwd === `/workspace/${language}`))
+        throw new Error('Invalid initial shell directory');
+    let filesystem, disposed = false, generation = 0, appliedGeneration = 0;
+    let pending, error = null;
+    let lastAcknowledgement;
+    const inspect = () => Object.freeze({
+        ready: Boolean(filesystem),
+        disposed,
+        cwd,
+        pendingCwd: pending?.cwd ?? null,
+        generation,
+        appliedGeneration,
+        error
+    });
+    const changed = () => {
+        try {
+            options.onChange?.(inspect());
+        }
+        catch {
+            /* Observers do not own protocol state. */
+        }
+    };
+    const currentFilesystem = () => {
+        if (disposed)
+            throw new Error('Shell directory control has been disposed');
+        if (!filesystem)
+            throw new Error('Shell directory control has not been set up');
+        return filesystem;
+    };
+    const ensureDirectory = (fs, path) => {
+        if (fs.lstat('/workspace').type !== 'directory' ||
+            fs.realpath('/workspace') !== '/workspace')
+            throw new Error('Workspace root is not a directory');
+        try {
+            if (fs.lstat(path).type !== 'directory' || fs.realpath(path) !== path)
+                throw new Error('Shell directory must be an actual project directory');
+        }
+        catch (reason) {
+            if (reason.code !== 'ENOENT')
+                throw reason;
+            fs.mkdir(path);
+        }
+    };
+    const writeRequest = (fs, value) => {
+        if (fs.lstat('/tmp').type !== 'directory' || fs.realpath('/tmp') !== '/tmp')
+            throw new Error('Shell control needs the private temporary mount');
+        try {
+            if (fs.lstat(SHELL_CONTROL_REQUEST).type !== 'file')
+                throw new Error('Shell control mailbox must be a regular file');
+        }
+        catch (reason) {
+            if (reason.code !== 'ENOENT')
+                throw reason;
+        }
+        fs.writeFile(SHELL_CONTROL_REQUEST, encoder.encode(value), { mode: 0o600 });
+    };
+    const acknowledge = (args, actualCwd) => {
+        if (disposed ||
+            !filesystem ||
+            args.length !== 5 ||
+            args[0] !== '1' ||
+            args[1] !== session ||
+            !/^[1-9][0-9]{0,9}$/.test(args[2]) ||
+            !allowed.has(args[3]) ||
+            !['ok', 'failed'].includes(args[4]) ||
+            !canonicalDirectory(actualCwd))
+            return 126;
+        const received = Number(args[2]), language = args[3], verdict = args[4];
+        if (verdict === 'ok' && actualCwd !== `/workspace/${language}`)
+            return 126;
+        if (received > MAX_GENERATION || received > generation)
+            return 126;
+        if (received < generation)
+            return 0; // A superseded completion cannot publish the new request.
+        if (!pending)
+            return lastAcknowledgement?.generation === received &&
+                lastAcknowledgement.language === language &&
+                lastAcknowledgement.cwd === actualCwd &&
+                lastAcknowledgement.verdict === verdict
+                ? 0
+                : 126;
+        if (pending.language !== language || (verdict === 'ok' && actualCwd !== pending.cwd))
+            return 126;
+        const completed = pending;
+        pending = undefined;
+        cwd = actualCwd;
+        lastAcknowledgement = { generation: received, language, cwd: actualCwd, verdict };
+        if (verdict === 'ok') {
+            appliedGeneration = received;
+            error = null;
+            completed.resolve();
+        }
+        else {
+            error = `Bash could not enter ${completed.cwd}`;
+            completed.reject(new Error(error));
+        }
+        changed();
+        return 0;
+    };
+    const adapter = {
+        id: ADAPTER,
+        filesystem: 'live',
+        async start(request) {
+            if (request.fs !== currentFilesystem() ||
+                request.invocation.command !== SHELL_CONTROL_COMMAND)
+                throw new Error('Shell control command belongs to a different container');
+            const emptyOutput = () => new ReadableStream({
+                start(controller) {
+                    controller.close();
+                }
+            });
+            return {
+                stdin: new WritableStream({
+                    write(bytes) {
+                        if (bytes.length)
+                            throw new Error('Shell control does not consume program input');
+                    }
+                }),
+                stdout: emptyOutput(),
+                stderr: emptyOutput(),
+                async run() {
+                    return {
+                        code: request.signal.aborted
+                            ? 143
+                            : acknowledge(request.invocation.args, request.invocation.cwd)
+                    };
+                },
+                async dispose() { }
+            };
+        }
+    };
+    const commands = Object.freeze({
+        [SHELL_CONTROL_COMMAND]: Object.freeze({
+            adapter: ADAPTER,
+            bytes: new Uint8Array(),
+            argv0: SHELL_CONTROL_COMMAND
+        })
+    });
+    const configuration = Object.freeze({
+        mountPath: SHELL_CONTROL_MOUNT,
+        rcfilePath: SHELL_CONTROL_RCFILE,
+        requestPath: SHELL_CONTROL_REQUEST,
+        // The pinned WASIX host requests inherited write access even for O_RDONLY.
+        // Standard Bash function import bootstraps the trusted body without opening
+        // a readonly file; the opt-in producer makes this one imported function readonly.
+        args: Object.freeze(['--noprofile', '--norc', '-i']),
+        env: Object.freeze({
+            WASM_IDLE_SHELL_CONTROL: '1',
+            INPUTRC: SHELL_INPUTRC,
+            [SHELL_CONTROL_FUNCTION_ENV]: `() ${rcfile(session, languages).match(/__wasm_idle_poll\(\) (\{[\s\S]*?\n\})/)[1]}`
+        })
+    });
+    return Object.freeze({
+        adapter,
+        commands,
+        route: Object.freeze({ path: SHELL_CONTROL_ROUTE, command: SHELL_CONTROL_COMMAND }),
+        setup(fs) {
+            if (disposed)
+                throw new Error('Shell directory control has been disposed');
+            if (filesystem) {
+                if (filesystem !== fs)
+                    throw new Error('Shell control cannot share containers');
+                return configuration;
+            }
+            ensureDirectory(fs, cwd);
+            writeRequest(fs, `1 ${session} 0 -\n`);
+            // The pinned C locale otherwise interprets UTF-8 input as Meta keys.
+            // Keep this on the writable mount: WASIX overrequests rights on open.
+            fs.writeFile(SHELL_INPUTRC, encoder.encode('set input-meta on\nset convert-meta off\nset output-meta on\n'), { mode: 0o600 });
+            fs.mountReadonly(SHELL_CONTROL_MOUNT, [
+                {
+                    path: 'rcfile',
+                    type: 'file',
+                    mode: 0o444,
+                    data: encoder.encode(rcfile(session, languages))
+                }
+            ]);
+            filesystem = fs;
+            changed();
+            return configuration;
+        },
+        requestDirectory(language) {
+            try {
+                const fs = currentFilesystem();
+                if (!allowed.has(language))
+                    throw new Error('Unknown shell project directory');
+                if (pending?.language === language)
+                    return pending.promise;
+                if (generation === MAX_GENERATION)
+                    throw new Error('Shell directory generation exhausted');
+                const target = `/workspace/${language}`, nextGeneration = generation + 1;
+                ensureDirectory(fs, target);
+                writeRequest(fs, `1 ${session} ${nextGeneration} ${language}\n`);
+                pending?.reject(abortError('Shell directory request was superseded'));
+                let resolve, reject;
+                const promise = new Promise((yes, no) => {
+                    resolve = yes;
+                    reject = no;
+                });
+                pending = { language, cwd: target, promise, resolve, reject };
+                generation = nextGeneration;
+                error = null;
+                changed();
+                return promise;
+            }
+            catch (reason) {
+                return Promise.reject(reason);
+            }
+        },
+        onInvocation(invocation) {
+            return invocation.path === SHELL_CONTROL_ROUTE
+                ? acknowledge(invocation.argv.slice(1), invocation.cwd)
+                : undefined;
+        },
+        inspect,
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            pending?.reject(abortError('Shell directory control was disposed'));
+            pending = undefined;
+            if (filesystem) {
+                try {
+                    if (filesystem.lstat(SHELL_CONTROL_REQUEST).type === 'file' &&
+                        new TextDecoder()
+                            .decode(filesystem.readFile(SHELL_CONTROL_REQUEST))
+                            .startsWith(`1 ${session} `))
+                        filesystem.unlink(SHELL_CONTROL_REQUEST);
+                }
+                catch {
+                    /* The guest may already have removed the temporary mailbox. */
+                }
+            }
+            changed();
+        }
+    });
+}

package/dist/playground/container/workspace.d.ts

@@ -0,0 +1,8 @@
+import type { WorkspaceFile } from '../../../routes/workspaceCodec';
+/** Reconcile independent terminal edits without discarding an unpublished editor revision. */
+export declare function mergeContainerWorkspace(local: readonly WorkspaceFile[], baseline: readonly WorkspaceFile[], remote: readonly WorkspaceFile[], options?: {
+    acceptRemoteConflicts?: boolean;
+}): {
+    files: WorkspaceFile[];
+    conflicts: string[];
+};

package/dist/playground/container/workspace.js

@@ -0,0 +1,29 @@
+const same = (a, b) => a === b ||
+    (!!a && !!b && a.content === b.content && (a.encoding ?? 'utf-8') === (b.encoding ?? 'utf-8'));
+/** Reconcile independent terminal edits without discarding an unpublished editor revision. */
+export function mergeContainerWorkspace(local, baseline, remote, options = {}) {
+    const localByPath = new Map(local.map((file) => [file.path, file]));
+    const baseByPath = new Map(baseline.map((file) => [file.path, file]));
+    const remoteByPath = new Map(remote.map((file) => [file.path, file]));
+    const conflicts = [];
+    const files = [];
+    for (const path of new Set([
+        ...localByPath.keys(),
+        ...baseByPath.keys(),
+        ...remoteByPath.keys()
+    ])) {
+        const here = localByPath.get(path), before = baseByPath.get(path), there = remoteByPath.get(path);
+        let selected;
+        if (same(here, before))
+            selected = there;
+        else if (same(there, before) || same(here, there))
+            selected = here;
+        else {
+            conflicts.push(path);
+            selected = options.acceptRemoteConflicts ? there : here;
+        }
+        if (selected)
+            files.push({ ...selected });
+    }
+    return { files, conflicts };
+}

package/dist/playground/d.d.ts

@@ -1,4 +1,5 @@
 import { type PlaygroundRuntimeAssets, type ResolvedDRuntimeAssetConfig } from './assets';
+import { RuntimeAssetCache } from '@wasm-idle/core';
 import { type CompilerDiagnostic, type SandboxExecutionOptions } from './options';
 import type { Sandbox, SandboxProgress } from './sandbox';
 declare class D implements Sandbox {
@@ -19,6 +20,8 @@ declare class D implements Sandbox {
     pendingEof: boolean;
     private activeOperation;
     private disposed;
+    private runtimeAssetCache;
+    private ownsRuntimeAssetCache;
     private disposePromise;
     private readonly disposeCancellation;
     private readonly workerSession;
@@ -37,8 +40,10 @@ declare class D implements Sandbox {
     write(input: string): void;
     eof(): void;
     private flushPendingInput;
-    run(code: string, prepare: boolean, _log?: boolean, _prog?: SandboxProgress, args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
+    run(code: string, prepare: boolean, log?: boolean, progress?: SandboxProgress, args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
+    private runLoaded;
     private cancelOperation;
+    setRuntimeAssetCache(cache: RuntimeAssetCache): void;
     kill(): void;
     terminate(reason?: unknown): void;
     clear(): Promise<void>;

package/dist/playground/d.js

@@ -1,10 +1,12 @@
 import { resolveDRuntimeAssetConfig } from './assets';
-import { BusyError, CancelledError, createRuntimeAssetsKey, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, RuntimeConfigurationError, TimeoutError, resolveExecutionLimits, validateExecutionWorkspace } from '@wasm-idle/core';
+import { BusyError, CancelledError, createRuntimeAssetsKey, createRuntimeWasmModuleService, DEFAULT_WORKSPACE_LIMITS, DiagnosticLimitError, OutputLimitError, RuntimeConfigurationError, RuntimeAssetCache, TimeoutError, resolveExecutionLimits, validateExecutionWorkspace } from '@wasm-idle/core';
 import { resolveSandboxExecutionArgs } from './options';
 import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
 import { createWasmIdleSharedBuffer } from './sharedBuffer';
 import { WorkerSession } from './workerSession';
 import { reportWorkerInputReady, reportWorkerProgress } from './workerProgress';
+import { WASM_D_COMPILER_PROFILE } from './wasmDVersion';
+import { WASM_D_OUTER_ASSET_RECEIPTS } from './wasmDIntegrity';
 const OUTPUT_ENCODER = new TextEncoder();
 const abortReason = (signal, phase) => signal.reason !== undefined
     ? signal.reason
@@ -27,6 +29,8 @@ class D {
     pendingEof = false;
     activeOperation = null;
     disposed = false;
+    runtimeAssetCache = new RuntimeAssetCache();
+    ownsRuntimeAssetCache = true;
     disposePromise = null;
     disposeCancellation = new CancelledError('D sandbox disposed', {
         phase: 'dispose',
@@ -382,7 +386,19 @@ class D {
             this.waitingForInput = false;
         }
     }
-    run(code, prepare, _log = true, _prog, args = [], options = {}) {
+    async run(code, prepare, log = true, progress, args = [], options = {}) {
+        if (!this.worker && this.moduleUrl && this.outerIntegrity && !this.disposed) {
+            await this.load({
+                d: {
+                    moduleUrl: this.moduleUrl,
+                    manifestUrl: this.manifestUrl,
+                    integrity: this.outerIntegrity
+                }
+            }, '', log, [], options, progress);
+        }
+        return this.runLoaded(code, prepare, log, progress, args, options);
+    }
+    runLoaded(code, prepare, _log = true, _prog, args = [], options = {}) {
         let activeOperation;
         try {
             activeOperation = this.beginOperation('execute');
@@ -467,6 +483,12 @@ class D {
                 catch {
                     // Handler cleanup must not replace the operation result.
                 }
+                // Only immutable compiler modules survive an execution. Retire the worker, its
+                // Emscripten heaps, filesystem and compiled guest before the next run. A
+                // prepare-only call has executed no guest; keep its compiled artifact for
+                // the following execution instead of compiling the same source twice.
+                if (!prepare)
+                    this.workerSession.reset();
                 return true;
             };
             const failRun = (error, disposeWorker = false) => {
@@ -549,15 +571,58 @@ class D {
                 return;
             this.begin = Date.now();
             try {
-                worker.postMessage({
+                const modulePorts = {};
+                const profile = WASM_D_COMPILER_PROFILE;
+                // Custom runtime bundles keep their independent compiler path. A worker
+                // cannot choose the host's receipt, loader profile or authorization key.
+                if (typeof MessageChannel === 'function' &&
+                    this.outerIntegrity?.['runtime/runtime-manifest.v1.json'].sha256 ===
+                        profile.manifestSha256 &&
+                    this.outerIntegrity?.['index.js'].sha256 ===
+                        WASM_D_OUTER_ASSET_RECEIPTS['index.js'].sha256) {
+                    for (const kind of ['ldc2', 'lld']) {
+                        const service = createRuntimeWasmModuleService({
+                            cache: this.runtimeAssetCache,
+                            receipt: profile[kind],
+                            identity: JSON.stringify([
+                                'wasm-d-verified-compiler-v1',
+                                this.activeDAssetsKey,
+                                profile.version,
+                                profile.manifestSha256,
+                                kind,
+                                ...(kind === 'lld'
+                                    ? [
+                                        profile.lldProfile,
+                                        profile.lldLoaderSha256,
+                                        profile.lldDataSha256
+                                    ]
+                                    : [])
+                            ]),
+                            compileKey: kind === 'lld'
+                                ? 'emscripten-lld16-instantiate-v1'
+                                : 'ldc2-wasi-preview1-v1',
+                            maxAssetBytes: limits.maxAssetBytes,
+                            signal
+                        });
+                        activeOperation.cleanups.push(() => service.close());
+                        modulePorts[kind] = service.port;
+                    }
+                }
+                const message = {
                     code,
                     prepare,
                     buffer: this.buffer,
                     args: programArgs,
                     stdin,
                     fileName: workspace.activePath,
-                    log: _log
-                });
+                    log: _log,
+                    ...(modulePorts.ldc2 ? { compilerModulePorts: modulePorts } : {})
+                };
+                const transfers = Object.values(modulePorts);
+                if (transfers.length)
+                    worker.postMessage(message, transfers);
+                else
+                    worker.postMessage(message);
             }
             catch (error) {
                 failRun(error, true);
@@ -585,6 +650,17 @@ class D {
         this.workerSession.terminate(reason);
         this.cleanupOperation(operation);
     }
+    setRuntimeAssetCache(cache) {
+        if (cache === this.runtimeAssetCache)
+            return;
+        if (this.worker || this.activeOperation || this.disposed) {
+            throw new Error('Cannot replace the D runtime asset cache while its worker is active or disposed');
+        }
+        if (this.ownsRuntimeAssetCache)
+            this.runtimeAssetCache.dispose();
+        this.runtimeAssetCache = cache;
+        this.ownsRuntimeAssetCache = false;
+    }
     kill() {
         this.terminate();
     }
@@ -620,6 +696,8 @@ class D {
         if (this.disposePromise)
             return this.disposePromise;
         this.disposed = true;
+        if (this.ownsRuntimeAssetCache)
+            this.runtimeAssetCache.dispose();
         this.disposePromise = Promise.resolve();
         const activeOperation = this.activeOperation;
         delete this.worker;

package/dist/playground/dotnet.js

@@ -495,15 +495,13 @@ class Dotnet {
         const hasExplicitStdin = !prepare && explicitStdin !== undefined;
         if (runUid !== this.uid)
             return '';
-        if (!prepare &&
-            !hasExplicitStdin &&
-            this.pendingInput.length === 0 &&
-            !this.pendingEof &&
-            readsConsoleStdin(code)) {
+        if (!prepare && !hasExplicitStdin && !this.pendingEof && readsConsoleStdin(code)) {
             reportWorkerInputReady(progress, `${this.languageLabel} runtime ready for input`);
-            if (runUid !== this.uid)
-                return '';
-            await new Promise((resolve) => this.stdinWaiters.push(resolve));
+            // The program receives stdin as one string, so wait for EOF instead of
+            // starting with only the input written before the first chunk arrived.
+            while (runUid === this.uid && !this.pendingEof) {
+                await new Promise((resolve) => this.stdinWaiters.push(resolve));
+            }
         }
         if (runUid !== this.uid)
             return '';

package/dist/playground/fortran.d.ts

@@ -1,4 +1,5 @@
 import { WorkerAssetBridge } from './assetBridge';
+import type { RuntimeAssetCache } from './runtimeAssetCache';
 import { type PlaygroundRuntimeAssets } from './assets';
 import type { SandboxExecutionOptions } from './options';
 import type { Sandbox, SandboxProgress } from './sandbox';
@@ -18,6 +19,7 @@ declare class Fortran implements Sandbox {
     assetBridge: WorkerAssetBridge | null;
     activeFortranAssetsKey: string;
     private activeOperation;
+    private runtimeAssetCache?;
     private preserveOperationOnWorkerDispose;
     private disposed;
     private disposePromise;
@@ -25,6 +27,7 @@ declare class Fortran implements Sandbox {
     private readonly workerSession;
     private disposedConfigurationError;
     private requireOperationIdle;
+    setRuntimeAssetCache(cache: RuntimeAssetCache): void;
     private beginOperation;
     private isOperationActive;
     private releaseOperation;

package/dist/playground/fortran.js

@@ -37,6 +37,7 @@ class Fortran {
     assetBridge = null;
     activeFortranAssetsKey = '';
     activeOperation = null;
+    runtimeAssetCache;
     preserveOperationOnWorkerDispose = false;
     disposed = false;
     disposePromise = null;
@@ -88,6 +89,14 @@ class Fortran {
             });
         }
     }
+    setRuntimeAssetCache(cache) {
+        if (this.runtimeAssetCache === cache)
+            return;
+        if (this.disposed || this.worker || this.activeOperation) {
+            throw new RuntimeConfigurationError('Cannot replace an active Fortran compiler cache');
+        }
+        this.runtimeAssetCache = cache;
+    }
     beginOperation(phase) {
         this.requireOperationIdle();
         const operation = {
@@ -287,7 +296,7 @@ class Fortran {
                     }
                     let assetBridge;
                     try {
-                        assetBridge = new WorkerAssetBridge(worker, 'clang', clangAssets, progress, limits.maxAssetBytes);
+                        assetBridge = new WorkerAssetBridge(worker, 'clang', clangAssets, progress, limits.maxAssetBytes, false, this.runtimeAssetCache);
                         assetBridge.setExecutionPersistentCache(options.persistentCache);
                     }
                     catch (error) {

package/dist/playground/go.js

@@ -328,7 +328,7 @@ class Go {
                         worker.onmessage = null;
                     return;
                 }
-                const { output, results, error, buffer, diagnostic, progress, debugEvent, phase } = event.data;
+                const { output, results, error, fatal, buffer, diagnostic, progress, debugEvent, phase } = event.data;
                 if (phase === 'compile' || phase === 'execute') {
                     if (phase !== activePhase)
                         armTimeout(phase);
@@ -342,8 +342,12 @@ class Go {
                 reportWorkerProgress(_prog, progress);
                 if (output)
                     this.output(output);
+                // The worker compiles only the active source, which the compiler names main.go.
                 if (diagnostic)
-                    this.oncompilerdiagnostic?.(diagnostic);
+                    this.oncompilerdiagnostic?.(options.activePath &&
+                        /(?:^|[\\/])main\.go$/u.test(diagnostic.fileName ?? '')
+                        ? { ...diagnostic, fileName: options.activePath }
+                        : diagnostic);
                 if (debugEvent)
                     this.ondebug?.(debugEvent);
                 if (results) {
@@ -367,7 +371,14 @@ class Go {
                     this.waitingForInput = false;
                     this.pendingEof = false;
                     this.workerSession.complete(operation);
-                    this.ondebug?.({ type: 'stop' });
+                    if (fatal === true && this.worker === worker) {
+                        // The worker abandoned a program that may still be running; terminating
+                        // it stops that program, and disposal reports the debug stop.
+                        this.workerSession.reset();
+                    }
+                    else {
+                        this.ondebug?.({ type: 'stop' });
+                    }
                     reject(error);
                 }
             };