wasm-idle 0.2.5 → 0.3.1

package/dist/clang/memory/memFs.d.ts

@@ -6,6 +6,7 @@ interface MemFsOptions {
     stdinStr?: string;
     path: string;
     progress?: Writable<number>;
+    trace?: (message: string) => void;
 }
 export default class MemFS {
     ready: Promise<void>;
@@ -14,6 +15,7 @@ export default class MemFS {
     stdinStr: string;
     stdin: () => string;
     stdout: (str: string) => void;
+    trace: (message: string) => void;
     instance: WebAssembly.Instance;
     exports: any;
     out: boolean;
@@ -22,7 +24,7 @@ export default class MemFS {
     setStdinStr(str: string): void;
     addDirectory(path: string): void;
     addFile(path: string, contents: string | ArrayBuffer | Uint8Array): void;
-    getFileContents(path: string): Uint8Array<ArrayBuffer>;
+    getFileContents(path: string): Uint8Array<ArrayBufferLike>;
     abort(): void;
     host_write(fd: number, iovs: number, iovs_len: number, nwritten_out: number): number;
     host_read(fd: number, iovs: number, iovs_len: number, nread: number): number;

package/dist/clang/memory/memFs.js

@@ -4,6 +4,7 @@ import { AbortError, assert } from '../error';
 import { compile } from '../wasm';
 import { memfsUrl } from '../url';
 const ESUCCESS = 0;
+const previewText = (text) => JSON.stringify(text.length > 96 ? text.slice(0, 93) + '...' : text);
 export default class MemFS {
     ready;
     mem = null;
@@ -11,6 +12,7 @@ export default class MemFS {
     stdinStr;
     stdin;
     stdout;
+    trace;
     instance = null;
     exports;
     out = true;
@@ -18,6 +20,7 @@ export default class MemFS {
         this.stdin = options.stdin;
         this.stdout = options.stdout;
         this.stdinStr = options.stdinStr || '';
+        this.trace = options.trace || (() => { });
         const env = bindNew(this, 'abort', 'host_write', 'host_read', 'memfs_log', 'copy_in', 'copy_out');
         this.ready = compile(memfsUrl(options.path), options.progress)
             .then((module) => WebAssembly.instantiate(module, { env }))
@@ -57,6 +60,7 @@ export default class MemFS {
         return new Uint8Array(this.mem.buffer, addr, size);
     }
     abort() {
+        this.trace('abort()');
         throw new AbortError();
     }
     host_write(fd, iovs, iovs_len, nwritten_out) {
@@ -73,6 +77,7 @@ export default class MemFS {
             size += len;
         }
         this.hostMem_.write32(nwritten_out, size);
+        this.trace(`host_write(fd=${fd}, bytes=${size}, data=${previewText(str)})`);
         if (this.out)
             this.stdout(str);
         return ESUCCESS;
@@ -91,18 +96,24 @@ export default class MemFS {
             const lenToWrite = Math.min(len, this.stdinStr.length);
             if (lenToWrite === 0)
                 break;
+            const chunk = this.stdinStr.substring(0, lenToWrite);
             this.hostMem_.write(buf, this.stdinStr.substring(0, lenToWrite));
             this.stdinStr = this.stdinStr.substring(lenToWrite);
             size += lenToWrite;
+            this.trace(`host_read(fd=${fd}, bytes=${lenToWrite}, data=${previewText(chunk)})`);
             if (lenToWrite !== len)
                 break;
         }
         this.hostMem_.write32(nread, size);
+        if (size === 0)
+            this.trace(`host_read(fd=${fd}, bytes=0)`);
         return ESUCCESS;
     }
     memfs_log(buf, len) {
         this.mem.check();
-        console.log(this.mem.readStr(buf, len));
+        const message = this.mem.readStr(buf, len);
+        this.trace(`memfs_log(${previewText(message)})`);
+        console.log(message);
     }
     copy_out(clang_dst, memfs_src, size) {
         this.hostMem_.check();

package/dist/clang/memory/memory.d.ts

@@ -1,12 +1,16 @@
 export default class Memory {
-    memory: DataView;
-    buffer: ArrayBuffer;
+    memory: WebAssembly.Memory;
+    view: DataView;
+    buffer: ArrayBufferLike;
     u8: Uint8Array;
     u32: Uint32Array;
-    constructor(memory: DataView);
+    constructor(memory: WebAssembly.Memory);
     check(): void;
     read8(o: number): number;
     read32(o: number): number;
+    readInt32(o: number): number;
+    readFloat32(o: number): number;
+    readFloat64(o: number): number;
     readStr(o: number, len: number): string;
     readStrR(o: number, len: number): string;
     write8(o: number, v: number): void;
@@ -14,5 +18,5 @@ export default class Memory {
     write64(o: number, vlo: number, vhi?: number): void;
     writeStr(o: number, str: string): number;
     writeUint8(o: number, arr: ArrayLike<number>): number;
-    write(o: number, buf: ArrayBuffer | string | Uint8Array): number;
+    write(o: number, buf: ArrayBufferLike | string | Uint8Array): number;
 }

package/dist/clang/memory/memory.js

@@ -1,18 +1,21 @@
 import { readStr, readStrR } from '../encode';
 export default class Memory {
     memory;
+    view;
     buffer;
     u8;
     u32;
     constructor(memory) {
         this.memory = memory;
         this.buffer = memory.buffer;
+        this.view = new DataView(this.buffer);
         this.u8 = new Uint8Array(this.buffer);
         this.u32 = new Uint32Array(this.buffer);
     }
     check() {
         if (this.buffer.byteLength === 0) {
             this.buffer = this.memory.buffer;
+            this.view = new DataView(this.buffer);
             this.u8 = new Uint8Array(this.buffer);
             this.u32 = new Uint32Array(this.buffer);
         }
@@ -23,6 +26,15 @@ export default class Memory {
     read32(o) {
         return this.u32[o >> 2];
     }
+    readInt32(o) {
+        return this.view.getInt32(o, true);
+    }
+    readFloat32(o) {
+        return this.view.getFloat32(o, true);
+    }
+    readFloat64(o) {
+        return this.view.getFloat64(o, true);
+    }
     readStr(o, len) {
         return readStr(this.u8, o, len);
     }
@@ -51,6 +63,8 @@ export default class Memory {
     write(o, buf) {
         if (buf instanceof ArrayBuffer)
             return this.writeUint8(o, new Uint8Array(buf));
+        if (buf instanceof SharedArrayBuffer)
+            return this.writeUint8(o, new Uint8Array(buf));
         else if (typeof buf === 'string')
             return this.writeUint8(o, buf.split('').map((x) => x.charCodeAt(0)));
         else

package/dist/clang/memory/tar.d.ts

@@ -1,2 +1,2 @@
 import type { MemFS } from './';
-export default function untar(buffer: ArrayBuffer, memfs: MemFS): void;
+export default function untar(buffer: Uint8Array | ArrayBufferLike, memfs: MemFS): void;

package/dist/clang/memory/tar.js

@@ -1,7 +1,7 @@
 import { readStr, readOct } from '../encode';
 import { assert } from '../error';
 function* readEntry(buffer) {
-    const u8 = new Uint8Array(buffer);
+    const u8 = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
     let offset = 0;
     const str = (len) => {
         offset += len;

package/dist/clang/wasm.d.ts

@@ -1,4 +1,4 @@
 import type { Writable } from 'svelte/store';
-export declare const readBuffer: (name: string, progress?: Writable<number>) => Promise<Uint8Array<ArrayBufferLike>>;
+export declare const readBuffer: (name: string, progress?: Writable<number>) => Promise<Uint8Array<ArrayBuffer>>;
 export declare function compile(filename: string, progress?: Writable<number>): Promise<any>;
 export declare function getInstance(module: WebAssembly.Module, imports: WebAssembly.Imports): Promise<WebAssembly.Instance>;

package/dist/clang/wasm.js

@@ -2,17 +2,24 @@ import * as zip from '@zip.js/zip.js';
 const store = {};
 export const readBuffer = async (name, progress) => {
     const response = await fetch(name);
+    const contentLength = +(response.headers.get('Content-Length') || 0);
+    if (!response.body) {
+        progress?.set?.(1);
+        return new Uint8Array(await response.arrayBuffer());
+    }
     const r = response.body.getReader();
-    const contentLength = +response.headers.get('Content-Length');
     let receivedLength = 0;
-    let chunks = [];
+    const chunks = [];
     while (true) {
         const { done, value } = await r.read();
         if (done)
             break;
-        chunks.push(value);
+        if (!value)
+            continue;
+        chunks.push(Uint8Array.from(value));
         receivedLength += value.length;
-        progress?.set?.(receivedLength / contentLength);
+        if (contentLength > 0)
+            progress?.set?.(receivedLength / contentLength);
     }
     progress?.set?.(1);
     const chunksAll = new Uint8Array(receivedLength); // (4.1)
@@ -24,6 +31,8 @@ export const readBuffer = async (name, progress) => {
     const reader = new zip.ZipReader(new zip.Uint8ArrayReader(chunksAll));
     const entries = await reader.getEntries();
     for (const entry of entries) {
+        if (!('getData' in entry))
+            continue;
         const data = await entry.getData(new zip.Uint8ArrayWriter());
         return data;
     }

package/dist/clangd/config.d.ts

@@ -0,0 +1,18 @@
+export declare const CLANGD_WORKSPACE_PATH = "/workspace";
+export declare const CLANGD_WORKSPACE_URI = "file:///workspace";
+export declare const CLANGD_CPP_FILE_PATH = "/workspace/main.cpp";
+export declare const CLANGD_CPP_FILE_URI = "file:///workspace/main.cpp";
+export type ClangdStatus = {
+    state: 'disabled';
+} | {
+    state: 'loading';
+    loaded?: number;
+    total?: number;
+} | {
+    state: 'ready';
+} | {
+    state: 'error';
+    message: string;
+};
+export declare const normalizeClangdBaseUrl: (baseUrl: string) => string;
+export declare const createClangdCompileFlags: () => string[];

package/dist/clangd/config.js

@@ -0,0 +1,14 @@
+export const CLANGD_WORKSPACE_PATH = '/workspace';
+export const CLANGD_WORKSPACE_URI = `file://${CLANGD_WORKSPACE_PATH}`;
+export const CLANGD_CPP_FILE_PATH = `${CLANGD_WORKSPACE_PATH}/main.cpp`;
+export const CLANGD_CPP_FILE_URI = `file://${CLANGD_CPP_FILE_PATH}`;
+export const normalizeClangdBaseUrl = (baseUrl) => baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+export const createClangdCompileFlags = () => [
+    '-std=gnu++2a',
+    '-xc++',
+    '--target=wasm32-wasi',
+    '-isystem/usr/include/c++/v1',
+    '-isystem/usr/include/wasm32-wasi/c++/v1',
+    '-isystem/usr/include',
+    '-isystem/usr/include/wasm32-wasi'
+];

package/dist/clangd/jsonStream.d.ts

@@ -0,0 +1,9 @@
+export declare class JsonStream {
+    inJson: boolean;
+    rawText: number[];
+    unbalancedBraces: number;
+    inString: boolean;
+    inEscape: number;
+    textDecoder: TextDecoder;
+    insert(charCode: number): string | null;
+}

package/dist/clangd/jsonStream.js

@@ -0,0 +1,48 @@
+const QUOTE = 34;
+const LEFT_BRACE = 123;
+const RIGHT_BRACE = 125;
+const BACKSLASH = 92;
+export class JsonStream {
+    inJson = false;
+    rawText = [];
+    unbalancedBraces = 0;
+    inString = false;
+    inEscape = 0;
+    textDecoder = new TextDecoder();
+    insert(charCode) {
+        if (!this.inJson && charCode === LEFT_BRACE) {
+            this.inJson = true;
+            this.rawText = [];
+        }
+        if (!this.inJson)
+            return null;
+        this.rawText.push(charCode);
+        if (this.inString) {
+            if (this.inEscape) {
+                if (charCode === 75)
+                    this.inEscape += 4;
+                this.inEscape -= 1;
+            }
+            else if (charCode === BACKSLASH) {
+                this.inEscape = 1;
+            }
+            else if (charCode === QUOTE) {
+                this.inString = false;
+            }
+        }
+        else if (charCode === LEFT_BRACE) {
+            this.unbalancedBraces += 1;
+        }
+        else if (charCode === RIGHT_BRACE) {
+            this.unbalancedBraces -= 1;
+            if (this.unbalancedBraces === 0) {
+                this.inJson = false;
+                return this.textDecoder.decode(new Uint8Array(this.rawText));
+            }
+        }
+        else if (charCode === QUOTE) {
+            this.inString = true;
+        }
+        return null;
+    }
+}

package/dist/clangd/session.d.ts

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

package/dist/clangd/session.js

@@ -0,0 +1,94 @@
+import { CloseAction, ErrorAction, MonacoLanguageClient, MonacoServices } from '@hancomac/monaco-languageclient';
+import { BrowserMessageReader, BrowserMessageWriter } from 'vscode-jsonrpc/browser';
+import { CLANGD_CPP_FILE_URI, CLANGD_WORKSPACE_URI, normalizeClangdBaseUrl } from './config';
+import ClangdWorker from './worker?worker';
+let servicesInstalled = false;
+export class ClangdSession {
+    Monaco;
+    baseUrl;
+    onStatus;
+    worker = null;
+    languageClient = null;
+    constructor(MonacoModule, baseUrl, onStatus) {
+        this.Monaco = MonacoModule;
+        this.onStatus = onStatus;
+        this.baseUrl = normalizeClangdBaseUrl(baseUrl);
+        if (!servicesInstalled) {
+            MonacoServices.install(MonacoModule);
+            servicesInstalled = true;
+        }
+    }
+    createModel(value) {
+        const uri = this.Monaco.Uri.parse(CLANGD_CPP_FILE_URI);
+        this.Monaco.editor.getModel(uri)?.dispose();
+        return this.Monaco.editor.createModel(value, 'cpp', uri);
+    }
+    async start() {
+        if (this.worker)
+            return;
+        this.onStatus?.({ state: 'loading' });
+        const worker = new ClangdWorker();
+        this.worker = worker;
+        await new Promise((resolve, reject) => {
+            const cleanup = () => {
+                worker.removeEventListener('message', handleMessage);
+                worker.removeEventListener('error', handleError);
+            };
+            const handleMessage = (event) => {
+                const { type, value, max, message } = event.data || {};
+                if (type === 'progress') {
+                    this.onStatus?.({ state: 'loading', loaded: value, total: max });
+                    return;
+                }
+                if (type === 'ready') {
+                    cleanup();
+                    resolve();
+                    return;
+                }
+                if (type === 'error') {
+                    cleanup();
+                    reject(new Error(message || 'clangd failed to start'));
+                }
+            };
+            const handleError = (event) => {
+                cleanup();
+                reject(event.error || new Error(event.message || 'clangd worker failed'));
+            };
+            worker.addEventListener('message', handleMessage);
+            worker.addEventListener('error', handleError);
+            worker.postMessage({ type: 'init', baseUrl: this.baseUrl });
+        });
+        const reader = new BrowserMessageReader(worker);
+        const writer = new BrowserMessageWriter(worker);
+        this.languageClient = new MonacoLanguageClient({
+            name: 'wasm-idle clangd',
+            clientOptions: {
+                documentSelector: ['cpp'],
+                errorHandler: {
+                    error: () => ({ action: ErrorAction.Continue }),
+                    closed: () => ({ action: CloseAction.DoNotRestart })
+                },
+                workspaceFolder: {
+                    index: 0,
+                    name: 'workspace',
+                    uri: this.Monaco.Uri.parse(CLANGD_WORKSPACE_URI)
+                }
+            },
+            connectionProvider: {
+                get: async () => ({ reader, writer })
+            }
+        });
+        this.languageClient.start();
+        reader.onClose(() => {
+            this.languageClient?.stop();
+            this.onStatus?.({ state: 'disabled' });
+        });
+        this.onStatus?.({ state: 'ready' });
+    }
+    dispose() {
+        this.languageClient?.stop();
+        this.languageClient = null;
+        this.worker?.terminate();
+        this.worker = null;
+    }
+}

package/dist/clangd/worker.d.ts

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

package/dist/clangd/worker.js

@@ -0,0 +1,130 @@
+/// <reference lib="WebWorker" />
+import { CLANGD_CPP_FILE_PATH, CLANGD_WORKSPACE_PATH, createClangdCompileFlags, normalizeClangdBaseUrl } from './config';
+import { JsonStream } from './jsonStream';
+import { BrowserMessageReader, BrowserMessageWriter } from 'vscode-jsonrpc/browser';
+const textEncoder = new TextEncoder();
+const jsonStream = new JsonStream();
+let resolveStdinReady = () => { };
+const stdinChunks = [];
+const currentStdinChunk = [];
+const stdin = () => {
+    if (currentStdinChunk.length === 0) {
+        if (stdinChunks.length === 0)
+            return null;
+        const nextChunk = stdinChunks.shift();
+        if (!nextChunk)
+            return null;
+        currentStdinChunk.push(...textEncoder.encode(nextChunk), null);
+    }
+    return currentStdinChunk.shift() ?? null;
+};
+const stdinReady = async () => {
+    if (stdinChunks.length === 0) {
+        return new Promise((resolve) => {
+            resolveStdinReady = resolve;
+        });
+    }
+};
+let writer = null;
+const stdout = (charCode) => {
+    const json = jsonStream.insert(charCode);
+    if (json && writer)
+        writer.write(JSON.parse(json));
+};
+const stderr = () => { };
+const onAbort = () => {
+    writer?.end();
+    self.reportError?.('clangd aborted');
+};
+self.addEventListener('message', async (event) => {
+    if (event.data?.type !== 'init')
+        return;
+    const baseUrl = normalizeClangdBaseUrl(event.data.baseUrl);
+    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 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 } : {})
+                });
+            }
+        }
+        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' });
+        const wasmDataUrl = URL.createObjectURL(wasmBlob);
+        const { default: Clangd } = await jsModule;
+        const clangd = await Clangd({
+            thisProgram: '/usr/bin/clangd',
+            mainScriptUrlOrBlob: jsDataUrl,
+            locateFile: (path, prefix) => path.endsWith('.wasm') ? wasmDataUrl : `${prefix}${path}`,
+            stdinReady,
+            stdin,
+            stdout,
+            stderr,
+            onExit: onAbort,
+            onAbort
+        });
+        clangd.FS.mkdirTree(CLANGD_WORKSPACE_PATH);
+        clangd.FS.writeFile(CLANGD_CPP_FILE_PATH, '');
+        clangd.FS.writeFile(`${CLANGD_WORKSPACE_PATH}/.clangd`, JSON.stringify({
+            CompileFlags: {
+                Add: createClangdCompileFlags()
+            }
+        }));
+        clangd.callMain([]);
+        writer = new BrowserMessageWriter(self);
+        const reader = new BrowserMessageReader(self);
+        reader.listen((data) => {
+            const body = JSON.stringify(data).replace(/[\u007F-\uFFFF]/g, (character) => {
+                return '\\u' + character.codePointAt(0)?.toString(16).padStart(4, '0');
+            });
+            stdinChunks.push(`Content-Length: ${body.length}\r\n`, '\r\n', body);
+            resolveStdinReady();
+        });
+        self.postMessage({ type: 'ready', value: receivedLength });
+    }
+    catch (error) {
+        self.postMessage({
+            type: 'error',
+            message: error instanceof Error ? error.message : String(error)
+        });
+    }
+});

package/dist/debug/editor/index.d.ts

@@ -0,0 +1 @@
+export { MonacoDebugView } from './monaco';

package/dist/debug/editor/index.js

@@ -0,0 +1 @@
+export { MonacoDebugView } from './monaco';

package/dist/debug/editor/monaco.d.ts

@@ -0,0 +1,18 @@
+import type { DebugVariable } from '../../playground/options';
+import type { DebugLanguageAdapter } from '../language';
+import type monaco from 'monaco-editor';
+export declare class MonacoDebugView {
+    Monaco: typeof monaco;
+    editor: monaco.editor.IStandaloneCodeEditor;
+    breakpointDecorations: monaco.editor.IEditorDecorationsCollection;
+    inlineValueDecorations: monaco.editor.IEditorDecorationsCollection;
+    pausedLineWidget: monaco.editor.IContentWidget | null;
+    pausedLineWidgetNode: HTMLDivElement | null;
+    mouseHandler: monaco.IDisposable | null;
+    breakpoints: number[];
+    onBreakpointsChange?: (lines: number[]) => void;
+    constructor(MonacoModule: typeof monaco, editor: monaco.editor.IStandaloneCodeEditor, onBreakpointsChange?: (lines: number[]) => void);
+    setBreakpoints(lines: number[]): void;
+    setPauseState(pausedLine: number | null, locals: DebugVariable[], adapter: DebugLanguageAdapter | null): void;
+    dispose(): void;
+}