wasm-idle 1.0.12 → 1.1.2

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

package/dist/playground/container/explorer.js

@@ -0,0 +1,112 @@
+export const EXPLORER_PAGE_SIZE = 256;
+function isRelativePath(path) {
+    return (path.length > 0 &&
+        path.length <= 4096 &&
+        !path.includes('\0') &&
+        path.split('/').every((part) => part !== '' && part !== '.' && part !== '..'));
+}
+function parentPath(path) {
+    const separator = path.lastIndexOf('/');
+    return separator === -1 ? '' : path.slice(0, separator);
+}
+/** Build directory entries without following symbolic links or changing POSIX path spelling. */
+export function buildExplorerModel(entries) {
+    const nodes = new Map([
+        ['', { path: '', name: '/workspace', parent: '', type: 'directory', size: 0 }]
+    ]);
+    for (const entry of entries) {
+        if (!isRelativePath(entry.path) || nodes.has(entry.path))
+            continue;
+        nodes.set(entry.path, {
+            ...entry,
+            name: entry.path.slice(entry.path.lastIndexOf('/') + 1),
+            parent: parentPath(entry.path)
+        });
+    }
+    for (const entry of [...nodes.values()]) {
+        let path = entry.parent;
+        while (path) {
+            if (!nodes.has(path))
+                nodes.set(path, {
+                    path,
+                    parent: parentPath(path),
+                    name: path.slice(path.lastIndexOf('/') + 1),
+                    type: 'directory',
+                    size: 0,
+                    implicit: true
+                });
+            path = parentPath(path);
+        }
+    }
+    for (const [path, entry] of nodes) {
+        let ancestor = entry.parent;
+        while (path) {
+            if (nodes.get(ancestor)?.type !== 'directory') {
+                nodes.delete(path);
+                break;
+            }
+            if (!ancestor)
+                break;
+            ancestor = parentPath(ancestor);
+        }
+    }
+    const children = new Map();
+    for (const entry of nodes.values()) {
+        if (!entry.path)
+            continue;
+        const siblings = children.get(entry.parent) ?? [];
+        siblings.push(entry);
+        children.set(entry.parent, siblings);
+    }
+    for (const siblings of children.values())
+        siblings.sort((a, b) => Number(b.type === 'directory') - Number(a.type === 'directory') ||
+            a.name.localeCompare(b.name, 'en', { numeric: true }) ||
+            a.path.localeCompare(b.path, 'en'));
+    return { entries: nodes, children };
+}
+/** Missing or removed folders fall back to the nearest actual directory, then /workspace. */
+export function resolveExplorerDirectory(model, requested) {
+    let path = isRelativePath(requested) ? requested : '';
+    while (path && model.entries.get(path)?.type !== 'directory')
+        path = parentPath(path);
+    return path;
+}
+export function explorerBreadcrumbs(directory) {
+    const result = [{ path: '', name: '/workspace' }];
+    if (!isRelativePath(directory))
+        return result;
+    const parts = directory.split('/');
+    for (let index = 0; index < parts.length; index++)
+        result.push({ path: parts.slice(0, index + 1).join('/'), name: parts[index] });
+    return result;
+}
+/** Flatten only expanded branches and retain a single page of rows, even in large workspaces. */
+export function visibleExplorerRows(model, directory, expanded, requestedOffset = 0) {
+    const root = resolveExplorerDirectory(model, directory);
+    const visible = [];
+    const pending = [...(model.children.get(root) ?? [])]
+        .reverse()
+        .map((entry) => ({ entry, depth: 0 }));
+    while (pending.length) {
+        const row = pending.pop();
+        const isExpanded = row.entry.type === 'directory' && expanded.has(row.entry.path);
+        visible.push({ ...row, expanded: isExpanded });
+        if (isExpanded) {
+            const children = model.children.get(row.entry.path) ?? [];
+            for (let index = children.length - 1; index >= 0; index--)
+                pending.push({ entry: children[index], depth: row.depth + 1 });
+        }
+    }
+    const lastPage = Math.max(0, Math.ceil(visible.length / EXPLORER_PAGE_SIZE) - 1) * EXPLORER_PAGE_SIZE;
+    const requested = Number.isSafeInteger(requestedOffset) && requestedOffset > 0
+        ? Math.floor(requestedOffset / EXPLORER_PAGE_SIZE) * EXPLORER_PAGE_SIZE
+        : 0;
+    const offset = Math.min(requested, lastPage);
+    const rows = visible.slice(offset, offset + EXPLORER_PAGE_SIZE);
+    return {
+        rows,
+        total: visible.length,
+        offset,
+        remaining: visible.length - offset - rows.length
+    };
+}

package/dist/playground/container/owner.worker.d.ts

@@ -0,0 +1 @@
+export {};