@crowdedkingdoms/crowdyjs 8.22.0 → 9.0.0

package/dist/live-coding/ide.d.ts

@@ -1,16 +1,23 @@
 import { type LiveCodingHandle, type MountLiveCodingOptions } from './mount.js';
+import { type PlatformIndex } from './platform-index.js';
 export interface MountLiveCodingIDEOptions extends MountLiveCodingOptions {
-    /** Authenticated wss endpoint ending in /authoring-lsp. */
-    languageServiceUrl?: string;
-    /** Current app token or a getter. Tokens are sent only after WSS connects. */
-    appToken?: string | (() => string | null);
     /** Consumer-provided Monaco editor worker (bundler-specific). */
     editorWorkerFactory?: () => Worker;
+    /** Optional module-worker factory; one worker is created for this editor. */
+    languageWorkerFactory?: () => Worker;
+    /**
+     * Generated platform symbol index. The worker strictly validates its schema;
+     * omit it to use the byte-identical embedded game export.
+     */
+    platformIndex?: PlatformIndex | unknown;
+    /** JSON-RPC request timeout; defaults to 3 seconds. */
+    languageRequestTimeoutMs?: number;
 }
 /**
- * Lazy Monaco live-coding IDE. Monaco and the language-client stack stay out
- * of the importing game's hot bundle until this async mount is called.
- * Missing LSP configuration degrades to the dependency-free textarea panel.
+ * Lazy Monaco live-coding IDE backed only by a browser module worker and local
+ * WASM parser assets. If Monaco, Worker, or WASM startup fails, the dependency-
+ * free textarea is mounted; there is deliberately no server fallback.
  */
 export declare function mountLiveCodingIDE(el: HTMLElement, options: MountLiveCodingIDEOptions): Promise<LiveCodingHandle>;
+export declare function isCurrentDiagnosticVersion(version: unknown, currentVersion: number): boolean;
 //# sourceMappingURL=ide.d.ts.map

package/dist/live-coding/ide.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ide.d.ts","sourceRoot":"","sources":["../../src/live-coding/ide.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAC5B,MAAM,YAAY,CAAC;AAKpB,MAAM,WAAW,yBAA0B,SAAQ,sBAAsB;IACvE,2DAA2D;IAC3D,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,GAAG,IAAI,CAAC,CAAC;IAC1C,iEAAiE;IACjE,mBAAmB,CAAC,EAAE,MAAM,MAAM,CAAC;CACpC;AAYD;;;;GAIG;AACH,wBAAsB,kBAAkB,CACtC,EAAE,EAAE,WAAW,EACf,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,gBAAgB,CAAC,CAwN3B"}
+{"version":3,"file":"ide.d.ts","sourceRoot":"","sources":["../../src/live-coding/ide.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAC5B,MAAM,YAAY,CAAC;AAUpB,OAAO,EAEL,KAAK,aAAa,EACnB,MAAM,qBAAqB,CAAC;AAY7B,MAAM,WAAW,yBAA0B,SAAQ,sBAAsB;IACvE,iEAAiE;IACjE,mBAAmB,CAAC,EAAE,MAAM,MAAM,CAAC;IACnC,6EAA6E;IAC7E,qBAAqB,CAAC,EAAE,MAAM,MAAM,CAAC;IACrC;;;OAGG;IACH,aAAa,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC;IACxC,uDAAuD;IACvD,wBAAwB,CAAC,EAAE,MAAM,CAAC;CACnC;AAgBD;;;;GAIG;AACH,wBAAsB,kBAAkB,CACtC,EAAE,EAAE,WAAW,EACf,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,gBAAgB,CAAC,CAwX3B;AA8GD,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,EAChB,cAAc,EAAE,MAAM,GACrB,OAAO,CAKT"}

package/dist/live-coding/ide.js

@@ -1,46 +1,42 @@
 import { LiveCodingController, } from './live-coding-controller.js';
 import { mountLiveCoding, } from './mount.js';
-import { PLAYER_CODE_TEMPLATES, } from './templates.js';
-let vscodeServicesPromise = null;
+import { isRecord, } from './lsp-protocol.js';
+import { loadPlatformIndex, } from './platform-index.js';
+import { PLAYER_CODE_TEMPLATES } from './templates.js';
+import { acquireMonacoWorkspace, ensureMonacoServicesInitialized, } from './monaco-services.js';
+let monacoLanguagesRegistered = false;
 /**
- * Lazy Monaco live-coding IDE. Monaco and the language-client stack stay out
- * of the importing game's hot bundle until this async mount is called.
- * Missing LSP configuration degrades to the dependency-free textarea panel.
+ * Lazy Monaco live-coding IDE backed only by a browser module worker and local
+ * WASM parser assets. If Monaco, Worker, or WASM startup fails, the dependency-
+ * free textarea is mounted; there is deliberately no server fallback.
  */
 export async function mountLiveCodingIDE(el, options) {
-    const token = resolveToken(options.appToken);
-    if (!options.languageServiceUrl || !token) {
+    if (!options.languageWorkerFactory && typeof Worker === 'undefined') {
         return mountLiveCoding(el, options);
     }
     if (options.editorWorkerFactory) {
         globalThis.MonacoEnvironment = { getWorker: options.editorWorkerFactory };
     }
+    let languageWorker = null;
+    let languageClient = null;
+    let releaseWorkspace = null;
+    let teardownMountedIde = null;
     try {
-        const [monaco, languageClientModule, wsJsonRpc, vscodeWrapperModule, workerFactoryModule,] = await Promise.all([
+        const platformIndex = options.platformIndex === undefined
+            ? undefined
+            : loadPlatformIndex(options.platformIndex);
+        const workerTransportPromise = import('./worker-transport.js');
+        await ensureMonacoServicesInitialized();
+        const [monaco, workerTransport] = await Promise.all([
             import('@codingame/monaco-vscode-editor-api'),
-            import('monaco-languageclient'),
-            import('vscode-ws-jsonrpc'),
-            import('monaco-languageclient/vscodeApiWrapper'),
-            import('monaco-languageclient/workerFactory'),
+            workerTransportPromise,
         ]);
-        if (!vscodeServicesPromise) {
-            const wrapper = new vscodeWrapperModule.MonacoVscodeApiWrapper({
-                $type: 'classic',
-                viewsConfig: { $type: 'EditorService' },
-                userConfiguration: {
-                    json: JSON.stringify({
-                        'workbench.colorTheme': 'Default Dark Modern',
-                        'editor.wordBasedSuggestions': 'off',
-                    }),
-                },
-                monacoWorkerFactory: workerFactoryModule.configureDefaultWorkerFactory,
-            });
-            vscodeServicesPromise = wrapper.start();
+        if (!monacoLanguagesRegistered) {
+            monaco.languages.register({ id: 'rust', extensions: ['.rs'] });
+            installRustSyntaxHighlighting(monaco);
+            monaco.languages.register({ id: 'toml', extensions: ['.toml'] });
+            monacoLanguagesRegistered = true;
         }
-        await vscodeServicesPromise;
-        monaco.languages.register({ id: 'rust', extensions: ['.rs'] });
-        installRustSyntaxHighlighting(monaco);
-        monaco.languages.register({ id: 'toml', extensions: ['.toml'] });
         const templates = options.templates ?? PLAYER_CODE_TEMPLATES;
         const root = document.createElement('div');
         root.className = 'ck-live-coding ck-live-coding-ide';
@@ -73,6 +69,10 @@ export async function mountLiveCodingIDE(el, options) {
             ...options,
             onStatus: (value) => renderStatus(status, meter, value),
         });
+        const workspaceLease = acquireMonacoWorkspace();
+        releaseWorkspace = workspaceLease.release;
+        const modelRootUri = workspaceLease.uri;
+        const ownsModel = (uri) => uri.toString().startsWith(`${modelRootUri}/`);
         const editor = monaco.editor.create(editorHost, {
             automaticLayout: true,
             minimap: { enabled: false },
@@ -81,9 +81,7 @@ export async function mountLiveCodingIDE(el, options) {
             tabSize: 2,
         });
         let models = [];
-        let languageClient = null;
-        let socket = null;
-        let modelRootUri = 'file:///player-mod';
+        const languageDisposables = [];
         const sourceJson = () => JSON.stringify(Object.fromEntries(models.map(({ path, model }) => [path, model.getValue()])));
         const showModel = (path) => {
             const found = models.find((entry) => entry.path === path);
@@ -94,16 +92,61 @@ export async function mountLiveCodingIDE(el, options) {
                     child.dataset.path === path ? 'true' : 'false';
             }
         };
-        const setFiles = (sourceFilesJson) => {
-            for (const entry of models)
+        const closeModels = () => {
+            for (const entry of models) {
+                if (entry.path.endsWith('.rs')) {
+                    void languageClient
+                        ?.notify('textDocument/didClose', {
+                        textDocument: { uri: entry.model.uri.toString() },
+                    })
+                        .catch(() => { });
+                }
+                entry.changeSubscription.dispose();
                 entry.model.dispose();
+            }
             models = [];
+        };
+        const openModel = (entry) => {
+            if (!entry.path.endsWith('.rs'))
+                return;
+            void languageClient
+                ?.notify('textDocument/didOpen', {
+                textDocument: {
+                    uri: entry.model.uri.toString(),
+                    languageId: 'rust',
+                    version: entry.model.getVersionId(),
+                    text: entry.model.getValue(),
+                },
+            })
+                .catch(() => { });
+        };
+        const setFiles = (sourceFilesJson) => {
+            closeModels();
             tabs.replaceChildren();
             const files = parseFiles(sourceFilesJson);
             for (const [path, content] of Object.entries(files)) {
                 const uri = monaco.Uri.parse(`${modelRootUri}/${path}`);
                 const model = monaco.editor.createModel(content, path.endsWith('.rs') ? 'rust' : path.endsWith('.toml') ? 'toml' : 'plaintext', uri);
-                models.push({ path, model });
+                const entry = {
+                    path,
+                    model,
+                    changeSubscription: { dispose: () => { } },
+                };
+                entry.changeSubscription = model.onDidChangeContent(() => {
+                    if (!path.endsWith('.rs'))
+                        return;
+                    void languageClient
+                        ?.notify('textDocument/didChange', {
+                        textDocument: {
+                            uri: model.uri.toString(),
+                            version: model.getVersionId(),
+                        },
+                        contentChanges: [{ text: model.getValue() }],
+                    })
+                        .catch(() => { });
+                });
+                models.push(entry);
+                openModel(entry);
                 const tab = button(path);
                 tab.dataset.path = path;
                 tab.addEventListener('click', () => showModel(path));
@@ -116,9 +159,8 @@ export async function mountLiveCodingIDE(el, options) {
         const refreshTemplates = () => {
             template.replaceChildren();
             const matching = templates.filter((item) => item.target === target.value);
-            for (const item of matching) {
+            for (const item of matching)
                 template.append(new Option(item.title, item.id));
-            }
             if (matching[0])
                 setFiles(matching[0].sourceFilesJson);
         };
@@ -144,117 +186,178 @@ export async function mountLiveCodingIDE(el, options) {
         draft.addEventListener('click', () => doDeploy(true));
         stop.addEventListener('click', () => controller.stop());
         const markerSubscription = monaco.editor.onDidChangeMarkers(() => {
-            const markers = monaco.editor.getModelMarkers({});
+            const markers = monaco.editor.getModelMarkers({ owner: 'crowdy-rust' });
             const errors = markers.filter((marker) => marker.severity === monaco.MarkerSeverity.Error).length;
             const warnings = markers.filter((marker) => marker.severity === monaco.MarkerSeverity.Warning).length;
             problems.textContent = `${errors} error(s) · ${warnings} warning(s)`;
         });
+        let tornDown = false;
+        teardownMountedIde = (graceful) => {
+            if (tornDown)
+                return;
+            tornDown = true;
+            markerSubscription.dispose();
+            for (const disposable of languageDisposables)
+                disposable.dispose();
+            controller.stop();
+            closeModels();
+            if (graceful)
+                languageClient?.shutdown();
+            else
+                languageClient?.dispose();
+            editor.dispose();
+            root.remove();
+            releaseWorkspace?.();
+            releaseWorkspace = null;
+        };
         refreshTemplates();
-        const authenticated = await authenticatedSocket(options.languageServiceUrl, token, String(options.appId), sourceJson());
-        socket = authenticated.socket;
-        const initialSource = sourceJson();
-        modelRootUri = authenticated.workspaceUri.replace(/\/$/, '');
-        setFiles(initialSource);
-        const adapter = websocketAdapter(socket);
-        const reader = new wsJsonRpc.WebSocketMessageReader(adapter);
-        const writer = new wsJsonRpc.WebSocketMessageWriter(adapter);
-        languageClient = new languageClientModule.MonacoLanguageClient({
-            name: 'Crowdy Rust',
-            clientOptions: {
-                documentSelector: [{ language: 'rust' }, { language: 'toml' }],
-                workspaceFolder: {
-                    uri: monaco.Uri.parse(modelRootUri),
-                    name: 'player-mod',
-                    index: 0,
+        languageWorker =
+            options.languageWorkerFactory?.() ??
+                workerTransport.createDefaultRustLanguageWorker();
+        languageClient = new workerTransport.WorkerLanguageClient(languageWorker, {
+            requestTimeoutMs: options.languageRequestTimeoutMs,
+        });
+        languageDisposables.push(languageClient.onNotification('textDocument/publishDiagnostics', (params) => {
+            if (!isRecord(params) || typeof params.uri !== 'string')
+                return;
+            const model = monaco.editor.getModel(monaco.Uri.parse(params.uri));
+            if (!model)
+                return;
+            if (!isCurrentDiagnosticVersion(params.version, model.getVersionId())) {
+                return;
+            }
+            const diagnostics = Array.isArray(params.diagnostics)
+                ? params.diagnostics
+                : [];
+            monaco.editor.setModelMarkers(model, 'crowdy-rust', diagnostics.map((diagnostic) => ({
+                ...toMonacoRange(diagnostic.range),
+                severity: diagnosticSeverity(monaco, diagnostic.severity),
+                message: diagnostic.message,
+                code: diagnostic.code,
+                source: diagnostic.source,
+            })));
+        }));
+        await languageClient.initialize({
+            processId: null,
+            clientInfo: { name: 'CrowdyJS Monaco', version: '1' },
+            rootUri: modelRootUri,
+            capabilities: {
+                general: { positionEncodings: ['utf-16'] },
+                textDocument: {
+                    completion: {},
+                    hover: { contentFormat: ['markdown', 'plaintext'] },
+                    documentSymbol: {},
+                    definition: {},
+                    publishDiagnostics: { versionSupport: true },
                 },
             },
-            messageTransports: { reader, writer },
+            initializationOptions: {
+                ...(platformIndex === undefined
+                    ? {}
+                    : { platformIndex }),
+            },
         });
-        await languageClient.start();
+        for (const entry of models)
+            openModel(entry);
+        languageDisposables.push(monaco.languages.registerCompletionItemProvider('rust', {
+            triggerCharacters: [':', '.'],
+            provideCompletionItems: async (model, position) => {
+                if (!ownsModel(model.uri))
+                    return { suggestions: [] };
+                const word = model.getWordUntilPosition(position);
+                const range = {
+                    startLineNumber: position.lineNumber,
+                    startColumn: word.startColumn,
+                    endLineNumber: position.lineNumber,
+                    endColumn: position.column,
+                };
+                const response = (await languageClient?.request('textDocument/completion', lspDocumentPosition(model.uri.toString(), position)));
+                return {
+                    suggestions: (response ?? []).map((item) => ({
+                        label: item.label,
+                        kind: completionKind(monaco, item.kind),
+                        detail: item.detail,
+                        documentation: item.documentation,
+                        insertText: item.insertText ?? item.label,
+                        range,
+                    })),
+                };
+            },
+        }), monaco.languages.registerHoverProvider('rust', {
+            provideHover: async (model, position) => {
+                if (!ownsModel(model.uri))
+                    return null;
+                const response = (await languageClient?.request('textDocument/hover', lspDocumentPosition(model.uri.toString(), position)));
+                if (!response)
+                    return null;
+                return {
+                    contents: [{ value: response.contents.value }],
+                    range: response.range
+                        ? new monaco.Range(response.range.start.line + 1, response.range.start.character + 1, response.range.end.line + 1, response.range.end.character + 1)
+                        : undefined,
+                };
+            },
+        }), monaco.languages.registerDocumentSymbolProvider('rust', {
+            provideDocumentSymbols: async (model) => {
+                if (!ownsModel(model.uri))
+                    return [];
+                const response = (await languageClient?.request('textDocument/documentSymbol', { textDocument: { uri: model.uri.toString() } }));
+                return (response ?? []).map((symbol) => ({
+                    name: symbol.name,
+                    detail: symbol.detail ?? '',
+                    kind: symbolKind(monaco, symbol.kind),
+                    tags: [],
+                    range: toMonacoRange(symbol.range),
+                    selectionRange: toMonacoRange(symbol.selectionRange),
+                }));
+            },
+        }), monaco.languages.registerDefinitionProvider('rust', {
+            provideDefinition: async (model, position) => {
+                if (!ownsModel(model.uri))
+                    return null;
+                const response = (await languageClient?.request('textDocument/definition', lspDocumentPosition(model.uri.toString(), position)));
+                if (!response)
+                    return null;
+                return {
+                    uri: monaco.Uri.parse(response.uri),
+                    range: toMonacoRange(response.range),
+                };
+            },
+        }));
         void controller.refreshUsage().catch(() => { });
         return {
             controller,
-            destroy: () => {
-                markerSubscription.dispose();
-                controller.stop();
-                void languageClient?.stop().catch(() => { });
-                socket?.close();
-                editor.dispose();
-                for (const entry of models)
-                    entry.model.dispose();
-                root.remove();
-            },
+            destroy: () => teardownMountedIde?.(true),
         };
     }
     catch (error) {
-        console.warn('Monaco live-coding IDE unavailable; using textarea fallback', error);
+        if (teardownMountedIde) {
+            teardownMountedIde(false);
+        }
+        else {
+            languageClient?.dispose();
+            if (!languageClient)
+                languageWorker?.terminate();
+            releaseWorkspace?.();
+            releaseWorkspace = null;
+        }
+        console.warn('Browser Rust IDE unavailable; using textarea fallback', error);
         el.replaceChildren();
         return mountLiveCoding(el, options);
     }
 }
 function installRustSyntaxHighlighting(monaco) {
     const keywords = new Set([
-        'as',
-        'async',
-        'await',
-        'break',
-        'const',
-        'continue',
-        'crate',
-        'dyn',
-        'else',
-        'enum',
-        'extern',
-        'false',
-        'fn',
-        'for',
-        'if',
-        'impl',
-        'in',
-        'let',
-        'loop',
-        'match',
-        'mod',
-        'move',
-        'mut',
-        'pub',
-        'ref',
-        'return',
-        'self',
-        'static',
-        'struct',
-        'super',
-        'trait',
-        'true',
-        'type',
-        'unsafe',
-        'use',
-        'where',
-        'while',
+        'as', 'async', 'await', 'break', 'const', 'continue', 'crate', 'dyn',
+        'else', 'enum', 'extern', 'false', 'fn', 'for', 'if', 'impl', 'in',
+        'let', 'loop', 'match', 'mod', 'move', 'mut', 'pub', 'ref', 'return',
+        'self', 'static', 'struct', 'super', 'trait', 'true', 'type', 'unsafe',
+        'use', 'where', 'while',
     ]);
     const types = new Set([
-        'Self',
-        'String',
-        'Vec',
-        'Option',
-        'Result',
-        'bool',
-        'char',
-        'str',
-        'usize',
-        'isize',
-        'u8',
-        'u16',
-        'u32',
-        'u64',
-        'u128',
-        'i8',
-        'i16',
-        'i32',
-        'i64',
-        'i128',
-        'f32',
-        'f64',
+        'Self', 'String', 'Vec', 'Option', 'Result', 'bool', 'char', 'str',
+        'usize', 'isize', 'u8', 'u16', 'u32', 'u64', 'u128', 'i8', 'i16',
+        'i32', 'i64', 'i128', 'f32', 'f64',
     ]);
     const state = {
         clone() {
@@ -272,25 +375,25 @@ function installRustSyntaxHighlighting(monaco) {
             while (index < line.length) {
                 const rest = line.slice(index);
                 let match;
-                if ((match = rest.match(/^\s+/))) {
+                if ((match = rest.match(/^\s+/u))) {
                     tokens.push({ startIndex: index, scopes: '' });
                 }
-                else if ((match = rest.match(/^\/\/.*$/))) {
+                else if ((match = rest.match(/^\/\/.*$/u))) {
                     tokens.push({ startIndex: index, scopes: 'comment.rust' });
                 }
-                else if ((match = rest.match(/^\/\*.*?(?:\*\/|$)/))) {
+                else if ((match = rest.match(/^\/\*.*?(?:\*\/|$)/u))) {
                     tokens.push({ startIndex: index, scopes: 'comment.rust' });
                 }
-                else if ((match = rest.match(/^"(?:\\.|[^"\\])*"?/))) {
+                else if ((match = rest.match(/^"(?:\\.|[^"\\])*"?/u))) {
                     tokens.push({ startIndex: index, scopes: 'string.rust' });
                 }
-                else if ((match = rest.match(/^(?:0x[\da-fA-F_]+|\d[\d_]*)/))) {
+                else if ((match = rest.match(/^(?:0x[\da-fA-F_]+|\d[\d_]*)/u))) {
                     tokens.push({ startIndex: index, scopes: 'number.rust' });
                 }
-                else if ((match = rest.match(/^[A-Za-z_]\w*!/))) {
+                else if ((match = rest.match(/^[A-Za-z_]\w*!/u))) {
                     tokens.push({ startIndex: index, scopes: 'macro.rust' });
                 }
-                else if ((match = rest.match(/^[A-Za-z_]\w*/))) {
+                else if ((match = rest.match(/^[A-Za-z_]\w*/u))) {
                     const word = match[0];
                     tokens.push({
                         startIndex: index,
@@ -302,7 +405,7 @@ function installRustSyntaxHighlighting(monaco) {
                     });
                 }
                 else {
-                    match = rest.match(/^./);
+                    match = rest.match(/^./u);
                     tokens.push({ startIndex: index, scopes: 'delimiter.rust' });
                 }
                 index += match?.[0].length ?? 1;
@@ -311,65 +414,77 @@ function installRustSyntaxHighlighting(monaco) {
         },
     });
 }
-function resolveToken(token) {
-    const value = typeof token === 'function' ? token() : token;
-    return value && value.length > 0 ? value : null;
-}
 function parseFiles(sourceFilesJson) {
     const parsed = JSON.parse(sourceFilesJson);
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    if (!isRecord(parsed))
         throw new Error('sourceFilesJson must be an object');
-    }
     return Object.fromEntries(Object.entries(parsed).map(([path, value]) => {
-        if (typeof value !== 'string')
+        if (typeof value !== 'string' ||
+            path.startsWith('/') ||
+            path.split('/').some((part) => part === '' || part === '.' || part === '..')) {
             throw new Error(`Invalid source file ${path}`);
+        }
         return [path, value];
     }));
 }
-async function authenticatedSocket(url, token, appId, sourceFilesJson) {
-    const socket = new WebSocket(url);
-    let workspaceUri = 'file:///player-mod';
-    await new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => reject(new Error('language service timeout')), 10000);
-        socket.addEventListener('open', () => {
-            socket.send(JSON.stringify({
-                type: 'authenticate',
-                token,
-                appId,
-                sourceFilesJson,
-            }));
-        }, { once: true });
-        socket.addEventListener('message', (event) => {
-            try {
-                const message = JSON.parse(String(event.data));
-                if (message.type !== 'ready' || !message.workspaceUri) {
-                    throw new Error('language service refused session');
-                }
-                workspaceUri = message.workspaceUri;
-                clearTimeout(timeout);
-                resolve();
-            }
-            catch (error) {
-                clearTimeout(timeout);
-                reject(error);
-            }
-        }, { once: true });
-        socket.addEventListener('close', (event) => {
-            clearTimeout(timeout);
-            reject(new Error(event.reason || 'language service closed'));
-        }, { once: true });
-    });
-    return { socket, workspaceUri };
+function lspDocumentPosition(uri, position) {
+    return {
+        textDocument: { uri },
+        position: {
+            line: position.lineNumber - 1,
+            character: position.column - 1,
+        },
+    };
 }
-function websocketAdapter(socket) {
+function toMonacoRange(range) {
     return {
-        send: (content) => socket.send(content),
-        onMessage: (callback) => socket.addEventListener('message', (event) => callback(event.data)),
-        onError: (callback) => socket.addEventListener('error', (event) => callback(event)),
-        onClose: (callback) => socket.addEventListener('close', (event) => callback(event.code, event.reason)),
-        dispose: () => socket.close(),
+        startLineNumber: range.start.line + 1,
+        startColumn: range.start.character + 1,
+        endLineNumber: range.end.line + 1,
+        endColumn: range.end.character + 1,
     };
 }
+export function isCurrentDiagnosticVersion(version, currentVersion) {
+    return (version === undefined ||
+        (Number.isSafeInteger(version) && version === currentVersion));
+}
+function diagnosticSeverity(monaco, severity) {
+    return severity === 1
+        ? monaco.MarkerSeverity.Error
+        : severity === 2
+            ? monaco.MarkerSeverity.Warning
+            : severity === 3
+                ? monaco.MarkerSeverity.Info
+                : monaco.MarkerSeverity.Hint;
+}
+function completionKind(monaco, kind) {
+    const kinds = monaco.languages.CompletionItemKind;
+    return ({
+        3: kinds.Function,
+        5: kinds.Field,
+        6: kinds.Variable,
+        7: kinds.Class,
+        9: kinds.Module,
+        13: kinds.Enum,
+        14: kinds.Keyword,
+        15: kinds.Snippet,
+        21: kinds.Constant,
+    }[kind] ?? kinds.Text);
+}
+function symbolKind(monaco, kind) {
+    const kinds = monaco.languages.SymbolKind;
+    return ({
+        2: kinds.Module,
+        5: kinds.Class,
+        6: kinds.Method,
+        10: kinds.Enum,
+        11: kinds.Interface,
+        12: kinds.Function,
+        13: kinds.Variable,
+        14: kinds.Constant,
+        23: kinds.Struct,
+    }[kind] ?? kinds.Object);
+}
 function select(values) {
     const element = document.createElement('select');
     for (const value of values)

package/dist/live-coding/index.d.ts

@@ -0,0 +1,8 @@
+export { LiveCodingController, type LiveCodingControllerOptions, type LiveCodingStatus, type LiveCodingTarget, } from './live-coding-controller.js';
+export { mountLiveCoding, type LiveCodingHandle, type MountLiveCodingOptions, } from './mount.js';
+export { mountLiveCodingIDE, type MountLiveCodingIDEOptions, } from './ide.js';
+export { PLAYER_CODE_TEMPLATES, templateById, type PlayerCodeTemplate, } from './templates.js';
+export { EMBEDDED_PLATFORM_INDEX, MAX_PLATFORM_CRATES, MAX_PLATFORM_CRATE_FIELD_LENGTH, MAX_PLATFORM_INDEX_BYTES, computePlatformIndexContentHash, loadPlatformIndex, type PlatformCrate, type PlatformIndex, type PlatformSymbol, type PlatformSymbolKind, } from './platform-index.js';
+export { DEFAULT_VFS_LIMITS, VfsLimitError, VirtualFileSystem, offsetAt, type VirtualDocument, type VirtualFileSystemLimits, } from './vfs.js';
+export { WorkerLanguageClient, WorkerMessageReader, WorkerMessageWriter, createDefaultRustLanguageWorker, type LanguageWorkerLike, type WorkerLanguageClientOptions, } from './worker-transport.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/live-coding/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/live-coding/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,KAAK,2BAA2B,EAChC,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,GACtB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,eAAe,EACf,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,GAC5B,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,kBAAkB,EAClB,KAAK,yBAAyB,GAC/B,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,qBAAqB,EACrB,YAAY,EACZ,KAAK,kBAAkB,GACxB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,uBAAuB,EACvB,mBAAmB,EACnB,+BAA+B,EAC/B,wBAAwB,EACxB,+BAA+B,EAC/B,iBAAiB,EACjB,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,kBAAkB,GACxB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,iBAAiB,EACjB,QAAQ,EACR,KAAK,eAAe,EACpB,KAAK,uBAAuB,GAC7B,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,mBAAmB,EACnB,+BAA+B,EAC/B,KAAK,kBAAkB,EACvB,KAAK,2BAA2B,GACjC,MAAM,uBAAuB,CAAC"}

package/dist/live-coding/index.js

@@ -0,0 +1,7 @@
+export { LiveCodingController, } from './live-coding-controller.js';
+export { mountLiveCoding, } from './mount.js';
+export { mountLiveCodingIDE, } from './ide.js';
+export { PLAYER_CODE_TEMPLATES, templateById, } from './templates.js';
+export { EMBEDDED_PLATFORM_INDEX, MAX_PLATFORM_CRATES, MAX_PLATFORM_CRATE_FIELD_LENGTH, MAX_PLATFORM_INDEX_BYTES, computePlatformIndexContentHash, loadPlatformIndex, } from './platform-index.js';
+export { DEFAULT_VFS_LIMITS, VfsLimitError, VirtualFileSystem, offsetAt, } from './vfs.js';
+export { WorkerLanguageClient, WorkerMessageReader, WorkerMessageWriter, createDefaultRustLanguageWorker, } from './worker-transport.js';