@wrongstack/tools 1.0.10 → 1.0.12

package/dist/codebase-index/dead-code-scan.d.ts

@@ -69,6 +69,10 @@ export interface DeadCodeScanOutput {
     };
 }
 export declare const deadCodeScanTool: Tool<DeadCodeScanInput, DeadCodeScanOutput>;
+/**
+ * Walk the workspace and discover entry-point files from package.json(s).
+ */
+export declare function discoverEntryPoints(projectRoot: string, userEntryPoints: string[] | undefined): string[];
 export declare function runDeadCodeScan(projectRoot: string, opts?: {
     indexDir?: string | undefined;
     userEntryPoints?: string[] | undefined;

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

@@ -1,10 +1,11 @@
 /**
  * Go source symbol extraction using `go/parser`.
  *
- * Spawns a `go run -` child process that parses the file with go/ast and
- * emits JSON. Falls back to empty results on any error.
+ * Runs the extraction program from `toolchain-scripts.ts` under `go run`, with
+ * the source on stdin, and decodes its JSON. When the toolchain is missing or
+ * the run yields nothing, a line-based extractor keeps the file indexed.
  *
- * Extracts: package, func, type, const, var
+ * Extracts: func, method, type, const, var
  */
 import type { FileSymbols, SymbolLang } from './schema.js';
 export declare function parseSymbols(opts: {
@@ -13,4 +14,23 @@ export declare function parseSymbols(opts: {
     lang: SymbolLang;
 }): Promise<FileSymbols>;
 export { detectLang } from './languages.js';
+/**
+ * Blank comment and string/rune literal contents, keeping offsets and newlines.
+ * Quote characters survive so the line structure stays readable.
+ */
+export declare function maskGoNonCode(src: string): string;
+/**
+ * Line-based extraction for when `go run` is unavailable or failed.
+ *
+ * Runs over {@link maskGoNonCode} output and only reads declarations at the top
+ * level. Previously it scanned every trimmed line of the raw source, so:
+ *  - a `(` or `}` inside a string or comment tripped the delimiter check and
+ *    the whole file indexed empty (`strings.Split(s, "(")` is enough);
+ *  - every `var x` / `type t` local inside a function body became a
+ *    package-level symbol;
+ *  - generic functions (`func Map[T any](`) were missing, grouped
+ *    `const ( … )` / `var ( … )` members were missing, and methods were
+ *    scoped `pkg.Name` instead of the native parser's `pkg.Recv.Name`.
+ */
+export declare function parseGoWithoutToolchain(filePath: string, content: string, lang?: SymbolLang): FileSymbols;
 //# sourceMappingURL=go-parser.d.ts.map

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

@@ -11,6 +11,16 @@
  * watcher run, which is what {@link shouldRefreshRanks} arbitrates.
  */
 import type { IndexStore } from './writer.js';
+/**
+ * Build the `implicitlyVisible` predicate for one rank pass.
+ *
+ * Without it every same-package Go/Java/C# reference — code that needs no
+ * import by the language's own rules — was scored as a contradicted
+ * misresolution (weight 0.02), as was every call into a Go package other than
+ * the one file the resolver picked to represent it. Centrality for those
+ * languages was computed on a graph with its package-internal wiring erased.
+ */
+export declare function createImplicitVisibility(): (sourceFile: string, targetFile: string, imports: ReadonlySet<string> | undefined) => boolean;
 /**
  * Data-version marker for the rank layer, in the same spirit as
  * `relation_graph_version`: bumping it forces every index to recompute ranks

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