@mrclrchtr/supi-lsp 11.3.0 → 11.4.0

package/README.md

@@ -100,7 +100,7 @@ For example, select a compiler installed as `my-ts6` without changing the TLS co
 - `code_health` and `/supi-ci-status` show the `native` or `tsserver` backend and resolved compiler version when known, separately from wrapper version. Manual/legacy-fallback launches have no inferred compiler identity. Missing versions remain unknown. Selection failures identify the package/root and a corrective action.
 - Topmost-root collapsing remains unchanged. Mixed nested backends, Windows live qualification, dependency watchers, performance benchmarking, and full TLS/native feature parity are outside this change. Existing legacy TLS support is not deliberately removed.
 
-Focused qualification pins native TypeScript **7.0.2**, TLS **6.0.2**, ordinary TypeScript **6.0.3**, and `@typescript/typescript6` **6.0.2** backed by `@typescript/old` → TypeScript **6.0.3**. The wrapper's dependency range does not guarantee that compiler version; the lockfile and [prerequisite pins](../../scripts/language-baseline/pins.json) fix these combinations. SuPi retains TS6 for its compiler-API dependency and legacy-server tests. Workspace typechecking and declaration builds use the native TS7 launcher directly to avoid ambiguity between the installed `tsc` binaries.
+Focused qualification uses the native TypeScript 7 alias (`@typescript/native`), TLS, ordinary TypeScript 6, and `@typescript/typescript6` backed by `@typescript/old` → TypeScript 6. Exact versions come from the root `package.json` and lockfile; the wrapper's dependency range does not fix its compiler version, so the lockfile does. SuPi retains TS6 for its compiler-API dependency and legacy-server tests. Workspace typechecking and declaration builds use the native TS7 launcher directly to avoid ambiguity between the installed `tsc` binaries.
 
 The required [Linux/macOS CI matrix](../../.github/workflows/ci.yml) keeps [selection/layout tests](__tests__/unit/typescript-launch.test.ts), [real native lifecycle tests](__tests__/integration/workspace-runtime.integration.typescript-native.test.ts), and [wrapper lifecycle tests](__tests__/integration/workspace-runtime.integration.typescript-launch.test.ts) separate from the [public TS/JS semantic matrix](../supi-code-intelligence/__tests__/acceptance/language-baseline-harness.ts). Required missing/unavailable behavior fails rather than skips. The matrix covers hover, definitions, references, meaningful implementations, document/workspace symbols, confirmed error → clean diagnostics, refresh, cross-file invalidation, Unicode-safe rename plan/apply and stale-plan rejection, and precise organize-imports. The TypeScript public matrix also checks unused-import removal, unchanged source during planning, stale-plan rejection, and preservation of unrelated text; native support is imports-only. Native TSX/JSX and module suffixes receive routing/synchronization checks rather than duplicate matrices. Existing stale-result and edit-safety suites remain in place.
 

package/node_modules/@mrclrchtr/supi-code-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-code-runtime",
-  "version": "11.3.0",
+  "version": "11.4.0",
   "description": "Shared workspace context and capability contracts for code intelligence",
   "license": "MIT",
   "repository": {

package/node_modules/@mrclrchtr/supi-code-runtime/src/api.ts

@@ -14,6 +14,7 @@ export type {
   StructuralProvider,
   StructuralResult,
 } from "./capability/types.ts";
+export { childDeclarationLevel } from "./declaration-level.ts";
 export type {
   CFamilyExtension,
   CFamilyFileAssociationResolver,
@@ -50,7 +51,7 @@ export type {
   CodeResult,
   CodeSymbol,
   ConfidenceMode,
-  DeclarationNesting,
+  DeclarationLevel,
   DisambiguationCandidate,
   DocumentCodeSymbol,
   DocumentEditPrecondition,

package/node_modules/@mrclrchtr/supi-code-runtime/src/declaration-level.ts

@@ -0,0 +1,34 @@
+import type { DeclarationLevel } from "./types.ts";
+
+/** Declarations whose body holds statements, so nested declarations are local to it. */
+const FUNCTION_LIKE_KINDS = new Set(["function", "method", "constructor"]);
+/** Bindings whose value may be a function (locals) or an object literal (members). */
+const VALUE_BINDING_KINDS = new Set(["variable", "constant", "property", "field"]);
+/** Kinds that name an entry of an object, type, or enum rather than a statement-level binding. */
+const MEMBER_ENTRY_KINDS = new Set(["property", "field", "method", "enummember", "key", "event"]);
+
+/**
+ * Level of a declaration reported directly inside `parent`.
+ *
+ * Inside a local declaration everything stays local. A function, method, or
+ * constructor makes its nested declarations local. A variable, constant,
+ * property, or field holds either a function body (nested bindings are local)
+ * or an object literal (nested properties and methods are members). Every
+ * other container — class, interface, enum, struct, namespace, module, or a
+ * document section — makes its nested declarations members.
+ *
+ * Kinds compare case-insensitively, so LSP SymbolKind names and Tree-sitter
+ * outline kinds share one rule.
+ */
+export function childDeclarationLevel(
+  parent: { readonly kind: string | null; readonly level: DeclarationLevel },
+  childKind: string | null,
+): Exclude<DeclarationLevel, "top-level" | "unknown"> {
+  if (parent.level === "local") return "local";
+  const parentKind = parent.kind?.toLowerCase() ?? "";
+  if (FUNCTION_LIKE_KINDS.has(parentKind)) return "local";
+  if (VALUE_BINDING_KINDS.has(parentKind)) {
+    return MEMBER_ENTRY_KINDS.has(childKind?.toLowerCase() ?? "") ? "member" : "local";
+  }
+  return "member";
+}

package/node_modules/@mrclrchtr/supi-code-runtime/src/types.ts

@@ -34,8 +34,16 @@ export interface SymbolAnchor {
   character: number;
 }
 
-/** Provider-backed nesting evidence for a declaration reported within one document. */
-export type DeclarationNesting = "top-level" | "nested" | "unknown";
+/**
+ * Where a declaration sits within its file, as reported by a provider.
+ *
+ * - `top-level`: directly in the file, not inside another declaration.
+ * - `member`: directly inside a class, interface, enum, struct, namespace,
+ *   module, or object literal (methods, fields, properties, enum members).
+ * - `local`: inside the body of a function, method, or constructor.
+ * - `unknown`: the provider reported a flat symbol list without hierarchy.
+ */
+export type DeclarationLevel = "top-level" | "member" | "local" | "unknown";
 
 /**
  * A discovered symbol / declaration.
@@ -54,7 +62,7 @@ export interface CodeSymbol {
   file: string;
   declarationAnchor: SymbolAnchor;
   nameAnchor?: SymbolAnchor;
-  /** Named symbolic container when reported; absence does not prove top-level nesting. */
+  /** Named enclosing declaration when reported; absence does not prove a top-level declaration. */
   container?: string | null;
 }
 
@@ -63,10 +71,10 @@ export interface CodeSymbol {
  *
  * `unknown` means the provider returned a flat observation without an actual
  * hierarchy. A reported container name remains metadata and does not promote
- * a flat observation to known nesting.
+ * a flat observation to a known level.
  */
 export interface DocumentCodeSymbol extends CodeSymbol {
-  nesting: DeclarationNesting;
+  level: DeclarationLevel;
 }
 
 // ── Result types ───────────────────────────────────────────────────────

package/node_modules/@mrclrchtr/supi-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-core",
-  "version": "11.3.0",
+  "version": "11.4.0",
   "description": "Shared settings, configuration, reporting, and session infrastructure",
   "license": "MIT",
   "repository": {

package/node_modules/semver/classes/range.js

@@ -119,7 +119,7 @@ class Range {
     debug('hyphen replace', range)
 
     // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
-    range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace)
+    range = trimComparatorWhitespace(range)
     debug('comparator trim', range)
 
     // `~ 1.2.3` => `~1.2.3`
@@ -224,11 +224,11 @@ const parseOptions = require('../internal/parse-options')
 const Comparator = require('./comparator')
 const debug = require('../internal/debug')
 const SemVer = require('./semver')
+const trimComparatorWhitespace = require('../internal/trim-comparator-whitespace')
 const {
   safeRe: re,
   src,
   t,
-  comparatorTrimReplace,
   tildeTrimReplace,
   caretTrimReplace,
 } = require('../internal/re')

package/node_modules/semver/internal/constants.js

@@ -15,6 +15,35 @@ const MAX_SAFE_COMPONENT_LENGTH = 16
 // the shortest version with a build 0.0.0+BUILD.
 const MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6
 
+// ECMAScript whitespace and line terminators matched by \s.
+const WHITESPACE_CHARACTERS = [
+  '\t',
+  '\n',
+  '\v',
+  '\f',
+  '\r',
+  ' ',
+  '\u00a0',
+  '\u1680',
+  '\u2000',
+  '\u2001',
+  '\u2002',
+  '\u2003',
+  '\u2004',
+  '\u2005',
+  '\u2006',
+  '\u2007',
+  '\u2008',
+  '\u2009',
+  '\u200a',
+  '\u2028',
+  '\u2029',
+  '\u202f',
+  '\u205f',
+  '\u3000',
+  '\ufeff',
+]
+
 const RELEASE_TYPES = [
   'major',
   'premajor',
@@ -30,6 +59,7 @@ module.exports = {
   MAX_SAFE_COMPONENT_LENGTH,
   MAX_SAFE_BUILD_LENGTH,
   MAX_SAFE_INTEGER,
+  WHITESPACE_CHARACTERS,
   RELEASE_TYPES,
   SEMVER_SPEC_VERSION,
   FLAG_INCLUDE_PRERELEASE: 0b001,

package/node_modules/semver/internal/trim-comparator-whitespace.js

@@ -0,0 +1,438 @@
+// @ts-check
+'use strict'
+
+// Reproduce safeRe[COMPARATORTRIM] replacement boundaries, not version
+// validation. Each end-index finder returns an exclusive end, or its start
+// on no match.
+// Positions count from zero. An end of 3 means characters 0, 1, and 2 were read;
+// range.slice(start, end) gives the matched text, not a converted number.
+const {
+  MAX_LENGTH,
+  MAX_SAFE_BUILD_LENGTH,
+  WHITESPACE_CHARACTERS,
+} = require('./constants')
+
+/**
+ * Remembers the last two rows of digits so their characters need not be reread.
+ * Positions start at -1 until a row has been found.
+ *
+ * @typedef {object} DigitRunCache
+ * @property {number} start The first character of the most recently found row.
+ * @property {number} end The position after that row's last character.
+ * @property {number} previousStart The first character of the previous row.
+ * @property {number} previousEnd The position after the previous row.
+ */
+
+// One entry per UTF-16 code unit keeps membership checks constant-time.
+const whitespace = new Uint8Array(0x10000)
+for (const char of WHITESPACE_CHARACTERS) {
+  whitespace[char.charCodeAt(0)] = 1
+}
+
+/**
+ * Checks whether a character is whitespace, like a space, tab, or newline.
+ * Looking past the end of the string returns false.
+ *
+ * @param {string|undefined} char One character, or undefined past the string's end.
+ * @returns {boolean} Whether the character is whitespace.
+ * @example isWhitespace(' ') // true
+ * @example isWhitespace('1') // false
+ */
+const isWhitespace = char =>
+  char !== undefined && whitespace[char.charCodeAt(0)] === 1
+
+/**
+ * Checks for v, =, or whitespace before the version number.
+ * These are historical version prefixes, not range operators:
+ * < and > are handled separately, as are tilde and caret ranges.
+ *
+ * @param {string|undefined} char One character to check.
+ * @returns {boolean} Whether the character can belong to a version prefix.
+ * @example isVersionPrefix('=') // true
+ * @example isVersionPrefix('>') // false
+ */
+const isVersionPrefix = char =>
+  char === 'v' ||
+  char === '=' ||
+  isWhitespace(char)
+
+/**
+ * Checks whether a character is one of the digits 0 through 9.
+ *
+ * @param {string|undefined} char One character to check.
+ * @returns {boolean} Whether the character is an ASCII digit.
+ * @example isDigit('7') // true
+ * @example isDigit('.') // false
+ */
+const isDigit = char => char !== undefined && char >= '0' && char <= '9'
+
+/**
+ * Checks whether a character is an English letter, uppercase or lowercase.
+ *
+ * @param {string|undefined} char One character to check.
+ * @returns {boolean} Whether the character is an ASCII letter.
+ * @example isLetter('b') // true
+ * @example isLetter('7') // false
+ */
+const isLetter = char =>
+  char !== undefined && (
+    (char >= 'a' && char <= 'z') ||
+    (char >= 'A' && char <= 'Z')
+  )
+
+/**
+ * Checks for a letter, digit, or hyphen: the characters allowed inside
+ * prerelease and build names such as beta-1.
+ *
+ * @param {string|undefined} char One character to check.
+ * @returns {boolean} Whether the character can be part of an identifier.
+ * @example isIdentifierCharacter('-') // true
+ * @example isIdentifierCharacter('.') // false; dots separate identifiers
+ */
+const isIdentifierCharacter = char => isDigit(char) || isLetter(char) || char === '-'
+
+/**
+ * Checks whether a version component can begin here: with a digit or
+ * a wildcard such as x, X, or *.
+ *
+ * @param {string|undefined} char One character to check.
+ * @returns {boolean} Whether a number or wildcard can start with this character.
+ * @example isVersionStart('x') // true
+ * @example isVersionStart('v') // false; v belongs to the prefix
+ */
+const isVersionStart = char =>
+  isDigit(char) ||
+  char === 'x' ||
+  char === 'X' ||
+  char === '*'
+
+/**
+ * Finds the end of a row of digits, but returns no more than limit digits.
+ * Remembers the last two rows so looking at them again does not reread them.
+ *
+ * @param {string} range The text to read; it is not changed.
+ * @param {number} start The position of the first character to check.
+ * @param {number} limit The most digit characters the returned match can include.
+ * @param {DigitRunCache} digitRuns Shared cache of digit-run positions, updated in place.
+ * @returns {number} The position after the matched digits, or start if none match.
+ * @example findDigitsEndIndex('123abc', 0, 10, digitRuns) // 3, pointing at a
+ * @example findDigitsEndIndex('123abc', 0, 2, digitRuns) // 2, pointing at the unread 3
+ */
+const findDigitsEndIndex = (range, start, limit, digitRuns) => {
+  if (!isDigit(range[start])) {
+    return start
+  }
+  if (start >= digitRuns.start && start < digitRuns.end) {
+    return Math.min(start + limit, digitRuns.end)
+  }
+  if (start >= digitRuns.previousStart && start < digitRuns.previousEnd) {
+    return Math.min(start + limit, digitRuns.previousEnd)
+  }
+  let end = start + 1
+  while (isDigit(range[end])) {
+    end++
+  }
+  // A failed full version can rewind from its second run to its first.
+  digitRuns.previousStart = digitRuns.start
+  digitRuns.previousEnd = digitRuns.end
+  digitRuns.start = start
+  digitRuns.end = end
+  return Math.min(start + limit, end)
+}
+
+/**
+ * Reads a number using the old regex's length and leading-zero rules.
+ * Strict mode reads just the first zero in 012; loose mode can read all three.
+ *
+ * @param {string} range The text to read; it is not changed.
+ * @param {number} start The position where the number should begin.
+ * @param {boolean} loose Whether to allow leading zeros.
+ * @param {DigitRunCache} digitRuns Shared digit-run cache, updated as needed.
+ * @returns {number} The position after the matched digits, not their numeric value.
+ * @example findVersionNumberEndIndex('012', 0, false, digitRuns) // 1
+ * @example findVersionNumberEndIndex('012', 0, true, digitRuns) // 3
+ */
+const findVersionNumberEndIndex = (range, start, loose, digitRuns) => {
+  if (!loose && range[start] === '0') {
+    return start + 1
+  }
+  // Strict syntax allows an initial nonzero digit plus MAX_LENGTH digits.
+  return findDigitsEndIndex(range, start, loose ? MAX_LENGTH : MAX_LENGTH + 1, digitRuns)
+}
+
+/**
+ * Reads one piece of a prerelease name, such as beta or 1 in beta.1.
+ * Tries the letter-or-hyphen form first, then the number-only form.
+ *
+ * @param {string} range The text to read; it is not changed.
+ * @param {number} start The position where the identifier should begin.
+ * @param {boolean} loose Whether numeric identifiers may have leading zeros.
+ * @param {DigitRunCache} digitRuns Shared digit-run cache, updated as needed.
+ * @returns {number} The position after the identifier, or start if none matches.
+ * @example findPrereleaseIdentifierEndIndex('beta.1', 0, false, digitRuns) // 4, at the dot
+ * @example findPrereleaseIdentifierEndIndex('001beta', 0, false, digitRuns) // 7
+ */
+const findPrereleaseIdentifierEndIndex = (range, start, loose, digitRuns) => {
+  const digitsEnd = findDigitsEndIndex(range, start, MAX_LENGTH, digitRuns)
+  // The legacy regex tries a nonnumeric identifier before a numeric one.
+  if (isLetter(range[digitsEnd]) || range[digitsEnd] === '-') {
+    let end = digitsEnd + 1
+    const limit = end + MAX_SAFE_BUILD_LENGTH
+    while (end < limit && isIdentifierCharacter(range[end])) {
+      end++
+    }
+    return end
+  }
+  return findVersionNumberEndIndex(range, start, loose, digitRuns)
+}
+
+/**
+ * Reads a prerelease suffix such as -beta.1, one dot-separated piece at a time.
+ * Loose mode also allows the name without its opening hyphen.
+ *
+ * @param {string} range The text to read; it is not changed.
+ * @param {number} start The position where the suffix should begin, including -.
+ * @param {boolean} loose Whether the opening hyphen is optional and zeros allowed.
+ * @param {DigitRunCache} digitRuns Shared digit-run cache, updated as needed.
+ * @returns {number} The position after the matched suffix, or start if absent.
+ * @example findPrereleaseEndIndex('-beta.1+sha', 0, false, digitRuns) // 7, at the plus
+ * @example findPrereleaseEndIndex('beta', 0, false, digitRuns) // 0; no opening hyphen
+ */
+const findPrereleaseEndIndex = (range, start, loose, digitRuns) => {
+  const hyphen = range[start] === '-'
+  if (!loose && !hyphen) {
+    return start
+  }
+  const identifierStart = start + (hyphen ? 1 : 0)
+  let end = findPrereleaseIdentifierEndIndex(range, identifierStart, loose, digitRuns)
+  if (end === identifierStart) {
+    if (!loose || !hyphen) {
+      return start
+    }
+    // In loose syntax, a lone hyphen can itself be the identifier.
+    end = findPrereleaseIdentifierEndIndex(range, start, loose, digitRuns)
+  }
+  while (range[end] === '.') {
+    const next = findPrereleaseIdentifierEndIndex(range, end + 1, loose, digitRuns)
+    if (next === end + 1) {
+      break
+    }
+    end = next
+  }
+  return end
+}
+
+/**
+ * Reads one build-name piece, such as sha or 123 in +sha.123.
+ * Stops at a disallowed character or the old regex's length limit.
+ *
+ * @param {string} range The text to read; it is not changed.
+ * @param {number} start The position where the identifier should begin.
+ * @returns {number} The position after the identifier, or start if none matches.
+ * @example findBuildIdentifierEndIndex('sha.123', 0) // 3, at the dot
+ * @example findBuildIdentifierEndIndex('001', 0) // 3; leading zeros are allowed
+ */
+const findBuildIdentifierEndIndex = (range, start) => {
+  let end = start
+  while (end - start < MAX_SAFE_BUILD_LENGTH && isIdentifierCharacter(range[end])) {
+    end++
+  }
+  return end
+}
+
+/**
+ * Reads optional build metadata such as +sha.123.
+ * Leaves the position unchanged if there is no plus sign followed by a name.
+ *
+ * @param {string} range The text to read; it is not changed.
+ * @param {number} start The position where the opening + should be.
+ * @returns {number} The position after the matched metadata, or start if absent.
+ * @example findBuildEndIndex('+sha.123 <2', 0) // 8, at the space
+ * @example findBuildEndIndex('+', 0) // 0; a plus sign alone is not a match
+ */
+const findBuildEndIndex = (range, start) => {
+  if (range[start] !== '+') {
+    return start
+  }
+  let end = findBuildIdentifierEndIndex(range, start + 1)
+  if (end === start + 1) {
+    return start
+  }
+  while (range[end] === '.') {
+    const next = findBuildIdentifierEndIndex(range, end + 1)
+    if (next === end + 1) {
+      break
+    }
+    end = next
+  }
+  return end
+}
+
+/**
+ * Reads three numbers separated by dots, then any prerelease and build suffixes.
+ * Uses loose rules, so forms such as 01.02.03beta can match here.
+ *
+ * @param {string} range The text to read; it is not changed.
+ * @param {number} start The position of the first number, after any prefix.
+ * @param {DigitRunCache} digitRuns Shared digit-run cache, updated as needed.
+ * @returns {number} The position after the version match, or start if none matches.
+ * @example findLooseFullVersionEndIndex('1.2.3-beta+sha <2', 0, digitRuns) // 14
+ * @example findLooseFullVersionEndIndex('1.2', 0, digitRuns) // 0; needs three numbers
+ */
+const findLooseFullVersionEndIndex = (range, start, digitRuns) => {
+  let end = start
+  for (let component = 0; component < 3; component++) {
+    const next = findVersionNumberEndIndex(range, end, true, digitRuns)
+    if (next === end) {
+      return start
+    }
+    end = next
+    if (component < 2) {
+      if (range[end] !== '.') {
+        return start
+      }
+      end++
+    }
+  }
+  const prereleaseEnd = findPrereleaseEndIndex(range, end, true, digitRuns)
+  return findBuildEndIndex(range, prereleaseEnd)
+}
+
+/**
+ * Reads one component of a partial or wildcard version, such as 2 or x in 2.x.
+ * Numbers use strict leading-zero rules; wildcards take up one character.
+ *
+ * @param {string} range The text to read; it is not changed.
+ * @param {number} start The position where the component should begin.
+ * @param {DigitRunCache} digitRuns Shared digit-run cache, updated as needed.
+ * @returns {number} The position after the component, or start if none matches.
+ * @example findPartialVersionComponentEndIndex('2.x', 0, digitRuns) // 1, at the dot
+ * @example findPartialVersionComponentEndIndex('2.x', 2, digitRuns) // 3, after x
+ */
+const findPartialVersionComponentEndIndex = (range, start, digitRuns) => {
+  if (isDigit(range[start])) {
+    return findVersionNumberEndIndex(range, start, false, digitRuns)
+  }
+  return isVersionStart(range[start]) ? start + 1 : start
+}
+
+/**
+ * Reads up to three components, allowing forms such as 1, 1.2, or 1.x.
+ * After the third component, also reads any strict prerelease and build suffixes.
+ *
+ * @param {string} range The text to read; it is not changed.
+ * @param {number} start The position of a number or wildcard, after any prefix.
+ * @param {DigitRunCache} digitRuns Shared digit-run cache, updated as needed.
+ * @returns {number} The position after the matched version text.
+ * @example findPartialVersionEndIndex('1.x <2', 0, digitRuns) // 3, at the space
+ * @example findPartialVersionEndIndex('1.', 0, digitRuns) // 1; the trailing dot is unread
+ */
+const findPartialVersionEndIndex = (range, start, digitRuns) => {
+  let end = findPartialVersionComponentEndIndex(range, start, digitRuns)
+  for (let component = 0; component < 2; component++) {
+    if (range[end] !== '.') {
+      return end
+    }
+    const next = findPartialVersionComponentEndIndex(range, end + 1, digitRuns)
+    if (next === end + 1) {
+      return end
+    }
+    end = next
+  }
+  const prereleaseEnd = findPrereleaseEndIndex(range, end, false, digitRuns)
+  return findBuildEndIndex(range, prereleaseEnd)
+}
+
+/**
+ * Finds where a version match ends, without deciding whether the range is valid.
+ * Tries a loose full version first, then a partial or wildcard version, just
+ * like the old regex's LOOSEPLAIN and XRANGEPLAIN alternatives.
+ *
+ * @param {string} range The text to read; it is not changed.
+ * @param {number} start The position of a number or wildcard, after any prefix.
+ * @param {DigitRunCache} digitRuns Shared digit-run cache, updated as needed.
+ * @returns {number} The position where scanning the next candidate can resume.
+ * @example findVersionEndIndex('1.2.3 <2', 0, digitRuns) // 5, at the space
+ * @example findVersionEndIndex('1.x <2', 0, digitRuns) // 3, at the space
+ */
+const findVersionEndIndex = (range, start, digitRuns) => {
+  const fullVersionEnd = findLooseFullVersionEndIndex(range, start, digitRuns)
+  return fullVersionEnd !== start
+    ? fullVersionEnd
+    : findPartialVersionEndIndex(range, start, digitRuns)
+}
+
+/**
+ * Finds the one whitespace character the old replacement would remove.
+ * Keeps leading whitespace, skips an optional operator, and checks immediately
+ * after it. Returns -1 if there is nothing to remove.
+ *
+ * @param {string} range The text containing a candidate already found by the caller.
+ * @param {number} matchStart The candidate's position, including leading whitespace.
+ * @returns {number} The position of the removable whitespace, or -1 if absent.
+ * @example findRemovableWhitespaceIndex(' > 1', 0) // 2; keep the space at position 0
+ * @example findRemovableWhitespaceIndex('>1', 0) // -1
+ */
+const findRemovableWhitespaceIndex = (range, matchStart) => {
+  let position = matchStart
+  if (isWhitespace(range[position])) {
+    position++
+  }
+  if (range[position] === '<' || range[position] === '>') {
+    position++
+  }
+  if (range[position] === '=') {
+    position++
+  }
+  return isWhitespace(range[position]) ? position : -1
+}
+
+/**
+ * Joins an operator to its version, turning > 1.2.3 into >1.2.3.
+ * Copies everything else according to the old regex's matching rules.
+ * Moves forward through prefixes and whole versions to avoid repeatedly
+ * searching the same characters on long inputs.
+ *
+ * @param {string} range The range text to process; the original string is unchanged.
+ * @returns {string} The range with matched operator whitespace removed.
+ * @example trimComparatorWhitespace('> 1.2.3 < 2') // '>1.2.3 <2'
+ * @example trimComparatorWhitespace('> invalid') // '> invalid'
+ */
+const trimComparatorWhitespace = range => {
+  let result = ''
+  let copyFrom = 0
+  let cursor = 0
+  const digitRuns = { start: -1, end: -1, previousStart: -1, previousEnd: -1 }
+
+  while (cursor < range.length) {
+    const matchStart = cursor
+    if (range[cursor] === '<' || range[cursor] === '>') {
+      cursor++
+    } else if (!isVersionPrefix(range[cursor]) && !isVersionStart(range[cursor])) {
+      cursor++
+      continue
+    }
+
+    // Consume a v/=/whitespace run once, even when no version follows it.
+    while (cursor < range.length && isVersionPrefix(range[cursor])) {
+      cursor++
+    }
+    if (!isVersionStart(range[cursor])) {
+      continue
+    }
+
+    const whitespacePosition = findRemovableWhitespaceIndex(range, matchStart)
+    if (whitespacePosition !== -1) {
+      result += range.slice(copyFrom, whitespacePosition)
+      copyFrom = whitespacePosition + 1
+    }
+
+    // Skip the entire match, so a prerelease's trailing v cannot be
+    // reconsidered as the prefix of another version.
+    cursor = findVersionEndIndex(range, cursor, digitRuns)
+  }
+
+  return result + range.slice(copyFrom)
+}
+
+module.exports = trimComparatorWhitespace

package/node_modules/semver/package.json

@@ -1,6 +1,6 @@
 {
   "name": "semver",
-  "version": "7.8.5",
+  "version": "7.8.6",
   "description": "The semantic version parser used by npm.",
   "main": "index.js",
   "scripts": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-lsp",
-  "version": "11.3.0",
+  "version": "11.4.0",
   "description": "Language Server Protocol runtime for SuPi code intelligence",
   "license": "MIT",
   "repository": {
@@ -38,8 +38,8 @@
     "vscode-jsonrpc": "^10.0.0",
     "vscode-languageserver-protocol": "^3.18.5",
     "vscode-languageserver-types": "^3.18.5",
-    "@mrclrchtr/supi-code-runtime": "11.3.0",
-    "@mrclrchtr/supi-core": "11.3.0"
+    "@mrclrchtr/supi-code-runtime": "11.4.0",
+    "@mrclrchtr/supi-core": "11.4.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",

package/src/config/tsconfig-scope.ts

@@ -162,6 +162,16 @@ export function getFileScopeDecision(filePath: string, cwd: string): FileScopeDe
   };
 }
 
+/**
+ * Whether a project config's program includes a file, by its own file set or
+ * include/exclude rules. Unlike {@link getFileScopeDecision}, the config need
+ * not be the file's nearest one (e.g. a test config including `../src`).
+ */
+export function projectConfigIncludesFile(configPath: string, filePath: string): boolean {
+  const parsed = parseProjectConfig(configPath);
+  return parsed !== null && decideFileScope(parsed, path.resolve(filePath)).included;
+}
+
 function isOutOfTree(cwd: string, absolutePath: string): boolean {
   const relative = path.relative(path.resolve(cwd), absolutePath);
   return relative.startsWith(`..${path.sep}`) || relative === "..";

package/src/manager/manager-typescript-coverage.ts

@@ -0,0 +1,118 @@
+import * as path from "node:path";
+import { collectExtendedProjectConfigs } from "../config/tsconfig-extends.ts";
+import { normalizeTsconfigPath } from "../config/tsconfig-path.ts";
+import { getFileScopeDecision, projectConfigIncludesFile } from "../config/tsconfig-scope.ts";
+import { type AutomaticLspPathPolicy, walkAutomaticLspTree } from "../workspace-path-policy.ts";
+
+/** Directory depth searched for project configs below a TypeScript route root. */
+const PROJECT_CONFIG_SCAN_DEPTH = 8;
+/** Project config paths named in one coverage reason. */
+const MAX_NAMED_PROJECTS = 3;
+/** File names tsserver loads as projects; `tsconfig.*.json` variants are never auto-loaded. */
+const LOADABLE_PROJECT_CONFIGS = new Set(["tsconfig.json", "jsconfig.json"]);
+
+/** Find loadable project configs under a route root, honoring the automatic path policy. */
+export function discoverTypeScriptProjectConfigs(
+  root: string,
+  policy: AutomaticLspPathPolicy,
+): string[] {
+  const configs: string[] = [];
+  walkAutomaticLspTree(policy, root, PROJECT_CONFIG_SCAN_DEPTH, (directory, entries) => {
+    for (const entry of entries) {
+      if (entry.isFile() && LOADABLE_PROJECT_CONFIGS.has(entry.name)) {
+        configs.push(path.join(directory, entry.name));
+      }
+    }
+    return false;
+  });
+  return configs;
+}
+
+/**
+ * Project configs whose program includes `file` but show no sign of being loaded.
+ *
+ * tsserver answers project-wide requests such as references and
+ * implementations only from loaded projects, and loads a project only when one
+ * of its files is open. An unloaded including project (typically a test
+ * config that includes `../src`) can hold matches the answer omits.
+ *
+ * A project counts as loaded when it is the nearest config of an open file or
+ * of a file in the answer (`resultFiles`): tsserver also loads projects on its
+ * own during a search, and a match from a project's own file proves it was searched.
+ *
+ * Base configs extended by another discovered config are skipped: their
+ * default include usually spans the whole tree while they own only root
+ * tooling files, so counting them would mark nearly every answer partial.
+ */
+export function findUnloadedTypeScriptProjects(options: {
+  readonly file: string;
+  readonly cwd: string;
+  readonly openFiles: readonly string[];
+  readonly resultFiles?: readonly string[];
+  readonly configs: readonly string[];
+}): string[] {
+  const baseConfigs = new Set(
+    options.configs.flatMap((config) => [...collectExtendedProjectConfigs(config)]),
+  );
+  const loaded = new Set<string>();
+  for (const loadedFile of [...options.openFiles, ...(options.resultFiles ?? [])]) {
+    const decision = getFileScopeDecision(loadedFile, options.cwd);
+    if (decision.status === "included" && decision.configPath) {
+      loaded.add(normalizeTsconfigPath(decision.configPath));
+    }
+  }
+  return options.configs.filter((config) => {
+    const key = normalizeTsconfigPath(config);
+    return (
+      !loaded.has(key) && !baseConfigs.has(key) && projectConfigIncludesFile(config, options.file)
+    );
+  });
+}
+
+/**
+ * Other projects that tsserver's implementation search skips for `file`.
+ *
+ * tsserver 6 and earlier answer `textDocument/implementation` from the file's
+ * default project only, unlike references, which span loaded projects. Any
+ * other non-base project may implement the target through an import, and
+ * opening its files does not change the answer.
+ */
+export function findSkippedImplementationProjects(options: {
+  readonly file: string;
+  readonly cwd: string;
+  readonly configs: readonly string[];
+}): string[] {
+  const baseConfigs = new Set(
+    options.configs.flatMap((config) => [...collectExtendedProjectConfigs(config)]),
+  );
+  const decision = getFileScopeDecision(options.file, options.cwd);
+  const own = decision.configPath ? normalizeTsconfigPath(decision.configPath) : undefined;
+  return options.configs.filter((config) => {
+    const key = normalizeTsconfigPath(config);
+    return key !== own && !baseConfigs.has(key);
+  });
+}
+
+/** Partial-result reason for tsserver's single-project implementation search. */
+export function singleProjectImplementationReason(skipped: readonly string[]): string {
+  const noun = skipped.length === 1 ? "1 other project is" : `${skipped.length} other projects are`;
+  return (
+    "TypeScript coverage is limited: the TypeScript 6 or earlier server (tsserver) " +
+    `searches implementations only in this file's project; ${noun} not searched. ` +
+    "Use references to find uses in other projects, or use TypeScript 7."
+  );
+}
+
+/** Actionable partial-result reason naming a bounded set of unloaded projects. */
+export function typeScriptCoverageGapReason(unloaded: readonly string[], cwd: string): string {
+  const named = unloaded
+    .slice(0, MAX_NAMED_PROJECTS)
+    .map((config) => path.relative(cwd, config) || path.basename(config));
+  const more = unloaded.length > named.length ? `, +${unloaded.length - named.length} more` : "";
+  const noun = unloaded.length === 1 ? "project that includes" : "projects that include";
+  return (
+    `TypeScript coverage is limited: ${unloaded.length} ${noun} this file ` +
+    `${unloaded.length === 1 ? "is" : "are"} not loaded (${named.join(", ")}${more}). ` +
+    "Open a file from each project and retry."
+  );
+}

package/src/manager/manager.ts

@@ -128,6 +128,13 @@ import type {
   OutstandingDiagnosticSummaryEntry,
   ServerStatus,
 } from "./manager-types.ts";
+import {
+  discoverTypeScriptProjectConfigs,
+  findSkippedImplementationProjects,
+  findUnloadedTypeScriptProjects,
+  singleProjectImplementationReason,
+  typeScriptCoverageGapReason,
+} from "./manager-typescript-coverage.ts";
 import {
   recoverWorkspaceDiagnostics as recoverWorkspaceDiagnosticsImpl,
   type WorkspaceRecoveryResult,
@@ -141,6 +148,7 @@ import {
   workspaceSymbolCollectionResult,
   workspaceSymbolCoverageGap,
 } from "./manager-workspace-symbol.ts";
+import { isFileLocalTopLevelDeclaration } from "./typescript-file-local.ts";
 
 type UnavailableReason = "missing-command" | "start-failed" | "runtime-error";
 
@@ -412,6 +420,8 @@ export class LspManager {
   private warmedSemanticProjects = new Set<string>();
   /** In-flight warm-up probes keyed by project key so concurrent callers share one probe. */
   private pendingWarmProbes = new Map<string, Promise<void>>();
+  /** Loadable TypeScript project configs per route root; cleared when a config changes. */
+  private typeScriptProjectConfigs = new Map<string, string[]>();
   /** One process-crash recovery budget and shared replacement per route. */
   private processCrashRecoveries = new Map<string, ProcessCrashRecoveryState>();
   /** Client generations that completed the initialize handshake. */
@@ -572,6 +582,53 @@ export class LspManager {
     );
   }
 
+  /**
+   * Coverage gap for a project-wide TypeScript request answered by `client`.
+   *
+   * Returns a partial-result reason when a TypeScript project that includes
+   * `filePath` owns neither an open file nor a file in `resultFiles`, so
+   * tsserver may not have searched it; otherwise null. Non-TypeScript routes
+   * always return null.
+   *
+   * Implementation requests not known to use the native backend report every
+   * other project instead: tsserver searches only the file's own project.
+   *
+   * No gap applies when `position` (zero-based) names a top-level declaration
+   * its module does not export: no other project can reference it.
+   */
+  typeScriptProjectCoverageGap(
+    client: LspClient,
+    filePath: string,
+    request: "references" | "implementation",
+    evidence: {
+      readonly resultFiles?: readonly string[];
+      readonly position?: { readonly line: number; readonly character: number };
+    } = {},
+  ): string | null {
+    const { resultFiles = [], position } = evidence;
+    if (client.name !== "typescript") return null;
+    const rootKey = path.resolve(client.root);
+    let configs = this.typeScriptProjectConfigs.get(rootKey);
+    if (!configs) {
+      configs = discoverTypeScriptProjectConfigs(rootKey, this.automaticPathPolicy);
+      this.typeScriptProjectConfigs.set(rootKey, configs);
+    }
+    const file = resolveSessionPath(this.cwd, filePath);
+    if (position && isFileLocalTopLevelDeclaration(file, position)) return null;
+    if (request === "implementation" && client.typescriptSelection?.backend !== "native") {
+      const skipped = findSkippedImplementationProjects({ file, cwd: this.cwd, configs });
+      return skipped.length > 0 ? singleProjectImplementationReason(skipped) : null;
+    }
+    const unloaded = findUnloadedTypeScriptProjects({
+      file,
+      cwd: this.cwd,
+      openFiles: client.openFiles,
+      resultFiles,
+      configs,
+    });
+    return unloaded.length > 0 ? typeScriptCoverageGapReason(unloaded, this.cwd) : null;
+  }
+
   /** Get or create an LSP client for the given file. */
   async getClientForFile(
     filePath: string,
@@ -2397,7 +2454,7 @@ export class LspManager {
    */
   noteWorkspaceChanges(changes: FileEvent[]): void {
     if (changes.length > 0) this.invalidationEpoch++;
-    invalidateProjectConfigCaches(changes);
+    if (invalidateProjectConfigCaches(changes)) this.typeScriptProjectConfigs.clear();
     this.notifyWorkspaceFileChanges(changes);
   }
 
@@ -2586,6 +2643,7 @@ export class LspManager {
     this.warmedWorkspaceSymbolFiles.clear();
     this.warmedSemanticProjects.clear();
     this.pendingWarmProbes.clear();
+    this.typeScriptProjectConfigs.clear();
     this.pendingRestarts.clear();
   }
   /** Get status of all servers. */
@@ -3437,15 +3495,19 @@ export class LspManager {
   }
 }
 
-function invalidateProjectConfigCaches(changes: readonly FileEvent[]): void {
+/** Invalidate parsed project configs; returns whether any config changed. */
+function invalidateProjectConfigCaches(changes: readonly FileEvent[]): boolean {
+  let changed = false;
   for (const change of changes) {
     const configPath = uriToFile(change.uri);
     if (!isProjectConfigFileName(path.basename(configPath))) continue;
+    changed = true;
     invalidateTsconfigCacheForConfig(configPath);
     if (change.type === FileChangeType.Created) {
       invalidateTsconfigCacheForConfigDir(path.dirname(configPath));
     }
   }
+  return changed;
 }
 
 function collectClientDiagnosticEvidenceDocuments(

package/src/manager/typescript-file-local.ts

@@ -0,0 +1,87 @@
+import * as fs from "node:fs";
+import ts from "typescript";
+
+/**
+ * Whether the identifier at `position` names a top-level declaration that only
+ * its own file can reference: the file is an ES module and the declaration is
+ * neither exported by a modifier nor by an export clause or assignment.
+ *
+ * Other TypeScript projects can then hold no references or implementations,
+ * so a project coverage gap cannot apply. Script files (no import or export),
+ * members, unreadable files, and non-declaration positions return false.
+ *
+ * @param position Zero-based LSP position.
+ */
+export function isFileLocalTopLevelDeclaration(
+  filePath: string,
+  position: { readonly line: number; readonly character: number },
+): boolean {
+  let text: string;
+  try {
+    text = fs.readFileSync(filePath, "utf8");
+  } catch {
+    return false;
+  }
+  const sourceFile = ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true);
+  if (!ts.isExternalModule(sourceFile)) return false;
+  let offset: number;
+  try {
+    offset = ts.getPositionOfLineAndCharacter(sourceFile, position.line, position.character);
+  } catch {
+    return false;
+  }
+  const statement = sourceFile.statements.find(
+    (candidate) => candidate.getStart(sourceFile) <= offset && offset < candidate.end,
+  );
+  if (!statement) return false;
+  const name = topLevelDeclarationNameAt(statement, offset, sourceFile);
+  return name !== null && !hasExportModifier(statement) && !exportedByName(sourceFile, name);
+}
+
+/** Name of the declaration `statement` declares at `offset`, or null. */
+function topLevelDeclarationNameAt(
+  statement: ts.Statement,
+  offset: number,
+  sourceFile: ts.SourceFile,
+): string | null {
+  const names: ts.Identifier[] = [];
+  if (
+    ts.isFunctionDeclaration(statement) ||
+    ts.isClassDeclaration(statement) ||
+    ts.isInterfaceDeclaration(statement) ||
+    ts.isTypeAliasDeclaration(statement) ||
+    ts.isEnumDeclaration(statement)
+  ) {
+    if (statement.name) names.push(statement.name);
+  } else if (ts.isVariableStatement(statement)) {
+    for (const declaration of statement.declarationList.declarations) {
+      if (ts.isIdentifier(declaration.name)) names.push(declaration.name);
+    }
+  }
+  const hit = names.find((name) => name.getStart(sourceFile) <= offset && offset <= name.end);
+  return hit ? hit.text : null;
+}
+
+function hasExportModifier(statement: ts.Statement): boolean {
+  return (
+    ts.canHaveModifiers(statement) &&
+    (ts.getModifiers(statement) ?? []).some(
+      (modifier) =>
+        modifier.kind === ts.SyntaxKind.ExportKeyword ||
+        modifier.kind === ts.SyntaxKind.DeclareKeyword,
+    )
+  );
+}
+
+/** `export { name }`, `export default name`, or `export = name` in this file. */
+function exportedByName(sourceFile: ts.SourceFile, name: string): boolean {
+  return sourceFile.statements.some((statement) => {
+    if (ts.isExportAssignment(statement)) {
+      return ts.isIdentifier(statement.expression) && statement.expression.text === name;
+    }
+    if (!ts.isExportDeclaration(statement) || statement.moduleSpecifier) return false;
+    const clause = statement.exportClause;
+    if (!clause || !ts.isNamedExports(clause)) return false;
+    return clause.elements.some((element) => (element.propertyName ?? element.name).text === name);
+  });
+}

package/src/provider/semantic-symbol-mapper.ts

@@ -2,10 +2,11 @@ import { readFile } from "node:fs/promises";
 import type {
   CodeLocation,
   CodeSymbol,
-  DeclarationNesting,
+  DeclarationLevel,
   DocumentCodeSymbol,
   SourceRange,
 } from "@mrclrchtr/supi-code-runtime/api";
+import { childDeclarationLevel } from "@mrclrchtr/supi-code-runtime/api";
 import { uriToFile } from "@mrclrchtr/supi-core/path";
 import type {
   DocumentSymbol,
@@ -100,15 +101,26 @@ export async function mapDocumentSymbols(
 ): Promise<DocumentCodeSymbol[]> {
   return flattenDocumentSymbols(symbols, filePath, null, {
     sourceLines: await readSourceLines(filePath),
-    nesting: "top-level",
+    parent: null,
   });
 }
 
+/** Level of a symbol reported inside `parent`, or top-level without one. */
+function levelWithin(
+  parent: { readonly kind: string; readonly level: DeclarationLevel } | null,
+  kind: string,
+): DeclarationLevel {
+  return parent ? childDeclarationLevel(parent, kind) : "top-level";
+}
+
 function flattenDocumentSymbols(
   symbols: DocumentSymbol[] | SymbolInformation[],
   filePath: string,
   container: string | null,
-  context: { sourceLines: readonly string[] | null; nesting: DeclarationNesting },
+  context: {
+    sourceLines: readonly string[] | null;
+    parent: { readonly kind: string; readonly level: DeclarationLevel } | null;
+  },
 ): DocumentCodeSymbol[] {
   const result: DocumentCodeSymbol[] = [];
   for (const sym of symbols) {
@@ -116,15 +128,13 @@ function flattenDocumentSymbols(
     let document: DocumentSymbol | null = null;
     if (isSymbolInformation(sym)) information = sym;
     else document = sym;
+    const kind = symbolKindName(sym.kind);
+    const level = information ? "unknown" : levelWithin(context.parent, kind);
+    const childContext = { sourceLines: context.sourceLines, parent: { kind, level } };
     const declarationRange = toValidRange(document?.range ?? information?.location.range);
     if (!declarationRange) {
       if (document?.children?.length) {
-        result.push(
-          ...flattenDocumentSymbols(document.children, filePath, sym.name, {
-            sourceLines: context.sourceLines,
-            nesting: "nested",
-          }),
-        );
+        result.push(...flattenDocumentSymbols(document.children, filePath, sym.name, childContext));
       }
       continue;
     }
@@ -134,23 +144,18 @@ function flattenDocumentSymbols(
       : null;
     const symbol: DocumentCodeSymbol = {
       name: sym.name,
-      kind: symbolKindName(sym.kind),
+      kind,
       file: filePath,
       declarationAnchor: { line: declStart.line + 1, character: declStart.character + 1 },
       container: information?.containerName ?? container,
-      nesting: information ? "unknown" : context.nesting,
+      level,
     };
     if (nameStart) {
       symbol.nameAnchor = { line: nameStart.line + 1, character: nameStart.character + 1 };
     }
     result.push(symbol);
     if (document?.children?.length) {
-      result.push(
-        ...flattenDocumentSymbols(document.children, filePath, sym.name, {
-          sourceLines: context.sourceLines,
-          nesting: "nested",
-        }),
-      );
+      result.push(...flattenDocumentSymbols(document.children, filePath, sym.name, childContext));
     }
   }
   return result;

package/src/session/runtime-registry.ts

@@ -1,11 +1,13 @@
 // Shared session-scoped LSP service registry reused by peer extensions.
 
 // biome-ignore lint/style/noExcessiveLinesPerFile: session registry, runtime recovery, and telemetry stay in one file; splitting would hide the recovery contract.
+import { fileURLToPath } from "node:url";
 import {
   type CodeQueryResult,
   type CodeRequestControl,
   isCodeRequestInterruption,
   mapCodeQueryResult,
+  partialCodeQuery,
   throwIfCodeRequestInterrupted,
   unavailableCodeQuery,
 } from "@mrclrchtr/supi-code-runtime/api";
@@ -193,9 +195,14 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
       control,
     });
     if (!client) return unavailableFileQuery("references", resolvedPath);
-    return mapCodeQueryResult(
-      await client.references(resolvedPath, position, control),
-      (data) => data ?? [],
+    return this.withProjectCoverage(
+      client,
+      { file: resolvedPath, position },
+      "references",
+      mapCodeQueryResult(
+        await client.references(resolvedPath, position, control),
+        (data) => data ?? [],
+      ),
     );
   }
 
@@ -211,7 +218,30 @@ class DefaultWorkspaceLspRuntime implements WorkspaceLspRuntime {
       control,
     });
     if (!client) return unavailableFileQuery("implementation", resolvedPath);
-    return client.implementation(resolvedPath, position, control);
+    return this.withProjectCoverage(
+      client,
+      { file: resolvedPath, position },
+      "implementation",
+      await client.implementation(resolvedPath, position, control),
+    );
+  }
+
+  /**
+   * Downgrade a completed project-wide answer to partial when the TypeScript
+   * server may not have searched every relevant project.
+   */
+  private withProjectCoverage<T extends Location[] | Location | LocationLink[] | null>(
+    client: NonNullable<Awaited<ReturnType<LspManager["ensureFileOpen"]>>>,
+    target: { readonly file: string; readonly position: Position },
+    request: "references" | "implementation",
+    result: CodeQueryResult<T>,
+  ): CodeQueryResult<T> {
+    if (result.kind !== "completed") return result;
+    const gap = this.manager.typeScriptProjectCoverageGap(client, target.file, request, {
+      resultFiles: locationFiles(result.data),
+      position: target.position,
+    });
+    return gap ? partialCodeQuery(result.data, gap) : result;
   }
 
   async documentSymbols(
@@ -605,6 +635,21 @@ export async function waitForWorkspaceLspRuntime(
   return state;
 }
 
+/** Local file paths of LSP locations or location links; non-file URIs are skipped. */
+function locationFiles(data: Location[] | Location | LocationLink[] | null): string[] {
+  const items: (Location | LocationLink)[] =
+    data === null ? [] : Array.isArray(data) ? data : [data];
+  return items.flatMap((item) => {
+    const uri = "targetUri" in item ? item.targetUri : item.uri;
+    if (!uri.startsWith("file:")) return [];
+    try {
+      return [fileURLToPath(uri)];
+    } catch {
+      return [];
+    }
+  });
+}
+
 /** Remove the LSP service state for a session cwd. */
 export function clearWorkspaceLspRuntime(cwd: string): void {
   registry.clear(cwd);