pi-readseek 0.3.16 → 0.3.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-readseek",
-  "version": "0.3.16",
+  "version": "0.3.18",
   "description": "Pi extension for readseek-backed hash-anchored read/edit/grep, structural code maps, structural search, and file exploration",
   "type": "module",
   "exports": {
@@ -39,12 +39,10 @@
     "node": ">=20.0.0"
   },
   "dependencies": {
-    "@jarkkojs/readseek": "^0.3.16",
+    "@jarkkojs/readseek": "^0.3.17",
     "diff": "^8.0.3",
     "ignore": "^7.0.5",
     "picomatch": "^4.0.4",
-    "tree-sitter-wasms": "0.1.13",
-    "web-tree-sitter": "0.25.10",
     "xxhash-wasm": "^1.1.0"
   },
   "peerDependencies": {

package/src/coerce-obvious-int.ts

@@ -4,16 +4,7 @@ type CoercedIntResult =
   | { ok: true; value: number | undefined }
   | { ok: false; message: string };
 
-export function coerceObviousBase10Int(value: unknown): unknown;
-export function coerceObviousBase10Int(value: unknown, name: string): CoercedIntResult;
-export function coerceObviousBase10Int(value: unknown, name?: string): unknown | CoercedIntResult {
-  if (name === undefined) {
-    if (typeof value === "string" && BASE10_INT_RE.test(value)) {
-      return Number.parseInt(value, 10);
-    }
-    return value;
-  }
-
+export function coerceObviousBase10Int(value: unknown, name: string): CoercedIntResult {
   if (value === undefined) {
     return { ok: true, value: undefined };
   }

package/src/diff-data.ts

@@ -99,7 +99,6 @@ function parseFullDiffEntries(diff: string): DiffEntry[] {
     entries.push({ kind: "meta", text: line });
   }
 
-  void nextOldLine;
   return entries;
 }
 

package/src/edit-diff.ts

@@ -4,10 +4,19 @@ import { CONFUSABLE_HYPHENS_RE } from "./confusable-hyphens.js";
 
 
 export function detectLineEnding(content: string): "\r\n" | "\n" {
-	const crlfIdx = content.indexOf("\r\n");
-	const lfIdx = content.indexOf("\n");
-	if (lfIdx === -1 || crlfIdx === -1) return "\n";
-	return crlfIdx < lfIdx ? "\r\n" : "\n";
+	let crlf = 0;
+	let lf = 0;
+	for (let i = 0; i < content.length; i++) {
+		if (content[i] === "\r" && i + 1 < content.length && content[i + 1] === "\n") {
+			crlf++;
+			i++;
+		} else if (content[i] === "\n") {
+			lf++;
+		}
+	}
+	if (lf === 0) return "\r\n";
+	if (crlf === 0) return "\n";
+	return crlf > lf ? "\r\n" : "\n";
 }
 
 export function normalizeToLF(text: string): string {

package/src/edit-syntax-validate.ts

@@ -1,6 +1,4 @@
-import type { Node as SyntaxNode, Parser as WasmParser, Tree } from "web-tree-sitter";
-import { getWasmParser, type WasmLanguageId } from "./readseek/parser-loader.js";
-import { reportParserError } from "./readseek/parser-errors.js";
+import { readseekCheck, type ReadseekCheckOutput, type ReadseekDiagnostic } from "./readseek-client.js";
 
 export interface ValidateInput {
   filePath: string;
@@ -14,122 +12,53 @@ export interface ValidateResult {
   newMissingCount: number;
 }
 
-interface NodeStats {
-  errors: Array<{ startLine: number; endLine: number }>;
-  missing: Array<{ startLine: number; endLine: number }>;
-}
-
-function countNodes(parser: WasmParser, source: string): NodeStats {
-  const tree: Tree | null = parser.parse(source);
-  const errors: Array<{ startLine: number; endLine: number }> = [];
-  const missing: Array<{ startLine: number; endLine: number }> = [];
-  if (!tree) return { errors, missing };
-  try {
-    const stack: SyntaxNode[] = [tree.rootNode];
-    while (stack.length > 0) {
-      const node = stack.pop()!;
-      if (node.type === "ERROR") {
-        errors.push({
-          startLine: node.startPosition.row + 1,
-          endLine: node.endPosition.row + 1,
-        });
-      }
-      if (node.isMissing) {
-        missing.push({
-          startLine: node.startPosition.row + 1,
-          endLine: node.endPosition.row + 1,
-        });
-      }
-      for (let i = 0; i < node.namedChildCount; i++) {
-        const c = node.namedChild(i);
-        if (c) stack.push(c);
-      }
-      // Also descend into anonymous children to find MISSING tokens.
-      for (let i = 0; i < node.childCount; i++) {
-        const c = node.child(i);
-        if (c && !c.isNamed) stack.push(c);
-      }
-    }
-    return { errors, missing };
-  } finally {
-    tree.delete();
-  }
-}
-
-function dedupeSortLines(
-  ranges: Array<{ startLine: number; endLine: number }>,
-): string[] {
+function dedupeSortLines(diagnostics: ReadseekDiagnostic[]): string[] {
   const seen = new Set<string>();
   const out: Array<{ key: string; start: number }> = [];
-  for (const r of ranges) {
-    const key = r.startLine === r.endLine
-      ? String(r.startLine)
-      : `${r.startLine}-${r.endLine}`;
+  for (const diagnostic of diagnostics) {
+    const key =
+      diagnostic.start_line === diagnostic.end_line
+        ? String(diagnostic.start_line)
+        : `${diagnostic.start_line}-${diagnostic.end_line}`;
     if (!seen.has(key)) {
       seen.add(key);
-      out.push({ key, start: r.startLine });
+      out.push({ key, start: diagnostic.start_line });
     }
   }
   out.sort((a, b) => a.start - b.start);
   return out.map((o) => o.key);
 }
 
-const EXTENSION_TO_LANGUAGE: Record<string, WasmLanguageId> = {
-	".rs": "rust",
-	".c": "cpp",
-	".cc": "cpp",
-	".cpp": "cpp",
-	".cxx": "cpp",
-	".h": "c-header",
-	".hpp": "c-header",
-	".hxx": "c-header",
-	".java": "java",
-};
-
-function detectWasmLang(filePath: string): WasmLanguageId | null {
-	for (const [ext, langId] of Object.entries(EXTENSION_TO_LANGUAGE)) {
-		if (filePath.toLowerCase().endsWith(ext)) return langId;
-	}
-	return null;
-}
+const EMPTY: ReadseekCheckOutput = { errorCount: 0, missingCount: 0, diagnostics: [] };
 
+/**
+ * Compare parse diagnostics between `before` and `after` and report any newly
+ * introduced syntax errors. Uses readseek's native `check`, so every language
+ * with a tree-sitter parser is validated.
+ *
+ * Returns `null` when nothing new appears or when readseek cannot parse the
+ * file, so a validator failure never blocks an edit.
+ */
 export async function validateSyntaxRegression(
-	input: ValidateInput,
+  input: ValidateInput,
 ): Promise<ValidateResult | null> {
-	const langId = detectWasmLang(input.filePath);
-	if (!langId) return null;
-	const parser = await getWasmParser(langId);
-  if (!parser) return null;
-
+  let before: ReadseekCheckOutput;
+  let after: ReadseekCheckOutput;
   try {
-    const beforeStats = input.before === undefined
-      ? { errors: [], missing: [] }
-      : countNodes(parser, input.before);
-    const afterStats = countNodes(parser, input.after);
+    before = input.before === undefined ? EMPTY : await readseekCheck(input.filePath, input.before);
+    after = await readseekCheck(input.filePath, input.after);
+  } catch {
+    return null;
+  }
 
-    // ±1 tolerance on ERROR count, no tolerance on MISSING.
-    const newErrorCount = Math.max(
-      0,
-      afterStats.errors.length - beforeStats.errors.length - 1,
-    );
-    const newMissingCount = Math.max(
-      0,
-      afterStats.missing.length - beforeStats.missing.length,
-    );
+  const newErrorCount = Math.max(0, after.errorCount - before.errorCount);
+  const newMissingCount = Math.max(0, after.missingCount - before.missingCount);
 
-    if (newErrorCount === 0 && newMissingCount === 0) return null;
+  if (newErrorCount === 0 && newMissingCount === 0) return null;
 
-    const errorLines = dedupeSortLines([
-      ...afterStats.errors,
-      ...afterStats.missing,
-    ]);
-    return { errorLines, newErrorCount, newMissingCount };
-	} catch (err) {
-		reportParserError(`wasm:syntax-validate:${langId}:${err instanceof Error ? err.message : String(err)}`, err, {
-			context: `tree-sitter syntax validation failed for ${langId}`,
-		});
-		return null;
-	} finally {
-		parser.delete();
-  }
+  return {
+    errorLines: dedupeSortLines(after.diagnostics),
+    newErrorCount,
+    newMissingCount,
+  };
 }

package/src/edit.ts

@@ -116,6 +116,26 @@ function buildEditError(
 	};
 }
 
+function mapEditFileError(err: any, filePath: string, displayPath: string, phase: "read" | "write"): ReturnType<typeof buildEditError> {
+	const code = err?.code;
+	if (code === "EISDIR") {
+		return buildEditError(filePath, "path-is-directory",
+			`Path is a directory: ${displayPath}`,
+			`Use ls(${JSON.stringify(displayPath)}) to inspect directories.`);
+	}
+	if (code === "ENOENT") {
+		return buildEditError(filePath, "file-not-found",
+			`${phase === "write" ? "Failed to write file" : "File not found"}: ${displayPath}`);
+	}
+	if (code === "EACCES" || code === "EPERM") {
+		return buildEditError(filePath, "permission-denied", `Permission denied: ${displayPath}`);
+	}
+	const prefix = phase === "write" ? "Failed to write file" : "File not readable";
+	const message = `${prefix}: ${displayPath}${err?.message ? ` — ${err.message}` : ""}`;
+	return buildEditError(filePath, "fs-error", message, undefined,
+		{ fsCode: code, fsMessage: err?.message });
+}
+
 export interface EditToolOptions {
 	wasReadInSession?: (absolutePath: string) => boolean;
 	syntaxValidate?: SyntaxValidateOptions["syntaxValidate"];
@@ -227,27 +247,7 @@ export function registerEditTool(pi: ExtensionAPI, options: EditToolOptions = {}
 			try {
 				rawBuffer = await fsReadFile(absolutePath);
 			} catch (err: any) {
-				const code = err?.code;
-				let errCode: string;
-				let message: string;
-				let hint: string | undefined;
-				let errorDetails: { fsCode?: string; fsMessage?: string } | undefined;
-				if (code === "EISDIR") {
-					errCode = "path-is-directory";
-					message = `Path is a directory: ${path}`;
-					hint = `Use ls(${JSON.stringify(path)}) to inspect directories.`;
-				} else if (code === "ENOENT") {
-					errCode = "file-not-found";
-					message = `File not found: ${path}`;
-				} else if (code === "EACCES" || code === "EPERM") {
-					errCode = "permission-denied";
-					message = `Permission denied: ${path}`;
-				} else {
-					errCode = "fs-error";
-					message = `File not readable: ${path}${err?.message ? ` — ${err.message}` : ""}`;
-					errorDetails = { fsCode: code, fsMessage: err?.message };
-				}
-				return buildEditError(absolutePath, errCode, message, hint, errorDetails);
+				return mapEditFileError(err, absolutePath, path, "read");
 			}
 			if (isBinaryBuffer(rawBuffer)) {
 				const message = `Cannot edit binary file: ${path}`;
@@ -258,6 +258,27 @@ export function registerEditTool(pi: ExtensionAPI, options: EditToolOptions = {}
 			const { bom, text: content } = stripBom(raw);
 			const originalEnding = detectLineEnding(content);
 			const originalNormalized = normalizeToLF(content);
+			const origLines = originalNormalized.split("\n");
+			const anchorSnapshots = new Map<string, string>();
+			for (const edit of anchorEdits) {
+				const refs: string[] = [];
+				if ("set_line" in edit) refs.push(edit.set_line.anchor);
+				else if ("replace_lines" in edit) {
+					refs.push(edit.replace_lines.start_anchor, edit.replace_lines.end_anchor);
+				} else if ("insert_after" in edit) refs.push(edit.insert_after.anchor);
+				for (const ref of refs) {
+					try {
+						const parsed = parseLineRef(ref);
+						if (parsed.line >= 1 && parsed.line <= origLines.length) {
+							const lineContent = origLines[parsed.line - 1];
+							const hash = computeLineHash(parsed.line, lineContent);
+							anchorSnapshots.set(ref, `${parsed.line}:${hash}|${escapeControlCharsForDisplay(lineContent)}`);
+						}
+					} catch {
+						/* skip malformed refs */
+					}
+				}
+			}
 			let preAnchorContent = originalNormalized;
 			// AC 26: reject anchored edits that target a line inside any replace_symbol
 			// pre-replace range. Resolve each target against the ORIGINAL content so the
@@ -302,8 +323,8 @@ export function registerEditTool(pi: ExtensionAPI, options: EditToolOptions = {}
 						let startLine: number | undefined;
 						let endLine: number | undefined;
 						try {
-							startLine = parseLineRef((edit as any).replace_lines.start_anchor).line;
-							endLine = parseLineRef((edit as any).replace_lines.end_anchor).line;
+							startLine = parseLineRef(edit.replace_lines.start_anchor).line;
+							endLine = parseLineRef(edit.replace_lines.end_anchor).line;
 						} catch {
 							// Let the normal anchored edit validation report malformed anchors later.
 						}
@@ -319,10 +340,10 @@ export function registerEditTool(pi: ExtensionAPI, options: EditToolOptions = {}
 						}
 					}
 					const refs: string[] = [];
-					if ("set_line" in edit) refs.push((edit as any).set_line.anchor);
+					if ("set_line" in edit) refs.push(edit.set_line.anchor);
 					else if ("replace_lines" in edit) {
-						refs.push((edit as any).replace_lines.start_anchor, (edit as any).replace_lines.end_anchor);
-					} else if ("insert_after" in edit) refs.push((edit as any).insert_after.anchor);
+						refs.push(edit.replace_lines.start_anchor, edit.replace_lines.end_anchor);
+					} else if ("insert_after" in edit) refs.push(edit.insert_after.anchor);
 					for (const ref of refs) {
 						let parsedLine: number | undefined;
 						try {
@@ -412,30 +433,9 @@ export function registerEditTool(pi: ExtensionAPI, options: EditToolOptions = {}
 							.join("\n");
 					diagnostic += "\nRe-read the file to see the current state.";
 				} else {
-					// Edits were not literally identical but heuristics normalized them back
-					const lines = result.split("\n");
-					const targetLines: string[] = [];
-					for (const edit of edits) {
-						const refs: string[] = [];
-						if ("set_line" in edit) refs.push((edit as any).set_line.anchor);
-						else if ("replace_lines" in edit) {
-							refs.push((edit as any).replace_lines.start_anchor, (edit as any).replace_lines.end_anchor);
-						} else if ("insert_after" in edit) refs.push((edit as any).insert_after.anchor);
-						for (const ref of refs) {
-							try {
-								const parsed = parseLineRef(ref);
-								if (parsed.line >= 1 && parsed.line <= lines.length) {
-									const lineContent = lines[parsed.line - 1];
-									const hash = computeLineHash(parsed.line, lineContent);
-									targetLines.push(`${parsed.line}:${hash}|${escapeControlCharsForDisplay(lineContent)}`);
-								}
-							} catch {
-								/* skip malformed refs */
-							}
-						}
-					}
+					const targetLines = [...new Set(anchorSnapshots.values())];
 					if (targetLines.length > 0) {
-						const preview = [...new Set(targetLines)].slice(0, 5).join("\n");
+						const preview = targetLines.slice(0, 5).join("\n");
 						diagnostic += `\nThe file currently contains:\n${preview}\nYour edits were normalized back to the original content. Ensure your replacement changes actual code, not just formatting.`;
 					}
 				}
@@ -467,18 +467,7 @@ export function registerEditTool(pi: ExtensionAPI, options: EditToolOptions = {}
 			try {
 				await fsWriteFile(absolutePath, writeContent, "utf-8");
 			} catch (err: any) {
-				const wrapped = wrapWriteError(err, path);
-				const code =
-					err?.code === "EACCES" || err?.code === "EPERM"
-						? "permission-denied"
-						: err?.code === "ENOENT"
-							? "file-not-found"
-							: "fs-error";
-				const message =
-					code === "fs-error" && err?.message ? `${wrapped.message} — ${err.message}` : wrapped.message;
-				return buildEditError(absolutePath, code, message, undefined, code === "fs-error"
-					? { fsCode: err?.code, fsMessage: err?.message }
-					: undefined);
+				return mapEditFileError(err, absolutePath, path, "write");
 			}
 
 			if (input.postEditVerify === true) {
@@ -555,7 +544,6 @@ export function registerEditTool(pi: ExtensionAPI, options: EditToolOptions = {}
 				semanticSummary,
 			});
 
-			const warn = warnings.length ? `\n\nWarnings:\n${warnings.join("\n")}` : "";
 			return {
 				content: [{ type: "text", text: builtOutput.text }],
 				details: {
@@ -581,10 +569,8 @@ export function registerEditTool(pi: ExtensionAPI, options: EditToolOptions = {}
 			};
 				});
 			} catch (err: any) {
-				const code = err?.code;
-				if (typeof code === "string") {
-					const message = `File not readable: ${path}${err?.message ? ` — ${err.message}` : ""}`;
-					return buildEditError(absolutePath, "fs-error", message, undefined, { fsCode: code, fsMessage: err?.message });
+				if (typeof err?.code === "string") {
+					return mapEditFileError(err, absolutePath, path, "read");
 				}
 				throw err;
 			}

package/src/readseek-client.ts

@@ -94,6 +94,18 @@ export interface ReadseekRefsOptions {
 	signal?: AbortSignal;
 }
 
+export interface ReadseekDiagnostic {
+	kind: "error" | "missing";
+	start_line: number;
+	end_line: number;
+}
+
+export interface ReadseekCheckOutput {
+	errorCount: number;
+	missingCount: number;
+	diagnostics: ReadseekDiagnostic[];
+}
+
 export interface ReadseekSearchOptions {
 	language?: string;
 	cached?: boolean;
@@ -472,3 +484,37 @@ export async function readseekRefs(
 	if (options.ignored) args.push("--ignored");
 	return parseRefsOutput(await runReadseek(args, { signal: options.signal })).references;
 }
+
+function parseDiagnosticKind(value: unknown): ReadseekDiagnostic["kind"] {
+	if (value === "error" || value === "missing") return value;
+	throw new Error("invalid readseek diagnostic.kind");
+}
+
+function parseCheckOutput(value: unknown): ReadseekCheckOutput {
+	if (!value || typeof value !== "object") throw new Error("invalid readseek check output");
+	const output = value as Record<string, unknown>;
+	if (!Array.isArray(output.diagnostics)) throw new Error("invalid readseek diagnostics");
+	return {
+		errorCount: requireNumber(output.error_count, "error_count"),
+		missingCount: requireNumber(output.missing_count, "missing_count"),
+		diagnostics: output.diagnostics.map((diagnostic) => {
+			if (!diagnostic || typeof diagnostic !== "object") throw new Error("invalid readseek diagnostic");
+			const item = diagnostic as Record<string, unknown>;
+			return {
+				kind: parseDiagnosticKind(item.kind),
+				start_line: requireNumber(item.start_line, "diagnostic.start_line"),
+				end_line: requireNumber(item.end_line, "diagnostic.end_line"),
+			};
+		}),
+	};
+}
+
+export async function readseekCheck(
+	filePath: string,
+	content: string,
+	options: { signal?: AbortSignal } = {},
+): Promise<ReadseekCheckOutput> {
+	return parseCheckOutput(
+		await runReadseek(["check", "--stdin", filePath], { signal: options.signal, stdin: content }),
+	);
+}

package/src/readseek-settings.ts

@@ -49,18 +49,6 @@ function readPositive(
   return undefined;
 }
 
-function readBoolean(
-  raw: Record<string, unknown>,
-  key: string,
-  path: string,
-  source: string,
-  warnings: ReadseekSettingsWarning[],
-): boolean | undefined {
-  if (!(key in raw)) return undefined;
-  if (typeof raw[key] === "boolean") return raw[key];
-  warnings.push(invalid(source, path));
-  return undefined;
-}
 
 function validateSettings(raw: unknown, source: string): ReadseekSettingsResult {
   const settings: ReadseekJsonSettings = {};

package/src/replace-symbol.ts

@@ -53,9 +53,11 @@ export async function replaceSymbol(input: ReplaceSymbolInput): Promise<ReplaceS
 	const reindented = reindent(dedent(input.newBody), indent);
 	const warnings: string[] = [];
 	const leaf = input.symbol.replace(/@\d+$/, "").split(".").pop() ?? "";
+	const declNameRe =
+		/\b(?:(?:export\s+(?:default\s+)?|async\s+|public\s+|private\s+|protected\s+|static\s+)*)(?:function\*?|class|const|let|var|fn|def|method|type|interface|enum)\s+([A-Za-z_$][\w$]*)/s;
 	const firstDeclName =
-		reindented.match(/\b(?:function|class|method|const|let|var)\s+([A-Za-z_$][\w$]*)/)?.[1]
-		?? reindented.match(/^\s*(?:[\w$<>,?\s]+\s+)?([A-Za-z_$][\w$]*)\s*\(/)?.[1];
+		reindented.match(declNameRe)?.[1]
+		?? reindented.match(/^\s*(?:(?:async\s+)?[\w$<>,?\s]+\s+)?([A-Za-z_$][\w$]*)\s*\(/)?.[1];
 	if (leaf && firstDeclName && firstDeclName !== leaf) {
 		warnings.push(`name-mismatch: expected ${leaf}, got ${firstDeclName}`);
 	}

package/src/write.ts

@@ -294,7 +294,7 @@ export async function executeWrite(opts: {
       warnings: readseekWarnings,
       diff: diffResult.diff,
       diffData,
-      ...(requestMap !== undefined ? { map: { appended: mapAppended } } : {}),
+      ...(requestMap ? { map: { appended: mapAppended } } : {}),
     },
   };
 }

package/src/readseek/parser-errors.ts

@@ -1,19 +0,0 @@
-const emitted = new Set<string>();
-
-function causeMessage(err: unknown): string {
-  if (err instanceof Error) return err.message;
-  return String(err);
-}
-
-export function reportParserError(
-  onceKey: string,
-  err: unknown,
-  options: { context?: string } = {},
-): void {
-  if (!process.env.PI_READSEEK_DEBUG) return;
-  if (emitted.has(onceKey)) return;
-  emitted.add(onceKey);
-  const context = options.context ?? onceKey;
-  console.error(`[readseek] ${context}: ${causeMessage(err)}`);
-}
-

package/src/readseek/parser-loader.ts

@@ -1,78 +0,0 @@
-import { createRequire } from "node:module";
-import { dirname, join } from "node:path";
-import { Language, Parser } from "web-tree-sitter";
-import { reportParserError } from "./parser-errors.js";
-
-export type WasmLanguageId = "rust" | "cpp" | "c-header" | "java";
-export type WasmParser = Parser;
-
-const require_ = createRequire(import.meta.url);
-const wasmNames: Record<WasmLanguageId, string> = {
-  rust: "rust",
-  cpp: "cpp",
-  "c-header": "cpp",
-  java: "java",
-};
-let initPromise: Promise<void> | null = null;
-const languages = new Map<WasmLanguageId, Language>();
-const languageLoads = new Map<WasmLanguageId, Promise<Language | null>>();
-
-function isBun(): boolean {
-  return typeof (globalThis as { Bun?: unknown }).Bun !== "undefined";
-}
-
-function wasmPath(langId: WasmLanguageId): string {
-  const pkg = require_.resolve("tree-sitter-wasms/package.json");
-  return join(dirname(pkg), "out", `tree-sitter-${wasmNames[langId]}.wasm`);
-}
-
-async function init(): Promise<void> {
-  initPromise ??= Parser.init().catch((err: unknown) => {
-    initPromise = null;
-    reportParserError("wasm:init", err, { context: "web-tree-sitter initialization failed" });
-    throw err;
-  });
-  return initPromise;
-}
-
-async function language(langId: WasmLanguageId): Promise<Language | null> {
-  const loaded = languages.get(langId);
-  if (loaded) return loaded;
-
-  const inFlight = languageLoads.get(langId);
-  if (inFlight) return inFlight;
-
-  const loadPromise = (async () => {
-    try {
-      await init();
-      const lang = await Language.load(wasmPath(langId));
-      languages.set(langId, lang);
-      return lang;
-    } catch (err) {
-      reportParserError(`wasm:load:${langId}`, err, {
-        context: `tree-sitter WASM grammar load failed for ${langId}`,
-      });
-      return null;
-    } finally {
-      languageLoads.delete(langId);
-    }
-  })();
-
-  languageLoads.set(langId, loadPromise);
-  return loadPromise;
-}
-
-export async function getWasmParser(langId: WasmLanguageId): Promise<WasmParser | null> {
-  if (isBun()) return null;
-  const lang = await language(langId);
-  if (!lang) return null;
-  try {
-    const parser = new Parser();
-    parser.setLanguage(lang);
-    return parser;
-  } catch (err) {
-    reportParserError(`wasm:parser:${langId}`, err, { context: `tree-sitter WASM parser creation failed for ${langId}` });
-    return null;
-  }
-}
-