@mrclrchtr/supi-code-intelligence 6.1.0 → 6.2.0

package/node_modules/@mrclrchtr/supi-tree-sitter/src/tool/callees.ts

@@ -1,9 +1,12 @@
 // Structural callee extraction — enclosing-scope lookup with per-language queries.
 
 import type { CodeRequestControl } from "@mrclrchtr/supi-code-runtime/api";
+import { validatePublicPositionBounds } from "../coordinates.ts";
 import { detectGrammar } from "../language.ts";
 import type { GrammarId, SourceRange, TreeSitterResult } from "../types.ts";
 import { queryParsedFile, type TreeSitterRuntime } from "../worker/runtime.ts";
+import { normalizeCallName } from "./call-name.ts";
+import { extractScopeName } from "./scope.ts";
 
 /** Result shape returned by lookupCalleesAt. */
 export interface CalleesAtResult {
@@ -25,13 +28,13 @@ const CALLEE_QUERIES: Partial<Record<GrammarId, string>> = {
   typescript: "(call_expression function: (_) @callee) (new_expression constructor: (_) @callee)",
   tsx: "(call_expression function: (_) @callee) (new_expression constructor: (_) @callee)",
   python: "(call function: (_) @callee)",
-  rust: "(call_expression function: (_) @callee) (macro_invocation) @callee",
+  rust: "(call_expression function: (_) @callee) (macro_invocation macro: (_) @callee)",
   go: "(call_expression function: (_) @callee)",
   c: "(call_expression function: (_) @callee)",
   cpp: "(call_expression function: (_) @callee)",
-  java: "(method_invocation name: (_) @callee) (object_creation_expression type: (_) @callee)",
-  kotlin: "(call_expression . (_) @callee)",
-  ruby: "(call method: (_) @callee)",
+  java: "(method_invocation) @callee (object_creation_expression type: (_) @callee)",
+  kotlin: "(call_expression) @callee",
+  ruby: "(call) @callee",
   bash: "(command . (_) @callee)",
   r: "(call function: (_) @callee)",
 };
@@ -57,63 +60,22 @@ const ENCLOSING_SCOPE_TYPES: Record<GrammarId, ReadonlySet<string>> = {
     "arrow_function",
     "function_expression",
   ]),
-  python: new Set(["function_definition"]),
-  rust: new Set(["function_item"]),
-  go: new Set(["function_declaration"]),
+  python: new Set(["function_definition", "lambda"]),
+  rust: new Set(["function_item", "closure_expression"]),
+  go: new Set(["function_declaration", "method_declaration", "func_literal"]),
   c: new Set(["function_definition"]),
-  cpp: new Set(["function_definition"]),
-  java: new Set(["method_declaration"]),
-  kotlin: new Set(["function_declaration"]),
-  ruby: new Set(["method"]),
+  cpp: new Set(["function_definition", "lambda_expression"]),
+  java: new Set(["method_declaration", "constructor_declaration", "lambda_expression"]),
+  kotlin: new Set(["function_declaration", "lambda_literal", "anonymous_function"]),
+  ruby: new Set(["method", "block", "do_block", "lambda"]),
   bash: new Set(["function_definition"]),
   r: new Set(["function_definition"]),
   html: new Set(),
   sql: new Set(),
 };
 
-// ── Name extraction from enclosing scope text ─────────────────────────
-
-/** Extract a best-effort name from an enclosing scope node's source text. */
-function extractScopeName(_type: string, text: string): string {
-  // JS/TS/Go/Rust: `function foo` or `fn foo` or `def foo`
-  // Python: `def foo`
-  const firstLine = text.split("\n")[0] ?? text;
-  const match = firstLine.match(/(?:function|fn|func|def|method)\s+(\w+)/);
-  if (match?.[1]) return match[1];
-
-  // Ruby: `def foo`
-  const rubyMatch = firstLine.match(/def\s+(\w+)/);
-  if (rubyMatch?.[1]) return rubyMatch[1];
-
-  // Bash: `foo()`
-  const bashMatch = firstLine.match(/^(\w+)\s*\(\)/);
-  if (bashMatch?.[1]) return bashMatch[1];
-
-  // Kotlin/Java: `fun foo` or `fun Foo.bar()` — extract the last name part
-  const kotlinMatch = firstLine.match(/fun\s+(?:[\w.]+\.)?(\w+)/);
-  if (kotlinMatch?.[1]) return kotlinMatch[1];
-
-  // C++: type name(params) { — heuristic: first word before `(`
-  const cLikeMatch = firstLine.match(
-    /(\w+)\s*\([^)]*\)\s*(?:const\s*)?(?:override\s*)?(?:final\s*)?[{;]/,
-  );
-  if (cLikeMatch?.[1]) return cLikeMatch[1];
-
-  return "anonymous";
-}
-
 // ── Main entrypoint ──────────────────────────────────────────────────
 
-/**
- * Extract direct structural callee calls for a file at the given position.
- *
- * 1. Parses the file with the Tree-sitter runtime.
- * 2. Finds the enclosing function/method/callback scope at the position.
- * 3. Runs a grammar-specific callee query.
- * 4. Filters to captures within that enclosing scope.
- * 5. Excludes nested function/method/callback scopes that do not contain the anchor.
- * 6. Deduplicates by name.
- */
 /** Validate that coordinates are usable and grammar is supported. */
 function validateCalleeInput(
   filePath: string,
@@ -168,6 +130,16 @@ function findEnclosingScope(
   return null;
 }
 
+/**
+ * Extract direct structural callee calls for a file at the given position.
+ *
+ * 1. Parses the file with the Tree-sitter runtime.
+ * 2. Finds the enclosing function/method/callback scope at the position.
+ * 3. Runs a grammar-specific callee query.
+ * 4. Filters to captures within that enclosing scope.
+ * 5. Excludes nested function/method/callback scopes that do not contain the anchor.
+ * 6. Deduplicates by name.
+ */
 // biome-ignore lint/complexity/useMaxParams: provider function needs runtime + coordinates + depth
 export async function lookupCalleesAt(
   runtime: TreeSitterRuntime,
@@ -189,6 +161,9 @@ export async function lookupCalleesAt(
   const { tree, source } = parseResult.data;
 
   try {
+    const boundsError = validatePublicPositionBounds(line, character, source);
+    if (boundsError) return boundsError;
+
     const scopes = ENCLOSING_SCOPE_TYPES[grammarId];
     const tsPoint = { row: line - 1, column: character - 1 };
     const node = tree.rootNode.descendantForPosition(tsPoint);
@@ -230,10 +205,17 @@ export async function lookupCalleesAt(
       };
     }
 
-    const callees = filterCalleeCaptures(queryResult.data, enclosingNode, scopes, tsPoint, depth);
+    const callees = filterCalleeCaptures(
+      queryResult.data,
+      grammarId,
+      enclosingNode,
+      scopes,
+      tsPoint,
+      depth,
+    );
 
     const enclosingRange = nodeToSourceRange(enclosingNode);
-    const scopeName = extractScopeName(enclosingNode.type, enclosingNode.text);
+    const scopeName = extractScopeName(enclosingNode);
 
     return {
       kind: "success",
@@ -329,7 +311,8 @@ function containsPoint(
 // biome-ignore lint/complexity/useMaxParams: filtering needs captures + node context + depth
 // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: filtering combines scope containment, column-aware inner-scope exclusion, and dedup in one cohesive pass
 function filterCalleeCaptures(
-  captures: Array<{ range: SourceRange; text: string }>,
+  captures: Array<{ nodeType: string; range: SourceRange; text: string }>,
+  grammarId: GrammarId,
   // biome-ignore lint/suspicious/noExplicitAny: tree-sitter SyntaxNode is complex
   enclosingNode: any,
   scopeTypes: ReadonlySet<string>,
@@ -382,7 +365,7 @@ function filterCalleeCaptures(
       if (isInInner) continue;
     }
 
-    const name = capture.text.replace(/\s+/g, "").slice(0, 60);
+    const name = normalizeCallName(capture.text, grammarId, capture.nodeType);
     if (name.length === 0 || seen.has(name)) continue;
     seen.add(name);
 

package/node_modules/@mrclrchtr/supi-tree-sitter/src/tool/exports.ts

@@ -5,6 +5,7 @@ import { nodeToRange } from "../coordinates.ts";
 import type { SyntaxNodeLike } from "../syntax-node.ts";
 import type { ExportRecord, TreeSitterResult } from "../types.ts";
 import type { TreeSitterRuntime } from "../worker/runtime.ts";
+import { extractBindingIdentifiers } from "./js-binding-pattern.ts";
 
 /** Extract export records from a supported file. */
 export async function extractExports(
@@ -120,13 +121,9 @@ function extractLexicalDeclarationExports(
 ): void {
   for (const child of decl.children) {
     if (child.type !== "variable_declarator") continue;
-    const nameNode = findNameNode(child);
-    if (!nameNode) continue;
-    exports.push({
-      name: nameNode.text,
-      kind: "variable",
-      range: nodeToRange(child, source),
-    });
+    const names = extractBindingIdentifiers(child.childForFieldName("name"));
+    const range = nodeToRange(child, source);
+    for (const name of names) exports.push({ name, kind: "variable", range });
   }
 }
 
@@ -139,6 +136,11 @@ function extractAmbientDeclarationExport(
   const nested = decl.children.find((child) => child.type !== "declare" && child.type !== ";");
   if (!nested) return;
 
+  if (nested.type === "lexical_declaration") {
+    extractLexicalDeclarationExports(nested, source, exports);
+    return;
+  }
+
   const name = getDeclarationName(nested);
   if (!name) return;
 

package/node_modules/@mrclrchtr/supi-tree-sitter/src/tool/js-binding-pattern.ts

@@ -0,0 +1,26 @@
+import type { SyntaxNodeLike } from "../syntax-node.ts";
+
+/** Extract every identifier bound by one JavaScript or TypeScript pattern. */
+export function extractBindingIdentifiers(pattern: SyntaxNodeLike | null): string[] {
+  if (!pattern) return [];
+
+  switch (pattern.type) {
+    case "identifier":
+      return [pattern.text];
+    case "shorthand_property_identifier_pattern":
+      return [pattern.text];
+    case "pair_pattern":
+    case "pair":
+      return extractBindingIdentifiers(pattern.childForFieldName("value"));
+    case "object_assignment_pattern":
+    case "assignment_pattern":
+      return extractBindingIdentifiers(pattern.childForFieldName("left"));
+    case "rest_pattern":
+      return pattern.children.flatMap((child) => extractBindingIdentifiers(child));
+    case "object_pattern":
+    case "array_pattern":
+      return pattern.children.flatMap((child) => extractBindingIdentifiers(child));
+    default:
+      return [];
+  }
+}

package/node_modules/@mrclrchtr/supi-tree-sitter/src/tool/node-at.ts

@@ -1,7 +1,7 @@
 // Node-at-position lookup.
 
 import type { CodeRequestControl } from "@mrclrchtr/supi-code-runtime/api";
-import { nodeToRange, publicToTreeSitter, splitSourceLines } from "../coordinates.ts";
+import { nodeToRange, publicToTreeSitter, validatePublicPositionBounds } from "../coordinates.ts";
 import type { NodeAtResult, SourceRange, TreeSitterResult } from "../types.ts";
 import type { TreeSitterRuntime } from "../worker/runtime.ts";
 
@@ -28,7 +28,7 @@ export async function lookupNodeAt(
   const { tree, source } = parseResult.data;
 
   try {
-    const boundsError = validateBounds(line, character, source);
+    const boundsError = validatePublicPositionBounds(line, character, source);
     if (boundsError) return boundsError;
 
     const tsPoint = publicToTreeSitter(line, character, source);
@@ -52,25 +52,6 @@ export async function lookupNodeAt(
   }
 }
 
-/** Validate that a requested public position exists in the source text. */
-function validateBounds(
-  line: number,
-  character: number,
-  source: string,
-): TreeSitterResult<NodeAtResult> | null {
-  const lines = splitSourceLines(source);
-  if (line > lines.length) {
-    return { kind: "validation-error", message: "line is beyond end of file" };
-  }
-
-  const lineText = lines[line - 1] ?? "";
-  if (character > lineText.length + 1) {
-    return { kind: "validation-error", message: "character is beyond end of line" };
-  }
-
-  return null;
-}
-
 function collectAncestry(
   node: {
     type: string;

package/node_modules/@mrclrchtr/supi-tree-sitter/src/tool/outline-html-sql.ts

@@ -80,7 +80,7 @@ function sqlType(node: SyntaxNodeLike, source: string): OutlineItem | null {
     ? enumElements.children
         .filter((child) => child.type === "literal")
         .map((child) => ({
-          name: stripSqlQuotes(child.text),
+          name: sqlStringLiteralValue(child.text),
           kind: "enum-member",
           range: nodeToRange(child, source),
         }))
@@ -112,10 +112,12 @@ function sqlColumns(node: SyntaxNodeLike, source: string): OutlineItem[] {
 function sqlInlineConstraints(node: SyntaxNodeLike, source: string): OutlineItem[] {
   const marker = node.children.findIndex((child) => child.type === "keyword_constraint");
   if (marker < 0) return [];
-  const name = node.children.slice(marker + 1).find((child) => child.type === "literal");
-  return name
-    ? [{ name: stripSqlQuotes(name.text), kind: "constraint", range: nodeToRange(name, source) }]
-    : [];
+  const nameNode = node.children
+    .slice(marker + 1)
+    .find((child) => child.type === "literal" || child.type === "identifier");
+  const name = readSqlNameAfterKeyword(node.text, "CONSTRAINT");
+  if (!name || !nameNode) return [];
+  return [{ name, kind: "constraint", range: nodeToRange(nameNode, source) }];
 }
 
 function sqlSchemaChildren(node: SyntaxNodeLike, source: string): OutlineItem[] {
@@ -139,21 +141,29 @@ function sqlItem(
 }
 
 function sqlMember(node: SyntaxNodeLike, kind: string, source: string): OutlineItem | null {
+  const textName =
+    kind === "constraint"
+      ? readSqlNameAfterKeyword(node.text, "CONSTRAINT")
+      : readSqlIdentifier(node.text);
   const name = node.childForFieldName("name") ?? directChild(node, "identifier");
-  return name ? { name: stripSqlQuotes(name.text), kind, range: nodeToRange(node, source) } : null;
+  const value = textName ?? (name ? normalizeSqlIdentifierLike(name.text) : null);
+  return value ? { name: value, kind, range: nodeToRange(node, source) } : null;
 }
 
 function sqlDeclarationName(node: SyntaxNodeLike): string | null {
-  if (node.type === "create_index") {
-    const indexName = node.childForFieldName("column");
-    return indexName ? stripSqlQuotes(indexName.text) : null;
+  const keyword = SQL_DECLARATION_KEYWORDS[node.type];
+  if (keyword) {
+    const name = readSqlNameAfterKeyword(node.text, keyword);
+    if (name) return name;
   }
+
   const reference = directChild(node, "object_reference");
   if (reference) {
     const name = reference.childForFieldName("name") ?? lastDirectChild(reference, "identifier");
-    if (name) return name.text;
+    if (name) return normalizeSqlIdentifierLike(name.text);
   }
-  return directChild(node, "identifier")?.text ?? null;
+  const name = directChild(node, "identifier");
+  return name ? normalizeSqlIdentifierLike(name.text) : null;
 }
 
 function directChild(node: SyntaxNodeLike, type: string): SyntaxNodeLike | null {
@@ -168,12 +178,119 @@ function lastDirectChild(node: SyntaxNodeLike, type: string): SyntaxNodeLike | n
   return null;
 }
 
-function stripSqlQuotes(value: string): string {
+function normalizeSqlIdentifierLike(value: string): string {
+  if (value.startsWith('"') && value.endsWith('"')) {
+    return value.slice(1, -1).replaceAll('""', '"');
+  }
+  if (value.startsWith("'") && value.endsWith("'")) {
+    return sqlStringLiteralValue(value);
+  }
+  return value;
+}
+
+function sqlStringLiteralValue(value: string): string {
   return value.startsWith("'") && value.endsWith("'")
     ? value.slice(1, -1).replaceAll("''", "'")
     : value;
 }
 
+function readSqlNameAfterKeyword(text: string, keyword: string): string | null {
+  const marker = findSqlKeyword(text, keyword);
+  if (marker < 0) return null;
+  let position = skipSqlSpace(text, marker + keyword.length);
+  for (const optional of ["CONCURRENTLY", "IF", "NOT", "EXISTS"]) {
+    if (readSqlWord(text, position) === optional) {
+      position = skipSqlSpace(text, position + optional.length);
+    }
+  }
+  const name = readSqlQualifiedIdentifier(text, position);
+  return name ? normalizeSqlIdentifierLike(name) : null;
+}
+
+function readSqlIdentifier(text: string): string | null {
+  const name = readSqlQualifiedIdentifier(text, 0);
+  return name ? normalizeSqlIdentifierLike(name) : null;
+}
+
+function readSqlQualifiedIdentifier(text: string, start: number): string | null {
+  let position = skipSqlSpace(text, start);
+  let last: string | null = null;
+  while (position < text.length) {
+    const token = readSqlIdentifierToken(text, position);
+    if (!token) break;
+    last = token.value;
+    position = skipSqlSpace(text, token.end);
+    if (text[position] !== ".") break;
+    position = skipSqlSpace(text, position + 1);
+  }
+  return last;
+}
+
+function readSqlIdentifierToken(
+  text: string,
+  start: number,
+): { value: string; end: number } | null {
+  if (text[start] === '"' || text[start] === "'") {
+    const quote = text[start];
+    let position = start + 1;
+    while (position < text.length) {
+      if (text[position] !== quote) {
+        position += 1;
+        continue;
+      }
+      if (text[position + 1] === quote) {
+        position += 2;
+        continue;
+      }
+      position += 1;
+      return { value: text.slice(start, position), end: position };
+    }
+    return null;
+  }
+
+  let position = start;
+  while (position < text.length && !/[\s(;.,]/.test(text[position] ?? "")) position += 1;
+  return position > start ? { value: text.slice(start, position), end: position } : null;
+}
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: quoted SQL names need a small lexical scan before keyword recovery
+function findSqlKeyword(text: string, keyword: string): number {
+  const upper = text.toUpperCase();
+  let quote: '"' | "'" | null = null;
+  for (let position = 0; position < text.length; position += 1) {
+    const character = text[position];
+    if (quote !== null) {
+      if (character === quote && text[position + 1] === quote) {
+        position += 1;
+      } else if (character === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      continue;
+    }
+    if (!upper.startsWith(keyword, position)) continue;
+    const before = upper[position - 1] ?? " ";
+    const after = upper[position + keyword.length] ?? " ";
+    if (!/[A-Z0-9_]/.test(before) && !/[A-Z0-9_]/.test(after)) return position;
+  }
+  return -1;
+}
+
+function readSqlWord(text: string, start: number): string | null {
+  const end = text.slice(start).search(/\s/);
+  const wordEnd = end < 0 ? text.length : start + end;
+  return wordEnd > start ? text.slice(start, wordEnd).toUpperCase() : null;
+}
+
+function skipSqlSpace(text: string, start: number): number {
+  let position = start;
+  while (/\s/.test(text[position] ?? "")) position += 1;
+  return position;
+}
+
 function one(item: OutlineItem | null): OutlineItem[] {
   return item ? [item] : [];
 }
@@ -184,3 +301,18 @@ const HTML_ELEMENT_TYPES = new Set([
   "self_closing_tag",
   "style_element",
 ]);
+
+const SQL_DECLARATION_KEYWORDS: Record<string, string> = {
+  create_schema: "SCHEMA",
+  create_type: "TYPE",
+  create_table: "TABLE",
+  create_view: "VIEW",
+  create_materialized_view: "VIEW",
+  create_index: "INDEX",
+  create_sequence: "SEQUENCE",
+  create_function: "FUNCTION",
+  create_trigger: "TRIGGER",
+  create_database: "DATABASE",
+  create_role: "ROLE",
+  create_extension: "EXTENSION",
+};

package/node_modules/@mrclrchtr/supi-tree-sitter/src/tool/outline.ts

@@ -3,6 +3,7 @@
 import { nodeToRange } from "../coordinates.ts";
 import type { SyntaxNodeLike } from "../syntax-node.ts";
 import type { OutlineItem } from "../types.ts";
+import { extractBindingIdentifiers } from "./js-binding-pattern.ts";
 import { extractPolyglotOutlineItems } from "./outline-polyglot.ts";
 
 /** Node types that can be extracted directly as outline items. */
@@ -18,6 +19,7 @@ const OUTLINE_DECLARATION_NODE_TYPES = new Set([
   "method_definition",
   "public_field_definition",
   "variable_declarator",
+  "lexical_declaration",
   "ambient_declaration",
   "internal_module",
   "module",
@@ -39,20 +41,27 @@ function collectItems(node: SyntaxNodeLike, source: string): OutlineItem[] {
       continue;
     }
 
-    const item = extractItem(child, source);
-    if (item) items.push(item);
+    const extractedItems = extractItems(child, source);
+    if (extractedItems) items.push(...extractedItems);
     else items.push(...collectItems(child, source));
   }
 
   return items;
 }
 
+function extractItems(node: SyntaxNodeLike, source: string): OutlineItem[] | null {
+  if (node.type === "lexical_declaration") return extractLexicalDeclarationItems(node, source);
+  if (node.type === "ambient_declaration") return extractAmbientDeclarationItems(node, source);
+  if (node.type === "export_statement") return extractExportStatement(node, source);
+
+  const item = extractItem(node, source);
+  return item ? [item] : null;
+}
+
 function extractItem(node: SyntaxNodeLike, source: string): OutlineItem | null {
   switch (node.type) {
-    case "export_statement":
-      return extractExportStatement(node, source);
     case "lexical_declaration":
-      return extractLexicalDeclaration(node, source);
+      return extractLexicalDeclarationItems(node, source)[0] ?? null;
     case "function_declaration":
     case "generator_function_declaration":
     case "function_signature":
@@ -72,7 +81,7 @@ function extractItem(node: SyntaxNodeLike, source: string): OutlineItem | null {
     case "public_field_definition":
       return extractFieldDefinition(node, source);
     case "variable_declarator":
-      return extractVariableDeclarator(node, source);
+      return extractVariableDeclaratorItems(node, source)[0] ?? null;
     case "ambient_declaration":
       return extractAmbientDeclaration(node, source);
     case "internal_module":
@@ -83,38 +92,36 @@ function extractItem(node: SyntaxNodeLike, source: string): OutlineItem | null {
   }
 }
 
-/** Extract an outline item from an export wrapper without exposing non-extractable syntax nodes. */
-function extractExportStatement(node: SyntaxNodeLike, source: string): OutlineItem | null {
+/** Extract outline items from an export wrapper without exposing local syntax nodes. */
+function extractExportStatement(node: SyntaxNodeLike, source: string): OutlineItem[] {
   const decl = node.children.find((child) => OUTLINE_DECLARATION_NODE_TYPES.has(child.type));
   if (decl) {
+    if (decl.type === "lexical_declaration") return extractLexicalDeclarationItems(decl, source);
+    if (decl.type === "ambient_declaration") return extractAmbientDeclarationItems(decl, source);
     const item = extractItem(decl, source);
-    if (item) return item;
+    if (item) return [item];
   }
 
   if (hasDefaultKeyword(node)) {
-    return {
-      name: "default",
-      kind: "export",
-      range: nodeToRange(node, source),
-    };
+    return [{ name: "default", kind: "export", range: nodeToRange(node, source) }];
   }
 
   const exportClause = node.children.find((child) => child.type === "export_clause");
-  if (exportClause) {
-    return {
-      name: node.text.replace(/^export\s+/, "").substring(0, 60),
-      kind: "export",
-      range: nodeToRange(node, source),
-    };
-  }
-
-  return null;
+  return exportClause
+    ? [
+        {
+          name: node.text.replace(/^export\s+/, "").substring(0, 60),
+          kind: "export",
+          range: nodeToRange(node, source),
+        },
+      ]
+    : [];
 }
 
-function extractLexicalDeclaration(node: SyntaxNodeLike, source: string): OutlineItem | null {
-  const declarators = node.children.filter((child) => child.type === "variable_declarator");
-  if (declarators.length !== 1) return null;
-  return extractVariableDeclarator(declarators[0] as SyntaxNodeLike, source);
+function extractLexicalDeclarationItems(node: SyntaxNodeLike, source: string): OutlineItem[] {
+  return node.children
+    .filter((child) => child.type === "variable_declarator")
+    .flatMap((declarator) => extractVariableDeclaratorItems(declarator, source));
 }
 
 function extractNamedDeclaration(
@@ -154,14 +161,11 @@ function extractEnumDeclaration(node: SyntaxNodeLike, source: string): OutlineIt
   return { ...item, children: collectEnumMembers(node, source) };
 }
 
-function extractVariableDeclarator(node: SyntaxNodeLike, source: string): OutlineItem | null {
-  const nameNode = findNameNode(node);
-  if (!nameNode) return null;
-  return {
-    name: nameNode.text,
-    kind: detectKind(node),
-    range: nodeToRange(node, source),
-  };
+function extractVariableDeclaratorItems(node: SyntaxNodeLike, source: string): OutlineItem[] {
+  const names = extractBindingIdentifiers(node.childForFieldName("name"));
+  const kind = detectKind(node);
+  const range = nodeToRange(node, source);
+  return names.map((name) => ({ name, kind, range }));
 }
 
 function extractFieldDefinition(node: SyntaxNodeLike, source: string): OutlineItem | null {
@@ -174,9 +178,18 @@ function extractFieldDefinition(node: SyntaxNodeLike, source: string): OutlineIt
   };
 }
 
-function extractAmbientDeclaration(node: SyntaxNodeLike, source: string): OutlineItem | null {
+function extractAmbientDeclarationItems(node: SyntaxNodeLike, source: string): OutlineItem[] {
   const declaration = node.children.find((child) => OUTLINE_DECLARATION_NODE_TYPES.has(child.type));
-  return declaration ? extractItem(declaration, source) : null;
+  if (!declaration) return [];
+  if (declaration.type === "lexical_declaration") {
+    return extractLexicalDeclarationItems(declaration, source);
+  }
+  const item = extractItem(declaration, source);
+  return item ? [item] : [];
+}
+
+function extractAmbientDeclaration(node: SyntaxNodeLike, source: string): OutlineItem | null {
+  return extractAmbientDeclarationItems(node, source)[0] ?? null;
 }
 
 function extractModuleDeclaration(node: SyntaxNodeLike, source: string): OutlineItem | null {