@mrclrchtr/supi-tree-sitter 6.0.1 → 6.2.0

package/src/session/structural-worker-protocol.ts

@@ -1,5 +1,4 @@
 // biome-ignore-all lint/style/noExcessiveLinesPerFile: one private protocol module defines and validates the full closed contract
-import type { CodeRequestControl } from "@mrclrchtr/supi-code-runtime/api";
 import { isDebugOperationId } from "@mrclrchtr/supi-core/debug";
 import type { TreeSitterResult } from "../types.ts";
 import type { StructuralTimingEvent } from "./structural-timing.ts";
@@ -120,6 +119,45 @@ export type StructuralProtocolValidation<T> =
   | { readonly kind: "valid"; readonly message: T }
   | { readonly kind: "invalid"; readonly reason: string };
 
+/** Validate one operation before it enters the Structural Worker mailbox. */
+export function validateStructuralWorkerOperation(
+  value: unknown,
+): StructuralProtocolValidation<StructuralWorkerOperation> {
+  if (!isRecord(value) || typeof value.operation !== "string") {
+    return invalid("Invalid structural operation");
+  }
+
+  switch (value.operation) {
+    case "canParse":
+    case "outline":
+    case "imports":
+    case "exports":
+    case "callSites":
+      return hasExactKeys(value, ["operation", "file"]) && isFileValue(value.file)
+        ? valid(value as unknown as StructuralWorkerOperation)
+        : invalid("Invalid structural operation");
+    case "query":
+      return hasExactKeys(value, ["operation", "file", "query"]) &&
+        isFileValue(value.file) &&
+        isQueryValue(value.query)
+        ? valid(value as unknown as StructuralWorkerOperation)
+        : invalid("Invalid structural operation");
+    case "nodeAt":
+      return hasExactKeys(value, ["operation", "file", "line", "character"]) &&
+        isFileValue(value.file) &&
+        isPositiveInteger(value.line) &&
+        isPositiveInteger(value.character)
+        ? valid(value as unknown as StructuralWorkerOperation)
+        : invalid("Invalid structural operation");
+    case "calleesAt":
+      return isCalleesAtOperation(value)
+        ? valid(value as unknown as StructuralWorkerOperation)
+        : invalid("Invalid structural operation");
+    default:
+      return invalid("Invalid structural operation");
+  }
+}
+
 /** Validate an untrusted request before the Structural Worker executes it. */
 export function validateStructuralWorkerRequest(
   value: unknown,
@@ -128,7 +166,7 @@ export function validateStructuralWorkerRequest(
   const required = ["kind", "version", "generation", "requestId", "input", "cancellationFlag"];
   const allowed = new Set([...required, "operationId", "deadline"]);
   if (
-    required.some((key) => !(key in value)) ||
+    required.some((key) => !Object.hasOwn(value, key)) ||
     Object.keys(value).some((key) => !allowed.has(key))
   ) {
     return invalid("Invalid structural request envelope");
@@ -138,7 +176,6 @@ export function validateStructuralWorkerRequest(
     value.version !== STRUCTURAL_WORKER_PROTOCOL_VERSION ||
     !isPositiveInteger(value.generation) ||
     !isRequestId(value.requestId) ||
-    !isRecord(value.input) ||
     !(value.cancellationFlag instanceof SharedArrayBuffer) ||
     value.cancellationFlag.byteLength !== Int32Array.BYTES_PER_ELEMENT ||
     (value.deadline !== undefined &&
@@ -147,7 +184,71 @@ export function validateStructuralWorkerRequest(
   ) {
     return invalid("Invalid structural request");
   }
-  return valid(value as unknown as StructuralWorkerRequestMessage);
+  const operation = validateStructuralWorkerOperation(value.input);
+  return operation.kind === "valid"
+    ? valid(value as unknown as StructuralWorkerRequestMessage)
+    : invalid(operation.reason);
+}
+
+/** Validate an untrusted cancellation envelope before it reaches the Worker state machine. */
+export function validateStructuralWorkerCancel(
+  value: unknown,
+): StructuralProtocolValidation<StructuralWorkerCancelMessage> {
+  if (!isRecord(value)) return invalid("Structural Worker cancel must be an object");
+  if (!hasExactKeys(value, ["kind", "version", "generation", "requestId"])) {
+    return invalid("Invalid structural cancel envelope");
+  }
+  if (
+    value.kind !== "cancel" ||
+    value.version !== STRUCTURAL_WORKER_PROTOCOL_VERSION ||
+    !isPositiveInteger(value.generation) ||
+    !isRequestId(value.requestId)
+  ) {
+    return invalid("Invalid structural cancel");
+  }
+  return valid(value as unknown as StructuralWorkerCancelMessage);
+}
+
+/** Validate an untrusted chunk acknowledgement before it reaches the Worker state machine. */
+export function validateStructuralWorkerChunkAck(
+  value: unknown,
+): StructuralProtocolValidation<StructuralWorkerChunkAckMessage> {
+  if (!isRecord(value)) return invalid("Structural Worker chunk acknowledgement must be an object");
+  if (!hasExactKeys(value, ["kind", "version", "generation", "requestId", "sequence"])) {
+    return invalid("Invalid structural chunk acknowledgement envelope");
+  }
+  if (
+    value.kind !== "chunk-ack" ||
+    value.version !== STRUCTURAL_WORKER_PROTOCOL_VERSION ||
+    !isPositiveInteger(value.generation) ||
+    !isRequestId(value.requestId) ||
+    !isNonNegativeInteger(value.sequence)
+  ) {
+    return invalid("Invalid structural chunk acknowledgement");
+  }
+  return valid(value as unknown as StructuralWorkerChunkAckMessage);
+}
+
+/** Validate any untrusted message sent from the parent to the Structural Worker. */
+export function validateParentToStructuralWorkerMessage(
+  value: unknown,
+): StructuralProtocolValidation<ParentToStructuralWorkerMessage> {
+  if (!isRecord(value)) return invalid("Structural Worker parent message must be an object");
+  switch (value.kind) {
+    case "request":
+      return validateStructuralWorkerRequest(value);
+    case "cancel":
+      return validateStructuralWorkerCancel(value);
+    case "chunk-ack":
+      return validateStructuralWorkerChunkAck(value);
+    default:
+      return invalid("Unknown Structural Worker parent message kind");
+  }
+}
+
+/** Read a generation only when the parent message has a safe positive integer shape. */
+export function getStructuralWorkerMessageGeneration(value: unknown): number | undefined {
+  return isRecord(value) && isPositiveInteger(value.generation) ? value.generation : undefined;
 }
 
 /** Encode one complete structural result into fixed-size binary chunks. */
@@ -219,11 +320,6 @@ export function validateWorkerToParentMessage(
   }
 }
 
-/** Build the exact request control represented by one Worker request. */
-export interface StructuralWorkerRequestControl extends CodeRequestControl {
-  readonly cancellationFlag: Int32Array;
-}
-
 function validateChunk(
   value: Record<string, unknown>,
 ): StructuralProtocolValidation<StructuralWorkerChunkMessage> {
@@ -439,10 +535,39 @@ function isPositiveInteger(value: unknown): value is number {
   return Number.isSafeInteger(value) && Number(value) > 0;
 }
 
+function isNonNegativeInteger(value: unknown): value is number {
+  return Number.isSafeInteger(value) && Number(value) >= 0;
+}
+
 function isRequestId(value: unknown): value is string {
   return typeof value === "string" && value.length > 0 && value.length <= 128;
 }
 
+function isCalleesAtOperation(value: Record<string, unknown>): boolean {
+  const keysValid =
+    hasExactKeys(value, ["operation", "file", "line", "character"]) ||
+    hasExactKeys(value, ["operation", "file", "line", "character", "depth"]);
+  return (
+    keysValid &&
+    isFileValue(value.file) &&
+    isPositiveInteger(value.line) &&
+    isPositiveInteger(value.character) &&
+    (!("depth" in value) || value.depth === "direct" || value.depth === "deep")
+  );
+}
+
+function isFileValue(value: unknown): value is string {
+  return isNonBlankString(value, 16_384);
+}
+
+function isQueryValue(value: unknown): value is string {
+  return isNonBlankString(value, 10_000);
+}
+
+function isNonBlankString(value: unknown, maxLength: number): value is string {
+  return typeof value === "string" && value.trim().length > 0 && value.length <= maxLength;
+}
+
 function valid<T>(message: T): StructuralProtocolValidation<T> {
   return { kind: "valid", message };
 }

package/src/tool/call-name.ts

@@ -0,0 +1,96 @@
+import type { GrammarId } from "../types.ts";
+
+/** Normalize one grammar node that represents a call callee. */
+export function normalizeCallName(text: string, grammarId: GrammarId, nodeType: string): string {
+  const normalized = text.trim().replace(/\s+/g, " ");
+  switch (grammarId) {
+    case "java":
+      return nodeType === "method_invocation"
+        ? stripFinalInvocationArguments(normalized)
+        : normalized;
+    case "kotlin":
+      return nodeType === "call_expression" ? stripKotlinCallSuffix(normalized) : normalized;
+    case "ruby":
+      return nodeType === "call" ? stripRubyCallSuffix(normalized) : normalized;
+    default:
+      return normalized;
+  }
+}
+
+function stripKotlinCallSuffix(text: string): string {
+  const lambda = topLevelIndex(text, "{");
+  const withoutLambda = lambda >= 0 ? text.slice(0, lambda).trim() : text;
+  return stripFinalInvocationArguments(withoutLambda);
+}
+
+function stripRubyCallSuffix(text: string): string {
+  const block = topLevelKeywordIndex(text, "do");
+  const withoutBlock = block >= 0 ? text.slice(0, block).trim() : text;
+  const bracedBlock = topLevelIndex(withoutBlock, "{");
+  const withoutSuffix = bracedBlock >= 0 ? withoutBlock.slice(0, bracedBlock).trim() : withoutBlock;
+  const withoutArguments = stripFinalInvocationArguments(withoutSuffix);
+  const whitespace = topLevelWhitespaceIndex(withoutArguments);
+  return whitespace >= 0 ? withoutArguments.slice(0, whitespace).trim() : withoutArguments;
+}
+
+function stripFinalInvocationArguments(text: string): string {
+  if (!text.endsWith(")")) return text;
+  const openingIndex = findLastTopLevelOpening(text);
+  return openingIndex >= 0 ? text.slice(0, openingIndex).trim() : text;
+}
+
+function findLastTopLevelOpening(text: string): number {
+  let openingIndex = -1;
+  scanTopLevel(text, (character, index, depth) => {
+    if (character === "(" && depth === 0) openingIndex = index;
+    return false;
+  });
+  return openingIndex;
+}
+
+function topLevelKeywordIndex(text: string, keyword: string): number {
+  const marker = ` ${keyword}`;
+  const index = topLevelIndex(text, marker);
+  return index >= 0 ? index + 1 : -1;
+}
+
+function topLevelIndex(text: string, marker: string): number {
+  return scanTopLevel(
+    text,
+    (_character, index, depth) => depth === 0 && text.startsWith(marker, index),
+  );
+}
+
+function topLevelWhitespaceIndex(text: string): number {
+  return scanTopLevel(text, (character, _index, depth) => depth === 0 && /\s/.test(character));
+}
+
+function scanTopLevel(
+  text: string,
+  visit: (character: string, index: number, depth: number) => boolean,
+): number {
+  let depth = 0;
+  let quote: string | null = null;
+  for (let index = 0; index < text.length; index += 1) {
+    const character = text[index] ?? "";
+    if (quote !== null) {
+      if (character === quote && text[index - 1] !== "\\") quote = null;
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      continue;
+    }
+    if (visit(character, index, depth)) return index;
+    depth = updateDepth(character, depth);
+  }
+  return -1;
+}
+
+function updateDepth(character: string, depth: number): number {
+  if (character === "(" || character === "[" || character === "{") return depth + 1;
+  if (character === ")" || character === "]" || character === "}") {
+    return Math.max(0, depth - 1);
+  }
+  return depth;
+}

package/src/tool/call-sites.ts

@@ -4,6 +4,7 @@ import type { CodeRequestControl } from "@mrclrchtr/supi-code-runtime/api";
 import { detectGrammar } from "../language.ts";
 import type { CallSiteMatch, GrammarId, TreeSitterResult } from "../types.ts";
 import type { TreeSitterRuntime } from "../worker/runtime.ts";
+import { normalizeCallName } from "./call-name.ts";
 
 // ── Per-grammar call-site queries ─────────────────────────────────────
 
@@ -21,18 +22,16 @@ const CALL_SITE_QUERIES: Partial<Record<GrammarId, string>> = {
   javascript: JS_TS_CALL_SITE_QUERY,
   typescript: JS_TS_CALL_SITE_QUERY,
   tsx: JS_TS_CALL_SITE_QUERY,
-  python:
-    "(call function: (identifier) @call) (call function: (attribute attribute: (identifier) @call))",
-  rust: "(call_expression function: (identifier) @call) (call_expression function: (field_expression field: (field_identifier) @call)) (macro_invocation macro: (identifier) @call)",
-  go: "(call_expression function: (identifier) @call) (call_expression function: (selector_expression field: (field_identifier) @call))",
-  c: "(call_expression function: (identifier) @call)",
-  cpp: "(call_expression function: (identifier) @call) (call_expression function: (field_expression field: (field_identifier) @call))",
-  java: "(method_invocation name: (identifier) @call) (object_creation_expression type: (type_identifier) @call)",
-  kotlin:
-    "(call_expression . (simple_identifier) @call) (call_expression . (navigation_expression . (simple_identifier) @call))",
-  ruby: "(call method: (identifier) @call)",
+  python: "(call function: (_) @call)",
+  rust: "(call_expression function: (_) @call) (macro_invocation macro: (_) @call)",
+  go: "(call_expression function: (_) @call)",
+  c: "(call_expression function: (_) @call)",
+  cpp: "(call_expression function: (_) @call)",
+  java: "(method_invocation) @call (object_creation_expression type: (_) @call)",
+  kotlin: "(call_expression) @call",
+  ruby: "(call) @call",
   bash: "(command name: (command_name) @call)",
-  r: "(call function: (identifier) @call)",
+  r: "(call function: (_) @call)",
 };
 
 /** Return whether the call-site extractor has a query for one grammar. */
@@ -78,7 +77,7 @@ export async function extractCallSites(
 
   for (const capture of captures) {
     // Normalize: trim whitespace and collapse internal whitespace to single space
-    const name = capture.text.trim().replace(/\s+/g, " ");
+    const name = normalizeCallName(capture.text, grammarId, capture.nodeType);
     if (name.length === 0) continue;
 
     // Deduplicate by name + line

package/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/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/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/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;