@lzehrung/codegraph 2.3.27 → 2.3.28

package/dist/bin/cli.js

@@ -2070,12 +2070,21 @@ function transformJsLikeTrivia(src, options) {
       if (preserveLength)
         out += "  ";
       i += 2;
-      while (i < src.length) {
+      let depth = 1;
+      while (i < src.length && depth > 0) {
+        if (options?.nestedBlockComments && src[i] === "/" && src[i + 1] === "*") {
+          if (preserveLength)
+            out += "  ";
+          depth += 1;
+          i += 2;
+          continue;
+        }
         if (src[i] === "*" && src[i + 1] === "/") {
           if (preserveLength)
             out += "  ";
+          depth -= 1;
           i += 2;
-          break;
+          continue;
         }
         if (preserveLength)
           out += maskedChar(src[i]);
@@ -2378,6 +2387,20 @@ function stripPythonCommentsAndStrings(src) {
   out = out.replace(/#.*$/gm, "");
   return out;
 }
+function maskMatchPreservingNewlines(match) {
+  let out = "";
+  for (const character of match) {
+    out += character === "\n" ? "\n" : " ".repeat(character.length);
+  }
+  return out;
+}
+function maskPythonCommentsAndStrings(src) {
+  let out = src;
+  out = out.replace(/([rRuU]?[fF]?)("""|''')[\s\S]*?\2/g, maskMatchPreservingNewlines);
+  out = out.replace(/([rRuU]?[fF]?)("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')/g, maskMatchPreservingNewlines);
+  out = out.replace(/#.*$/gm, maskMatchPreservingNewlines);
+  return out;
+}
 var init_comments = __esm({
   "dist/util/comments.js"() {
     "use strict";
@@ -2567,6 +2590,7 @@ var init_typescript = __esm({
     (function_declaration name: (identifier) @name)
     (generator_function_declaration name: (identifier) @name)
     (method_definition name: (property_identifier) @name)
+    (public_field_definition name: (property_identifier) @name)
     (method_signature name: (property_identifier) @name)
     (abstract_method_signature name: (property_identifier) @name)
     (function_signature name: (identifier) @name)
@@ -2575,6 +2599,8 @@ var init_typescript = __esm({
     (variable_declarator name: (identifier) @name)
     (interface_declaration name: (type_identifier) @name)
     (type_alias_declaration name: (type_identifier) @name)
+    (enum_body (property_identifier) @name)
+    (enum_assignment name: (property_identifier) @name)
     (enum_declaration name: [ (identifier) (type_identifier) ] @name)
     (internal_module name: (identifier) @name)
     (module name: (identifier) @name)
@@ -2623,13 +2649,23 @@ var init_typescript = __esm({
         return "variable";
       },
       isDeclarationName: (node) => {
-        const p = node.parent?.type;
+        const parent = node.parent;
+        const p = parent?.type;
+        if (parent?.type === "variable_declarator") {
+          return parent.childForFieldName("name")?.id === node.id;
+        }
+        if (parent?.type === "public_field_definition" || parent?.type === "enum_assignment") {
+          const name = parent.childForFieldName("name") ?? parent.childForFieldName("property");
+          return name?.id === node.id;
+        }
+        if (parent?.type === "enum_body") {
+          return node.type === "property_identifier";
+        }
         return !!p && [
           "generator_function_declaration",
           "function_declaration",
           "class_declaration",
           "abstract_class_declaration",
-          "variable_declarator",
           "interface_declaration",
           "type_alias_declaration",
           "enum_declaration",
@@ -2654,7 +2690,7 @@ var init_typescript = __esm({
         const parent = node.parent?.type;
         return parent === "function_signature" || parent === "internal_module" || parent === "module";
       },
-      createsBlockScope: (n) => n.type === "program" || n.type === "block" || n.type === "class_body" || n.type === "class_static_block",
+      createsBlockScope: (n) => n.type === "program" || n.type === "block" || n.type === "class_body" || n.type === "class_static_block" || n.type === "enum_body",
       createsFunctionScope: (n) => n.type === "generator_function_declaration" || n.type === "function_declaration" || n.type === "function" || n.type === "function_expression" || n.type === "arrow_function" || n.type === "method_definition",
       membersAreImplicitlyInScope: false,
       supportsCrossModuleSymbols: true
@@ -2813,6 +2849,7 @@ var init_javascript = __esm({
       (function_declaration name: (identifier) @name)
       (generator_function_declaration name: (identifier) @name)
       (method_definition name: (property_identifier) @name)
+      (field_definition property: (property_identifier) @name)
       (class_declaration name: (identifier) @name)
       (variable_declarator name: (identifier) @name)
     `,
@@ -2850,12 +2887,19 @@ var init_javascript = __esm({
         return "variable";
       },
       isDeclarationName: (node) => {
-        const p = node.parent?.type;
+        const parent = node.parent;
+        const p = parent?.type;
+        if (parent?.type === "variable_declarator") {
+          return parent.childForFieldName("name")?.id === node.id;
+        }
+        if (parent?.type === "field_definition") {
+          const name = parent.childForFieldName("name") ?? parent.childForFieldName("property");
+          return name?.id === node.id;
+        }
         return !!p && [
           "function_declaration",
           "generator_function_declaration",
           "class_declaration",
-          "variable_declarator",
           "import_specifier",
           "namespace_import",
           "import_clause",
@@ -3093,9 +3137,13 @@ var init_python = __esm({
           return parent?.childForFieldName("name")?.id === node.id;
         if (t === "pattern_list" || t === "tuple_pattern")
           return true;
+        if (t === "assignment")
+          return parent?.childForFieldName("left")?.id === node.id;
+        if (t === "aliased_import")
+          return parent?.childForFieldName("alias")?.id === node.id;
         if (isTypeAliasLeftName(node))
           return true;
-        return !!t && ["function_definition", "class_definition", "assignment", "aliased_import"].includes(t);
+        return !!t && ["function_definition", "class_definition"].includes(t);
       },
       createsBlockScope: (n) => n.type === "module" || n.type === "block",
       createsFunctionScope: (n) => n.type === "function_definition" || n.type === "lambda",
@@ -3158,7 +3206,7 @@ var init_php = __esm({
           },
           {
             type: "const_declaration",
-            nameQuery: "(const_element (name) @chunk.name)",
+            nameQuery: "(const_element . (name) @chunk.name)",
             captureId: "const"
           }
         ],
@@ -3190,7 +3238,7 @@ var init_php = __esm({
       (enum_declaration name: (name) @name)
       (enum_case name: (name) @name)
       (function_definition name: (name) @name)
-      (const_declaration (const_element (name) @name))
+      (const_declaration (const_element . (name) @name))
     `,
         locals: `
       (class_declaration name: (name) @name)
@@ -3200,8 +3248,8 @@ var init_php = __esm({
       (enum_case name: (name) @name)
       (function_definition name: (name) @name)
       (method_declaration name: (name) @name)
-      (const_declaration (const_element (name) @name))
-      (property_element (variable_name) @name)
+      (const_declaration (const_element . (name) @name))
+      (property_element name: (variable_name) @name)
     `,
         importBindings: `
       (require_expression) @stmt
@@ -3257,9 +3305,10 @@ var init_php = __esm({
         if (nameFieldOwnerTypes.has(parent.type)) {
           return parent.childForFieldName("name")?.id === node.id;
         }
-        if (parent.type === "property_element" && node.type === "variable_name")
-          return true;
-        return parent.type === "const_element" && parent.namedChildren.some((child) => child.id === node.id && child.type === "name");
+        if (parent.type === "property_element") {
+          return parent.childForFieldName("name")?.id === node.id;
+        }
+        return parent.type === "const_element" && parent.namedChildren[0]?.id === node.id && node.type === "name";
       },
       scopeDeclarationNames: (node) => node.type === "variable_name" && node.parent?.type === "property_element",
       createsFunctionScope: (node) => node.type === "function_definition" || node.type === "method_declaration",
@@ -5133,12 +5182,12 @@ var init_zig = __esm({
     `,
         exports: `
       (source_file (function_declaration name: (identifier) @name))
-      (source_file (variable_declaration (identifier) @name))
+      (source_file (variable_declaration . (identifier) @name (_)))
     `,
         locals: `
       (function_declaration name: (identifier) @name)
       (parameter (identifier) @name)
-      (variable_declaration (identifier) @name)
+      (variable_declaration . (identifier) @name (_))
     `,
         importBindings: `
       (variable_declaration
@@ -5193,7 +5242,10 @@ var init_zig = __esm({
           return false;
         if (parent.type === "function_declaration" && parent.childForFieldName("name")?.id === node.id)
           return true;
-        return parent.type === "variable_declaration";
+        if (parent.type !== "variable_declaration")
+          return false;
+        const declaredName = parent.namedChildren.find((child) => child.type === "identifier");
+        return declaredName?.id === node.id;
       }
     };
     registerLanguage(ZIG_DEF);
@@ -8742,11 +8794,11 @@ var require_pattern = __commonJS({
       if (openingBraceIndex === -1) {
         return false;
       }
-      const closingBraceIndex = pattern.indexOf("}", openingBraceIndex + 1);
-      if (closingBraceIndex === -1) {
+      const closingBraceIndex2 = pattern.indexOf("}", openingBraceIndex + 1);
+      if (closingBraceIndex2 === -1) {
         return false;
       }
-      const braceContent = pattern.slice(openingBraceIndex, closingBraceIndex);
+      const braceContent = pattern.slice(openingBraceIndex, closingBraceIndex2);
       return BRACE_EXPANSION_SEPARATORS_RE.test(braceContent);
     }
     function convertToPositivePattern(pattern) {
@@ -32887,7 +32939,8 @@ function flattenRustUseTree(prefix, item) {
       kind: "member",
       from,
       imported,
-      local: alias ?? imported
+      local: alias ?? imported,
+      ...alias !== void 0 ? { explicitAlias: true } : {}
     }
   ];
 }
@@ -32943,6 +32996,7 @@ function parsePhpImportClause(rawClause, importType) {
         from: fullPath2,
         imported: imported2,
         local: aliasMatch2?.[2] ?? imported2,
+        ...aliasMatch2 ? { explicitAlias: true } : {},
         importType: memberType
       });
     }
@@ -32960,6 +33014,7 @@ function parsePhpImportClause(rawClause, importType) {
       from: fullPath,
       imported,
       local: aliasMatch?.[2] ?? imported,
+      ...aliasMatch ? { explicitAlias: true } : {},
       importType
     }
   ];
@@ -33144,7 +33199,8 @@ function parseKotlinImportStatement(stmtText) {
     kind: "named",
     from: rawSpec,
     imported,
-    local: match?.[2] ?? imported
+    local: match?.[2] ?? imported,
+    ...match?.[2] !== void 0 ? { explicitAlias: true } : {}
   };
 }
 function parseJavaImportStatement(stmtText) {
@@ -43127,6 +43183,19 @@ function collectLineStartOffsets(source) {
   }
   return lineStarts;
 }
+function positionAtOffset(lineStarts, index) {
+  let low = 0;
+  let high = lineStarts.length - 1;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    if (lineStarts[middle] <= index) {
+      low = middle;
+    } else {
+      high = middle - 1;
+    }
+  }
+  return { line: low + 1, column: index - lineStarts[low] + 1, index };
+}
 var init_lines = __esm({
   "dist/util/lines.js"() {
     "use strict";
@@ -45022,6 +45091,239 @@ var init_parse_context = __esm({
   }
 });
 
+// dist/indexer/imports/binding-ranges.js
+function maskTriviaSpan(text, start, end) {
+  return text.slice(start, end).replace(/[^\r\n]/g, " ");
+}
+function nestedBlockCommentEnd(text, start) {
+  let depth = 1;
+  let index = start + 2;
+  while (index < text.length && depth) {
+    if (text.startsWith("/*", index)) {
+      depth += 1;
+      index += 2;
+    } else if (text.startsWith("*/", index)) {
+      depth -= 1;
+      index += 2;
+    } else {
+      index += 1;
+    }
+  }
+  return index;
+}
+function lineCommentEnd(text, start) {
+  let index = start + 2;
+  while (index < text.length && text[index] !== "\r" && text[index] !== "\n")
+    index += 1;
+  return index;
+}
+function escapedQuotedLiteralEnd(text, start, quote) {
+  let index = start + 1;
+  while (index < text.length) {
+    if (text[index] === "\\") {
+      index = Math.min(text.length, index + 2);
+    } else if (text[index] === quote) {
+      return index + 1;
+    } else {
+      index += 1;
+    }
+  }
+  return text.length;
+}
+function kotlinLiteralEnd(text, start) {
+  const quote = text[start];
+  if (quote !== '"' && quote !== "'")
+    return null;
+  if (quote === '"' && text.startsWith('"""', start)) {
+    const close = text.indexOf('"""', start + 3);
+    return close === -1 ? text.length : close + 3;
+  }
+  return escapedQuotedLiteralEnd(text, start, quote);
+}
+function swiftStringEnd(text, start) {
+  let quoteStart = start;
+  while (text[quoteStart] === "#")
+    quoteStart += 1;
+  if (text[quoteStart] !== '"')
+    return null;
+  const hashCount = quoteStart - start;
+  const quote = text.startsWith('"""', quoteStart) ? '"""' : '"';
+  const close = `${quote}${"#".repeat(hashCount)}`;
+  let index = quoteStart + quote.length;
+  while (index < text.length) {
+    if (!hashCount && text[index] === "\\") {
+      index = Math.min(text.length, index + 2);
+    } else if (text.startsWith(close, index)) {
+      return index + close.length;
+    } else {
+      index += 1;
+    }
+  }
+  return text.length;
+}
+function maskNestedLanguageCommentsAndStrings(text, languageId) {
+  let masked = "";
+  let copiedThrough = 0;
+  for (let index = 0; index < text.length; ) {
+    let end = null;
+    if (text.startsWith("//", index)) {
+      end = lineCommentEnd(text, index);
+    } else if (text.startsWith("/*", index)) {
+      end = nestedBlockCommentEnd(text, index);
+    } else {
+      end = languageId === "kotlin" ? kotlinLiteralEnd(text, index) : swiftStringEnd(text, index);
+    }
+    if (end === null) {
+      index += 1;
+      continue;
+    }
+    masked += text.slice(copiedThrough, index);
+    masked += maskTriviaSpan(text, index, end);
+    copiedThrough = end;
+    index = end;
+  }
+  return masked + text.slice(copiedThrough);
+}
+function maskImportBindingTrivia(text, languageId) {
+  if (languageId === "rust") {
+    let masked2 = "";
+    for (let index = 0; index < text.length; ) {
+      const trivia = skipRustCommentOrLiteral(text, index);
+      if (!trivia) {
+        masked2 += text[index];
+        index += 1;
+        continue;
+      }
+      masked2 += text.slice(index, trivia.end).replace(/[^\r\n]/g, " ");
+      index = trivia.end;
+    }
+    return masked2;
+  }
+  if (languageId === "kotlin" || languageId === "swift") {
+    return maskNestedLanguageCommentsAndStrings(text, languageId);
+  }
+  const masked = maskJsLikeCommentsAndStrings(text);
+  if (languageId !== "php")
+    return masked;
+  return masked.replace(/#[^\r\n]*/g, (comment) => " ".repeat(comment.length));
+}
+function attributeNamedBindingRanges(args) {
+  const { bindings, fromIndex, text, textStartIndex, source, alwaysAliased } = args;
+  const slots = buildRoleSlots(bindings, fromIndex, alwaysAliased);
+  if (!slots.length)
+    return;
+  const matches = matchRoleSequenceBackward(text, slots);
+  if (!matches)
+    return;
+  const lineStarts = collectLineStartOffsets(source);
+  for (let index = 0; index < slots.length; index++) {
+    const slot = slots[index];
+    const binding = bindings[slot.bindingIndex];
+    if (binding.kind !== "named")
+      continue;
+    const range = toSourceRange(lineStarts, textStartIndex, matches[index]);
+    binding[slot.field] = range;
+    if (slot.field === "importedRange" && binding.local === binding.imported && !binding.explicitAlias && binding.localRange === void 0) {
+      binding.localRange = range;
+    }
+  }
+}
+function buildRoleSlots(bindings, fromIndex, alwaysAliased) {
+  const slots = [];
+  for (let index = fromIndex; index < bindings.length; index++) {
+    const binding = bindings[index];
+    if (binding.kind !== "named")
+      continue;
+    if (binding.importedRange !== void 0 || binding.localRange !== void 0)
+      continue;
+    if (alwaysAliased) {
+      slots.push({ bindingIndex: index, field: "localRange", name: binding.local });
+      slots.push({ bindingIndex: index, field: "importedRange", name: binding.imported });
+    } else if (binding.local === binding.imported && !binding.explicitAlias) {
+      slots.push({ bindingIndex: index, field: "importedRange", name: binding.imported });
+    } else {
+      slots.push({ bindingIndex: index, field: "importedRange", name: binding.imported });
+      slots.push({ bindingIndex: index, field: "localRange", name: binding.local });
+    }
+  }
+  return slots;
+}
+function matchRoleSequenceBackward(text, slots) {
+  const matches = new Array(slots.length).fill(null);
+  let upperBound = text.length;
+  for (let index = slots.length - 1; index >= 0; index--) {
+    const match = findRightmostWholeWordOccurrence(text, slots[index].name, upperBound);
+    if (!match)
+      return null;
+    matches[index] = match;
+    upperBound = match.start;
+  }
+  return matches;
+}
+function isIdentifierContinuationBefore(text, index) {
+  if (index <= 0)
+    return false;
+  let charIndex = index - 1;
+  const code = text.charCodeAt(charIndex);
+  if (code >= 56320 && code <= 57343 && charIndex > 0) {
+    const highCode = text.charCodeAt(charIndex - 1);
+    if (highCode >= 55296 && highCode <= 56319)
+      charIndex -= 1;
+  }
+  const codePoint = text.codePointAt(charIndex);
+  return codePoint !== void 0 && IDENTIFIER_CONTINUATION_PATTERN.test(String.fromCodePoint(codePoint));
+}
+function isIdentifierContinuationAt(text, index) {
+  if (index >= text.length)
+    return false;
+  const codePoint = text.codePointAt(index);
+  return codePoint !== void 0 && IDENTIFIER_CONTINUATION_PATTERN.test(String.fromCodePoint(codePoint));
+}
+function isWholeWordMatchAt(text, start, word) {
+  if (isIdentifierContinuationBefore(text, start))
+    return false;
+  if (isIdentifierContinuationAt(text, start + word.length))
+    return false;
+  return true;
+}
+function findRightmostWholeWordOccurrence(text, word, beforeIndex) {
+  if (!word)
+    return null;
+  let best = null;
+  let searchFrom = 0;
+  for (; ; ) {
+    const start = text.indexOf(word, searchFrom);
+    if (start === -1)
+      break;
+    const end = start + word.length;
+    if (end > beforeIndex)
+      break;
+    searchFrom = start + 1;
+    if (isWholeWordMatchAt(text, start, word))
+      best = { start, end };
+  }
+  return best;
+}
+function toSourceRange(lineStarts, textStartIndex, match) {
+  return sourceRangeFromOffsets(lineStarts, textStartIndex + match.start, textStartIndex + match.end);
+}
+function sourceRangeFromOffsets(lineStarts, startIndex, endIndex) {
+  return {
+    start: positionAtOffset(lineStarts, startIndex),
+    end: positionAtOffset(lineStarts, endIndex)
+  };
+}
+var IDENTIFIER_CONTINUATION_PATTERN;
+var init_binding_ranges = __esm({
+  "dist/indexer/imports/binding-ranges.js"() {
+    "use strict";
+    init_import_statement_parsers();
+    init_comments();
+    init_lines();
+    IDENTIFIER_CONTINUATION_PATTERN = /[\p{ID_Continue}$@]/u;
+  }
+});
+
 // dist/indexer/imports/graph-only.js
 async function collectGraphOnlyImports(context) {
   const entries = Array.from(extractGraphOnlyModuleSpecifiers(context.languageId, context.source));
@@ -45074,20 +45376,136 @@ function sourceForTextImportExtraction(context) {
   }
   return context.source;
 }
-function splitNamedImports(namedBlock) {
-  return namedBlock.replace(/[{}]/g, "").split(",").map((spec) => spec.trim()).filter(Boolean);
+function tokenRange(source, lineStarts, index, token) {
+  if (index < 0 || !token)
+    return void 0;
+  if (source.slice(index, index + token.length) !== token)
+    return void 0;
+  return {
+    start: positionAtOffset(lineStarts, index),
+    end: positionAtOffset(lineStarts, index + token.length)
+  };
+}
+function splitNamedImportsWithOffsets(namedBlock) {
+  const out = [];
+  let cursor = 0;
+  for (const raw of namedBlock.split(",")) {
+    const leading = raw.length - raw.trimStart().length;
+    const spec = raw.trim();
+    if (spec)
+      out.push({ spec, start: cursor + leading });
+    cursor += raw.length + 1;
+  }
+  return out;
+}
+function closingBraceIndex(maskedSource, openingIndex) {
+  let depth = 0;
+  for (let index = openingIndex; index < maskedSource.length; index += 1) {
+    const character = maskedSource[index];
+    if (character === "{") {
+      depth += 1;
+    } else if (character === "}") {
+      depth -= 1;
+      if (depth === 0)
+        return index;
+    }
+  }
+  return -1;
+}
+function splitNamedRequireBindingsWithOffsets(source, maskedSource, blockStart, blockEnd) {
+  const out = [];
+  let specStart = blockStart;
+  let braceDepth = 0;
+  let bracketDepth = 0;
+  let parenDepth = 0;
+  const push = (end) => {
+    const raw = source.slice(specStart, end);
+    const leading = raw.length - raw.trimStart().length;
+    const spec = raw.trim();
+    if (spec)
+      out.push({ spec, start: specStart - blockStart + leading });
+  };
+  for (let index = blockStart; index < blockEnd; index += 1) {
+    const character = maskedSource[index];
+    if (character === "{")
+      braceDepth += 1;
+    else if (character === "}")
+      braceDepth -= 1;
+    else if (character === "[")
+      bracketDepth += 1;
+    else if (character === "]")
+      bracketDepth -= 1;
+    else if (character === "(")
+      parenDepth += 1;
+    else if (character === ")")
+      parenDepth -= 1;
+    else if (character === "," && braceDepth === 0 && bracketDepth === 0 && parenDepth === 0) {
+      push(index);
+      specStart = index + 1;
+    }
+  }
+  push(blockEnd);
+  return out;
 }
 function parseNamedImportSpecifier(spec) {
   const typeOnlyMatch = spec.match(TYPE_NAMED_IMPORT_SPECIFIER_PATTERN);
   if (typeOnlyMatch) {
     const imported2 = typeOnlyMatch[1];
-    return { imported: imported2, local: typeOnlyMatch[2] ?? imported2, typeOnly: true };
+    const importedOffset = /^type\s+/.exec(spec)[0].length;
+    if (typeOnlyMatch[2] !== void 0) {
+      const local = typeOnlyMatch[2];
+      return {
+        imported: imported2,
+        local,
+        typeOnly: true,
+        importedOffset,
+        localOffset: spec.length - local.length,
+        explicitAlias: true
+      };
+    }
+    return {
+      imported: imported2,
+      local: imported2,
+      typeOnly: true,
+      importedOffset,
+      localOffset: importedOffset,
+      explicitAlias: false
+    };
   }
   const namedMatch = spec.match(NAMED_IMPORT_SPECIFIER_PATTERN);
   if (!namedMatch)
     return null;
   const imported = namedMatch[1];
-  return { imported, local: namedMatch[2] ?? imported, typeOnly: false };
+  if (namedMatch[2] !== void 0) {
+    const local = namedMatch[2];
+    return {
+      imported,
+      local,
+      typeOnly: false,
+      importedOffset: 0,
+      localOffset: spec.length - local.length,
+      explicitAlias: true
+    };
+  }
+  return { imported, local: imported, typeOnly: false, importedOffset: 0, localOffset: 0, explicitAlias: false };
+}
+function parseNamedRequireSpecifier(spec) {
+  const bindingSpec = spec.replace(/\s*=\s*[\s\S]*$/u, "").trimEnd();
+  const namedMatch = bindingSpec.match(NAMED_REQUIRE_SPECIFIER_PATTERN);
+  if (!namedMatch)
+    return null;
+  const imported = namedMatch[1];
+  if (namedMatch[2] !== void 0) {
+    const local = namedMatch[2];
+    return {
+      imported,
+      local,
+      importedOffset: 0,
+      localOffset: bindingSpec.length - local.length,
+      explicitAlias: true
+    };
+  }
+  return { imported, local: imported, importedOffset: 0, localOffset: 0, explicitAlias: false };
 }
 function matchStartsInCode2(maskedSource, match) {
   const index = match.index;
@@ -45102,24 +45520,34 @@ function matchStartsInCode2(maskedSource, match) {
   }
   return true;
 }
-async function collectEsImports(context, source, maskedSource) {
+async function collectEsImports(context, source, maskedSource, lineStarts) {
   const typeOnlyImport = /\bimport\s+type\b/;
   const fromPattern = /^\s*import\s+([^\n;]*?)\s+from\s+(["'])(?<module>[^"']+)\2/gm;
   for (const match of source.matchAll(fromPattern)) {
     if (!matchStartsInCode2(maskedSource, match))
       continue;
-    const clause = match[1].trim().replace(/^type\s+/, "");
     const moduleSpecifier = match.groups?.module;
     if (!moduleSpecifier)
       continue;
+    const importPrefix = /^\s*import\s+/.exec(match[0]);
+    const clauseStart = importPrefix && match.index !== void 0 ? match.index + importPrefix[0].length : -1;
+    const clauseRaw = match[1];
+    const leading = clauseRaw.length - clauseRaw.trimStart().length;
+    const trimmedClause = clauseRaw.trim();
+    const typePrefix = /^type\s+/.exec(trimmedClause);
+    const clause = typePrefix ? trimmedClause.slice(typePrefix[0].length) : trimmedClause;
+    const bodyStart = clauseStart < 0 ? -1 : clauseStart + leading + (typePrefix ? typePrefix[0].length : 0);
     const typeOnly = typeOnlyImport.test(match[0]);
     const resolved = await context.resolveFrom(moduleSpecifier);
     const namespaceMatch = clause.match(NAMESPACE_IMPORT_PATTERN);
     if (namespaceMatch) {
+      const localNS = namespaceMatch[1];
+      const localRange = bodyStart < 0 ? void 0 : tokenRange(source, lineStarts, bodyStart + namespaceMatch[0].indexOf(localNS), localNS);
       context.pushBinding({
         kind: "namespace",
-        localNS: namespaceMatch[1],
+        localNS,
         from: moduleSpecifier,
+        ...localRange ? { localRange } : {},
         resolved,
         typeOnly
       });
@@ -45128,33 +45556,44 @@ async function collectEsImports(context, source, maskedSource) {
     const namedBlockMatch = clause.match(/\{(?<named>[^}]*)\}/);
     const defaultPart = namedBlockMatch?.index === void 0 ? clause.split(",", 1)[0].trim() : clause.slice(0, namedBlockMatch.index).replace(/,\s*$/, "").trim();
     if (defaultPart) {
+      const localRange = bodyStart < 0 ? void 0 : tokenRange(source, lineStarts, bodyStart + clause.indexOf(defaultPart), defaultPart);
       context.pushBinding({
         kind: "default",
         local: defaultPart,
         from: moduleSpecifier,
+        ...localRange ? { localRange } : {},
         resolved,
         typeOnly
       });
     }
-    const namedBlock = namedBlockMatch?.groups?.named ?? "";
-    for (const spec of splitNamedImports(namedBlock)) {
-      const namedImport = parseNamedImportSpecifier(spec);
-      if (!namedImport)
-        continue;
-      const bindingTypeOnly = typeOnly || namedImport.typeOnly;
-      context.pushBinding({
-        kind: "named",
-        local: namedImport.local,
-        imported: namedImport.imported,
-        from: moduleSpecifier,
-        resolved,
-        typeOnly: bindingTypeOnly
-      });
+    if (namedBlockMatch?.index !== void 0 && bodyStart >= 0) {
+      const namedBlockContentStart = bodyStart + namedBlockMatch.index + namedBlockMatch[0].indexOf("{") + 1;
+      for (const { spec, start } of splitNamedImportsWithOffsets(namedBlockMatch.groups?.named ?? "")) {
+        const namedImport = parseNamedImportSpecifier(spec);
+        if (!namedImport)
+          continue;
+        const specStart = namedBlockContentStart + start;
+        const bindingTypeOnly = typeOnly || namedImport.typeOnly;
+        const importedRange = tokenRange(source, lineStarts, specStart + namedImport.importedOffset, namedImport.imported);
+        const localRange = tokenRange(source, lineStarts, specStart + namedImport.localOffset, namedImport.local);
+        context.pushBinding({
+          kind: "named",
+          local: namedImport.local,
+          imported: namedImport.imported,
+          from: moduleSpecifier,
+          ...namedImport.explicitAlias ? { explicitAlias: true } : {},
+          ...importedRange ? { importedRange } : {},
+          ...localRange ? { localRange } : {},
+          resolved,
+          typeOnly: bindingTypeOnly
+        });
+      }
     }
   }
 }
-async function collectCommonJsRequireDeclarations(context, source, maskedSource) {
+async function collectCommonJsRequireDeclarations(context, source, maskedSource, lineStarts) {
   const defaultRequirePattern = DEFAULT_REQUIRE_PATTERN;
+  const defaultRequirePrefix = /(?:^|[;{}])\s*(?:export\s+)?(?:const|let|var)\s+/;
   for (const match of source.matchAll(defaultRequirePattern)) {
     if (!matchStartsInCode2(maskedSource, match))
       continue;
@@ -45162,43 +45601,53 @@ async function collectCommonJsRequireDeclarations(context, source, maskedSource)
     const moduleSpecifier = match.groups?.module;
     if (!moduleSpecifier)
       continue;
+    const localStart = (match.index ?? 0) + (defaultRequirePrefix.exec(match[0])?.[0].length ?? 0);
+    const localRange = tokenRange(source, lineStarts, localStart, local);
     const resolved = await context.resolveFrom(moduleSpecifier);
     context.pushBinding({
       kind: "default",
       local,
       from: moduleSpecifier,
+      ...localRange ? { localRange } : {},
       resolved,
       mechanism: "cjs"
     });
   }
-  const namedRequirePattern = /(?:^|[;{}])\s*(?:export\s+)?(?:const|let|var)\s*\{([^}]+)\}\s*=\s*require\s*\(\s*(["'])(?<module>[^"']+)\2\s*\)/gm;
-  for (const match of source.matchAll(namedRequirePattern)) {
-    if (!matchStartsInCode2(maskedSource, match))
+  for (const match of maskedSource.matchAll(NAMED_REQUIRE_DECLARATION_PATTERN)) {
+    const openingIndex = (match.index ?? 0) + match[0].lastIndexOf("{");
+    const closingIndex = closingBraceIndex(maskedSource, openingIndex);
+    if (closingIndex < 0)
       continue;
-    const specs = match[1].split(",").map((spec) => spec.trim()).filter(Boolean);
-    const moduleSpecifier = match.groups?.module;
+    const requireMatch = REQUIRE_AFTER_BINDING_PATTERN.exec(source.slice(closingIndex + 1));
+    const moduleSpecifier = requireMatch?.groups?.module;
     if (!moduleSpecifier)
       continue;
+    const namedBlockStart = openingIndex + 1;
     const resolved = await context.resolveFrom(moduleSpecifier);
-    for (const spec of specs) {
-      const namedMatch = spec.match(NAMED_REQUIRE_SPECIFIER_PATTERN);
-      if (!namedMatch)
+    for (const { spec, start } of splitNamedRequireBindingsWithOffsets(source, maskedSource, namedBlockStart, closingIndex)) {
+      const namedRequire = parseNamedRequireSpecifier(spec);
+      if (!namedRequire)
         continue;
-      const imported = namedMatch[1];
-      const local = namedMatch[2] ?? imported;
+      const specStart = namedBlockStart + start;
+      const importedRange = tokenRange(source, lineStarts, specStart + namedRequire.importedOffset, namedRequire.imported);
+      const localRange = tokenRange(source, lineStarts, specStart + namedRequire.localOffset, namedRequire.local);
       context.pushBinding({
         kind: "named",
-        local,
-        imported,
+        local: namedRequire.local,
+        imported: namedRequire.imported,
         from: moduleSpecifier,
+        ...namedRequire.explicitAlias ? { explicitAlias: true } : {},
+        ...importedRange ? { importedRange } : {},
+        ...localRange ? { localRange } : {},
         resolved,
         mechanism: "cjs"
       });
     }
   }
 }
-async function collectCommonJsImportEquals(context, source, maskedSource) {
+async function collectCommonJsImportEquals(context, source, maskedSource, lineStarts) {
   const importEqualsPattern = IMPORT_EQUALS_REQUIRE_PATTERN;
+  const importEqualsPrefix = /(?:^|[;{}])\s*import\s+/;
   for (const match of source.matchAll(importEqualsPattern)) {
     if (!matchStartsInCode2(maskedSource, match))
       continue;
@@ -45206,42 +45655,50 @@ async function collectCommonJsImportEquals(context, source, maskedSource) {
     const moduleSpecifier = match.groups?.module;
     if (!moduleSpecifier)
       continue;
+    const localStart = (match.index ?? 0) + (importEqualsPrefix.exec(match[0])?.[0].length ?? 0);
+    const localRange = tokenRange(source, lineStarts, localStart, local);
     const resolved = await context.resolveFrom(moduleSpecifier);
     context.pushBinding({
       kind: "default",
       local,
       from: moduleSpecifier,
+      ...localRange ? { localRange } : {},
       resolved,
       mechanism: "cjs"
     });
   }
 }
-async function collectCommonJsImports(context, source, maskedSource) {
-  await collectCommonJsRequireDeclarations(context, source, maskedSource);
-  await collectCommonJsImportEquals(context, source, maskedSource);
+async function collectCommonJsImports(context, source, maskedSource, lineStarts) {
+  await collectCommonJsRequireDeclarations(context, source, maskedSource, lineStarts);
+  await collectCommonJsImportEquals(context, source, maskedSource, lineStarts);
 }
 async function collectJsTextValueRequireImports(context) {
   const source = sourceForTextImportExtraction(context);
-  await collectCommonJsRequireDeclarations(context, source, maskJsLikeCommentsStringsAndRegex(source));
+  const lineStarts = collectLineStartOffsets(source);
+  await collectCommonJsRequireDeclarations(context, source, maskJsLikeCommentsStringsAndRegex(source), lineStarts);
 }
 async function collectJsTextImports(context) {
   const source = sourceForTextImportExtraction(context);
   const maskedSource = maskJsLikeCommentsStringsAndRegex(source);
-  await collectEsImports(context, source, maskedSource);
-  await collectCommonJsImports(context, source, maskedSource);
+  const lineStarts = collectLineStartOffsets(source);
+  await collectEsImports(context, source, maskedSource, lineStarts);
+  await collectCommonJsImports(context, source, maskedSource, lineStarts);
 }
-var TYPE_NAMED_IMPORT_SPECIFIER_PATTERN, NAMED_IMPORT_SPECIFIER_PATTERN, NAMESPACE_IMPORT_PATTERN, DEFAULT_REQUIRE_PATTERN, NAMED_REQUIRE_SPECIFIER_PATTERN, IMPORT_EQUALS_REQUIRE_PATTERN;
+var TYPE_NAMED_IMPORT_SPECIFIER_PATTERN, NAMED_IMPORT_SPECIFIER_PATTERN, NAMESPACE_IMPORT_PATTERN, DEFAULT_REQUIRE_PATTERN, NAMED_REQUIRE_SPECIFIER_PATTERN, IMPORT_EQUALS_REQUIRE_PATTERN, NAMED_REQUIRE_DECLARATION_PATTERN, REQUIRE_AFTER_BINDING_PATTERN;
 var init_js_text_imports = __esm({
   "dist/indexer/imports/js-text-imports.js"() {
     "use strict";
     init_comments();
     init_identifiers();
+    init_lines();
     TYPE_NAMED_IMPORT_SPECIFIER_PATTERN = new RegExp(String.raw`^type\s+(${ECMASCRIPT_IDENTIFIER_SOURCE})(?:\s+as\s+(${ECMASCRIPT_IDENTIFIER_SOURCE}))?$`, "u");
     NAMED_IMPORT_SPECIFIER_PATTERN = new RegExp(String.raw`^(${ECMASCRIPT_IDENTIFIER_SOURCE})(?:\s+as\s+(${ECMASCRIPT_IDENTIFIER_SOURCE}))?$`, "u");
     NAMESPACE_IMPORT_PATTERN = new RegExp(String.raw`^\*\s+as\s+(${ECMASCRIPT_IDENTIFIER_SOURCE})$`, "u");
     DEFAULT_REQUIRE_PATTERN = new RegExp(String.raw`(?:^|[;{}])\s*(?:export\s+)?(?:const|let|var)\s+(${ECMASCRIPT_IDENTIFIER_SOURCE})\s*=\s*require\s*\(\s*(["'])(?<module>[^"']+)\2\s*\)`, "gmu");
     NAMED_REQUIRE_SPECIFIER_PATTERN = new RegExp(String.raw`^(${ECMASCRIPT_IDENTIFIER_SOURCE})(?::\s*(${ECMASCRIPT_IDENTIFIER_SOURCE}))?$`, "u");
     IMPORT_EQUALS_REQUIRE_PATTERN = new RegExp(String.raw`(?:^|[;{}])\s*import\s+(${ECMASCRIPT_IDENTIFIER_SOURCE})\s*=\s*require\s*\(\s*(["'])(?<module>[^"']+)\2\s*\)`, "gmu");
+    NAMED_REQUIRE_DECLARATION_PATTERN = /(?:^|[;{}])\s*(?:export\s+)?(?:const|let|var)\s*\{/gmu;
+    REQUIRE_AFTER_BINDING_PATTERN = /^\s*=\s*require\s*\(\s*(["'])(?<module>[^"']+)\1\s*\)/u;
   }
 });
 
@@ -45325,27 +45782,40 @@ async function appendJavaTextImports(context) {
       continue;
     const fromValue = isStatic ? parts.slice(0, -1).join(".") : rawSpec;
     const resolved = await context.resolveFrom(fromValue);
-    context.pushBinding({
+    const namedBinding = {
       kind: "named",
       local: imported,
       imported,
       from: fromValue,
       resolved,
       typeOnly: false
-    });
+    };
+    if (match.index !== void 0) {
+      attributeNamedBindingRanges({
+        bindings: [namedBinding],
+        fromIndex: 0,
+        text: maskImportBindingTrivia(match[0], context.languageId),
+        textStartIndex: match.index,
+        source: context.source
+      });
+    }
+    context.pushBinding(namedBinding);
   }
 }
 async function appendKotlinTextImports(context) {
   if (context.languageId !== "kotlin" || context.getBindings().length) {
     return;
   }
-  const importPattern = new RegExp(String.raw`^\s*import\s+(${KOTLIN_DOTTED_NAME_SOURCE}(?:\.\*)?)(?:\s+as\s+(${KOTLIN_IDENTIFIER_SOURCE}))?\s*;?\s*$`, "gmu");
-  for (const match of context.source.matchAll(importPattern)) {
+  const dottedNameWithTrivia = String.raw`${KOTLIN_IDENTIFIER_SOURCE}(?:\s*\.\s*${KOTLIN_IDENTIFIER_SOURCE})*`;
+  const importPattern = new RegExp(String.raw`^\s*import\s+(${dottedNameWithTrivia}(?:\s*\.\s*\*)?)(?:\s+as\s+(${KOTLIN_IDENTIFIER_SOURCE}))?\s*;?\s*$`, "gmu");
+  const maskedSource = maskImportBindingTrivia(context.source, context.languageId);
+  for (const match of maskedSource.matchAll(importPattern)) {
     const rawSpec = match[1];
     if (!rawSpec)
       continue;
-    if (rawSpec.endsWith(".*")) {
-      const fromValue = rawSpec.slice(0, -2);
+    const normalizedSpec = rawSpec.replace(/\s+/gu, "");
+    if (normalizedSpec.endsWith(".*")) {
+      const fromValue = normalizedSpec.slice(0, -2);
       const resolved2 = await context.resolveFrom(fromValue);
       context.pushBinding({
         kind: "star",
@@ -45355,19 +45825,30 @@ async function appendKotlinTextImports(context) {
       });
       continue;
     }
-    const parts = rawSpec.split(".");
+    const parts = normalizedSpec.split(".");
     const imported = parts[parts.length - 1];
     if (!imported)
       continue;
-    const resolved = await context.resolveFrom(rawSpec);
-    context.pushBinding({
+    const resolved = await context.resolveFrom(normalizedSpec);
+    const namedBinding = {
       kind: "named",
       local: match[2] ?? imported,
       imported,
-      from: rawSpec,
+      from: normalizedSpec,
+      ...match[2] !== void 0 ? { explicitAlias: true } : {},
       resolved,
       typeOnly: false
-    });
+    };
+    if (match.index !== void 0) {
+      attributeNamedBindingRanges({
+        bindings: [namedBinding],
+        fromIndex: 0,
+        text: maskImportBindingTrivia(match[0], context.languageId),
+        textStartIndex: match.index,
+        source: context.source
+      });
+    }
+    context.pushBinding(namedBinding);
   }
 }
 async function appendPhpComposerImplicitImports(context) {
@@ -45411,6 +45892,7 @@ function pushCsharpOverride(context, parsed, typeOnly, fromValue, resolved) {
       local: parsed.alias,
       imported,
       from: fromValue,
+      explicitAlias: true,
       resolved,
       typeOnly
     });
@@ -45481,6 +45963,7 @@ async function pushJvmImportBinding(context, parsed, local, typeOnly) {
     local: local ?? parsed.imported,
     imported: parsed.imported,
     from: parsed.from,
+    ...parsed.explicitAlias ? { explicitAlias: true } : {},
     resolved,
     typeOnly
   });
@@ -45588,7 +46071,15 @@ function scanRustImportStatements(sourceText) {
 }
 function buildRustBinding(parsed, resolved, typeOnly) {
   if (parsed.kind === "member") {
-    return { kind: "named", local: parsed.local, imported: parsed.imported, from: parsed.from, resolved, typeOnly };
+    return {
+      kind: "named",
+      local: parsed.local,
+      imported: parsed.imported,
+      from: parsed.from,
+      ...parsed.explicitAlias ? { explicitAlias: true } : {},
+      resolved,
+      typeOnly
+    };
   }
   if (parsed.kind === "module") {
     return { kind: "namespace", localNS: parsed.local, from: parsed.from, resolved, typeOnly };
@@ -45621,7 +46112,15 @@ async function appendRustTextImports(context) {
     const parsedList = parseRustImportStatements(statement.text);
     if (!parsedList.length)
       continue;
+    const bindingCountBefore = context.getBindings().length;
     await pushParsedRustImports(context, parsedList, false, statement.start, seen);
+    attributeNamedBindingRanges({
+      bindings: context.getBindings(),
+      fromIndex: bindingCountBefore,
+      text: maskImportBindingTrivia(statement.text, context.languageId),
+      textStartIndex: statement.start,
+      source: context.source
+    });
   }
 }
 function isRustTestOnlyStatement(context, normalizedStmt, statementStartIndex) {
@@ -45681,6 +46180,7 @@ async function applyPhpStatementOverride(context, normalizedStmt, typeOnly) {
       local: entry.local,
       imported: entry.imported,
       from: entry.from,
+      ...entry.explicitAlias ? { explicitAlias: true } : {},
       phpImportType: entry.importType,
       resolved,
       typeOnly,
@@ -45696,17 +46196,25 @@ async function applyStatementImportOverride(context, state, stmtText, typeOnly,
   const statementKey = statementImportOverrideKey(context.languageId, normalizedStmt, statementStartIndex);
   if (state.handledStatements.has(statementKey))
     return true;
+  let parserStmt = normalizedStmt;
+  const canMaskStrings = context.languageId !== "rust" && (context.languageId !== "php" || /^\s*use\b/i.test(normalizedStmt));
+  if (canMaskStrings) {
+    parserStmt = maskImportBindingTrivia(normalizedStmt, context.languageId);
+    if (context.languageId === "csharp" || context.languageId === "java" || context.languageId === "kotlin") {
+      parserStmt = parserStmt.replace(/\s*\.\s*/gu, ".");
+    }
+  }
   let handled = false;
   if (context.languageId === "csharp") {
-    handled = await applyCsharpStatementOverride(context, normalizedStmt, typeOnly);
+    handled = await applyCsharpStatementOverride(context, parserStmt, typeOnly);
   } else if (context.languageId === "java") {
-    handled = await applyJavaStatementOverride(context, normalizedStmt, typeOnly);
+    handled = await applyJavaStatementOverride(context, parserStmt, typeOnly);
   } else if (context.languageId === "kotlin") {
-    handled = await applyKotlinStatementOverride(context, normalizedStmt, typeOnly);
+    handled = await applyKotlinStatementOverride(context, parserStmt, typeOnly);
   } else if (context.languageId === "rust") {
     handled = await applyRustStatementOverride(context, normalizedStmt, typeOnly, statementStartIndex);
   } else if (context.languageId === "php") {
-    handled = await applyPhpStatementOverride(context, normalizedStmt, typeOnly);
+    handled = await applyPhpStatementOverride(context, parserStmt, typeOnly);
   }
   if (!handled)
     return false;
@@ -45720,20 +46228,21 @@ function statementImportOverrideKey(languageId, normalizedStmt, statementStartIn
   return normalizedStmt;
 }
 function appendImplicitImportBinding(context, args) {
-  const { from, resolved, typeOnly, stmtText, alias, wildcard } = args;
+  const { from, resolved, typeOnly, stmtText, stmtStartIndex, source, alias, wildcard } = args;
+  const pushNamed = (binding, alwaysAliased) => pushNamedImplicitBinding(context, binding, stmtText, stmtStartIndex, source, alwaysAliased);
   if (context.languageId === "java") {
     const parts = from.split(".");
     const last = parts[parts.length - 1];
     if (last === "*") {
       context.pushBinding({ kind: "star", from, resolved, typeOnly });
     } else if (last) {
-      context.pushBinding({ kind: "named", local: last, imported: last, from, resolved, typeOnly });
+      pushNamed({ kind: "named", local: last, imported: last, from, resolved, typeOnly });
     }
   } else if (context.languageId === "csharp") {
     if (alias) {
       const fromParts = from.split(".");
       const imported = fromParts[fromParts.length - 1] ?? alias;
-      context.pushBinding({ kind: "named", local: alias, imported, from, resolved, typeOnly });
+      pushNamed({ kind: "named", local: alias, imported, from, explicitAlias: true, resolved, typeOnly }, true);
     } else {
       context.pushBinding({ kind: "star", from, resolved, typeOnly });
     }
@@ -45766,7 +46275,7 @@ function appendImplicitImportBinding(context, args) {
       if (last === "*") {
         context.pushBinding({ kind: "star", from, resolved });
       } else {
-        context.pushBinding({ kind: "named", local: last, imported: last, from, resolved });
+        pushNamed({ kind: "named", local: last, imported: last, from, resolved });
       }
     }
   } else if (context.languageId === "kotlin") {
@@ -45776,7 +46285,15 @@ function appendImplicitImportBinding(context, args) {
       const parts = from.split(".");
       const imported = parts[parts.length - 1];
       if (imported)
-        context.pushBinding({ kind: "named", local: alias ?? imported, imported, from, resolved, typeOnly });
+        pushNamed({
+          kind: "named",
+          local: alias ?? imported,
+          imported,
+          from,
+          ...alias !== void 0 ? { explicitAlias: true } : {},
+          resolved,
+          typeOnly
+        });
     }
   } else if (context.languageId === "swift") {
     const parts = from.split(".");
@@ -45787,7 +46304,7 @@ function appendImplicitImportBinding(context, args) {
       context.pushBinding({ kind: "namespace", localNS: last, from, resolved, typeOnly });
       context.pushBinding({ kind: "star", from, resolved, typeOnly });
     } else {
-      context.pushBinding({ kind: "named", local: last, imported: last, from, resolved, typeOnly });
+      pushNamed({ kind: "named", local: last, imported: last, from, resolved, typeOnly });
     }
   } else if (context.languageId === "zig") {
     if (alias)
@@ -45796,6 +46313,19 @@ function appendImplicitImportBinding(context, args) {
     context.pushBinding({ kind: "star", from, resolved, typeOnly });
   }
 }
+function pushNamedImplicitBinding(context, binding, stmtText, stmtStartIndex, source, alwaysAliased) {
+  if (stmtStartIndex !== void 0 && source !== void 0) {
+    attributeNamedBindingRanges({
+      bindings: [binding],
+      fromIndex: 0,
+      text: maskImportBindingTrivia(stmtText, context.languageId),
+      textStartIndex: stmtStartIndex,
+      source,
+      ...alwaysAliased !== void 0 ? { alwaysAliased } : {}
+    });
+  }
+  context.pushBinding(binding);
+}
 var RUST_IMPORT_KEYWORD_PATTERN;
 var init_language_specific = __esm({
   "dist/indexer/imports/language-specific.js"() {
@@ -45805,6 +46335,7 @@ var init_language_specific = __esm({
     init_rust_test_modules();
     init_resolution();
     init_rust2();
+    init_binding_ranges();
     RUST_IMPORT_KEYWORD_PATTERN = /^(?:pub(?:\s*\([^)]*\))?\s+)?(use|extern\s+crate|mod)\b/;
   }
 });
@@ -45912,45 +46443,51 @@ var init_shared2 = __esm({
 
 // dist/indexer/imports/native-captures.js
 function parseObjectPatternBindings(patternText) {
-  const trimmed = patternText.trim();
-  if (!trimmed.startsWith("{") || !trimmed.endsWith("}"))
-    return [];
-  const body = trimmed.slice(1, -1).trim();
-  if (!body)
+  const maskedPatternText = maskJsLikeCommentsStringsAndRegex(patternText);
+  const openBrace = maskedPatternText.indexOf("{");
+  const closeBrace = maskedPatternText.lastIndexOf("}");
+  if (openBrace < 0 || closeBrace <= openBrace)
     return [];
-  const parts = body.split(",").map((part) => part.trim()).filter(Boolean);
+  const bodyStart = openBrace + 1;
   const out = [];
-  for (const part of parts) {
-    const withoutDefault = part.replace(/\s*=\s*.+$/, "").trim();
+  for (const { spec, start } of splitNamedRequireBindingsWithOffsets(maskedPatternText, maskedPatternText, bodyStart, closeBrace)) {
+    const specStart = bodyStart + start;
+    const withoutDefault = spec.replace(/\s*=\s*[\s\S]*$/u, "").trim();
     const match = withoutDefault.match(OBJECT_PATTERN_BINDING_PATTERN);
     if (!match)
       continue;
     const imported = match[1];
     const local = match[2] ?? imported;
-    out.push({ imported, local });
+    const importedOffset = specStart + withoutDefault.indexOf(imported);
+    const localOffset = match[2] === void 0 ? importedOffset : specStart + withoutDefault.lastIndexOf(local);
+    out.push({ imported, local, importedOffset, localOffset, explicitAlias: match[2] !== void 0 });
   }
   return out;
 }
-async function pushTextObjectPatternBindings(context, patterns, from, typeOnly) {
+async function pushTextObjectPatternBindings(context, patterns, from, typeOnly, byteIndexMap, lineStarts) {
   if (!from)
     return;
   for (const pattern of patterns) {
     if (pattern.nodeType !== "object_pattern")
       continue;
     const resolved = await context.resolveFrom(from);
-    for (const binding of parseObjectPatternBindings(pattern.text)) {
-      context.pushBinding({
-        kind: "named",
-        local: binding.local,
-        imported: binding.imported,
-        from,
-        resolved,
-        typeOnly
-      });
-    }
+    const patternStartIndex = stringIndexForByte(byteIndexMap, pattern.start.index);
+    const patternBindings = parseObjectPatternBindings(pattern.text).map((binding) => ({
+      kind: "named",
+      local: binding.local,
+      imported: binding.imported,
+      from,
+      ...binding.explicitAlias ? { explicitAlias: true } : {},
+      importedRange: sourceRangeFromOffsets(lineStarts, patternStartIndex + binding.importedOffset, patternStartIndex + binding.importedOffset + binding.imported.length),
+      localRange: sourceRangeFromOffsets(lineStarts, patternStartIndex + binding.localOffset, patternStartIndex + binding.localOffset + binding.local.length),
+      resolved,
+      typeOnly
+    }));
+    for (const binding of patternBindings)
+      context.pushBinding(binding);
   }
 }
-function pushNamespaceBinding(context, caps, stmtText, from, resolved, typeOnly) {
+function pushNamespaceBinding(context, caps, stmtText, from, resolved, typeOnly, byteIndexMap) {
   const namespaceCapture = caps["ns"];
   if (!namespaceCapture)
     return;
@@ -45978,11 +46515,12 @@ function pushNamespaceBinding(context, caps, stmtText, from, resolved, typeOnly)
     kind: "namespace",
     localNS: namespaceCapture.text,
     from,
+    localRange: rangeFromNativeCapture(namespaceCapture, byteIndexMap),
     resolved,
     typeOnly
   });
 }
-async function pushStandardBindings(context, match, caps, stmtText, from, patternCount, typeOnly) {
+async function pushStandardBindings(context, match, caps, stmtText, from, patternCount, typeOnly, byteIndexMap, statementStartIndex) {
   if (!from)
     return;
   const resolved = await context.resolveFrom(from);
@@ -45992,21 +46530,27 @@ async function pushStandardBindings(context, match, caps, stmtText, from, patter
       kind: "default",
       local: defaultCapture.text,
       from,
+      localRange: rangeFromNativeCapture(defaultCapture, byteIndexMap),
       resolved,
       typeOnly
     });
   }
-  pushNamespaceBinding(context, caps, stmtText, from, resolved, typeOnly);
+  pushNamespaceBinding(context, caps, stmtText, from, resolved, typeOnly, byteIndexMap);
   const inames = capturesNamed(match, "iname");
   const aliases = capturesNamed(match, "alias");
   for (let i = 0; i < inames.length; i++) {
     const imported = inames[i].text;
-    const alias = aliases[i]?.text ?? imported;
+    const importedRange = rangeFromNativeCapture(inames[i], byteIndexMap);
+    const aliasCapture = aliases[i];
+    const alias = aliasCapture?.text ?? imported;
     context.pushBinding({
       kind: "named",
       local: alias,
       imported,
       from,
+      ...aliasCapture ? { explicitAlias: true } : {},
+      importedRange,
+      localRange: aliasCapture ? rangeFromNativeCapture(aliasCapture, byteIndexMap) : importedRange,
       resolved,
       typeOnly
     });
@@ -46017,12 +46561,15 @@ async function pushStandardBindings(context, match, caps, stmtText, from, patter
       resolved,
       typeOnly,
       stmtText,
+      ...statementStartIndex !== void 0 ? { stmtStartIndex: statementStartIndex, source: context.source } : {},
       ...caps["alias"]?.text ? { alias: caps["alias"].text } : {},
       ...caps["wild"] ? { wildcard: true } : {}
     });
   }
 }
 async function collectNativeCaptureImportBindings(context, matches) {
+  const byteIndexMap = buildByteToStringIndexMap(context.source);
+  let lineStarts;
   for (const match of matches) {
     const caps = capturesByName(match);
     const statementCapture = caps["stmt"];
@@ -46035,20 +46582,29 @@ async function collectNativeCaptureImportBindings(context, matches) {
     }
     const from = caps["from"] ? unquote(caps["from"].text) : void 0;
     const patterns = capturesNamed(match, "pattern");
-    await pushTextObjectPatternBindings(context, patterns, from, statementTypeOnly);
-    await pushStandardBindings(context, match, caps, stmtText, from, patterns.length, typeOnly);
+    if (patterns.length) {
+      const rangeLineStarts = lineStarts ?? collectLineStartOffsets(context.source);
+      lineStarts = rangeLineStarts;
+      await pushTextObjectPatternBindings(context, patterns, from, statementTypeOnly, byteIndexMap, rangeLineStarts);
+    }
+    await pushStandardBindings(context, match, caps, stmtText, from, patterns.length, typeOnly, byteIndexMap, statementStartIndex);
   }
 }
 var OBJECT_PATTERN_BINDING_PATTERN;
 var init_native_captures = __esm({
   "dist/indexer/imports/native-captures.js"() {
     "use strict";
+    init_byte_index();
     init_query_results();
     init_ast();
+    init_comments();
     init_identifiers();
+    init_lines();
     init_rust_test_modules();
     init_shared2();
+    init_binding_ranges();
     init_language_specific();
+    init_js_text_imports();
     OBJECT_PATTERN_BINDING_PATTERN = new RegExp(String.raw`^(${ECMASCRIPT_IDENTIFIER_SOURCE})(?::\s*(${ECMASCRIPT_IDENTIFIER_SOURCE}))?$`, "u");
   }
 });
@@ -46105,7 +46661,7 @@ async function pushStarImport(context, moduleSpec, moduleLevel) {
     moduleLevel
   });
 }
-async function pushNamedImport(context, moduleSpec, imported, local, moduleLevel) {
+async function pushNamedImport(context, moduleSpec, imported, local, moduleLevel, explicitAlias) {
   const { relDots, mod } = splitRelativeModuleSpec(moduleSpec);
   const resolved = await resolvePythonModule(context.projectRoot, context.file, mod, relDots);
   const namespaceResolved = resolvePythonNamespaceMember(resolved, imported);
@@ -46125,6 +46681,7 @@ async function pushNamedImport(context, moduleSpec, imported, local, moduleLevel
     local,
     imported,
     from: moduleSpec,
+    ...explicitAlias ? { explicitAlias: true } : {},
     resolved,
     mechanism: "python",
     moduleLevel
@@ -46167,20 +46724,21 @@ function isPythonModuleLevelImportPrefix(prefix) {
     return false;
   return true;
 }
-function isModuleLevelKeywordInStrippedSource(strippedSrc, keywordStart) {
-  const lineStart = strippedSrc.lastIndexOf("\n", keywordStart - 1) + 1;
-  return isPythonModuleLevelImportPrefix(strippedSrc.slice(lineStart, keywordStart));
+function isModuleLevelKeywordInStrippedSource(maskedSrc, keywordStart) {
+  const lineStart = maskedSrc.lastIndexOf("\n", keywordStart - 1) + 1;
+  return isPythonModuleLevelImportPrefix(maskedSrc.slice(lineStart, keywordStart));
 }
 function normalizePythonImportStatement(statement) {
   return stripPythonCommentsAndStrings(statement).replace(/\\\r?\n[\t ]*/g, " ").trim();
 }
-async function collectPythonImportStatement(context, statement, moduleLevel) {
+async function collectPythonImportStatement(context, statement, moduleLevel, statementStartIndex) {
   const normalized = normalizePythonImportStatement(statement);
   const fromMatch = normalized.match(/^from\s+([^\s]+)\s+import\s+([\s\S]+)$/u);
   if (fromMatch) {
     const moduleSpec = fromMatch[1];
     const importedList = fromMatch[2].trim().replace(/^\(\s*|\s*\)$/g, "");
-    for (const item of importedList.split(",").map((entry) => entry.trim()).filter(Boolean)) {
+    const bindingCountBefore = context.getBindings().length;
+    for (const item of maskPythonCommentsAndStrings(importedList).replace(/^\(\s*|\s*\)$/g, "").split(",").map((x) => x.trim()).filter(Boolean)) {
       if (item === "*") {
         await pushStarImport(context, moduleSpec, moduleLevel);
         continue;
@@ -46189,7 +46747,17 @@ async function collectPythonImportStatement(context, statement, moduleLevel) {
       if (!aliasMatch)
         continue;
       const imported = aliasMatch[1];
-      await pushNamedImport(context, moduleSpec, imported, aliasMatch[2] ?? imported, moduleLevel);
+      await pushNamedImport(context, moduleSpec, imported, aliasMatch[2] ?? imported, moduleLevel, aliasMatch[2] !== void 0);
+    }
+    if (statementStartIndex !== void 0) {
+      const searchText = maskPythonCommentsAndStrings(statement);
+      attributeNamedBindingRanges({
+        bindings: context.getBindings(),
+        fromIndex: bindingCountBefore,
+        text: searchText,
+        textStartIndex: statementStartIndex,
+        source: context.source
+      });
     }
     return true;
   }
@@ -46214,17 +46782,20 @@ async function collectPythonImportsFromNativeMatches(context, matches) {
     const lineStart = context.source.lastIndexOf("\n", startIndex - 1) + 1;
     const prefix = context.source.slice(lineStart, startIndex);
     const moduleLevel = isPythonModuleLevelImportPrefix(prefix);
-    await collectPythonImportStatement(context, statementCapture.text, moduleLevel);
+    await collectPythonImportStatement(context, statementCapture.text, moduleLevel, startIndex);
   }
 }
 async function collectPythonImportsFromSource(context) {
-  const pySrc = stripPythonCommentsAndStrings(context.source);
-  const fromLinePattern = /(^[\t ]*|;[\t ]*)from\s+([^\s]+)\s+import\s+([^\n;#]+)/gm;
+  const pySrc = maskPythonCommentsAndStrings(context.source);
+  const fromLinePattern = /(^[\t ]*|;[\t ]*)from\s+([^\s]+)\s+import\s+(\([\s\S]*?\)|[^\n;#]+)/gm;
   for (const match of pySrc.matchAll(fromLinePattern)) {
     const keywordStart = match.index + match[1].length;
     const mod = match[2].trim();
     const moduleLevel = isModuleLevelKeywordInStrippedSource(pySrc, keywordStart);
-    const items = match[3].split(",").map((item) => item.trim());
+    const listText = match[3];
+    const bindingListText = maskPythonCommentsAndStrings(listText);
+    const bindingCountBefore = context.getBindings().length;
+    const items = bindingListText.replace(/^\(\s*|\s*\)$/g, "").split(",").map((item) => item.trim());
     for (const item of items) {
       if (item === "*") {
         await pushStarImport(context, mod, moduleLevel);
@@ -46235,8 +46806,16 @@ async function collectPythonImportsFromSource(context) {
         continue;
       const imported = aliasMatch[1];
       const local = aliasMatch[2] ?? imported;
-      await pushNamedImport(context, mod, imported, local, moduleLevel);
+      await pushNamedImport(context, mod, imported, local, moduleLevel, aliasMatch[2] !== void 0);
     }
+    const listStart = match.index + match[0].length - listText.length;
+    attributeNamedBindingRanges({
+      bindings: context.getBindings(),
+      fromIndex: bindingCountBefore,
+      text: listText,
+      textStartIndex: listStart,
+      source: context.source
+    });
   }
   const importPattern = PYTHON_MODULE_IMPORT_PATTERN;
   for (const match of pySrc.matchAll(importPattern)) {
@@ -46255,6 +46834,7 @@ var init_python3 = __esm({
     init_comments();
     init_identifiers();
     init_rust_test_modules();
+    init_binding_ranges();
     PYTHON_NAMED_IMPORT_PATTERN = new RegExp(String.raw`^(${PYTHON_IDENTIFIER_SOURCE})(?:\s+as\s+(${PYTHON_IDENTIFIER_SOURCE}))?$`, "u");
     PYTHON_MODULE_IMPORT_PATTERN = new RegExp(String.raw`(^[\t ]*|;[\t ]*)import\s+(${PYTHON_IDENTIFIER_SOURCE}(?:\.${PYTHON_IDENTIFIER_SOURCE})*)\s*(?:as\s+(${PYTHON_IDENTIFIER_SOURCE}))?`, "gmu");
     PYTHON_MODULE_LIST_ITEM_PATTERN = new RegExp(String.raw`^(${PYTHON_IDENTIFIER_SOURCE}(?:\.${PYTHON_IDENTIFIER_SOURCE})*)(?:\s+as\s+(${PYTHON_IDENTIFIER_SOURCE}))?$`, "u");
@@ -46304,7 +46884,8 @@ async function collectImportsForFile(file2, projectRoot, opts) {
       file: file2,
       projectRoot,
       source: resolvedSource,
-      pushBinding: (binding) => imports.push(binding)
+      pushBinding: (binding) => imports.push(binding),
+      getBindings: () => imports
     };
     if (resolvedNativeQueries) {
       await collectPythonImportsFromNativeMatches(context, resolvedNativeQueries.importBindings);
@@ -46358,7 +46939,19 @@ async function collectImportsForFile(file2, projectRoot, opts) {
     await finalizeLanguageSpecificImports(languageContext);
   };
   const applyStatementOverride = async (stmtText, typeOnly, statementStartIndex) => {
-    return await applyStatementImportOverride(languageContext, statementOverrideState, stmtText, typeOnly, statementStartIndex);
+    const bindingCountBefore = imports.length;
+    const handled = await applyStatementImportOverride(languageContext, statementOverrideState, stmtText, typeOnly, statementStartIndex);
+    if (handled && statementStartIndex !== void 0) {
+      attributeNamedBindingRanges({
+        bindings: imports,
+        fromIndex: bindingCountBefore,
+        text: maskImportBindingTrivia(stmtText, resolvedSup.id),
+        textStartIndex: statementStartIndex,
+        source: resolvedSource,
+        alwaysAliased: resolvedSup.id === "csharp"
+      });
+    }
+    return handled;
   };
   const runFallback = async () => {
     await collectJsTextImports({
@@ -46443,6 +47036,7 @@ var init_imports = __esm({
     init_document_links();
     init_comments();
     init_tree_sitter_native();
+    init_binding_ranges();
     init_graph_only();
     init_js_text_imports();
     init_language_specific();
@@ -46734,6 +47328,13 @@ function buildScopeIndexFromSource(file2, source, support, imports = [], opts) {
         addPatternDecls(left, "local", addBindingToScope);
       return;
     }
+    if (support.id === "zig" && node.type === "variable_declaration") {
+      const name = node.namedChildren.find((child) => child.type === "identifier");
+      const isImportDeclaration = name !== void 0 && hasImportBinding(name) && /@(?:import|cImport)\s*\(/.test(sliceText(node, source));
+      if (name && !isImportDeclaration)
+        addBindingToScope(name, "local");
+      return;
+    }
     for (const child of node.namedChildren) {
       if (child.type === "variable_declarator" || child.type === "var_spec" || child.type === "const_spec") {
         const name = child.childForFieldName("name");
@@ -46822,6 +47423,13 @@ function buildScopeIndexFromSource(file2, source, support, imports = [], opts) {
           extraBindings.push(buildBinding(name, "local"));
       }
     }
+    if (node.type === "enum_assignment") {
+      const name = node.childForFieldName("name");
+      if (name)
+        addDecl(name, "local");
+    } else if (node.type === "property_identifier" && node.parent?.type === "enum_body") {
+      addDecl(node, "local");
+    }
     let pushed = false;
     if (support.createsFunctionScope(node)) {
       const scope = {
@@ -51384,8 +51992,8 @@ var init_options2 = __esm({
     init_project_files();
     init_tree_sitter_native();
     init_languages();
-    CORE_ALGORITHM_EPOCH = 12;
-    LANGUAGE_BEHAVIOR_EPOCH = 3;
+    CORE_ALGORITHM_EPOCH = 18;
+    LANGUAGE_BEHAVIOR_EPOCH = 6;
   }
 });
 
@@ -51671,7 +52279,28 @@ function isModuleIndex(value) {
   if (!value || typeof value !== "object")
     return false;
   const mod = value;
-  return typeof mod.file === "string" && Array.isArray(mod.exports) && Array.isArray(mod.imports) && Array.isArray(mod.locals);
+  return typeof mod.file === "string" && Array.isArray(mod.exports) && Array.isArray(mod.imports) && mod.imports.every(hasValidImportBindingRanges) && Array.isArray(mod.locals);
+}
+function hasValidImportBindingRanges(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const binding = value;
+  return (binding.explicitAlias === void 0 || typeof binding.explicitAlias === "boolean") && isOptionalRange(binding.importedRange) && isOptionalRange(binding.localRange);
+}
+function isOptionalRange(value) {
+  return value === void 0 || isRange(value);
+}
+function isRange(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const range = value;
+  return isPos(range.start) && isPos(range.end);
+}
+function isPos(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const pos = value;
+  return typeof pos.line === "number" && typeof pos.column === "number" && (pos.index === void 0 || typeof pos.index === "number");
 }
 function transformPersistedExportFromModule(projectRoot, entry, toRelative) {
   if (toRelative) {
@@ -56033,13 +56662,53 @@ function transformModule(root, module2, toRelative) {
     }))
   };
 }
+function transformSnapshotAnalysisReport(root, persistedProjectRoot, report, toRelative) {
+  const reportFile = (file2) => {
+    if (file2 === "unknown")
+      return file2;
+    if (!toRelative && path44.isAbsolute(file2) && !isFilePathWithinRoot(root, file2) && isFilePathWithinRoot(persistedProjectRoot, file2)) {
+      return transformPath(root, cacheRelativePath(persistedProjectRoot, file2), false);
+    }
+    return transformPath(root, file2, toRelative);
+  };
+  const transformed = {};
+  if (report.backend) {
+    const backend = {
+      ...report.backend,
+      native: {
+        ...report.backend.native,
+        errors: report.backend.native.errors.map((error51) => ({ ...error51, file: reportFile(error51.file) }))
+      }
+    };
+    if (report.backend.parser) {
+      backend.parser = {
+        ...report.backend.parser,
+        files: report.backend.parser.files.map((entry) => ({
+          ...entry,
+          file: reportFile(entry.file)
+        }))
+      };
+    }
+    transformed.backend = backend;
+  }
+  if (report.graph) {
+    transformed.graph = {
+      ...report.graph,
+      fallbackImportExtraction: {
+        ...report.graph.fallbackImportExtraction,
+        files: Object.fromEntries(Object.entries(report.graph.fallbackImportExtraction.files).map(([file2, entry]) => [reportFile(file2), entry]))
+      }
+    };
+  }
+  return transformed;
+}
 function transformSnapshotPaths(payload, root, toRelative) {
   const bloomFilters = payload.bloomFilters ? Object.fromEntries(Object.entries(payload.bloomFilters).map(([file2, filter]) => [transformPath(root, file2, toRelative), filter])) : void 0;
   const fileSignatures = Object.fromEntries(Object.entries(payload.fileSignatures ?? {}).map(([file2, signature]) => [
     transformPath(root, file2, toRelative),
     signature
   ]));
-  return {
+  const transformed = {
     ...payload,
     graph: {
       nodes: payload.graph.nodes.map((node) => transformPath(root, node, toRelative)),
@@ -56060,6 +56729,10 @@ function transformSnapshotPaths(payload, root, toRelative) {
     ...bloomFilters ? { bloomFilters } : {},
     fileSignatures
   };
+  if (payload.analysisReport) {
+    transformed.analysisReport = transformSnapshotAnalysisReport(root, payload.projectRoot, payload.analysisReport, toRelative);
+  }
+  return transformed;
 }
 function migrateProjectSnapshotPayload(value, currentRoot) {
   if (!value || typeof value !== "object" || Array.isArray(value))
@@ -57046,7 +57719,7 @@ function isSymbolDef(value) {
   if (!value || typeof value !== "object")
     return false;
   const symbol2 = value;
-  return typeof symbol2.file === "string" && typeof symbol2.localName === "string" && isSymbolKind(symbol2.kind) && isRange(symbol2.range) && (symbol2.docstring === void 0 || typeof symbol2.docstring === "string") && (symbol2.lineSpan === void 0 || typeof symbol2.lineSpan === "number") && (symbol2.complexity === void 0 || typeof symbol2.complexity === "number");
+  return typeof symbol2.file === "string" && typeof symbol2.localName === "string" && isSymbolKind(symbol2.kind) && isRange2(symbol2.range) && (symbol2.docstring === void 0 || typeof symbol2.docstring === "string") && (symbol2.lineSpan === void 0 || typeof symbol2.lineSpan === "number") && (symbol2.complexity === void 0 || typeof symbol2.complexity === "number");
 }
 function isImportBinding(value) {
   if (!value || typeof value !== "object")
@@ -57055,13 +57728,15 @@ function isImportBinding(value) {
   if (typeof binding.from !== "string" || !isResolvedImportTarget(binding.resolved) || !isOptionalBoolean(binding.typeOnly) || !isImportMechanism(binding.mechanism) || !isResolvedType(binding.resolvedType) || !isOptionalNumber(binding.confidence)) {
     return false;
   }
-  if (binding.kind === "default")
-    return typeof binding.local === "string";
+  if (binding.kind === "default") {
+    return typeof binding.local === "string" && isOptionalRange2(binding.localRange);
+  }
   if (binding.kind === "named") {
-    return typeof binding.local === "string" && typeof binding.imported === "string" && (binding.phpImportType === void 0 || binding.phpImportType === "class" || binding.phpImportType === "function" || binding.phpImportType === "const");
+    return typeof binding.local === "string" && typeof binding.imported === "string" && isOptionalBoolean(binding.explicitAlias) && isOptionalRange2(binding.importedRange) && isOptionalRange2(binding.localRange) && (binding.phpImportType === void 0 || binding.phpImportType === "class" || binding.phpImportType === "function" || binding.phpImportType === "const");
+  }
+  if (binding.kind === "namespace") {
+    return typeof binding.localNS === "string" && isOptionalRange2(binding.localRange);
   }
-  if (binding.kind === "namespace")
-    return typeof binding.localNS === "string";
   return binding.kind === "star";
 }
 function isExportEntry(value) {
@@ -57098,16 +57773,19 @@ function isOptionalBoolean(value) {
 function isOptionalNumber(value) {
   return value === void 0 || typeof value === "number";
 }
+function isOptionalRange2(value) {
+  return value === void 0 || isRange2(value);
+}
 function isSymbolKind(value) {
   return SNAPSHOT_SYMBOL_KINDS.has(value);
 }
-function isRange(value) {
+function isRange2(value) {
   if (!value || typeof value !== "object")
     return false;
   const range = value;
-  return isPos(range.start) && isPos(range.end);
+  return isPos2(range.start) && isPos2(range.end);
 }
-function isPos(value) {
+function isPos2(value) {
   if (!value || typeof value !== "object")
     return false;
   const pos = value;
@@ -60544,8 +61222,9 @@ async function resolveMemberAccessDefinition(params) {
         });
       }
     }
-    const objDef = await resolveReceiverDefinition(obj, source, sup, resolveExpression);
-    if (objDef) {
+    const receiver = await resolveReceiverDefinition(obj, source, sup, resolveExpression);
+    if (receiver) {
+      const objDef = receiver.def;
       const targetContext = await ensureParsedContext(objDef.file, void 0, index.languageExtensions);
       const start = objDef.range.start;
       const targetPosition = {
@@ -60554,11 +61233,21 @@ async function resolveMemberAccessDefinition(params) {
       };
       const nameNode = targetContext.tree.rootNode.descendantForPosition(targetPosition, targetPosition);
       const container = nameNode.parent;
+      if (receiver.runtimeTypeOnly && container && container.type !== "enum_declaration" && container.type !== "internal_module" && container.type !== "module") {
+        return null;
+      }
       if (container) {
         const targetModule = index.byFile.get(fileIdentityKey(objDef.file));
         if (targetModule) {
           const normalizeIdentifier = targetContext.sup.normalizeIdentifier;
-          const memberDef = targetContext.sup.id === "java" ? findDirectLocalWithinNode(targetModule.locals, member, container, targetContext, normalizeIdentifier) : findReceiverMemberDefinition(targetModule.locals, member, objDef, container, targetContext, normalizeIdentifier);
+          let memberDef;
+          if (receiver.runtimeTypeOnly) {
+            memberDef = findDirectLocalWithinNode(targetModule.locals, member, container, targetContext, normalizeIdentifier);
+          } else if (targetContext.sup.id === "java") {
+            memberDef = findDirectLocalWithinNode(targetModule.locals, member, container, targetContext, normalizeIdentifier);
+          } else {
+            memberDef = findReceiverMemberDefinition(targetModule.locals, member, objDef, container, targetContext, normalizeIdentifier, receiver.memberScope);
+          }
           if (memberDef) {
             return okGoToResult(index, memberDef, {
               via: { exportedName: member },
@@ -60590,17 +61279,24 @@ async function resolveReceiverDefinition(obj, source, sup, resolveExpression) {
   if (constructor) {
     const result = await resolveExpression(constructor);
     if (result?.kind === "resolved") {
-      return result.def;
+      return {
+        def: result.def,
+        memberScope: isJsTsLanguage(sup.id) ? "instance" : "any"
+      };
     }
   }
-  if (isJsTsLanguage(sup.id)) {
-    if (sup.nodeTypes.identifier.includes(obj.type)) {
-      return null;
+  const direct = await resolveExpression(obj);
+  if (isJsTsLanguage(sup.id) && sup.nodeTypes.identifier.includes(obj.type)) {
+    if (direct?.kind === "resolved" && direct.def.kind === SymbolKind.Class) {
+      return { def: direct.def, memberScope: "static" };
+    }
+    if (direct?.kind === "resolved" && direct.def.kind === SymbolKind.TypeAlias) {
+      return { def: direct.def, memberScope: "any", runtimeTypeOnly: true };
     }
+    return null;
   }
-  const direct = await resolveExpression(obj);
   if (direct?.kind === "resolved") {
-    return direct.def;
+    return { def: direct.def, memberScope: "any" };
   }
   return null;
 }
@@ -60802,8 +61498,9 @@ async function resolveMemberDefinitionForBase(index, baseDef, member) {
     return void 0;
   return findReceiverMemberDefinition(targetModule.locals, member, baseDef, container, targetContext, normalizeIdentifier);
 }
-function findReceiverMemberDefinition(locals, member, receiverDef, container, targetContext, normalizeIdentifier) {
-  const containerHit = findLocalWithinNode(locals, member, container, normalizeIdentifier);
+function findReceiverMemberDefinition(locals, member, receiverDef, container, targetContext, normalizeIdentifier, memberScope = "any") {
+  const memberPredicate = memberScope === "any" ? void 0 : (local) => hasStaticModifier(local, targetContext, container) === (memberScope === "static");
+  const containerHit = memberScope === "any" ? findLocalWithinNode(locals, member, container, normalizeIdentifier) : findDirectLocalWithinNode(locals, member, container, targetContext, normalizeIdentifier, memberPredicate);
   if (containerHit)
     return containerHit;
   if (targetContext.sup.id !== "rust")
@@ -60811,17 +61508,35 @@ function findReceiverMemberDefinition(locals, member, receiverDef, container, ta
   const implNode = findRustImplForType(targetContext.tree.rootNode, receiverDef.localName, targetContext.source);
   return implNode ? findLocalWithinNode(locals, member, implNode, normalizeIdentifier) : void 0;
 }
-function findLocalWithinNode(locals, member, node, normalizeIdentifier = (name) => name) {
+function findLocalWithinNode(locals, member, node, normalizeIdentifier = (name) => name, predicate) {
   const containerStart = node.startIndex;
   const containerEnd = node.endIndex;
   const normalizedMember = normalizeIdentifier(member);
   return locals.find((local) => {
     const startIndex = local.range.start.index;
     const endIndex = local.range.end.index;
-    return normalizeIdentifier(local.localName) === normalizedMember && startIndex !== void 0 && endIndex !== void 0 && startIndex >= containerStart && endIndex <= containerEnd;
+    return normalizeIdentifier(local.localName) === normalizedMember && startIndex !== void 0 && endIndex !== void 0 && startIndex >= containerStart && endIndex <= containerEnd && (!predicate || predicate(local));
   });
 }
-function findDirectLocalWithinNode(locals, member, container, targetContext, normalizeIdentifier) {
+function hasStaticModifier(local, targetContext, container) {
+  const position = {
+    row: local.range.start.line - 1,
+    column: local.range.start.column - 1
+  };
+  let current = targetContext.tree.rootNode.descendantForPosition(position, position);
+  while (current && current !== container) {
+    for (let childIndex = 0; ; childIndex += 1) {
+      const child = current.child(childIndex);
+      if (!child)
+        break;
+      if (child.type === "static")
+        return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+function findDirectLocalWithinNode(locals, member, container, targetContext, normalizeIdentifier, predicate) {
   const containerStart = container.startIndex;
   const containerEnd = container.endIndex;
   const normalizedMember = normalizeIdentifier(member);
@@ -60839,14 +61554,15 @@ function findDirectLocalWithinNode(locals, member, container, targetContext, nor
     let current = targetContext.tree.rootNode.descendantForPosition(position, position).parent;
     let isDeclarationParent = true;
     while (current && current !== container) {
-      if (!isDeclarationParent && (current.type === "class_body" && current.parent !== container || NESTED_MEMBER_LOCAL_CONTAINERS.has(current.type))) {
+      const isDirectBody = current.type === "statement_block" && current.parent === container;
+      if (!isDeclarationParent && !isDirectBody && (current.type === "class_body" && current.parent !== container || NESTED_MEMBER_LOCAL_CONTAINERS.has(current.type))) {
         current = null;
         break;
       }
       isDeclarationParent = false;
       current = current.parent;
     }
-    if (current)
+    if (current && (!predicate || predicate(local)))
       return local;
   }
   return void 0;
@@ -60885,6 +61601,7 @@ var init_navigation_goto = __esm({
     init_parse_context();
     init_navigation_provenance();
     init_navigation_resolve();
+    init_types2();
     RUBY_CONSTANT_SOURCE = String.raw`(?=\p{Lu})${XID_IDENTIFIER_SOURCE}`;
     CSHARP_CONSTANT_SOURCE = String.raw`(?=@?\p{Lu})${CSHARP_IDENTIFIER_SOURCE}`;
     JAVA_CONSTANT_SOURCE = String.raw`(?=\p{Lu})${JAVA_IDENTIFIER_SOURCE}`;
@@ -68676,9 +69393,14 @@ async function collectNamedNodeReferences(index, fileId, symbolName) {
     ]);
     const canonicalSymbolName = parsed.sup.normalizeIdentifier(symbolName);
     const ranges = [];
+    const moduleIndex = index.byFile.get(fileIdentityKey(fileId));
+    const importDeclarationKeys = importBindingDeclarationRangeKeys(moduleIndex);
     const walk = (node) => {
       if (identifierTypes.has(node.type) && parsed.sup.normalizeIdentifier(sliceText(node, parsed.source)) === canonicalSymbolName) {
-        ranges.push(toRange(node));
+        const range = toRange(node);
+        if (!importDeclarationKeys.has(rangeIdentityKey(range))) {
+          ranges.push(range);
+        }
       }
       for (const child of node.namedChildren) {
         walk(child);
@@ -68690,12 +69412,16 @@ async function collectNamedNodeReferences(index, fileId, symbolName) {
     return null;
   }
 }
-async function collectVerifiedNamedNodeReferences(index, fileId, symbolName, expectedDef, resolveDefinition, maxVerified) {
+async function collectVerifiedNamedNodeReferences(index, fileId, symbolName, expectedDef, resolveDefinition, maxVerified, includeReference) {
   const collected = await collectNamedNodeReferences(index, fileId, symbolName);
   if (!collected)
     return [];
   const { ranges, parsed } = collected;
   const verified = [];
+  const pushVerified = (reference) => {
+    if (!includeReference || includeReference(reference))
+      verified.push(reference);
+  };
   for (const range of ranges) {
     if (maxVerified !== void 0 && maxVerified > 0 && verified.length >= maxVerified) {
       break;
@@ -68705,7 +69431,7 @@ async function collectVerifiedNamedNodeReferences(index, fileId, symbolName, exp
       const reexported = resolveExport(index, exportFrom.entry.fromModule, exportFrom.entry.sourceSpecifier);
       if (reexported?.kind === "resolved") {
         if (sameDef(reexported.def, expectedDef, index.languageExtensions)) {
-          verified.push({ range, via: { reexport: true } });
+          pushVerified({ range, via: { reexport: true } });
         }
         continue;
       }
@@ -68718,7 +69444,7 @@ async function collectVerifiedNamedNodeReferences(index, fileId, symbolName, exp
     if (resolved.status !== "ok" || !resolved.definition)
       continue;
     if (sameDef(resolved.definition, expectedDef, index.languageExtensions)) {
-      verified.push({
+      pushVerified({
         range,
         ...exportFrom?.isExportFrom ? { via: { reexport: true } } : {},
         ...resolved.provenance ? { provenance: resolved.provenance } : {}
@@ -68884,7 +69610,183 @@ function getCachedReferenceCandidateFiles(index, def, exportedNames, hasGlobalNa
   cache.set(key, sorted);
   return sorted;
 }
-var EXPORT_FROM_PATTERN, NAMESPACE_EXPORT_PATTERN, EXPORT_FROM_SPECIFIER_PATTERN, referenceCandidateCache;
+function rangeIdentityKey(range) {
+  return `${range.start.line}:${range.start.column}:${range.start.index ?? ""}:${range.end.line}:${range.end.column}:${range.end.index ?? ""}`;
+}
+function referenceSiteKey(file2, range) {
+  return `${fileIdentityKey(file2)}:${rangeIdentityKey(range)}`;
+}
+function rangesEqual(left, right) {
+  if (!left || !right)
+    return false;
+  return rangeIdentityKey(left) === rangeIdentityKey(right);
+}
+function bindingTokenRanges(imp) {
+  if (imp.kind === "named") {
+    return { importedRange: imp.importedRange, localRange: imp.localRange };
+  }
+  if (imp.kind === "default" || imp.kind === "namespace") {
+    return { importedRange: void 0, localRange: imp.localRange };
+  }
+  return { importedRange: void 0, localRange: void 0 };
+}
+function importBindingReferenceSites(imp) {
+  const sites = [];
+  if (imp.kind === "named") {
+    const { importedRange, localRange } = bindingTokenRanges(imp);
+    if (importedRange) {
+      sites.push({ range: importedRange, importBinding: "imported" });
+    } else if (localRange && imp.local === imp.imported) {
+      sites.push({ range: localRange, importBinding: "imported" });
+    }
+    if (localRange && !rangesEqual(localRange, importedRange)) {
+      sites.push({ range: localRange, importBinding: "local" });
+    }
+  } else if (imp.kind === "default") {
+    const { localRange } = bindingTokenRanges(imp);
+    if (localRange) {
+      sites.push({ range: localRange, importBinding: "local" });
+    }
+  }
+  return sites;
+}
+function importBindingIdentityVerificationSites(imp) {
+  const sites = importBindingReferenceSites(imp);
+  if (imp.kind !== "named" || imp.local === imp.imported) {
+    return sites;
+  }
+  const localSites = sites.filter((site) => site.importBinding === "local");
+  return localSites.length > 0 ? localSites : sites;
+}
+function importBindingDeclarationRangeKeys(moduleIndex) {
+  const keys = /* @__PURE__ */ new Set();
+  if (!moduleIndex)
+    return keys;
+  for (const imp of moduleIndex.imports) {
+    const { importedRange, localRange } = bindingTokenRanges(imp);
+    if (importedRange)
+      keys.add(rangeIdentityKey(importedRange));
+    if (localRange)
+      keys.add(rangeIdentityKey(localRange));
+  }
+  return keys;
+}
+function structurallyExportsDefinition(index, moduleFile, exportedName, def, definitionExportedNames, visited = /* @__PURE__ */ new Set()) {
+  const normalizeIdentifier = supportForFileWithoutHeaderSample(moduleFile, index.languageExtensions)?.normalizeIdentifier ?? ((name) => name);
+  const canonicalName = normalizeIdentifier(exportedName);
+  const fileKey = fileIdentityKey(moduleFile);
+  const visitKey = `${fileKey}::${canonicalName}`;
+  if (visited.has(visitKey))
+    return false;
+  visited.add(visitKey);
+  if (fileKey === fileIdentityKey(def.file) && definitionExportedNames.some((name) => normalizeIdentifier(name) === canonicalName)) {
+    return true;
+  }
+  const moduleIndex = index.byFile.get(fileKey);
+  if (!moduleIndex)
+    return false;
+  for (const entry of moduleIndex.exports) {
+    if (entry.type === "local") {
+      if (normalizeIdentifier(entry.exportedAs) === canonicalName && sameDef(entry.target, def, index.languageExtensions)) {
+        return true;
+      }
+      continue;
+    }
+    if (entry.type === "reexport" && normalizeIdentifier(entry.exportedAs) === canonicalName) {
+      if (structurallyExportsDefinition(index, entry.fromModule, entry.sourceSpecifier || exportedName, def, definitionExportedNames, visited)) {
+        return true;
+      }
+    } else if (entry.type === "exportStar" && structurallyExportsDefinition(index, entry.fromModule, exportedName, def, definitionExportedNames, visited)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isUnresolvedIndexedImport(index, imp, def, exportedNames) {
+  if (typeof imp.resolved !== "string")
+    return false;
+  let importedName;
+  if (imp.kind === "named")
+    importedName = imp.imported;
+  else if (imp.kind === "default")
+    importedName = "default";
+  else
+    return false;
+  if (!structurallyExportsDefinition(index, imp.resolved, importedName, def, exportedNames))
+    return false;
+  return !importCanReferenceDefinition(index, imp, def, exportedNames);
+}
+function parserDegradedCandidateFiles(index, scannedFiles) {
+  const report = index.buildReport?.backend?.parser;
+  if (!report)
+    return { files: [], hasUnlistedCandidate: false };
+  const scanned = new Set(scannedFiles.map((file2) => fileIdentityKey(file2)));
+  const listed = new Set(report.files.map((entry) => fileIdentityKey(entry.file)));
+  const affected = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of report.files) {
+    const key = fileIdentityKey(entry.file);
+    if (!scanned.has(key) || seen.has(key))
+      continue;
+    seen.add(key);
+    affected.push(entry.file);
+  }
+  let hasUnlistedCandidate = false;
+  if (report.total > report.files.length) {
+    for (const fileKey of scanned) {
+      if (listed.has(fileKey))
+        continue;
+      hasUnlistedCandidate = true;
+      break;
+    }
+  }
+  return { files: affected, hasUnlistedCandidate };
+}
+function buildIndexedCandidateCoverage(args) {
+  const { index, def, exportedNames, candidateFiles, scannedFiles, truncated } = args;
+  const reasons = [];
+  const affectedFiles = [];
+  const affectedSeen = /* @__PURE__ */ new Set();
+  const addAffected = (file2) => {
+    const key = fileIdentityKey(file2);
+    if (affectedSeen.has(key))
+      return;
+    affectedSeen.add(key);
+    affectedFiles.push(file2);
+  };
+  const degraded = parserDegradedCandidateFiles(index, scannedFiles);
+  if (degraded.files.length || degraded.hasUnlistedCandidate) {
+    reasons.push("parser_degraded");
+    for (const file2 of degraded.files)
+      addAffected(file2);
+  }
+  const unresolvedFiles = [];
+  for (const fileId of candidateFiles) {
+    const moduleIndex = index.byFile.get(fileIdentityKey(fileId));
+    if (!moduleIndex)
+      continue;
+    if (moduleIndex.imports.some((imp) => isUnresolvedIndexedImport(index, imp, def, exportedNames))) {
+      unresolvedFiles.push(fileId);
+    }
+  }
+  if (unresolvedFiles.length) {
+    reasons.push("unresolved_import");
+    for (const file2 of unresolvedFiles)
+      addAffected(file2);
+  }
+  if (truncated)
+    reasons.push("truncated");
+  if (!reasons.length) {
+    return { scope: "indexed_candidates", state: "complete" };
+  }
+  return {
+    scope: "indexed_candidates",
+    state: "partial",
+    reasons: COVERAGE_REASON_ORDER.filter((reason) => reasons.includes(reason)),
+    ...affectedFiles.length ? { affectedFiles } : {}
+  };
+}
+var EXPORT_FROM_PATTERN, NAMESPACE_EXPORT_PATTERN, EXPORT_FROM_SPECIFIER_PATTERN, referenceCandidateCache, COVERAGE_REASON_ORDER;
 var init_navigation_references = __esm({
   "dist/indexer/navigation-references.js"() {
     "use strict";
@@ -68902,6 +69804,7 @@ var init_navigation_references = __esm({
     NAMESPACE_EXPORT_PATTERN = new RegExp(String.raw`\bexport\s*\*\s*as\s*(${ECMASCRIPT_IDENTIFIER_SOURCE})\s*from\s*(["'])([^"']+)\2`, "gu");
     EXPORT_FROM_SPECIFIER_PATTERN = new RegExp(String.raw`^(${ECMASCRIPT_IDENTIFIER_SOURCE})`, "u");
     referenceCandidateCache = /* @__PURE__ */ new WeakMap();
+    COVERAGE_REASON_ORDER = ["parser_degraded", "unresolved_import", "truncated"];
   }
 });
 
@@ -69228,22 +70131,38 @@ async function goToSqlDefinition(index, req) {
     confidence: "high"
   });
 }
-async function findSqlReferences(index, definition) {
+async function findSqlReferences(index, definition, options) {
   if (!isSqlFile2(definition.file))
     return null;
   const references = [];
   const seen = /* @__PURE__ */ new Set();
   const lookup = getSqlDefinitionLookup(index);
+  const candidateFiles = sqlFiles(index);
+  const scannedFiles = [];
+  const includeDefinition = options?.includeDefinition ?? true;
+  const maxReferences = typeof options?.maxReferences === "number" && options.maxReferences > 0 ? options.maxReferences : void 0;
+  const collectionLimit = maxReferences === void 0 ? void 0 : maxReferences + 1;
+  const definitionKey = `${fileIdentityKey(definition.file)}:${definition.range.start.line}:${definition.range.start.column}`;
+  const hasReachedCollectionLimit = () => collectionLimit !== void 0 && references.length >= collectionLimit;
   const addReference = (file2, range) => {
-    const key = `${file2}:${range.start.line}:${range.start.column}`;
+    if (hasReachedCollectionLimit())
+      return;
+    const key = `${fileIdentityKey(file2)}:${range.start.line}:${range.start.column}`;
+    if (!includeDefinition && key === definitionKey)
+      return;
     if (seen.has(key))
       return;
     seen.add(key);
     references.push({ file: file2, range });
   };
-  for (const file2 of sqlFiles(index)) {
+  for (const file2 of candidateFiles) {
+    if (hasReachedCollectionLimit())
+      break;
+    scannedFiles.push(file2);
     const facts = await sqlFactsForFile(index, file2);
     for (const fact of facts) {
+      if (hasReachedCollectionLimit())
+        break;
       for (const name of [fact.objectName, fact.relatedObjectName]) {
         if (!name || !sqlNameResolvesToDefinition(lookup, name, definition))
           continue;
@@ -69252,7 +70171,11 @@ async function findSqlReferences(index, definition) {
         }
       }
     }
+    if (hasReachedCollectionLimit())
+      break;
     for (const statement of sqlStatementSlices(facts)) {
+      if (hasReachedCollectionLimit())
+        break;
       for (const range of qualifiedReferenceRanges(lookup, statement, definition)) {
         addReference(file2, range);
       }
@@ -69264,11 +70187,22 @@ async function findSqlReferences(index, definition) {
       return fileCompare;
     return left.range.start.line - right.range.start.line || left.range.start.column - right.range.start.column;
   });
+  const truncated = maxReferences !== void 0 && references.length > maxReferences;
+  if (truncated)
+    references.length = maxReferences;
   return {
     status: "ok",
     definition,
     references,
-    provenance: createNavigationProvenance(index, "exact", "high")
+    provenance: createNavigationProvenance(index, "exact", "high"),
+    referenceCoverage: buildIndexedCandidateCoverage({
+      index,
+      def: definition,
+      exportedNames: [],
+      candidateFiles,
+      scannedFiles,
+      truncated
+    })
   };
 }
 var SQL_IDENTIFIER, SQL_DOTTED_TOKEN, SQL_DOTTED_TOKEN_RE, SQL_SOURCE_KEYWORDS, SQL_SOURCE_MODIFIERS, SQL_SOURCE_BOUNDARY_RE;
@@ -69276,6 +70210,7 @@ var init_navigation = __esm({
   "dist/sql/navigation.js"() {
     "use strict";
     init_navigation_provenance();
+    init_navigation_references();
     init_paths();
     init_extract_facts();
     init_lookup();
@@ -69457,6 +70392,15 @@ function isUnresolvedReceiverMemberProperty(sup, node) {
   return !!property && node.id === property.id;
 }
 async function findReferences(index, req, opts) {
+  return findReferencesInternal(index, req, opts, "all");
+}
+async function findUsageReferences(index, req, opts) {
+  return findReferencesInternal(index, req, opts, "usages");
+}
+async function findRenameReferences(index, def, opts) {
+  return findReferencesInternal(index, { def }, opts, "rename");
+}
+async function findReferencesInternal(index, req, opts, collectionMode) {
   let def = null;
   let provenance2;
   if ("def" in req) {
@@ -69482,10 +70426,37 @@ async function findReferences(index, req, opts) {
   if (!def) {
     return { status: "not_found", reason: "Could not resolve definition" };
   }
-  const sqlReferences = await findSqlReferences(index, def);
+  const maxReferences = typeof opts?.maxReferences === "number" && opts.maxReferences > 0 ? opts.maxReferences : void 0;
+  const sqlReferences = await findSqlReferences(index, def, {
+    includeDefinition: collectionMode === "all",
+    ...maxReferences === void 0 ? {} : { maxReferences }
+  });
   if (sqlReferences)
     return sqlReferences;
   const definitionFile = def.file;
+  const definitionSiteKey = referenceSiteKey(definitionFile, def.range);
+  const includeReference = (ref) => {
+    if (collectionMode === "all")
+      return true;
+    if (ref.via?.reexport || referenceSiteKey(ref.file, ref.range) === definitionSiteKey)
+      return false;
+    if (collectionMode === "usages")
+      return ref.via?.importBinding === void 0;
+    const binding = ref.via?.import;
+    if (!binding || binding.kind === "star" || binding.kind === "namespace")
+      return true;
+    if (ref.via?.importBinding === "imported" && binding.kind === "named" && binding.imported === def.localName) {
+      return true;
+    }
+    if (binding.kind === "default")
+      return false;
+    return !binding.explicitAlias && binding.local === def.localName;
+  };
+  const verifiedReferenceFilter = (fileId) => {
+    if (collectionMode === "all")
+      return void 0;
+    return (reference) => !reference.via?.reexport && referenceSiteKey(fileId, reference.range) !== definitionSiteKey;
+  };
   const parsedDef = index.parsed?.get(fileIdentityKey(definitionFile));
   const parsedContext = await ensureParsedContext(definitionFile, parsedDef, index.languageExtensions);
   const mod = index.byFile.get(fileIdentityKey(definitionFile));
@@ -69493,14 +70464,26 @@ async function findReferences(index, req, opts) {
     return { status: "not_found", reason: "Module not found" };
   const scope = getCachedScope(index, definitionFile, mod, parsedContext);
   const refs = [];
-  const maxReferences = typeof opts?.maxReferences === "number" && opts.maxReferences > 0 ? opts.maxReferences : void 0;
-  const seenRefs = /* @__PURE__ */ new Set();
-  const hasReachedMaxReferences = () => maxReferences !== void 0 && refs.length >= maxReferences;
+  const seenRefs = /* @__PURE__ */ new Map();
+  const collectionLimit = maxReferences !== void 0 ? maxReferences + 1 : void 0;
+  const hasReachedCollectionLimit = () => collectionLimit !== void 0 && refs.length >= collectionLimit;
+  const remainingCollectionSlots = () => collectionLimit !== void 0 ? Math.max(0, collectionLimit - refs.length) : void 0;
+  const importBindingRank = (ref) => ref.via?.importBinding === "imported" ? 1 : 0;
   const pushRef = (ref) => {
-    const key = `${fileIdentityKey(ref.file)}:${ref.range.start.line}:${ref.range.start.column}`;
-    if (seenRefs.has(key))
+    if (!includeReference(ref))
+      return;
+    const key = referenceSiteKey(ref.file, ref.range);
+    const existingIndex = seenRefs.get(key);
+    if (existingIndex !== void 0) {
+      const existing = refs[existingIndex];
+      if (importBindingRank(ref) > importBindingRank(existing)) {
+        refs[existingIndex] = ref;
+      }
+      return;
+    }
+    if (hasReachedCollectionLimit())
       return;
-    seenRefs.add(key);
+    seenRefs.set(key, refs.length);
     refs.push(ref);
   };
   const normalizedLocalName = parsedContext.sup.normalizeIdentifier(def.localName);
@@ -69509,7 +70492,7 @@ async function findReferences(index, req, opts) {
   pushRef({ file: definitionFile, range: def.range });
   if (localBinding) {
     for (const occurrence of localBinding.occurrences) {
-      if (hasReachedMaxReferences())
+      if (hasReachedCollectionLimit())
         break;
       pushRef({ file: definitionFile, range: occurrence });
     }
@@ -69543,7 +70526,7 @@ async function findReferences(index, req, opts) {
     });
   }
   for (const fileId of candidateFiles) {
-    if (hasReachedMaxReferences())
+    if (hasReachedCollectionLimit())
       break;
     const module2 = index.byFile.get(fileIdentityKey(fileId));
     if (!module2)
@@ -69566,7 +70549,7 @@ async function findReferences(index, req, opts) {
     };
     if (supportForFileWithoutHeaderSample(fileId, index.languageExtensions)?.supportsExportFromReferences) {
       for (const entry of module2.exports) {
-        if (hasReachedMaxReferences())
+        if (hasReachedCollectionLimit())
           break;
         if (entry.type !== "reexport")
           continue;
@@ -69575,10 +70558,10 @@ async function findReferences(index, req, opts) {
         const resolved = resolveExport(index, entry.fromModule, entry.sourceSpecifier);
         if (resolved?.kind === "resolved" && !sameDef(resolved.def, def, index.languageExtensions))
           continue;
-        const remainingReferences = maxReferences !== void 0 ? Math.max(0, maxReferences - refs.length) : void 0;
-        const ranges = await collectVerifiedNamedNodeReferences(index, fileId, entry.sourceSpecifier, def, (params, parsed) => goToDefinition(index, params, parsed), remainingReferences);
+        const remainingReferences = remainingCollectionSlots();
+        const ranges = await collectVerifiedNamedNodeReferences(index, fileId, entry.sourceSpecifier, def, (params, parsed) => goToDefinition(index, params, parsed), remainingReferences, verifiedReferenceFilter(fileId));
         for (const { range, provenance: provenance3, via } of ranges) {
-          if (hasReachedMaxReferences())
+          if (hasReachedCollectionLimit())
             break;
           if (!via?.reexport)
             continue;
@@ -69587,13 +70570,43 @@ async function findReferences(index, req, opts) {
       }
     }
     for (const imp of module2.imports) {
-      if (hasReachedMaxReferences())
+      if (hasReachedCollectionLimit())
         break;
       const targetFile = typeof imp.resolved === "string" ? imp.resolved : void 0;
-      if (!targetFile)
+      const bindingSites = importBindingReferenceSites(imp);
+      let verifiedBindingMatches;
+      const bindingMatchesDefinition = async () => {
+        if (verifiedBindingMatches !== void 0)
+          return verifiedBindingMatches;
+        verifiedBindingMatches = false;
+        const parsed = await ensureCandidateParsed();
+        for (const verificationSite of importBindingIdentityVerificationSites(imp)) {
+          const resolved = await goToDefinition(index, {
+            file: fileId,
+            line: verificationSite.range.start.line,
+            column: verificationSite.range.start.column
+          }, parsed);
+          if (resolved.status === "ok" && sameDef(resolved.definition, def, index.languageExtensions)) {
+            verifiedBindingMatches = true;
+            break;
+          }
+        }
+        return verifiedBindingMatches;
+      };
+      if (!targetFile) {
+        if (!bindingSites.length || !await bindingMatchesDefinition())
+          continue;
+        for (const site of bindingSites) {
+          pushRef({
+            file: fileId,
+            range: site.range,
+            via: { import: imp, importBinding: site.importBinding }
+          });
+        }
         continue;
+      }
       for (const exportedName of exportedNames) {
-        if (hasReachedMaxReferences())
+        if (hasReachedCollectionLimit())
           break;
         if (imp.kind === "namespace") {
           const hit = resolveExport(index, targetFile, exportedName);
@@ -69603,7 +70616,7 @@ async function findReferences(index, req, opts) {
           const parsed = await ensureCandidateParsed();
           const ranges = await collectNamespaceMemberRefs(fileId, imp.localNS, exportedName, parsed, index.languageExtensions);
           for (const range of ranges) {
-            if (hasReachedMaxReferences())
+            if (hasReachedCollectionLimit())
               break;
             pushRef({
               file: fileId,
@@ -69619,10 +70632,10 @@ async function findReferences(index, req, opts) {
           if (hasExpandedNamedImport(module2, targetFile, exportedName)) {
             continue;
           }
-          const remainingReferences = maxReferences !== void 0 ? Math.max(0, maxReferences - refs.length) : void 0;
-          const ranges = await collectVerifiedNamedNodeReferences(index, fileId, exportedName, def, (params, parsed) => goToDefinition(index, params, parsed), remainingReferences);
+          const remainingReferences = remainingCollectionSlots();
+          const ranges = await collectVerifiedNamedNodeReferences(index, fileId, exportedName, def, (params, parsed) => goToDefinition(index, params, parsed), remainingReferences, verifiedReferenceFilter(fileId));
           for (const { range, provenance: provenance3, via } of ranges) {
-            if (hasReachedMaxReferences())
+            if (hasReachedCollectionLimit())
               break;
             pushRef({
               file: fileId,
@@ -69639,14 +70652,24 @@ async function findReferences(index, req, opts) {
             exported = "default";
           }
           const hit = resolveExport(index, targetFile, exported);
-          const matchesDef = hit?.kind === "resolved" && sameDef(hit.def, def, index.languageExtensions);
+          let matchesDef = hit?.kind === "resolved" && sameDef(hit.def, def, index.languageExtensions);
+          if (!matchesDef && bindingSites.length) {
+            matchesDef = await bindingMatchesDefinition();
+          }
           if (!matchesDef)
             continue;
+          for (const site of bindingSites) {
+            pushRef({
+              file: fileId,
+              range: site.range,
+              via: { import: imp, importBinding: site.importBinding }
+            });
+          }
           if (fileIdentityKey(targetFile) !== fileIdentityKey(definitionFile)) {
-            const remainingReferences = maxReferences !== void 0 ? Math.max(0, maxReferences - refs.length) : void 0;
-            const ranges = await collectVerifiedNamedNodeReferences(index, fileId, imp.local, def, (params, parsed2) => goToDefinition(index, params, parsed2), remainingReferences);
+            const remainingReferences = remainingCollectionSlots();
+            const ranges = await collectVerifiedNamedNodeReferences(index, fileId, imp.local, def, (params, parsed2) => goToDefinition(index, params, parsed2), remainingReferences, verifiedReferenceFilter(fileId));
             for (const { range, provenance: provenance3, via } of ranges) {
-              if (hasReachedMaxReferences())
+              if (hasReachedCollectionLimit())
                 break;
               pushRef({
                 file: fileId,
@@ -69660,12 +70683,15 @@ async function findReferences(index, req, opts) {
           const parsed = await ensureCandidateParsed();
           const resolvedScope = await ensureScope();
           const localName = parsed.sup.normalizeIdentifier(imp.local);
+          const declarationKeys = importBindingDeclarationRangeKeys(module2);
           const bindings = resolvedScope.bindings.get(localName) ?? [];
           for (const binding of bindings) {
             if (binding.import === imp) {
               for (const occurrence of binding.occurrences) {
-                if (hasReachedMaxReferences())
+                if (hasReachedCollectionLimit())
                   break;
+                if (declarationKeys.has(rangeIdentityKey(occurrence)))
+                  continue;
                 pushRef({ file: fileId, range: occurrence, via: { import: imp } });
               }
             }
@@ -69674,36 +70700,42 @@ async function findReferences(index, req, opts) {
       }
     }
     if (phpQualifiedNames.length) {
-      const remainingReferences = maxReferences !== void 0 ? Math.max(0, maxReferences - refs.length) : void 0;
+      const remainingReferences = remainingCollectionSlots();
       for (const candidateName of [...exportedNames, ...phpQualifiedNames]) {
-        if (hasReachedMaxReferences())
+        if (hasReachedCollectionLimit())
           break;
-        const ranges = await collectVerifiedNamedNodeReferences(index, fileId, candidateName, def, (params, parsed) => goToDefinition(index, params, parsed), remainingReferences);
+        const ranges = await collectVerifiedNamedNodeReferences(index, fileId, candidateName, def, (params, parsed) => goToDefinition(index, params, parsed), remainingReferences, verifiedReferenceFilter(fileId));
         for (const { range, provenance: provenance3, via } of ranges) {
-          if (hasReachedMaxReferences())
+          if (hasReachedCollectionLimit())
             break;
           pushRef({ file: fileId, range, ...via ? { via } : {}, ...provenance3 ? { provenance: provenance3 } : {} });
         }
       }
     }
   }
+  const receiverScannedFiles = [];
   if (shouldScanVerifiedReferences(def, phpQualifiedNames, parsedContext)) {
     for (const fileId of Array.from(index.byFile.values(), (module2) => module2.file).sort((left, right) => left.localeCompare(right))) {
-      if (hasReachedMaxReferences())
+      if (hasReachedCollectionLimit())
         break;
+      receiverScannedFiles.push(fileId);
       const filter = index.bloomFilters?.get(fileIdentityKey(fileId));
       const canonicalName = supportForFileWithoutHeaderSample(fileId, index.languageExtensions)?.normalizeIdentifier(def.localName) ?? def.localName;
       if (filter && !filter.mightContain(canonicalName))
         continue;
-      const remainingReferences = maxReferences !== void 0 ? Math.max(0, maxReferences - refs.length) : void 0;
-      const ranges = await collectVerifiedNamedNodeReferences(index, fileId, def.localName, def, (params, parsed) => goToDefinition(index, params, parsed), remainingReferences);
+      const remainingReferences = remainingCollectionSlots();
+      const ranges = await collectVerifiedNamedNodeReferences(index, fileId, def.localName, def, (params, parsed) => goToDefinition(index, params, parsed), remainingReferences, verifiedReferenceFilter(fileId));
       for (const { range, provenance: provenance3, via } of ranges) {
-        if (hasReachedMaxReferences())
+        if (hasReachedCollectionLimit())
           break;
         pushRef({ file: fileId, range, ...via ? { via } : {}, ...provenance3 ? { provenance: provenance3 } : {} });
       }
     }
   }
+  const truncated = maxReferences !== void 0 && refs.length > maxReferences;
+  if (truncated) {
+    refs.length = maxReferences;
+  }
   refs.sort((left, right) => {
     if (fileIdentityKey(left.file) === fileIdentityKey(right.file)) {
       const leftIndex = left.range.start.index ?? 0;
@@ -69731,26 +70763,36 @@ async function findReferences(index, req, opts) {
       }
     }
   }
+  const scannedFiles = [definitionFile, ...candidateFiles, ...receiverScannedFiles];
+  const referenceCoverage = buildIndexedCandidateCoverage({
+    index,
+    def,
+    exportedNames,
+    candidateFiles,
+    scannedFiles,
+    truncated
+  });
   return {
     status: "ok",
     definition: def,
     references: refs,
+    referenceCoverage,
     ...provenance2 ? { provenance: provenance2 } : {}
   };
 }
 function shouldScanVerifiedReferences(def, phpQualifiedNames, parsedContext) {
-  if (def.kind !== SymbolKind.Function || phpQualifiedNames.length) {
+  if (phpQualifiedNames.length)
     return false;
-  }
-  if (!supportsReceiverMemberResolution(parsedContext.sup.id)) {
+  if (!supportsReceiverMemberResolution(parsedContext.sup.id))
     return false;
-  }
-  return isReceiverMethodDefinition(def, parsedContext);
+  return isReceiverMemberDefinition(def, parsedContext);
 }
 function shouldUseLocalNameAsExportFallback(def, parsedContext) {
-  return !isReceiverMethodDefinition(def, parsedContext);
+  return !isReceiverMemberDefinition(def, parsedContext);
 }
-function isReceiverMethodDefinition(def, parsedContext) {
+function isReceiverMemberDefinition(def, parsedContext) {
+  if (def.isMember)
+    return true;
   if (def.kind !== SymbolKind.Function) {
     return false;
   }
@@ -73261,7 +74303,7 @@ async function attachCallCompatibilityHints(index, changedSymbols, options) {
     if (options.workBudget) {
       recordReferenceLookupStarted(options.workBudget);
     }
-    const referenceResult = await (options.referenceCache ? options.referenceCache.get(index, referenceDef, { maxReferences: referenceScanLimit }) : findReferences(index, { def: referenceDef }, { maxReferences: referenceScanLimit }));
+    const referenceResult = await (options.referenceCache ? options.referenceCache.getUsages(index, referenceDef, { maxReferences: referenceScanLimit }) : findUsageReferences(index, { def: referenceDef }, { maxReferences: referenceScanLimit }));
     let refs = [];
     const shouldIncludeReference = options.shouldIncludeReference ?? (() => true);
     if (referenceResult.status === "ok") {
@@ -74170,17 +75212,19 @@ var init_map = __esm({
 // dist/impact/reference-cache.js
 function createReferenceLookupCache() {
   const cachesByIndex = /* @__PURE__ */ new WeakMap();
-  return {
-    async get(index, def, options) {
-      const maxReferences = normalizeMaxReferences(options?.maxReferences);
-      const indexCache = getIndexReferenceCache(cachesByIndex, index);
-      const baseResult = await getBaseReferences(index, def, maxReferences, indexCache);
-      const bounded = cloneReferenceResult(baseResult, maxReferences);
-      if (bounded.status !== "ok" || options?.context === void 0)
-        return bounded;
-      await attachReferenceContext(index, bounded.references, options);
+  const lookup = async (mode, index, def, options) => {
+    const maxReferences = normalizeMaxReferences(options?.maxReferences);
+    const indexCache = getIndexReferenceCache(cachesByIndex, index);
+    const baseResult = await getBaseReferences(index, def, maxReferences, indexCache, mode);
+    const bounded = cloneReferenceResult(baseResult, maxReferences);
+    if (bounded.status !== "ok" || options?.context === void 0)
       return bounded;
-    }
+    await attachReferenceContext(index, bounded.references, options);
+    return bounded;
+  };
+  return {
+    get: (index, def, options) => lookup("all", index, def, options),
+    getUsages: (index, def, options) => lookup("usages", index, def, options)
   };
 }
 function getIndexReferenceCache(cachesByIndex, index) {
@@ -74191,13 +75235,14 @@ function getIndexReferenceCache(cachesByIndex, index) {
   }
   return cache;
 }
-function getBaseReferences(index, def, maxReferences, cache) {
-  const key = referenceLookupKey(def);
+function getBaseReferences(index, def, maxReferences, cache, mode) {
+  const key = referenceLookupKey(def, mode);
   const entries = cache.get(key) ?? [];
   const reusable = entries.find((entry) => canReuseEntry(entry.maxReferences, maxReferences));
   if (reusable)
     return reusable.refs;
-  const refs = findReferences(index, { def }, maxReferences === void 0 ? void 0 : { maxReferences });
+  const finder = mode === "usages" ? findUsageReferences : findReferences;
+  const refs = finder(index, { def }, maxReferences === void 0 ? void 0 : { maxReferences });
   entries.push({ maxReferences, refs });
   cache.set(key, entries);
   return refs;
@@ -74214,24 +75259,45 @@ function normalizeMaxReferences(maxReferences) {
     return void 0;
   return maxReferences;
 }
+function cloneCoverage(coverage) {
+  return {
+    scope: coverage.scope,
+    state: coverage.state,
+    ...coverage.reasons ? { reasons: [...coverage.reasons] } : {},
+    ...coverage.affectedFiles ? { affectedFiles: [...coverage.affectedFiles] } : {}
+  };
+}
+function withTruncatedCoverage(coverage) {
+  const reasons = new Set(coverage.reasons ?? []);
+  reasons.add("truncated");
+  return {
+    scope: "indexed_candidates",
+    state: "partial",
+    reasons: COVERAGE_REASON_ORDER2.filter((reason) => reasons.has(reason)),
+    ...coverage.affectedFiles ? { affectedFiles: [...coverage.affectedFiles] } : {}
+  };
+}
 function cloneReferenceResult(result, maxReferences) {
   if (result.status !== "ok")
     return result;
+  const truncatedByBound = maxReferences !== void 0 && result.references.length > maxReferences;
   const references = result.references.slice(0, maxReferences).map(cloneReference);
+  const baseCoverage = cloneCoverage(result.referenceCoverage);
   return {
     status: "ok",
     definition: result.definition,
     references,
+    referenceCoverage: truncatedByBound ? withTruncatedCoverage(baseCoverage) : baseCoverage,
     ...result.provenance ? { provenance: result.provenance } : {}
   };
 }
 function cloneReference(reference) {
   return {
     file: reference.file,
-    range: reference.range,
+    range: { start: { ...reference.range.start }, end: { ...reference.range.end } },
     ...reference.context !== void 0 ? { context: reference.context } : {},
-    ...reference.via !== void 0 ? { via: reference.via } : {},
-    ...reference.provenance !== void 0 ? { provenance: reference.provenance } : {}
+    ...reference.via !== void 0 ? { via: { ...reference.via } } : {},
+    ...reference.provenance !== void 0 ? { provenance: { ...reference.provenance } } : {}
   };
 }
 async function attachReferenceContext(index, references, options) {
@@ -74252,8 +75318,9 @@ async function attachReferenceContext(index, references, options) {
     }
   }
 }
-function referenceLookupKey(def) {
+function referenceLookupKey(def, mode) {
   return JSON.stringify({
+    mode,
     file: def.file,
     name: def.localName,
     kind: def.kind,
@@ -74262,6 +75329,7 @@ function referenceLookupKey(def) {
     index: def.range.start.index
   });
 }
+var COVERAGE_REASON_ORDER2;
 var init_reference_cache = __esm({
   "dist/impact/reference-cache.js"() {
     "use strict";
@@ -74270,6 +75338,7 @@ var init_reference_cache = __esm({
     init_reference_context();
     init_shared2();
     init_paths();
+    COVERAGE_REASON_ORDER2 = ["parser_degraded", "unresolved_import", "truncated"];
   }
 });
 
@@ -74519,21 +75588,6 @@ function collectDiffSnippets(source, range, changedLines, contextLines) {
   pushGroup(groupStart, groupEnd);
   return snippets;
 }
-function sameRange(left, right) {
-  const leftStart = left.start.index;
-  const rightStart = right.start.index;
-  const leftEnd = left.end.index;
-  const rightEnd = right.end.index;
-  if (typeof leftStart === "number" && typeof rightStart === "number") {
-    if (leftStart !== rightStart)
-      return false;
-    if (typeof leftEnd === "number" && typeof rightEnd === "number") {
-      return leftEnd === rightEnd;
-    }
-    return true;
-  }
-  return left.start.line === right.start.line && left.start.column === right.start.column;
-}
 async function summarizeChangedFiles2(input) {
   const { projectRoot, index, changedFileList, diffHunksByFile, diffKindsByFile, diffChangesByFile, explicitFiles, existenceByFile, deletedSnapshots, loadSource: suppliedLoadSource, includeSymbolDetails, includeDiffContext, diffContextLines, maxCallsites, referenceConcurrency, diagnostics, reviewTimings } = input;
   const readSource = suppliedLoadSource ?? (async (file2) => await fsp39.readFile(file2, "utf8"));
@@ -74644,8 +75698,8 @@ async function summarizeChangedFiles2(input) {
   const defsToResolve = fileEntries.flatMap((entry) => entry.locals);
   const referencesStart = performance11.now();
   const referenceResults = includeSymbolDetails && maxCallsites > 0 ? await mapLimit(defsToResolve, referenceConcurrency, async (def) => {
-    const refs = await referenceCache.get(index, def, {
-      maxReferences: maxCallsites + 1
+    const refs = await referenceCache.getUsages(index, def, {
+      maxReferences: maxCallsites
     });
     return { def, refs };
   }) : [];
@@ -74676,12 +75730,16 @@ async function summarizeChangedFiles2(input) {
     const diffLines = diffLinesByHandle.get(handle) ?? /* @__PURE__ */ new Set();
     const diffSnippets = includeDiffContext && diffLines.size ? collectDiffSnippets(source, local.range, diffLines, diffContextLines) : [];
     let callsites;
+    let callsiteCoverage;
     if (maxCallsites > 0) {
       const entry = referencesByHandle.get(handle);
       const refs = entry?.refs;
       if (refs?.status === "ok") {
-        const candidates = refs.references.filter((ref) => !(fileIdentityKey(ref.file) === fileIdentityKey(local.file) && sameRange(ref.range, local.range)));
-        const limited = candidates.slice(0, maxCallsites).map((ref) => ({
+        callsiteCoverage = refs.referenceCoverage.affectedFiles ? {
+          ...refs.referenceCoverage,
+          affectedFiles: refs.referenceCoverage.affectedFiles.map((file2) => relativePath2(projectRoot, file2))
+        } : refs.referenceCoverage;
+        const limited = refs.references.map((ref) => ({
           file: relativePath2(projectRoot, ref.file),
           range: ref.range
         }));
@@ -74693,7 +75751,8 @@ async function summarizeChangedFiles2(input) {
       ...base,
       ...definitionSnippet,
       ...diffSnippets.length ? { diffSnippets } : {},
-      ...callsites ? { callsites } : {}
+      ...callsites ? { callsites } : {},
+      ...callsiteCoverage ? { callsiteCoverage } : {}
     };
   };
   const summariesWithHandles = await mapLimit(fileEntries, Math.max(1, referenceConcurrency), async ({ file: file2, mod, hunks, locals, handles, diffLinesByHandle }) => {
@@ -76661,6 +77720,7 @@ async function buildExplanation(snapshot, lookup, resolved, request) {
     dependencies: dependencies.items,
     reverseDependencies: reverseDependencies.items,
     references: references.items,
+    ...referenceContext.referenceCoverage ? { referenceCoverage: referenceContext.referenceCoverage } : {},
     relatedSqlObjects: relatedSqlObjects.items,
     duplicates: duplicates.items,
     snippets: snippets.items,
@@ -76878,7 +77938,8 @@ async function collectReferenceContext(snapshot, def, referenceLimit, snippetLim
     return emptyReferenceContext();
   const references = result.references.map((reference) => ({
     file: normalizeAgentFilePath(snapshot.root, reference.file),
-    range: reference.range
+    range: reference.range,
+    ...reference.via?.importBinding ? { importBinding: reference.via.importBinding } : {}
   })).sort((left, right) => {
     const fileDelta = left.file.localeCompare(right.file);
     if (fileDelta !== 0)
@@ -76897,7 +77958,21 @@ async function collectReferenceContext(snapshot, def, referenceLimit, snippetLim
   return {
     references: boundedReferences,
     snippets: boundedSnippets,
-    referencesOmittedLowerBound: result.references.length === collectionLimit && boundedReferences.omitted > 0
+    // Core now reports `truncated` exactly (it probes one past `maxReferences` internally), so
+    // reuse that signal instead of guessing from a boundary count: a returned length that merely
+    // happens to equal `collectionLimit` is not by itself evidence of truncation.
+    referencesOmittedLowerBound: Boolean(result.referenceCoverage.reasons?.includes("truncated")) && boundedReferences.omitted > 0,
+    referenceCoverage: normalizeReferenceCoverage(snapshot, result.referenceCoverage)
+  };
+}
+function normalizeReferenceCoverage(snapshot, coverage) {
+  if (!coverage)
+    return void 0;
+  if (!coverage.affectedFiles)
+    return coverage;
+  return {
+    ...coverage,
+    affectedFiles: coverage.affectedFiles.map((file2) => normalizeAgentFilePath(snapshot.root, file2))
   };
 }
 function snippetFromReference(snapshot, reference) {
@@ -77049,7 +78124,8 @@ function emptyReferenceContext() {
   return {
     references: emptyAgentBoundedList(),
     snippets: emptyAgentBoundedList(),
-    referencesOmittedLowerBound: false
+    referencesOmittedLowerBound: false,
+    referenceCoverage: void 0
   };
 }
 function collectFollowUps(snapshot, resolved, symbols, relFile, duplicates) {
@@ -82285,7 +83361,7 @@ async function analyzeChangedSymbolReferences(context, changedSymbol) {
     let reason = "directRef";
     if (ref.via?.namespaceMember) {
       reason = "namespaceMember";
-    } else if (ref.via?.import) {
+    } else if (ref.via?.import || ref.via?.importBinding) {
       reason = "importAlias";
     }
     const severityResult = calculateSeverity(changedSymbol, ref, [reason], 0, index, context.fanInByFile);
@@ -85439,6 +86515,14 @@ var init_semantic_symbols = __esm({
 // dist/agent/rename-preview.js
 import fs37 from "node:fs/promises";
 import path81 from "node:path";
+function incompleteReferenceCoverageReason(coverage) {
+  if (coverage.state === "complete")
+    return void 0;
+  const reasons = (coverage.reasons ?? []).filter((reason) => reason !== "truncated");
+  if (coverage.reasons?.length && !reasons.length)
+    return void 0;
+  return reasons.length ? `Reference coverage is partial (${reasons.join(", ")}).` : "Reference coverage is partial.";
+}
 async function previewRename(request) {
   const session = createAgentSession({
     root: request.root,
@@ -85459,11 +86543,15 @@ async function previewRenameInSnapshot(snapshot, request, freshness = { state: "
   const semanticReferences = [];
   let referenceFailure;
   try {
-    const referenceResult = await findReferences(snapshot.index, { def: resolved.def }, { maxReferences: maxEdits + 1 });
-    if (referenceResult.status === "ok")
+    const referenceResult = await findRenameReferences(snapshot.index, resolved.def, {
+      maxReferences: maxEdits + 1
+    });
+    if (referenceResult.status === "ok") {
       semanticReferences.push(...referenceResult.references);
-    else
+      referenceFailure = incompleteReferenceCoverageReason(referenceResult.referenceCoverage);
+    } else {
       referenceFailure = referenceResult.reason;
+    }
   } catch (error51) {
     referenceFailure = errorMessage(error51);
   }
@@ -85525,11 +86613,15 @@ async function previewRenameInSnapshot(snapshot, request, freshness = { state: "
       }
       semanticDefinitions.set(implementation.symbolId, memberDef);
       try {
-        const memberReferences = await findReferences(snapshot.index, { def: memberDef }, { maxReferences: maxEdits + 1 });
-        if (memberReferences.status === "ok")
+        const memberReferences = await findRenameReferences(snapshot.index, memberDef, {
+          maxReferences: maxEdits + 1
+        });
+        if (memberReferences.status === "ok") {
           semanticReferences.push(...memberReferences.references);
-        else
+          referenceFailure ??= incompleteReferenceCoverageReason(memberReferences.referenceCoverage);
+        } else {
           referenceFailure ??= memberReferences.reason;
+        }
       } catch (error51) {
         referenceFailure ??= errorMessage(error51);
       }
@@ -85590,7 +86682,7 @@ async function previewRenameInSnapshot(snapshot, request, freshness = { state: "
     ...selectedReferences.map((reference) => ({
       file: reference.file,
       range: reference.range,
-      kind: "reference",
+      kind: reference.via?.importBinding === "imported" ? "import" : "reference",
       reference
     }))
   ];
@@ -86106,14 +87198,25 @@ async function collectImportDeclarationCandidates(references, oldName, loadSourc
   const candidates = [];
   const missing = [];
   const seenBindings = /* @__PURE__ */ new Set();
+  const resolvedBindingKeys = /* @__PURE__ */ new Set();
+  for (const reference of references) {
+    if (reference.via?.importBinding !== "imported")
+      continue;
+    const binding = reference.via.import;
+    if (binding && binding.kind === "named") {
+      resolvedBindingKeys.add(namedImportBindingKey(reference.file, binding));
+    }
+  }
   for (const reference of references) {
     const binding = reference.via?.import;
     if (!binding || binding.kind !== "named" || binding.imported !== oldName)
       continue;
-    const key = `${reference.file}:${binding.from}:${binding.imported}:${binding.local}`;
+    const key = namedImportBindingKey(reference.file, binding);
     if (seenBindings.has(key))
       continue;
     seenBindings.add(key);
+    if (resolvedBindingKeys.has(key))
+      continue;
     const source = await loadSource(reference.file);
     if (!source)
       continue;
@@ -86125,6 +87228,9 @@ async function collectImportDeclarationCandidates(references, oldName, loadSourc
   }
   return { candidates, missing };
 }
+function namedImportBindingKey(file2, binding) {
+  return `${file2}:${binding.from}:${binding.imported}:${binding.local}`;
+}
 async function collectExportDeclarationCandidates(snapshot, target, loadSource) {
   const candidates = [];
   const missingFiles = [];
@@ -86316,9 +87422,12 @@ function isPreservedImportAlias(reference, text, oldName) {
   const binding = reference.via?.import;
   if (!binding || binding.kind === "star" || binding.kind === "namespace")
     return false;
+  if (reference.via?.importBinding === "imported" && binding.kind === "named" && binding.imported === oldName) {
+    return false;
+  }
   if (binding.kind === "default")
     return true;
-  return binding.local !== oldName && text === binding.local;
+  return (binding.explicitAlias || binding.local !== oldName) && text === binding.local;
 }
 function normalizeEdits(edits, unsafeSites, provenance2) {
   const byRange = /* @__PURE__ */ new Map();
@@ -86477,6 +87586,12 @@ async function buildRefactorPlanInSnapshot(snapshot, request, freshness = { stat
       ...includeContext && reference.context ? { context: reference.context } : {}
     };
   });
+  const referenceCoverage = referenceResult.referenceCoverage ? {
+    ...referenceResult.referenceCoverage,
+    ...referenceResult.referenceCoverage.affectedFiles ? {
+      affectedFiles: referenceResult.referenceCoverage.affectedFiles.map((file2) => normalizeAgentFilePath(snapshot.root, file2))
+    } : {}
+  } : void 0;
   const callersResult = findCallHierarchy(snapshot.symbolGraph, resolved.id, "incoming", {
     depth: 1,
     limit: callerLimit
@@ -86569,6 +87684,7 @@ async function buildRefactorPlanInSnapshot(snapshot, request, freshness = { stat
     target,
     definition: target.location,
     references,
+    ...referenceCoverage ? { referenceCoverage } : {},
     callers,
     callees,
     supertypes,
@@ -104493,13 +105609,22 @@ function createCodegraphMcpHandlersForSession(options, session) {
       return { references: [], limit, totalSeen: 0, truncated: false, omitted: 0 };
     }
     const { items, omitted } = boundList(result.references, limit);
-    const references = items.map((reference) => ({ file: relative(reference.file), range: reference.range }));
+    const references = items.map((reference) => ({
+      file: relative(reference.file),
+      range: reference.range,
+      ...reference.via?.importBinding ? { importBinding: reference.via.importBinding } : {}
+    }));
+    const referenceCoverage = result.referenceCoverage ? {
+      ...result.referenceCoverage,
+      ...result.referenceCoverage.affectedFiles ? { affectedFiles: result.referenceCoverage.affectedFiles.map((file2) => relative(file2)) } : {}
+    } : void 0;
     return {
       references,
       limit,
       totalSeen: result.references.length,
       truncated: Boolean(omitted),
-      omitted
+      omitted,
+      ...referenceCoverage ? { referenceCoverage } : {}
     };
   };
   const fileDeps = async (request) => await withFreshness(async () => {
@@ -104630,7 +105755,8 @@ function createCodegraphMcpHandlersForSession(options, session) {
           limit: explanation.limits.references,
           totalSeen: explanation.references.length + explanation.omittedCounts.references,
           truncated: explanation.omittedCounts.references > 0,
-          omitted: explanation.omittedCounts.references
+          omitted: explanation.omittedCounts.references,
+          ...explanation.referenceCoverage ? { referenceCoverage: explanation.referenceCoverage } : {}
         };
       }
       if (file2 === void 0 || line === void 0 || column === void 0) {
@@ -112501,6 +113627,10 @@ function writePrettyReferences(context, result) {
     const { line, column } = reference.range.start;
     context.writeStdoutLine(`${rel}:${line}:${column}`);
   }
+  if (result.referenceCoverage?.state === "partial") {
+    const reasons = result.referenceCoverage.reasons?.length ? ` (${result.referenceCoverage.reasons.join(", ")})` : "";
+    context.writeStdoutLine(`note: reference coverage partial${reasons}`);
+  }
 }
 async function handleGotoCommand(context) {
   let input;