arkts-lsp-proxy 0.1.0 → 0.1.2

package/dist/proxy.js

@@ -1,64 +1,680 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.injectInitializationOptions = injectInitializationOptions;
 exports.createProxy = createProxy;
 const node_1 = require("vscode-jsonrpc/node");
-function injectInitializationOptions(message, payload) {
-    if (message.method === 'initialize' && message.params) {
-        const params = { ...message.params };
-        params.initializationOptions = {
-            ...(params.initializationOptions || {}),
-            rootUri: payload.rootUri,
-            lspServerWorkspacePath: payload.lspServerWorkspacePath,
-            modules: payload.modules,
+const vscode_jsonrpc_1 = require("vscode-jsonrpc");
+const path = __importStar(require("node:path"));
+const node_url_1 = require("node:url");
+const project_1 = require("./project");
+const ace_server_1 = require("./ace-server");
+const hvigor_1 = require("./hvigor");
+const ACE_NOTIFICATION_METHODS = {
+    'textDocument/didOpen': 'aceProject/onAsyncDidOpen',
+    'textDocument/didChange': 'aceProject/onAsyncDidChange',
+    'textDocument/didClose': 'aceProject/onAsyncDidClose',
+};
+const ACE_FIND_USAGES_METHOD = 'aceProject/onAsyncFindUsages';
+const ACE_REQUEST_METHODS = {
+    'textDocument/hover': 'aceProject/onAsyncHover',
+    'textDocument/completion': 'aceProject/onAsyncCompletion',
+    'completionItem/resolve': 'aceProject/onAsyncCompletionResolve',
+    'textDocument/definition': 'aceProject/onAsyncDefinition',
+    'textDocument/references': ACE_FIND_USAGES_METHOD,
+    'textDocument/signatureHelp': 'aceProject/onAsyncSignatureHelp',
+};
+const ACE_RESPONSE_METHODS = new Set(Object.values(ACE_REQUEST_METHODS));
+const ACE_MODULE_INIT_METHOD = 'aceProject/onModuleInitFinish';
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+function createQueueToken() {
+    return `arkts-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function uriToFilePath(uri) {
+    if (typeof uri !== 'string' || !uri.length) {
+        return null;
+    }
+    if (uri.startsWith('file://')) {
+        try {
+            return (0, node_url_1.fileURLToPath)(uri);
+        }
+        catch {
+            return null;
+        }
+    }
+    return path.resolve(uri);
+}
+function detectLanguageId(uri) {
+    const ext = path.extname(uri).toLowerCase();
+    if (ext === '.ets' || ext === '.d.ets') {
+        return 'deveco.apptool.ets';
+    }
+    if (ext === '.ts') {
+        return 'deveco.apptool.ts';
+    }
+    if (ext === '.js') {
+        return 'deveco.apptool.js';
+    }
+    return 'deveco.apptool.ts';
+}
+function normalizeAceLanguageId(uri, languageId) {
+    if (typeof languageId === 'string' && languageId.startsWith('deveco.apptool.')) {
+        return languageId;
+    }
+    return detectLanguageId(uri);
+}
+function inferProjectRootFromInitializeParams(params) {
+    if (!isPlainObject(params)) {
+        return null;
+    }
+    const candidate = (Array.isArray(params.workspaceFolders)
+        ? params.workspaceFolders[0]?.uri
+        : undefined) ??
+        params.rootUri ??
+        params.rootPath;
+    return uriToFilePath(candidate ?? null);
+}
+function getEditorFiles(openFiles) {
+    return Array.from(openFiles)
+        .map((uri) => uriToFilePath(uri))
+        .filter((filePath) => Boolean(filePath));
+}
+function getOpenFileUris(openFiles) {
+    return Array.from(openFiles);
+}
+function createRequestPayload(params) {
+    return {
+        requestId: createQueueToken(),
+        params: params || {},
+        editorFiles: [],
+        traceId: createQueueToken(),
+    };
+}
+function isModuleInitSuccess(payload) {
+    if (Array.isArray(payload)) {
+        return payload.length > 0 && payload.every(isModuleInitSuccess);
+    }
+    if (typeof payload === 'boolean') {
+        return payload;
+    }
+    if (!isPlainObject(payload)) {
+        return false;
+    }
+    if ('success' in payload && typeof payload.success === 'boolean') {
+        return payload.success;
+    }
+    if ('code' in payload && typeof payload.code === 'number') {
+        return payload.code === 0;
+    }
+    if ('status' in payload && typeof payload.status === 'string') {
+        return payload.status.toLowerCase() === 'success';
+    }
+    if ('result' in payload && typeof payload.result === 'boolean') {
+        return payload.result;
+    }
+    return false;
+}
+function extractTextDocument(params) {
+    if (!isPlainObject(params)) {
+        return null;
+    }
+    const textDocument = params.textDocument ?? null;
+    return isPlainObject(textDocument) ? textDocument : null;
+}
+function mapNotification(method, params, openFiles) {
+    if (!ACE_NOTIFICATION_METHODS[method]) {
+        return null;
+    }
+    if (method === 'textDocument/didOpen') {
+        const textDocument = extractTextDocument(params);
+        if (!textDocument) {
+            return null;
+        }
+        const uri = typeof textDocument.uri === 'string' ? textDocument.uri : null;
+        if (!uri) {
+            return null;
+        }
+        return {
+            method: ACE_NOTIFICATION_METHODS[method],
+            params: {
+                requestId: createQueueToken(),
+                params: {
+                    textDocument: {
+                        uri,
+                        languageId: normalizeAceLanguageId(uri, textDocument.languageId),
+                        version: textDocument.version,
+                        text: typeof textDocument.text === 'string' ? textDocument.text : '',
+                    },
+                },
+                editorFiles: getEditorFiles(openFiles),
+                traceId: createQueueToken(),
+            },
+        };
+    }
+    if (method === 'textDocument/didClose') {
+        const textDocument = extractTextDocument(params);
+        if (!textDocument) {
+            return null;
+        }
+        const uri = typeof textDocument.uri === 'string' ? textDocument.uri : null;
+        if (!uri) {
+            return null;
+        }
+        return {
+            method: ACE_NOTIFICATION_METHODS[method],
+            params: {
+                requestId: createQueueToken(),
+                params: {
+                    textDocument,
+                },
+                editorFiles: getEditorFiles(openFiles),
+                traceId: createQueueToken(),
+            },
+        };
+    }
+    if (method === 'textDocument/didChange') {
+        const textDocument = extractTextDocument(params);
+        if (!textDocument) {
+            return null;
+        }
+        const uri = typeof textDocument.uri === 'string' ? textDocument.uri : null;
+        if (!uri) {
+            return null;
+        }
+        return {
+            method: ACE_NOTIFICATION_METHODS[method],
+            params: {
+                requestId: createQueueToken(),
+                params: {
+                    textDocument: {
+                        uri,
+                        languageId: detectLanguageId(uri),
+                        version: textDocument.version,
+                        text: typeof textDocument.text === 'string' ? textDocument.text : '',
+                    },
+                    contentChanges: Array.isArray(params?.contentChanges) ? params.contentChanges : [],
+                },
+                editorFiles: getEditorFiles(openFiles),
+                traceId: createQueueToken(),
+            },
         };
-        return { ...message, params };
     }
-    return message;
+    return {
+        method: ACE_NOTIFICATION_METHODS[method],
+        params: {
+            ...createRequestPayload(params),
+            editorFiles: getEditorFiles(openFiles),
+        },
+    };
 }
-function createProxy(clientIn, clientOut, aceProcess, payload) {
-    const aceIn = aceProcess.stdout;
-    const aceOut = aceProcess.stdin;
-    if (!aceIn || !aceOut) {
+function mapRequest(method, params, openFiles) {
+    const mappedMethod = ACE_REQUEST_METHODS[method];
+    if (!mappedMethod) {
+        return null;
+    }
+    const payload = {
+        ...createRequestPayload(params),
+        editorFiles: getEditorFiles(openFiles),
+    };
+    if (method === 'textDocument/definition') {
+        payload.params = {
+            ...(isPlainObject(payload.params) ? payload.params : {}),
+            isGotoDefinition: true,
+        };
+    }
+    return {
+        method: mappedMethod,
+        params: payload,
+    };
+}
+function isDevEcoEnv(value) {
+    return (isPlainObject(value) &&
+        typeof value.devecoHome === 'string' &&
+        typeof value.sdkPath === 'string' &&
+        typeof value.aceServerPath === 'string' &&
+        typeof value.nodeBin === 'string' &&
+        typeof value.hvigorPath === 'string');
+}
+function isLegacyPayload(value) {
+    return (isPlainObject(value) &&
+        typeof value.rootUri === 'string' &&
+        typeof value.lspServerWorkspacePath === 'string' &&
+        Array.isArray(value.modules));
+}
+function isModernMode(value) {
+    return isPlainObject(value) && isDevEcoEnv(value.env);
+}
+function injectInitializationOptions(message, payload) {
+    if (message.method !== 'initialize' || !message.params) {
+        return message;
+    }
+    const params = { ...message.params };
+    const existing = typeof params.initializationOptions === 'object' &&
+        params.initializationOptions !== null
+        ? params.initializationOptions
+        : {};
+    params.initializationOptions = {
+        ...existing,
+        ...payload,
+    };
+    return { ...message, params };
+}
+function createLegacyProxy(clientConn, proc, payload) {
+    if (!proc.stdout || !proc.stdin) {
         throw new Error('aceProcess must have both stdout and stdin streams');
     }
-    const clientConn = (0, node_1.createMessageConnection)(new node_1.StreamMessageReader(clientIn), new node_1.StreamMessageWriter(clientOut));
-    const aceConn = (0, node_1.createMessageConnection)(new node_1.StreamMessageReader(aceIn), new node_1.StreamMessageWriter(aceOut));
-    clientConn.onNotification((method, params) => {
-        aceConn.sendNotification(method, params);
-    });
-    clientConn.onRequest((method, params, token) => {
-        if (method === 'initialize') {
-            const message = { method, params: params };
-            const modified = injectInitializationOptions(message, payload);
-            return aceConn.sendRequest(method, modified.params, token);
+    const aceConn = (0, node_1.createMessageConnection)(new node_1.StreamMessageReader(proc.stdout), new node_1.StreamMessageWriter(proc.stdin));
+    let disposed = false;
+    clientConn.onRequest((method, params) => {
+        if (method === 'initialize' && payload) {
+            const msg = injectInitializationOptions({
+                id: 0,
+                method,
+                params: isPlainObject(params) ? params : {},
+            }, payload);
+            return aceConn.sendRequest(method, msg.params);
         }
-        return aceConn.sendRequest(method, params, token);
+        return aceConn.sendRequest(method, params);
     });
     aceConn.onNotification((method, params) => {
         clientConn.sendNotification(method, params);
     });
-    aceConn.onRequest((method, params, token) => {
-        return clientConn.sendRequest(method, params, token);
-    });
-    aceConn.onError(([err]) => {
-        process.stderr.write(`[arkts-lsp] ace connection error: ${err.message}\n`);
-        clientConn.dispose();
+    aceConn.onError((error) => {
+        process.stderr.write(`[arkts-lsp] legacy ace connection error: ${String(error)}\n`);
     });
-    clientConn.onError(([err]) => {
-        process.stderr.write(`[arkts-lsp] client connection error: ${err.message}\n`);
-        aceConn.dispose();
+    clientConn.onNotification((method, params) => {
+        aceConn.sendNotification(method, params);
     });
-    aceProcess.on('exit', () => {
-        clientConn.dispose();
+    clientConn.onError((error) => {
+        process.stderr.write(`[arkts-lsp] client connection error: ${String(error)}\n`);
     });
     clientConn.listen();
     aceConn.listen();
     return {
         dispose: () => {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
             clientConn.dispose();
             aceConn.dispose();
         },
     };
 }
+function createProxy(clientIn, clientOut, envOrLegacy, maybeOptions) {
+    const clientConn = (0, node_1.createMessageConnection)(new node_1.StreamMessageReader(clientIn), new node_1.StreamMessageWriter(clientOut));
+    if (!isDevEcoEnv(envOrLegacy)) {
+        const legacyProc = envOrLegacy.process ?? envOrLegacy;
+        if (!legacyProc) {
+            throw new Error('legacy mode requires ChildProcess-like object with stdin/stdout streams');
+        }
+        return createLegacyProxy(clientConn, legacyProc, isLegacyPayload(maybeOptions) ? maybeOptions : undefined);
+    }
+    const env = envOrLegacy;
+    const options = isModernMode(maybeOptions) ? maybeOptions : { env, projectRootHint: undefined };
+    const explicitProjectRoot = options.projectRootHint || process.env.ARKTS_PROJECT_ROOT || process.env.ARKTS_PROJECT_PATH;
+    const openFiles = new Set();
+    const requestQueue = [];
+    const notificationQueue = [];
+    const pendingAceRequests = new Map();
+    let isInitialized = false;
+    let isServerReady = false;
+    let isBootstrapping = false;
+    let bootstrapPromise = null;
+    let initializePromise = null;
+    let syncPromise = null;
+    let aceConn = null;
+    let aceHandle = null;
+    let project = null;
+    let disposed = false;
+    function queueRequest(run) {
+        return new Promise((resolve, reject) => {
+            requestQueue.push({ run, resolve, reject });
+        });
+    }
+    function queueNotification(method, params) {
+        notificationQueue.push({ method, params });
+    }
+    function clearQueues(error) {
+        const finalError = error ?? new Error('proxy disposed');
+        while (requestQueue.length > 0) {
+            const p = requestQueue.shift();
+            if (p) {
+                p.reject(finalError);
+            }
+        }
+        notificationQueue.length = 0;
+        for (const pending of pendingAceRequests.values()) {
+            pending.reject(finalError);
+        }
+        pendingAceRequests.clear();
+    }
+    function flushQueues() {
+        if (!isServerReady || !aceConn) {
+            return;
+        }
+        while (notificationQueue.length > 0) {
+            const n = notificationQueue.shift();
+            if (!n) {
+                continue;
+            }
+            try {
+                aceConn.sendNotification(n.method, n.params);
+            }
+            catch {
+                // ignore flush notification errors
+            }
+        }
+        while (requestQueue.length > 0) {
+            const p = requestQueue.shift();
+            if (!p) {
+                continue;
+            }
+            p.run().then(p.resolve, p.reject);
+        }
+    }
+    function completePendingAceRequest(method, params) {
+        if (!ACE_RESPONSE_METHODS.has(method) || !isPlainObject(params)) {
+            return false;
+        }
+        const requestId = typeof params.requestId === 'string' ? params.requestId : null;
+        if (!requestId) {
+            return false;
+        }
+        const pending = pendingAceRequests.get(requestId);
+        if (!pending) {
+            return false;
+        }
+        pendingAceRequests.delete(requestId);
+        pending.resolve('result' in params ? params.result : params);
+        return true;
+    }
+    function sendAceRequestAsNotification(conn, method, params) {
+        const requestId = typeof params.requestId === 'string' ? params.requestId : createQueueToken();
+        const payload = { ...params, requestId };
+        return new Promise((resolve, reject) => {
+            pendingAceRequests.set(requestId, { resolve, reject });
+            try {
+                conn.sendNotification(method, payload);
+            }
+            catch (err) {
+                pendingAceRequests.delete(requestId);
+                reject(err);
+            }
+        });
+    }
+    function sendAceRequest(conn, method, params, useNotificationResponse) {
+        return useNotificationResponse
+            ? sendAceRequestAsNotification(conn, method, params)
+            : conn.sendRequest(method, params);
+    }
+    function createAceConnection(proc) {
+        if (!proc.stdout || !proc.stdin) {
+            throw new Error('aceProcess must have both stdout and stdin streams');
+        }
+        const conn = (0, node_1.createMessageConnection)(new node_1.StreamMessageReader(proc.stdout), new node_1.StreamMessageWriter(proc.stdin));
+        conn.onNotification((method, params) => {
+            if (completePendingAceRequest(method, params)) {
+                return;
+            }
+            if (method === ACE_MODULE_INIT_METHOD) {
+                if (isModuleInitSuccess(params)) {
+                    isServerReady = true;
+                    flushQueues();
+                }
+                else {
+                    process.stderr.write('[arkts-lsp] ace server module init reported failure, continue serving requests\n');
+                }
+            }
+            clientConn.sendNotification(method, params);
+        });
+        conn.onRequest((method, params) => {
+            if (method === 'client/registerCapability') {
+                return null;
+            }
+            return clientConn.sendRequest(method, params).catch((error) => {
+                process.stderr.write(`[arkts-lsp] client request ${method} failed: ${String(error)}\n`);
+                return null;
+            });
+        });
+        conn.onError((error) => {
+            process.stderr.write(`[arkts-lsp] ace connection error: ${String(error)}\n`);
+            clearQueues(error);
+        });
+        return conn;
+    }
+    function scheduleHvigorSync(projectRoot) {
+        if (syncPromise) {
+            return;
+        }
+        const config = (0, hvigor_1.parseHvigorSyncConfig)();
+        process.stderr.write(`[arkts-lsp] hvigor metadata sync mode=${config.mode}, timeout=${config.timeoutMs}ms\n`);
+        syncPromise = (0, hvigor_1.runHvigorSyncAsync)(env, projectRoot, config)
+            .then((result) => {
+            const before = result.metadataBefore.state;
+            const after = result.metadataAfter?.state ?? before;
+            process.stderr.write(`[arkts-lsp] hvigor sync ${result.status}; metadata ${before} -> ${after}; elapsed=${result.elapsedMs}ms\n`);
+            if (result.errorMessage) {
+                process.stderr.write(`[arkts-lsp] hvigor sync detail: ${result.errorMessage}\n`);
+            }
+        })
+            .catch((error) => {
+            process.stderr.write(`[arkts-lsp] hvigor sync unexpected error: ${String(error)}\n`);
+        })
+            .finally(() => {
+            syncPromise = null;
+        });
+    }
+    function ensureServer(rootHint) {
+        if (bootstrapPromise) {
+            return bootstrapPromise;
+        }
+        bootstrapPromise = (async () => {
+            isBootstrapping = true;
+            const candidate = explicitProjectRoot
+                ? path.resolve(explicitProjectRoot)
+                : rootHint
+                    ? path.resolve(rootHint)
+                    : process.cwd();
+            const resolvedRoot = (0, project_1.findProjectRoot)(candidate);
+            if (!resolvedRoot) {
+                throw new vscode_jsonrpc_1.ResponseError(vscode_jsonrpc_1.ErrorCodes.InvalidParams, 'No ArkTS project root found in workspace.');
+            }
+            const parsed = (0, project_1.parseProject)(resolvedRoot, env.sdkPath);
+            if (!parsed) {
+                throw new vscode_jsonrpc_1.ResponseError(vscode_jsonrpc_1.ErrorCodes.InvalidParams, `Unable to parse build-profile.json5 at ${resolvedRoot}`);
+            }
+            project = parsed;
+            scheduleHvigorSync(parsed.projectRoot);
+            const handle = (0, ace_server_1.startAceServer)(env);
+            aceHandle = handle;
+            const conn = createAceConnection(handle.process);
+            aceConn = conn;
+            conn.listen();
+            handle.onExit((code, signal) => {
+                if (disposed) {
+                    return;
+                }
+                process.stderr.write(`[arkts-lsp] ace-server exited (code=${code}, signal=${signal})\n`);
+                clearQueues(new vscode_jsonrpc_1.ResponseError(vscode_jsonrpc_1.ErrorCodes.InternalError, 'ace-server exited unexpectedly'));
+            });
+            return conn;
+        })();
+        const runningPromise = bootstrapPromise;
+        runningPromise.finally(() => {
+            isBootstrapping = false;
+            if (bootstrapPromise === runningPromise) {
+                bootstrapPromise = null;
+            }
+        });
+        return runningPromise;
+    }
+    function resolveInitializeRequest(params) {
+        if (initializePromise) {
+            return initializePromise;
+        }
+        const initRootHint = inferProjectRootFromInitializeParams(params);
+        initializePromise = (async () => {
+            const connection = await ensureServer(initRootHint);
+            if (!project) {
+                throw new vscode_jsonrpc_1.ResponseError(vscode_jsonrpc_1.ErrorCodes.InvalidParams, 'Project not available');
+            }
+            const payload = (0, project_1.buildInitializationOptions)(project);
+            const initMessage = injectInitializationOptions({
+                id: 0,
+                method: 'initialize',
+                params: isPlainObject(params) ? params : {},
+            }, payload);
+            const initParams = (initMessage.params || {});
+            if (getEditorFiles(openFiles).length > 0) {
+                initParams.editorFiles = getEditorFiles(openFiles);
+            }
+            const result = await connection.sendRequest('initialize', initParams);
+            isInitialized = true;
+            isServerReady = true;
+            flushQueues();
+            return result;
+        })().catch((err) => {
+            isInitialized = false;
+            clearQueues(err);
+            throw err;
+        }).finally(() => {
+            initializePromise = null;
+        });
+        return initializePromise;
+    }
+    function onRequest(method, params) {
+        if (method === 'initialize') {
+            return resolveInitializeRequest(params);
+        }
+        if (!isInitialized && !initializePromise) {
+            return Promise.reject(new vscode_jsonrpc_1.ResponseError(vscode_jsonrpc_1.ErrorCodes.ServerNotInitialized, 'Initialize first.'));
+        }
+        const mapped = mapRequest(method, params, openFiles);
+        const targetMethod = mapped?.method ?? method;
+        const targetParams = mapped?.params ?? createRequestPayload(params);
+        const useNotificationResponse = Boolean(mapped);
+        if (!aceConn) {
+            if (!initializePromise) {
+                return Promise.reject(new vscode_jsonrpc_1.ResponseError(vscode_jsonrpc_1.ErrorCodes.InternalError, 'ace connection is not ready'));
+            }
+            return queueRequest(() => {
+                if (!aceConn) {
+                    return Promise.reject(new vscode_jsonrpc_1.ResponseError(vscode_jsonrpc_1.ErrorCodes.InternalError, 'ace connection is not ready'));
+                }
+                return sendAceRequest(aceConn, targetMethod, targetParams, useNotificationResponse);
+            });
+        }
+        if (!isServerReady) {
+            const activeConn = aceConn;
+            if (!activeConn) {
+                return Promise.reject(new vscode_jsonrpc_1.ResponseError(vscode_jsonrpc_1.ErrorCodes.InternalError, 'ace connection is not ready'));
+            }
+            return queueRequest(() => sendAceRequest(activeConn, targetMethod, targetParams, useNotificationResponse));
+        }
+        return sendAceRequest(aceConn, targetMethod, targetParams, useNotificationResponse);
+    }
+    function onNotification(method, params) {
+        if (method === 'textDocument/didOpen') {
+            const textDocument = isPlainObject(params) ? params.textDocument : undefined;
+            const uri = isPlainObject(textDocument) ? textDocument.uri : undefined;
+            if (uri && typeof uri === 'string') {
+                openFiles.add(uri);
+            }
+        }
+        if (method === 'textDocument/didClose') {
+            const textDocument = isPlainObject(params) ? params.textDocument : undefined;
+            const uri = isPlainObject(textDocument) ? textDocument.uri : undefined;
+            if (uri && typeof uri === 'string') {
+                openFiles.delete(uri);
+            }
+        }
+        if (method === 'initialized') {
+            const editors = getOpenFileUris(openFiles).map((uri) => ({ uri, selected: true, receivedOpened: false }));
+            const payload = {
+                ...(isPlainObject(params) ? params : {}),
+                editors,
+            };
+            if (!aceConn) {
+                queueNotification('initialized', payload);
+                return;
+            }
+            aceConn.sendNotification('initialized', payload);
+            return;
+        }
+        const mapped = mapNotification(method, params, openFiles);
+        const finalMethod = mapped ? mapped.method : method;
+        const finalParams = mapped ? mapped.params : createRequestPayload(params);
+        if (!isServerReady || !aceConn) {
+            queueNotification(finalMethod, finalParams);
+            return;
+        }
+        try {
+            aceConn.sendNotification(finalMethod, finalParams);
+        }
+        catch {
+            queueNotification(finalMethod, finalParams);
+        }
+    }
+    clientConn.onRequest((method, params) => {
+        return onRequest(method, params);
+    });
+    clientConn.onNotification((method, params) => {
+        onNotification(method, params);
+    });
+    clientConn.onError((error) => {
+        process.stderr.write(`[arkts-lsp] client connection error: ${String(error)}\n`);
+    });
+    clientConn.listen();
+    return {
+        dispose: () => {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            clearQueues(new Error('disposed'));
+            if (aceHandle) {
+                aceHandle.dispose();
+            }
+            if (bootstrapPromise && isBootstrapping) {
+                bootstrapPromise = null;
+            }
+            clientConn.dispose();
+        },
+    };
+}
 //# sourceMappingURL=proxy.js.map