@crowdedkingdoms/crowdyjs 8.22.0 → 9.0.0

package/dist/live-coding/rust-lsp-server.js

@@ -0,0 +1,455 @@
+import { JSON_RPC_ERRORS, decodeJsonRpcMessage, isRecord, } from './lsp-protocol.js';
+import { EMBEDDED_PLATFORM_INDEX, loadPlatformIndex, } from './platform-index.js';
+import { DEFAULT_VFS_LIMITS, VfsLimitError, VirtualFileSystem, } from './vfs.js';
+class LspRequestError extends Error {
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+    }
+}
+export const MAX_PENDING_LSP_REQUESTS = 256;
+export class RustLspServer {
+    constructor(options) {
+        this.options = options;
+        this.vfs = null;
+        this.analysis = null;
+        this.initialized = false;
+        this.shuttingDown = false;
+        this.disposed = false;
+        this.requestStates = new Map();
+        this.diagnosticTimers = new Map();
+        this.diagnosticGenerations = new Map();
+    }
+    async handle(raw) {
+        if (this.disposed)
+            return;
+        const decoded = decodeJsonRpcMessage(raw);
+        if (!decoded.ok) {
+            this.sendError(decoded.id, decoded.code, decoded.message);
+            return;
+        }
+        const message = decoded.message;
+        if (!('method' in message))
+            return;
+        if (!('id' in message) && message.method === '$/cancelRequest') {
+            this.cancelRequest(message.params);
+            return;
+        }
+        if ('id' in message) {
+            await this.handleRequest(message);
+        }
+        else {
+            await this.handleNotification(message);
+        }
+    }
+    /**
+     * Observes a worker message before it enters the serialized dispatch queue.
+     * Request state is bounded, and unknown cancellation ids are never retained.
+     */
+    observeIncoming(raw) {
+        const decoded = decodeJsonRpcMessage(raw);
+        if (!decoded.ok)
+            return false;
+        const message = decoded.message;
+        if (!('method' in message))
+            return false;
+        if ('id' in message) {
+            if (this.requestStates.has(message.id)) {
+                this.sendError(message.id, JSON_RPC_ERRORS.invalidRequest, 'Request id is already pending');
+                return true;
+            }
+            if (this.requestStates.size >= MAX_PENDING_LSP_REQUESTS) {
+                this.sendError(message.id, -32000, `Pending request limit is ${MAX_PENDING_LSP_REQUESTS}`);
+                return true;
+            }
+            this.requestStates.set(message.id, { cancelled: false, active: false });
+            return false;
+        }
+        if (message.method !== '$/cancelRequest')
+            return false;
+        this.cancelRequest(message.params);
+        return true;
+    }
+    /** Backwards-compatible immediate cancellation hook for direct transports. */
+    handleImmediate(raw) {
+        return this.observeIncoming(raw);
+    }
+    cancelRequest(value) {
+        const params = optionalRecord(value);
+        if (typeof params.id === 'string' || typeof params.id === 'number') {
+            const request = this.requestStates.get(params.id);
+            if (request)
+                request.cancelled = true;
+        }
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        for (const timer of this.diagnosticTimers.values())
+            clearTimeout(timer);
+        this.diagnosticTimers.clear();
+        this.diagnosticGenerations.clear();
+        for (const request of this.requestStates.values()) {
+            request.cancelled = true;
+        }
+        this.requestStates.clear();
+        this.vfs?.clear();
+        this.analysis?.dispose();
+        this.vfs = null;
+        this.analysis = null;
+    }
+    async handleRequest(request) {
+        let cancellation = this.requestStates.get(request.id);
+        if (!cancellation) {
+            if (this.requestStates.size >= MAX_PENDING_LSP_REQUESTS) {
+                this.sendError(request.id, -32000, `Pending request limit is ${MAX_PENDING_LSP_REQUESTS}`);
+                return;
+            }
+            cancellation = { cancelled: false, active: false };
+            this.requestStates.set(request.id, cancellation);
+        }
+        if (cancellation.active) {
+            this.sendError(request.id, JSON_RPC_ERRORS.invalidRequest, 'Request id is already active');
+            return;
+        }
+        cancellation.active = true;
+        try {
+            if (cancellation.cancelled) {
+                throw new LspRequestError(JSON_RPC_ERRORS.requestCancelled, 'Request cancelled');
+            }
+            if (request.method === 'initialize') {
+                await this.initialize(request);
+                return;
+            }
+            if (!this.initialized) {
+                this.sendError(request.id, -32002, 'Server not initialized');
+                return;
+            }
+            if (request.method === 'shutdown') {
+                this.shuttingDown = true;
+                this.sendResult(request.id, null);
+                return;
+            }
+            if (this.shuttingDown) {
+                this.sendError(request.id, JSON_RPC_ERRORS.invalidRequest, 'Server is shutting down');
+                return;
+            }
+            const result = await withTimeout(this.dispatchAnalysisRequest(request, cancellation), this.options.requestTimeoutMs ?? 2000);
+            if (cancellation.cancelled) {
+                throw new LspRequestError(JSON_RPC_ERRORS.requestCancelled, 'Request cancelled');
+            }
+            this.sendResult(request.id, result);
+        }
+        catch (error) {
+            const failure = error instanceof LspRequestError
+                ? error
+                : new LspRequestError(JSON_RPC_ERRORS.internalError, error instanceof Error ? error.message : 'Internal error');
+            this.sendError(request.id, failure.code, failure.message, failure.data);
+        }
+        finally {
+            if (this.requestStates.get(request.id) === cancellation) {
+                this.requestStates.delete(request.id);
+            }
+        }
+    }
+    async initialize(request) {
+        if (this.initialized) {
+            this.sendError(request.id, JSON_RPC_ERRORS.invalidRequest, 'Already initialized');
+            return;
+        }
+        try {
+            const params = optionalRecord(request.params);
+            const rootUri = typeof params.rootUri === 'string' ? params.rootUri : 'file:///player-mod';
+            const initializationOptions = optionalRecord(params.initializationOptions);
+            const limits = loadLimits(initializationOptions.limits);
+            const index = loadPlatformIndex(initializationOptions.platformIndex ?? EMBEDDED_PLATFORM_INDEX);
+            this.vfs = new VirtualFileSystem(rootUri, limits);
+            this.analysis = await this.options.createAnalysis(index);
+            this.initialized = true;
+            this.sendResult(request.id, {
+                capabilities: {
+                    positionEncoding: 'utf-16',
+                    textDocumentSync: { openClose: true, change: 2 },
+                    completionProvider: { triggerCharacters: [':', '.'] },
+                    hoverProvider: true,
+                    documentSymbolProvider: true,
+                    definitionProvider: true,
+                },
+                serverInfo: {
+                    name: 'Crowdy browser Rust language service',
+                    version: '1',
+                },
+            });
+        }
+        catch (error) {
+            this.sendError(request.id, JSON_RPC_ERRORS.invalidParams, error instanceof Error ? error.message : 'Invalid initialize parameters');
+        }
+    }
+    async dispatchAnalysisRequest(request, cancellation) {
+        if (cancellation.cancelled) {
+            throw new LspRequestError(JSON_RPC_ERRORS.requestCancelled, 'Request cancelled');
+        }
+        if (![
+            'textDocument/completion',
+            'textDocument/hover',
+            'textDocument/documentSymbol',
+            'textDocument/definition',
+        ].includes(request.method)) {
+            throw new LspRequestError(JSON_RPC_ERRORS.methodNotFound, `Method not found: ${request.method}`);
+        }
+        const params = requireRecord(request.params, 'params');
+        const textDocument = requireRecord(params.textDocument, 'textDocument');
+        const uri = requiredString(textDocument.uri, 'textDocument.uri');
+        const document = this.requireVfs().require(uri);
+        const version = document.version;
+        const analysis = this.requireAnalysis();
+        let result;
+        switch (request.method) {
+            case 'textDocument/completion':
+                result = analysis.completions(document, requiredPosition(params.position), this.requireVfs().documents());
+                break;
+            case 'textDocument/hover':
+                result = analysis.hover(document, requiredPosition(params.position), this.requireVfs().documents());
+                break;
+            case 'textDocument/documentSymbol':
+                result = analysis.documentSymbols(document);
+                break;
+            case 'textDocument/definition':
+                result = analysis.definition(document, requiredPosition(params.position), this.requireVfs().documents());
+                break;
+            default:
+                throw new LspRequestError(JSON_RPC_ERRORS.internalError, 'Unreachable method');
+        }
+        if (this.requireVfs().get(uri)?.version !== version) {
+            throw new LspRequestError(JSON_RPC_ERRORS.contentModified, 'Document changed while request was running');
+        }
+        return result;
+    }
+    async handleNotification(message) {
+        if (!('method' in message))
+            return;
+        if (message.method === 'exit') {
+            this.dispose();
+            return;
+        }
+        if (message.method === '$/cancelRequest') {
+            this.handleImmediate(message);
+            return;
+        }
+        if (!this.initialized || this.shuttingDown)
+            return;
+        try {
+            const params = requireRecord(message.params, 'params');
+            switch (message.method) {
+                case 'initialized':
+                    return;
+                case 'textDocument/didOpen': {
+                    const item = requireRecord(params.textDocument, 'textDocument');
+                    const document = this.requireVfs().open({
+                        uri: requiredString(item.uri, 'textDocument.uri'),
+                        languageId: requiredString(item.languageId, 'textDocument.languageId'),
+                        version: requiredVersion(item.version),
+                        text: requiredStringValue(item.text, 'textDocument.text'),
+                    });
+                    this.requireAnalysis().invalidate(document.uri);
+                    this.scheduleDiagnostics(document.uri);
+                    return;
+                }
+                case 'textDocument/didChange': {
+                    const item = requireRecord(params.textDocument, 'textDocument');
+                    if (!Array.isArray(params.contentChanges)) {
+                        throw new Error('contentChanges must be an array');
+                    }
+                    const uri = requiredString(item.uri, 'textDocument.uri');
+                    const changed = this.requireVfs().change(uri, requiredVersion(item.version), params.contentChanges.map(loadContentChange));
+                    if (changed.applied) {
+                        this.requireAnalysis().invalidate(uri);
+                        this.scheduleDiagnostics(uri);
+                    }
+                    return;
+                }
+                case 'textDocument/didClose': {
+                    const item = requireRecord(params.textDocument, 'textDocument');
+                    const uri = requiredString(item.uri, 'textDocument.uri');
+                    this.cancelDiagnostics(uri);
+                    this.requireVfs().close(uri);
+                    this.requireAnalysis().invalidate(uri);
+                    this.publishDiagnostics(uri, null, []);
+                    return;
+                }
+                default:
+                    return;
+            }
+        }
+        catch (error) {
+            const textDocument = isRecord(message.params)
+                ? optionalRecord(message.params.textDocument)
+                : {};
+            const uri = typeof textDocument.uri === 'string' ? textDocument.uri : undefined;
+            if (uri && error instanceof VfsLimitError) {
+                this.publishDiagnostics(uri, null, [
+                    {
+                        range: {
+                            start: { line: 0, character: 0 },
+                            end: { line: 0, character: 0 },
+                        },
+                        severity: 1,
+                        source: 'crowdy-rust',
+                        code: 'workspace-limit',
+                        message: error.message,
+                    },
+                ]);
+            }
+            this.options.postMessage({
+                jsonrpc: '2.0',
+                method: 'window/logMessage',
+                params: {
+                    type: 1,
+                    message: error instanceof Error ? error.message : 'Invalid notification',
+                },
+            });
+        }
+    }
+    scheduleDiagnostics(uri) {
+        this.cancelDiagnostics(uri);
+        const generation = (this.diagnosticGenerations.get(uri) ?? 0) + 1;
+        this.diagnosticGenerations.set(uri, generation);
+        const timer = setTimeout(() => {
+            this.diagnosticTimers.delete(uri);
+            if (this.disposed ||
+                generation !== this.diagnosticGenerations.get(uri)) {
+                return;
+            }
+            const document = this.vfs?.get(uri);
+            if (!document || !this.analysis)
+                return;
+            const diagnostics = this.analysis.diagnostics(document);
+            if (generation === this.diagnosticGenerations.get(uri) &&
+                this.vfs?.get(uri)?.version === document.version) {
+                this.publishDiagnostics(uri, document.version, diagnostics);
+            }
+        }, this.options.diagnosticDebounceMs ?? 75);
+        this.diagnosticTimers.set(uri, timer);
+    }
+    cancelDiagnostics(uri) {
+        const timer = this.diagnosticTimers.get(uri);
+        if (timer)
+            clearTimeout(timer);
+        this.diagnosticTimers.delete(uri);
+        this.diagnosticGenerations.set(uri, (this.diagnosticGenerations.get(uri) ?? 0) + 1);
+    }
+    publishDiagnostics(uri, version, diagnostics) {
+        this.options.postMessage({
+            jsonrpc: '2.0',
+            method: 'textDocument/publishDiagnostics',
+            params: {
+                uri,
+                ...(version === null ? {} : { version }),
+                diagnostics,
+            },
+        });
+    }
+    requireVfs() {
+        if (!this.vfs)
+            throw new Error('Server VFS is unavailable');
+        return this.vfs;
+    }
+    requireAnalysis() {
+        if (!this.analysis)
+            throw new Error('Rust analysis is unavailable');
+        return this.analysis;
+    }
+    sendResult(id, result) {
+        this.options.postMessage({ jsonrpc: '2.0', id, result });
+    }
+    sendError(id, code, message, data) {
+        this.options.postMessage({
+            jsonrpc: '2.0',
+            id,
+            error: { code, message, ...(data === undefined ? {} : { data }) },
+        });
+    }
+}
+function loadLimits(value) {
+    if (value === undefined)
+        return DEFAULT_VFS_LIMITS;
+    const input = requireRecord(value, 'limits');
+    const allowed = new Set(['maxFiles', 'maxFileBytes', 'maxWorkspaceBytes']);
+    const unexpected = Object.keys(input).find((key) => !allowed.has(key));
+    if (unexpected)
+        throw new Error(`limits has unexpected field ${unexpected}`);
+    return Object.fromEntries(Object.entries(input).map(([key, item]) => {
+        if (!Number.isSafeInteger(item) || item <= 0) {
+            throw new Error(`limits.${key} must be a positive safe integer`);
+        }
+        return [key, item];
+    }));
+}
+function loadContentChange(value) {
+    const input = requireRecord(value, 'contentChanges[]');
+    const text = requiredStringValue(input.text, 'contentChanges[].text');
+    if (input.range === undefined)
+        return { text };
+    const range = requireRecord(input.range, 'contentChanges[].range');
+    return {
+        text,
+        range: {
+            start: requiredPosition(range.start),
+            end: requiredPosition(range.end),
+        },
+    };
+}
+function requiredPosition(value) {
+    const input = requireRecord(value, 'position');
+    if (!Number.isSafeInteger(input.line) ||
+        !Number.isSafeInteger(input.character) ||
+        input.line < 0 ||
+        input.character < 0) {
+        throw new LspRequestError(JSON_RPC_ERRORS.invalidParams, 'Invalid position');
+    }
+    return { line: input.line, character: input.character };
+}
+function requireRecord(value, field) {
+    if (!isRecord(value)) {
+        throw new LspRequestError(JSON_RPC_ERRORS.invalidParams, `${field} must be an object`);
+    }
+    return value;
+}
+function optionalRecord(value) {
+    return isRecord(value) ? value : {};
+}
+function requiredString(value, field) {
+    if (typeof value !== 'string' || value.length === 0 || value.length > 4096) {
+        throw new LspRequestError(JSON_RPC_ERRORS.invalidParams, `${field} must be a non-empty bounded string`);
+    }
+    return value;
+}
+function requiredStringValue(value, field) {
+    if (typeof value !== 'string') {
+        throw new LspRequestError(JSON_RPC_ERRORS.invalidParams, `${field} must be a string`);
+    }
+    return value;
+}
+function requiredVersion(value) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new LspRequestError(JSON_RPC_ERRORS.invalidParams, 'Document version must be a non-negative safe integer');
+    }
+    return value;
+}
+async function withTimeout(promise, timeoutMs) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new LspRequestError(-32001, 'Request timed out')), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}

package/dist/live-coding/rust-lsp.worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=rust-lsp.worker.d.ts.map

package/dist/live-coding/rust-lsp.worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rust-lsp.worker.d.ts","sourceRoot":"","sources":["../../src/live-coding/rust-lsp.worker.ts"],"names":[],"mappings":""}

package/dist/live-coding/rust-lsp.worker.js

@@ -0,0 +1,26 @@
+import { RustAnalysis } from './rust-analysis.js';
+import { RustLspServer } from './rust-lsp-server.js';
+const scope = globalThis;
+const parserWasmUrl = new URL('./assets/web-tree-sitter.wasm', import.meta.url).href;
+const grammarWasmUrl = new URL('./assets/tree-sitter-rust.wasm', import.meta.url).href;
+const server = new RustLspServer({
+    postMessage: (message) => scope.postMessage(message),
+    createAnalysis: (platformIndex) => RustAnalysis.create({ parserWasmUrl, grammarWasmUrl, platformIndex }),
+});
+let queue = Promise.resolve();
+scope.onmessage = (event) => {
+    if (server.observeIncoming(event.data))
+        return;
+    queue = queue
+        .then(() => server.handle(event.data))
+        .catch((error) => {
+        scope.postMessage({
+            jsonrpc: '2.0',
+            method: 'window/logMessage',
+            params: {
+                type: 1,
+                message: error instanceof Error ? error.message : 'Worker failure',
+            },
+        });
+    });
+};

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

@@ -0,0 +1,41 @@
+import type { Position, TextDocumentContentChangeEvent, TextDocumentItem } from './lsp-protocol.js';
+export interface VirtualFileSystemLimits {
+    maxFiles: number;
+    maxFileBytes: number;
+    maxWorkspaceBytes: number;
+}
+export declare const DEFAULT_VFS_LIMITS: Readonly<VirtualFileSystemLimits>;
+export interface VirtualDocument extends TextDocumentItem {
+    readonly path: string;
+    readonly bytes: number;
+}
+export declare class VfsLimitError extends Error {
+    readonly code = "VFS_LIMIT";
+    constructor(message: string);
+}
+export declare class VirtualFileSystem {
+    private readonly files;
+    private readonly encoder;
+    private totalBytes;
+    readonly workspaceUri: string;
+    readonly limits: Readonly<VirtualFileSystemLimits>;
+    constructor(workspaceUri?: string, limits?: Partial<VirtualFileSystemLimits>);
+    get size(): number;
+    get bytes(): number;
+    open(item: TextDocumentItem): VirtualDocument;
+    change(uri: string, version: number, changes: readonly TextDocumentContentChangeEvent[]): {
+        applied: boolean;
+        document: VirtualDocument;
+    };
+    close(uri: string): boolean;
+    get(uri: string): VirtualDocument | undefined;
+    require(uri: string): VirtualDocument;
+    documents(): VirtualDocument[];
+    clear(): void;
+    pathForUri(uri: string): string;
+    private makeDocument;
+    private ensureFits;
+    private assertLimits;
+}
+export declare function offsetAt(text: string, position: Position): number;
+//# sourceMappingURL=vfs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vfs.d.ts","sourceRoot":"","sources":["../../src/live-coding/vfs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,8BAA8B,EAC9B,gBAAgB,EACjB,MAAM,mBAAmB,CAAC;AAE3B,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,uBAAuB,CAIhE,CAAC;AAEF,MAAM,WAAW,eAAgB,SAAQ,gBAAgB;IACvD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,qBAAa,aAAc,SAAQ,KAAK;IACtC,QAAQ,CAAC,IAAI,eAAe;gBAEhB,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAsC;IAC5D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAC7C,OAAO,CAAC,UAAU,CAAK;IACvB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,uBAAuB,CAAC,CAAC;gBAGjD,YAAY,SAAuB,EACnC,MAAM,GAAE,OAAO,CAAC,uBAAuB,CAAM;IAiB/C,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,IAAI,CAAC,IAAI,EAAE,gBAAgB,GAAG,eAAe;IAiB7C,MAAM,CACJ,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,SAAS,8BAA8B,EAAE,GACjD;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,eAAe,CAAA;KAAE;IA+BlD,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAQ3B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAI7C,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe;IAMrC,SAAS,IAAI,eAAe,EAAE;IAI9B,KAAK,IAAI,IAAI;IAKb,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IA4B/B,OAAO,CAAC,YAAY;IAgBpB,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,YAAY;CAUrB;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAoBjE"}