@mrclrchtr/supi-tree-sitter 9.1.0 → 9.1.1

package/README.md

@@ -19,6 +19,8 @@ to access structural code-understanding workflows in pi.
 npm install @mrclrchtr/supi-tree-sitter
 ```
 
+Structural analysis always runs in a Node.js child process. Under Bun, including compiled applications such as Pi-Bolt, install Node.js and make the `node` executable available on `PATH`. SuPi validates that executable before it starts the process host. If Node.js is unavailable, structural analysis reports an installation error. There is no Bun Worker or main-thread parser fallback.
+
 ![Tree-sitter outline in action](https://raw.githubusercontent.com/mrclrchtr/supi/main/screenshots/supi-tree-sitter.png)
 
 ## What you get
@@ -107,7 +109,7 @@ The benchmark reports cold and repeated outline results. It also reports cold an
 
 The Structural Worker reads files asynchronously. It identifies fresh parsed files by canonical path, grammar, and SHA-256 content hash. Cached trees use true least-recently-used eviction with limits of 128 files and 32 MiB of retained UTF-8 source bytes. Compiled queries use the same policy with limits of 128 queries and 512 KiB of retained UTF-8 query text. Source and query byte counts are memory-related proxies because `web-tree-sitter` does not report WASM resource sizes. Cached canonical trees stay private in the Worker.
 
-The Structural Worker runs in a dedicated Node child process. The process uses `--liftoff-only` so V8 avoids the optimizing WebAssembly compiler that uses unsafe amounts of memory for large grammars. This applies to every grammar in the Worker. Pi's main process does not receive this flag, and a V8 failure in the Worker process cannot crash Pi.
+The Structural Worker runs in a dedicated Node child process. The process uses `--liftoff-only` so V8 avoids the optimizing WebAssembly compiler that uses unsafe amounts of memory for large grammars. This applies to every grammar in the Worker. Pi's main process does not receive this flag, and a V8 failure in the Worker process cannot crash Pi. A Node parent uses its current executable and advanced IPC. A Bun parent selects Node explicitly and uses JSON IPC with bounded base64 result chunks; the private Worker-thread protocol stays unchanged.
 
 All structural service operations accept optional `CodeRequestControl`. The parent converts cancellation to one shared atomic flag and forwards absolute deadlines. When present, it forwards only the opaque Debug Operation ID through the Worker protocol so parse and query timing events keep direct request ownership. Direct library calls have no ID. The process host creates a shared atomic flag for its Worker thread because Node IPC cannot share the parent flag. Worker read phases observe a local abort signal. Parser and query progress callbacks observe the flag and deadline. If cooperative interruption does not settle in the fixed 250 ms grace period, the parent terminates the Worker process. Valid queued work keeps FIFO order on one fresh Worker with cold caches. There is no main-thread parser fallback.
 

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

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

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-tree-sitter",
-  "version": "9.1.0",
+  "version": "9.1.1",
   "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": "9.1.0",
-    "@mrclrchtr/supi-core": "9.1.0"
+    "@mrclrchtr/supi-core": "9.1.1",
+    "@mrclrchtr/supi-code-runtime": "9.1.1"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",

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

@@ -0,0 +1,23 @@
+import { assertStructuralProtocolMessageSize } from "./structural-worker-message-size.ts";
+import { STRUCTURAL_WORKER_LIMITS } from "./structural-worker-protocol.ts";
+
+/** Restore bounded binary chunks before the private Worker protocol validates them. */
+export function decodeStructuralWorkerJsonMessage(message: unknown): unknown {
+  assertStructuralProtocolMessageSize(message);
+  if (!message || typeof message !== "object" || !("kind" in message) || message.kind !== "chunk") {
+    return message;
+  }
+  const payload = "payload" in message ? message.payload : undefined;
+  const maxLength = Math.ceil(STRUCTURAL_WORKER_LIMITS.targetChunkBytes / 3) * 4;
+  if (typeof payload !== "string" || payload.length > maxLength) {
+    throw new Error("Invalid Structural Worker JSON chunk payload");
+  }
+  const bytes = Buffer.from(payload, "base64");
+  if (
+    bytes.byteLength > STRUCTURAL_WORKER_LIMITS.targetChunkBytes ||
+    bytes.toString("base64") !== payload
+  ) {
+    throw new Error("Invalid Structural Worker JSON chunk payload");
+  }
+  return { ...message, payload: bytes };
+}

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

@@ -0,0 +1,29 @@
+import { spawnSync } from "node:child_process";
+import { isAbsolute } from "node:path";
+
+/** Select a real Node executable without re-entering a compiled Bun application. */
+export function resolveStructuralWorkerNode(): string {
+  if (!process.versions.bun) return process.execPath;
+
+  const probe = spawnSync(
+    "node",
+    [
+      "--liftoff-only",
+      "--eval",
+      "if (!process.versions.bun) process.stdout.write(process.execPath)",
+    ],
+    {
+      encoding: "utf8",
+      env: { ...process.env, NODE_OPTIONS: "" },
+      timeout: 2_000,
+      maxBuffer: 4_096,
+      windowsHide: true,
+    },
+  );
+  if (probe.status !== 0 || !probe.stdout || !isAbsolute(probe.stdout)) {
+    throw new Error(
+      "Structural analysis under Bun requires Node.js on PATH. Install Node.js and restart Pi.",
+    );
+  }
+  return probe.stdout;
+}

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

@@ -1,6 +1,8 @@
 import { type ChildProcess, fork } from "node:child_process";
 import { EventEmitter } from "node:events";
 import { fileURLToPath } from "node:url";
+import { decodeStructuralWorkerJsonMessage } from "./structural-worker-json.ts";
+import { resolveStructuralWorkerNode } from "./structural-worker-node.ts";
 import type {
   ParentToStructuralWorkerMessage,
   StructuralWorkerToParentMessage,
@@ -23,23 +25,28 @@ export function createStructuralWorkerProcess(options: {
   readonly generation: number;
 }): StructuralWorkerLike {
   const hostPath = fileURLToPath(new URL("../worker/process-host.mjs", import.meta.url));
+  const jsonIpc = Boolean(process.versions.bun);
+  const args = [options.cwd, String(options.generation), ...(jsonIpc ? ["json"] : [])];
   // A child process accepts the V8 flag that a Worker thread rejects.
-  const child = fork(hostPath, [options.cwd, String(options.generation)], {
+  const child = fork(hostPath, args, {
+    execPath: resolveStructuralWorkerNode(),
     execArgv: ["--liftoff-only"],
     env: { ...process.env, NODE_OPTIONS: "" },
-    serialization: "advanced",
+    serialization: jsonIpc ? "json" : "advanced",
     stdio: ["ignore", "ignore", "inherit", "ipc"],
     windowsHide: true,
   });
-  return new StructuralWorkerProcess(child);
+  return new StructuralWorkerProcess(child, jsonIpc);
 }
 
 class StructuralWorkerProcess implements StructuralWorkerLike {
   readonly #events = new EventEmitter();
   readonly #child: ChildProcess;
+  readonly #jsonIpc: boolean;
 
-  constructor(child: ChildProcess) {
+  constructor(child: ChildProcess, jsonIpc: boolean) {
     this.#child = child;
+    this.#jsonIpc = jsonIpc;
     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));
@@ -96,7 +103,16 @@ class StructuralWorkerProcess implements StructuralWorkerLike {
       this.#events.emit("error", new Error(value.message.message));
       return;
     }
-    this.#events.emit("message", value.message);
+    let message: unknown = value.message;
+    if (this.#jsonIpc) {
+      try {
+        message = decodeStructuralWorkerJsonMessage(message);
+      } catch (error) {
+        this.#events.emit("error", error instanceof Error ? error : new Error(String(error)));
+        return;
+      }
+    }
+    this.#events.emit("message", message);
   }
 }
 

package/src/worker/process-host.mjs

@@ -1,8 +1,13 @@
 import { Worker } from "node:worker_threads";
 
-const [cwd, generationValue] = process.argv.slice(2);
+const [cwd, generationValue, serialization = "advanced"] = process.argv.slice(2);
 const generation = Number(generationValue);
-if (!cwd || !Number.isSafeInteger(generation) || generation < 1) {
+if (
+  !cwd ||
+  !Number.isSafeInteger(generation) ||
+  generation < 1 ||
+  !["advanced", "json"].includes(serialization)
+) {
   throw new Error("Structural Worker process received invalid startup data");
 }
 
@@ -76,7 +81,19 @@ function isParentChannel(value) {
 }
 
 function send(message, callback) {
-  if (process.connected && process.send) process.send(message, callback);
+  if (!process.connected || !process.send) return;
+  // Bun and Node use different binary IPC formats. Keep the thread protocol unchanged.
+  const forwarded =
+    serialization === "json" && message.message.kind === "chunk"
+      ? {
+          ...message,
+          message: {
+            ...message.message,
+            payload: Buffer.from(message.message.payload).toString("base64"),
+          },
+        }
+      : message;
+  process.send(forwarded, callback);
 }
 
 function disconnect() {