@mrclrchtr/supi-tree-sitter 8.0.1 → 9.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-tree-sitter",
-  "version": "8.0.1",
+  "version": "9.1.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": "8.0.1",
-    "@mrclrchtr/supi-core": "8.0.1"
+    "@mrclrchtr/supi-code-runtime": "9.1.0",
+    "@mrclrchtr/supi-core": "9.1.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",
@@ -59,6 +59,8 @@
     "generate:kotlin-wasm": "node scripts/generate-kotlin-wasm.mjs",
     "check:kotlin-wasm": "node scripts/generate-kotlin-wasm.mjs --check",
     "generate:sql-wasm": "node scripts/generate-sql-wasm.mjs",
-    "check:sql-wasm": "node scripts/generate-sql-wasm.mjs --check"
+    "check:sql-wasm": "node scripts/generate-sql-wasm.mjs --check",
+    "generate:latex-wasm": "node scripts/generate-latex-wasm.mjs",
+    "check:latex-wasm": "node scripts/generate-latex-wasm.mjs --check"
   }
 }

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

@@ -6,7 +6,7 @@
     "releaseAsset": "https://github.com/fwcd/tree-sitter-kotlin/releases/download/0.3.8/tree-sitter-kotlin.wasm"
   },
   "generatedWith": {
-    "treeSitterCli": "0.27.0"
+    "treeSitterCli": "0.27.1"
   },
   "sha256": "7f522f2e3ef633735b3e2bdea165071b5ad0a99d6201e84acab49017590f812a"
 }

package/resources/grammars/latex/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Patrick Förster
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1,17 @@
+{
+  "source": {
+    "npmPackage": "@pfoerster/tree-sitter-latex",
+    "version": "0.6.0",
+    "repository": "https://github.com/latex-lsp/tree-sitter-latex"
+  },
+  "generatedWith": {
+    "treeSitterCli": "0.27.1"
+  },
+  "patches": [
+    {
+      "id": "label-underscore-v1",
+      "file": "grammar.js"
+    }
+  ],
+  "sha256": "122e3587a1faaed6316c2fadb2336e531252787ea541f897a966b0dc0c812d52"
+}

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

@@ -5,7 +5,7 @@
     "repository": "https://github.com/derekstride/tree-sitter-sql"
   },
   "generatedWith": {
-    "treeSitterCli": "0.27.0"
+    "treeSitterCli": "0.27.1"
   },
   "sha256": "e03fb5079e88cfe0807056c284fd2b0589cee35df9bbb3d07e72f2f4178de8de",
   "trust": {

package/src/language.ts

@@ -48,6 +48,9 @@ const EXTENSION_GRAMMAR = {
   ".xhtml": "html",
   ".r": "r",
   ".sql": "sql",
+  ".tex": "latex",
+  ".sty": "latex",
+  ".cls": "latex",
 } satisfies Record<SupportedExtension, GrammarId>;
 
 const SUPPORTED_EXTENSIONS = Object.keys(EXTENSION_GRAMMAR) as SupportedExtension[];
@@ -87,6 +90,7 @@ const GRAMMAR_WASM: Record<GrammarId, string> = {
   html: "tree-sitter-html.wasm",
   r: "tree-sitter-r.wasm",
   sql: "tree-sitter-sql.wasm",
+  latex: "tree-sitter-latex.wasm",
 };
 
 const resourcesDir = path.resolve(sourceDir, "../resources/grammars");
@@ -103,7 +107,7 @@ export function resolveGrammarWasmPath(grammarId: GrammarId): string {
   if (!fs.existsSync(vendoredPath)) {
     throw new Error(
       `Vendored WASM grammar not found for "${grammarId}": expected at ${vendoredPath}. ` +
-        "Run `node scripts/vendor-wasm.mjs` or reinstall the package.",
+        "Run `pnpm --filter @mrclrchtr/supi-tree-sitter generate:all-wasm` or reinstall the package.",
     );
   }
 

package/src/operation-support.ts

@@ -33,6 +33,12 @@ export function supportsGrammarOperation(
     case "outline":
       return true;
     case "imports":
+      return (
+        grammar === "javascript" ||
+        grammar === "typescript" ||
+        grammar === "tsx" ||
+        grammar === "latex"
+      );
     case "exports":
       return grammar === "javascript" || grammar === "typescript" || grammar === "tsx";
     default:

package/src/provider/tree-sitter-provider.ts

@@ -103,6 +103,8 @@ function mapOutlineItems(items: OutlineItem[]): OutlineData[] {
   return items.map((item) => ({
     name: item.name,
     kind: item.kind,
+    ...(item.nameAnchor ? { nameAnchor: { ...item.nameAnchor } } : {}),
+    ...(item.nameEndAnchor ? { nameEndAnchor: { ...item.nameEndAnchor } } : {}),
     ...takeRange(item.range),
     children: item.children ? mapOutlineItems(item.children) : undefined,
   }));

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

@@ -1,6 +1,5 @@
 // biome-ignore-all lint/style/noExcessiveLinesPerFile: one mailbox state machine owns all Worker lifecycle transitions
 import { setImmediate as yieldImmediate } from "node:timers/promises";
-import { Worker } from "node:worker_threads";
 import {
   type CodeRequestControl,
   CodeRequestDeadlineError,
@@ -11,6 +10,10 @@ import type { TreeSitterResult } from "../types.ts";
 import { publishStructuralTimingEvent } from "./structural-timing.ts";
 import { StructuralWorkerLifecycle } from "./structural-worker-client-lifecycle.ts";
 import { assertStructuralProtocolMessageSize } from "./structural-worker-message-size.ts";
+import {
+  createStructuralWorkerProcess,
+  type StructuralWorkerLike,
+} from "./structural-worker-process.ts";
 import {
   decodeStructuralResult,
   type ParentToStructuralWorkerMessage,
@@ -22,14 +25,6 @@ import {
   validateWorkerToParentMessage,
 } from "./structural-worker-protocol.ts";
 
-interface StructuralWorkerLike {
-  postMessage(message: ParentToStructuralWorkerMessage): void;
-  on(event: "message", listener: (message: unknown) => void): this;
-  on(event: "error", listener: (error: Error) => void): this;
-  on(event: "exit", listener: (code: number) => void): this;
-  terminate(): Promise<number>;
-}
-
 export type StructuralWorkerFactory = (options: {
   readonly cwd: string;
   readonly generation: number;
@@ -71,6 +66,7 @@ interface ActiveWorker {
   readonly worker: StructuralWorkerLike;
   ready: boolean;
   startupSettled: boolean;
+  failureStarted: boolean;
   readonly settleStartupFailure: (message: string) => void;
 }
 
@@ -198,6 +194,7 @@ export class StructuralWorkerClient {
       worker,
       ready: false,
       startupSettled: false,
+      failureStarted: false,
       settleStartupFailure: (message) => rejectStartup(message),
     };
     this.#worker = active;
@@ -241,23 +238,18 @@ export class StructuralWorkerClient {
       });
       worker.on("error", (error) => {
         settleFailure(error.message);
-        if (this.#worker === active && active.ready) {
-          void this.#lifecycle.run(() => this.#workerFailure(error.message));
-        }
+        if (active.ready) this.#failWorker(active, error.message);
       });
       worker.on("exit", (code) => {
         settleFailure(`Structural Worker exited with code ${code}`);
-        if (!this.#closed && this.#worker === active && active.ready) {
-          void this.#lifecycle.run(() =>
-            this.#workerFailure(`Structural Worker exited with code ${code}`),
-          );
-        }
+        if (active.ready) this.#failWorker(active, `Structural Worker exited with code ${code}`);
       });
     });
   }
 
   #dispatch(): void {
-    if (this.#closed || this.#active || !this.#worker?.ready) return;
+    const worker = this.#worker;
+    if (this.#closed || this.#active || !worker?.ready) return;
     while (this.#queue.length > 0) {
       const request = this.#queue.shift();
       if (!request) return;
@@ -271,7 +263,7 @@ export class StructuralWorkerClient {
       const message = {
         kind: "request",
         version: STRUCTURAL_WORKER_PROTOCOL_VERSION,
-        generation: this.#worker.generation,
+        generation: worker.generation,
         requestId: request.id,
         input: request.input,
         ...(request.control?.operationId ? { operationId: request.control.operationId } : {}),
@@ -280,7 +272,7 @@ export class StructuralWorkerClient {
       } as const;
       try {
         assertStructuralProtocolMessageSize(message);
-        this.#worker.worker.postMessage(message);
+        if (!this.#send(worker, message)) return;
       } catch (error) {
         this.#active = null;
         this.#settle(request, runtimeError(errorMessage(error)));
@@ -334,12 +326,13 @@ export class StructuralWorkerClient {
     active.awaitingAck = message.sequence;
     if (message.final) active.finalSequence = message.sequence;
     await yieldImmediate();
-    if (this.#active !== active || !this.#worker) return;
+    const worker = this.#worker;
+    if (this.#active !== active || !worker) return;
     active.awaitingAck = null;
-    this.#worker.worker.postMessage({
+    this.#send(worker, {
       kind: "chunk-ack",
       version: STRUCTURAL_WORKER_PROTOCOL_VERSION,
-      generation: this.#worker.generation,
+      generation: worker.generation,
       requestId: active.id,
       sequence: message.sequence,
     });
@@ -401,6 +394,22 @@ export class StructuralWorkerClient {
     };
   }
 
+  #send(worker: ActiveWorker, message: ParentToStructuralWorkerMessage): boolean {
+    try {
+      worker.worker.postMessage(message);
+      return true;
+    } catch (error) {
+      this.#failWorker(worker, errorMessage(error));
+      return false;
+    }
+  }
+
+  #failWorker(worker: ActiveWorker, reason: string): void {
+    if (this.#closed || this.#worker !== worker || worker.failureStarted) return;
+    worker.failureStarted = true;
+    void this.#lifecycle.run(() => this.#workerFailure(reason)).catch(() => undefined);
+  }
+
   #interrupt(request: PendingRequest<unknown>, error: unknown): void {
     if (request.settled) return;
     const queuedIndex = this.#queue.indexOf(request);
@@ -409,14 +418,19 @@ export class StructuralWorkerClient {
       this.#reject(request, error);
       return;
     }
-    if (this.#active !== request || !this.#worker) return;
+    const worker = this.#worker;
+    if (this.#active !== request || !worker) return;
     Atomics.store(request.cancellationFlag, 0, 1);
-    this.#worker.worker.postMessage({
-      kind: "cancel",
-      version: STRUCTURAL_WORKER_PROTOCOL_VERSION,
-      generation: this.#worker.generation,
-      requestId: request.id,
-    });
+    if (
+      !this.#send(worker, {
+        kind: "cancel",
+        version: STRUCTURAL_WORKER_PROTOCOL_VERSION,
+        generation: worker.generation,
+        requestId: request.id,
+      })
+    ) {
+      return;
+    }
     request.hardStopTimer = setTimeout(
       () => void this.#hardStop(request, error),
       STRUCTURAL_WORKER_LIMITS.hardStopGraceMs,
@@ -550,10 +564,7 @@ function createProductionWorker(options: {
   cwd: string;
   generation: number;
 }): StructuralWorkerLike {
-  return new Worker(new URL("../worker/bootstrap.mjs", import.meta.url), {
-    execArgv: [],
-    workerData: options,
-  });
+  return createStructuralWorkerProcess(options);
 }
 
 function runtimeError<T = never>(message: string): TreeSitterResult<T> {

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

@@ -0,0 +1,122 @@
+import { type ChildProcess, fork } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { fileURLToPath } from "node:url";
+import type {
+  ParentToStructuralWorkerMessage,
+  StructuralWorkerToParentMessage,
+} from "./structural-worker-protocol.ts";
+
+const PARENT_CHANNEL = "supi-tree-sitter-parent";
+const WORKER_CHANNEL = "supi-tree-sitter-worker";
+
+export interface StructuralWorkerLike {
+  postMessage(message: ParentToStructuralWorkerMessage): void;
+  on(event: "message", listener: (message: unknown) => void): this;
+  on(event: "error", listener: (error: Error) => void): this;
+  on(event: "exit", listener: (code: number) => void): this;
+  terminate(): Promise<number>;
+}
+
+/** Start the Structural Worker in a Node process with safe WebAssembly compilation. */
+export function createStructuralWorkerProcess(options: {
+  readonly cwd: string;
+  readonly generation: number;
+}): StructuralWorkerLike {
+  const hostPath = fileURLToPath(new URL("../worker/process-host.mjs", import.meta.url));
+  // A child process accepts the V8 flag that a Worker thread rejects.
+  const child = fork(hostPath, [options.cwd, String(options.generation)], {
+    execArgv: ["--liftoff-only"],
+    env: { ...process.env, NODE_OPTIONS: "" },
+    serialization: "advanced",
+    stdio: ["ignore", "ignore", "inherit", "ipc"],
+    windowsHide: true,
+  });
+  return new StructuralWorkerProcess(child);
+}
+
+class StructuralWorkerProcess implements StructuralWorkerLike {
+  readonly #events = new EventEmitter();
+  readonly #child: ChildProcess;
+
+  constructor(child: ChildProcess) {
+    this.#child = child;
+    child.on("message", (value: unknown) => this.#receive(value));
+    child.on("error", (error) => this.#events.emit("error", error));
+    child.on("exit", (code) => this.#events.emit("exit", code ?? 1));
+  }
+
+  postMessage(message: ParentToStructuralWorkerMessage): void {
+    if (!this.#child.connected) throw new Error("Structural Worker process is disconnected");
+    // The process host creates a shared cancellation flag for its Worker thread.
+    const forwarded =
+      message.kind === "request" ? { ...message, cancellationFlag: undefined } : message;
+    this.#child.send({ channel: PARENT_CHANNEL, message: forwarded }, (error) => {
+      if (error) this.#events.emit("error", error);
+    });
+  }
+
+  on(event: "message", listener: (message: unknown) => void): this;
+  on(event: "error", listener: (error: Error) => void): this;
+  on(event: "exit", listener: (code: number) => void): this;
+  on(
+    event: "message" | "error" | "exit",
+    listener: ((message: unknown) => void) | ((error: Error) => void) | ((code: number) => void),
+  ): this {
+    this.#events.on(event, listener);
+    return this;
+  }
+
+  terminate(): Promise<number> {
+    if (this.#child.exitCode !== null) return Promise.resolve(this.#child.exitCode ?? 0);
+    if (this.#child.signalCode !== null) return Promise.resolve(0);
+
+    return new Promise((resolve) => {
+      let settled = false;
+      const finish = (code: number | null) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(forceStopTimer);
+        resolve(code ?? 0);
+      };
+      const forceStopTimer = setTimeout(() => {
+        if (!this.#child.kill("SIGKILL")) finish(this.#child.exitCode);
+      }, 250);
+      forceStopTimer.unref?.();
+      this.#child.once("exit", (code) => finish(code));
+      if (!this.#child.kill("SIGTERM")) finish(this.#child.exitCode);
+    });
+  }
+
+  #receive(value: unknown): void {
+    if (!isWorkerChannel(value)) {
+      this.#events.emit("message", value);
+      return;
+    }
+    if (value.message.kind === "worker-error") {
+      this.#events.emit("error", new Error(value.message.message));
+      return;
+    }
+    this.#events.emit("message", value.message);
+  }
+}
+
+interface WorkerChannelMessage {
+  readonly channel: typeof WORKER_CHANNEL;
+  readonly message:
+    | StructuralWorkerToParentMessage
+    | { readonly kind: "worker-error"; readonly message: string };
+}
+
+function isWorkerChannel(value: unknown): value is WorkerChannelMessage {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value as Partial<WorkerChannelMessage>;
+  if (
+    candidate.channel !== WORKER_CHANNEL ||
+    !candidate.message ||
+    typeof candidate.message !== "object"
+  ) {
+    return false;
+  }
+  const message = candidate.message as { kind?: unknown; message?: unknown };
+  return message.kind !== "worker-error" || typeof message.message === "string";
+}

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

@@ -515,7 +515,7 @@ function isFiniteDuration(value: unknown): boolean {
 }
 
 function hasExactKeys(value: Record<string, unknown>, expected: readonly string[]): boolean {
-  const actual = Object.keys(value).sort();
+  const actual = Object.keys(value);
   return actual.length === expected.length && expected.every((key) => actual.includes(key));
 }
 

package/src/tool/callees.ts

@@ -76,6 +76,7 @@ const ENCLOSING_SCOPE_TYPES: Record<GrammarId, ReadonlySet<string>> = {
   r: new Set(["function_definition"]),
   html: new Set(),
   sql: new Set(),
+  latex: new Set(),
 };
 
 // ── Main entrypoint ──────────────────────────────────────────────────

package/src/tool/imports.ts

@@ -19,7 +19,11 @@ export async function extractImports(
   const imports: ImportRecord[] = [];
 
   try {
-    walkForImports(tree.rootNode, source, imports);
+    if (parseResult.data.grammarId === "latex") {
+      walkForLatexImports(tree.rootNode, source, imports);
+    } else {
+      walkForImports(tree.rootNode, source, imports);
+    }
     return { kind: "success", data: imports };
   } finally {
     tree.delete();
@@ -42,3 +46,53 @@ function walkForImports(node: SyntaxNodeLike, source: string, imports: ImportRec
     walkForImports(child, source, imports);
   }
 }
+
+const LATEX_IMPORT_FIELDS: Readonly<Record<string, string>> = {
+  package_include: "paths",
+  class_include: "path",
+  latex_include: "path",
+  biblatex_include: "glob",
+  bibstyle_include: "path",
+  bibtex_include: "paths",
+};
+
+function walkForLatexImports(node: SyntaxNodeLike, source: string, imports: ImportRecord[]): void {
+  if (node.type === "import_include") {
+    const directory = groupContent(node.childForFieldName("directory"));
+    const file = groupContent(node.childForFieldName("file"));
+    if (directory || file) {
+      const separator = directory && !directory.endsWith("/") ? "/" : "";
+      imports.push({
+        moduleSpecifier: `${directory}${separator}${file}`,
+        range: nodeToRange(node, source),
+      });
+    }
+    return;
+  }
+
+  const field = LATEX_IMPORT_FIELDS[node.type];
+  if (field) {
+    for (const moduleSpecifier of fieldValues(node, field)) {
+      if (moduleSpecifier) imports.push({ moduleSpecifier, range: nodeToRange(node, source) });
+    }
+    return;
+  }
+
+  for (const child of node.children) {
+    walkForLatexImports(child, source, imports);
+  }
+}
+
+function fieldValues(node: SyntaxNodeLike, field: string): string[] {
+  const value = node.childForFieldName(field);
+  if (!value) return [];
+  const paths = value.childrenForFieldName("path");
+  if (paths.length > 0) return paths.map((path) => path.text.trim()).filter(Boolean);
+  return [groupContent(value)];
+}
+
+function groupContent(node: SyntaxNodeLike | null): string {
+  if (!node) return "";
+  const trimmed = node.text.trim();
+  return trimmed.startsWith("{") && trimmed.endsWith("}") ? trimmed.slice(1, -1).trim() : trimmed;
+}