@wrongstack/tools 1.0.11 → 1.0.12

package/dist/codebase-index/graph-rank.d.ts

@@ -156,6 +156,14 @@ export interface WiringGraphOptions {
     fileOf?: ReadonlyMap<number, string> | undefined;
     /** Files each source file imports, as resolved by the module resolver. */
     importsOf?: ReadonlyMap<string, ReadonlySet<string>> | undefined;
+    /**
+     * True when the target is visible to the source without a file-level import
+     * — the same Go package, Java package or C# namespace directory, or a file
+     * of a Go package the source imports (the resolver records ONE
+     * representative file per imported package). Those edges are ordinary
+     * code, not misresolutions, and must not take the contradicted weight.
+     */
+    implicitlyVisible?: ((sourceFile: string, targetFile: string, imports: ReadonlySet<string> | undefined) => boolean) | undefined;
 }
 export declare function buildWiringGraph(refs: readonly ResolvedRefEdge[], options?: WiringGraphOptions): WiringGraph;
 /**

package/dist/codebase-index/index.d.ts

@@ -17,7 +17,6 @@ export { type InvariantEvaluationResult, type InvariantRuleId, type InvariantVio
 export { type MutateSymbolOptions, type MutateSymbolResult, replaceSymbolInFile, } from './ast-symbol-mutator.js';
 export { cancelPendingReindexes, checkCodebaseIndexServerHealth, codebaseIndexStats, enqueueReindex, ensureCodebaseIndexServer, fileGraphService, getIndexState, incomingCallsService, isIndexableFile, isIndexing, isIndexReady, onIndexStateChange, outgoingCallsService, packageGraphService, runStartupIndex, searchCodebaseIndex, shutdownCodebaseIndexHost, shutdownCodebaseIndexServer, symbolGraphService, } from './background-indexer.js';
 export { buildBm25Index, buildIndexableText, tokenise, } from './bm25.js';
-export { getCodebaseIndexPerfSnapshot, resetCodebaseIndexPerfMetrics, type CodebaseIndexPerfSnapshot, } from './perf-metrics.js';
 export type { CircuitSnapshot, CircuitState } from './circuit-breaker.js';
 export { CircuitOpenError, IndexCircuitBreaker, IndexTimeoutError, indexCircuitBreaker, resetIndexCircuitBreaker, } from './circuit-breaker.js';
 export { type CodebaseAstReplaceInput, type CodebaseAstReplaceOutput, codebaseAstReplaceTool, } from './codebase-ast-replace-tool.js';
@@ -37,6 +36,7 @@ export { compileGitignore, type IgnoreMatcher, loadGitignoreMatcher, } from './g
 export { runIndexer } from './indexer.js';
 export { detectLang, INDEXABLE_EXTENSIONS, isIndexablePath } from './languages.js';
 export { internalKindToLspKind, lspKindToInternalKind, } from './lsp-kind.js';
+export { type CodebaseIndexPerfSnapshot, getCodebaseIndexPerfSnapshot, resetCodebaseIndexPerfMetrics, } from './perf-metrics.js';
 export type { ProjectIndexServerClientHealth, ProjectIndexServerConnectionState, ProjectIndexServerConnectionStatus, } from './project-server-client.js';
 export { type ProjectIndexDaemonAvailability, resolveProjectIndexDaemonAvailability, } from './project-server-client.js';
 export { projectIndexServerEndpoint, projectIndexServerMetadataPath, } from './project-server-endpoint.js';

package/dist/codebase-index/index.js

@@ -51,8 +51,8 @@ import {
   setContextQueryEmbedder,
   writeAtlas,
   writeProjectAtlas
-} from "../chunk-ENE22I5W.js";
-import "../chunk-XRNN44QY.js";
+} from "../chunk-K37AKCTN.js";
+import "../chunk-2IRHFHZY.js";
 import "../chunk-UVYRQKPZ.js";
 import "../chunk-SCMRM6NL.js";
 import "../chunk-HDYUBRMF.js";
@@ -78,11 +78,11 @@ import {
   shutdownCodebaseIndexHost,
   shutdownCodebaseIndexServer,
   symbolGraphService
-} from "../chunk-HYHE4VNA.js";
+} from "../chunk-UMOP3VGK.js";
 import {
   projectIndexServerEndpoint,
   projectIndexServerMetadataPath
-} from "../chunk-XPVYZ2S6.js";
+} from "../chunk-RYLMSGR5.js";
 import {
   CONCEPT_RELATIONS,
   CONTRADICTED_VISIBILITY_WEIGHT,
@@ -122,14 +122,14 @@ import {
   shouldRefreshRanks,
   toSymbolRankRows,
   tokenise
-} from "../chunk-NEYUPZL6.js";
-import "../chunk-KHUCKLOR.js";
-import "../chunk-4CE3RKEP.js";
-import "../chunk-SKRMUHTU.js";
+} from "../chunk-6D3UIQMF.js";
+import "../chunk-BJ5LXLKE.js";
+import "../chunk-R3HR3QI3.js";
+import "../chunk-HSLDY55L.js";
 import {
   getCodebaseIndexPerfSnapshot,
   resetCodebaseIndexPerfMetrics
-} from "../chunk-ZKC5UNGD.js";
+} from "../chunk-OIFY4XNP.js";
 import {
   INDEXABLE_EXTENSIONS,
   detectLang,

package/dist/codebase-index/lsp-kind.d.ts

@@ -36,8 +36,10 @@ export declare enum LSPSymbolKind {
     Operator = 25,
     TypeParameter = 26
 }
+/** All internal kinds an LSP kind number covers; empty when it has no equivalent. */
+export declare function lspKindToInternalKinds(k: number): readonly SymbolKind[];
 /**
- * Maps an LSP kind number to the corresponding internal SymbolKind.
+ * Maps an LSP kind number to its primary internal SymbolKind.
  * Returns null if the LSP kind has no equivalent in the internal taxonomy.
  */
 export declare function lspKindToInternalKind(k: number): SymbolKind | null;

package/dist/codebase-index/module-resolver.d.ts

@@ -66,8 +66,28 @@ export declare class ModuleResolver {
      * leading dots the extractor preserves (`.sibling`, `..parent.mod`).
      */
     private resolvePython;
-    /** `use crate::a::b`, `use super::x`, `use self::y`, `use other_crate::z`. */
+    /**
+     * `use crate::a::b`, `use super::x`, `use self::y`, `use other_crate::z`,
+     * and `mod x;` declarations.
+     *
+     * Paths are resolved from the declaring file's MODULE directory, which is
+     * only its filesystem directory for `mod.rs`/`lib.rs`/`main.rs`. A plain
+     * `src/net.rs` owns `src/net/`: its `mod http;` is `src/net/http.rs`, its
+     * `super` is the crate root. Using the file's directory put every
+     * `self::`/`super::`/`mod` path from such a file one level too high, so
+     * those edges silently resolved to nothing (or to an unrelated file).
+     */
     private resolveRust;
+    /**
+     * Longest module prefix of `segments` under `base` that is an indexed file.
+     * The trailing segments of a `use` are usually items (`net::http::Client::new`),
+     * so each is dropped in turn until a module file matches.
+     */
+    private lookupRustPath;
+    /** The file defining the module whose children live in `dir`. */
+    private lookupRustModuleFile;
+    /** A crate's root file: the library root, else the binary root. */
+    private lookupRustCrateRoot;
     /** `com.example.Thing` and `com.example.*` against JVM source roots. */
     private resolveJvm;
     /** `#include "foo/bar.h"` — quoted form only; `<…>` is a system header. */

package/dist/codebase-index/parser-batch.d.ts

@@ -4,16 +4,15 @@
  * The single-file parsers spawn one `go run` / `python` child process per
  * file. For a 400-file Go project that is 400 process spawns, each paying
  * toolchain startup; the spawn gate serializes them, so parse time scales
- * linearly with spawn cost. This module runs the SAME extraction logic over
- * a batch: one child process per chunk of files, sources in over stdin as a
- * JSON array, one JSON envelope out per file.
+ * linearly with spawn cost. This module runs the SAME extraction core (see
+ * `toolchain-scripts.ts`) over a batch: one child process per chunk of files,
+ * sources in over stdin as a JSON array, one JSON envelope out per file.
  *
  * Fallback contract: a file the batch could not parse (per-file error in the
  * envelope, or the chunk itself failing) is simply ABSENT from the returned
  * map — the caller re-parses those files through the single-file parser,
  * which owns the per-language fallback semantics (Go: regex extractor;
- * Python: generic regex only when the runtime is missing). Parity with the
- * per-file path is therefore by construction, not by reimplementation.
+ * Python: generic regex only when the runtime is missing).
  */
 import type { FileSymbols, SymbolLang } from './schema.js';
 export interface BatchFile {
@@ -25,9 +24,8 @@ export interface BatchFile {
  *  Generic so callers' extra per-file fields (e.g. source index) survive. */
 export declare function chunkBatchFiles<T extends BatchFile>(files: readonly T[]): T[][];
 /**
- * Test-only: the cached batch-script paths. The security regression test
- * observes WHERE the scripts were written without needing a toolchain —
- * a missing binary still leaves the (already-created) path cached.
+ * Test-only: the cached batch-script paths, so a test can observe WHERE the
+ * scripts were written without needing a toolchain.
  */
 export declare function __batchScriptPathsForTest(): {
     go: string | null;

package/dist/codebase-index/parser-output.d.ts

@@ -11,7 +11,7 @@
  * it, and a stale script must degrade to "symbols but no edges", never to a
  * hard parse failure that drops the file from the index entirely.
  */
-import type { Ref, SymbolLang } from './schema.js';
+import type { Symbol as IndexSymbol, Ref, SymbolLang } from './schema.js';
 interface RawParsedSymbol {
     name: string;
     kind: string;
@@ -19,7 +19,11 @@ interface RawParsedSymbol {
     col: number;
     signature: string;
     scope: string;
+    /** First line of the declaration's doc comment / docstring. */
+    doc: string;
 }
+/** Map decoded parser symbols onto index rows for `file`. */
+export declare function toIndexSymbols(raw: readonly RawParsedSymbol[], file: string, lang: SymbolLang): IndexSymbol[];
 interface ParsedParserOutput {
     symbols: RawParsedSymbol[];
     refs: Ref[];

package/dist/codebase-index/parser-worker-script.js

@@ -1,9 +1,9 @@
 import {
   parseFilesContent
-} from "../chunk-KHUCKLOR.js";
-import "../chunk-4CE3RKEP.js";
-import "../chunk-SKRMUHTU.js";
-import "../chunk-ZKC5UNGD.js";
+} from "../chunk-BJ5LXLKE.js";
+import "../chunk-R3HR3QI3.js";
+import "../chunk-HSLDY55L.js";
+import "../chunk-OIFY4XNP.js";
 import "../chunk-YOHO4DVT.js";
 import "../chunk-XZLVJD56.js";
 

package/dist/codebase-index/project-server-framing.d.ts

@@ -9,21 +9,5 @@ import type { ClientState } from './project-server-types.js';
  */
 export declare const MAX_CLIENT_WRITE_BUFFER_BYTES: number;
 export declare function sendServerMessage(state: ClientState, message: ProjectServerMessage): void;
-/**
- * Frame reader for one client connection. Each frame is sniffed per first
- * byte: `0x57` ('W') → length-prefixed MessagePack, anything else →
- * newline-delimited JSON text. Bytes stay raw until a complete frame is
- * assembled, so a multibyte UTF-8 sequence split across chunks is only ever
- * decoded as part of a finished line (raw `0x0a` only occurs as the JSON
- * delimiter — inside JSON strings `\n` is escaped — so a complete line is
- * always complete UTF-8).
- *
- * The buffer is consumed with a scan offset rather than re-slicing after
- * every frame: each parsed frame advances `scan` within the same Buffer,
- * and the leftover tail is compacted once at the end of the call. A burst
- * of small frames therefore costs one allocation per chunk, not one
- * per frame (the previous slice-per-frame loop reallocated on every frame
- * while pinning the whole parent buffer).
- */
-export declare function consumeClientChunk(state: ClientState, chunk: Buffer, onMessage: (state: ClientState, message: ProjectServerClientMessage) => void): void;
+export declare function consumeClientChunk(state: ClientState, chunk: Buffer, onMessage: (state: ClientState, message: ProjectServerClientMessage) => void | Promise<void>): void;
 //# sourceMappingURL=project-server-framing.d.ts.map

package/dist/codebase-index/project-server-watcher.d.ts

@@ -2,6 +2,12 @@ import type { ClientState } from './project-server-types.js';
 export declare const DEFAULT_EXTERNAL_DEBOUNCE_MS = 400;
 export declare const DEFAULT_EXTERNAL_COALESCE_WINDOW_MS = 50;
 export declare function isIgnoredRelativePath(relativePath: string): boolean;
+/**
+ * Whether a non-indexable `rename` path may be a directory whose files the
+ * index holds: an existing directory, or a vanished path without an
+ * extension (a deleted `.png` must not trigger an index write run).
+ */
+export declare function isDirectoryWatchCandidate(absolute: string): Promise<boolean>;
 export interface ProjectServerWatcherOptions {
     projectRoot: string;
     onFilesChanged: (files: string[]) => void;

package/dist/codebase-index/project-server.js

@@ -10,7 +10,7 @@ import {
   projectIndexServerBuildId,
   projectIndexServerEndpoint,
   projectIndexServerMetadataPath
-} from "../chunk-XPVYZ2S6.js";
+} from "../chunk-RYLMSGR5.js";
 import {
   contextService,
   fileGraphService,
@@ -24,13 +24,13 @@ import {
   statsService,
   symbolGraphService,
   vectorSearchService
-} from "../chunk-NEYUPZL6.js";
-import "../chunk-KHUCKLOR.js";
-import "../chunk-4CE3RKEP.js";
-import "../chunk-SKRMUHTU.js";
+} from "../chunk-6D3UIQMF.js";
+import "../chunk-BJ5LXLKE.js";
+import "../chunk-R3HR3QI3.js";
+import "../chunk-HSLDY55L.js";
 import {
   recordWriteQueueWait
-} from "../chunk-ZKC5UNGD.js";
+} from "../chunk-OIFY4XNP.js";
 import {
   isIndexablePath
 } from "../chunk-YOHO4DVT.js";
@@ -39,7 +39,7 @@ import "../chunk-XZLVJD56.js";
 
 // src/codebase-index/project-server.ts
 import { randomBytes } from "node:crypto";
-import * as fs2 from "node:fs";
+import * as fs3 from "node:fs";
 import * as net from "node:net";
 import * as path3 from "node:path";
 import { startSharedHeapWatchdog, useDaemonPerfDefaults } from "@wrongstack/core/utils";
@@ -58,6 +58,29 @@ function sendServerMessage(state, message) {
     state.binary ? encodeBinaryFrame(message) : encodeProjectServerMessage(message)
   );
 }
+function isClientMessage(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.type === "string";
+}
+function rejectConnection(state, reason) {
+  state.buffer = Buffer.alloc(0);
+  if (!state.socket.destroyed) state.socket.destroy(new Error(reason));
+}
+function dispatchClientMessage(state, message, onMessage) {
+  const fail = (error) => {
+    const detail = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`codebase-index server: client message handler failed: ${detail}
+`);
+    rejectConnection(state, "codebase-index client message handler failed");
+  };
+  try {
+    const pending = onMessage(state, message);
+    if (pending && typeof pending.then === "function") pending.then(void 0, fail);
+    return true;
+  } catch (error) {
+    fail(error);
+    return false;
+  }
+}
 function consumeClientChunk(state, chunk, onMessage) {
   const buffer = state.buffer.length === 0 ? chunk : Buffer.concat([state.buffer, chunk]);
   let scan = 0;
@@ -73,18 +96,21 @@ function consumeClientChunk(state, chunk, onMessage) {
       }
       if (buffer.length - scan < 5 + frameLen) break;
       const payload = buffer.subarray(scan + 5, scan + 5 + frameLen);
-      let message2;
+      let decoded;
       try {
-        message2 = decodeBinaryFrame(payload);
+        decoded = decodeBinaryFrame(payload);
       } catch {
-        state.buffer = Buffer.alloc(0);
-        state.socket.destroy(new Error("invalid codebase-index client binary frame"));
+        rejectConnection(state, "invalid codebase-index client binary frame");
+        return;
+      }
+      if (!isClientMessage(decoded)) {
+        rejectConnection(state, "invalid codebase-index client binary frame");
         return;
       }
       scan += 5 + frameLen;
       state.binary = true;
       state.lastSeenAt = Date.now();
-      onMessage(state, message2);
+      if (!dispatchClientMessage(state, decoded, onMessage)) return;
       continue;
     }
     const newline = buffer.indexOf(10, scan);
@@ -104,16 +130,19 @@ function consumeClientChunk(state, chunk, onMessage) {
     const line = buffer.subarray(scan, newline).toString("utf8");
     scan = newline + 1;
     if (!line) continue;
-    let message;
+    let parsed2;
     try {
-      message = JSON.parse(line);
+      parsed2 = JSON.parse(line);
     } catch {
-      state.buffer = Buffer.alloc(0);
-      state.socket.destroy(new Error("invalid codebase-index client message"));
+      rejectConnection(state, "invalid codebase-index client message");
+      return;
+    }
+    if (!isClientMessage(parsed2)) {
+      rejectConnection(state, "invalid codebase-index client message");
       return;
     }
     state.lastSeenAt = Date.now();
-    onMessage(state, message);
+    if (!dispatchClientMessage(state, parsed2, onMessage)) return;
   }
   state.buffer = scan === 0 ? buffer : Buffer.from(buffer.subarray(scan));
 }
@@ -475,6 +504,7 @@ async function dispatchOperation(ctx, state, message) {
 }
 
 // src/codebase-index/project-server-watcher.ts
+import * as fs2 from "node:fs/promises";
 import * as path2 from "node:path";
 import {
   DEFAULT_WALK_IGNORE_SET,
@@ -485,6 +515,14 @@ var DEFAULT_EXTERNAL_COALESCE_WINDOW_MS = 50;
 function isIgnoredRelativePath(relativePath) {
   return relativePath.split(/[/\\]/u).some((segment) => DEFAULT_WALK_IGNORE_SET.has(segment));
 }
+async function isDirectoryWatchCandidate(absolute) {
+  try {
+    return (await fs2.stat(absolute)).isDirectory();
+  } catch (err) {
+    const code = err?.code;
+    return (code === "ENOENT" || code === "ENOTDIR") && path2.extname(absolute) === "";
+  }
+}
 var ProjectServerWatcherManager = class {
   constructor(options) {
     this.options = options;
@@ -525,14 +563,21 @@ var ProjectServerWatcherManager = class {
     const projectRoot2 = this.options.projectRoot;
     this.externalWatcher = watchProjectTree(
       projectRoot2,
-      ({ filename }) => {
+      ({ eventType, filename }) => {
         if (!filename || isIgnoredRelativePath(filename)) return;
         const absolute = path2.resolve(projectRoot2, filename);
         const relative2 = path2.relative(projectRoot2, absolute);
-        if (relative2 === ".." || relative2.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative2) || !isIndexablePath(absolute)) {
+        if (relative2 === ".." || relative2.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative2)) {
+          return;
+        }
+        if (isIndexablePath(absolute)) {
+          this.enqueueExternalFile(absolute);
           return;
         }
-        this.enqueueExternalFile(absolute);
+        if (eventType !== "rename") return;
+        void isDirectoryWatchCandidate(absolute).then((candidate) => {
+          if (candidate && this.externalWatcher) this.enqueueExternalFile(absolute);
+        });
       },
       {
         onError: () => {
@@ -910,11 +955,12 @@ async function handleMessage(state, message) {
     const previousDebounceMs = state.debounceMs;
     const previousCoalesceWindowMs = state.coalesceWindowMs;
     try {
-      state.watchExternal = message.watchExternal;
-      state.debounceMs = Math.max(0, message.debounceMs);
-      state.coalesceWindowMs = Math.max(
-        0,
-        message.coalesceWindowMs ?? DEFAULT_EXTERNAL_COALESCE_WINDOW_MS
+      const nonNegative = (value, fallback) => typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : fallback;
+      state.watchExternal = message.watchExternal === true;
+      state.debounceMs = nonNegative(message.debounceMs, DEFAULT_EXTERNAL_DEBOUNCE_MS);
+      state.coalesceWindowMs = nonNegative(
+        message.coalesceWindowMs,
+        DEFAULT_EXTERNAL_COALESCE_WINDOW_MS
       );
       watcherManager.reconcile(clients);
       send(state, {
@@ -1054,7 +1100,7 @@ async function stop(_reason) {
   });
   if (process.platform !== "win32") {
     try {
-      fs2.rmSync(endpoint, { force: true });
+      fs3.rmSync(endpoint, { force: true });
     } catch {
     }
   }

package/dist/codebase-index/py-parser.d.ts

@@ -1,10 +1,10 @@
 /**
  * Python source symbol extraction using the `ast` module.
  *
- * Spawns a `python -c` child process that parses the file with Python's `ast`
- * module and emits JSON. Falls back to empty results on any error.
+ * Runs the extraction program from `toolchain-scripts.ts` under the resolved
+ * interpreter, with the source on stdin, and decodes its JSON.
  *
- * Extracts: class, function, async function, const, var, import, import_from
+ * Extracts: class, function, method, property, const, var, type
  */
 import type { FileSymbols, SymbolLang } from './schema.js';
 /**
@@ -23,7 +23,7 @@ export declare function parseSymbols(opts: {
 export { detectLang } from './languages.js';
 /**
  * The resolved Python binary (or null when no runtime is available).
- * Shared with the P3.8 batch parser so both paths run the same interpreter.
+ * Shared with the batch parser so both paths run the same interpreter.
  */
 export declare function resolvePythonBinary(): Promise<string | null>;
 //# sourceMappingURL=py-parser.d.ts.map

package/dist/codebase-index/rs-parser.d.ts

@@ -27,4 +27,11 @@ export declare function parseSymbols(opts: {
     lang: SymbolLang;
 }): Promise<FileSymbols>;
 export { detectLang } from './languages.js';
+/**
+ * Replace comments and string/char literal contents with spaces, keeping every
+ * offset and newline intact so match positions map straight back to the
+ * original source. Quote characters survive, so the lifetime guard
+ * (`'static`) still sees its apostrophe.
+ */
+export declare function maskRustNonCode(src: string): string;
 //# sourceMappingURL=rs-parser.d.ts.map

package/dist/codebase-index/toolchain-scripts.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The out-of-process parser programs (Go's `go/ast`, Python's `ast`) and the
+ * plumbing that runs them.
+ *
+ * The single-file parsers (`go-parser.ts`, `py-parser.ts`) and the batch
+ * parsers (`parser-batch.ts`) used to embed two hand-maintained copies of each
+ * program. The copies drifted: the Go batch reported 1-based columns while the
+ * single-file script reported 0-based ones, so the same file indexed with
+ * different positions depending on which path parsed it. Each language now has
+ * ONE extraction core; the single-file and batch programs differ only in their
+ * `main` (one source on stdin vs. a JSON array of sources).
+ */
+/** One Go source on stdin → `{"symbols": [...], "refs": [...]}`. */
+export declare const GO_PARSE_SCRIPT = "\npackage main\n\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"go/ast\"\n\t\"go/parser\"\n\t\"go/token\"\n\t\"io\"\n\t\"os\"\n\t\"strconv\"\n\t\"strings\"\n)\n\ntype Sym struct {\n\tName      string `json:\"name\"`\n\tKind      string `json:\"kind\"`\n\tLine      int    `json:\"line\"`\n\tCol       int    `json:\"col\"`\n\tSignature string `json:\"signature\"`\n\tScope     string `json:\"scope\"`\n\tDoc       string `json:\"doc\"`\n}\n\n// Ref is a cross-reference emitted alongside the symbols, so one run yields\n// both. Module is the import path for CallType \"import\", else empty.\ntype Ref struct {\n\tToName   string `json:\"toName\"`\n\tCallType string `json:\"callType\"`\n\tLine     int    `json:\"line\"`\n\tModule   string `json:\"module\"`\n}\n\nfunc extract(src []byte) ([]Sym, []Ref, error) {\n\tfset := token.NewFileSet()\n\tnode, err := parser.ParseFile(fset, \"src.go\", src, parser.ParseComments)\n\tif err != nil {\n\t\treturn nil, nil, err\n\t}\n\tpkg := node.Name.Name\n\t// token columns are 1-based; the index schema's are 0-based.\n\tat := func(p token.Pos) (int, int) {\n\t\tpos := fset.Position(p)\n\t\treturn pos.Line, pos.Column - 1\n\t}\n\n\tsyms := []Sym{}\n\tfor _, decl := range node.Decls {\n\t\tswitch d := decl.(type) {\n\t\tcase *ast.FuncDecl:\n\t\t\tline, col := at(d.Pos())\n\t\t\tkind := \"function\"\n\t\t\tscope := pkg + \".\" + d.Name.Name\n\t\t\tif d.Recv != nil && len(d.Recv.List) > 0 {\n\t\t\t\tkind = \"method\"\n\t\t\t\tscope = pkg + \".\" + recvTypeName(d.Recv.List[0].Type) + \".\" + d.Name.Name\n\t\t\t}\n\t\t\tsyms = append(syms, Sym{Name: d.Name.Name, Kind: kind, Line: line, Col: col, Signature: formatFuncSig(d), Scope: scope, Doc: firstDocLine(d.Doc)})\n\n\t\tcase *ast.GenDecl:\n\t\t\t// An ungrouped declaration carries its comment on the GenDecl; a\n\t\t\t// grouped one's doc describes the group, not each member.\n\t\t\tvar declDoc *ast.CommentGroup\n\t\t\tif !d.Lparen.IsValid() {\n\t\t\t\tdeclDoc = d.Doc\n\t\t\t}\n\t\t\tfor _, spec := range d.Specs {\n\t\t\t\tswitch s := spec.(type) {\n\t\t\t\tcase *ast.TypeSpec:\n\t\t\t\t\tline, col := at(s.Pos())\n\t\t\t\t\tsig := \"type \" + s.Name.Name + formatTypeParams(s.TypeParams)\n\t\t\t\t\tif s.Assign.IsValid() {\n\t\t\t\t\t\tsig += \" =\"\n\t\t\t\t\t}\n\t\t\t\t\tsig += \" \" + formatType(s.Type)\n\t\t\t\t\tsyms = append(syms, Sym{Name: s.Name.Name, Kind: \"type\", Line: line, Col: col, Signature: sig, Scope: pkg, Doc: firstDocLine(s.Doc, declDoc)})\n\t\t\t\tcase *ast.ValueSpec:\n\t\t\t\t\tkind := \"var\"\n\t\t\t\t\tif d.Tok == token.CONST {\n\t\t\t\t\t\tkind = \"const\"\n\t\t\t\t\t}\n\t\t\t\t\tfor _, n := range s.Names {\n\t\t\t\t\t\tline, col := at(n.Pos())\n\t\t\t\t\t\tsig := kind + \" \" + n.Name\n\t\t\t\t\t\tif s.Type != nil {\n\t\t\t\t\t\t\tsig += \" \" + formatType(s.Type)\n\t\t\t\t\t\t}\n\t\t\t\t\t\tsyms = append(syms, Sym{Name: n.Name, Kind: kind, Line: line, Col: col, Signature: sig, Scope: pkg, Doc: firstDocLine(s.Doc, declDoc)})\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\trefs := []Ref{}\n\tast.Inspect(node, func(n ast.Node) bool {\n\t\tswitch expr := n.(type) {\n\t\tcase *ast.CallExpr:\n\t\t\tline := fset.Position(expr.Pos()).Line\n\t\t\tswitch fun := expr.Fun.(type) {\n\t\t\tcase *ast.Ident:\n\t\t\t\trefs = append(refs, Ref{ToName: fun.Name, CallType: \"call\", Line: line})\n\t\t\tcase *ast.SelectorExpr:\n\t\t\t\t// The selected name (`Join` of `filepath.Join`) is the declared\n\t\t\t\t// symbol name, so it resolves like the TS and Python call refs.\n\t\t\t\trefs = append(refs, Ref{ToName: fun.Sel.Name, CallType: \"call\", Line: line})\n\t\t\t}\n\t\tcase *ast.ImportSpec:\n\t\t\tif expr.Path != nil {\n\t\t\t\tif importPath, uerr := strconv.Unquote(expr.Path.Value); uerr == nil {\n\t\t\t\t\tline := fset.Position(expr.Pos()).Line\n\t\t\t\t\t// A Go import names a package; its last path segment is the\n\t\t\t\t\t// name it is referenced by.\n\t\t\t\t\tname := importPath\n\t\t\t\t\tif idx := strings.LastIndex(importPath, \"/\"); idx >= 0 {\n\t\t\t\t\t\tname = importPath[idx+1:]\n\t\t\t\t\t}\n\t\t\t\t\trefs = append(refs, Ref{ToName: name, CallType: \"import\", Line: line, Module: importPath})\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn true\n\t})\n\treturn syms, refs, nil\n}\n\nfunc firstDocLine(groups ...*ast.CommentGroup) string {\n\tfor _, g := range groups {\n\t\tif g == nil {\n\t\t\tcontinue\n\t\t}\n\t\tfor _, line := range strings.Split(g.Text(), \"\\n\") {\n\t\t\tif t := strings.TrimSpace(line); t != \"\" {\n\t\t\t\tif r := []rune(t); len(r) > 200 {\n\t\t\t\t\tt = string(r[:200])\n\t\t\t\t}\n\t\t\t\treturn t\n\t\t\t}\n\t\t}\n\t}\n\treturn \"\"\n}\n\n// recvTypeName unwraps pointers, parens and generic instantiation:\n// `(l *List[T])` is a method of List, not of \"?\".\nfunc recvTypeName(t ast.Expr) string {\n\tswitch v := t.(type) {\n\tcase *ast.Ident:\n\t\treturn v.Name\n\tcase *ast.StarExpr:\n\t\treturn recvTypeName(v.X)\n\tcase *ast.ParenExpr:\n\t\treturn recvTypeName(v.X)\n\tcase *ast.IndexExpr:\n\t\treturn recvTypeName(v.X)\n\tcase *ast.IndexListExpr:\n\t\treturn recvTypeName(v.X)\n\tdefault:\n\t\treturn \"?\"\n\t}\n}\n\nfunc formatFuncSig(d *ast.FuncDecl) string {\n\tsig := \"func \"\n\tif d.Recv != nil && len(d.Recv.List) > 0 {\n\t\tsig += formatFieldList(d.Recv.List) + \" \"\n\t}\n\treturn sig + d.Name.Name + formatTypeParams(d.Type.TypeParams) + formatFuncType(d.Type)\n}\n\nfunc fieldsOf(fl *ast.FieldList) []*ast.Field {\n\tif fl == nil {\n\t\treturn nil\n\t}\n\treturn fl.List\n}\n\nfunc formatFuncType(f *ast.FuncType) string {\n\tout := formatFieldList(fieldsOf(f.Params))\n\tresults := fieldsOf(f.Results)\n\tif len(results) == 1 && len(results[0].Names) == 0 {\n\t\tout += \" \" + formatType(results[0].Type)\n\t} else if len(results) > 0 {\n\t\tout += \" \" + formatFieldList(results)\n\t}\n\treturn out\n}\n\n// formatField keeps every name of a shared-type field: `a, b int`.\nfunc formatField(f *ast.Field) string {\n\tt := formatType(f.Type)\n\tif len(f.Names) == 0 {\n\t\treturn t\n\t}\n\tnames := make([]string, len(f.Names))\n\tfor i, n := range f.Names {\n\t\tnames[i] = n.Name\n\t}\n\treturn strings.Join(names, \", \") + \" \" + t\n}\n\nfunc formatFieldList(fields []*ast.Field) string {\n\tparts := make([]string, len(fields))\n\tfor i, f := range fields {\n\t\tparts[i] = formatField(f)\n\t}\n\treturn \"(\" + strings.Join(parts, \", \") + \")\"\n}\n\n// formatFields renders struct fields and interface members.\nfunc formatFields(fields []*ast.Field) string {\n\tparts := make([]string, len(fields))\n\tfor i, f := range fields {\n\t\tif ft, ok := f.Type.(*ast.FuncType); ok && len(f.Names) == 1 {\n\t\t\tparts[i] = f.Names[0].Name + formatFuncType(ft)\n\t\t} else {\n\t\t\tparts[i] = formatField(f)\n\t\t}\n\t}\n\treturn strings.Join(parts, \"; \")\n}\n\nfunc formatTypeParams(tp *ast.FieldList) string {\n\tif tp == nil || len(tp.List) == 0 {\n\t\treturn \"\"\n\t}\n\tparts := make([]string, len(tp.List))\n\tfor i, p := range tp.List {\n\t\tparts[i] = formatField(p)\n\t}\n\treturn \"[\" + strings.Join(parts, \", \") + \"]\"\n}\n\nfunc formatType(t ast.Expr) string {\n\tif t == nil {\n\t\treturn \"?\"\n\t}\n\tswitch v := t.(type) {\n\tcase *ast.Ident:\n\t\treturn v.Name\n\tcase *ast.SelectorExpr:\n\t\treturn formatType(v.X) + \".\" + v.Sel.Name\n\tcase *ast.StarExpr:\n\t\treturn \"*\" + formatType(v.X)\n\tcase *ast.ParenExpr:\n\t\treturn \"(\" + formatType(v.X) + \")\"\n\tcase *ast.Ellipsis:\n\t\tif v.Elt == nil {\n\t\t\treturn \"...\"\n\t\t}\n\t\treturn \"...\" + formatType(v.Elt)\n\tcase *ast.ArrayType:\n\t\tif v.Len == nil {\n\t\t\treturn \"[]\" + formatType(v.Elt)\n\t\t}\n\t\treturn \"[\" + formatType(v.Len) + \"]\" + formatType(v.Elt)\n\tcase *ast.MapType:\n\t\treturn \"map[\" + formatType(v.Key) + \"]\" + formatType(v.Value)\n\tcase *ast.ChanType:\n\t\tswitch v.Dir {\n\t\tcase ast.SEND:\n\t\t\treturn \"chan<- \" + formatType(v.Value)\n\t\tcase ast.RECV:\n\t\t\treturn \"<-chan \" + formatType(v.Value)\n\t\tdefault:\n\t\t\treturn \"chan \" + formatType(v.Value)\n\t\t}\n\tcase *ast.InterfaceType:\n\t\tif len(fieldsOf(v.Methods)) == 0 {\n\t\t\treturn \"interface{}\"\n\t\t}\n\t\treturn \"interface{ \" + formatFields(v.Methods.List) + \" }\"\n\tcase *ast.StructType:\n\t\tif len(fieldsOf(v.Fields)) == 0 {\n\t\t\treturn \"struct{}\"\n\t\t}\n\t\treturn \"struct{ \" + formatFields(v.Fields.List) + \" }\"\n\tcase *ast.FuncType:\n\t\treturn \"func\" + formatFuncType(v)\n\tcase *ast.UnaryExpr:\n\t\treturn v.Op.String() + formatType(v.X)\n\tcase *ast.BinaryExpr:\n\t\treturn formatType(v.X) + \" \" + v.Op.String() + \" \" + formatType(v.Y)\n\tcase *ast.BasicLit:\n\t\treturn v.Value\n\tcase *ast.IndexExpr:\n\t\treturn formatType(v.X) + \"[\" + formatType(v.Index) + \"]\"\n\tcase *ast.IndexListExpr:\n\t\targs := make([]string, len(v.Indices))\n\t\tfor i, idx := range v.Indices {\n\t\t\targs[i] = formatType(idx)\n\t\t}\n\t\treturn formatType(v.X) + \"[\" + strings.Join(args, \", \") + \"]\"\n\tdefault:\n\t\treturn \"?\"\n\t}\n}\n\ntype Result struct {\n\tSymbols []Sym `json:\"symbols\"`\n\tRefs    []Ref `json:\"refs\"`\n}\n\nfunc main() {\n\tempty := `{\"symbols\":[],\"refs\":[]}`\n\tsrc, err := io.ReadAll(os.Stdin)\n\tif err != nil {\n\t\tfmt.Print(empty)\n\t\treturn\n\t}\n\tsyms, refs, err := extract(src)\n\tif err != nil {\n\t\tfmt.Print(empty)\n\t\treturn\n\t}\n\tdata, err := json.Marshal(Result{Symbols: syms, Refs: refs})\n\tif err != nil {\n\t\tfmt.Print(empty)\n\t\treturn\n\t}\n\tfmt.Print(string(data))\n}\n";
+/** A JSON array of `{file, content}` on stdin → one envelope with per-file results. */
+export declare const GO_BATCH_SCRIPT = "\npackage main\n\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"go/ast\"\n\t\"go/parser\"\n\t\"go/token\"\n\t\"io\"\n\t\"os\"\n\t\"strconv\"\n\t\"strings\"\n)\n\ntype Sym struct {\n\tName      string `json:\"name\"`\n\tKind      string `json:\"kind\"`\n\tLine      int    `json:\"line\"`\n\tCol       int    `json:\"col\"`\n\tSignature string `json:\"signature\"`\n\tScope     string `json:\"scope\"`\n\tDoc       string `json:\"doc\"`\n}\n\n// Ref is a cross-reference emitted alongside the symbols, so one run yields\n// both. Module is the import path for CallType \"import\", else empty.\ntype Ref struct {\n\tToName   string `json:\"toName\"`\n\tCallType string `json:\"callType\"`\n\tLine     int    `json:\"line\"`\n\tModule   string `json:\"module\"`\n}\n\nfunc extract(src []byte) ([]Sym, []Ref, error) {\n\tfset := token.NewFileSet()\n\tnode, err := parser.ParseFile(fset, \"src.go\", src, parser.ParseComments)\n\tif err != nil {\n\t\treturn nil, nil, err\n\t}\n\tpkg := node.Name.Name\n\t// token columns are 1-based; the index schema's are 0-based.\n\tat := func(p token.Pos) (int, int) {\n\t\tpos := fset.Position(p)\n\t\treturn pos.Line, pos.Column - 1\n\t}\n\n\tsyms := []Sym{}\n\tfor _, decl := range node.Decls {\n\t\tswitch d := decl.(type) {\n\t\tcase *ast.FuncDecl:\n\t\t\tline, col := at(d.Pos())\n\t\t\tkind := \"function\"\n\t\t\tscope := pkg + \".\" + d.Name.Name\n\t\t\tif d.Recv != nil && len(d.Recv.List) > 0 {\n\t\t\t\tkind = \"method\"\n\t\t\t\tscope = pkg + \".\" + recvTypeName(d.Recv.List[0].Type) + \".\" + d.Name.Name\n\t\t\t}\n\t\t\tsyms = append(syms, Sym{Name: d.Name.Name, Kind: kind, Line: line, Col: col, Signature: formatFuncSig(d), Scope: scope, Doc: firstDocLine(d.Doc)})\n\n\t\tcase *ast.GenDecl:\n\t\t\t// An ungrouped declaration carries its comment on the GenDecl; a\n\t\t\t// grouped one's doc describes the group, not each member.\n\t\t\tvar declDoc *ast.CommentGroup\n\t\t\tif !d.Lparen.IsValid() {\n\t\t\t\tdeclDoc = d.Doc\n\t\t\t}\n\t\t\tfor _, spec := range d.Specs {\n\t\t\t\tswitch s := spec.(type) {\n\t\t\t\tcase *ast.TypeSpec:\n\t\t\t\t\tline, col := at(s.Pos())\n\t\t\t\t\tsig := \"type \" + s.Name.Name + formatTypeParams(s.TypeParams)\n\t\t\t\t\tif s.Assign.IsValid() {\n\t\t\t\t\t\tsig += \" =\"\n\t\t\t\t\t}\n\t\t\t\t\tsig += \" \" + formatType(s.Type)\n\t\t\t\t\tsyms = append(syms, Sym{Name: s.Name.Name, Kind: \"type\", Line: line, Col: col, Signature: sig, Scope: pkg, Doc: firstDocLine(s.Doc, declDoc)})\n\t\t\t\tcase *ast.ValueSpec:\n\t\t\t\t\tkind := \"var\"\n\t\t\t\t\tif d.Tok == token.CONST {\n\t\t\t\t\t\tkind = \"const\"\n\t\t\t\t\t}\n\t\t\t\t\tfor _, n := range s.Names {\n\t\t\t\t\t\tline, col := at(n.Pos())\n\t\t\t\t\t\tsig := kind + \" \" + n.Name\n\t\t\t\t\t\tif s.Type != nil {\n\t\t\t\t\t\t\tsig += \" \" + formatType(s.Type)\n\t\t\t\t\t\t}\n\t\t\t\t\t\tsyms = append(syms, Sym{Name: n.Name, Kind: kind, Line: line, Col: col, Signature: sig, Scope: pkg, Doc: firstDocLine(s.Doc, declDoc)})\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\trefs := []Ref{}\n\tast.Inspect(node, func(n ast.Node) bool {\n\t\tswitch expr := n.(type) {\n\t\tcase *ast.CallExpr:\n\t\t\tline := fset.Position(expr.Pos()).Line\n\t\t\tswitch fun := expr.Fun.(type) {\n\t\t\tcase *ast.Ident:\n\t\t\t\trefs = append(refs, Ref{ToName: fun.Name, CallType: \"call\", Line: line})\n\t\t\tcase *ast.SelectorExpr:\n\t\t\t\t// The selected name (`Join` of `filepath.Join`) is the declared\n\t\t\t\t// symbol name, so it resolves like the TS and Python call refs.\n\t\t\t\trefs = append(refs, Ref{ToName: fun.Sel.Name, CallType: \"call\", Line: line})\n\t\t\t}\n\t\tcase *ast.ImportSpec:\n\t\t\tif expr.Path != nil {\n\t\t\t\tif importPath, uerr := strconv.Unquote(expr.Path.Value); uerr == nil {\n\t\t\t\t\tline := fset.Position(expr.Pos()).Line\n\t\t\t\t\t// A Go import names a package; its last path segment is the\n\t\t\t\t\t// name it is referenced by.\n\t\t\t\t\tname := importPath\n\t\t\t\t\tif idx := strings.LastIndex(importPath, \"/\"); idx >= 0 {\n\t\t\t\t\t\tname = importPath[idx+1:]\n\t\t\t\t\t}\n\t\t\t\t\trefs = append(refs, Ref{ToName: name, CallType: \"import\", Line: line, Module: importPath})\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn true\n\t})\n\treturn syms, refs, nil\n}\n\nfunc firstDocLine(groups ...*ast.CommentGroup) string {\n\tfor _, g := range groups {\n\t\tif g == nil {\n\t\t\tcontinue\n\t\t}\n\t\tfor _, line := range strings.Split(g.Text(), \"\\n\") {\n\t\t\tif t := strings.TrimSpace(line); t != \"\" {\n\t\t\t\tif r := []rune(t); len(r) > 200 {\n\t\t\t\t\tt = string(r[:200])\n\t\t\t\t}\n\t\t\t\treturn t\n\t\t\t}\n\t\t}\n\t}\n\treturn \"\"\n}\n\n// recvTypeName unwraps pointers, parens and generic instantiation:\n// `(l *List[T])` is a method of List, not of \"?\".\nfunc recvTypeName(t ast.Expr) string {\n\tswitch v := t.(type) {\n\tcase *ast.Ident:\n\t\treturn v.Name\n\tcase *ast.StarExpr:\n\t\treturn recvTypeName(v.X)\n\tcase *ast.ParenExpr:\n\t\treturn recvTypeName(v.X)\n\tcase *ast.IndexExpr:\n\t\treturn recvTypeName(v.X)\n\tcase *ast.IndexListExpr:\n\t\treturn recvTypeName(v.X)\n\tdefault:\n\t\treturn \"?\"\n\t}\n}\n\nfunc formatFuncSig(d *ast.FuncDecl) string {\n\tsig := \"func \"\n\tif d.Recv != nil && len(d.Recv.List) > 0 {\n\t\tsig += formatFieldList(d.Recv.List) + \" \"\n\t}\n\treturn sig + d.Name.Name + formatTypeParams(d.Type.TypeParams) + formatFuncType(d.Type)\n}\n\nfunc fieldsOf(fl *ast.FieldList) []*ast.Field {\n\tif fl == nil {\n\t\treturn nil\n\t}\n\treturn fl.List\n}\n\nfunc formatFuncType(f *ast.FuncType) string {\n\tout := formatFieldList(fieldsOf(f.Params))\n\tresults := fieldsOf(f.Results)\n\tif len(results) == 1 && len(results[0].Names) == 0 {\n\t\tout += \" \" + formatType(results[0].Type)\n\t} else if len(results) > 0 {\n\t\tout += \" \" + formatFieldList(results)\n\t}\n\treturn out\n}\n\n// formatField keeps every name of a shared-type field: `a, b int`.\nfunc formatField(f *ast.Field) string {\n\tt := formatType(f.Type)\n\tif len(f.Names) == 0 {\n\t\treturn t\n\t}\n\tnames := make([]string, len(f.Names))\n\tfor i, n := range f.Names {\n\t\tnames[i] = n.Name\n\t}\n\treturn strings.Join(names, \", \") + \" \" + t\n}\n\nfunc formatFieldList(fields []*ast.Field) string {\n\tparts := make([]string, len(fields))\n\tfor i, f := range fields {\n\t\tparts[i] = formatField(f)\n\t}\n\treturn \"(\" + strings.Join(parts, \", \") + \")\"\n}\n\n// formatFields renders struct fields and interface members.\nfunc formatFields(fields []*ast.Field) string {\n\tparts := make([]string, len(fields))\n\tfor i, f := range fields {\n\t\tif ft, ok := f.Type.(*ast.FuncType); ok && len(f.Names) == 1 {\n\t\t\tparts[i] = f.Names[0].Name + formatFuncType(ft)\n\t\t} else {\n\t\t\tparts[i] = formatField(f)\n\t\t}\n\t}\n\treturn strings.Join(parts, \"; \")\n}\n\nfunc formatTypeParams(tp *ast.FieldList) string {\n\tif tp == nil || len(tp.List) == 0 {\n\t\treturn \"\"\n\t}\n\tparts := make([]string, len(tp.List))\n\tfor i, p := range tp.List {\n\t\tparts[i] = formatField(p)\n\t}\n\treturn \"[\" + strings.Join(parts, \", \") + \"]\"\n}\n\nfunc formatType(t ast.Expr) string {\n\tif t == nil {\n\t\treturn \"?\"\n\t}\n\tswitch v := t.(type) {\n\tcase *ast.Ident:\n\t\treturn v.Name\n\tcase *ast.SelectorExpr:\n\t\treturn formatType(v.X) + \".\" + v.Sel.Name\n\tcase *ast.StarExpr:\n\t\treturn \"*\" + formatType(v.X)\n\tcase *ast.ParenExpr:\n\t\treturn \"(\" + formatType(v.X) + \")\"\n\tcase *ast.Ellipsis:\n\t\tif v.Elt == nil {\n\t\t\treturn \"...\"\n\t\t}\n\t\treturn \"...\" + formatType(v.Elt)\n\tcase *ast.ArrayType:\n\t\tif v.Len == nil {\n\t\t\treturn \"[]\" + formatType(v.Elt)\n\t\t}\n\t\treturn \"[\" + formatType(v.Len) + \"]\" + formatType(v.Elt)\n\tcase *ast.MapType:\n\t\treturn \"map[\" + formatType(v.Key) + \"]\" + formatType(v.Value)\n\tcase *ast.ChanType:\n\t\tswitch v.Dir {\n\t\tcase ast.SEND:\n\t\t\treturn \"chan<- \" + formatType(v.Value)\n\t\tcase ast.RECV:\n\t\t\treturn \"<-chan \" + formatType(v.Value)\n\t\tdefault:\n\t\t\treturn \"chan \" + formatType(v.Value)\n\t\t}\n\tcase *ast.InterfaceType:\n\t\tif len(fieldsOf(v.Methods)) == 0 {\n\t\t\treturn \"interface{}\"\n\t\t}\n\t\treturn \"interface{ \" + formatFields(v.Methods.List) + \" }\"\n\tcase *ast.StructType:\n\t\tif len(fieldsOf(v.Fields)) == 0 {\n\t\t\treturn \"struct{}\"\n\t\t}\n\t\treturn \"struct{ \" + formatFields(v.Fields.List) + \" }\"\n\tcase *ast.FuncType:\n\t\treturn \"func\" + formatFuncType(v)\n\tcase *ast.UnaryExpr:\n\t\treturn v.Op.String() + formatType(v.X)\n\tcase *ast.BinaryExpr:\n\t\treturn formatType(v.X) + \" \" + v.Op.String() + \" \" + formatType(v.Y)\n\tcase *ast.BasicLit:\n\t\treturn v.Value\n\tcase *ast.IndexExpr:\n\t\treturn formatType(v.X) + \"[\" + formatType(v.Index) + \"]\"\n\tcase *ast.IndexListExpr:\n\t\targs := make([]string, len(v.Indices))\n\t\tfor i, idx := range v.Indices {\n\t\t\targs[i] = formatType(idx)\n\t\t}\n\t\treturn formatType(v.X) + \"[\" + strings.Join(args, \", \") + \"]\"\n\tdefault:\n\t\treturn \"?\"\n\t}\n}\n\ntype FileResult struct {\n\tFile    string `json:\"file\"`\n\tError   string `json:\"error,omitempty\"`\n\tSymbols []Sym  `json:\"symbols\"`\n\tRefs    []Ref  `json:\"refs\"`\n}\n\ntype BatchResult struct {\n\tVersion int          `json:\"version\"`\n\tResults []FileResult `json:\"results\"`\n}\n\ntype inputFile struct {\n\tFile    string `json:\"file\"`\n\tContent string `json:\"content\"`\n}\n\nfunc main() {\n\tvar inputs []inputFile\n\traw, err := io.ReadAll(os.Stdin)\n\tif err == nil {\n\t\terr = json.Unmarshal(raw, &inputs)\n\t}\n\tresults := make([]FileResult, 0, len(inputs))\n\tif err == nil {\n\t\tfor _, in := range inputs {\n\t\t\tres := FileResult{File: in.File, Symbols: []Sym{}, Refs: []Ref{}}\n\t\t\tif syms, refs, perr := extract([]byte(in.Content)); perr != nil {\n\t\t\t\tres.Error = perr.Error()\n\t\t\t} else {\n\t\t\t\tres.Symbols, res.Refs = syms, refs\n\t\t\t}\n\t\t\tresults = append(results, res)\n\t\t}\n\t}\n\tdata, merr := json.Marshal(BatchResult{Version: 1, Results: results})\n\tif merr != nil {\n\t\tfmt.Print(`{\"version\":1,\"results\":[]}`)\n\t\treturn\n\t}\n\tfmt.Print(string(data))\n}\n";
+/** One Python source on stdin (file path in argv[1]) → `{"symbols", "refs"}`. */
+export declare const PY_PARSE_SCRIPT = "import ast, json, sys\n\n# Decorators whose function is an attribute accessor, by last dotted segment.\nPROPERTY_DECORATORS = (\"property\", \"cached_property\", \"abstractproperty\", \"setter\", \"getter\", \"deleter\")\n\ndef get_name(node):\n    if isinstance(node, ast.Name):\n        return node.id\n    if isinstance(node, ast.Attribute):\n        return get_name(node.value) + \".\" + node.attr\n    if isinstance(node, ast.Subscript):\n        return get_name(node.value)\n    if isinstance(node, ast.Call):\n        return get_name(node.func)\n    if isinstance(node, ast.Constant):\n        return str(node.value)\n    return \"\"\n\ndef leaf_name(node):\n    # Declared name of the callee: `join` of `os.path.join`. Matches how the\n    # TypeScript and Go extractors record call refs.\n    if isinstance(node, ast.Attribute):\n        return node.attr\n    if isinstance(node, ast.Name):\n        return node.id\n    return get_name(node).split(\".\")[-1]\n\ndef is_private(name):\n    return name.startswith(\"__\") and not name.endswith(\"__\")\n\ndef first_doc_line(node):\n    try:\n        doc = ast.get_docstring(node)\n    except Exception:\n        return \"\"\n    for line in (doc or \"\").splitlines():\n        line = line.strip()\n        if line:\n            return line[:200]\n    return \"\"\n\ndef module_name_of(path):\n    base = path.replace(\"\\\\\", \"/\").rsplit(\"/\", 1)[-1]\n    return base.rsplit(\".\", 1)[0] if \".\" in base else base\n\ndef read_stdin_text():\n    # Decode explicitly: sys.stdin uses the locale code page on Windows\n    # (cp1254, cp1252, ...), which mangles or rejects the UTF-8 we are sent.\n    return sys.stdin.buffer.read().decode(\"utf-8\", \"replace\")\n\ndef parse_source(text, name):\n    # ast.parse rejects a leading U+FEFF in a str source.\n    if text.startswith(\"\\ufeff\"):\n        text = text[1:]\n    return ast.parse(text, filename=name or \"<module>\")\n\ndef format_args(args):\n    parts = [a.arg for a in list(getattr(args, \"posonlyargs\", [])) + list(args.args)]\n    if args.vararg is not None:\n        parts.append(\"*\" + args.vararg.arg)\n    elif args.kwonlyargs:\n        parts.append(\"*\")\n    parts.extend(a.arg for a in args.kwonlyargs)\n    if args.kwarg is not None:\n        parts.append(\"**\" + args.kwarg.arg)\n    return \", \".join(parts)\n\ndef extract(tree, module_name):\n    syms = []\n    refs = []\n    scope = [module_name]\n\n    def add(name, kind, line, col, signature, sym_scope, doc=\"\"):\n        syms.append({\n            \"name\": name, \"kind\": kind, \"line\": line, \"col\": col,\n            \"signature\": signature, \"scope\": sym_scope, \"doc\": doc,\n        })\n\n    def qualified(name):\n        return \".\".join(scope) + \".\" + name\n\n    # Kinds are the index schema's (class/function/method/property/var/const/\n    # type). Imports are refs, not symbols: an import symbol per file made\n    # every imported name look like a definition in every importing module.\n    class Visitor(ast.NodeVisitor):\n        in_class = False\n\n        def visit_ClassDef(self, node):\n            bases = [get_name(b) for b in node.bases]\n            sig = \"class \" + node.name + (\"(\" + \", \".join(bases) + \")\" if bases else \"\") + \": ...\"\n            add(node.name, \"class\", node.lineno, node.col_offset, sig, qualified(node.name), first_doc_line(node))\n            scope.append(node.name)\n            outer = self.in_class\n            self.in_class = True\n            try:\n                self.generic_visit(node)\n            finally:\n                self.in_class = outer\n                scope.pop()\n\n        def visit_FunctionDef(self, node):\n            kind = \"method\" if self.in_class else \"function\"\n            for dec in node.decorator_list:\n                if get_name(dec).rsplit(\".\", 1)[-1] in PROPERTY_DECORATORS:\n                    kind = \"property\"\n            prefix = \"async def \" if isinstance(node, ast.AsyncFunctionDef) else \"def \"\n            sig = prefix + node.name + \"(\" + format_args(node.args) + \")\"\n            returns = get_name(node.returns) if node.returns is not None else \"\"\n            if returns:\n                sig += \" -> \" + returns\n            add(node.name, kind, node.lineno, node.col_offset, sig, qualified(node.name), first_doc_line(node))\n            # Bodies are not visited: function locals are not index symbols.\n\n        visit_AsyncFunctionDef = visit_FunctionDef\n\n        def add_target(self, target, line, annotation=None, has_value=True):\n            if isinstance(target, ast.Name):\n                if is_private(target.id):\n                    return\n                kind = \"const\" if target.id.isupper() else \"var\"\n                if annotation is not None:\n                    sig = target.id + \": \" + get_name(annotation) + (\" = ...\" if has_value else \"\")\n                else:\n                    sig = target.id + \" = ...\"\n                add(target.id, kind, line, target.col_offset, sig, \".\".join(scope))\n            elif isinstance(target, (ast.Tuple, ast.List)):\n                for elt in target.elts:\n                    self.add_target(elt, line)\n            elif isinstance(target, ast.Starred):\n                self.add_target(target.value, line)\n\n        def visit_Assign(self, node):\n            for target in node.targets:\n                self.add_target(target, node.lineno)\n\n        def visit_AnnAssign(self, node):\n            self.add_target(node.target, node.lineno, node.annotation, node.value is not None)\n\n        def visit_TypeAlias(self, node):\n            if isinstance(node.name, ast.Name):\n                add(node.name.id, \"type\", node.lineno, node.col_offset, \"type \" + node.name.id + \" = ...\", \".\".join(scope))\n\n    Visitor().visit(tree)\n\n    # Refs need a full walk: the visitor deliberately skips function bodies,\n    # which is exactly where the calls are.\n    for node in ast.walk(tree):\n        if isinstance(node, ast.Call):\n            name = leaf_name(node.func)\n            if name:\n                refs.append({\"toName\": name, \"callType\": \"call\", \"line\": node.lineno})\n        elif isinstance(node, ast.Import):\n            for alias in node.names:\n                refs.append({\n                    \"toName\": alias.name.split(\".\")[-1], \"callType\": \"import\",\n                    \"line\": node.lineno, \"module\": alias.name,\n                })\n        elif isinstance(node, ast.ImportFrom):\n            # PEP 328: keep the leading dots so the resolver can walk up from\n            # the importing file's package.\n            module = (\".\" * (node.level or 0)) + (node.module or \"\")\n            for alias in node.names:\n                refs.append({\n                    \"toName\": alias.name, \"callType\": \"import\",\n                    \"line\": node.lineno, \"module\": module,\n                })\n        elif isinstance(node, ast.ClassDef):\n            for base in node.bases:\n                name = leaf_name(base)\n                if name:\n                    refs.append({\"toName\": name, \"callType\": \"inherit\", \"line\": node.lineno})\n\n    return syms, refs\n\ndef main():\n    name = sys.argv[1] if len(sys.argv) > 1 else \"module.py\"\n    try:\n        syms, refs = extract(parse_source(read_stdin_text(), name), module_name_of(name))\n    except Exception:\n        syms, refs = [], []\n    print(json.dumps({\"symbols\": syms, \"refs\": refs}))\n\nmain()\n";
+/** A JSON array of `{file, content}` on stdin → one envelope with per-file results. */
+export declare const PY_BATCH_SCRIPT = "import ast, json, sys\n\n# Decorators whose function is an attribute accessor, by last dotted segment.\nPROPERTY_DECORATORS = (\"property\", \"cached_property\", \"abstractproperty\", \"setter\", \"getter\", \"deleter\")\n\ndef get_name(node):\n    if isinstance(node, ast.Name):\n        return node.id\n    if isinstance(node, ast.Attribute):\n        return get_name(node.value) + \".\" + node.attr\n    if isinstance(node, ast.Subscript):\n        return get_name(node.value)\n    if isinstance(node, ast.Call):\n        return get_name(node.func)\n    if isinstance(node, ast.Constant):\n        return str(node.value)\n    return \"\"\n\ndef leaf_name(node):\n    # Declared name of the callee: `join` of `os.path.join`. Matches how the\n    # TypeScript and Go extractors record call refs.\n    if isinstance(node, ast.Attribute):\n        return node.attr\n    if isinstance(node, ast.Name):\n        return node.id\n    return get_name(node).split(\".\")[-1]\n\ndef is_private(name):\n    return name.startswith(\"__\") and not name.endswith(\"__\")\n\ndef first_doc_line(node):\n    try:\n        doc = ast.get_docstring(node)\n    except Exception:\n        return \"\"\n    for line in (doc or \"\").splitlines():\n        line = line.strip()\n        if line:\n            return line[:200]\n    return \"\"\n\ndef module_name_of(path):\n    base = path.replace(\"\\\\\", \"/\").rsplit(\"/\", 1)[-1]\n    return base.rsplit(\".\", 1)[0] if \".\" in base else base\n\ndef read_stdin_text():\n    # Decode explicitly: sys.stdin uses the locale code page on Windows\n    # (cp1254, cp1252, ...), which mangles or rejects the UTF-8 we are sent.\n    return sys.stdin.buffer.read().decode(\"utf-8\", \"replace\")\n\ndef parse_source(text, name):\n    # ast.parse rejects a leading U+FEFF in a str source.\n    if text.startswith(\"\\ufeff\"):\n        text = text[1:]\n    return ast.parse(text, filename=name or \"<module>\")\n\ndef format_args(args):\n    parts = [a.arg for a in list(getattr(args, \"posonlyargs\", [])) + list(args.args)]\n    if args.vararg is not None:\n        parts.append(\"*\" + args.vararg.arg)\n    elif args.kwonlyargs:\n        parts.append(\"*\")\n    parts.extend(a.arg for a in args.kwonlyargs)\n    if args.kwarg is not None:\n        parts.append(\"**\" + args.kwarg.arg)\n    return \", \".join(parts)\n\ndef extract(tree, module_name):\n    syms = []\n    refs = []\n    scope = [module_name]\n\n    def add(name, kind, line, col, signature, sym_scope, doc=\"\"):\n        syms.append({\n            \"name\": name, \"kind\": kind, \"line\": line, \"col\": col,\n            \"signature\": signature, \"scope\": sym_scope, \"doc\": doc,\n        })\n\n    def qualified(name):\n        return \".\".join(scope) + \".\" + name\n\n    # Kinds are the index schema's (class/function/method/property/var/const/\n    # type). Imports are refs, not symbols: an import symbol per file made\n    # every imported name look like a definition in every importing module.\n    class Visitor(ast.NodeVisitor):\n        in_class = False\n\n        def visit_ClassDef(self, node):\n            bases = [get_name(b) for b in node.bases]\n            sig = \"class \" + node.name + (\"(\" + \", \".join(bases) + \")\" if bases else \"\") + \": ...\"\n            add(node.name, \"class\", node.lineno, node.col_offset, sig, qualified(node.name), first_doc_line(node))\n            scope.append(node.name)\n            outer = self.in_class\n            self.in_class = True\n            try:\n                self.generic_visit(node)\n            finally:\n                self.in_class = outer\n                scope.pop()\n\n        def visit_FunctionDef(self, node):\n            kind = \"method\" if self.in_class else \"function\"\n            for dec in node.decorator_list:\n                if get_name(dec).rsplit(\".\", 1)[-1] in PROPERTY_DECORATORS:\n                    kind = \"property\"\n            prefix = \"async def \" if isinstance(node, ast.AsyncFunctionDef) else \"def \"\n            sig = prefix + node.name + \"(\" + format_args(node.args) + \")\"\n            returns = get_name(node.returns) if node.returns is not None else \"\"\n            if returns:\n                sig += \" -> \" + returns\n            add(node.name, kind, node.lineno, node.col_offset, sig, qualified(node.name), first_doc_line(node))\n            # Bodies are not visited: function locals are not index symbols.\n\n        visit_AsyncFunctionDef = visit_FunctionDef\n\n        def add_target(self, target, line, annotation=None, has_value=True):\n            if isinstance(target, ast.Name):\n                if is_private(target.id):\n                    return\n                kind = \"const\" if target.id.isupper() else \"var\"\n                if annotation is not None:\n                    sig = target.id + \": \" + get_name(annotation) + (\" = ...\" if has_value else \"\")\n                else:\n                    sig = target.id + \" = ...\"\n                add(target.id, kind, line, target.col_offset, sig, \".\".join(scope))\n            elif isinstance(target, (ast.Tuple, ast.List)):\n                for elt in target.elts:\n                    self.add_target(elt, line)\n            elif isinstance(target, ast.Starred):\n                self.add_target(target.value, line)\n\n        def visit_Assign(self, node):\n            for target in node.targets:\n                self.add_target(target, node.lineno)\n\n        def visit_AnnAssign(self, node):\n            self.add_target(node.target, node.lineno, node.annotation, node.value is not None)\n\n        def visit_TypeAlias(self, node):\n            if isinstance(node.name, ast.Name):\n                add(node.name.id, \"type\", node.lineno, node.col_offset, \"type \" + node.name.id + \" = ...\", \".\".join(scope))\n\n    Visitor().visit(tree)\n\n    # Refs need a full walk: the visitor deliberately skips function bodies,\n    # which is exactly where the calls are.\n    for node in ast.walk(tree):\n        if isinstance(node, ast.Call):\n            name = leaf_name(node.func)\n            if name:\n                refs.append({\"toName\": name, \"callType\": \"call\", \"line\": node.lineno})\n        elif isinstance(node, ast.Import):\n            for alias in node.names:\n                refs.append({\n                    \"toName\": alias.name.split(\".\")[-1], \"callType\": \"import\",\n                    \"line\": node.lineno, \"module\": alias.name,\n                })\n        elif isinstance(node, ast.ImportFrom):\n            # PEP 328: keep the leading dots so the resolver can walk up from\n            # the importing file's package.\n            module = (\".\" * (node.level or 0)) + (node.module or \"\")\n            for alias in node.names:\n                refs.append({\n                    \"toName\": alias.name, \"callType\": \"import\",\n                    \"line\": node.lineno, \"module\": module,\n                })\n        elif isinstance(node, ast.ClassDef):\n            for base in node.bases:\n                name = leaf_name(base)\n                if name:\n                    refs.append({\"toName\": name, \"callType\": \"inherit\", \"line\": node.lineno})\n\n    return syms, refs\n\ndef main():\n    try:\n        inputs = json.loads(read_stdin_text())\n    except Exception:\n        print(json.dumps({\"version\": 1, \"results\": []}))\n        return\n    results = []\n    for entry in inputs:\n        name = entry.get(\"file\", \"\")\n        result = {\"file\": name, \"symbols\": [], \"refs\": []}\n        try:\n            syms, refs = extract(parse_source(entry.get(\"content\", \"\"), name), module_name_of(name))\n            result[\"symbols\"] = syms\n            result[\"refs\"] = refs\n        except Exception as e:\n            result[\"error\"] = str(e) or type(e).__name__\n        results.append(result)\n    print(json.dumps({\"version\": 1, \"results\": results}))\n\nmain()\n";
+/**
+ * Path of `script` written to a PRIVATE, UNPREDICTABLE directory, written once
+ * per process.
+ *
+ * Security: a fixed location such as `os.tmpdir()/ws-py-parse/parse.py` can be
+ * pre-created by another local user, who then either symlinks the script path
+ * (our write follows the link) or leaves their own `ast.py`/`json.py` next to
+ * it — Python puts the script's directory first on `sys.path`, so indexing
+ * would run their module. `fs.mkdtemp` creates the directory with a random
+ * suffix (0700 on POSIX) and `wx` refuses to write through anything already at
+ * the path. The in-flight promise is cached so concurrent first calls share
+ * one directory instead of racing to create several.
+ */
+export declare function privateScriptPath(prefix: string, fileName: string, script: string): Promise<string>;
+/** Test-only: every script path written so far (failed writes resolve to ''). */
+export declare function __privateScriptPathsForTest(): Promise<string[]>;
+interface ToolchainSpawnOptions {
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * Run `go run` from the script's own directory, never the indexed project.
+ *
+ * Launched from the project, the go command reads the project's `go.mod` and
+ * `go.work`: a `go`/`toolchain` line newer than the installed Go made every
+ * parse fail ("requires go >= …"), dropping the whole repository to the regex
+ * fallback — or, with the default `GOTOOLCHAIN=auto`, made indexing download
+ * and run whatever toolchain the scanned repository named. The parser only
+ * needs the standard library, so it runs outside any module on the local
+ * toolchain.
+ */
+export declare function goSpawnOptions(scriptPath: string): ToolchainSpawnOptions;
+/** Python runs from the script directory too, so the project is never on its path. */
+export declare function pySpawnOptions(scriptPath: string): ToolchainSpawnOptions;
+/**
+ * Spawn a parser child, feed `stdinPayload`, collect stdout.
+ * Resolves `null` on spawn failure or timeout; never rejects.
+ */
+export declare function runToolchainChild(binary: string, args: string[], stdinPayload: string, timeoutMs: number, options: ToolchainSpawnOptions): Promise<{
+    code: number | null;
+    stdout: string;
+} | null>;
+export {};
+//# sourceMappingURL=toolchain-scripts.d.ts.map

package/dist/codebase-index/tree-sitter/queries.d.ts

@@ -47,6 +47,20 @@ export interface NodeQueries {
     scopeNodes?: ReadonlySet<string>;
     skipNamedChildren?: boolean;
     refRules?: Partial<Record<string, RefRule>>;
+    /**
+     * Final say on a matched node's kind; `null` skips it. For node types that
+     * are only sometimes declarations: C's `declaration` (prototype, global or
+     * local), a Ruby `constant` (assignment target or mere reference), an
+     * Elixir `call` (`def` or any call at all).
+     */
+    resolveKind?: (node: import('web-tree-sitter').Node, kind: SymbolKind) => SymbolKind | null;
+    /**
+     * Names for nodes that declare several (`int a, b;`) or whose name is not an
+     * identifier child. `undefined` falls back to single-name extraction.
+     */
+    declaredNames?: (node: import('web-tree-sitter').Node) => readonly string[] | undefined;
+    /** Scope membership decided per node; replaces `scopeNodes` when set. */
+    isScopeNode?: (node: import('web-tree-sitter').Node) => boolean;
 }
 /** One ref a refRule wants emitted. `callType` defaults to the rule's. */
 export interface RefEmission {