wasm-idle 0.5.0 → 0.6.0

package/dist/clangd/worker.js

@@ -26,6 +26,7 @@ const stdinReady = async () => {
     }
 };
 let writer = null;
+let clangdRuntime = null;
 const stdout = (charCode) => {
     const json = jsonStream.insert(charCode);
     if (json && writer)
@@ -36,7 +37,22 @@ const onAbort = () => {
     writer?.end();
     self.reportError?.('clangd aborted');
 };
+const syncWorkspaceFile = (filePath) => {
+    if (!clangdRuntime)
+        return;
+    const normalizedFilePath = filePath.startsWith(CLANGD_WORKSPACE_PATH)
+        ? filePath
+        : `${CLANGD_WORKSPACE_PATH}/${filePath.replace(/^\/+/, '')}`;
+    const lastSlash = normalizedFilePath.lastIndexOf('/');
+    const directoryPath = lastSlash > 0 ? normalizedFilePath.slice(0, lastSlash) : CLANGD_WORKSPACE_PATH;
+    clangdRuntime.FS.mkdirTree(directoryPath);
+    clangdRuntime.FS.writeFile(normalizedFilePath, '');
+};
 self.addEventListener('message', async (event) => {
+    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);
@@ -91,7 +107,7 @@ self.addEventListener('message', async (event) => {
         const wasmBlob = new Blob([wasmBytes.buffer], { type: 'application/wasm' });
         const wasmDataUrl = URL.createObjectURL(wasmBlob);
         const { default: Clangd } = await jsModule;
-        const clangd = await Clangd({
+        clangdRuntime = await Clangd({
             thisProgram: '/usr/bin/clangd',
             mainScriptUrlOrBlob: jsDataUrl,
             locateFile: (path, prefix) => path.endsWith('.wasm') ? wasmDataUrl : `${prefix}${path}`,
@@ -102,14 +118,14 @@ self.addEventListener('message', async (event) => {
             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({
+        clangdRuntime.FS.mkdirTree(CLANGD_WORKSPACE_PATH);
+        syncWorkspaceFile(CLANGD_CPP_FILE_PATH);
+        clangdRuntime.FS.writeFile(`${CLANGD_WORKSPACE_PATH}/.clangd`, JSON.stringify({
             CompileFlags: {
                 Add: createClangdCompileFlags()
             }
         }));
-        clangd.callMain([]);
+        clangdRuntime.callMain([]);
         writer = new BrowserMessageWriter(self);
         const reader = new BrowserMessageReader(self);
         reader.listen((data) => {

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import Terminal from './terminal';
 export { cppDebugLanguageAdapter, pythonDebugLanguageAdapter, evaluateDebugExpression, createDebugSessionController, MonacoDebugView, attachMonacoDebugActions, selectInlineDebugLocals } from './debug';
+export { getEditorLanguageServer, getCppLanguageServer, getPythonLanguageServer, resolveCppLanguageServerBaseUrl, resolvePythonLanguageServerBaseUrl } from './lsp';
 import playground, { createPlaygroundBinding } from './playground';
 export default Terminal;
 export { createPlaygroundBinding, playground };
@@ -9,3 +10,4 @@ export type { DebugSessionController, DebugSessionControllerOptions, DebugWatchV
 export type { PlaygroundRuntimeAssets, RuntimeAssetConfig, RuntimeAssetLoadRequest, RuntimeAssetLoader, RuntimeAssetLoaderResult } from './playground/assets';
 export type { BoundSandbox, PlaygroundBinding, PlaygroundTerminalProps, SandboxProgress, SandboxRuntimeAssets } from './playground/sandbox';
 export type { DebugLanguageAdapter } from './debug';
+export type { EditorLanguageServerHandle, EditorLanguageServerRuntimeOptions } from './lsp';

package/dist/index.js

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

package/dist/lsp/cpp/server.d.ts

@@ -0,0 +1,2 @@
+import type { EditorLanguageServerRuntimeOptions, EditorLanguageServerHandle } from '../types';
+export declare function getCppLanguageServer(options?: string | EditorLanguageServerRuntimeOptions): Promise<EditorLanguageServerHandle>;

package/dist/lsp/cpp/server.js

@@ -0,0 +1,57 @@
+import { resolveCppLanguageServerBaseUrl } from '../runtime';
+import ClangdWorker from '../../clangd/worker?worker';
+import { BrowserMessageReader, BrowserMessageWriter } from 'vscode-jsonrpc/browser';
+const currentUrl = () => globalThis.location?.href || '';
+async function createServer(baseUrl) {
+    let resolveReady = () => { };
+    let rejectReady = (_error) => { };
+    const ready = new Promise((resolve, reject) => {
+        resolveReady = resolve;
+        rejectReady = reject;
+    });
+    const worker = new ClangdWorker();
+    const cleanup = () => {
+        worker.removeEventListener('message', readyListener);
+        worker.removeEventListener('error', errorListener);
+    };
+    const readyListener = (event) => {
+        switch (event.data?.type) {
+            case 'ready': {
+                cleanup();
+                resolveReady();
+                break;
+            }
+            case 'error': {
+                cleanup();
+                rejectReady(new Error(event.data?.message || 'clangd failed to initialize'));
+                break;
+            }
+        }
+    };
+    const errorListener = (event) => {
+        cleanup();
+        rejectReady(event.error || new Error(event.message || 'clangd worker failed'));
+    };
+    worker.addEventListener('message', readyListener);
+    worker.addEventListener('error', errorListener);
+    worker.postMessage({ type: 'init', baseUrl });
+    await ready;
+    return worker;
+}
+export async function getCppLanguageServer(options) {
+    const baseUrl = resolveCppLanguageServerBaseUrl(options, currentUrl());
+    const worker = await createServer(baseUrl);
+    const reader = new BrowserMessageReader(worker);
+    const writer = new BrowserMessageWriter(worker);
+    return {
+        transport: { reader, writer },
+        syncFile: (path) => {
+            worker.postMessage({ type: 'sync-file', name: path });
+        },
+        dispose: () => {
+            worker.terminate();
+            reader.dispose();
+            writer.dispose();
+        }
+    };
+}

package/dist/lsp/index.d.ts

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

package/dist/lsp/index.js

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

package/dist/lsp/python/main.worker.d.ts

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

package/dist/lsp/python/main.worker.js

@@ -0,0 +1,92 @@
+/// <reference lib="WebWorker" />
+import { loadPyodide } from 'pyodide';
+import packageInitSource from './package/arcturus_python_lsp/__init__.py?raw';
+import packageServerSource from './package/arcturus_python_lsp/server.py?raw';
+let pyodide = null;
+let bridge = null;
+let initPromise = null;
+let configuredPyodideBaseUrl = '/pyodide/';
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function normalizeBaseUrl(baseUrl) {
+    return baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
+}
+function emitTransportMessage(payload) {
+    try {
+        self.postMessage(JSON.parse(payload));
+    }
+    catch (error) {
+        console.error('Failed to emit Python LSP payload', error, payload);
+    }
+}
+function installPythonServerPackage(currentPyodide) {
+    currentPyodide.FS.mkdirTree('/arcturus_lsp/arcturus_python_lsp');
+    currentPyodide.FS.writeFile('/arcturus_lsp/arcturus_python_lsp/__init__.py', packageInitSource);
+    currentPyodide.FS.writeFile('/arcturus_lsp/arcturus_python_lsp/server.py', packageServerSource);
+}
+async function bootstrapPythonBridge(pyodideBaseUrl) {
+    if (bridge)
+        return;
+    if (initPromise)
+        return initPromise;
+    initPromise = (async () => {
+        self.postMessage({ type: 'progress', stage: 'load-pyodide' });
+        pyodide = await loadPyodide({ indexURL: normalizeBaseUrl(pyodideBaseUrl) });
+        pyodide.registerJsModule('arcturus_lsp_bridge', {
+            emit: emitTransportMessage
+        });
+        await pyodide.loadPackage('jedi');
+        installPythonServerPackage(pyodide);
+        await pyodide.runPythonAsync(`
+import sys
+
+if "/arcturus_lsp" not in sys.path:
+    sys.path.insert(0, "/arcturus_lsp")
+
+from arcturus_python_lsp import create_bridge
+
+_arcturus_python_lsp_bridge = create_bridge()
+`);
+        const bridgeProxy = pyodide.globals.get('_arcturus_python_lsp_bridge');
+        bridge = (payload) => {
+            bridgeProxy(payload);
+        };
+        self.postMessage({ type: 'ready' });
+    })().catch((error) => {
+        const message = toErrorMessage(error);
+        console.error('Python LSP bootstrap failed', error);
+        self.postMessage({ type: 'error', error: message });
+        initPromise = null;
+        bridge = null;
+        throw error;
+    });
+    return initPromise;
+}
+self.addEventListener('message', (event) => {
+    const payload = event.data;
+    if (!payload || typeof payload !== 'object')
+        return;
+    if (payload.type === 'init') {
+        configuredPyodideBaseUrl =
+            typeof payload.pyodideBaseUrl === 'string' ? payload.pyodideBaseUrl : '/pyodide/';
+        void bootstrapPythonBridge(configuredPyodideBaseUrl).catch((error) => {
+            console.error('Failed to initialize Python LSP worker', error);
+        });
+        return;
+    }
+    if ('type' in payload)
+        return;
+    const serialized = JSON.stringify(payload);
+    if (bridge) {
+        bridge(serialized);
+        return;
+    }
+    void bootstrapPythonBridge(configuredPyodideBaseUrl)
+        .then(() => {
+        bridge?.(serialized);
+    })
+        .catch((error) => {
+        console.error('Failed to forward LSP message to Python bridge', error);
+    });
+});

package/dist/lsp/python/package/arcturus_python_lsp/__init__.py

@@ -0,0 +1,3 @@
+from .server import create_bridge
+
+__all__ = ["create_bridge"]

package/dist/lsp/python/package/arcturus_python_lsp/server.py

@@ -0,0 +1,462 @@
+from __future__ import annotations
+
+import ast
+import json
+from pathlib import Path
+from urllib.parse import unquote, urlparse
+
+from jedi import Project, Script
+
+from arcturus_lsp_bridge import emit
+
+SERVER_NAME = "arcturus-python-lsp"
+SERVER_VERSION = "0.2.0"
+WORKSPACE_ROOT = "/workspace"
+
+TEXT_DOCUMENT_SYNC_FULL = 1
+DIAGNOSTIC_SEVERITY_ERROR = 1
+
+COMPLETION_ITEM_KIND = {
+    "text": 1,
+    "method": 2,
+    "function": 3,
+    "constructor": 4,
+    "field": 5,
+    "variable": 6,
+    "class": 7,
+    "interface": 8,
+    "module": 9,
+    "property": 10,
+    "unit": 11,
+    "value": 12,
+    "enum": 13,
+    "keyword": 14,
+    "snippet": 15,
+    "color": 16,
+    "file": 17,
+    "reference": 18,
+    "folder": 19,
+    "enumMember": 20,
+    "constant": 21,
+    "struct": 22,
+    "event": 23,
+    "operator": 24,
+    "typeParameter": 25,
+}
+
+SYMBOL_KIND = {
+    "file": 1,
+    "module": 2,
+    "namespace": 3,
+    "package": 4,
+    "class": 5,
+    "method": 6,
+    "property": 7,
+    "field": 8,
+    "constructor": 9,
+    "enum": 10,
+    "interface": 11,
+    "function": 12,
+    "variable": 13,
+    "constant": 14,
+}
+
+COMPLETION_KIND_MAP = {
+    "module": COMPLETION_ITEM_KIND["module"],
+    "class": COMPLETION_ITEM_KIND["class"],
+    "instance": COMPLETION_ITEM_KIND["variable"],
+    "function": COMPLETION_ITEM_KIND["function"],
+    "param": COMPLETION_ITEM_KIND["variable"],
+    "path": COMPLETION_ITEM_KIND["file"],
+    "keyword": COMPLETION_ITEM_KIND["keyword"],
+    "statement": COMPLETION_ITEM_KIND["keyword"],
+    "property": COMPLETION_ITEM_KIND["property"],
+}
+
+SYMBOL_KIND_MAP = {
+    "module": SYMBOL_KIND["module"],
+    "class": SYMBOL_KIND["class"],
+    "function": SYMBOL_KIND["function"],
+    "statement": SYMBOL_KIND["variable"],
+    "instance": SYMBOL_KIND["variable"],
+    "param": SYMBOL_KIND["variable"],
+}
+
+
+def _uri_to_path(uri: str) -> str:
+    if uri.startswith("file://"):
+        return unquote(urlparse(uri).path)
+
+    parsed = urlparse(uri)
+    if parsed.scheme and parsed.path:
+        return unquote(parsed.path)
+
+    return uri
+
+
+def _path_to_uri(path: Path) -> str:
+    return path.as_posix()
+
+
+class Document:
+    def __init__(
+        self,
+        uri: str,
+        source: str,
+        version: int | None = None,
+        language_id: str | None = None,
+    ) -> None:
+        self.uri = uri
+        self.source = source
+        self.version = version
+        self.language_id = language_id
+        self.path = _uri_to_path(uri)
+
+    @property
+    def lines(self) -> list[str]:
+        lines = self.source.splitlines(True)
+        return lines or [""]
+
+    def offset_at(self, position: dict) -> int:
+        line = max(int(position.get("line", 0)), 0)
+        character = max(int(position.get("character", 0)), 0)
+        lines = self.lines
+        if line >= len(lines):
+            return len(self.source)
+
+        offset = sum(len(lines[idx]) for idx in range(line))
+        return offset + min(character, len(lines[line]))
+
+    def apply_change(self, change: dict) -> None:
+        if "range" not in change or change["range"] is None:
+            self.source = change.get("text", "")
+            return
+
+        change_range = change["range"]
+        start = self.offset_at(change_range["start"])
+        end = self.offset_at(change_range["end"])
+        self.source = self.source[:start] + change.get("text", "") + self.source[end:]
+
+
+class ArcturusPythonLsp:
+    def __init__(self) -> None:
+        self.workspace_root = WORKSPACE_ROOT
+        Path(self.workspace_root).mkdir(parents=True, exist_ok=True)
+        self.project = Project(
+            path=self.workspace_root,
+            smart_sys_path=True,
+            load_unsafe_extensions=False,
+        )
+        self.documents: dict[str, Document] = {}
+        self.shutdown_requested = False
+
+    def handle(self, payload: str) -> None:
+        message = json.loads(payload)
+        if message.get("jsonrpc") != "2.0":
+            return
+
+        method = message.get("method")
+        if not method:
+            return
+
+        if "id" in message:
+            self._handle_request(message["id"], method, message.get("params") or {})
+        else:
+            self._handle_notification(method, message.get("params") or {})
+
+    def _emit(self, body: dict) -> None:
+        emit(json.dumps(body))
+
+    def _respond(self, msg_id, result=None, error: dict | None = None) -> None:
+        response = {"jsonrpc": "2.0", "id": msg_id}
+        if error is not None:
+            response["error"] = error
+        else:
+            response["result"] = result
+        self._emit(response)
+
+    def _notify(self, method: str, params: dict) -> None:
+        self._emit({"jsonrpc": "2.0", "method": method, "params": params})
+
+    def _refresh_project(self, root_uri: str | None) -> None:
+        if root_uri:
+            self.workspace_root = _uri_to_path(root_uri)
+
+        Path(self.workspace_root).mkdir(parents=True, exist_ok=True)
+        self.project = Project(
+            path=self.workspace_root,
+            smart_sys_path=True,
+            load_unsafe_extensions=False,
+        )
+
+    def _document(self, uri: str) -> Document:
+        return self.documents[uri]
+
+    def _mirror_document(self, uri: str) -> None:
+        document = self._document(uri)
+        path = Path(document.path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(document.source, encoding="utf-8")
+
+    def _script(self, uri: str) -> Script:
+        document = self._document(uri)
+        return Script(code=document.source, path=document.path, project=self.project)
+
+    def _range_for_name(self, name) -> dict | None:
+        if name.line is None or name.column is None:
+            return None
+
+        return {
+            "start": {"line": name.line - 1, "character": name.column},
+            "end": {"line": name.line - 1, "character": name.column + len(name.name)},
+        }
+
+    def _location_for_name(self, name, fallback_uri: str) -> dict | None:
+        range_value = self._range_for_name(name)
+        if range_value is None:
+            return None
+
+        module_path = getattr(name, "module_path", None)
+        uri = fallback_uri
+        if module_path is not None:
+            uri = _path_to_uri(Path(module_path))
+
+        return {"uri": uri, "range": range_value}
+
+    def _completion_kind(self, name_type: str) -> int:
+        return COMPLETION_KIND_MAP.get(name_type, COMPLETION_ITEM_KIND["text"])
+
+    def _symbol_kind(self, name_type: str) -> int:
+        return SYMBOL_KIND_MAP.get(name_type, SYMBOL_KIND["variable"])
+
+    def _publish_diagnostics(self, uri: str) -> None:
+        document = self._document(uri)
+        diagnostics: list[dict] = []
+
+        try:
+            ast.parse(document.source, filename=document.path)
+        except SyntaxError as error:
+            line = max((error.lineno or 1) - 1, 0)
+            column = max((error.offset or 1) - 1, 0)
+            diagnostics.append(
+                {
+                    "range": {
+                        "start": {"line": line, "character": column},
+                        "end": {"line": line, "character": column + 1},
+                    },
+                    "severity": DIAGNOSTIC_SEVERITY_ERROR,
+                    "source": SERVER_NAME,
+                    "message": error.msg or "Syntax error",
+                }
+            )
+
+        self._notify(
+            "textDocument/publishDiagnostics",
+            {"uri": uri, "diagnostics": diagnostics},
+        )
+
+    def _hover_text(self, definitions) -> str | None:
+        chunks: list[str] = []
+        for definition in definitions:
+            description = getattr(definition, "description", "") or definition.name
+            doc = definition.docstring(raw=False).strip()
+            block = description if not doc else f"{description}\n\n{doc}"
+            if block and block not in chunks:
+                chunks.append(block)
+
+        if not chunks:
+            return None
+
+        return "\n\n---\n\n".join(chunks)
+
+    def _initialize(self, params: dict) -> dict:
+        root_uri = params.get("rootUri")
+        if not root_uri and params.get("workspaceFolders"):
+            root_uri = params["workspaceFolders"][0].get("uri")
+        self._refresh_project(root_uri)
+        return {
+            "capabilities": {
+                "textDocumentSync": TEXT_DOCUMENT_SYNC_FULL,
+                "completionProvider": {
+                    "triggerCharacters": [".", "(", "[", '"', "'"],
+                    "resolveProvider": False,
+                },
+                "hoverProvider": True,
+                "definitionProvider": True,
+                "documentSymbolProvider": True,
+                "signatureHelpProvider": {"triggerCharacters": ["(", ","]},
+            },
+            "serverInfo": {"name": SERVER_NAME, "version": SERVER_VERSION},
+        }
+
+    def _shutdown(self):
+        self.shutdown_requested = True
+        return None
+
+    def _completion(self, params: dict) -> dict:
+        position = params["position"]
+        completions = self._script(params["textDocument"]["uri"]).complete(
+            line=position["line"] + 1,
+            column=position["character"],
+        )
+        items = []
+        for completion in completions:
+            item = {
+                "label": completion.name_with_symbols or completion.name,
+                "kind": self._completion_kind(completion.type),
+                "detail": completion.type,
+                "insertText": completion.complete or completion.name,
+            }
+            doc = completion.docstring(raw=False).strip()
+            if doc:
+                item["documentation"] = doc
+            items.append(item)
+        return {"isIncomplete": False, "items": items}
+
+    def _signature_help(self, params: dict) -> dict | None:
+        position = params["position"]
+        signatures = self._script(params["textDocument"]["uri"]).get_signatures(
+            line=position["line"] + 1,
+            column=position["character"],
+        )
+        if not signatures:
+            return None
+
+        items = []
+        for signature in signatures:
+            items.append(
+                {
+                    "label": signature.to_string(),
+                    "documentation": signature.docstring(raw=False).strip() or None,
+                    "parameters": [
+                        {"label": parameter.to_string()} for parameter in signature.params
+                    ],
+                }
+            )
+
+        return {"signatures": items, "activeSignature": 0, "activeParameter": 0}
+
+    def _hover(self, params: dict) -> dict | None:
+        position = params["position"]
+        definitions = self._script(params["textDocument"]["uri"]).infer(
+            line=position["line"] + 1,
+            column=position["character"],
+        )
+        hover_text = self._hover_text(definitions)
+        if not hover_text:
+            return None
+        return {"contents": {"kind": "markdown", "value": hover_text}}
+
+    def _definition(self, params: dict) -> list[dict] | None:
+        position = params["position"]
+        definitions = self._script(params["textDocument"]["uri"]).goto(
+            line=position["line"] + 1,
+            column=position["character"],
+            follow_imports=True,
+            follow_builtin_imports=True,
+        )
+        locations = [
+            location
+            for location in (
+                self._location_for_name(definition, params["textDocument"]["uri"])
+                for definition in definitions
+            )
+            if location is not None
+        ]
+        return locations or None
+
+    def _document_symbols(self, params: dict) -> list[dict]:
+        names = self._script(params["textDocument"]["uri"]).get_names(
+            all_scopes=True,
+            definitions=True,
+            references=False,
+        )
+        symbols = []
+        for name in names:
+            location = self._location_for_name(name, params["textDocument"]["uri"])
+            if location is None:
+                continue
+            symbols.append(
+                {
+                    "name": name.name,
+                    "kind": self._symbol_kind(name.type),
+                    "location": location,
+                    "containerName": getattr(name, "full_name", None) or name.name,
+                }
+            )
+        return symbols
+
+    def _handle_request(self, msg_id, method: str, params: dict) -> None:
+        try:
+            handlers = {
+                "initialize": self._initialize,
+                "shutdown": self._shutdown,
+                "textDocument/completion": self._completion,
+                "textDocument/signatureHelp": self._signature_help,
+                "textDocument/hover": self._hover,
+                "textDocument/definition": self._definition,
+                "textDocument/documentSymbol": self._document_symbols,
+            }
+            handler = handlers.get(method)
+            if handler is None:
+                self._respond(
+                    msg_id,
+                    error={"code": -32601, "message": f"Method not found: {method}"},
+                )
+                return
+            self._respond(msg_id, result=handler(params))
+        except Exception as error:
+            self._respond(
+                msg_id,
+                error={"code": -32603, "message": str(error) or "Internal server error"},
+            )
+
+    def _handle_notification(self, method: str, params: dict) -> None:
+        try:
+            if method == "initialized":
+                return
+            if method == "exit":
+                self.shutdown_requested = True
+                return
+            if method == "textDocument/didOpen":
+                text_document = params["textDocument"]
+                self.documents[text_document["uri"]] = Document(
+                    uri=text_document["uri"],
+                    source=text_document.get("text", ""),
+                    version=text_document.get("version"),
+                    language_id=text_document.get("languageId"),
+                )
+                self._mirror_document(text_document["uri"])
+                self._publish_diagnostics(text_document["uri"])
+                return
+            if method == "textDocument/didChange":
+                text_document = params["textDocument"]
+                document = self._document(text_document["uri"])
+                for change in params.get("contentChanges", []):
+                    document.apply_change(change)
+                document.version = text_document.get("version")
+                self._mirror_document(text_document["uri"])
+                self._publish_diagnostics(text_document["uri"])
+                return
+            if method == "textDocument/didSave":
+                text_document = params["textDocument"]
+                document = self._document(text_document["uri"])
+                if "text" in params and params["text"] is not None:
+                    document.source = params["text"]
+                self._mirror_document(text_document["uri"])
+                self._publish_diagnostics(text_document["uri"])
+                return
+            if method == "textDocument/didClose":
+                text_document = params["textDocument"]
+                self.documents.pop(text_document["uri"], None)
+                self._notify(
+                    "textDocument/publishDiagnostics",
+                    {"uri": text_document["uri"], "diagnostics": []},
+                )
+        except Exception:
+            return
+
+
+def create_bridge():
+    server = ArcturusPythonLsp()
+    return server.handle

package/dist/lsp/python/server.d.ts

@@ -0,0 +1,2 @@
+import type { EditorLanguageServerHandle, EditorLanguageServerRuntimeOptions } from '../types';
+export declare function getPythonLanguageServer(options?: string | EditorLanguageServerRuntimeOptions): Promise<EditorLanguageServerHandle>;

package/dist/lsp/python/server.js

@@ -0,0 +1,54 @@
+import { resolvePythonLanguageServerBaseUrl } from '../runtime';
+import PythonLspWorker from './main.worker?worker';
+import { BrowserMessageReader, BrowserMessageWriter } from 'vscode-jsonrpc/browser';
+const currentUrl = () => globalThis.location?.href || '';
+async function createServer(pyodideBaseUrl) {
+    let resolveReady = () => { };
+    let rejectReady = (_error) => { };
+    const ready = new Promise((resolve, reject) => {
+        resolveReady = resolve;
+        rejectReady = reject;
+    });
+    const worker = new PythonLspWorker();
+    const cleanup = () => {
+        worker.removeEventListener('message', readyListener);
+        worker.removeEventListener('error', errorListener);
+    };
+    const readyListener = (event) => {
+        switch (event.data?.type) {
+            case 'ready': {
+                cleanup();
+                resolveReady();
+                break;
+            }
+            case 'error': {
+                cleanup();
+                rejectReady(new Error(event.data?.error || 'Python LSP worker failed to initialize'));
+                break;
+            }
+        }
+    };
+    const errorListener = (event) => {
+        cleanup();
+        rejectReady(event.error || new Error(event.message || 'Python LSP worker failed'));
+    };
+    worker.addEventListener('message', readyListener);
+    worker.addEventListener('error', errorListener);
+    worker.postMessage({ type: 'init', pyodideBaseUrl });
+    await ready;
+    return worker;
+}
+export async function getPythonLanguageServer(options) {
+    const pyodideBaseUrl = resolvePythonLanguageServerBaseUrl(options, currentUrl());
+    const worker = await createServer(pyodideBaseUrl);
+    const reader = new BrowserMessageReader(worker);
+    const writer = new BrowserMessageWriter(worker);
+    return {
+        transport: { reader, writer },
+        dispose: () => {
+            worker.terminate();
+            reader.dispose();
+            writer.dispose();
+        }
+    };
+}

package/dist/lsp/registry.d.ts

@@ -0,0 +1,2 @@
+import type { EditorLanguageServerRuntimeOptions, EditorLanguageServerHandle } from './types';
+export declare function getEditorLanguageServer(language: string, options?: string | EditorLanguageServerRuntimeOptions): Promise<EditorLanguageServerHandle | null>;

package/dist/lsp/registry.js

@@ -0,0 +1,12 @@
+import { getCppLanguageServer } from './cpp/server';
+import { getPythonLanguageServer } from './python/server';
+export async function getEditorLanguageServer(language, options) {
+    const normalized = language.toLowerCase();
+    if (normalized === 'c' || normalized === 'cpp') {
+        return getCppLanguageServer(options);
+    }
+    if (normalized === 'python') {
+        return getPythonLanguageServer(options);
+    }
+    return null;
+}

package/dist/lsp/runtime.d.ts

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

package/dist/lsp/runtime.js

@@ -0,0 +1,30 @@
+const normalizeBaseUrl = (baseUrl, currentUrl = '') => {
+    const normalized = baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
+    return currentUrl ? new URL(normalized, currentUrl).href : normalized;
+};
+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 = '') {
+    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 normalizeBaseUrl('/clangd/', currentUrl);
+}
+export function resolvePythonLanguageServerBaseUrl(options, currentUrl = '') {
+    if (typeof options === 'string') {
+        return resolveRuntimeRootBaseUrl(options, '/pyodide/', currentUrl);
+    }
+    if (options?.python?.baseUrl) {
+        return normalizeBaseUrl(options.python.baseUrl, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveRuntimeRootBaseUrl(options.rootUrl, '/pyodide/', currentUrl);
+    }
+    return normalizeBaseUrl('/pyodide/', currentUrl);
+}

package/dist/lsp/types.d.ts

@@ -0,0 +1,15 @@
+import type { MessageTransports } from '@hancomac/monaco-languageclient';
+export interface EditorLanguageServerHandle {
+    transport: string | MessageTransports;
+    syncFile?: (path: string) => void;
+    dispose: () => void;
+}
+export interface EditorLanguageServerRuntimeOptions {
+    rootUrl?: string;
+    cpp?: {
+        baseUrl?: string;
+    };
+    python?: {
+        baseUrl?: string;
+    };
+}

package/dist/lsp/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wasm-idle",
-	"version": "0.5.0",
+	"version": "0.6.0",
 	"description": "A simple web app to run C++/Python/Java code in the browser",
 	"license": "MIT",
 	"type": "module",