wasm-idle 0.7.1 → 0.7.2

package/dist/clang/index.js

@@ -3,6 +3,7 @@ import { MemFS, untar } from './memory';
 import { green, yellow, normal } from './color';
 import { compile, readBuffer } from './wasm';
 import { clangUrl, lldUrl, rootUrl } from './url';
+import { installGccCompatibilityHeaders } from './gccCompat';
 import { derived, writable } from 'svelte/store';
 const clangCommonArgs = [
     '-disable-free',
@@ -174,7 +175,10 @@ export default class Clang {
         });
         this.getModule(clangUrl(this.path), this.progress.clang);
         this.getModule(lldUrl(this.path), this.progress.lld);
-        this.ready = this.memfs.ready.then(() => this.hostLogAsync(`Untarring ${rootUrl(this.path)}`, readBuffer(rootUrl(this.path)).then((buffer) => untar(buffer, this.memfs))));
+        this.ready = this.memfs.ready.then(async () => {
+            await this.hostLogAsync(`Untarring ${rootUrl(this.path)}`, readBuffer(rootUrl(this.path)).then((buffer) => untar(buffer, this.memfs)));
+            installGccCompatibilityHeaders(this.memfs);
+        });
     }
     hostLog(message) {
         if (!this.log)

package/dist/clang/url.d.ts

@@ -1,4 +1,4 @@
-export declare const memfsUrl: (prefix: string) => string;
-export declare const clangUrl: (prefix: string) => string;
-export declare const lldUrl: (prefix: string) => string;
-export declare const rootUrl: (prefix: string) => string;
+export declare const memfsUrl: (baseUrl: string) => string;
+export declare const clangUrl: (baseUrl: string) => string;
+export declare const lldUrl: (baseUrl: string) => string;
+export declare const rootUrl: (baseUrl: string) => string;

package/dist/clang/url.js

@@ -1,4 +1,5 @@
-export const memfsUrl = (prefix) => prefix + '/clang/bin/memfs.zip';
-export const clangUrl = (prefix) => prefix + '/clang/bin/clang.zip';
-export const lldUrl = (prefix) => prefix + '/clang/bin/lld.zip';
-export const rootUrl = (prefix) => prefix + '/clang/bin/sysroot.tar.zip';
+const normalizeBaseUrl = (baseUrl) => baseUrl ? (baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`) : '/clang/';
+export const memfsUrl = (baseUrl) => `${normalizeBaseUrl(baseUrl)}bin/memfs.zip`;
+export const clangUrl = (baseUrl) => `${normalizeBaseUrl(baseUrl)}bin/clang.zip`;
+export const lldUrl = (baseUrl) => `${normalizeBaseUrl(baseUrl)}bin/lld.zip`;
+export const rootUrl = (baseUrl) => `${normalizeBaseUrl(baseUrl)}bin/sysroot.tar.zip`;

package/dist/clangd/session.d.ts

@@ -1,13 +1,17 @@
 import { MonacoLanguageClient } from '@hancomac/monaco-languageclient';
 import type * as Monaco from 'monaco-editor';
 import { type ClangdStatus } from './config';
+import { WorkerAssetBridge } from '../playground/assetBridge';
+import { type ResolvedRuntimeAssetConfig, type RuntimeAssetConfig } from '../playground/assets';
 export declare class ClangdSession {
     Monaco: typeof Monaco;
     baseUrl: string;
+    assetConfig: ResolvedRuntimeAssetConfig;
+    assetBridge: WorkerAssetBridge | null;
     onStatus?: (status: ClangdStatus) => void;
     worker: Worker | null;
     languageClient: MonacoLanguageClient | null;
-    constructor(MonacoModule: typeof Monaco, baseUrl: string, onStatus?: (status: ClangdStatus) => void);
+    constructor(MonacoModule: typeof Monaco, baseUrl: string | RuntimeAssetConfig, onStatus?: (status: ClangdStatus) => void);
     createModel(value: string): Monaco.editor.ITextModel;
     start(): Promise<void>;
     dispose(): void;

package/dist/clangd/session.js

@@ -1,18 +1,23 @@
 import { CloseAction, ErrorAction, MonacoLanguageClient, MonacoServices } from '@hancomac/monaco-languageclient';
-import { CLANGD_CPP_FILE_URI, CLANGD_WORKSPACE_URI, normalizeClangdBaseUrl } from './config';
+import { CLANGD_CPP_FILE_URI, CLANGD_WORKSPACE_URI } from './config';
 import ClangdWorker from './worker?worker';
+import { WorkerAssetBridge } from '../playground/assetBridge';
+import { resolveRuntimeAssetConfig } from '../playground/assets';
 import { BrowserMessageReader, BrowserMessageWriter } from '../utils/vscodeJsonrpcBrowser';
 let servicesInstalled = false;
 export class ClangdSession {
     Monaco;
     baseUrl;
+    assetConfig;
+    assetBridge = null;
     onStatus;
     worker = null;
     languageClient = null;
     constructor(MonacoModule, baseUrl, onStatus) {
         this.Monaco = MonacoModule;
         this.onStatus = onStatus;
-        this.baseUrl = normalizeClangdBaseUrl(baseUrl);
+        this.assetConfig = resolveRuntimeAssetConfig('clangd', { clangd: typeof baseUrl === 'string' ? { baseUrl } : baseUrl }, globalThis.location?.href || '');
+        this.baseUrl = this.assetConfig.baseUrl;
         if (!servicesInstalled) {
             MonacoServices.install(MonacoModule);
             servicesInstalled = true;
@@ -29,12 +34,17 @@ export class ClangdSession {
         this.onStatus?.({ state: 'loading' });
         const worker = new ClangdWorker();
         this.worker = worker;
+        this.assetBridge = new WorkerAssetBridge(worker, 'clangd', this.assetConfig, {
+            set: (value) => this.onStatus?.({ state: 'loading', loaded: value, total: 1 })
+        });
         await new Promise((resolve, reject) => {
             const cleanup = () => {
                 worker.removeEventListener('message', handleMessage);
                 worker.removeEventListener('error', handleError);
             };
             const handleMessage = (event) => {
+                if (this.assetBridge?.handleMessage(event))
+                    return;
                 const { type, value, max, message } = event.data || {};
                 if (type === 'progress') {
                     this.onStatus?.({ state: 'loading', loaded: value, total: max });
@@ -56,7 +66,14 @@ export class ClangdSession {
             };
             worker.addEventListener('message', handleMessage);
             worker.addEventListener('error', handleError);
-            worker.postMessage({ type: 'init', baseUrl: this.baseUrl });
+            worker.postMessage({
+                type: 'init',
+                baseUrl: this.baseUrl,
+                assets: {
+                    baseUrl: this.assetConfig.baseUrl,
+                    useAssetBridge: this.assetConfig.useAssetBridge
+                }
+            });
         });
         const reader = new BrowserMessageReader(worker);
         const writer = new BrowserMessageWriter(worker);
@@ -90,5 +107,6 @@ export class ClangdSession {
         this.languageClient = null;
         this.worker?.terminate();
         this.worker = null;
+        this.assetBridge = null;
     }
 }

package/dist/clangd/worker.js

@@ -1,6 +1,8 @@
 /// <reference lib="WebWorker" />
 import { CLANGD_CPP_FILE_PATH, CLANGD_WORKSPACE_PATH, createClangdCompileFlags, normalizeClangdBaseUrl } from './config';
+import { writeGccCompatibilityHeaders } from '../clang/gccCompat';
 import { JsonStream } from './jsonStream';
+import { configureWorkerRuntimeAssets, handleWorkerAssetMessage, loadWorkerRuntimeAsset } from '../playground/worker/assets';
 import { BrowserMessageReader, BrowserMessageWriter } from '../utils/vscodeJsonrpcBrowser';
 const textEncoder = new TextEncoder();
 const jsonStream = new JsonStream();
@@ -49,62 +51,44 @@ const syncWorkspaceFile = (filePath) => {
     clangdRuntime.FS.writeFile(normalizedFilePath, '');
 };
 self.addEventListener('message', async (event) => {
+    if (handleWorkerAssetMessage(event.data))
+        return;
     if (event.data?.type === 'sync-file' && typeof event.data?.name === 'string') {
         syncWorkspaceFile(event.data.name);
         return;
     }
     if (event.data?.type !== 'init')
         return;
-    const baseUrl = normalizeClangdBaseUrl(event.data.baseUrl);
+    const runtimeAssets = event.data.assets;
+    const normalizedBaseUrl = normalizeClangdBaseUrl(event.data.baseUrl || '');
+    const baseUrl = runtimeAssets?.baseUrl || (normalizedBaseUrl ? `${normalizedBaseUrl}/` : '/clangd/');
+    configureWorkerRuntimeAssets({
+        baseUrl,
+        useAssetBridge: !!runtimeAssets?.useAssetBridge
+    });
     try {
-        const jsResponse = await fetch(`${baseUrl}/clangd.js`);
-        if (!jsResponse.ok) {
-            throw new Error(`Failed to load clangd.js: ${jsResponse.status}`);
-        }
-        const jsSource = await jsResponse.text();
+        const jsSource = new TextDecoder().decode((await loadWorkerRuntimeAsset('clangd.js')).bytes);
+        self.postMessage({ type: 'progress', value: 1, max: 3 });
         const jsDataUrl = URL.createObjectURL(new Blob([jsSource], { type: 'text/javascript;charset=utf-8' }));
         const jsModule = import(/* @vite-ignore */ jsDataUrl);
-        const wasmResponse = await fetch(`${baseUrl}/clangd.wasm.gz`);
-        if (!wasmResponse.ok) {
-            throw new Error(`Failed to load clangd.wasm.gz: ${wasmResponse.status}`);
-        }
-        const wasmSize = +(wasmResponse.headers.get('Content-Length') || 0);
-        const wasmReader = wasmResponse.body?.getReader();
-        const chunks = [];
-        let receivedLength = 0;
-        if (wasmReader) {
-            while (true) {
-                const { done, value } = await wasmReader.read();
-                if (done)
-                    break;
-                if (!value)
-                    continue;
-                chunks.push(Uint8Array.from(value));
-                receivedLength += value.length;
-                self.postMessage({
-                    type: 'progress',
-                    value: receivedLength,
-                    ...(wasmSize > 0 ? { max: wasmSize } : {})
-                });
+        const compressedWasmBytes = (await loadWorkerRuntimeAsset('clangd.wasm.gz')).bytes;
+        self.postMessage({ type: 'progress', value: 2, max: 3 });
+        let wasmBytes = compressedWasmBytes;
+        if (compressedWasmBytes[0] === 0x1f && compressedWasmBytes[1] === 0x8b) {
+            if (typeof DecompressionStream === 'undefined') {
+                throw new Error('Failed to decompress clangd.wasm.gz: DecompressionStream is unavailable');
             }
+            const compressedWasmCopy = new Uint8Array(compressedWasmBytes.byteLength);
+            compressedWasmCopy.set(compressedWasmBytes);
+            const stream = new Blob([compressedWasmCopy.buffer])
+                .stream()
+                .pipeThrough(new DecompressionStream('gzip'));
+            wasmBytes = new Uint8Array(await new Response(stream).arrayBuffer());
         }
-        else {
-            const wasmBytes = new Uint8Array(await wasmResponse.arrayBuffer());
-            chunks.push(wasmBytes);
-            receivedLength = wasmBytes.byteLength;
-            self.postMessage({
-                type: 'progress',
-                value: receivedLength,
-                ...(wasmSize > 0 ? { max: wasmSize } : {})
-            });
-        }
-        const wasmBytes = new Uint8Array(receivedLength);
-        let offset = 0;
-        for (const chunk of chunks) {
-            wasmBytes.set(chunk, offset);
-            offset += chunk.length;
-        }
-        const wasmBlob = new Blob([wasmBytes.buffer], { type: 'application/wasm' });
+        self.postMessage({ type: 'progress', value: 3, max: 3 });
+        const wasmBlobBytes = new Uint8Array(wasmBytes.byteLength);
+        wasmBlobBytes.set(wasmBytes);
+        const wasmBlob = new Blob([wasmBlobBytes.buffer], { type: 'application/wasm' });
         const wasmDataUrl = URL.createObjectURL(wasmBlob);
         const { default: Clangd } = await jsModule;
         clangdRuntime = await Clangd({
@@ -119,6 +103,7 @@ self.addEventListener('message', async (event) => {
             onAbort
         });
         clangdRuntime.FS.mkdirTree(CLANGD_WORKSPACE_PATH);
+        writeGccCompatibilityHeaders(clangdRuntime.FS, '/usr');
         syncWorkspaceFile(CLANGD_CPP_FILE_PATH);
         clangdRuntime.FS.writeFile(`${CLANGD_WORKSPACE_PATH}/.clangd`, JSON.stringify({
             CompileFlags: {
@@ -135,7 +120,7 @@ self.addEventListener('message', async (event) => {
             stdinChunks.push(`Content-Length: ${body.length}\r\n`, '\r\n', body);
             resolveStdinReady();
         });
-        self.postMessage({ type: 'ready', value: receivedLength });
+        self.postMessage({ type: 'ready', value: wasmBytes.byteLength });
     }
     catch (error) {
         self.postMessage({

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import Terminal from './terminal';
 export { cppDebugLanguageAdapter, pythonDebugLanguageAdapter, evaluateDebugExpression, createDebugSessionController, MonacoDebugView, attachMonacoDebugActions, selectInlineDebugLocals } from './debug';
-export { getEditorLanguageServer, getCppLanguageServer, getPythonLanguageServer, resolveCppLanguageServerBaseUrl, resolvePythonLanguageServerBaseUrl } from './lsp';
+export { getEditorLanguageServer, getCppLanguageServer, getPythonLanguageServer, resolveCppLanguageServerBaseUrl, resolveCppLanguageServerRuntimeAssetConfig, resolvePythonLanguageServerBaseUrl } from './lsp';
 import playground, { createPlaygroundBinding } from './playground';
 export default Terminal;
 export { createPlaygroundBinding, playground };

package/dist/index.js

@@ -1,6 +1,6 @@
 import Terminal from './terminal';
 export { cppDebugLanguageAdapter, pythonDebugLanguageAdapter, evaluateDebugExpression, createDebugSessionController, MonacoDebugView, attachMonacoDebugActions, selectInlineDebugLocals } from './debug';
-export { getEditorLanguageServer, getCppLanguageServer, getPythonLanguageServer, resolveCppLanguageServerBaseUrl, resolvePythonLanguageServerBaseUrl } from './lsp';
+export { getEditorLanguageServer, getCppLanguageServer, getPythonLanguageServer, resolveCppLanguageServerBaseUrl, resolveCppLanguageServerRuntimeAssetConfig, resolvePythonLanguageServerBaseUrl } from './lsp';
 import playground, { createPlaygroundBinding } from './playground';
 export default Terminal;
 export { createPlaygroundBinding, playground };

package/dist/lsp/cpp/server.js

@@ -1,8 +1,9 @@
-import { resolveCppLanguageServerBaseUrl } from '../runtime';
+import { resolveCppLanguageServerRuntimeAssetConfig } from '../runtime';
 import ClangdWorker from '../../clangd/worker?worker';
+import { WorkerAssetBridge } from '../../playground/assetBridge';
 import { BrowserMessageReader, BrowserMessageWriter } from '../../utils/vscodeJsonrpcBrowser';
 const currentUrl = () => globalThis.location?.href || '';
-async function createServer(baseUrl) {
+async function createServer(assetConfig) {
     let resolveReady = () => { };
     let rejectReady = (_error) => { };
     const ready = new Promise((resolve, reject) => {
@@ -10,11 +11,14 @@ async function createServer(baseUrl) {
         rejectReady = reject;
     });
     const worker = new ClangdWorker();
+    const assetBridge = new WorkerAssetBridge(worker, 'clangd', assetConfig);
     const cleanup = () => {
         worker.removeEventListener('message', readyListener);
         worker.removeEventListener('error', errorListener);
     };
     const readyListener = (event) => {
+        if (assetBridge.handleMessage(event))
+            return;
         switch (event.data?.type) {
             case 'ready': {
                 cleanup();
@@ -34,13 +38,20 @@ async function createServer(baseUrl) {
     };
     worker.addEventListener('message', readyListener);
     worker.addEventListener('error', errorListener);
-    worker.postMessage({ type: 'init', baseUrl });
+    worker.postMessage({
+        type: 'init',
+        baseUrl: assetConfig.baseUrl,
+        assets: {
+            baseUrl: assetConfig.baseUrl,
+            useAssetBridge: assetConfig.useAssetBridge
+        }
+    });
     await ready;
     return worker;
 }
 export async function getCppLanguageServer(options) {
-    const baseUrl = resolveCppLanguageServerBaseUrl(options, currentUrl());
-    const worker = await createServer(baseUrl);
+    const assetConfig = resolveCppLanguageServerRuntimeAssetConfig(options, currentUrl());
+    const worker = await createServer(assetConfig);
     const reader = new BrowserMessageReader(worker);
     const writer = new BrowserMessageWriter(worker);
     return {

package/dist/lsp/index.d.ts

@@ -1,5 +1,5 @@
 export { getEditorLanguageServer } from './registry';
-export { resolveCppLanguageServerBaseUrl, resolvePythonLanguageServerBaseUrl } from './runtime';
+export { resolveCppLanguageServerBaseUrl, resolveCppLanguageServerRuntimeAssetConfig, resolvePythonLanguageServerBaseUrl } from './runtime';
 export { getCppLanguageServer } from './cpp/server';
 export { getPythonLanguageServer } from './python/server';
 export type { EditorLanguageServerHandle, EditorLanguageServerRuntimeOptions } from './types';

package/dist/lsp/index.js

@@ -1,4 +1,4 @@
 export { getEditorLanguageServer } from './registry';
-export { resolveCppLanguageServerBaseUrl, resolvePythonLanguageServerBaseUrl } from './runtime';
+export { resolveCppLanguageServerBaseUrl, resolveCppLanguageServerRuntimeAssetConfig, resolvePythonLanguageServerBaseUrl } from './runtime';
 export { getCppLanguageServer } from './cpp/server';
 export { getPythonLanguageServer } from './python/server';

package/dist/lsp/runtime.d.ts

@@ -1,3 +1,5 @@
 import type { EditorLanguageServerRuntimeOptions } from './types';
+import { type ResolvedRuntimeAssetConfig } from '../playground/assets';
 export declare function resolveCppLanguageServerBaseUrl(options: string | EditorLanguageServerRuntimeOptions | undefined, currentUrl?: string): string;
+export declare function resolveCppLanguageServerRuntimeAssetConfig(options: string | EditorLanguageServerRuntimeOptions | undefined, currentUrl?: string): ResolvedRuntimeAssetConfig;
 export declare function resolvePythonLanguageServerBaseUrl(options: string | EditorLanguageServerRuntimeOptions | undefined, currentUrl?: string): string;

package/dist/lsp/runtime.js

@@ -1,3 +1,4 @@
+import { resolveRuntimeAssetConfig } from '../playground/assets';
 const normalizeBaseUrl = (baseUrl, currentUrl = '') => {
     const normalized = baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
     return currentUrl ? new URL(normalized, currentUrl).href : normalized;
@@ -5,16 +6,16 @@ const normalizeBaseUrl = (baseUrl, currentUrl = '') => {
 const normalizeRootUrl = (rootUrl) => rootUrl.endsWith('/') ? rootUrl.slice(0, -1) : rootUrl;
 const resolveRuntimeRootBaseUrl = (rootUrl, suffix, currentUrl = '') => normalizeBaseUrl(`${normalizeRootUrl(rootUrl) || ''}${suffix}`, currentUrl);
 export function resolveCppLanguageServerBaseUrl(options, currentUrl = '') {
+    return resolveCppLanguageServerRuntimeAssetConfig(options, currentUrl).baseUrl;
+}
+export function resolveCppLanguageServerRuntimeAssetConfig(options, currentUrl = '') {
     if (typeof options === 'string') {
-        return resolveRuntimeRootBaseUrl(options, '/clangd/', currentUrl);
-    }
-    if (options?.cpp?.baseUrl) {
-        return normalizeBaseUrl(options.cpp.baseUrl, currentUrl);
-    }
-    if (options?.rootUrl) {
-        return resolveRuntimeRootBaseUrl(options.rootUrl, '/clangd/', currentUrl);
+        return resolveRuntimeAssetConfig('clangd', options, currentUrl);
     }
-    return normalizeBaseUrl('/clangd/', currentUrl);
+    return resolveRuntimeAssetConfig('clangd', {
+        rootUrl: options?.rootUrl,
+        clangd: options?.cpp
+    }, currentUrl);
 }
 export function resolvePythonLanguageServerBaseUrl(options, currentUrl = '') {
     if (typeof options === 'string') {

package/dist/lsp/types.d.ts

@@ -1,4 +1,5 @@
 import type { MessageTransports } from '@hancomac/monaco-languageclient';
+import type { RuntimeAssetLoader } from '../playground/assets';
 export interface EditorLanguageServerHandle {
     transport: string | MessageTransports;
     syncFile?: (path: string) => void;
@@ -8,6 +9,7 @@ export interface EditorLanguageServerRuntimeOptions {
     rootUrl?: string;
     cpp?: {
         baseUrl?: string;
+        loader?: RuntimeAssetLoader;
     };
     python?: {
         baseUrl?: string;

package/dist/playground/assetBridge.js

@@ -1,9 +1,15 @@
-import { JAVA_RUNTIME_LOAD_ASSETS, PYTHON_RUNTIME_LOAD_ASSETS } from './assets';
+import { CLANGD_RUNTIME_LOAD_ASSETS, CLANG_RUNTIME_LOAD_ASSETS, JAVA_RUNTIME_LOAD_ASSETS, PYTHON_RUNTIME_LOAD_ASSETS } from './assets';
 const encoder = new TextEncoder();
 const transferBuffer = (bytes) => bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength
     ? bytes.buffer
     : bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
-const expectedAssetsForRuntime = (runtime) => new Set(runtime === 'python' ? [...PYTHON_RUNTIME_LOAD_ASSETS] : [...JAVA_RUNTIME_LOAD_ASSETS]);
+const expectedAssetsForRuntime = (runtime) => new Set(runtime === 'python'
+    ? [...PYTHON_RUNTIME_LOAD_ASSETS]
+    : runtime === 'java'
+        ? [...JAVA_RUNTIME_LOAD_ASSETS]
+        : runtime === 'clang'
+            ? [...CLANG_RUNTIME_LOAD_ASSETS]
+            : [...CLANGD_RUNTIME_LOAD_ASSETS]);
 class RuntimeLoadProgress {
     fractions = new Map();
     expectedAssets;

package/dist/playground/assets.d.ts

@@ -1,4 +1,4 @@
-export type RuntimeAssetRuntime = 'python' | 'java';
+export type RuntimeAssetRuntime = 'python' | 'java' | 'clang' | 'clangd';
 export interface RuntimeAssetLoadRequest {
     runtime: RuntimeAssetRuntime;
     asset: string;
@@ -42,6 +42,8 @@ export interface PlaygroundRuntimeAssets {
     rootUrl?: string;
     python?: RuntimeAssetConfig;
     java?: RuntimeAssetConfig;
+    clang?: RuntimeAssetConfig;
+    clangd?: RuntimeAssetConfig;
     rust?: RustRuntimeAssetConfig;
     go?: GoRuntimeAssetConfig;
     ocaml?: OcamlRuntimeAssetConfig;
@@ -68,6 +70,8 @@ export interface ResolvedRuntimeAssetConfig {
 }
 export declare const PYTHON_RUNTIME_LOAD_ASSETS: readonly ["pyodide.asm.js", "pyodide-lock.json", "pyodide.asm.wasm", "python_stdlib.zip"];
 export declare const JAVA_RUNTIME_LOAD_ASSETS: readonly ["compiler.wasm-runtime.js", "compiler.wasm", "compile-classlib-teavm.bin", "runtime-classlib-teavm.bin"];
+export declare const CLANG_RUNTIME_LOAD_ASSETS: readonly ["bin/memfs.zip", "bin/clang.zip", "bin/lld.zip", "bin/sysroot.tar.zip"];
+export declare const CLANGD_RUNTIME_LOAD_ASSETS: readonly ["clangd.js", "clangd.wasm.gz"];
 export declare function resolveRuntimeAssetConfig(runtime: RuntimeAssetRuntime, options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): ResolvedRuntimeAssetConfig;
 export declare function resolveRustCompilerUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): any;
 export declare function resolveGoCompilerUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): any;

package/dist/playground/assets.js

@@ -12,15 +12,23 @@ export const JAVA_RUNTIME_LOAD_ASSETS = [
     'compile-classlib-teavm.bin',
     'runtime-classlib-teavm.bin'
 ];
+export const CLANG_RUNTIME_LOAD_ASSETS = [
+    'bin/memfs.zip',
+    'bin/clang.zip',
+    'bin/lld.zip',
+    'bin/sysroot.tar.zip'
+];
+export const CLANGD_RUNTIME_LOAD_ASSETS = ['clangd.js', 'clangd.wasm.gz'];
 const PYTHON_VIRTUAL_BASE_URL = 'https://wasm-idle.invalid/python/';
 const JAVA_VIRTUAL_BASE_URL = 'https://wasm-idle.invalid/java/';
+const CLANG_VIRTUAL_BASE_URL = 'https://wasm-idle.invalid/clang/';
+const CLANGD_VIRTUAL_BASE_URL = 'https://wasm-idle.invalid/clangd/';
 const normalizeBaseUrl = (baseUrl, currentUrl = '') => {
     const normalized = baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
     return currentUrl ? new URL(normalized, currentUrl).href : normalized;
 };
 const resolveConfiguredUrl = (url, currentUrl = '') => currentUrl ? new URL(url, currentUrl).href : url;
 const normalizeRootUrl = (rootUrl) => rootUrl.endsWith('/') ? rootUrl.slice(0, -1) : rootUrl;
-const isLocalHostname = (hostname) => hostname === 'localhost' || hostname === '127.0.0.1';
 const resolvePythonBaseUrl = (rootUrl = '', currentUrl = '') => normalizeBaseUrl(`${normalizeRootUrl(rootUrl) || ''}/pyodide/`, currentUrl);
 const resolvePythonRuntimeAssetConfig = (options, currentUrl = '') => {
     if (typeof options === 'string') {
@@ -93,10 +101,85 @@ const resolveJavaRuntimeAssetConfig = (options, currentUrl = '') => {
         useAssetBridge: false
     };
 };
+const resolveClangRuntimeAssetConfig = (options, currentUrl = '') => {
+    if (typeof options === 'string') {
+        return {
+            baseUrl: normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/clang/`, currentUrl),
+            useAssetBridge: false
+        };
+    }
+    const runtimeConfig = options?.clang;
+    if (runtimeConfig?.baseUrl) {
+        return {
+            baseUrl: normalizeBaseUrl(runtimeConfig.baseUrl, currentUrl),
+            loader: runtimeConfig.loader,
+            useAssetBridge: !!runtimeConfig.loader
+        };
+    }
+    if (options?.rootUrl) {
+        return {
+            baseUrl: normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/clang/`, currentUrl),
+            loader: runtimeConfig?.loader,
+            useAssetBridge: !!runtimeConfig?.loader
+        };
+    }
+    if (runtimeConfig?.loader) {
+        return {
+            baseUrl: CLANG_VIRTUAL_BASE_URL,
+            loader: runtimeConfig.loader,
+            useAssetBridge: true
+        };
+    }
+    return {
+        baseUrl: normalizeBaseUrl('/clang/', currentUrl),
+        useAssetBridge: false
+    };
+};
+const resolveClangdRuntimeAssetConfig = (options, currentUrl = '') => {
+    if (typeof options === 'string') {
+        return {
+            baseUrl: normalizeBaseUrl(`${normalizeRootUrl(options) || ''}/clangd/`, currentUrl),
+            useAssetBridge: false
+        };
+    }
+    const runtimeConfig = options?.clangd;
+    if (runtimeConfig?.baseUrl) {
+        return {
+            baseUrl: normalizeBaseUrl(runtimeConfig.baseUrl, currentUrl),
+            loader: runtimeConfig.loader,
+            useAssetBridge: !!runtimeConfig.loader
+        };
+    }
+    if (options?.rootUrl) {
+        return {
+            baseUrl: normalizeBaseUrl(`${normalizeRootUrl(options.rootUrl) || ''}/clangd/`, currentUrl),
+            loader: runtimeConfig?.loader,
+            useAssetBridge: !!runtimeConfig?.loader
+        };
+    }
+    if (runtimeConfig?.loader) {
+        return {
+            baseUrl: CLANGD_VIRTUAL_BASE_URL,
+            loader: runtimeConfig.loader,
+            useAssetBridge: true
+        };
+    }
+    return {
+        baseUrl: normalizeBaseUrl('/clangd/', currentUrl),
+        useAssetBridge: false
+    };
+};
 export function resolveRuntimeAssetConfig(runtime, options, currentUrl = '') {
-    return runtime === 'python'
-        ? resolvePythonRuntimeAssetConfig(options, currentUrl)
-        : resolveJavaRuntimeAssetConfig(options, currentUrl);
+    switch (runtime) {
+        case 'python':
+            return resolvePythonRuntimeAssetConfig(options, currentUrl);
+        case 'java':
+            return resolveJavaRuntimeAssetConfig(options, currentUrl);
+        case 'clang':
+            return resolveClangRuntimeAssetConfig(options, currentUrl);
+        case 'clangd':
+            return resolveClangdRuntimeAssetConfig(options, currentUrl);
+    }
 }
 export function resolveRustCompilerUrl(options, currentUrl = '') {
     const configuredCompilerUrl = (typeof options === 'object' && options?.rust?.compilerUrl) ||
@@ -206,49 +289,7 @@ export function resolveTinyGoHostCompileUrls(options, currentUrl = '') {
     if (configuredHostCompileUrl) {
         return [resolveConfiguredUrl(configuredHostCompileUrl, currentUrl)];
     }
-    const urls = [];
-    const pushUrl = (url) => {
-        const resolvedUrl = resolveConfiguredUrl(url, currentUrl);
-        if (!urls.includes(resolvedUrl)) {
-            urls.push(resolvedUrl);
-        }
-    };
-    let currentPageUrl = null;
-    try {
-        currentPageUrl = currentUrl ? new URL(currentUrl) : null;
-    }
-    catch {
-        currentPageUrl = null;
-    }
-    const canAutoDeriveHostCompileUrls = currentPageUrl !== null &&
-        isLocalHostname(currentPageUrl.hostname) &&
-        (currentPageUrl.protocol === 'http:' || currentPageUrl.protocol === 'https:');
-    if (!canAutoDeriveHostCompileUrls || currentPageUrl === null) {
-        return urls;
-    }
-    if (typeof options === 'string') {
-        pushUrl(`${normalizeRootUrl(options) || ''}/api/tinygo/compile`);
-    }
-    else if (options?.rootUrl) {
-        pushUrl(`${normalizeRootUrl(options.rootUrl) || ''}/api/tinygo/compile`);
-    }
-    else {
-        const currentPathname = currentPageUrl.pathname.endsWith('/')
-            ? currentPageUrl.pathname
-            : `${currentPageUrl.pathname}/`;
-        pushUrl(`${currentPageUrl.origin}${currentPathname}api/tinygo/compile`);
-    }
-    const moduleUrl = resolveTinyGoModuleUrl(options, currentUrl);
-    if (moduleUrl) {
-        const moduleAssetUrl = new URL(moduleUrl, currentUrl || undefined);
-        if (moduleAssetUrl.protocol === 'http:' || moduleAssetUrl.protocol === 'https:') {
-            pushUrl(new URL('../api/tinygo/compile', moduleAssetUrl).toString());
-        }
-    }
-    if (currentPageUrl.port !== '4175') {
-        pushUrl(`${currentPageUrl.protocol}//${currentPageUrl.hostname}:4175/api/tinygo/compile`);
-    }
-    return urls;
+    return [];
 }
 export function resolveTinyGoHostCompileUrl(options, currentUrl = '') {
     return resolveTinyGoHostCompileUrls(options, currentUrl)[0] || '';

package/dist/playground/clang.d.ts

@@ -1,5 +1,6 @@
 import type { DebugCommand, DebugSessionEvent, SandboxExecutionOptions } from './options';
-import type { PlaygroundRuntimeAssets } from './assets';
+import { WorkerAssetBridge } from './assetBridge';
+import { type PlaygroundRuntimeAssets } from './assets';
 import type { Sandbox } from './sandbox';
 import type { Writable } from 'svelte/store';
 declare class Clang implements Sandbox {
@@ -21,9 +22,10 @@ declare class Clang implements Sandbox {
     waitingForInput: boolean;
     pendingEof: boolean;
     exit: boolean;
+    assetBridge: WorkerAssetBridge | null;
     activeReject: ((reason?: string) => void) | null;
     constructor(language: 'C' | 'CPP');
-    load(runtimeAssets?: string | PlaygroundRuntimeAssets, code?: string, log?: boolean, args?: string[], _options?: SandboxExecutionOptions, _progress?: {
+    load(runtimeAssets?: string | PlaygroundRuntimeAssets, code?: string, log?: boolean, args?: string[], _options?: SandboxExecutionOptions, progress?: {
         set?: (value: number) => void;
     } | import('svelte/store').Writable<number>): Promise<void>;
     write(input: string): void;