weavatrix 0.3.14 → 1.0.0

package/src/precision/lsp-client/message-parser.js

@@ -1,81 +0,0 @@
-import {TextDecoder} from 'node:util'
-import {DEFAULT_MAX_HEADER_BYTES, DEFAULT_MAX_MESSAGE_BYTES, positiveInteger} from './constants.js'
-import {LspProtocolError} from './errors.js'
-
-const HEADER_DELIMITER = Buffer.from('\r\n\r\n', 'ascii')
-const UTF8_DECODER = new TextDecoder('utf-8', {fatal: true})
-
-function asBuffer(chunk) {
-    if (Buffer.isBuffer(chunk)) return chunk
-    if (chunk instanceof Uint8Array) return Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)
-    return Buffer.from(chunk)
-}
-
-function parseHeaders(bytes, maxMessageBytes) {
-    const lines = bytes.toString('ascii').split('\r\n')
-    let contentLength = null
-    for (const line of lines) {
-        const match = /^([!#$%&'*+\-.^_`|~0-9A-Za-z]+):[ \t]*(.*)$/.exec(line)
-        if (!match) throw new LspProtocolError('Malformed LSP header line')
-        if (match[1].toLowerCase() !== 'content-length') continue
-        if (contentLength != null) throw new LspProtocolError('Duplicate Content-Length header')
-        if (!/^(0|[1-9][0-9]*)$/.test(match[2])) throw new LspProtocolError('Invalid Content-Length header')
-        contentLength = Number(match[2])
-        if (!Number.isSafeInteger(contentLength) || contentLength <= 0) {
-            throw new LspProtocolError('Content-Length must be positive')
-        }
-        if (contentLength > maxMessageBytes) {
-            throw new LspProtocolError(`LSP message exceeds ${maxMessageBytes} byte limit`)
-        }
-    }
-    if (contentLength == null) throw new LspProtocolError('Missing Content-Length header')
-    return contentLength
-}
-
-/** Incremental parser for the Content-Length framed JSON-RPC transport used by LSP. */
-export class ContentLengthMessageParser {
-    constructor({onMessage, maxMessageBytes = DEFAULT_MAX_MESSAGE_BYTES, maxHeaderBytes = DEFAULT_MAX_HEADER_BYTES} = {}) {
-        if (typeof onMessage !== 'function') throw new TypeError('onMessage must be a function')
-        this.onMessage = onMessage
-        this.maxMessageBytes = positiveInteger(maxMessageBytes, DEFAULT_MAX_MESSAGE_BYTES, 'maxMessageBytes')
-        this.maxHeaderBytes = positiveInteger(maxHeaderBytes, DEFAULT_MAX_HEADER_BYTES, 'maxHeaderBytes')
-        this.buffer = Buffer.alloc(0)
-        this.expectedBodyBytes = null
-    }
-
-    push(chunk) {
-        const incoming = asBuffer(chunk)
-        if (incoming.length === 0) return
-        this.buffer = this.buffer.length === 0 ? incoming : Buffer.concat([this.buffer, incoming])
-        while (this.buffer.length > 0) {
-            if (this.expectedBodyBytes == null) {
-                const delimiterIndex = this.buffer.indexOf(HEADER_DELIMITER)
-                if (delimiterIndex < 0) {
-                    if (this.buffer.length > this.maxHeaderBytes) throw new LspProtocolError('LSP header exceeds byte limit')
-                    return
-                }
-                if (delimiterIndex === 0) throw new LspProtocolError('Empty LSP header block')
-                if (delimiterIndex > this.maxHeaderBytes) throw new LspProtocolError('LSP header exceeds byte limit')
-                this.expectedBodyBytes = parseHeaders(
-                    this.buffer.subarray(0, delimiterIndex),
-                    this.maxMessageBytes,
-                )
-                this.buffer = this.buffer.subarray(delimiterIndex + HEADER_DELIMITER.length)
-            }
-            if (this.buffer.length < this.expectedBodyBytes) return
-            const body = this.buffer.subarray(0, this.expectedBodyBytes)
-            this.buffer = this.buffer.subarray(this.expectedBodyBytes)
-            this.expectedBodyBytes = null
-            let value
-            try {
-                value = JSON.parse(UTF8_DECODER.decode(body))
-            } catch (error) {
-                throw new LspProtocolError('Invalid UTF-8 JSON in LSP message', {cause: error})
-            }
-            if (value == null || typeof value !== 'object' || Array.isArray(value)) {
-                throw new LspProtocolError('LSP message must be a JSON object')
-            }
-            this.onMessage(value)
-        }
-    }
-}

package/src/precision/lsp-client/protocol.js

@@ -1,212 +0,0 @@
-import {JSON_RPC_VERSION, positiveInteger} from './constants.js'
-import {LspProtocolError, LspTimeoutError} from './errors.js'
-import {WEAVATRIX_VERSION} from '../../version.js'
-
-export function assertPosition(position) {
-    if (position == null || typeof position !== 'object') throw new TypeError('position is required')
-    const line = Number(position.line)
-    const character = Number(position.character)
-    if (!Number.isSafeInteger(line) || line < 0 || !Number.isSafeInteger(character) || character < 0) {
-        throw new TypeError('position line and character must be non-negative integers')
-    }
-    return {line, character}
-}
-
-function normalizeRange(range) {
-    if (range == null || typeof range !== 'object') throw new LspProtocolError('LSP location is missing a range')
-    return {start: assertPosition(range.start), end: assertPosition(range.end)}
-}
-
-function jsonRpcError(error) {
-    const wrapped = new Error(error?.message || 'LSP request failed')
-    wrapped.name = 'LspResponseError'
-    wrapped.code = error?.code
-    wrapped.data = error?.data
-    return wrapped
-}
-
-export function assertClientWritable(client) {
-    if (!['running', 'initialized', 'stopping'].includes(client.state) || client.child.stdin?.destroyed) {
-        throw new Error(`LSP client is not writable (state=${client.state})`)
-    }
-}
-
-export function writeClientMessage(client, message) {
-    assertClientWritable(client)
-    const body = Buffer.from(JSON.stringify(message), 'utf8')
-    if (body.length > client.maxMessageBytes) {
-        throw new LspProtocolError(`Outgoing LSP message exceeds ${client.maxMessageBytes} byte limit`)
-    }
-    const header = Buffer.from(`Content-Length: ${body.length}\r\n\r\n`, 'ascii')
-    return new Promise((resolveWrite, rejectWrite) => {
-        client.child.stdin.write(
-            Buffer.concat([header, body]),
-            (error) => error ? rejectWrite(error) : resolveWrite(),
-        )
-    })
-}
-
-export async function requestFromClient(client, method, params = null, {timeoutMs = client.requestTimeoutMs} = {}) {
-    if (typeof method !== 'string' || method === '') throw new TypeError('LSP method is required')
-    const boundedTimeout = positiveInteger(timeoutMs, client.requestTimeoutMs, 'timeoutMs')
-    const id = client.nextId++
-    let entry
-    const response = new Promise((resolveResponse, rejectResponse) => {
-        const timer = setTimeout(() => {
-            if (client.pending.get(id) !== entry) return
-            client.pending.delete(id)
-            void writeClientMessage(client, {
-                jsonrpc: JSON_RPC_VERSION,
-                method: '$/cancelRequest',
-                params: {id},
-            }).catch(() => {})
-            rejectResponse(new LspTimeoutError(method, boundedTimeout))
-        }, boundedTimeout)
-        entry = {method, timer, resolve: resolveResponse, reject: rejectResponse}
-        client.pending.set(id, entry)
-    })
-    try {
-        await writeClientMessage(client, {jsonrpc: JSON_RPC_VERSION, id, method, params})
-    } catch (error) {
-        if (client.pending.get(id) === entry) {
-            clearTimeout(entry.timer)
-            client.pending.delete(id)
-            entry.reject(error)
-        }
-    }
-    return response
-}
-
-export async function notifyClient(client, method, params = null) {
-    if (typeof method !== 'string' || method === '') throw new TypeError('LSP method is required')
-    await writeClientMessage(client, {jsonrpc: JSON_RPC_VERSION, method, params})
-}
-
-export async function initializeClient(client, {
-    capabilities = {},
-    initializationOptions,
-    clientInfo = {name: 'weavatrix', version: WEAVATRIX_VERSION},
-} = {}) {
-    if (client.state !== 'running') throw new Error(`LSP initialize is invalid in state=${client.state}`)
-    const workspaceName = client.normalizer.rootPath.split(/[\\/]/).pop() || 'repository'
-    const result = await requestFromClient(client, 'initialize', {
-        processId: process.pid,
-        clientInfo,
-        rootUri: client.normalizer.rootUri,
-        capabilities,
-        initializationOptions,
-        workspaceFolders: [{uri: client.normalizer.rootUri, name: workspaceName}],
-    })
-    await notifyClient(client, 'initialized', {})
-    client.state = 'initialized'
-    return result
-}
-
-export async function openClientDocument(client, {filePath, text, languageId, version = 1}) {
-    if (client.state !== 'initialized') throw new Error('LSP client is not initialized')
-    if (typeof text !== 'string') throw new TypeError('document text must be a string')
-    if (typeof languageId !== 'string' || languageId === '') throw new TypeError('languageId is required')
-    if (!Number.isSafeInteger(version) || version < 0) {
-        throw new TypeError('document version must be a non-negative integer')
-    }
-    const normalized = client.normalizer.toUri(filePath)
-    await notifyClient(client, 'textDocument/didOpen', {
-        textDocument: {uri: normalized.uri, languageId, version, text},
-    })
-    client.openDocuments.set(normalized.uri, {file: normalized.file, version, languageId})
-    return {file: normalized.file, version, languageId}
-}
-
-export async function closeClientDocument(client, filePath) {
-    const normalized = client.normalizer.toUri(filePath)
-    if (!client.openDocuments.has(normalized.uri)) return false
-    await notifyClient(client, 'textDocument/didClose', {textDocument: {uri: normalized.uri}})
-    client.openDocuments.delete(normalized.uri)
-    return true
-}
-
-export function normalizeClientLocations(client, result) {
-    const locations = []
-    for (const raw of result == null ? [] : Array.isArray(result) ? result : [result]) {
-        if (raw == null || typeof raw !== 'object') continue
-        const uri = raw.uri || raw.targetUri
-        const range = raw.range || raw.targetSelectionRange || raw.targetRange
-        try {
-            const normalized = client.normalizer.fromUri(uri)
-            locations.push({file: normalized.file, range: normalizeRange(range)})
-        } catch (error) {
-            if (error instanceof RangeError) continue
-            throw error
-        }
-    }
-    return locations
-}
-
-export async function queryClientLocations(client, kind, {filePath, position, includeDeclaration = true, timeoutMs}) {
-    const normalized = client.normalizer.toUri(filePath)
-    const method = kind === 'references' ? 'textDocument/references' : 'textDocument/definition'
-    const params = {textDocument: {uri: normalized.uri}, position: assertPosition(position)}
-    if (kind === 'references') params.context = {includeDeclaration: Boolean(includeDeclaration)}
-    const result = await requestFromClient(client, method, params, {
-        timeoutMs: timeoutMs ?? client.requestTimeoutMs,
-    })
-    return normalizeClientLocations(client, result)
-}
-
-export async function defaultClientServerRequest(client, method, params) {
-    if (method === 'workspace/configuration') return Array.isArray(params?.items) ? params.items.map(() => null) : []
-    if (method === 'workspace/workspaceFolders') {
-        return [{uri: client.normalizer.rootUri, name: client.normalizer.rootPath.split(/[\\/]/).pop() || 'repository'}]
-    }
-    if (['client/registerCapability', 'client/unregisterCapability', 'window/workDoneProgress/create'].includes(method)) return null
-    if (method === 'workspace/applyEdit') {
-        return {applied: false, failureReason: 'Weavatrix precision provider is read-only'}
-    }
-    const error = new Error(`Unsupported LSP server request: ${method}`)
-    error.code = -32601
-    throw error
-}
-
-export async function handleClientServerRequest(client, message) {
-    try {
-        const result = client.onServerRequest
-            ? await client.onServerRequest(message.method, message.params, client)
-            : await defaultClientServerRequest(client, message.method, message.params)
-        await writeClientMessage(client, {jsonrpc: JSON_RPC_VERSION, id: message.id, result: result ?? null})
-    } catch (error) {
-        try {
-            await writeClientMessage(client, {
-                jsonrpc: JSON_RPC_VERSION,
-                id: message.id,
-                error: {
-                    code: Number.isInteger(error?.code) ? error.code : -32603,
-                    message: error?.message || 'LSP client error',
-                },
-            })
-        } catch { /* process exited while request handler was running */ }
-    }
-}
-
-export function handleClientMessage(client, message) {
-    if (message.jsonrpc !== JSON_RPC_VERSION) throw new LspProtocolError('Unsupported JSON-RPC version from LSP server')
-    if (typeof message.method === 'string') {
-        if (message.id != null) void handleClientServerRequest(client, message)
-        else client.onNotification?.(message.method, message.params, client)
-        return
-    }
-    if (message.id == null) throw new LspProtocolError('LSP response is missing an id')
-    const entry = client.pending.get(message.id)
-    if (!entry) return
-    client.pending.delete(message.id)
-    clearTimeout(entry.timer)
-    if (message.error != null) entry.reject(jsonRpcError(message.error))
-    else entry.resolve(message.result)
-}
-
-export function rejectPendingRequests(client, error) {
-    for (const entry of client.pending.values()) {
-        clearTimeout(entry.timer)
-        entry.reject(error)
-    }
-    client.pending.clear()
-}

package/src/precision/lsp-client/registry.js

@@ -1,59 +0,0 @@
-const ACTIVE_LSP_CLIENTS = new Set()
-let acceptingLspClients = true
-
-export function assertLspClientCreationAllowed() {
-    if (!acceptingLspClients) throw new Error('LSP process creation is disabled during MCP shutdown')
-}
-
-export function registerLspClient(client) {
-    ACTIVE_LSP_CLIENTS.add(client)
-}
-
-export function unregisterLspClient(client) {
-    ACTIVE_LSP_CLIENTS.delete(client)
-}
-
-export function isLspClientActive(client) {
-    return ACTIVE_LSP_CLIENTS.has(client)
-}
-
-export function activeLspClientCount() {
-    return ACTIVE_LSP_CLIENTS.size
-}
-
-export function beginLspClientShutdown() {
-    acceptingLspClients = false
-}
-
-export async function shutdownActiveLspClients({timeoutMs = 3_000} = {}) {
-    const boundedTimeout = Math.max(250, Math.min(10_000, Number(timeoutMs) || 3_000))
-    const startedAt = Date.now()
-    const clients = [...ACTIVE_LSP_CLIENTS]
-    if (!clients.length) return {requested: 0, remaining: 0, timedOut: false}
-    let timer
-    const gracefulBudget = Math.max(125, Math.floor(boundedTimeout * 0.6))
-    const graceful = Promise.allSettled(clients.map((client) => client.shutdown({timeoutMs: boundedTimeout})))
-    const outcome = await Promise.race([
-        graceful.then(() => 'closed'),
-        new Promise((resolveOutcome) => { timer = setTimeout(() => resolveOutcome('timeout'), gracefulBudget) }),
-    ])
-    if (timer) clearTimeout(timer)
-    const survivors = [...ACTIVE_LSP_CLIENTS]
-    if (survivors.length) {
-        const reason = new Error(`MCP shutdown timed out with ${ACTIVE_LSP_CLIENTS.size} active LSP client(s)`)
-        const forceBudget = Math.max(100, boundedTimeout - (Date.now() - startedAt))
-        await Promise.allSettled(survivors.map(async (client) => {
-            if (typeof client.killWindowsTreeAndWait === 'function') await client.killWindowsTreeAndWait(forceBudget)
-            client.kill(reason)
-        }))
-        const reapBudget = Math.max(250, Math.min(1_000, Math.floor(boundedTimeout * 0.4)))
-        await Promise.allSettled(survivors.map((client) => (
-            typeof client.waitForExit === 'function' ? client.waitForExit(reapBudget) : undefined
-        )))
-    }
-    return {
-        requested: clients.length,
-        remaining: ACTIVE_LSP_CLIENTS.size,
-        timedOut: outcome === 'timeout' || ACTIVE_LSP_CLIENTS.size > 0,
-    }
-}

package/src/precision/lsp-client/repo-uri.js

@@ -1,60 +0,0 @@
-import {realpathSync} from 'node:fs'
-import {isAbsolute, relative, resolve, sep} from 'node:path'
-import {fileURLToPath, pathToFileURL} from 'node:url'
-
-function normalizeFilesystemPath(path) {
-    let normalized = path
-    if (process.platform === 'win32' && normalized.startsWith('\\\\?\\UNC\\')) normalized = `\\\\${normalized.slice(8)}`
-    else if (process.platform === 'win32' && normalized.startsWith('\\\\?\\')) normalized = normalized.slice(4)
-    return resolve(normalized)
-}
-
-function realpathIfPossible(path) {
-    try { return normalizeFilesystemPath(realpathSync.native(path)) }
-    catch { return normalizeFilesystemPath(path) }
-}
-
-function existingRealpath(path) {
-    try { return normalizeFilesystemPath(realpathSync.native(path)) }
-    catch { return null }
-}
-
-function pathInside(rootPath, candidatePath) {
-    const rel = relative(rootPath, candidatePath)
-    return rel === '' || (rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel))
-}
-
-function portableRelative(rootPath, candidatePath) {
-    return relative(rootPath, candidatePath).split(sep).join('/')
-}
-
-/** Repository-bounded path/URI conversion surface used by the client. */
-export function createRepoUriNormalizer(repoRoot) {
-    if (typeof repoRoot !== 'string' || repoRoot.trim() === '') throw new TypeError('repoRoot is required')
-    const lexicalRoot = normalizeFilesystemPath(resolve(repoRoot))
-    const absoluteRoot = realpathIfPossible(lexicalRoot)
-    const toAbsolute = (filePath) => {
-        if (typeof filePath !== 'string' || filePath.trim() === '') throw new TypeError('filePath is required')
-        const lexicalPath = normalizeFilesystemPath(resolve(lexicalRoot, filePath))
-        const canonicalPath = existingRealpath(lexicalPath)
-        if (canonicalPath == null) {
-            if (!pathInside(lexicalRoot, lexicalPath)) throw new RangeError('LSP path is outside the repository')
-            return lexicalPath
-        }
-        if (!pathInside(absoluteRoot, canonicalPath)) throw new RangeError('LSP path resolves outside the repository')
-        return canonicalPath
-    }
-    const fromUri = (uri) => {
-        if (typeof uri !== 'string' || !uri.startsWith('file:')) throw new RangeError('Only file: LSP URIs are accepted')
-        let filePath
-        try { filePath = fileURLToPath(uri) }
-        catch (error) { throw new RangeError('Invalid file: LSP URI', {cause: error}) }
-        const absolutePath = toAbsolute(filePath)
-        return {file: portableRelative(absoluteRoot, absolutePath), absolutePath, uri: pathToFileURL(absolutePath).href}
-    }
-    const toUri = (filePath) => {
-        const absolutePath = toAbsolute(filePath)
-        return {file: portableRelative(absoluteRoot, absolutePath), absolutePath, uri: pathToFileURL(absolutePath).href}
-    }
-    return {rootPath: absoluteRoot, rootUri: pathToFileURL(absoluteRoot).href, toAbsolute, toUri, fromUri}
-}

package/src/precision/lsp-client/stdio-client.js

@@ -1,140 +0,0 @@
-import {spawn as spawnChild} from 'node:child_process'
-import {isAbsolute} from 'node:path'
-import {
-    DEFAULT_MAX_HEADER_BYTES,
-    DEFAULT_MAX_MESSAGE_BYTES,
-    DEFAULT_REQUEST_TIMEOUT_MS,
-    positiveInteger,
-} from './constants.js'
-import {lspChildProcessEnv} from './environment.js'
-import {ContentLengthMessageParser} from './message-parser.js'
-import {createRepoUriNormalizer} from './repo-uri.js'
-import {
-    assertLspClientCreationAllowed,
-    registerLspClient,
-    unregisterLspClient,
-} from './registry.js'
-import {
-    closeClientDocument,
-    handleClientMessage,
-    initializeClient,
-    openClientDocument,
-    queryClientLocations,
-    rejectPendingRequests,
-    requestFromClient,
-    writeClientMessage,
-} from './protocol.js'
-import {
-    failClient,
-    killClient,
-    killWindowsTreeAndWait,
-    shutdownClient,
-    waitForClientExit,
-} from './lifecycle.js'
-
-export class StdioLspClient {
-    constructor({
-        repoRoot,
-        executablePath = process.execPath,
-        args = [],
-        env = {},
-        requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS,
-        maxMessageBytes = DEFAULT_MAX_MESSAGE_BYTES,
-        maxHeaderBytes = DEFAULT_MAX_HEADER_BYTES,
-        onNotification,
-        onServerRequest,
-        spawn = spawnChild,
-    } = {}) {
-        if (typeof executablePath !== 'string' || !isAbsolute(executablePath)) {
-            throw new TypeError('LSP executablePath must be absolute')
-        }
-        if (!Array.isArray(args) || args.some((arg) => typeof arg !== 'string')) {
-            throw new TypeError('LSP args must be strings')
-        }
-        if (typeof spawn !== 'function') throw new TypeError('spawn must be a function')
-        assertLspClientCreationAllowed()
-        this.normalizer = createRepoUriNormalizer(repoRoot)
-        this.requestTimeoutMs = positiveInteger(requestTimeoutMs, DEFAULT_REQUEST_TIMEOUT_MS, 'requestTimeoutMs')
-        this.maxMessageBytes = positiveInteger(maxMessageBytes, DEFAULT_MAX_MESSAGE_BYTES, 'maxMessageBytes')
-        this.onNotification = typeof onNotification === 'function' ? onNotification : null
-        this.onServerRequest = typeof onServerRequest === 'function' ? onServerRequest : null
-        this.pending = new Map()
-        this.openDocuments = new Map()
-        this.nextId = 1
-        this.state = 'starting'
-        this.stderrTail = ''
-        this.shutdownPromise = null
-        this.windowsTreeKillPromise = null
-        this.child = spawn(executablePath, args, {
-            cwd: this.normalizer.rootPath,
-            env: lspChildProcessEnv(env),
-            shell: false,
-            detached: process.platform !== 'win32',
-            windowsHide: true,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        })
-        this.processGroupPid = process.platform !== 'win32' && Number.isInteger(this.child.pid)
-            ? this.child.pid : null
-        registerLspClient(this)
-        this.parser = new ContentLengthMessageParser({
-            maxMessageBytes: this.maxMessageBytes,
-            maxHeaderBytes,
-            onMessage: (message) => this.handleMessage(message),
-        })
-        this.child.stdout?.on('data', (chunk) => {
-            try { this.parser.push(chunk) }
-            catch (error) { this.fail(error) }
-        })
-        this.child.stderr?.setEncoding('utf8')
-        this.child.stderr?.on('data', (chunk) => {
-            this.stderrTail = `${this.stderrTail}${chunk}`.slice(-16_000)
-        })
-        this.spawned = new Promise((resolveSpawn, rejectSpawn) => {
-            this.child.once('spawn', () => {
-                if (this.state === 'starting') this.state = 'running'
-                resolveSpawn(this)
-            })
-            this.child.once('error', (error) => {
-                this.fail(error)
-                rejectSpawn(error)
-            })
-        })
-        this.exited = new Promise((resolveExit) => {
-            let settled = false
-            const finishExit = (code, signal) => {
-                if (settled) return
-                settled = true
-                const wasStopping = this.state === 'stopping' || this.state === 'closed'
-                this.state = 'closed'
-                const suffix = this.stderrTail ? `\n${this.stderrTail}` : ''
-                this.rejectPending(new Error(`LSP server exited (code=${code}, signal=${signal})${suffix}`))
-                if (!wasStopping && code !== 0) this.openDocuments.clear()
-                unregisterLspClient(this)
-                resolveExit({code, signal})
-            }
-            this.child.once('exit', finishExit)
-            this.child.once('close', finishExit)
-        })
-    }
-
-    async start() { await this.spawned; return this }
-    writeMessage(message) { return writeClientMessage(this, message) }
-    request(method, params, options) { return requestFromClient(this, method, params, options) }
-    initialize(options) { return initializeClient(this, options) }
-    openDocument(options) { return openClientDocument(this, options) }
-    closeDocument(filePath) { return closeClientDocument(this, filePath) }
-    definition(options) { return queryClientLocations(this, 'definition', options) }
-    references(options) { return queryClientLocations(this, 'references', options) }
-    handleMessage(message) { return handleClientMessage(this, message) }
-    rejectPending(error) { return rejectPendingRequests(this, error) }
-    fail(error) { return failClient(this, error) }
-    kill(reason) { return killClient(this, reason) }
-    killWindowsTreeAndWait(timeoutMs) { return killWindowsTreeAndWait(this, timeoutMs) }
-    waitForExit(timeoutMs) { return waitForClientExit(this, timeoutMs) }
-    shutdown(options) { return shutdownClient(this, options) }
-}
-
-export async function startStdioLspClient(options) {
-    const client = new StdioLspClient(options)
-    return client.start()
-}

package/src/precision/lsp-client.js

@@ -1,10 +0,0 @@
-export {
-    activeLspClientCount,
-    beginLspClientShutdown,
-    shutdownActiveLspClients,
-} from './lsp-client/registry.js'
-export {lspChildProcessEnv} from './lsp-client/environment.js'
-export {LspProtocolError, LspTimeoutError} from './lsp-client/errors.js'
-export {ContentLengthMessageParser} from './lsp-client/message-parser.js'
-export {createRepoUriNormalizer} from './lsp-client/repo-uri.js'
-export {StdioLspClient, startStdioLspClient} from './lsp-client/stdio-client.js'

package/src/precision/lsp-overlay/budget-policy.js

@@ -1,78 +0,0 @@
-import {boundedInteger} from '../../bounds.js'
-
-const DEFAULT_MAX_SYMBOLS = 32
-const BOUNDED_MAX_SYMBOLS = 64
-const EXPANDED_MAX_SYMBOLS = 10_000
-const DEFAULT_MAX_REFERENCES = 2_048
-const BOUNDED_MAX_REFERENCES = 16_384
-const EXPANDED_MAX_REFERENCES = 131_072
-const DEFAULT_MAX_LINKS = 2_048
-const BOUNDED_MAX_LINKS = 16_384
-const EXPANDED_MAX_LINKS = 131_072
-const DEFAULT_TIMEOUT_MS = 45_000
-const BOUNDED_MAX_TIMEOUT_MS = 60_000
-const EXPANDED_MAX_TIMEOUT_MS = 30 * 60_000
-
-function configured(value, environmentName) {
-  if (value !== undefined && value !== null && String(value).trim() !== '') return value
-  const environmentValue = process.env[environmentName]
-  return environmentValue != null && String(environmentValue).trim() !== ''
-    ? environmentValue : undefined
-}
-
-export function precisionPrewarmBudget(options = {}) {
-  const targetBatch = Array.isArray(options.targetIds) && options.targetIds.length > 0
-  const configuredMode = String(configured(
-    options.prewarmMode,
-    'WEAVATRIX_PRECISION_PREWARM',
-  ) || 'bounded').trim().toLowerCase()
-  const full = configuredMode === 'full' && !targetBatch
-  const requestedSymbols = configured(options.maxSymbols, 'WEAVATRIX_PRECISION_MAX_SYMBOLS')
-  const numericSymbols = Number(requestedSymbols)
-  const expanded = full || (Number.isFinite(numericSymbols) && numericSymbols > BOUNDED_MAX_SYMBOLS)
-  const maxSymbols = full ? EXPANDED_MAX_SYMBOLS : boundedInteger(
-    requestedSymbols,
-    DEFAULT_MAX_SYMBOLS,
-    1,
-    expanded ? EXPANDED_MAX_SYMBOLS : BOUNDED_MAX_SYMBOLS,
-  )
-  const referenceFallback = expanded
-    ? Math.min(EXPANDED_MAX_REFERENCES, Math.max(DEFAULT_MAX_REFERENCES, maxSymbols * 16))
-    : DEFAULT_MAX_REFERENCES
-  const linkFallback = expanded
-    ? Math.min(EXPANDED_MAX_LINKS, Math.max(DEFAULT_MAX_LINKS, maxSymbols * 16))
-    : DEFAULT_MAX_LINKS
-  const timeoutFallback = expanded
-    ? Math.min(15 * 60_000, Math.max(DEFAULT_TIMEOUT_MS, maxSymbols * 1_000))
-    : DEFAULT_TIMEOUT_MS
-  const maxReferences = boundedInteger(
-    configured(options.maxReferences, 'WEAVATRIX_PRECISION_MAX_REFERENCES'),
-    referenceFallback,
-    1,
-    expanded ? EXPANDED_MAX_REFERENCES : BOUNDED_MAX_REFERENCES,
-  )
-  const maxLinks = boundedInteger(
-    configured(options.maxLinks, 'WEAVATRIX_PRECISION_MAX_LINKS'),
-    linkFallback,
-    1,
-    expanded ? EXPANDED_MAX_LINKS : BOUNDED_MAX_LINKS,
-  )
-  const timeoutMs = boundedInteger(
-    configured(options.timeoutMs, 'WEAVATRIX_PRECISION_TIMEOUT_MS'),
-    timeoutFallback,
-    100,
-    expanded ? EXPANDED_MAX_TIMEOUT_MS : BOUNDED_MAX_TIMEOUT_MS,
-  )
-  return {
-    expanded,
-    full,
-    maxSymbols,
-    maxReferences,
-    maxLinks,
-    timeoutMs,
-    maxOpenDocuments: expanded ? 1_024 : 96,
-    maxOpenBytes: expanded ? 128 * 1024 * 1024 : 32 * 1024 * 1024,
-    maxClassificationDocuments: expanded ? 1_024 : 96,
-    maxClassificationBytes: expanded ? 128 * 1024 * 1024 : 32 * 1024 * 1024,
-  }
-}