@mrclrchtr/supi-tree-sitter 11.3.0 → 12.0.0

package/README.md

@@ -82,7 +82,7 @@ The `type` filter accepts `class`, `interface`, `type`, `enum`, `struct`, `union
 ### Extraction limits
 
 - TS/JS, Python, Java, Go, Rust, and C/C++ outlines include nested named declarations and members. They are not complete indexes of local variables, parameters, or anonymous expressions. Other languages retain their existing extraction depth. HTML outlines list only elements with non-empty `id` attributes. SQL outlines list supported `CREATE` declarations and first-level table/type members. LaTeX outlines list section headings and selected command, environment, label, acronym, glossary-entry, and color definitions.
-- TypeScript and TSX use [checked build-time grammar patches](scripts/generate-typescript-wasm.mjs) for type-only star re-exports, arrays of qualified import types such as `import("node:fs").Dirent[]`, and import types in generic calls such as `read<import("./api").Value>()` or `read<typeof import("./api")>()`. Runtime parsing retains the original source and coordinates; other grammar gaps still report recovered syntax.
+- TypeScript and TSX use [checked build-time grammar patches](scripts/generate-typescript-wasm.mjs) for type-only star re-exports, arrays of qualified import types such as `import("node:fs").Dirent[]`, import types in generic calls such as `read<import("./api").Value>()` or `read<typeof import("./api")>()`, and import types with type arguments such as `import("typebox").Static<T>`. Runtime parsing retains the original source and coordinates; other grammar gaps still report recovered syntax.
 - JavaScript-family imports collect `import` statements, not CommonJS `require()` calls. Exports collect file-level `export` statements, including TypeScript `export =`; they do not collect `module.exports` assignments or nested namespace exports. An eligible `.cjs` file can therefore return no imports or exports.
 - Python imports retain `import`/`from` module targets, including relative prefixes. Java imports retain ordinary/static targets. Go imports retain single/grouped paths. Rust imports retain explicit `use` paths, `extern crate`, and external `mod` names; inline module bodies are not imports. C/C++ imports retain literal quoted and angle-bracket include targets. Grouped paths use explicit syntax only; no files or bindings are resolved. Conditional directives are written evidence, not proof of active dependencies. Dynamic loaders, computed targets, and C++20 module imports remain outside extraction support.
 - LaTeX imports include package, class, source, and bibliography directives. Bibliography directives can refer to `.bib` files, but the grammar does not parse those files.

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

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

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

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

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

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

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

@@ -34,8 +34,16 @@ export interface SymbolAnchor {
   character: number;
 }
 
-/** Provider-backed nesting evidence for a declaration reported within one document. */
-export type DeclarationNesting = "top-level" | "nested" | "unknown";
+/**
+ * Where a declaration sits within its file, as reported by a provider.
+ *
+ * - `top-level`: directly in the file, not inside another declaration.
+ * - `member`: directly inside a class, interface, enum, struct, namespace,
+ *   module, or object literal (methods, fields, properties, enum members).
+ * - `local`: inside the body of a function, method, or constructor.
+ * - `unknown`: the provider reported a flat symbol list without hierarchy.
+ */
+export type DeclarationLevel = "top-level" | "member" | "local" | "unknown";
 
 /**
  * A discovered symbol / declaration.
@@ -54,7 +62,7 @@ export interface CodeSymbol {
   file: string;
   declarationAnchor: SymbolAnchor;
   nameAnchor?: SymbolAnchor;
-  /** Named symbolic container when reported; absence does not prove top-level nesting. */
+  /** Named enclosing declaration when reported; absence does not prove a top-level declaration. */
   container?: string | null;
 }
 
@@ -63,10 +71,10 @@ export interface CodeSymbol {
  *
  * `unknown` means the provider returned a flat observation without an actual
  * hierarchy. A reported container name remains metadata and does not promote
- * a flat observation to known nesting.
+ * a flat observation to a known level.
  */
 export interface DocumentCodeSymbol extends CodeSymbol {
-  nesting: DeclarationNesting;
+  level: DeclarationLevel;
 }
 
 // ── Result types ───────────────────────────────────────────────────────
@@ -185,31 +193,53 @@ export interface WorkspaceEdit {
 }
 
 /**
- * Supported refactor operation names for the current semantic planning path.
- */
-export type RefactorOperation =
-  | "rename_symbol"
-  | "extract_function"
-  | "extract_variable"
-  | "rename_file"
-  | "move_file"
-  | "update_imports"
-  | "delete_dead_code";
-
-/**
- * Operation-aware refactor planning request.
+ * Operation-aware refactor planning request. Each operation carries only the
+ * scope it needs:
+ *
+ * - `rename_symbol`: one symbol position and the new name.
+ * - `code_action`: one file range and a CodeActionKind prefix under `refactor`.
+ * - `source_action`: one whole file and a CodeActionKind prefix under `source`.
  *
- * Consumers provide a target file/position plus operation-specific options.
- * File/resource operations remain requestable so providers can reject them
- * explicitly and honestly until shared workspace-edit resource ops exist.
+ * `kind` matches the requested kind and its dotted sub-kinds. `title`, when
+ * present, selects one action by its exact title.
  */
-export interface RefactorRequest {
-  operation: RefactorOperation;
-  file: string;
-  position: CodePosition;
-  range?: SourceRange;
-  newName?: string;
-  destination?: string;
+export type RefactorRequest =
+  | {
+      operation: "rename_symbol";
+      file: string;
+      position: CodePosition;
+      newName: string;
+    }
+  | {
+      operation: "code_action";
+      file: string;
+      range: SourceRange;
+      kind: string;
+      title?: string;
+    }
+  | {
+      operation: "source_action";
+      file: string;
+      kind: string;
+      title?: string;
+    };
+
+/** Supported refactor operation names. */
+export type RefactorOperation = RefactorRequest["operation"];
+
+/** The code action selected for a precise code- or source-action plan. */
+export interface RefactorActionIdentity {
+  /** Server-reported CodeActionKind. */
+  kind: string;
+  /** Server-reported action title. */
+  title: string;
+  /**
+   * How the edits were obtained: `edit` from the action itself (after
+   * `codeAction/resolve` when needed), or `captured-command` from the single
+   * `workspace/applyEdit` the server pushed while running the action's command.
+   * Captured edits were refused, never applied.
+   */
+  provenance?: "edit" | "captured-command";
 }
 
 /**
@@ -220,6 +250,10 @@ export interface DisambiguationCandidate {
   file?: string;
   line?: number;
   character?: number;
+  /** Server-reported CodeActionKind, for code-action candidates. */
+  kind?: string;
+  /** Exact action title to pass back as `title`, for code-action candidates. */
+  title?: string;
 }
 
 /**
@@ -233,6 +267,8 @@ export type RefactorResult =
   | {
       kind: "precise";
       edits: WorkspaceEdit;
+      /** The selected code action, for code- and source-action plans. */
+      action?: RefactorActionIdentity;
       /** Provider roots authorized by the semantic route. Consumers canonicalize before storage. */
       authorizedMutationRoots: string[];
     }

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-tree-sitter",
-  "version": "11.3.0",
+  "version": "12.0.0",
   "description": "Structural AST analysis for SuPi code intelligence",
   "license": "MIT",
   "repository": {
@@ -36,8 +36,8 @@
   "dependencies": {
     "jiti": "^2.7.0",
     "web-tree-sitter": "^0.27.0",
-    "@mrclrchtr/supi-code-runtime": "11.3.0",
-    "@mrclrchtr/supi-core": "11.3.0"
+    "@mrclrchtr/supi-code-runtime": "12.0.0",
+    "@mrclrchtr/supi-core": "12.0.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",

package/resources/grammars/tsx/tree-sitter-tsx.wasm.json

@@ -22,7 +22,11 @@
     {
       "id": "import-type-generic-calls-v1",
       "file": "common/define-grammar.js"
+    },
+    {
+      "id": "import-type-member-type-arguments-v1",
+      "file": "common/define-grammar.js"
     }
   ],
-  "sha256": "aaa2904a00000d8e058708845172bd3ce7836566c7e16e9ee594c43f4ba4f451"
+  "sha256": "7c7552ea30a3a6785826e26c12c9dd33410ac577d9cb09a4fa5cf5701665abd8"
 }

package/resources/grammars/typescript/tree-sitter-typescript.wasm.json

@@ -22,7 +22,11 @@
     {
       "id": "import-type-generic-calls-v1",
       "file": "common/define-grammar.js"
+    },
+    {
+      "id": "import-type-member-type-arguments-v1",
+      "file": "common/define-grammar.js"
     }
   ],
-  "sha256": "86ba3af6f8214c90f32af1ea82214a0c1da87c9e2f5ea47c19577ba5b6c78bfb"
+  "sha256": "d9e67877e2da665b26ab837bccd036e267cf1b5f521073e76352ec4af22ded4c"
 }

package/src/coordinates.ts

@@ -100,7 +100,21 @@ export function validatePublicPositionBounds(
   return null;
 }
 
-/** Split source into logical lines without CRLF line-ending bytes. */
+/**
+ * Split source into Tree-sitter rows, dropping the `\r` of CRLF endings.
+ * Tree-sitter rows break only on `\n`, so a lone `\r` is not a line break here.
+ * LSP treats a lone `\r` as a line break, so structural lines after one differ from LSP lines.
+ */
 export function splitSourceLines(source: string): string[] {
-  return source.replace(/\r\n?/g, "\n").split("\n");
+  if (lastSplit?.source === source) return lastSplit.lines;
+  const lines = source.split(/\r?\n/);
+  lastSplit = { source, lines };
+  return lines;
 }
+
+/**
+ * Single-entry cache: range conversion calls this once per node on the same
+ * source, so re-splitting each time made extraction quadratic in file size.
+ * Callers must not mutate the returned array.
+ */
+let lastSplit: { source: string; lines: string[] } | undefined;

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

@@ -331,8 +331,9 @@ export class StructuralWorkerClient {
     try {
       throwIfCodeRequestInterrupted(active.control);
     } catch (error) {
+      // Keep the chunk handshake alive so the Worker can send its terminal message
+      // instead of waiting for the hard stop.
       this.#interrupt(active, error);
-      return;
     }
     active.chunks.push(Uint8Array.from(message.payload));
     active.nextSequence += 1;
@@ -433,7 +434,7 @@ export class StructuralWorkerClient {
       return;
     }
     const worker = this.#worker;
-    if (this.#active !== request || !worker) return;
+    if (this.#active !== request || !worker || request.hardStopTimer) return;
     Atomics.store(request.cancellationFlag, 0, 1);
     if (
       !this.#send(worker, {

package/src/syntax-errors.ts

@@ -4,7 +4,9 @@ import type { GrammarId, SourceRange } from "./types.ts";
 
 /** Return whether a parsed tree contains an explicit or recovered syntax error. */
 export function hasSyntaxErrors(root: SyntaxNodeLike): boolean {
+  // web-tree-sitter's hasError already covers ERROR and missing descendants.
   if (root.hasError === true) return true;
+  if (root.hasError === false) return false;
   if (root.type === "ERROR" || root.isMissing === true) return true;
   return (root.children ?? []).some(hasSyntaxErrors);
 }

package/src/tool/call-range.ts

@@ -0,0 +1,94 @@
+// Callee ranges for grammars whose call queries capture the whole call node.
+
+import { tsPointToPublic } from "../coordinates.ts";
+import type { SyntaxNodeLike } from "../syntax-node.ts";
+import type { GrammarId, SourceRange } from "../types.ts";
+
+/**
+ * Return the callee range for a whole-call capture, so call-site ranges cover the
+ * callee expression in every grammar (`a.b` in `a.b(1)`), as JS/TS, Python, Go,
+ * and Rust queries capture directly. Returns `null` when the capture already is
+ * the callee or no narrower callee exists.
+ */
+export function calleeRangeForCallNode(
+  node: SyntaxNodeLike,
+  grammarId: GrammarId,
+  source: string,
+): SourceRange | null {
+  const end = calleeEnd(node, grammarId);
+  if (!end) return null;
+  const start = tsPointToPublic(node.startPosition, source);
+  const publicEnd = tsPointToPublic(end, source);
+  return {
+    startLine: start.line,
+    startCharacter: start.character,
+    endLine: publicEnd.line,
+    endCharacter: publicEnd.character,
+  };
+}
+
+/**
+ * Find the syntax node for one query capture by walking up from the leaf at its start.
+ * Returns `null` when no ancestor has the capture's type and range.
+ */
+export function findCaptureNode(
+  root: SyntaxNodeLike & {
+    descendantForPosition(point: { row: number; column: number }): SyntaxNodeLike | null;
+  },
+  capture: { nodeType: string; range: SourceRange },
+): SyntaxNodeLike | null {
+  const { range } = capture;
+  let node = root.descendantForPosition({
+    row: range.startLine - 1,
+    column: range.startCharacter - 1,
+  });
+  while (node) {
+    if (
+      node.type === capture.nodeType &&
+      node.startPosition.row === range.startLine - 1 &&
+      node.startPosition.column === range.startCharacter - 1 &&
+      node.endPosition.row === range.endLine - 1 &&
+      node.endPosition.column === range.endCharacter - 1
+    ) {
+      return node;
+    }
+    node = node.parent;
+  }
+  return null;
+}
+
+function calleeEnd(
+  node: SyntaxNodeLike,
+  grammarId: GrammarId,
+): { row: number; column: number } | null {
+  switch (grammarId) {
+    case "java":
+      return node.type === "method_invocation"
+        ? (node.childForFieldName("name")?.endPosition ?? null)
+        : null;
+    case "kotlin":
+      return node.type === "call_expression" ? (kotlinCallee(node)?.endPosition ?? null) : null;
+    case "ruby":
+      return node.type === "call"
+        ? ((node.childForFieldName("method") ?? node.childForFieldName("receiver"))?.endPosition ??
+            null)
+        : null;
+    default:
+      return null;
+  }
+}
+
+/**
+ * Kotlin nests `f(x) { }` as an outer call (lambda-only suffix) wrapping `f(x)`.
+ * Treat both as one call so they share the callee `f`; `f(1)(2)` keeps `f(1)` as
+ * the outer callee because its suffix has value arguments.
+ */
+function kotlinCallee(node: SyntaxNodeLike): SyntaxNodeLike | null {
+  const callee = node.children[0];
+  if (!callee) return null;
+  const suffix = node.children.find((child) => child.type === "call_suffix");
+  const lambdaOnly =
+    suffix !== undefined && !suffix.children.some((child) => child.type === "value_arguments");
+  if (callee.type === "call_expression" && lambdaOnly) return kotlinCallee(callee);
+  return callee;
+}

package/src/tool/call-sites.ts

@@ -1,10 +1,17 @@
 /** File-wide call-site extraction using per-grammar tree-sitter queries. */
 
 import type { CodeRequestControl } from "@mrclrchtr/supi-code-runtime/api";
-import type { CallSiteMatch, GrammarId, TreeSitterResult } from "../types.ts";
+import type {
+  CallSiteMatch,
+  GrammarId,
+  QueryCapture,
+  SourceRange,
+  TreeSitterResult,
+} from "../types.ts";
 import { isTypeOnlyImportCapture } from "../worker/call-context.ts";
 import { queryParsedFile, type TreeSitterRuntime } from "../worker/runtime.ts";
 import { normalizeCallName } from "./call-name.ts";
+import { calleeRangeForCallNode, findCaptureNode } from "./call-range.ts";
 
 // ── Per-grammar call-site queries ─────────────────────────────────────
 
@@ -90,17 +97,19 @@ export async function extractCallSites(
       const name = normalizeCallName(capture.text, grammarId, capture.nodeType);
       if (name.length === 0) continue;
 
+      const range = callSiteRange(tree.rootNode, capture, grammarId, source);
+
       // Collapse duplicate captures only when they identify the same source range.
-      const key = `${capture.range.startLine}:${capture.range.startCharacter}:${capture.range.endLine}:${capture.range.endCharacter}`;
+      const key = `${range.startLine}:${range.startCharacter}:${range.endLine}:${range.endCharacter}`;
       if (seen.has(key)) continue;
       seen.add(key);
 
       matches.push({
         name,
-        startLine: capture.range.startLine,
-        startCharacter: capture.range.startCharacter,
-        endLine: capture.range.endLine,
-        endCharacter: capture.range.endCharacter,
+        startLine: range.startLine,
+        startCharacter: range.startCharacter,
+        endLine: range.endLine,
+        endCharacter: range.endCharacter,
       });
     }
 
@@ -111,3 +120,14 @@ export async function extractCallSites(
     tree.delete();
   }
 }
+
+/** Narrow whole-call captures to their callee so ranges match the other grammars. */
+function callSiteRange(
+  root: Parameters<typeof findCaptureNode>[0],
+  capture: QueryCapture,
+  grammarId: GrammarId,
+  source: string,
+): SourceRange {
+  const node = findCaptureNode(root, capture);
+  return (node && calleeRangeForCallNode(node, grammarId, source)) ?? capture.range;
+}

package/src/tool/callees.ts

@@ -9,6 +9,7 @@ import type { GrammarId, SourceRange, TreeSitterResult } from "../types.ts";
 import { isTypeOnlyImportCapture } from "../worker/call-context.ts";
 import { queryParsedFile, type TreeSitterRuntime } from "../worker/runtime.ts";
 import { normalizeCallName } from "./call-name.ts";
+import { calleeRangeForCallNode } from "./call-range.ts";
 import { createCalleeDisplayName, createSourceLineStarts } from "./callee-display-name.ts";
 import { extractScopeName } from "./scope.ts";
 
@@ -387,11 +388,13 @@ function filterCalleeCaptures(
 
     if (isTypeOnlyImportCapture(enclosingNode, capture, grammarId)) continue;
     const name = normalizeCallName(capture.text, grammarId, capture.nodeType);
-    const rangeKey = sourceRangeKey(capture.range);
+    const syntaxNode = syntaxNodes.get(captureNodeKey(capture));
+    const range =
+      (syntaxNode && calleeRangeForCallNode(syntaxNode, grammarId, source)) ?? capture.range;
+    const rangeKey = sourceRangeKey(range);
     if (name.length === 0 || seenRanges.has(rangeKey)) continue;
     seenRanges.add(rangeKey);
 
-    const syntaxNode = syntaxNodes.get(captureNodeKey(capture));
     const displayName = syntaxNode
       ? createCalleeDisplayName({
           node: syntaxNode,
@@ -404,7 +407,7 @@ function filterCalleeCaptures(
     callees.push({
       name,
       ...(displayName === undefined ? {} : { displayName }),
-      range: capture.range,
+      range,
     });
   }
 

package/src/tool/exports.ts

@@ -91,9 +91,11 @@ const DECLARATION_EXPORT_NODE_TYPES = new Set([
   "type_alias_declaration",
   "enum_declaration",
   "lexical_declaration",
+  "variable_declaration",
   "ambient_declaration",
   "internal_module",
   "module",
+  "import_alias",
 ]);
 
 function extractDeclarationExport(
@@ -101,7 +103,7 @@ function extractDeclarationExport(
   source: string,
   exports: ExportRecord[],
 ): void {
-  if (decl.type === "lexical_declaration") {
+  if (decl.type === "lexical_declaration" || decl.type === "variable_declaration") {
     extractLexicalDeclarationExports(decl, source, exports);
     return;
   }
@@ -111,7 +113,11 @@ function extractDeclarationExport(
     return;
   }
 
-  const name = getDeclarationName(decl);
+  // `export import X = Y.Z` exports the alias `X`, which may name a value, type, or namespace.
+  const name =
+    decl.type === "import_alias"
+      ? (decl.children.find((child) => child.type === "identifier")?.text ?? null)
+      : getDeclarationName(decl);
   if (!name) return;
 
   exports.push({
@@ -143,7 +149,7 @@ function extractAmbientDeclarationExport(
   const nested = decl.children.find((child) => child.type !== "declare" && child.type !== ";");
   if (!nested) return;
 
-  if (nested.type === "lexical_declaration") {
+  if (nested.type === "lexical_declaration" || nested.type === "variable_declaration") {
     extractLexicalDeclarationExports(nested, source, exports);
     return;
   }
@@ -177,6 +183,8 @@ function exportKindForDeclaration(type: string): string {
     case "internal_module":
     case "module":
       return "namespace";
+    case "import_alias":
+      return "alias";
     default:
       return type.replace(/_declaration$/, "");
   }
@@ -217,8 +225,9 @@ function extractDefaultExport(node: SyntaxNodeLike, source: string, exports: Exp
   });
 }
 
+/** Return the `from "module"` specifier; a string value such as `export default "x"` is not one. */
 function findStringChild(node: SyntaxNodeLike): SyntaxNodeLike | undefined {
-  return node.children.find((child) => child.type === "string");
+  return node.childForFieldName("source") ?? undefined;
 }
 
 function extractReExport(

package/src/worker/runtime.ts

@@ -13,11 +13,7 @@ import {
   type StructuralTimingEvent,
   startStructuralTiming,
 } from "../session/structural-timing.ts";
-import {
-  collectSyntaxErrorRanges,
-  hasSyntaxErrors,
-  withSyntaxCompleteness,
-} from "../syntax-errors.ts";
+import { withSyntaxCompleteness } from "../syntax-errors.ts";
 import type { GrammarId, QueryCapture, TreeSitterResult } from "../types.ts";
 import {
   ParsedFileReadError,
@@ -172,8 +168,6 @@ export class TreeSitterRuntime {
           source: string;
           resolvedPath: string;
           grammarId: GrammarId;
-          hasSyntaxErrors: boolean;
-          errorRanges: ReturnType<typeof collectSyntaxErrorRanges>;
         };
       }
     | Exclude<TreeSitterResult<never>, { kind: "success" | "partial" }>
@@ -249,8 +243,6 @@ export class TreeSitterRuntime {
           source: parsed.source,
           resolvedPath: parsed.resolvedPath,
           grammarId: parsed.grammarId,
-          hasSyntaxErrors: hasSyntaxErrors(parsed.tree.rootNode),
-          errorRanges: collectSyntaxErrorRanges(parsed.tree.rootNode, parsed.source),
         },
       };
     } catch (err: unknown) {