wasm-idle 1.0.12 → 1.1.2

package/dist/playground/commonlispAssets.js

@@ -0,0 +1,184 @@
+import { AssetIntegrityError, defineRuntimeRegistryManifest, UnsupportedBrowserFeatureError, preflightRuntimeAssets, ResourceLimitError, RuntimeConfigurationError, verifyRuntimeAssetIntegrity } from '@wasm-idle/core';
+import { WASM_COMMONLISP_PROFILE as profile } from './wasmCommonLispVersion';
+export const COMMONLISP_INITIAL_MEMORY_BYTES = 64 * 1024 * 1024;
+/** ecl.wasm is delivered as the producer's pinned gzip bytes; `.bin` keeps hosts from adding
+ * Content-Encoding, so the browser never transparently decodes it before verification. */
+export const COMMONLISP_WASM_STORAGE_PATH = 'ecl.wasm.gz.bin';
+const identityAsset = (name, mediaType) => ({
+    key: name,
+    path: name,
+    compressedSha256: profile.assets[name].sha256,
+    uncompressedSha256: profile.assets[name].sha256,
+    compressedBytes: profile.assets[name].bytes,
+    uncompressedBytes: profile.assets[name].bytes,
+    encoding: 'identity',
+    mediaType
+});
+const deliveryAssets = [
+    identityAsset('producer-receipt.json', 'application/json'),
+    identityAsset('ecl.mjs', 'text/javascript'),
+    {
+        key: 'ecl.wasm',
+        path: COMMONLISP_WASM_STORAGE_PATH,
+        compressedSha256: profile.assets['ecl.wasm.gz'].sha256,
+        uncompressedSha256: profile.runtime['ecl.wasm'].sha256,
+        compressedBytes: profile.assets['ecl.wasm.gz'].bytes,
+        uncompressedBytes: profile.runtime['ecl.wasm'].bytes,
+        encoding: 'gzip',
+        mediaType: 'application/wasm'
+    }
+];
+export const COMMONLISP_RUNTIME_MANIFEST = defineRuntimeRegistryManifest({
+    schemaVersion: 2,
+    manifestId: 'wasm-idle/commonlisp',
+    revision: profile.assets['producer-receipt.json'].sha256,
+    runtimes: [
+        {
+            runtimeId: 'COMMONLISP',
+            identity: {
+                languageId: 'COMMONLISP',
+                implementationId: 'ecl-emscripten',
+                implementationVersion: profile.version,
+                profile: {
+                    profileId: profile.profileId,
+                    manifestSchemaVersion: 1,
+                    manifestSha256: profile.assets['producer-receipt.json'].sha256,
+                    protocolVersion: 1,
+                    trustProfileId: profile.profileId,
+                    trustProfileSchemaVersion: 1
+                }
+            },
+            capabilities: {
+                stdin: 'streaming',
+                workspace: true,
+                abort: true,
+                artifacts: false,
+                streamingOutput: true
+            },
+            workerLifetime: { mode: 'per-run' },
+            requiredBrowserFeatures: ['wasm', 'wasm-exceptions', 'decompression-stream'],
+            assetRoot: '.',
+            assets: deliveryAssets,
+            contracts: {
+                routeId: 'COMMONLISP',
+                runtimeAssetKey: 'commonlisp',
+                documentationId: 'commonlisp',
+                syncTarget: 'wasm-commonlisp',
+                browserTestId: 'COMMONLISP'
+            }
+        }
+    ]
+});
+export function resolveCommonLispRuntimeAssetConfig(assets, currentUrl) {
+    const root = typeof assets === 'string' ? assets : assets.rootUrl || '';
+    const override = typeof assets === 'string' ? undefined : assets.commonlisp?.baseUrl;
+    const baseUrl = new URL(override ?? `${root.replace(/\/+$/, '')}/wasm-commonlisp/`, currentUrl);
+    if (!['http:', 'https:'].includes(baseUrl.protocol) ||
+        baseUrl.username ||
+        baseUrl.password ||
+        baseUrl.search ||
+        baseUrl.hash) {
+        throw new RuntimeConfigurationError('Common Lisp requires a credential-free HTTP(S) asset directory.', { runtimeId: 'COMMONLISP' });
+    }
+    if (!baseUrl.pathname.endsWith('/'))
+        baseUrl.pathname += '/';
+    const workerUrl = new URL('runner-worker.js', baseUrl);
+    workerUrl.searchParams.set('v', profile.workerReceipt.sha256);
+    return {
+        baseUrl: baseUrl.href,
+        workerUrl: workerUrl.href,
+        manifestFingerprint: profile.assets['producer-receipt.json'].sha256,
+        workerReceipt: profile.workerReceipt
+    };
+}
+export async function preflightCommonLispRuntimeAssets(baseUrl, options) {
+    if (options.limits.maxWasmMemoryBytes < COMMONLISP_INITIAL_MEMORY_BYTES) {
+        throw new ResourceLimitError('Common Lisp needs at least 64 MiB of Wasm memory.', {
+            runtimeId: 'COMMONLISP',
+            phase: 'asset',
+            resource: 'wasm-memory',
+            actual: COMMONLISP_INITIAL_MEMORY_BYTES,
+            limit: options.limits.maxWasmMemoryBytes
+        });
+    }
+    const loaded = new Map();
+    const total = deliveryAssets.reduce((sum, asset) => sum + asset.compressedBytes, 0);
+    const result = await preflightRuntimeAssets({
+        manifest: COMMONLISP_RUNTIME_MANIFEST,
+        runtimeId: 'COMMONLISP',
+        rootUrl: baseUrl,
+        assetUrls: Object.fromEntries(deliveryAssets.map((asset) => [
+            asset.key,
+            new URL(`${asset.path}?v=${asset.compressedSha256}`, baseUrl)
+        ])),
+        limits: options.limits,
+        persistentCache: options.persistentCache,
+        signal: options.signal,
+        fetch: options.fetch,
+        redirect: 'error',
+        requireExactResponseUrl: true,
+        maxConcurrentDownloads: 2,
+        maxTotalDeliveryBytes: total,
+        reportProgress(progress) {
+            loaded.set(progress.assetKey, progress.loadedBytes);
+            options.reportProgress?.(0.04 + (0.13 * [...loaded.values()].reduce((a, b) => a + b, 0)) / total, `Verifying ECL ${progress.assetKey}`);
+        }
+    });
+    const wasm = await decompressCommonLispWasm(result.assets['ecl.wasm'].bytes, options.signal);
+    return Object.freeze({
+        fingerprint: profile.assets['producer-receipt.json'].sha256,
+        'producer-receipt.json': result.assets['producer-receipt.json'].bytes,
+        'ecl.mjs': result.assets['ecl.mjs'].bytes,
+        'ecl.wasm': wasm
+    });
+}
+/** Decode the verified gzip delivery into an exactly sized buffer and verify the logical receipt. */
+export async function decompressCommonLispWasm(compressed, signal) {
+    const context = { runtimeId: 'COMMONLISP', profileId: profile.profileId };
+    if (typeof DecompressionStream !== 'function')
+        throw new UnsupportedBrowserFeatureError('DecompressionStream(gzip)', {
+            ...context,
+            phase: 'asset'
+        });
+    const expected = profile.runtime['ecl.wasm'];
+    const body = new Response(Uint8Array.from(compressed)).body;
+    const reader = body.pipeThrough(new DecompressionStream('gzip')).getReader();
+    const wasm = new Uint8Array(expected.bytes);
+    let offset = 0;
+    try {
+        for (;;) {
+            signal?.throwIfAborted();
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (offset + value.byteLength > wasm.byteLength)
+                throw new AssetIntegrityError('ECL ecl.wasm gzip output exceeds its receipt', context);
+            wasm.set(value, offset);
+            offset += value.byteLength;
+        }
+    }
+    catch (error) {
+        void reader.cancel().catch(() => undefined);
+        if (error instanceof AssetIntegrityError || signal?.aborted)
+            throw error;
+        throw new AssetIntegrityError('ECL ecl.wasm gzip decompression failed', {
+            ...context,
+            cause: error
+        });
+    }
+    if (offset !== wasm.byteLength)
+        throw new AssetIntegrityError('ECL ecl.wasm gzip output is truncated', context);
+    await verifyRuntimeAssetIntegrity({
+        asset: 'ecl.wasm',
+        bytes: wasm,
+        expected: {
+            ...expected,
+            uncompressedSha256: expected.sha256,
+            uncompressedBytes: expected.bytes
+        },
+        stage: 'uncompressed',
+        mimeType: 'application/wasm',
+        ...context
+    });
+    return wasm;
+}

package/dist/playground/compiledArtifactCache.d.ts

@@ -1,4 +1,5 @@
 import type { BrowserClangArtifact, BrowserClangCompileRequest } from '@wasm-idle/llvm-core/clang';
+import type { CompilerDiagnostic } from '@wasm-idle/llvm-core/clang';
 /** Only immutable compiler output lives here, never a worker, instance, or filesystem. */
 export declare class CompiledArtifactCache {
     private entries;
@@ -9,7 +10,8 @@ export declare class CompiledArtifactCache {
     private maxBytes;
     constructor(maxEntries?: number, maxBytes?: number);
     get(key: string): BrowserClangArtifact | undefined;
-    set(key: string, artifact: BrowserClangArtifact): void;
+    getDiagnostics(key: string): CompilerDiagnostic[];
+    set(key: string, artifact: BrowserClangArtifact, diagnostics?: CompilerDiagnostic[]): void;
     clear(): void;
     stats(): {
         hits: number;

package/dist/playground/compiledArtifactCache.js

@@ -1,3 +1,12 @@
+function snapshotArtifact(artifact) {
+    const { bytes, wasm, ...metadata } = artifact;
+    return {
+        ...structuredClone(metadata),
+        // Compiled modules are immutable. Byte views must not retain an oversized backing buffer.
+        wasm,
+        bytes: ArrayBuffer.isView(bytes) ? Uint8Array.from(bytes) : bytes.slice(0)
+    };
+}
 /** Only immutable compiler output lives here, never a worker, instance, or filesystem. */
 export class CompiledArtifactCache {
     entries = new Map();
@@ -7,6 +16,10 @@ export class CompiledArtifactCache {
     maxEntries;
     maxBytes;
     constructor(maxEntries = 8, maxBytes = 32 * 1024 * 1024) {
+        if (!Number.isSafeInteger(maxEntries) || maxEntries < 0)
+            throw new TypeError('Invalid compiled artifact cache maxEntries');
+        if (!Number.isSafeInteger(maxBytes) || maxBytes < 0)
+            throw new TypeError('Invalid compiled artifact cache maxBytes');
         this.maxEntries = maxEntries;
         this.maxBytes = maxBytes;
     }
@@ -19,17 +32,29 @@ export class CompiledArtifactCache {
         this.hits++;
         this.entries.delete(key);
         this.entries.set(key, entry);
-        return entry.artifact;
+        return snapshotArtifact(entry.artifact);
+    }
+    getDiagnostics(key) {
+        return this.entries.get(key)?.diagnostics.map((diagnostic) => ({ ...diagnostic })) ?? [];
     }
-    set(key, artifact) {
-        const size = artifact.bytes.byteLength + key.length * 2;
+    set(key, artifact, diagnostics = []) {
+        // A zero budget disables retention without disabling compilation.
+        if (this.maxEntries === 0 || this.maxBytes === 0)
+            return;
+        const size = artifact.bytes.byteLength +
+            key.length * 2 +
+            (diagnostics.length ? JSON.stringify(diagnostics).length * 2 : 0);
         if (size > this.maxBytes)
             return;
         const old = this.entries.get(key);
         if (old)
             this.bytes -= old.size;
         this.entries.delete(key);
-        this.entries.set(key, { artifact, size });
+        this.entries.set(key, {
+            artifact: snapshotArtifact(artifact),
+            diagnostics: diagnostics.map((diagnostic) => ({ ...diagnostic })),
+            size
+        });
         this.bytes += size;
         while (this.entries.size > this.maxEntries || this.bytes > this.maxBytes) {
             const oldest = this.entries.keys().next().value;
@@ -52,7 +77,7 @@ export class CompiledArtifactCache {
 }
 export function clangCompileKey(runtimeBaseUrl, maxAssetBytes, request, languageSysroots = false) {
     return JSON.stringify([
-        'wasm-idle/clang-cache-v2',
+        'wasm-idle/clang-cache-v3',
         runtimeBaseUrl,
         maxAssetBytes,
         languageSysroots,
@@ -62,6 +87,7 @@ export function clangCompileKey(runtimeBaseUrl, maxAssetBytes, request, language
         request.compileArgs,
         request.cVersion,
         request.cppVersion,
+        request.maxWasmMemoryBytes,
         [...(request.workspaceFiles || [])].sort((a, b) => a.path.localeCompare(b.path))
     ]);
 }

package/dist/playground/container/ContainerExplorer.svelte

@@ -0,0 +1,307 @@
+<script lang="ts">
+	import type { ContainerWorkspaceEntry } from './protocol';
+	import {
+		buildExplorerModel,
+		explorerBreadcrumbs,
+		EXPLORER_PAGE_SIZE,
+		resolveExplorerDirectory,
+		visibleExplorerRows
+	} from './explorer';
+
+	interface Props {
+		entries: readonly ContainerWorkspaceEntry[];
+		selectedPath?: string;
+		initialDirectory?: string;
+		busy?: boolean;
+		onOpenFile: (entry: ContainerWorkspaceEntry) => void;
+	}
+
+	let {
+		entries,
+		selectedPath,
+		initialDirectory = '',
+		busy = false,
+		onOpenFile
+	}: Props = $props();
+	let requestedDirectory = $state('');
+	let expanded = $state(new Set<string>());
+	let offset = $state(0);
+	const model = $derived(buildExplorerModel(entries));
+	const directory = $derived(resolveExplorerDirectory(model, requestedDirectory));
+	const breadcrumbs = $derived(explorerBreadcrumbs(directory));
+	const visible = $derived(visibleExplorerRows(model, directory, expanded, offset));
+
+	$effect(() => {
+		requestedDirectory = initialDirectory;
+		expanded = new Set();
+		offset = 0;
+	});
+
+	function enterDirectory(path: string) {
+		requestedDirectory = resolveExplorerDirectory(model, path);
+		offset = 0;
+	}
+
+	function toggleDirectory(path: string) {
+		const next = new Set(expanded);
+		if (next.has(path)) next.delete(path);
+		else next.add(path);
+		expanded = next;
+		offset = 0;
+	}
+</script>
+
+<div class="container-explorer">
+	<nav aria-label="Workspace folder" class="breadcrumbs">
+		<button
+			type="button"
+			class="parent-button"
+			aria-label="Go to parent folder"
+			title="Go to parent folder"
+			disabled={!directory}
+			onclick={() => enterDirectory(model.entries.get(directory)?.parent ?? '')}>↑</button
+		>
+		<ol>
+			{#each breadcrumbs as crumb (crumb.path)}
+				<li>
+					<button
+						type="button"
+						title={crumb.path ? `/workspace/${crumb.path}` : '/workspace'}
+						aria-current={crumb.path === directory ? 'location' : undefined}
+						onclick={() => enterDirectory(crumb.path)}>{crumb.name}</button
+					>
+				</li>
+			{/each}
+		</ol>
+	</nav>
+	<div class="files">
+		{#if visible.rows.length === 0}
+			<p class="empty">This folder is empty.</p>
+		{:else}
+			<ul aria-label="Workspace files">
+				{#each visible.rows as row (row.entry.path)}
+					{@const entry = row.entry}
+					<li style:padding-left={`${Math.min(row.depth, 16) * 12}px`}>
+						{#if entry.type === 'directory'}
+							<button
+								type="button"
+								class="toggle"
+								aria-label={`${row.expanded ? 'Collapse' : 'Expand'} /workspace/${entry.path}`}
+								aria-expanded={row.expanded}
+								onclick={() => toggleDirectory(entry.path)}
+								>{row.expanded ? '▾' : '▸'}</button
+							>
+							<button
+								type="button"
+								class="entry directory"
+								data-container-directory={entry.path}
+								aria-label={`Open folder /workspace/${entry.path}`}
+								title={`/workspace/${entry.path}/`}
+								onclick={() => enterDirectory(entry.path)}
+							>
+								<span class="material-symbols-outlined" aria-hidden="true"
+									>folder</span
+								>
+								<span>{entry.name}</span>
+							</button>
+						{:else if entry.type === 'file'}
+							<button
+								type="button"
+								class="entry file"
+								class:active={entry.path === selectedPath}
+								data-container-path={entry.path}
+								aria-current={entry.path === selectedPath ? 'true' : undefined}
+								title={`/workspace/${entry.path} (${entry.size} bytes)`}
+								disabled={busy}
+								onclick={() => onOpenFile(entry)}
+							>
+								<span class="material-symbols-outlined" aria-hidden="true"
+									>draft</span
+								>
+								<span>{entry.name}</span>
+							</button>
+						{:else}
+							<div
+								class="entry symlink"
+								title={`/workspace/${entry.path} (symbolic link; target is not followed)`}
+							>
+								<span class="material-symbols-outlined" aria-hidden="true"
+									>link</span
+								>
+								<span>{entry.name}</span>
+								<small>link</small>
+							</div>
+						{/if}
+					</li>
+				{/each}
+			</ul>
+		{/if}
+	</div>
+	{#if visible.offset > 0 || visible.remaining > 0}
+		<div class="pagination">
+			{#if visible.offset > 0}<button
+					type="button"
+					onclick={() => (offset = visible.offset - EXPLORER_PAGE_SIZE)}
+					>Previous files</button
+				>{/if}
+			<span aria-live="polite"
+				>{visible.offset + 1}–{visible.offset + visible.rows.length} of {visible.total}</span
+			>
+			{#if visible.remaining > 0}<button
+					type="button"
+					onclick={() => (offset = visible.offset + EXPLORER_PAGE_SIZE)}
+					>Show more ({visible.remaining} remaining)</button
+				>{/if}
+		</div>
+	{/if}
+</div>
+
+<style>
+	.container-explorer {
+		display: flex;
+		flex-direction: column;
+		min-height: 36px;
+		overflow: hidden;
+	}
+	.breadcrumbs {
+		display: flex;
+		align-items: flex-start;
+		gap: 4px;
+		padding: 4px 0;
+		border-bottom: 1px solid var(--line-soft, #e5e7eb);
+	}
+	.breadcrumbs ol {
+		display: flex;
+		flex-wrap: wrap;
+		align-items: center;
+		gap: 2px;
+		min-width: 0;
+		margin: 0;
+		padding: 0;
+		list-style: none;
+	}
+	.breadcrumbs li {
+		display: flex;
+		align-items: center;
+		min-width: 0;
+	}
+	.breadcrumbs li + li::before {
+		content: '/';
+		color: var(--text-4, #888);
+		font-size: 10px;
+	}
+	button {
+		border: 0;
+		border-radius: 6px;
+		background: transparent;
+		color: var(--text-2, #535c6d);
+		cursor: pointer;
+		font: inherit;
+	}
+	button:disabled {
+		cursor: not-allowed;
+		opacity: 0.6;
+	}
+	button:hover:enabled,
+	button.active {
+		background: var(--primary-soft, #eaf2ff);
+		color: var(--primary-strong, #2563eb);
+	}
+	button:focus-visible {
+		outline: 2px solid var(--primary, #3182f6);
+		outline-offset: -2px;
+	}
+	.breadcrumbs button {
+		max-width: 200px;
+		padding: 4px 5px;
+		overflow-wrap: anywhere;
+		text-align: left;
+		font: 10px var(--mono, monospace);
+	}
+	.breadcrumbs button[aria-current] {
+		color: var(--text, #1f2937);
+	}
+	.breadcrumbs .parent-button {
+		flex: 0 0 26px;
+		text-align: center;
+		font-size: 15px;
+	}
+	.files {
+		min-height: 36px;
+		overflow: auto;
+	}
+	.files ul {
+		margin: 0;
+		padding: 4px 0;
+		list-style: none;
+	}
+	.files li {
+		display: flex;
+		align-items: center;
+		box-sizing: border-box;
+		min-width: 0;
+	}
+	.entry {
+		display: flex;
+		align-items: center;
+		flex: 1 1 auto;
+		gap: 6px;
+		min-width: 0;
+		min-height: 30px;
+		padding: 5px 8px;
+		text-align: left;
+		font: 11px var(--mono, monospace);
+		color: var(--text-2, #535c6d);
+	}
+	.entry > span:last-child {
+		min-width: 0;
+		overflow: hidden;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+	}
+	.entry.file,
+	.entry.symlink {
+		margin-left: 24px;
+	}
+	.toggle {
+		flex: 0 0 24px;
+		width: 24px;
+		min-height: 30px;
+		padding: 0;
+		font-size: 13px;
+	}
+	.material-symbols-outlined {
+		flex: 0 0 auto;
+		font-size: 16px;
+	}
+	.symlink {
+		color: var(--text-3, #7a8393);
+	}
+	.symlink span:nth-child(2) {
+		overflow: hidden;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+	}
+	.symlink small {
+		margin-left: auto;
+		font-size: 9px;
+	}
+	.empty {
+		margin: 8px;
+		color: var(--text-3, #7a8393);
+		font-size: 11px;
+	}
+	.pagination {
+		display: flex;
+		flex-wrap: wrap;
+		align-items: center;
+		gap: 5px;
+		border-top: 1px solid var(--line-soft, #e5e7eb);
+		padding: 5px 0;
+		color: var(--text-3, #7a8393);
+		font-size: 10px;
+	}
+	.pagination button {
+		padding: 5px;
+	}
+</style>

package/dist/playground/container/ContainerExplorer.svelte.d.ts

@@ -0,0 +1,14 @@
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type ContainerExplorerProps = typeof __propDef.props;
+export type ContainerExplorerEvents = typeof __propDef.events;
+export type ContainerExplorerSlots = typeof __propDef.slots;
+export default class ContainerExplorer extends SvelteComponentTyped<ContainerExplorerProps, ContainerExplorerEvents, ContainerExplorerSlots> {
+}
+export {};

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

@@ -0,0 +1,26 @@
+import type { PlaygroundBinding, SandboxRuntimeAssets } from '../sandbox';
+import type { TerminalShellBinding } from '@wasm-idle/terminal';
+import type { WorkspaceFile as ContainerWorkspaceFile } from '@wasm-idle/core';
+import { type ContainerWorkerClient } from './client';
+import type { ContainerWorkerEvent, ContainerWorkspaceEntry } from './protocol';
+type BindingOptions = {
+    applicationRootURL: string;
+    workspaceId: string;
+    getLanguage?: () => string;
+    /** Deterministic transport contract tests only. */
+    clientFactory?: () => ContainerWorkerClient;
+};
+export interface ContainerPlaygroundBinding extends PlaygroundBinding {
+    readonly shell: TerminalShellBinding;
+    inspect(): Promise<unknown>;
+    setShellDirectory(language: string): Promise<void>;
+    syncWorkspace(language: string, files: readonly ContainerWorkspaceFile[]): Promise<void>;
+    readWorkspace(language: string): Promise<ContainerWorkspaceFile[]>;
+    listWorkspaceFiles(): Promise<ContainerWorkspaceEntry[]>;
+    publishedWorkspace(language: string): ContainerWorkspaceFile[];
+    acceptWorkspace(language: string, files: readonly ContainerWorkspaceFile[]): void;
+    onWorkspaceChange(listener: (event: ContainerWorkerEvent) => void): () => void;
+}
+/** Existing Terminal/Debug controls use this facade; every execution belongs to the owner Container. */
+export declare function createContainerPlaygroundBinding(runtimeAssets: SandboxRuntimeAssets, options: BindingOptions): ContainerPlaygroundBinding;
+export {};