wasm-idle 1.1.0 → 1.1.2

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 {};

package/dist/playground/container/client.js

@@ -0,0 +1,189 @@
+import { CONTAINER_WORKER_PROTOCOL, OWNER_CLEANUP_DEADLINE_MS, snapshotContainerArguments } from './protocol';
+export function createContainerWorkerClient(options) {
+    const channel = crypto.randomUUID();
+    const worker = options.workerFactory?.() ??
+        new Worker(new URL('./owner.worker.ts', import.meta.url), {
+            type: 'module',
+            name: 'wasm-idle-container-owner'
+        });
+    const listeners = new Set();
+    const pending = new Map();
+    let nextId = 1, disposed = false, disposal;
+    let retirementError;
+    const cleanupDeadlineMs = options.cleanupDeadlineMs ?? OWNER_CLEANUP_DEADLINE_MS;
+    const abortError = () => new DOMException('Container operation cancelled', 'AbortError');
+    const post = (data) => worker.postMessage(data);
+    const retire = (error) => {
+        if (disposed)
+            return;
+        retirementError = error;
+        disposed = true;
+        worker.removeEventListener('message', message);
+        worker.removeEventListener('error', crash);
+        worker.removeEventListener('messageerror', crash);
+        worker.terminate();
+        for (const entry of pending.values()) {
+            entry.cleanup();
+            entry.reject(error);
+        }
+        pending.clear();
+        listeners.clear();
+    };
+    const crash = (event) => {
+        if (event.type === 'messageerror') {
+            retire(new Error('The container owner Worker message could not be decoded'));
+            return;
+        }
+        const failure = event;
+        retire(failure.error ?? new Error(failure.message || 'The container owner Worker crashed'));
+    };
+    const message = (event) => {
+        const data = event.data;
+        if (!data || data.version !== CONTAINER_WORKER_PROTOCOL || data.channel !== channel)
+            return;
+        if (data.type === 'event') {
+            for (const listener of listeners) {
+                try {
+                    listener(data.event);
+                }
+                catch (error) {
+                    console.error('Container UI event handler failed', error);
+                }
+            }
+            return;
+        }
+        const entry = pending.get(data.id);
+        if (!entry)
+            return;
+        if (data.type === 'progress') {
+            try {
+                if (data.progress.kind === 'set')
+                    entry.options?.progress?.set?.(data.progress.value, data.progress.stage);
+                else
+                    entry.options?.progress?.report?.(data.progress.event);
+            }
+            catch (error) {
+                console.error('Container UI progress handler failed', error);
+            }
+            return;
+        }
+        entry.cleanup();
+        pending.delete(data.id);
+        if (data.type === 'error') {
+            const error = Object.assign(new Error(data.error.message), {
+                name: data.error.name,
+                code: data.error.code
+            });
+            entry.reject(error);
+        }
+        else
+            entry.resolve(data.value);
+    };
+    worker.addEventListener('message', message);
+    worker.addEventListener('error', crash);
+    worker.addEventListener('messageerror', crash);
+    const initialized = new Promise((resolve, reject) => {
+        const timer = setTimeout(() => retire(new Error('Container owner initialization timed out')), options.initializationTimeoutMs ?? 60_000);
+        pending.set(0, { resolve: () => resolve(), reject, cleanup: () => clearTimeout(timer) });
+        try {
+            post({
+                version: CONTAINER_WORKER_PROTOCOL,
+                channel,
+                id: 0,
+                type: 'init',
+                settings: snapshotContainerArguments({
+                    runtimeAssets: options.runtimeAssets,
+                    applicationRootURL: options.applicationRootURL,
+                    workspaceId: options.workspaceId
+                })
+            });
+        }
+        catch (error) {
+            retire(error);
+        }
+    });
+    void initialized.catch(() => { });
+    const call = async (method, args = [], settings = {}) => {
+        if (disposed)
+            throw retirementError;
+        if (settings.signal?.aborted)
+            throw abortError();
+        // Snapshot before the first await; caller mutation never changes a pending request.
+        const values = snapshotContainerArguments(args);
+        await initialized;
+        if (disposed)
+            throw retirementError;
+        if (settings.signal?.aborted)
+            throw abortError();
+        const id = nextId++;
+        return await new Promise((resolve, reject) => {
+            const cancel = () => {
+                const entry = pending.get(id);
+                if (!entry || entry.cancelTimer)
+                    return;
+                try {
+                    post({ version: CONTAINER_WORKER_PROTOCOL, channel, id, type: 'cancel' });
+                }
+                catch (error) {
+                    retire(error);
+                    return;
+                }
+                entry.cancelTimer = setTimeout(() => retire(new Error('Container owner did not finish cancellation before its cleanup deadline')), cleanupDeadlineMs);
+            };
+            pending.set(id, {
+                resolve: (value) => settings.signal?.aborted ? reject(abortError()) : resolve(value),
+                reject,
+                options: settings,
+                cleanup() {
+                    settings.signal?.removeEventListener('abort', cancel);
+                    const timer = pending.get(id)?.cancelTimer;
+                    if (timer)
+                        clearTimeout(timer);
+                }
+            });
+            settings.signal?.addEventListener('abort', cancel, { once: true });
+            try {
+                post({
+                    version: CONTAINER_WORKER_PROTOCOL,
+                    channel,
+                    id,
+                    type: 'call',
+                    method,
+                    args: values
+                });
+            }
+            catch (error) {
+                const entry = pending.get(id);
+                entry?.cleanup();
+                pending.delete(id);
+                reject(error);
+            }
+            if (settings.signal?.aborted)
+                cancel();
+        });
+    };
+    return {
+        call,
+        onEvent(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        dispose() {
+            return (disposal ??= (async () => {
+                if (disposed)
+                    return;
+                const timer = setTimeout(() => retire(new Error('Container owner disposal deadline expired')), cleanupDeadlineMs);
+                try {
+                    await call('dispose');
+                }
+                catch {
+                    /* Retiring the Worker is the final cleanup boundary. */
+                }
+                finally {
+                    clearTimeout(timer);
+                    retire(new Error('Container owner has been disposed'));
+                }
+            })());
+        }
+    };
+}

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

@@ -0,0 +1,31 @@
+import type { ContainerWorkspaceEntry } from './protocol';
+export interface ExplorerEntry extends ContainerWorkspaceEntry {
+    name: string;
+    parent: string;
+    implicit?: boolean;
+}
+export interface ExplorerModel {
+    readonly entries: ReadonlyMap<string, ExplorerEntry>;
+    readonly children: ReadonlyMap<string, readonly ExplorerEntry[]>;
+}
+export interface ExplorerRow {
+    entry: ExplorerEntry;
+    depth: number;
+    expanded: boolean;
+}
+export declare const EXPLORER_PAGE_SIZE = 256;
+/** Build directory entries without following symbolic links or changing POSIX path spelling. */
+export declare function buildExplorerModel(entries: readonly ContainerWorkspaceEntry[]): ExplorerModel;
+/** Missing or removed folders fall back to the nearest actual directory, then /workspace. */
+export declare function resolveExplorerDirectory(model: ExplorerModel, requested: string): string;
+export declare function explorerBreadcrumbs(directory: string): {
+    path: string;
+    name: string;
+}[];
+/** Flatten only expanded branches and retain a single page of rows, even in large workspaces. */
+export declare function visibleExplorerRows(model: ExplorerModel, directory: string, expanded: ReadonlySet<string>, requestedOffset?: number): {
+    rows: ExplorerRow[];
+    total: number;
+    offset: number;
+    remaining: number;
+};