weavatrix 0.3.14 → 1.1.0

package/src/precision/lsp-overlay/store.js

@@ -1,150 +0,0 @@
-import {existsSync, readFileSync} from 'node:fs'
-import {dirname, resolve} from 'node:path'
-import {atomicWriteFileSync} from '../../graph/file-lock.js'
-import {edgeProvenance} from '../../graph/edge-provenance.js'
-import {
-  PRECISION_FILE,
-  PRECISION_OVERLAY_V,
-  baseOverlay,
-  endpoint,
-  precisionOverlayMatches,
-} from './contract.js'
-
-export function precisionPathForGraph(graphPath) {
-  return resolve(dirname(graphPath), PRECISION_FILE)
-}
-
-export function readPrecisionOverlay(graphPath, graph) {
-  const path = precisionPathForGraph(graphPath)
-  if (!existsSync(path)) return null
-  try {
-    const overlay = JSON.parse(readFileSync(path, 'utf8'))
-    return precisionOverlayMatches(overlay, graph) ? overlay : null
-  } catch { return null }
-}
-
-export function precisionSummary(overlay) {
-  if (!overlay) return {
-    state: 'UNAVAILABLE',
-    provider: null,
-    verifiedEdges: 0,
-    candidates: 0,
-    queried: 0,
-    reason: 'no revision-matched precision overlay',
-  }
-  const engine = Array.isArray(overlay.engines) ? overlay.engines[0] : null
-  return {
-    state: String(overlay.state || 'UNAVAILABLE'),
-    provider: engine?.provider || null,
-    providerVersion: engine?.version || null,
-    typescriptVersion: engine?.typescriptVersion || null,
-    verifiedEdges: Number(overlay.coverage?.verifiedEdges) || 0,
-    candidates: Number(overlay.coverage?.candidates) || 0,
-    selected: Number(overlay.coverage?.selected) || 0,
-    queried: Number(overlay.coverage?.queried) || 0,
-    references: Number(overlay.coverage?.references) || 0,
-    unclassifiedReferences: Number(overlay.coverage?.unclassifiedReferences) || 0,
-    referenceEvidence: Array.isArray(overlay.referenceEvidence) ? overlay.referenceEvidence.length : 0,
-    truncated: overlay.coverage?.truncated === true,
-    reason: overlay.reason || engine?.reason || null,
-    noReferenceSymbols: Array.isArray(overlay.noReferenceSymbols) ? overlay.noReferenceSymbols.length : 0,
-  }
-}
-
-export function mergePrecisionOverlay(graph, overlay) {
-  if (!precisionOverlayMatches(overlay, graph)) return {...graph, precision: precisionSummary(null)}
-  const nodes = Array.isArray(graph.nodes) ? graph.nodes : []
-  const ids = new Set(nodes.map((node) => String(node.id)))
-  const links = (Array.isArray(graph.links) ? graph.links : []).map((link) => ({...link}))
-  for (const exact of Array.isArray(overlay.links) ? overlay.links : []) {
-    const source = endpoint(exact.source)
-    const target = endpoint(exact.target)
-    if (!ids.has(source) || !ids.has(target) || source === target) continue
-    const relation = String(exact.relation || 'references')
-    const exactLine = Number.isInteger(exact.line) ? exact.line : null
-    const exactCharacter = Number.isInteger(exact.character) ? exact.character : null
-    let matched = false
-    for (const link of links) {
-      if (edgeProvenance(link) !== 'EXACT_LSP') continue
-      if (endpoint(link.source) !== source || endpoint(link.target) !== target
-        || String(link.relation || '') !== relation) continue
-      if (exactLine != null && (!Number.isInteger(link.line) || link.line !== exactLine)) continue
-      if (exactCharacter != null
-        && (!Number.isInteger(link.character) || link.character !== exactCharacter)) continue
-      link.provenance = 'EXACT_LSP'
-      link.confidence = 'EXACT_LSP'
-      link.precisionProvider = String(exact.provider || 'typescript-language-server')
-      if (exact.typeOnly === true) link.typeOnly = true
-      else delete link.typeOnly
-      if (exact.compileOnly === true) link.compileOnly = true
-      else delete link.compileOnly
-      matched = true
-      break
-    }
-    if (!matched) links.push({
-      source,
-      target,
-      relation: relation || 'references',
-      provenance: 'EXACT_LSP',
-      confidence: 'EXACT_LSP',
-      precisionProvider: String(exact.provider || 'typescript-language-server'),
-      ...(exact.typeOnly === true ? {typeOnly: true} : {}),
-      ...(exact.compileOnly === true ? {compileOnly: true} : {}),
-      ...(exactLine != null ? {line: exactLine} : {}),
-      ...(exactCharacter != null ? {character: exactCharacter} : {}),
-      ...(Number.isInteger(exact.endLine) ? {endLine: exact.endLine} : {}),
-      ...(Number.isInteger(exact.endCharacter) ? {endCharacter: exact.endCharacter} : {}),
-    })
-  }
-  return {
-    ...graph,
-    links,
-    precisionOverlayV: PRECISION_OVERLAY_V,
-    precision: precisionSummary(overlay),
-    precisionNoReferenceSymbols: Array.isArray(overlay.noReferenceSymbols)
-      ? overlay.noReferenceSymbols.filter((id) => ids.has(String(id))).map(String) : [],
-    precisionReferenceEvidence: Array.isArray(overlay.referenceEvidence)
-      ? overlay.referenceEvidence.filter((evidence) => ids.has(endpoint(evidence.source))
-        && ids.has(endpoint(evidence.target))).map((evidence) => ({
-        source: endpoint(evidence.source),
-        target: endpoint(evidence.target),
-        ...(Number.isInteger(evidence.line) ? {line: evidence.line} : {}),
-        ...(Number.isInteger(evidence.character) ? {character: evidence.character} : {}),
-        classification: String(evidence.classification || 'unknown'),
-        provider: String(evidence.provider || 'typescript-language-server'),
-      })) : [],
-  }
-}
-
-export function writePrecisionOverlay(graphPath, overlay) {
-  atomicWriteFileSync(precisionPathForGraph(graphPath), JSON.stringify(overlay), 'utf8')
-  return overlay
-}
-
-const SAFE_INVALIDATION_REASON = 'repository changed while semantic precision was running'
-
-export function invalidatePrecisionOverlay(graphPath, graph, reason = SAFE_INVALIDATION_REASON) {
-  if (!graphPath || !graph) throw new Error('precision invalidation requires graphPath and graph')
-  const previous = readPrecisionOverlay(graphPath, graph)
-  const safeReason = typeof reason === 'string'
-    && reason.length > 0 && reason.length <= 160
-    && /^[A-Za-z0-9 _.,()-]+$/.test(reason) ? reason : SAFE_INVALIDATION_REASON
-  const engines = (Array.isArray(previous?.engines) && previous.engines.length
-    ? previous.engines
-    : [{
-      provider: 'typescript-language-server', version: null,
-      language: 'typescript/javascript', capability: 'textDocument/references',
-    }]).map((engine) => ({...engine, status: 'PARTIAL'}))
-  return writePrecisionOverlay(graphPath, baseOverlay(graph, 'PARTIAL', {
-    ...(previous?.request ? {request: previous.request} : {}),
-    reason: safeReason,
-    engines,
-    coverage: {
-      candidates: 0, selected: 0, queried: 0, references: 0,
-      unclassifiedReferences: 0, verifiedEdges: 0, truncated: true,
-    },
-    links: [],
-    referenceEvidence: [],
-    noReferenceSymbols: [],
-  }))
-}

package/src/precision/lsp-overlay/target-index.js

@@ -1,152 +0,0 @@
-import {realpathSync} from 'node:fs'
-import {isAbsolute, relative, resolve, sep} from 'node:path'
-import {fileURLToPath} from 'node:url'
-import {edgeProvenance} from '../../graph/edge-provenance.js'
-import {isStructuralRelation} from '../../graph/relations.js'
-import {isPathInside} from '../../repo-path.js'
-import {JS_TS_FILE, endpoint, norm} from './contract.js'
-
-const lineNumber = (value) => {
-  const match = /L(\d+)/.exec(String(value || ''))
-  return match ? Number(match[1]) : 0
-}
-
-export function repoFileFromLocation(repoRoot, location) {
-  if (location?.file) {
-    try {
-      const root = realpathSync.native(repoRoot)
-      const path = realpathSync.native(resolve(root, String(location.file)))
-      if (!isPathInside(root, path)) return null
-      const rel = relative(root, path)
-      return rel && !rel.startsWith(`..${sep}`) && !isAbsolute(rel) ? norm(rel) : null
-    } catch { return null }
-  }
-  const uri = typeof location === 'string' ? location : location?.uri || location?.targetUri
-  if (!uri || !String(uri).startsWith('file:')) return null
-  try {
-    const root = realpathSync.native(repoRoot)
-    const path = realpathSync.native(fileURLToPath(uri))
-    if (!isPathInside(root, path)) return null
-    const rel = relative(root, path)
-    if (!rel || rel === '..' || rel.startsWith(`..${sep}`) || isAbsolute(rel)) return null
-    return norm(rel)
-  } catch { return null }
-}
-
-export function locationStart(location) {
-  return location?.range?.start || location?.targetSelectionRange?.start
-    || location?.targetRange?.start || null
-}
-
-const comparePosition = (left, right) => left.line - right.line || left.character - right.character
-
-export function symbolIndex(graph) {
-  const files = new Set()
-  const byFile = new Map()
-  for (const node of graph.nodes || []) {
-    const id = String(node.id)
-    const file = norm(node.source_file || (id.includes('#') ? id.slice(0, id.indexOf('#')) : id))
-    if (!file) continue
-    if (!id.includes('#')) files.add(file)
-    else {
-      const start = lineNumber(node.source_location) || Number(node.selection_start?.line) + 1 || 0
-      const end = lineNumber(node.source_end) || start
-      if (!start) continue
-      const range = node.source_range
-      const hasRange = Number.isInteger(range?.start?.line)
-        && Number.isInteger(range?.start?.character)
-        && Number.isInteger(range?.end?.line)
-        && Number.isInteger(range?.end?.character)
-      const rows = byFile.get(file) || []
-      rows.push({id, start, end: Math.max(start, end), ...(hasRange ? {range} : {})})
-      byFile.set(file, rows)
-    }
-  }
-  for (const rows of byFile.values()) rows.sort((a, b) => {
-    if (a.range && b.range) {
-      return comparePosition(b.range.start, a.range.start)
-        || comparePosition(a.range.end, b.range.end)
-        || a.id.localeCompare(b.id)
-    }
-    return (a.end - a.start) - (b.end - b.start) || b.start - a.start || a.id.localeCompare(b.id)
-  })
-  return {files, byFile}
-}
-
-export function sourceAt(index, file, position) {
-  if (!Number.isInteger(position?.line) || !Number.isInteger(position?.character)) {
-    return index.files.has(file) ? file : null
-  }
-  const line = position.line + 1
-  const rows = (index.byFile.get(file) || []).filter((row) => row.range
-    ? comparePosition(row.range.start, position) <= 0 && comparePosition(position, row.range.end) < 0
-    : row.start < line && line < row.end)
-  if (rows.length) {
-    const first = rows[0]
-    const span = first.range ? null : first.end - first.start
-    const tied = rows.filter((row) => {
-      if (first.range || row.range) return Boolean(first.range && row.range
-        && comparePosition(first.range.start, row.range.start) === 0
-        && comparePosition(first.range.end, row.range.end) === 0)
-      return row.end - row.start === span
-    })
-    if (tied.length === 1) return tied[0].id
-  }
-  return index.files.has(file) ? file : null
-}
-
-export function eligibleTargets(graph, limit, requestedIds = null) {
-  const byId = new Map((graph.nodes || []).map((node) => [String(node.id), node]))
-  if (Array.isArray(requestedIds) && requestedIds.length) {
-    const ids = [...new Set(requestedIds.map(String))]
-    const eligible = ids.map((id) => byId.get(id))
-      .filter((node) => node?.selection_start && JS_TS_FILE.test(String(node.source_file || '')))
-    // total counts only eligible targets so coverage fractions stay honest when ids were dropped.
-    return {
-      targets: eligible.slice(0, limit),
-      total: eligible.length,
-      droppedRequested: ids.length - eligible.length,
-      orphanIds: new Set(),
-    }
-  }
-  const ranked = new Map()
-  const inbound = new Set()
-  for (const link of graph.links || []) {
-    const relation = String(link.relation || '')
-    if (!isStructuralRelation(relation)) inbound.add(endpoint(link.target))
-    if (isStructuralRelation(relation)
-      || !['calls', 'references', 'inherits', 'implements'].includes(relation)) continue
-    if (edgeProvenance(link) === 'EXACT_LSP') continue
-    const target = endpoint(link.target)
-    const node = byId.get(target)
-    if (!node?.selection_start || !JS_TS_FILE.test(String(node.source_file || ''))) continue
-    const score = (relation === 'calls' ? 30 : relation === 'inherits' || relation === 'implements' ? 20 : 10)
-      + (edgeProvenance(link) === 'INFERRED' ? 8 : 0)
-    ranked.set(target, Math.max(ranked.get(target) || 0, score))
-  }
-  const orphans = new Set()
-  for (const node of byId.values()) {
-    const id = String(node.id)
-    const visibility = String(node.visibility || '').toLowerCase()
-    if (!node.selection_start || !JS_TS_FILE.test(String(node.source_file || '')) || inbound.has(id)) continue
-    if (node.exported === true || visibility === 'public' || visibility === 'protected') continue
-    if (!/\(\)$/.test(String(node.label || ''))
-      && !['function', 'method', 'constructor'].includes(String(node.symbol_kind || '').toLowerCase())) continue
-    if (!ranked.has(id)) { ranked.set(id, 4); orphans.add(id) }
-  }
-  const all = [...ranked.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
-  const positive = all.filter(([id]) => !orphans.has(id))
-  const orphan = all.filter(([id]) => orphans.has(id))
-  const reserve = orphan.length ? Math.min(8, Math.ceil(limit / 4), limit) : 0
-  const selected = positive.slice(0, Math.max(0, limit - reserve))
-  selected.push(...orphan.slice(0, reserve))
-  if (selected.length < limit) {
-    const selectedIds = new Set(selected.map(([id]) => id))
-    selected.push(...all.filter(([id]) => !selectedIds.has(id)).slice(0, limit - selected.length))
-  }
-  return {
-    targets: selected.map(([id]) => byId.get(id)),
-    total: all.length,
-    orphanIds: new Set(orphan.map(([id]) => id)),
-  }
-}

package/src/precision/lsp-overlay/target-query.js

@@ -1,55 +0,0 @@
-import {isStructuralRelation} from '../../graph/relations.js'
-import {JS_TS_FILE, endpoint, norm} from './contract.js'
-import {
-  ensureBudget,
-  ensureFullUniverse,
-  ensureOpen,
-  requestReferences,
-} from './source-session.js'
-
-function supportFilesFor(session, target, relPath) {
-  const supportFiles = []
-  for (const link of session.graph.links || []) {
-    if (endpoint(link.target) !== String(target.id) || isStructuralRelation(link.relation)) continue
-    const sourceId = endpoint(link.source)
-    const sourceFile = norm(session.nodesById.get(sourceId)?.source_file
-      || (sourceId.includes('#') ? sourceId.slice(0, sourceId.indexOf('#')) : sourceId))
-    if (sourceFile && JS_TS_FILE.test(sourceFile)
-      && sourceFile !== relPath && !supportFiles.includes(sourceFile)) supportFiles.push(sourceFile)
-    if (supportFiles.length >= 12) break
-  }
-  return supportFiles
-}
-
-export async function queryPrecisionTarget(session, target) {
-  const relPath = norm(target.source_file)
-  await ensureOpen(session, relPath)
-  for (const file of supportFilesFor(session, target, relPath)) await ensureOpen(session, file)
-  if (session.universe.complete
-    && session.universe.files.every((file) => session.opened.has(file))) {
-    session.fullUniverseOpened = true
-  }
-  let locations = await requestReferences(session, relPath, target.selection_start)
-  if (!Array.isArray(locations)) throw new Error('language server returned an invalid references result')
-  session.queried++
-  if (locations.length !== 0) return locations
-  ensureBudget(session)
-  const configRel = session.semanticInputs.fileConfigs?.[relPath]
-  const project = configRel ? session.semanticInputs.projects?.[configRel] : null
-  const configuredFiles = [...new Set((project?.projectFiles || [])
-    .map(norm).filter((file) => JS_TS_FILE.test(file)))].sort()
-  const projectFiles = new Set(configuredFiles)
-  const exactlyCoversUniverse = session.universe.complete
-    && configuredFiles.length === session.universe.files.length
-    && session.universe.files.every((file) => projectFiles.has(file))
-  ensureBudget(session)
-  if (configRel && projectFiles.has(relPath) && exactlyCoversUniverse) {
-    const alreadyComplete = session.fullUniverseOpened
-    if (alreadyComplete || await ensureFullUniverse(session)) {
-      if (!alreadyComplete) locations = await requestReferences(session, relPath, target.selection_start)
-      if (!Array.isArray(locations)) throw new Error('language server returned an invalid references result')
-      if (locations.length === 0) session.noReferenceSymbols.push(String(target.id))
-    }
-  }
-  return locations
-}

package/src/precision/lsp-overlay.js

@@ -1,11 +0,0 @@
-export {PRECISION_FILE, PRECISION_OVERLAY_V, precisionOverlayMatches} from './lsp-overlay/contract.js'
-export {
-  invalidatePrecisionOverlay,
-  mergePrecisionOverlay,
-  precisionPathForGraph,
-  precisionSummary,
-  readPrecisionOverlay,
-  writePrecisionOverlay,
-} from './lsp-overlay/store.js'
-export {precisionSemanticInputs, precisionSemanticInputsMatch} from './lsp-overlay/semantic-inputs.js'
-export {buildLspPrecisionOverlay} from './lsp-overlay/build.js'

package/src/precision/symbol-query.js

@@ -1,224 +0,0 @@
-import {existsSync, readFileSync, statSync} from 'node:fs'
-import {dirname, resolve} from 'node:path'
-import {boundedInteger} from '../bounds.js'
-import {atomicWriteFileSync, withFileLock} from '../graph/file-lock.js'
-import {
-    buildLspPrecisionOverlay,
-    precisionOverlayMatches,
-    precisionSemanticInputsMatch,
-} from './lsp-overlay.js'
-import {createPathClassifier, hasPathClass} from '../path-classification.js'
-
-const SYMBOL_PRECISION_CACHE_V = 1
-const SYMBOL_PRECISION_CACHE_FILE = 'precision-symbols.json'
-
-const MAX_CACHE_ENTRIES = 32
-const MAX_CACHE_BYTES = 8 * 1024 * 1024
-const MAX_CACHE_READ_BYTES = 16 * 1024 * 1024
-const inFlight = new Map()
-
-export function symbolPrecisionCachePath(graphPath) {
-    return resolve(dirname(graphPath), SYMBOL_PRECISION_CACHE_FILE)
-}
-
-function loadRawGraph(graphPath) {
-    const graph = JSON.parse(readFileSync(graphPath, 'utf8'))
-    if (!graph || !Array.isArray(graph.nodes) || !Array.isArray(graph.links)) {
-        throw new Error('the active graph is not a valid Weavatrix graph')
-    }
-    return graph
-}
-
-function emptyCache() {
-    return {symbolPrecisionCacheV: SYMBOL_PRECISION_CACHE_V, entries: []}
-}
-
-function readCache(path) {
-    if (!existsSync(path)) return emptyCache()
-    try {
-        if (statSync(path).size > MAX_CACHE_READ_BYTES) return emptyCache()
-        const value = JSON.parse(readFileSync(path, 'utf8'))
-        if (Number(value?.symbolPrecisionCacheV) !== SYMBOL_PRECISION_CACHE_V || !Array.isArray(value.entries)) return emptyCache()
-        return {symbolPrecisionCacheV: SYMBOL_PRECISION_CACHE_V, entries: value.entries.slice(0, MAX_CACHE_ENTRIES)}
-    } catch {
-        return emptyCache()
-    }
-}
-
-function writeBoundedCache(path, entries) {
-    const kept = entries
-        .filter((entry) => entry && typeof entry === 'object')
-        .sort((left, right) => Number(right.usedAt) - Number(left.usedAt))
-        .slice(0, MAX_CACHE_ENTRIES)
-    let body
-    do {
-        body = JSON.stringify({symbolPrecisionCacheV: SYMBOL_PRECISION_CACHE_V, entries: kept})
-        if (Buffer.byteLength(body) <= MAX_CACHE_BYTES || !kept.length) break
-        kept.pop()
-    } while (true)
-    atomicWriteFileSync(path, body, 'utf8')
-}
-
-function cacheMatch(entry, {targetId, graph, repoRoot, request}) {
-    if (String(entry?.targetId || '') !== targetId || !entry.overlay) return false
-    if (!precisionOverlayMatches(entry.overlay, graph, {request})) return false
-    return precisionSemanticInputsMatch(entry.overlay, repoRoot, graph)
-}
-
-async function storeEntry(path, entry) {
-    await withFileLock(`${path}.lock`, async () => {
-        const current = readCache(path)
-        const entries = current.entries.filter((item) => String(item?.targetId || '') !== entry.targetId)
-        entries.unshift(entry)
-        writeBoundedCache(path, entries)
-    })
-}
-
-function cacheable(overlay) {
-    // NONE is stable for the fingerprint, but only COMPLETE ever proves absence (see reader below).
-    if (overlay?.state === 'COMPLETE' || overlay?.state === 'NONE') return true
-    return overlay?.state === 'PARTIAL'
-        && overlay?.reason === 'semantic precision stopped at a configured safety limit'
-}
-
-// Point-query results intentionally live outside the broad precision overlay. Health tools still
-// need to consume revision-bound positive evidence: once an exact query found a reference, the
-// same symbol must not remain in a dead-code queue. This reader is synchronous and fail-closed;
-// stale, malformed, incomplete no-reference, or semantically changed entries contribute nothing.
-export function readCachedSymbolPrecisionEvidence({repoRoot, graphPath, graph} = {}) {
-    const empty = {referenceSymbols: [], productionReferenceSymbols: [], testReferenceSymbols: [], noReferenceSymbols: []}
-    if (!repoRoot || !graphPath || !graph) return empty
-    const precisionGraph = graph.graphPrecisionMode === 'off' ? {...graph, graphPrecisionMode: 'lsp'} : graph
-    const nodesById = new Map((precisionGraph.nodes || []).map((node) => [String(node.id), node]))
-    const classifier = createPathClassifier(repoRoot)
-    const referenced = new Set()
-    const production = new Set()
-    const tests = new Set()
-    const noReference = new Set()
-    const semanticMatches = new Map()
-    for (const entry of readCache(symbolPrecisionCachePath(graphPath)).entries) {
-        const overlay = entry?.overlay
-        if (!overlay || !precisionOverlayMatches(overlay, precisionGraph, {request: overlay.request})) continue
-        const fingerprint = String(overlay.semanticInputFingerprint || '')
-        if (!semanticMatches.has(fingerprint)) semanticMatches.set(
-            fingerprint,
-            precisionSemanticInputsMatch(overlay, repoRoot, precisionGraph),
-        )
-        if (!semanticMatches.get(fingerprint)) continue
-        const targetId = String(entry.targetId || '')
-        if (!nodesById.has(targetId)) continue
-        const locations = Array.isArray(overlay.locations)
-            ? overlay.locations.filter((location) => String(location?.target || '') === targetId)
-            : []
-        if (locations.length) {
-            referenced.add(targetId)
-            for (const location of locations) {
-                const file = String(location?.file || nodesById.get(String(location?.source || ''))?.source_file || '')
-                if (!file) continue
-                const info = classifier.explain(file, {content: ''})
-                if (hasPathClass(info, 'test', 'e2e')) tests.add(targetId)
-                else production.add(targetId)
-            }
-        }
-        if (overlay.state === 'COMPLETE' && Array.isArray(overlay.noReferenceSymbols)
-            && overlay.noReferenceSymbols.some((id) => String(id) === targetId)) noReference.add(targetId)
-    }
-    return {
-        referenceSymbols: [...referenced],
-        productionReferenceSymbols: [...production],
-        testReferenceSymbols: [...tests],
-        noReferenceSymbols: [...noReference],
-    }
-}
-
-export async function querySymbolPrecision({
-    repoRoot,
-    graphPath,
-    targetId,
-    maxReferences = 1_000,
-    timeoutMs = 30_000,
-    clientFactory,
-} = {}) {
-    if (!repoRoot || !graphPath || !targetId) throw new Error('symbol precision requires repoRoot, graphPath, and targetId')
-    const boundedReferences = boundedInteger(maxReferences, 1_000, 1, 5_000)
-    const boundedTimeout = boundedInteger(timeoutMs, 30_000, 1_000, 60_000)
-    const request = {maxSymbols: 1, maxReferences: boundedReferences, maxLinks: boundedReferences}
-    const rawGraph = loadRawGraph(graphPath)
-    const graph = rawGraph.graphPrecisionMode === 'off' ? {...rawGraph, graphPrecisionMode: 'lsp'} : rawGraph
-    const target = graph.nodes.find((node) => String(node?.id || '') === String(targetId))
-    if (!target) throw new Error('the selected symbol is not present in the active raw graph')
-    if (!target.selection_start || !/\.(?:[cm]?[jt]sx?)$/i.test(String(target.source_file || ''))) {
-        throw new Error('exact symbol precision currently supports JavaScript and TypeScript symbols with source selections')
-    }
-
-    const id = String(targetId)
-    const cachePath = symbolPrecisionCachePath(graphPath)
-    const startedAt = Date.now()
-    const cached = readCache(cachePath).entries.find((entry) => cacheMatch(entry, {targetId: id, graph, repoRoot, request}))
-    if (cached) return {overlay: cached.overlay, cached: true, elapsedMs: Date.now() - startedAt, cachePath}
-
-    const flightKey = `${graphPath}\0${graph.graphRevision || ''}\0${id}\0${boundedReferences}`
-    if (inFlight.has(flightKey)) return inFlight.get(flightKey)
-    const operation = (async () => {
-        const overlay = await buildLspPrecisionOverlay({
-            repoRoot,
-            graph,
-            mode: 'lsp',
-            maxSymbols: 1,
-            maxReferences: boundedReferences,
-            maxLinks: boundedReferences,
-            timeoutMs: boundedTimeout,
-            targetIds: [id],
-            clientFactory,
-        })
-        if (cacheable(overlay)) {
-            await storeEntry(cachePath, {targetId: id, usedAt: Date.now(), overlay})
-        }
-        return {overlay, cached: false, elapsedMs: Date.now() - startedAt, cachePath}
-    })()
-    inFlight.set(flightKey, operation)
-    try {
-        return await operation
-    } finally {
-        inFlight.delete(flightKey)
-    }
-}
-
-export async function querySymbolsPrecision({
-    repoRoot,
-    graphPath,
-    targetIds,
-    maxReferences = 5_000,
-    timeoutMs = 45_000,
-    clientFactory,
-} = {}) {
-    if (!repoRoot || !graphPath || !Array.isArray(targetIds) || !targetIds.length) {
-        throw new Error('batch symbol precision requires repoRoot, graphPath, and targetIds')
-    }
-    const ids = [...new Set(targetIds.map(String).filter(Boolean))].slice(0, 16)
-    const boundedReferences = boundedInteger(maxReferences, 5_000, 1, 16_384)
-    const boundedTimeout = boundedInteger(timeoutMs, 45_000, 1_000, 60_000)
-    const rawGraph = loadRawGraph(graphPath)
-    const graph = rawGraph.graphPrecisionMode === 'off' ? {...rawGraph, graphPrecisionMode: 'lsp'} : rawGraph
-    const nodes = new Map((graph.nodes || []).map((node) => [String(node?.id || ''), node]))
-    for (const id of ids) {
-        const target = nodes.get(id)
-        if (!target) throw new Error(`precision target is absent from the active graph: ${id}`)
-        if (!target.selection_start || !/\.(?:[cm]?[jt]sx?)$/i.test(String(target.source_file || ''))) {
-            throw new Error(`exact batch precision does not support target: ${id}`)
-        }
-    }
-    const startedAt = Date.now()
-    const overlay = await buildLspPrecisionOverlay({
-        repoRoot,
-        graph,
-        mode: 'lsp',
-        maxSymbols: ids.length,
-        maxReferences: boundedReferences,
-        maxLinks: boundedReferences,
-        timeoutMs: boundedTimeout,
-        targetIds: ids,
-        clientFactory,
-    })
-    return {overlay, targetIds: ids, elapsedMs: Date.now() - startedAt}
-}

package/src/precision/typescript-lsp-provider.js

@@ -1,12 +0,0 @@
-export {
-    TYPESCRIPT_LSP_CAPABILITY_CONTRACT,
-    typeScriptLanguageId,
-    typeScriptLspAvailability,
-    typeScriptLspContract,
-} from './typescript-provider/discovery.js'
-export {classifyTypeScriptReferenceUsage} from './typescript-provider/reference-usage.js'
-export {
-    typeScriptConfiguredProjectMembership,
-    typeScriptProjectSafety,
-} from './typescript-provider/project-safety.js'
-export {createTypeScriptLspClient} from './typescript-provider/client.js'