wasm-idle 1.0.12 → 1.1.2

package/dist/playground/container/binding.js

@@ -0,0 +1,247 @@
+import { createContainerWorkerClient } from './client';
+const copyFiles = (files) => files.map((file) => ({
+    path: file.path,
+    content: typeof file.content === 'string' ? file.content : Uint8Array.from(file.content)
+}));
+const bytes = (content) => typeof content === 'string' ? new TextEncoder().encode(content) : content;
+const equal = (left, right) => {
+    const a = bytes(left), b = bytes(right);
+    return a.length === b.length && a.every((byte, index) => byte === b[index]);
+};
+function sameFiles(left, right) {
+    return (left.length === right.length &&
+        left.every((file) => {
+            const other = right.find((candidate) => candidate.path === file.path);
+            return other && equal(file.content, other.content);
+        }));
+}
+/** Existing Terminal/Debug controls use this facade; every execution belongs to the owner Container. */
+export function createContainerPlaygroundBinding(runtimeAssets, options) {
+    let client, disposed = false;
+    const sandboxes = new Map();
+    const published = new Map();
+    const changes = new Set();
+    const queues = new Map();
+    let shellOutput;
+    let shellError;
+    let shellConnection;
+    let requestedShellLanguage;
+    const decoders = new Map();
+    const decoder = (key) => {
+        let value = decoders.get(key);
+        if (!value)
+            decoders.set(key, (value = new TextDecoder()));
+        return value;
+    };
+    const connection = () => {
+        if (disposed)
+            throw new Error('Container playground has been disposed');
+        if (client)
+            return client;
+        client =
+            options.clientFactory?.() ??
+                createContainerWorkerClient({
+                    runtimeAssets,
+                    applicationRootURL: options.applicationRootURL,
+                    workspaceId: options.workspaceId
+                });
+        client.onEvent((event) => {
+            if (event.name === 'workspace') {
+                for (const listener of changes)
+                    listener(event);
+                return;
+            }
+            if (event.name === 'shell-output') {
+                const data = event.data;
+                if (data.error)
+                    shellError?.(new Error(data.error));
+                if (data.bytes)
+                    shellOutput?.(decoder(`shell:${data.stream}`).decode(data.bytes, { stream: true }));
+                return;
+            }
+            const sandbox = event.language && sandboxes.get(event.language);
+            if (!sandbox)
+                return;
+            if (event.name === 'output')
+                sandbox.output?.(typeof event.data === 'string'
+                    ? event.data
+                    : decoder(event.language).decode(event.data, {
+                        stream: true
+                    }));
+            if (event.name === 'debug')
+                sandbox.ondebug?.(event.data);
+            if (event.name === 'diagnostic')
+                sandbox.oncompilerdiagnostic?.(event.data);
+            if (event.name === 'image')
+                sandbox.image?.(event.data);
+        });
+        return client;
+    };
+    const syncWorkspace = (language, files) => {
+        const snapshot = copyFiles(files);
+        const previous = queues.get(language) ?? Promise.resolve();
+        const next = previous
+            .catch(() => { })
+            .then(async () => {
+            const baseline = published.get(language);
+            if (baseline && sameFiles(baseline, snapshot))
+                return;
+            await connection().call('syncWorkspace', [
+                language,
+                snapshot,
+                baseline && copyFiles(baseline)
+            ]);
+            published.set(language, copyFiles(snapshot));
+        });
+        queues.set(language, next);
+        return next;
+    };
+    const shell = {
+        connect(output, error) {
+            shellOutput = output;
+            shellError = error;
+            return (shellConnection ??= (async () => {
+                const language = requestedShellLanguage ?? options.getLanguage?.() ?? 'CPP';
+                await queues.get(language)?.catch(() => { });
+                await connection().call('shellStart', [
+                    { cwd: `/workspace/${language}`, env: { PS1: '\\w $ ' } }
+                ]);
+            })());
+        },
+        async write(text) {
+            await shellConnection;
+            await connection().call('shellWrite', [text]);
+        },
+        async eof() {
+            await shellConnection;
+            await connection().call('shellEof');
+        },
+        async interrupt() {
+            await shellConnection;
+            await connection().call('shellInterrupt');
+        },
+        async dispose() {
+            if (client && !disposed)
+                await client.call('shellDispose');
+        }
+    };
+    const binding = {
+        async setShellDirectory(language) {
+            if (!/^[A-Z][A-Z0-9_]*$/.test(language))
+                throw new TypeError('Invalid shell language');
+            requestedShellLanguage = language;
+            // Selecting a language before Terminal mounts must not start a temporary shell.
+            if (!shellConnection)
+                return;
+            await shellConnection;
+            await connection().call('shellSetDirectory', [language]);
+        },
+        runtimeAssets,
+        terminalProps: undefined,
+        shell,
+        async load(language) {
+            let sandbox = sandboxes.get(language);
+            if (sandbox)
+                return sandbox;
+            const invoke = (method, args = [], execution, progress) => connection().call(method, [language, ...args], {
+                signal: execution?.signal,
+                progress
+            });
+            const record = {
+                runtimeAssets,
+                elapse: 0,
+                async load(code, log = true, args = [], execution = {}, progress) {
+                    await queues.get(language);
+                    await invoke('load', [code, log, args, execution], execution, progress);
+                },
+                async run(code, prepare, log = true, progress, args = [], execution = {}) {
+                    await queues.get(language);
+                    const started = performance.now();
+                    try {
+                        return await invoke(prepare ? 'prepare' : 'run', [code, log, args, execution], execution, progress);
+                    }
+                    finally {
+                        record.elapse = Math.round(performance.now() - started);
+                    }
+                },
+                async clear() {
+                    await invoke('clear');
+                },
+                async restart() {
+                    await invoke('restart');
+                },
+                async terminate() {
+                    await invoke('stop');
+                },
+                async kill() {
+                    await invoke('stop');
+                },
+                async dispose() {
+                    if (client && !disposed)
+                        await invoke('clear');
+                },
+                write(text) {
+                    void invoke('write', [text]).catch((error) => shellError?.(error));
+                },
+                eof() {
+                    void invoke('eof').catch((error) => shellError?.(error));
+                }
+            };
+            for (const method of [
+                'debugCommand',
+                'debugPause',
+                'setBreakpoints',
+                'debugEvaluate',
+                'debugVariables',
+                'debugScopes',
+                'debugFrameScopes',
+                'debugFrameName',
+                'debugReadMemory',
+                'debugWriteMemory',
+                'debugDataBreakpointInfo',
+                'debugSetDataBreakpoints'
+            ]) {
+                record[method] = (...args) => invoke(method, args);
+            }
+            sandboxes.set(language, record);
+            return record;
+        },
+        // Owner and command index can be ready without fetching compiler bodies at page boot.
+        async prewarm() {
+            connection();
+            return true;
+        },
+        async setPrewarmEnabled() { },
+        async cancelPrewarm() { },
+        syncWorkspace,
+        async readWorkspace(language) {
+            await queues.get(language)?.catch(() => { });
+            return await connection().call('readWorkspace', [language]);
+        },
+        async listWorkspaceFiles() {
+            return await connection().call('listWorkspaceFiles');
+        },
+        publishedWorkspace(language) {
+            return copyFiles(published.get(language) ?? []);
+        },
+        acceptWorkspace(language, files) {
+            published.set(language, copyFiles(files));
+        },
+        onWorkspaceChange(listener) {
+            changes.add(listener);
+            return () => changes.delete(listener);
+        },
+        async inspect() {
+            return await connection().call('inspect');
+        },
+        async dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            changes.clear();
+            await client?.dispose();
+        }
+    };
+    binding.terminalProps = { playground: binding, runtimeAssets };
+    return binding;
+}

package/dist/playground/container/clang-runtime.d.ts

@@ -0,0 +1,38 @@
+import type { Container } from '@wasm-idle/container';
+import { type SandboxExecutionOptions } from '../options';
+import type { ProgressLike } from '@wasm-idle/core';
+import type { ContainerWorkerEvent } from './protocol';
+import type { WebsiteRuntimeAdapter } from './runtime-adapter';
+type Profile = {
+    container: Container;
+    prepareCommand(invocation: unknown, signal: AbortSignal): Promise<void>;
+};
+/** The Run button uses the same real Clang command and artifacts as Bash. Debug uses its qualified backend. */
+export declare class WebsiteClangRuntime {
+    #private;
+    private readonly profile;
+    private readonly files;
+    private readonly emit;
+    constructor(profile: Profile, files: WebsiteRuntimeAdapter, emit: (event: ContainerWorkerEvent) => void);
+    private queue;
+    private key;
+    private drain;
+    private success;
+    private headerKey;
+    private discardHeader;
+    prepare(language: string, code: string, args: string[], options: SandboxExecutionOptions, signal: AbortSignal, progress: ProgressLike | undefined, requestId: number): Promise<boolean>;
+    run(language: string, code: string, args: string[], options: SandboxExecutionOptions, signal: AbortSignal, progress: ProgressLike | undefined, requestId: number): Promise<boolean>;
+    private flush;
+    write(language: string, text: string): Promise<void>;
+    eof(language: string): Promise<void>;
+    stop(language: string): Promise<void>;
+    clear(language: string): void;
+    inspect(): {
+        language: string;
+        phase: "run" | "prepare";
+        pid: number | undefined;
+        filesystem: string;
+    }[];
+    dispose(): Promise<void>;
+}
+export {};

package/dist/playground/container/clang-runtime.js

@@ -0,0 +1,343 @@
+import { resolveSandboxExecutionArgs } from '../options';
+/** The Run button uses the same real Clang command and artifacts as Bash. Debug uses its qualified backend. */
+export class WebsiteClangRuntime {
+    profile;
+    files;
+    emit;
+    #active = new Map();
+    #prepared = new Map();
+    #input = new Map();
+    #header;
+    constructor(profile, files, emit) {
+        this.profile = profile;
+        this.files = files;
+        this.emit = emit;
+    }
+    queue(language) {
+        let value = this.#input.get(language);
+        if (!value)
+            this.#input.set(language, (value = { chunks: [], size: 0, eof: false }));
+        return value;
+    }
+    key(language, code, args, options) {
+        return JSON.stringify([
+            language,
+            code,
+            args,
+            options.cppVersion,
+            options.cVersion,
+            options.compileArgs,
+            options.activePath,
+            options.env,
+            options.workspaceFiles
+        ]);
+    }
+    async drain(process, language, requestId, diagnostics = false, quiet = false) {
+        const output = async (stream, stderr) => {
+            const reader = stream.getReader(), decoder = new TextDecoder();
+            let pending = '';
+            try {
+                for (;;) {
+                    const { value, done } = await reader.read();
+                    const text = done ? decoder.decode() : decoder.decode(value, { stream: true });
+                    if (text && !quiet)
+                        this.emit({ language, name: 'output', data: text, requestId });
+                    if (stderr && diagnostics) {
+                        pending += text;
+                        const lines = pending.split('\n');
+                        pending = lines.pop() ?? '';
+                        for (const line of lines) {
+                            const match = /^(.*?):(\d+):(\d+): (fatal error|error|warning|note): (.*)$/.exec(line);
+                            if (match)
+                                this.emit({
+                                    language,
+                                    name: 'diagnostic',
+                                    requestId,
+                                    data: {
+                                        fileName: match[1].replace(`/workspace/${language}/`, '/workspace/'),
+                                        lineNumber: Number(match[2]),
+                                        columnNumber: Number(match[3]),
+                                        severity: match[4].includes('error')
+                                            ? 'error'
+                                            : match[4] === 'warning'
+                                                ? 'warning'
+                                                : 'other',
+                                        message: match[5]
+                                    }
+                                });
+                        }
+                        if (pending.length > 65536)
+                            pending = '';
+                    }
+                    if (done)
+                        break;
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+        };
+        const [result] = await Promise.all([
+            process.exited,
+            output(process.stdout, false),
+            output(process.stderr, true)
+        ]);
+        return result;
+    }
+    success(result, signal) {
+        if (signal.aborted)
+            throw signal.reason ?? new DOMException('Command cancelled', 'AbortError');
+        if (result.reason !== 'exited')
+            throw new Error(`Container command ended with ${result.reason}`);
+        return result.code === 0;
+    }
+    headerKey(language, code, compileArgs, options, cwd, standard) {
+        // A textual prefix and the fixed system headers are the only admitted inputs.
+        // Custom arguments, environment paths, or workspace headers can alter declarations.
+        if (language !== 'CPP' ||
+            compileArgs.length ||
+            Object.keys(options.env ?? {}).length ||
+            options.workspaceFiles?.some((file) => file.path !== options.activePath && !/\.(?:c|cc|cpp|cxx|wasm)$/i.test(file.path)))
+            return;
+        let rest = code.replace(/^\uFEFF/, '');
+        for (;;) {
+            rest = rest.replace(/^\s+/, '');
+            if (rest.startsWith('//')) {
+                const end = rest.indexOf('\n');
+                if (end < 0 || rest.slice(0, end).trimEnd().endsWith('\\'))
+                    return;
+                rest = rest.slice(end + 1);
+            }
+            else if (rest.startsWith('/*')) {
+                const end = rest.indexOf('*/', 2);
+                if (end < 0)
+                    return;
+                rest = rest.slice(end + 2);
+            }
+            else
+                break;
+        }
+        if (!/^#[ \t]*include[ \t]*<bits\/stdc\+\+\.h>/.test(rest))
+            return;
+        return JSON.stringify([cwd, standard, '-fno-exceptions']);
+    }
+    discardHeader() {
+        if (!this.#header)
+            return;
+        try {
+            this.profile.container.fs.unlink(this.#header.path);
+        }
+        catch {
+            /* Already removed. */
+        }
+        this.#header = undefined;
+    }
+    async prepare(language, code, args, options, signal, progress, requestId) {
+        if (this.#active.has(language))
+            throw new Error(`${language} already has an active command`);
+        const input = this.files.inputs(language, code, options);
+        const cwd = this.files.directory(language), artifact = `${cwd}/program.wasm`;
+        const job = { language, phase: 'prepare', signal };
+        this.#active.set(language, job);
+        this.#prepared.delete(language);
+        try {
+            progress?.report?.({
+                kind: 'activity',
+                phase: 'initializing',
+                label: 'Preparing the Clang toolchain'
+            });
+            await this.profile.prepareCommand({ path: '/usr/local/bin/clang' }, signal);
+            const { compileArgs } = resolveSandboxExecutionArgs(language, args, options);
+            const standard = language === 'CPP'
+                ? (options.cppVersion ?? 'CPP20').replace(/^CPP/, 'c++').toLowerCase()
+                : options.cVersion?.toLowerCase();
+            // An opaque response file or -x override can select C++ for a C editor.
+            // Keep its default source mode C while enabling the C++ driver's link libraries.
+            const override = compileArgs.some((arg) => arg.startsWith('@') || arg.startsWith('-x'));
+            const common = [
+                ...(language === 'CPP' || override ? ['--driver-mode=g++'] : []),
+                ...(language === 'C' && override ? ['-x', 'c'] : []),
+                ...(standard ? [`-std=${standard}`] : []),
+                '-fno-color-diagnostics',
+                '-fno-exceptions',
+                ...compileArgs
+            ];
+            const compile = async (argv, quiet = false) => {
+                job.process = await this.profile.container.spawn('clang', argv, {
+                    cwd,
+                    signal,
+                    env: options.env
+                });
+                const drained = this.drain(job.process, language, requestId, !quiet, quiet);
+                await job.process.stdin.getWriter().close();
+                const result = await drained;
+                if (job.stopped)
+                    throw new DOMException('Command cancelled', 'AbortError');
+                return this.success(result, signal);
+            };
+            const headerKey = this.headerKey(language, input.code, compileArgs, input.options, cwd, standard);
+            if (headerKey && this.#header?.key !== headerKey)
+                this.discardHeader();
+            let header = headerKey === this.#header?.key ? this.#header : undefined;
+            if (header) {
+                // Restore owned bytes instead of trusting a writable temporary file.
+                try {
+                    try {
+                        this.profile.container.fs.unlink(header.path);
+                    }
+                    catch {
+                        /* Already removed. */
+                    }
+                    this.profile.container.fs.writeFile(header.path, header.bytes);
+                }
+                catch {
+                    this.discardHeader();
+                    header = undefined;
+                }
+            }
+            let okay = await compile([
+                ...common,
+                ...(header ? ['-include-pch', header.path] : []),
+                input.options.activePath,
+                '-lc-printscan-long-double',
+                '-o',
+                artifact
+            ]);
+            if (header && okay)
+                progress?.set?.(95, 'Compiled with precompiled <bits/stdc++.h>');
+            else if (header) {
+                this.discardHeader();
+                okay = await compile([
+                    ...common,
+                    input.options.activePath,
+                    '-lc-printscan-long-double',
+                    '-o',
+                    artifact
+                ]);
+            }
+            if (okay && headerKey && !this.#header) {
+                const path = `/tmp/wasm-idle-stdcpp-${crypto.randomUUID()}.pch`;
+                try {
+                    if (await compile([
+                        ...common,
+                        '-c',
+                        '-x',
+                        'c++-header',
+                        '/usr/share/wasm-sysroot/include/bits/stdc++.h',
+                        '-o',
+                        path
+                    ], true)) {
+                        const bytes = this.profile.container.fs.readFile(path);
+                        if (bytes.byteLength > 0 && bytes.byteLength <= 32 * 1024 * 1024)
+                            this.#header = { key: headerKey, path, bytes };
+                    }
+                }
+                catch (error) {
+                    if (signal.aborted || job.stopped)
+                        throw error;
+                }
+                finally {
+                    if (this.#header?.path !== path) {
+                        try {
+                            this.profile.container.fs.unlink(path);
+                        }
+                        catch {
+                            /* No usable header. */
+                        }
+                    }
+                }
+            }
+            if (okay)
+                this.#prepared.set(language, this.key(language, input.code, args, options));
+            return okay;
+        }
+        finally {
+            if (this.#active.get(language) === job)
+                this.#active.delete(language);
+        }
+    }
+    async run(language, code, args, options, signal, progress, requestId) {
+        const input = this.files.inputs(language, code, options);
+        if (this.#prepared.get(language) !== this.key(language, input.code, args, options) &&
+            !(await this.prepare(language, code, args, options, signal, progress, requestId)))
+            return false;
+        const cwd = this.files.directory(language), job = { language, phase: 'run', signal };
+        if (this.#active.has(language))
+            throw new Error(`${language} already has an active command`);
+        this.#active.set(language, job);
+        try {
+            const { programArgs } = resolveSandboxExecutionArgs(language, args, options);
+            job.process = await this.profile.container.spawn('wasm-run', [`${cwd}/program.wasm`, ...programArgs], { cwd, signal, env: options.env });
+            job.writer = job.process.stdin.getWriter();
+            progress?.report?.({
+                kind: 'ready',
+                state: 'running',
+                reason: 'started',
+                label: 'Container program started'
+            });
+            const drained = this.drain(job.process, language, requestId);
+            if (options.stdin !== undefined) {
+                await job.writer.write(new TextEncoder().encode(options.stdin));
+                await job.writer.close();
+            }
+            else
+                await this.flush(language);
+            return this.success(await drained, signal);
+        }
+        finally {
+            job.writer?.releaseLock();
+            this.#input.delete(language);
+            if (this.#active.get(language) === job)
+                this.#active.delete(language);
+        }
+    }
+    async flush(language) {
+        const writer = this.#active.get(language)?.writer;
+        if (!writer)
+            return;
+        const queue = this.queue(language);
+        for (const text of queue.chunks.splice(0)) {
+            const bytes = new TextEncoder().encode(text);
+            await writer.write(bytes);
+            queue.size -= bytes.byteLength;
+        }
+        if (queue.eof) {
+            queue.eof = false;
+            await writer.close();
+        }
+    }
+    async write(language, text) {
+        const q = this.queue(language);
+        q.size += new TextEncoder().encode(text).length;
+        if (q.size > 8 * 1024 * 1024)
+            throw new Error('Pending stdin exceeds its limit');
+        q.chunks.push(text);
+        await this.flush(language);
+    }
+    async eof(language) {
+        this.queue(language).eof = true;
+        await this.flush(language);
+    }
+    async stop(language) {
+        this.#input.delete(language);
+        const job = this.#active.get(language);
+        if (job)
+            job.stopped = true;
+        await job?.process?.terminate();
+    }
+    clear(language) {
+        this.#input.delete(language);
+    }
+    inspect() {
+        return [...this.#active.values()].map((job) => ({
+            language: job.language,
+            phase: job.phase,
+            pid: job.process?.pid,
+            filesystem: 'live'
+        }));
+    }
+    async dispose() {
+        await Promise.allSettled([...this.#active.keys()].map((language) => this.stop(language)));
+        this.discardHeader();
+    }
+}

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

@@ -0,0 +1,15 @@
+import { type ContainerWorkerCallOptions, type ContainerWorkerEvent, type ContainerWorkerInitialization } from './protocol';
+export interface ContainerWorkerClient {
+    call<T = unknown>(method: string, args?: unknown[], options?: ContainerWorkerCallOptions): Promise<T>;
+    onEvent(listener: (event: ContainerWorkerEvent) => void): () => void;
+    dispose(): Promise<void>;
+}
+type OwnerWorker = Pick<Worker, 'postMessage' | 'addEventListener' | 'removeEventListener' | 'terminate'>;
+interface ClientOptions extends ContainerWorkerInitialization {
+    /** Injection is used only by deterministic transport tests. */
+    workerFactory?: () => OwnerWorker;
+    initializationTimeoutMs?: number;
+    cleanupDeadlineMs?: number;
+}
+export declare function createContainerWorkerClient(options: ClientOptions): ContainerWorkerClient;
+export {};