token-goat 2.9.13 → 2.9.15

package/dist/token-goat-chunk-NDRP4KJQ.mjs

@@ -0,0 +1,4371 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  pathEqClause,
+  projectScopeClause,
+  querySymbols
+} from "./token-goat-chunk-2X2EBBC6.mjs";
+import {
+  DocumentRefusedError,
+  MAX_DOCUMENT_WORK_MILLIS
+} from "./token-goat-chunk-Y4AFKTHK.mjs";
+import {
+  TREE_SITTER_LANGUAGES,
+  _detectOpenQuote,
+  _lineClosesQuote,
+  buildLineIndex,
+  detectLanguage,
+  findHtmlHeadingMatches,
+  getDb,
+  offsetToLine,
+  precedingDocComment,
+  redactIfDotenv,
+  refineLanguageByContent,
+  stripCstyleComments,
+  stripJsComments,
+  stripStringLiterals,
+  stripXmlComments
+} from "./token-goat-chunk-K7F2BFIK.mjs";
+import {
+  fingerprintContent,
+  loadConfig
+} from "./token-goat-chunk-S4XRY446.mjs";
+import {
+  registerReset
+} from "./token-goat-chunk-EEIDFMEM.mjs";
+import {
+  SYMBOL_BODY_CHAR_CAP,
+  countContentLines,
+  dataDir,
+  decodeSource,
+  ensureDataDirPrivate,
+  ensureDirSync,
+  foldPath,
+  globalDbPath,
+  isCaseInsensitiveFs
+} from "./token-goat-chunk-PM76YS22.mjs";
+import {
+  displaySafeText,
+  normalizePath
+} from "./token-goat-chunk-ERTXEKB6.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/doc_embed_extract.ts
+init_define_import_meta_env();
+import * as path from "node:path";
+var EMBEDDABLE_DOCUMENT_EXTENSIONS = /* @__PURE__ */ new Set([".pdf", ".docx", ".pptx", ".xlsx"]);
+var XLSX_SHEET_ROW_CAP = 500;
+function isEmbeddableDocument(filePath) {
+  return EMBEDDABLE_DOCUMENT_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+}
+function isDocumentRefusal(err) {
+  return err instanceof DocumentRefusedError;
+}
+function isTransientDocumentRefusal(err) {
+  return err instanceof DocumentRefusedError && err.transient;
+}
+async function extractEmbeddableDocumentText(filePath) {
+  switch (path.extname(filePath).toLowerCase()) {
+    case ".pdf": {
+      const { extractPdfText, readPdfFileWithinBounds } = await import("./token-goat-chunk-Z6UXPYJA.mjs");
+      const { text } = await extractPdfText(await readPdfFileWithinBounds(filePath));
+      return text;
+    }
+    case ".docx":
+      return await (await import("./token-goat-chunk-LT7JRU6K.mjs")).docxText(filePath);
+    case ".pptx":
+      return await (await import("./token-goat-chunk-7ZYK25AO.mjs")).pptxAllSlidesText(filePath, true);
+    case ".xlsx":
+      return await (await import("./token-goat-chunk-3NSDDTGL.mjs")).allSheetsHeadText(filePath, XLSX_SHEET_ROW_CAP);
+    default:
+      return null;
+  }
+}
+
+// src/embed_model.ts
+init_define_import_meta_env();
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path2 from "node:path";
+import { pipeline } from "node:stream/promises";
+
+// src/embed_tokenizer.ts
+init_define_import_meta_env();
+var MAX_SEQUENCE_TOKENS = 512;
+var UnsupportedTokenizerError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UnsupportedTokenizerError";
+  }
+};
+function fail(message) {
+  throw new UnsupportedTokenizerError(message);
+}
+function asRecord(value, path5) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) fail(`${path5} is not an object`);
+  return value;
+}
+function asString(value, path5) {
+  if (typeof value !== "string") fail(`${path5} is not a string`);
+  return value;
+}
+function asArray(value, path5) {
+  if (!Array.isArray(value)) fail(`${path5} is not an array`);
+  return value;
+}
+function expectValue(actual, wanted, path5) {
+  if (actual !== wanted) fail(`${path5} is ${JSON.stringify(actual)}, expected ${JSON.stringify(wanted)}`);
+}
+function isChinese(cp) {
+  return cp >= 19968 && cp <= 40959 || cp >= 13312 && cp <= 19903 || cp >= 131072 && cp <= 173791 || cp >= 173824 && cp <= 177983 || cp >= 177984 && cp <= 178207 || cp >= 178208 && cp <= 183983 || cp >= 63744 && cp <= 64255 || cp >= 194560 && cp <= 195103;
+}
+var PUNCTUATION = new RegExp("\\p{P}", "u");
+function isPunctuation(ch) {
+  const cp = ch.codePointAt(0) ?? 0;
+  if (cp >= 33 && cp <= 47 || cp >= 58 && cp <= 64 || cp >= 91 && cp <= 96 || cp >= 123 && cp <= 126) {
+    return true;
+  }
+  return PUNCTUATION.test(ch);
+}
+var CONTROL = new RegExp("\\p{Cc}|\\p{Cf}|\\p{Co}|\\p{Cs}", "u");
+function isControl(ch) {
+  if (ch === "	" || ch === "\n" || ch === "\r") return false;
+  return CONTROL.test(ch);
+}
+var SPACE_SEPARATOR = new RegExp("\\p{Zs}", "u");
+function isWhitespace(ch) {
+  return ch === " " || ch === "	" || ch === "\n" || ch === "\r" || SPACE_SEPARATOR.test(ch);
+}
+var COMBINING_MARK = /[\u0300-\u036f]/gu;
+function normalize(text) {
+  let out = "";
+  for (const ch of text) {
+    const cp = ch.codePointAt(0) ?? 0;
+    if (cp === 0 || cp === 65533 || isControl(ch)) continue;
+    if (isWhitespace(ch)) {
+      out += " ";
+      continue;
+    }
+    if (isChinese(cp)) {
+      out += ` ${ch} `;
+      continue;
+    }
+    out += ch;
+  }
+  return out.normalize("NFD").replace(COMBINING_MARK, "").toLowerCase();
+}
+function preTokenize(text) {
+  const words = [];
+  for (const piece of text.split(/\s+/)) {
+    if (!piece) continue;
+    let buf = "";
+    for (const ch of piece) {
+      if (isPunctuation(ch)) {
+        if (buf) {
+          words.push(buf);
+          buf = "";
+        }
+        words.push(ch);
+      } else {
+        buf += ch;
+      }
+    }
+    if (buf) words.push(buf);
+  }
+  return words;
+}
+function readSpec(raw) {
+  const spec = asRecord(raw, "tokenizer.json");
+  const normalizer = asRecord(spec["normalizer"], "normalizer");
+  expectValue(normalizer["type"], "BertNormalizer", "normalizer.type");
+  expectValue(normalizer["clean_text"], true, "normalizer.clean_text");
+  expectValue(normalizer["handle_chinese_chars"], true, "normalizer.handle_chinese_chars");
+  expectValue(normalizer["lowercase"], true, "normalizer.lowercase");
+  const stripAccents = normalizer["strip_accents"];
+  if (stripAccents !== null && stripAccents !== true) {
+    fail(`normalizer.strip_accents is ${JSON.stringify(stripAccents)}, expected null or true`);
+  }
+  expectValue(asRecord(spec["pre_tokenizer"], "pre_tokenizer")["type"], "BertPreTokenizer", "pre_tokenizer.type");
+  const model = asRecord(spec["model"], "model");
+  expectValue(model["type"], "WordPiece", "model.type");
+  expectValue(model["continuing_subword_prefix"], "##", "model.continuing_subword_prefix");
+  const post = asRecord(spec["post_processor"], "post_processor");
+  expectValue(post["type"], "TemplateProcessing", "post_processor.type");
+  const template = asArray(post["single"], "post_processor.single").map((part) => {
+    const special = asRecord(part, "post_processor.single[]")["SpecialToken"];
+    return special === void 0 ? "A" : asString(asRecord(special, "SpecialToken")["id"], "SpecialToken.id");
+  }).join(" ");
+  if (template !== "[CLS] A [SEP]") fail(`post_processor.single is "${template}", expected "[CLS] A [SEP]"`);
+  const vocab = /* @__PURE__ */ new Map();
+  for (const [token, id] of Object.entries(asRecord(model["vocab"], "model.vocab"))) {
+    if (typeof id !== "number" || !Number.isInteger(id)) fail(`model.vocab["${token}"] is not an integer id`);
+    vocab.set(token, id);
+  }
+  const maxChars = model["max_input_chars_per_word"];
+  if (maxChars !== void 0 && (typeof maxChars !== "number" || !Number.isInteger(maxChars) || maxChars < 1)) {
+    fail("model.max_input_chars_per_word is not a positive integer");
+  }
+  return {
+    vocab,
+    unkToken: asString(model["unk_token"], "model.unk_token"),
+    maxInputCharsPerWord: typeof maxChars === "number" ? maxChars : 100
+  };
+}
+var BertWordPiece = class _BertWordPiece {
+  vocab;
+  maxInputCharsPerWord;
+  clsId;
+  sepId;
+  padId;
+  unkId;
+  /** @param raw the parsed contents of a tokenizer.json. */
+  constructor(raw) {
+    const spec = readSpec(raw);
+    this.vocab = spec.vocab;
+    this.maxInputCharsPerWord = spec.maxInputCharsPerWord;
+    this.clsId = this.requireToken("[CLS]");
+    this.sepId = this.requireToken("[SEP]");
+    this.padId = this.requireToken("[PAD]");
+    this.unkId = this.requireToken(spec.unkToken);
+  }
+  /** Parse and validate in one step, for the common case of reading the file off disk. */
+  static fromJson(json) {
+    let parsed;
+    try {
+      parsed = JSON.parse(json);
+    } catch (err) {
+      throw new UnsupportedTokenizerError(`tokenizer.json is not valid JSON: ${err.message}`);
+    }
+    return new _BertWordPiece(parsed);
+  }
+  requireToken(token) {
+    const id = this.vocab.get(token);
+    if (id === void 0) fail(`model.vocab is missing the ${token} token`);
+    return id;
+  }
+  /** Greedy longest-match-first over one whitespace- and punctuation-free word. */
+  wordToIds(word, into) {
+    if (word.length > this.maxInputCharsPerWord) {
+      into.push(this.unkId);
+      return;
+    }
+    const pieces = [];
+    let start = 0;
+    while (start < word.length) {
+      let end = word.length;
+      let found = -1;
+      while (start < end) {
+        const sub = start === 0 ? word.slice(start, end) : `##${word.slice(start, end)}`;
+        const id = this.vocab.get(sub);
+        if (id !== void 0) {
+          found = id;
+          break;
+        }
+        end--;
+      }
+      if (found === -1) {
+        into.push(this.unkId);
+        return;
+      }
+      pieces.push(found);
+      start = end;
+    }
+    for (const id of pieces) into.push(id);
+  }
+  /**
+   * `[CLS] ... [SEP]`, cut to `maxLength` tokens.
+   *
+   * The cut is taken after the markers are added, not before, which means a sequence long enough to
+   * be truncated ends on an ordinary token and has no [SEP] at all. That is what the reference does
+   * and therefore what the model has been fed all along, so it is deliberate rather than an
+   * oversight: keeping the [SEP] would be the more defensible sequence and a different one, and a
+   * tokenizer whose whole justification is producing identical ids does not get to improve on them.
+   * The oracle carries two cases that reach the limit; both end mid-text.
+   */
+  encode(text, maxLength = MAX_SEQUENCE_TOKENS) {
+    if (!Number.isInteger(maxLength) || maxLength < 2) {
+      throw new RangeError(`maxLength must be an integer >= 2 (both markers), got ${maxLength}`);
+    }
+    const ids = [this.clsId];
+    for (const word of preTokenize(normalize(text))) {
+      this.wordToIds(word, ids);
+      if (ids.length >= maxLength) return ids.slice(0, maxLength);
+    }
+    ids.push(this.sepId);
+    return ids.length > maxLength ? ids.slice(0, maxLength) : ids;
+  }
+};
+
+// src/embed_model.ts
+var _require = createRequire(import.meta.url);
+var DEFAULT_MODEL = "Xenova/bge-small-en-v1.5";
+var DEFAULT_DIM = 384;
+var DEFAULT_EMBED_THREADS = 2;
+var PINNED_MODEL_REVISION = "ea104dacec62c0de699686887e3f920caeb4f3e3";
+var MODEL_FILES = [
+  {
+    name: "tokenizer.json",
+    sha256: "d241a60d5e8f04cc1b2b3e9ef7a4921b27bf526d9f6050ab90f9267a1f9e5c66",
+    bytes: 711396
+  },
+  {
+    name: "onnx/model_quantized.onnx",
+    sha256: "6c9c6101a956d62dfb5e7190c538226c0c5bb9cb27b651234b6df063ee7dbfe4",
+    bytes: 34014426
+  }
+];
+function modelDir() {
+  return path2.join(dataDir(), "models", ...DEFAULT_MODEL.split("/"), PINNED_MODEL_REVISION);
+}
+function modelFilesPresent() {
+  const roots = [modelDir(), sharedModelCacheDir()].filter((d) => d !== null);
+  return roots.some(
+    (root) => MODEL_FILES.every((file) => {
+      try {
+        return fs.statSync(path2.join(root, file.name)).size === file.bytes;
+      } catch {
+        return false;
+      }
+    })
+  );
+}
+function downloadUrl(file) {
+  return `https://huggingface.co/${DEFAULT_MODEL}/resolve/${PINNED_MODEL_REVISION}/${file.name}`;
+}
+function sharedModelCacheDir() {
+  const raw = process.env["TOKEN_GOAT_MODEL_CACHE_DIR"]?.trim();
+  if (!raw) return null;
+  return path2.join(raw, ...DEFAULT_MODEL.split("/"), PINNED_MODEL_REVISION);
+}
+async function copyFromSharedCache(shared, file, target) {
+  const source = path2.join(shared, file.name);
+  const temp = `${target}.${process.pid}.shared`;
+  try {
+    const info = fs.lstatSync(source, { throwIfNoEntry: false });
+    if (!info?.isFile() || info.size !== file.bytes) return false;
+    fs.copyFileSync(source, temp);
+    if (await sha256Of(temp) !== file.sha256) {
+      fs.rmSync(temp, { force: true, maxRetries: 20, retryDelay: 25 });
+      fs.rmSync(source, { force: true, maxRetries: 20, retryDelay: 25 });
+      return false;
+    }
+    fs.renameSync(temp, target);
+    return true;
+  } catch {
+    try {
+      fs.rmSync(temp, { force: true, maxRetries: 20, retryDelay: 25 });
+    } catch {
+    }
+    return false;
+  }
+}
+function publishToSharedCache(shared, file, target) {
+  const destination = path2.join(shared, file.name);
+  const temp = `${destination}.${process.pid}.partial`;
+  let created = false;
+  try {
+    if (fs.existsSync(destination)) return;
+    ensureDirSync(path2.dirname(destination));
+    fs.copyFileSync(target, temp, fs.constants.COPYFILE_EXCL);
+    created = true;
+    fs.renameSync(temp, destination);
+  } catch {
+    if (!created) return;
+    try {
+      fs.rmSync(temp, { force: true, maxRetries: 20, retryDelay: 25 });
+    } catch {
+    }
+  }
+}
+var _ort = null;
+var _ortError = null;
+var _ortLoadAttempted = false;
+function ensureRuntimeLoaded() {
+  if (_ortLoadAttempted) return;
+  _ortLoadAttempted = true;
+  try {
+    _ort = _require("onnxruntime-node");
+  } catch (e) {
+    _ortError = e instanceof Error ? e : new Error(String(e));
+  }
+}
+function isRuntimeAvailable() {
+  ensureRuntimeLoaded();
+  return _ort !== null && _ortError === null;
+}
+function runtimeLoadError() {
+  ensureRuntimeLoaded();
+  return _ortError;
+}
+function runtimeVersion() {
+  ensureRuntimeLoaded();
+  if (_ort === null) return "unknown";
+  try {
+    let dir = path2.dirname(_require.resolve("onnxruntime-node"));
+    for (let depth = 0; depth < 6; depth++) {
+      const manifest = path2.join(dir, "package.json");
+      if (fs.existsSync(manifest)) {
+        const parsed = JSON.parse(fs.readFileSync(manifest, "utf8"));
+        if (parsed.name === "onnxruntime-node" && typeof parsed.version === "string") return parsed.version;
+      }
+      const up = path2.dirname(dir);
+      if (up === dir) break;
+      dir = up;
+    }
+  } catch {
+  }
+  return "unknown";
+}
+function sha256Of(filePath) {
+  return new Promise((resolve2, reject) => {
+    const hash = createHash("sha256");
+    const stream = fs.createReadStream(filePath);
+    stream.on("error", reject);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve2(hash.digest("hex")));
+  });
+}
+async function download(file, target) {
+  const url = downloadUrl(file);
+  const response = await fetch(url, { redirect: "follow" });
+  if (!response.ok) throw new Error(`GET ${url} returned ${response.status} ${response.statusText}`);
+  if (!response.body) throw new Error(`GET ${url} returned no body`);
+  const temp = `${target}.${process.pid}.partial`;
+  const hash = createHash("sha256");
+  let written = 0;
+  const out = fs.createWriteStream(temp);
+  try {
+    await pipeline(async function* () {
+      for await (const chunk of response.body) {
+        written += chunk.byteLength;
+        if (written > file.bytes) throw new Error(`${file.name} is longer than the pinned ${file.bytes} bytes`);
+        hash.update(chunk);
+        yield chunk;
+      }
+    }, out);
+    if (written !== file.bytes) {
+      throw new Error(`${file.name} is ${written} bytes, expected the pinned ${file.bytes}`);
+    }
+    const digest = hash.digest("hex");
+    if (digest !== file.sha256) {
+      throw new Error(`${file.name} has sha256 ${digest}, expected the pinned ${file.sha256}`);
+    }
+    fs.renameSync(temp, target);
+  } catch (e) {
+    await new Promise((resolve2) => {
+      if (out.closed) resolve2();
+      else out.once("close", () => resolve2());
+    });
+    try {
+      fs.rmSync(temp, { force: true, maxRetries: 20, retryDelay: 25 });
+    } catch {
+    }
+    throw e;
+  }
+}
+var _inFlightModelDownload = null;
+function ensureModelFiles(modelName = DEFAULT_MODEL) {
+  if (modelName !== DEFAULT_MODEL) {
+    return Promise.reject(
+      new Error(
+        `Only ${DEFAULT_MODEL} is supported: its files are pinned to a revision and to a sha256 each, and "${modelName}" has neither, so there would be nothing to check the download against.`
+      )
+    );
+  }
+  if (_inFlightModelDownload !== null) {
+    return _inFlightModelDownload;
+  }
+  _inFlightModelDownload = (async () => {
+    try {
+      return await _ensureModelFilesInner(modelName);
+    } finally {
+      _inFlightModelDownload = null;
+    }
+  })();
+  return _inFlightModelDownload;
+}
+async function _ensureModelFilesInner(_modelName) {
+  ensureDataDirPrivate();
+  const dir = modelDir();
+  const offline = loadConfig().network.offline;
+  const shared = sharedModelCacheDir();
+  for (const file of MODEL_FILES) {
+    const target = path2.join(dir, file.name);
+    if (fs.existsSync(target)) {
+      const digest = await sha256Of(target);
+      if (digest === file.sha256) continue;
+      fs.rmSync(target, { force: true });
+    }
+    if (shared) {
+      ensureDirSync(path2.dirname(target));
+      if (await copyFromSharedCache(shared, file, target)) continue;
+    }
+    if (offline) {
+      throw new Error(
+        `Offline mode is on (network.offline): refusing to download ${file.name} for the embedding model. Copy the pinned files into ${dir} on a connected machine to use semantic search here.`
+      );
+    }
+    ensureDirSync(path2.dirname(target));
+    console.warn(
+      `Downloading the embedding model, once (${file.name}, ${Math.round(file.bytes / 1024 / 1024)} MB) into ${dir}`
+    );
+    await download(file, target);
+    if (shared) publishToSharedCache(shared, file, target);
+  }
+  return dir;
+}
+function poolAndNormalize(hidden, seq, dim) {
+  const pooled = new Float64Array(dim);
+  for (let t = 0; t < seq; t++) {
+    const base = t * dim;
+    for (let d = 0; d < dim; d++) pooled[d] = (pooled[d] ?? 0) + (hidden[base + d] ?? 0);
+  }
+  let sumOfSquares = 0;
+  for (let d = 0; d < dim; d++) {
+    const mean = (pooled[d] ?? 0) / seq;
+    pooled[d] = mean;
+    sumOfSquares += mean * mean;
+  }
+  const norm = Math.sqrt(sumOfSquares);
+  const out = new Float32Array(dim);
+  if (norm === 0 || !Number.isFinite(norm)) return out;
+  for (let d = 0; d < dim; d++) out[d] = (pooled[d] ?? 0) / norm;
+  return out;
+}
+var EmbeddingModel = class _EmbeddingModel {
+  constructor(tokenizer, session, tensorFactory) {
+    this.tokenizer = tokenizer;
+    this.session = session;
+    this.tensorFactory = tensorFactory;
+  }
+  tokenizer;
+  session;
+  tensorFactory;
+  static async load(modelName = DEFAULT_MODEL) {
+    if (!isRuntimeAvailable()) {
+      throw new Error(`onnxruntime-node is not available: ${_ortError?.message ?? "unknown error"}`);
+    }
+    const dir = await ensureModelFiles(modelName);
+    const tokenizer = BertWordPiece.fromJson(fs.readFileSync(path2.join(dir, "tokenizer.json"), "utf8"));
+    const ort = _ort;
+    const threads = loadConfig().worker.embed_threads ?? DEFAULT_EMBED_THREADS;
+    const session = await ort.InferenceSession.create(path2.join(dir, "onnx", "model_quantized.onnx"), {
+      intraOpNumThreads: threads,
+      interOpNumThreads: 1
+    });
+    return new _EmbeddingModel(tokenizer, session, ort.Tensor);
+  }
+  /** Embed one text. Sequences are run singly, so there is no padding and no mask to get wrong. */
+  async embed(text) {
+    const ids = this.tokenizer.encode(text);
+    const length = ids.length;
+    const feeds = {
+      input_ids: new this.tensorFactory("int64", BigInt64Array.from(ids, BigInt), [1, length]),
+      attention_mask: new this.tensorFactory("int64", new BigInt64Array(length).fill(1n), [1, length])
+    };
+    if (this.session.inputNames.includes("token_type_ids")) {
+      feeds["token_type_ids"] = new this.tensorFactory("int64", new BigInt64Array(length), [1, length]);
+    }
+    const outputName = this.session.outputNames[0];
+    if (outputName === void 0) throw new Error("the model declares no outputs");
+    const output = (await this.session.run(feeds))[outputName];
+    if (!output) throw new Error(`the model produced no ${outputName}`);
+    const [, seq, dim] = output.dims;
+    if (seq === void 0 || dim === void 0) {
+      throw new Error(`expected a [batch, sequence, dimension] output, got [${output.dims.join(", ")}]`);
+    }
+    if (dim !== DEFAULT_DIM) {
+      throw new Error(`the model produced ${dim}-dimension vectors, expected ${DEFAULT_DIM}`);
+    }
+    return poolAndNormalize(output.data, seq, dim);
+  }
+};
+async function checkEmbeddingPreflight(options) {
+  const modelName = options?.modelName ?? DEFAULT_MODEL;
+  const cfg = loadConfig();
+  const enabled = cfg.indexing?.embeddings_enabled ?? true;
+  const mDir = modelDir();
+  const rtVer = runtimeVersion();
+  const rtAvail = isRuntimeAvailable();
+  const filesPresent = modelFilesPresent();
+  let warmed = false;
+  const buildResult = (params) => {
+    const indexed = params.coverage?.indexedFiles ?? 0;
+    const embedded = params.coverage?.embeddedFiles ?? 0;
+    const pct = indexed > 0 ? Math.round(embedded / indexed * 100) : 0;
+    return {
+      status: params.status,
+      available: params.available,
+      message: params.message,
+      summary: params.message,
+      modelName,
+      runtimeVersion: rtVer,
+      runtimeAvailable: rtAvail,
+      configEnabled: enabled,
+      modelFilesPresent: filesPresent,
+      modelWarmed: warmed,
+      modelDir: mDir,
+      ...params.suggestion !== void 0 ? { suggestion: params.suggestion, actionRequired: params.suggestion } : {},
+      ...params.error !== void 0 ? { error: params.error } : {},
+      indexedFiles: indexed,
+      embeddedFiles: embedded,
+      coveragePercent: pct,
+      ...params.coverage !== void 0 ? { coverage: params.coverage } : {}
+    };
+  };
+  if (!enabled) {
+    return buildResult({
+      status: "disabled",
+      available: false,
+      message: "Matching on meaning is off (indexing.embeddings_enabled / TOKEN_GOAT_EMBEDDINGS_ENABLED is disabled)",
+      suggestion: "Enable in config: set indexing.embeddings_enabled = true or unset TOKEN_GOAT_EMBEDDINGS_ENABLED"
+    });
+  }
+  if (!rtAvail) {
+    const err = runtimeLoadError();
+    return buildResult({
+      status: "missing_runtime",
+      available: false,
+      message: `Inference runtime is not available: ${err?.message ?? "onnxruntime-node is not installed"}`,
+      suggestion: "Install it with: npm install -g onnxruntime-node (drop -g if token-goat is a project dependency)",
+      ...err?.message ? { error: err.message } : {}
+    });
+  }
+  if (!filesPresent && cfg?.network?.offline) {
+    return buildResult({
+      status: "missing_model_files",
+      available: false,
+      message: "Embedding model files are missing and offline mode (network.offline) prevents downloading them",
+      suggestion: `Download or copy the pinned model files into ${mDir}`
+    });
+  }
+  if (options?.warm === true) {
+    try {
+      await ensureModelFiles(modelName);
+      await EmbeddingModel.load(modelName);
+      warmed = true;
+    } catch (e) {
+      const err = e instanceof Error ? e.message : String(e);
+      return buildResult({
+        status: "load_error",
+        available: false,
+        message: `Failed to warm/load embedding model: ${err}`,
+        suggestion: "Check model integrity or run 'token-goat doctor'",
+        error: err
+      });
+    }
+  }
+  const coverage = options?.coverage;
+  if (coverage && coverage.indexedFiles > 0 && coverage.embeddedFiles === 0) {
+    return buildResult({
+      status: "no_embeddings",
+      available: false,
+      message: `Embedding model is available, but 0 of ${coverage.indexedFiles} indexed file(s) in this project have embeddings`,
+      suggestion: options?.projectRoot ? `Run 'token-goat index "${options.projectRoot}"' to generate embeddings` : "Run 'token-goat index' to generate embeddings",
+      coverage
+    });
+  }
+  return buildResult({
+    status: "ready",
+    available: true,
+    message: "Semantic embedding model is ready and available",
+    ...coverage !== void 0 ? { coverage } : {}
+  });
+}
+registerReset(() => {
+  _ort = null;
+  _ortError = null;
+  _ortLoadAttempted = false;
+  _inFlightModelDownload = null;
+});
+
+// src/embeddings.ts
+init_define_import_meta_env();
+
+// src/embed_fingerprint.ts
+init_define_import_meta_env();
+var EMBED_FINGERPRINT = "b1fd4a80b27f2ca1";
+
+// src/embeddings.ts
+var QUERY_INSTRUCTION_PREFIX = "Represent this sentence for searching relevant passages: ";
+var _extractorCache = /* @__PURE__ */ new Map();
+var inHousePipelineFn = async (_task, modelName) => {
+  const model = await EmbeddingModel.load(modelName);
+  return async (text) => ({ data: await model.embed(text) });
+};
+var _pipelineFnOverride = null;
+registerReset(() => {
+  _extractorCache.clear();
+  _pipelineFnOverride = null;
+});
+var PIPELINE_RETRY_ATTEMPTS = 3;
+var PIPELINE_RETRY_DELAY_MS = 250;
+var DEFAULT_PIPELINE_RETRY_DELAY_MS = PIPELINE_RETRY_DELAY_MS;
+registerReset(() => {
+  PIPELINE_RETRY_DELAY_MS = DEFAULT_PIPELINE_RETRY_DELAY_MS;
+});
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function buildExtractorWithRetry(pipelineFn, modelName) {
+  let lastError;
+  for (let attempt = 1; attempt <= PIPELINE_RETRY_ATTEMPTS; attempt++) {
+    try {
+      return await pipelineFn("feature-extraction", modelName);
+    } catch (e) {
+      lastError = e;
+      if (attempt < PIPELINE_RETRY_ATTEMPTS) await sleep(PIPELINE_RETRY_DELAY_MS * attempt);
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+var MIN_CHUNK_CHARS = 50;
+var MAX_CHUNK_CHARS = 8e3;
+var DEFAULT_DISTANCE_THRESHOLD = 1.2;
+var _GENERATED_PATH_SEGMENTS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  "__pycache__",
+  ".next",
+  ".nuxt",
+  ".turbo",
+  ".cache",
+  "coverage",
+  "out",
+  "target",
+  "vendor",
+  ".venv",
+  "venv",
+  ".tox",
+  "site-packages",
+  "bower_components",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".ruff_cache"
+]);
+var _GENERATED_PATH_PENALTY = 0.5;
+var _ARCHIVE_PATH_SEGMENTS = /* @__PURE__ */ new Set([
+  "archive",
+  "archived",
+  "old",
+  "deprecated",
+  "plans",
+  "drafts"
+]);
+var _ARCHIVE_FILE_RE = /(^changelog|\.bak$|\.orig$)/i;
+var _DOCS_FILE_RE = /\.md$/i;
+var _DOCS_DIR_SEGMENT = "docs";
+var _VERBATIM_TOKEN_BOOST = 0.05;
+var _MAX_VERBATIM_BOOST = 0.25;
+var _TOKEN_RE = /\w+/g;
+var _MIN_TOKEN_LEN = 3;
+var OVER_FETCH_FACTOR = 4;
+var MAX_OVER_FETCH = 100;
+var VEC_MAX_K = 4096;
+function isAvailable() {
+  return isRuntimeAvailable();
+}
+function embeddingBackendLoadError() {
+  return runtimeLoadError();
+}
+async function embedTexts(texts, modelName = DEFAULT_MODEL) {
+  if (!isAvailable()) {
+    throw new Error(
+      `Embedding backend not available: ${runtimeLoadError()?.message ?? "unknown error"}`
+    );
+  }
+  if (texts.length === 0) {
+    return [];
+  }
+  let extractorPromise = _extractorCache.get(modelName);
+  if (!extractorPromise) {
+    const pipelineFn = _pipelineFnOverride ?? inHousePipelineFn;
+    extractorPromise = buildExtractorWithRetry(pipelineFn, modelName);
+    _extractorCache.set(modelName, extractorPromise);
+    extractorPromise.catch(() => {
+      if (_extractorCache.get(modelName) === extractorPromise) _extractorCache.delete(modelName);
+    });
+  }
+  const extractor = await extractorPromise;
+  const vecs = [];
+  const expectedDim = DEFAULT_DIM;
+  try {
+    for (const text of texts) {
+      const embedding = await extractor(text, {
+        pooling: "mean",
+        normalize: true
+      });
+      let vec;
+      const embeddingObj = embedding;
+      const embData = embeddingObj?.["data"];
+      if (Array.isArray(embData)) {
+        vec = Array.from(embData);
+      } else if (embData instanceof Float32Array) {
+        vec = Array.from(embData);
+      } else {
+        throw new Error(
+          `Unexpected embedding type: ${typeof embData}`
+        );
+      }
+      if (vec.length !== expectedDim) {
+        throw new Error(
+          `Dimension mismatch: model returned ${vec.length}-dim vector, expected ${expectedDim}`
+        );
+      }
+      const badIndex = vec.findIndex((component) => !Number.isFinite(component));
+      if (badIndex !== -1) {
+        throw new Error(
+          `Non-finite embedding component at index ${badIndex}: model returned ${String(vec[badIndex])}`
+        );
+      }
+      vecs.push(vec);
+    }
+  } finally {
+  }
+  return vecs;
+}
+function packVec(vec) {
+  const view = new Float32Array(vec.length);
+  for (const [i, val] of vec.entries()) {
+    view[i] = val;
+    if (!Number.isFinite(view[i])) {
+      throw new Error(
+        `Non-finite embedding component at index ${i}: ${String(val)} is not representable as a 32-bit float`
+      );
+    }
+  }
+  return Buffer.from(view.buffer);
+}
+function splitRangeIntoChunks(filePath, lines2, rangeStart, rangeEnd, chunkSize, overlap, kind) {
+  const chunks = [];
+  let currentChunk = "";
+  let startLine = rangeStart;
+  let currentLine = rangeStart;
+  for (let lineNo = rangeStart; lineNo <= rangeEnd; lineNo++) {
+    const line = lines2[lineNo - 1] ?? "";
+    const lineWithNewline = line + "\n";
+    if (currentChunk.length + lineWithNewline.length > chunkSize && currentChunk.length > 0) {
+      const trimmedLength = currentChunk.trim().length;
+      const currentChunkTooSmall = trimmedLength < MIN_CHUNK_CHARS;
+      if (!currentChunkTooSmall) {
+        chunks.push({
+          filePath,
+          startLine,
+          endLine: currentLine - 1,
+          text: currentChunk.trim(),
+          kind
+        });
+      }
+      let overlapChars = 0;
+      let computedOverlapStart = currentLine;
+      while (computedOverlapStart > rangeStart) {
+        const candidateChars = (lines2[computedOverlapStart - 2] ?? "").length + 1;
+        if (overlapChars + candidateChars > overlap) break;
+        overlapChars += candidateChars;
+        computedOverlapStart--;
+      }
+      const droppedChunkHadContent = currentChunkTooSmall && trimmedLength > 0;
+      const overlapStart = droppedChunkHadContent ? Math.min(computedOverlapStart, startLine) : computedOverlapStart;
+      if (overlapStart !== startLine) {
+        const overlapText = lines2.slice(overlapStart - 1, currentLine - 1).join("\n");
+        currentChunk = overlapText + "\n";
+        startLine = overlapStart;
+      }
+    }
+    currentChunk += lineWithNewline;
+    currentLine++;
+  }
+  if (currentChunk.trim().length >= MIN_CHUNK_CHARS) {
+    chunks.push({
+      filePath,
+      startLine,
+      endLine: rangeEnd,
+      text: currentChunk.trim(),
+      kind
+    });
+  } else if (currentChunk.length > 0 && chunks.length > 0) {
+    const last = chunks[chunks.length - 1];
+    last.endLine = rangeEnd;
+    last.text = lines2.slice(last.startLine - 1, rangeEnd).join("\n").trim();
+  }
+  return chunks;
+}
+function chunkFile(filePath, content, chunkSize = MAX_CHUNK_CHARS, overlap = 200, boundaries = []) {
+  const lines2 = content.split(/\r?\n/);
+  if (lines2.length > 1 && lines2[lines2.length - 1] === "") lines2.pop();
+  const totalLines = lines2.length;
+  if (boundaries.length === 0) {
+    return splitRangeIntoChunks(filePath, lines2, 1, totalLines, chunkSize, overlap, "window");
+  }
+  const clipped = boundaries.map((b) => ({
+    start: Math.max(1, Math.min(b.start, totalLines)),
+    end: Math.max(1, Math.min(b.end, totalLines)),
+    kind: b.kind
+  })).filter((b) => b.end >= b.start).sort((a, b) => a.start - b.start || b.end - a.end);
+  if (clipped.length === 0) {
+    return splitRangeIntoChunks(filePath, lines2, 1, totalLines, chunkSize, overlap, "window");
+  }
+  const flattened = [];
+  let openEnd = 0;
+  for (const b of clipped) {
+    const start = Math.max(b.start, openEnd + 1);
+    if (start > b.end) continue;
+    flattened.push({ ...b, start });
+    openEnd = b.end;
+  }
+  const gapLength = (start, end) => {
+    let text = "";
+    for (let lineNo = start; lineNo <= end; lineNo++) text += (lines2[lineNo - 1] ?? "") + "\n";
+    return text.trim().length;
+  };
+  const ranges = [];
+  let cursor = 1;
+  for (const b of flattened) {
+    let boundaryStart = b.start;
+    let boundaryKind = b.kind;
+    const gapStart = cursor;
+    const gapEnd = b.start - 1;
+    if (gapEnd >= gapStart) {
+      if (gapLength(gapStart, gapEnd) < MIN_CHUNK_CHARS) {
+        const prev = ranges[ranges.length - 1];
+        if (prev !== void 0) {
+          prev.end = gapEnd;
+        } else {
+          boundaryStart = gapStart;
+          boundaryKind = "window";
+        }
+      } else {
+        ranges.push({ start: gapStart, end: gapEnd, kind: "window" });
+      }
+    }
+    ranges.push({ start: boundaryStart, end: b.end, kind: boundaryKind });
+    cursor = b.end + 1;
+  }
+  if (cursor <= totalLines) {
+    const gapStart = cursor;
+    const gapEnd = totalLines;
+    if (gapLength(gapStart, gapEnd) < MIN_CHUNK_CHARS) {
+      ranges[ranges.length - 1].end = gapEnd;
+    } else {
+      ranges.push({ start: gapStart, end: gapEnd, kind: "window" });
+    }
+  }
+  let i = 0;
+  while (i < ranges.length) {
+    const r = ranges[i];
+    if (gapLength(r.start, r.end) >= MIN_CHUNK_CHARS) {
+      i++;
+      continue;
+    }
+    if (i > 0) {
+      ranges[i - 1].end = r.end;
+      ranges.splice(i, 1);
+      i--;
+    } else if (ranges.length > 1) {
+      ranges[i + 1].start = r.start;
+      ranges.splice(i, 1);
+    } else {
+      i++;
+    }
+  }
+  const chunks = [];
+  for (const r of ranges) {
+    chunks.push(...splitRangeIntoChunks(filePath, lines2, r.start, r.end, chunkSize, overlap, r.kind));
+  }
+  return chunks;
+}
+function insertChunkVector(stmt, rowid, embedding) {
+  stmt.run(BigInt(rowid), packVec(embedding));
+}
+async function upsertChunks(db, chunks) {
+  if (chunks.length === 0) {
+    return "embedded";
+  }
+  const filePath = chunks[0].filePath;
+  if (!isAvailable()) {
+    console.warn("Embeddings not available; skipping semantic indexing");
+    deleteFileEmbeddings(db, filePath);
+    return "unavailable";
+  }
+  if (!chunkVectorsTableExists(db)) {
+    deleteFileEmbeddings(db, filePath);
+    return "unavailable";
+  }
+  ensureEmbeddingProvenance(db);
+  const texts = chunks.map((c) => c.text);
+  const embeddings = await embedTexts(texts);
+  const chunkInsertStmt = db.prepare(`
+    INSERT INTO chunks (file_path, start_line, end_line, text, kind)
+    VALUES (?, ?, ?, ?, ?)
+  `);
+  const vectorInsertStmt = db.prepare(`
+    INSERT INTO chunk_vectors (rowid, embedding)
+    VALUES (?, ?)
+  `);
+  const tx = db.transaction(() => {
+    deleteFileEmbeddings(db, filePath);
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      const embedding = embeddings[i];
+      if (!chunk || !embedding) {
+        continue;
+      }
+      const chunkResult = chunkInsertStmt.run(
+        chunk.filePath,
+        chunk.startLine,
+        chunk.endLine,
+        chunk.text,
+        chunk.kind
+      );
+      insertChunkVector(vectorInsertStmt, chunkResult.lastInsertRowid, embedding);
+    }
+  });
+  tx.immediate();
+  return "embedded";
+}
+var BACKFILL_MULTIPLIER = 3;
+function countStoredVectors(db) {
+  const row = db.prepare("SELECT count(*) AS n FROM chunks").get();
+  return typeof row?.n === "number" && Number.isFinite(row.n) ? row.n : 0;
+}
+function fetchScopedHits(db, queryVec, k, maxDistance, rootDir) {
+  const stmt = db.prepare(`
+    SELECT rowid, distance FROM chunk_vectors
+    WHERE embedding MATCH ?
+    AND k = ?
+    ORDER BY distance ASC
+  `);
+  const rows = stmt.all(packVec(queryVec), k);
+  if (!rows || rows.length === 0) {
+    return { hits: [], candidateCount: 0 };
+  }
+  const scope = rootDir !== void 0 ? projectScopeClause("file_path") : void 0;
+  const chunkSql = scope !== void 0 ? `SELECT file_path, start_line, end_line, text, kind FROM chunks WHERE id = ? AND ${scope.clause}` : `SELECT file_path, start_line, end_line, text, kind FROM chunks WHERE id = ?`;
+  const chunkStmt = db.prepare(chunkSql);
+  const scopeParams = scope !== void 0 && rootDir !== void 0 ? scope.params(rootDir) : void 0;
+  const hits = [];
+  for (const row of rows) {
+    if (!row) {
+      continue;
+    }
+    if (typeof row.distance === "number" && Number.isFinite(row.distance) && row.distance <= maxDistance) {
+      const chunk = scopeParams !== void 0 ? chunkStmt.get(row.rowid, ...scopeParams) : chunkStmt.get(row.rowid);
+      if (chunk) {
+        hits.push({
+          filePath: chunk.file_path,
+          startLine: chunk.start_line,
+          endLine: chunk.end_line,
+          kind: chunk.kind,
+          distance: row.distance,
+          text: chunk.text
+        });
+      }
+    }
+  }
+  return { hits, candidateCount: rows.length };
+}
+function fetchScopedExactHits(db, queryVec, limit, maxDistance, rootDir) {
+  const scope = projectScopeClause("c.file_path");
+  const rows = db.prepare(
+    `SELECT file_path, start_line, end_line, text, kind, distance FROM (
+         SELECT c.id AS id, c.file_path AS file_path, c.start_line AS start_line, c.end_line AS end_line, c.text AS text, c.kind AS kind, vec_distance_L2(v.embedding, ?) AS distance
+         FROM chunks c JOIN chunk_vectors v ON v.rowid = c.id
+         WHERE ${scope.clause}
+       )
+       WHERE distance IS NOT NULL AND distance <= ?
+       ORDER BY distance ASC, file_path ASC, start_line ASC, id ASC
+       LIMIT ?`
+  ).all(packVec(queryVec), ...scope.params(rootDir), maxDistance, limit);
+  const hits = [];
+  for (const row of rows) {
+    if (!row || typeof row.distance !== "number" || !Number.isFinite(row.distance) || row.distance > maxDistance) {
+      continue;
+    }
+    hits.push({
+      filePath: row.file_path,
+      startLine: row.start_line,
+      endLine: row.end_line,
+      kind: row.kind,
+      distance: row.distance,
+      text: row.text
+    });
+  }
+  return hits;
+}
+async function searchSemantic(db, query, topK = 8, modelName = DEFAULT_MODEL, maxDistance = DEFAULT_DISTANCE_THRESHOLD, rootDir) {
+  if (!isAvailable()) {
+    return [];
+  }
+  if (query.trim().length === 0) {
+    return [];
+  }
+  if (!chunkVectorsTableExists(db)) {
+    return [];
+  }
+  ensureEmbeddingProvenance(db, modelName);
+  const queryEmbeddings = await embedTexts([`${QUERY_INSTRUCTION_PREFIX}${query}`], modelName);
+  if (queryEmbeddings.length === 0) {
+    return [];
+  }
+  const queryVec = queryEmbeddings[0];
+  if (!queryVec) {
+    return [];
+  }
+  const overFetchK = Math.min(
+    MAX_OVER_FETCH,
+    Math.ceil(topK * OVER_FETCH_FACTOR)
+  );
+  let k = Math.min(overFetchK, VEC_MAX_K);
+  let pass = fetchScopedHits(db, queryVec, k, maxDistance, rootDir);
+  let hits = pass.hits;
+  if (rootDir !== void 0) {
+    const ceiling = Math.min(countStoredVectors(db), VEC_MAX_K);
+    while (hits.length < topK && pass.candidateCount === k && k < ceiling) {
+      k = Math.min(ceiling, k * BACKFILL_MULTIPLIER);
+      pass = fetchScopedHits(db, queryVec, k, maxDistance, rootDir);
+      hits = pass.hits;
+    }
+    if (hits.length < topK && pass.candidateCount === k && k >= ceiling && countStoredVectors(db) > VEC_MAX_K) {
+      hits = fetchScopedExactHits(db, queryVec, VEC_MAX_K, maxDistance, rootDir);
+    }
+  }
+  return rerankHits(hits, query, topK);
+}
+function rerankHits(hits, query, topK) {
+  const queryTokens = _extractQueryTokens(query);
+  const scored = hits.map((hit, index) => {
+    let boost = 0;
+    if (queryTokens.size > 0) {
+      const hitTokens = _extractQueryTokens(hit.text);
+      let matches = 0;
+      for (const token of queryTokens) {
+        if (hitTokens.has(token)) {
+          matches++;
+        }
+      }
+      boost = Math.min(matches * _VERBATIM_TOKEN_BOOST, _MAX_VERBATIM_BOOST);
+    }
+    const penalty = _isGeneratedPath(hit.filePath) ? _GENERATED_PATH_PENALTY : 0;
+    const pathPenalty = _pathPriorityPenalty(hit.filePath);
+    return { hit, index, adjusted: hit.distance - boost + penalty + pathPenalty };
+  });
+  scored.sort((a, b) => a.adjusted - b.adjusted || a.index - b.index);
+  return scored.slice(0, topK).map((entry) => ({ ...entry.hit, adjustedDistance: entry.adjusted }));
+}
+function mergeNearbyHits(hits, proximity = 20) {
+  if (hits.length <= 1) {
+    return hits;
+  }
+  const byFile = /* @__PURE__ */ new Map();
+  for (const hit of hits) {
+    const fileHits = byFile.get(hit.filePath);
+    if (fileHits) {
+      fileHits.push(hit);
+    } else {
+      byFile.set(hit.filePath, [hit]);
+    }
+  }
+  const merged = [];
+  for (const fileHits of byFile.values()) {
+    fileHits.sort((a, b) => a.startLine - b.startLine);
+    let current = fileHits[0];
+    if (!current) {
+      continue;
+    }
+    let curStart = current.startLine;
+    let curEnd = current.endLine;
+    let curDist = current.distance;
+    let curAdjusted = current.adjustedDistance ?? current.distance;
+    const mergedTexts = [current.text];
+    for (let i = 1; i < fileHits.length; i++) {
+      const hit = fileHits[i];
+      if (!hit) {
+        continue;
+      }
+      const gap = hit.startLine - curEnd - 1;
+      if (gap <= proximity) {
+        curEnd = Math.max(curEnd, hit.endLine);
+        curDist = Math.min(curDist, hit.distance);
+        curAdjusted = Math.min(curAdjusted, hit.adjustedDistance ?? hit.distance);
+        mergedTexts.push(hit.text);
+      } else {
+        merged.push({
+          filePath: current.filePath,
+          startLine: curStart,
+          endLine: curEnd,
+          kind: current.kind,
+          distance: curDist,
+          adjustedDistance: curAdjusted,
+          text: mergedTexts.join("\n---\n")
+        });
+        current = hit;
+        curStart = hit.startLine;
+        curEnd = hit.endLine;
+        curDist = hit.distance;
+        curAdjusted = hit.adjustedDistance ?? hit.distance;
+        mergedTexts.length = 0;
+        mergedTexts.push(hit.text);
+      }
+    }
+    merged.push({
+      filePath: current.filePath,
+      startLine: curStart,
+      endLine: curEnd,
+      kind: current.kind,
+      distance: curDist,
+      adjustedDistance: curAdjusted,
+      text: mergedTexts.join("\n---\n")
+    });
+  }
+  merged.sort((a, b) => (a.adjustedDistance ?? a.distance) - (b.adjustedDistance ?? b.distance));
+  return merged;
+}
+async function indexFile(db, filePath, content, boundaries = []) {
+  const chunks = chunkFile(filePath, content, void 0, void 0, boundaries);
+  if (chunks.length > 0) {
+    return upsertChunks(db, chunks);
+  }
+  deleteFileEmbeddings(db, filePath);
+  return "embedded";
+}
+var _chunkVectorsUsable = /* @__PURE__ */ new WeakMap();
+function chunkVectorsTableExists(db) {
+  const cached = _chunkVectorsUsable.get(db);
+  if (cached !== void 0) {
+    return cached;
+  }
+  let usable;
+  try {
+    db.prepare("SELECT rowid FROM chunk_vectors LIMIT 1").get();
+    usable = true;
+  } catch {
+    usable = false;
+  }
+  _chunkVectorsUsable.set(db, usable);
+  return usable;
+}
+function embeddingsDepsAvailable(db) {
+  return isAvailable() && chunkVectorsTableExists(db);
+}
+function deleteFileEmbeddings(db, filePath) {
+  const folded = foldPath(filePath);
+  if (chunkVectorsTableExists(db)) {
+    const ids = db.prepare(`SELECT id FROM chunks WHERE ${pathEqClause("file_path")}`).pluck().all(folded);
+    const deleteVector = db.prepare("DELETE FROM chunk_vectors WHERE rowid = ?");
+    for (const id of ids) deleteVector.run(id);
+  }
+  db.prepare(`DELETE FROM chunks WHERE ${pathEqClause("file_path")}`).run(folded);
+}
+function resetAllEmbeddings(db) {
+  const paths = db.prepare("SELECT DISTINCT file_path FROM chunks").pluck().all();
+  const clearEmbedSha = db.prepare(`UPDATE files SET embed_sha = NULL WHERE ${pathEqClause("path")}`);
+  const tx = db.transaction(() => {
+    for (const p of paths) deleteFileEmbeddings(db, p);
+    for (const p of paths) clearEmbedSha.run(foldPath(p));
+  });
+  tx.immediate();
+  return paths.length;
+}
+function embeddingProvenance(modelName = DEFAULT_MODEL) {
+  const revision = modelName === DEFAULT_MODEL ? PINNED_MODEL_REVISION.slice(0, 12) : "unpinned";
+  return `${modelName}@${revision}/${backendId()}/embed-${EMBED_FINGERPRINT}`;
+}
+function backendId() {
+  return `onnxruntime-node@${majorMinor(runtimeVersion())}`;
+}
+function majorMinor(version) {
+  const parts = version.split(".");
+  return parts.length >= 2 ? `${parts[0]}.${parts[1]}` : version;
+}
+var _provenanceChecked = /* @__PURE__ */ new WeakSet();
+function ensureEmbeddingProvenance(db, modelName = DEFAULT_MODEL) {
+  if (_provenanceChecked.has(db)) return;
+  _provenanceChecked.add(db);
+  const current = embeddingProvenance(modelName);
+  const stored = db.prepare("SELECT provenance FROM embedding_provenance WHERE id = 1").pluck().get();
+  if (stored === current) return;
+  const cleared = resetAllEmbeddings(db);
+  db.prepare(
+    "INSERT INTO embedding_provenance (id, provenance) VALUES (1, ?) ON CONFLICT(id) DO UPDATE SET provenance = excluded.provenance"
+  ).run(current);
+  if (cleared > 0) {
+    console.warn(
+      `Embedding stack changed (${stored ?? "unrecorded"} -> ${current}); discarded ${cleared} file${cleared === 1 ? "" : "s"} worth of vectors because they no longer reliably describe this file's current chunks. Run \`token-goat index\` to rebuild them.`
+    );
+  }
+}
+function _extractQueryTokens(query) {
+  const tokens = /* @__PURE__ */ new Set();
+  const matches = query.matchAll(_TOKEN_RE);
+  for (const match of matches) {
+    const token = match[0].toLowerCase();
+    if (token.length >= _MIN_TOKEN_LEN) {
+      tokens.add(token);
+    }
+  }
+  return tokens;
+}
+function _isGeneratedPath(filePath) {
+  const segments = filePath.split(/[/\\]+/);
+  for (const seg of segments) {
+    if (_GENERATED_PATH_SEGMENTS.has(seg.toLowerCase())) {
+      return true;
+    }
+  }
+  return false;
+}
+function _pathPriorityPenalty(filePath) {
+  const segments = filePath.split(/[/\\]+/);
+  const basename2 = segments[segments.length - 1] ?? filePath;
+  const weights = loadConfig().semantic;
+  const isArchive = _ARCHIVE_FILE_RE.test(basename2) || segments.some((seg) => _ARCHIVE_PATH_SEGMENTS.has(seg.toLowerCase()));
+  if (isArchive) {
+    return 1 - weights.archive_weight;
+  }
+  const isDocs = _DOCS_FILE_RE.test(basename2) || segments.some((seg) => seg.toLowerCase() === _DOCS_DIR_SEGMENT);
+  if (isDocs) {
+    return 1 - weights.docs_weight;
+  }
+  return 0;
+}
+
+// src/parser_fingerprint.ts
+init_define_import_meta_env();
+var PARSER_FINGERPRINT = "ef41adb465538db6";
+
+// src/parser.ts
+init_define_import_meta_env();
+import * as fs2 from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import * as path4 from "node:path";
+
+// src/embedding_boundaries.ts
+init_define_import_meta_env();
+
+// src/hints/markdown_hints.ts
+init_define_import_meta_env();
+
+// src/markdown_lines.ts
+init_define_import_meta_env();
+function* eachUnfencedLine(lines2) {
+  let fence = null;
+  for (let i = 0; i < lines2.length; i++) {
+    const line = lines2[i];
+    if (line === void 0) continue;
+    const fm = /^\s*(`{3,}|~{3,})([^\n]*)$/.exec(line);
+    if (fm !== null && fm[1] !== void 0) {
+      const run = fm[1];
+      const ch = run[0] ?? "";
+      const rest = fm[2] ?? "";
+      if (fence === null) {
+        fence = { ch, len: run.length };
+      } else if (ch === fence.ch && run.length >= fence.len && rest.trim() === "") {
+        fence = null;
+      }
+      continue;
+    }
+    if (fence !== null) continue;
+    yield [i, line];
+  }
+}
+
+// src/hints/markdown_hints.ts
+var MARKDOWN_SIZE_THRESHOLD = 8e3;
+var MAX_HEADINGS = 40;
+var MAX_OUTPUT_LINES = 60;
+function extractMarkdownHeadings(content, limit = MAX_HEADINGS) {
+  const headings = [];
+  const lines2 = content.split("\n");
+  const unfenced = Array.from(eachUnfencedLine(lines2));
+  for (let u = 0; u < unfenced.length; u++) {
+    const [i, line] = unfenced[u];
+    if (!line) continue;
+    const match = /^(#+)\s+([^\r\n]+?)(?:\s+#+)?\s*$/.exec(line);
+    if (match && match.length >= 3) {
+      const hashes = match[1];
+      const headingText = match[2];
+      const level = hashes.length;
+      const maxLevel = limit === Infinity ? 6 : 3;
+      if (level <= maxLevel) {
+        const text = headingText.trim();
+        if (text) {
+          headings.push({
+            level,
+            text,
+            lineNumber: i + 1
+          });
+          if (headings.length >= limit) break;
+        }
+      }
+      continue;
+    }
+    const trimmed = line.trim();
+    if (trimmed !== "" && !trimmed.startsWith("#") && !trimmed.startsWith("|") && !trimmed.startsWith("```") && !trimmed.startsWith("~~~") && !/^([-*+]|\d+\.)\s/.test(trimmed) && u + 1 < unfenced.length) {
+      const [nextIdx, nextLine] = unfenced[u + 1];
+      if (nextIdx === i + 1) {
+        let setextLevel = 0;
+        if (/^\s*(=+)\s*$/.test(nextLine)) setextLevel = 1;
+        else if (/^\s*(-+)\s*$/.test(nextLine)) setextLevel = 2;
+        if (setextLevel > 0) {
+          headings.push({
+            level: setextLevel,
+            text: trimmed,
+            lineNumber: i + 1
+          });
+          u++;
+          if (headings.length >= limit) break;
+        }
+      }
+    }
+  }
+  return headings;
+}
+function formatHeadingTreeParts(headings, filePath) {
+  if (headings.length === 0) return { guidance: "", sectionsList: "" };
+  const seenTexts = /* @__PURE__ */ new Map();
+  const dedupedHeadings = [];
+  for (const h of headings) {
+    const count = (seenTexts.get(h.text) ?? 0) + 1;
+    seenTexts.set(h.text, count);
+    const suffix = count > 1 ? ` #${count}` : "";
+    dedupedHeadings.push({
+      text: h.text + suffix,
+      level: h.level
+    });
+  }
+  const guidanceLines = [];
+  guidanceLines.push(`Large markdown file (${headings.length} headings). Use token-goat section to read a specific section:`);
+  guidanceLines.push(`  token-goat section "${filePath}::Heading Name"`);
+  guidanceLines.push(`  Tip: an unambiguous heading prefix also resolves (e.g. "Lesson 16" instead of the full heading text) \u2014 shorter to type and avoids shell-quoting issues with punctuation in long headings.`);
+  guidanceLines.push(``);
+  guidanceLines.push(`Sections:`);
+  const sectionLines = [];
+  let headingsAdded = 0;
+  for (const h of dedupedHeadings) {
+    if (guidanceLines.length + sectionLines.length + 1 >= MAX_OUTPUT_LINES) {
+      const remaining = dedupedHeadings.length - headingsAdded;
+      sectionLines.push(`  ... (${remaining} more headings)`);
+      break;
+    }
+    const indent = h.level === 1 ? "" : h.level === 2 ? "  " : "    ";
+    const marker = "#".repeat(h.level);
+    sectionLines.push(`  ${indent}${marker} ${displaySafeText(h.text)}`);
+    headingsAdded++;
+  }
+  return { guidance: guidanceLines.join("\n"), sectionsList: sectionLines.join("\n") };
+}
+var WELL_KNOWN_SECTIONS = {
+  "CHANGELOG.md": ["Unreleased"],
+  "README.md": ["Install", "Usage", "API", "Configuration", "Getting Started"],
+  "CONTRIBUTING.md": ["Setup", "Commands", "Testing", "Development"],
+  "CLAUDE.md": ["Commands", "Architecture"],
+  "CLAUDE.arch.md": ["Component Map", "Architecture"]
+};
+function getWellKnownSections(basename2) {
+  return WELL_KNOWN_SECTIONS[basename2] ?? [];
+}
+function extractChangelogVersionHint(content, filePath) {
+  const lines2 = content.split("\n");
+  let foundUnreleased = false;
+  let firstVersion = null;
+  for (const line of lines2) {
+    const m = /^##\s+(\[?[\d]+\.[\d]+\.[\d]+\]?)/.exec(line);
+    if (m) {
+      if (foundUnreleased) {
+        const ver = m[1];
+        return ` | token-goat section "${filePath}::${ver}"`;
+      }
+      if (firstVersion === null) firstVersion = m[1];
+    }
+    if (/^##\s+\[?unreleased\]?/i.test(line)) {
+      foundUnreleased = true;
+    }
+  }
+  if (!foundUnreleased && firstVersion !== null) {
+    return ` | token-goat section "${filePath}::${firstVersion}"`;
+  }
+  return "";
+}
+
+// src/embedding_boundaries.ts
+function buildEmbeddingBoundaries(filePath, content, dbPath) {
+  if (detectLanguage(filePath) === "markdown") {
+    const headings = extractMarkdownHeadings(content, Infinity);
+    return headings.map((h, i) => ({
+      start: h.lineNumber,
+      // Runs to just before the next heading, or to end-of-file for the last one. chunkFile clips end values to the file's actual line count, so this sentinel is safe without re-deriving the file's line count here.
+      end: headings[i + 1] !== void 0 ? headings[i + 1].lineNumber - 1 : Number.MAX_SAFE_INTEGER,
+      kind: "section"
+    }));
+  }
+  const symbols = querySymbols({ filePath, limit: Number.MAX_SAFE_INTEGER }, dbPath);
+  return symbols.map((s) => ({ start: s.lineStart, end: s.lineEnd, kind: "symbol" }));
+}
+
+// src/languages/salesforce_frontend.ts
+init_define_import_meta_env();
+import * as path3 from "node:path";
+function lines(content) {
+  return content.split("\n");
+}
+function bundleName(filePath) {
+  const normalized = filePath.replaceAll("\\", "/");
+  const parent = path3.posix.basename(path3.posix.dirname(normalized));
+  const base = path3.posix.basename(normalized).replace(/\.[^.]+$/, "");
+  return parent === "lwc" || parent === "aura" ? base : parent;
+}
+function lwcTagAlias(name) {
+  const kebab = name.replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/([a-z\d])([A-Z])/g, "$1-$2").toLowerCase();
+  return `c-${kebab}`;
+}
+function symbol(filePath, name, kind, lineStart, lineEnd = lineStart) {
+  return { filePath, name, kind, lineStart, lineEnd, body: "", docstring: "", parent: "" };
+}
+function ref(filePath, name, line, col, context) {
+  return { filePath, name, line, col, context };
+}
+function dedupe(values, key) {
+  const seen = /* @__PURE__ */ new Set();
+  return values.filter((value) => {
+    const id = key(value);
+    if (seen.has(id)) return false;
+    seen.add(id);
+    return true;
+  });
+}
+function extractLwcJavaScript(content, filePath) {
+  const sourceLines = lines(content);
+  const bundle = bundleName(filePath);
+  const symbols = [
+    symbol(filePath, bundle, "lwc_bundle", 1, countContentLines(content)),
+    symbol(filePath, lwcTagAlias(bundle), "lwc_component_alias", 1, countContentLines(content))
+  ];
+  const refs = [];
+  const commentFree = stripJsComments(content);
+  const apiRe = /@api\s*(?:\r?\n\s*)?(?:(get|set)\s+)?(?:async\s+)?([A-Za-z_$][\w$]*)\s*(\()?/g;
+  for (const match of commentFree.matchAll(apiRe)) {
+    const before = commentFree.slice(0, match.index ?? 0);
+    const line = before.split("\n").length;
+    const kind = match[3] && !match[1] ? "lwc_api_method" : "lwc_api_property";
+    symbols.push(symbol(filePath, match[2] ?? "", kind, line));
+  }
+  const importRe = /from\s+['"]@salesforce\/(apex|schema|label|resourceUrl|messageChannel|customPermission|userPermission)\/([^'"]+)['"]/g;
+  for (const match of commentFree.matchAll(importRe)) {
+    const offset = match.index ?? 0;
+    const line = commentFree.slice(0, offset).split("\n").length;
+    const context = sourceLines[line - 1]?.trim() ?? "";
+    const target = match[2] ?? "";
+    const targetOffset = offset + (match[0]?.indexOf(target) ?? 0);
+    const col = targetOffset - (commentFree.lastIndexOf("\n", targetOffset) + 1);
+    if (match[1] === "apex") {
+      const className = target.split(".")[0] ?? target;
+      refs.push(ref(filePath, className, line, col, context));
+    }
+    refs.push(ref(filePath, target, line, col, context));
+  }
+  return {
+    symbols: dedupe(symbols, (entry) => `${entry.name}\0${entry.kind}\0${entry.lineStart}`),
+    refs: dedupe(refs, (entry) => `${entry.filePath}\0${entry.name}\0${entry.line}\0${entry.col}`)
+  };
+}
+function matchLine(content, offset) {
+  return content.slice(0, offset).split("\n").length;
+}
+function lineContext(content, line) {
+  return lines(content)[line - 1]?.trim() ?? "";
+}
+function extractLwcTemplate(content, filePath) {
+  const symbols = [];
+  const refs = [];
+  const markupNoComments = stripXmlComments(content);
+  for (const match of markupNoComments.matchAll(/\blwc:ref\s*=\s*["']([^"']+)["']/gi)) {
+    const line = matchLine(markupNoComments, match.index ?? 0);
+    symbols.push(symbol(filePath, match[1] ?? "", "lwc_ref", line));
+  }
+  for (const match of markupNoComments.matchAll(/\bid\s*=\s*["']([^"'{}:]+)["']/gi)) {
+    const line = matchLine(markupNoComments, match.index ?? 0);
+    symbols.push(symbol(filePath, match[1] ?? "", "lwc_id", line));
+  }
+  for (const match of markupNoComments.matchAll(/\bon[a-z][\w-]*\s*=\s*\{\s*([A-Za-z_$][\w$]*)\s*\}/gi)) {
+    const offset = match.index ?? 0;
+    const line = matchLine(markupNoComments, offset);
+    refs.push(ref(filePath, match[1] ?? "", line, 0, lineContext(content, line)));
+  }
+  for (const match of markupNoComments.matchAll(/<\s*(c-[a-z][\w-]*)\b/gi)) {
+    const offset = match.index ?? 0;
+    const line = matchLine(markupNoComments, offset);
+    refs.push(ref(filePath, (match[1] ?? "").toLowerCase(), line, 0, lineContext(content, line)));
+  }
+  return {
+    symbols: dedupe(symbols, (entry) => `${entry.name}\0${entry.kind}\0${entry.lineStart}`),
+    refs: dedupe(refs, (entry) => `${entry.filePath}\0${entry.name}\0${entry.line}\0${entry.col}`)
+  };
+}
+var MARKUP_KIND = {
+  ".cmp": "aura_bundle",
+  ".app": "aura_application",
+  ".evt": "aura_event_bundle",
+  ".intf": "aura_interface",
+  ".design": "aura_design",
+  ".auradoc": "aura_documentation",
+  ".tokens": "aura_tokens",
+  ".page": "visualforce_page",
+  ".component": "visualforce_component",
+  ".email": "visualforce_email_template"
+};
+function markupArtifactName(filePath, extension) {
+  if (extension === ".page" || extension === ".component" || extension === ".email") {
+    return path3.posix.basename(filePath.replaceAll("\\", "/")).replace(new RegExp(`${extension.replace(".", "\\.")}$`, "i"), "");
+  }
+  return bundleName(filePath);
+}
+function addAttributeSymbols(symbols, content, filePath, tag, kind) {
+  const tagRe = new RegExp(`<\\s*${tag}\\b[^>]*\\bname\\s*=\\s*["']([^"']+)["'][^>]*>`, "gi");
+  for (const match of content.matchAll(tagRe)) {
+    symbols.push(symbol(filePath, match[1] ?? "", kind, matchLine(content, match.index ?? 0)));
+  }
+}
+function attributeRefs(refs, content, filePath, attribute, split = false) {
+  const attributeRe = new RegExp(`\\b${attribute}\\s*=\\s*["']([^"']+)["']`, "gi");
+  for (const match of content.matchAll(attributeRe)) {
+    const line = matchLine(content, match.index ?? 0);
+    const values = split ? (match[1] ?? "").split(",").map((value) => value.trim()).filter(Boolean) : [match[1] ?? ""];
+    for (const value of values) refs.push(ref(filePath, value, line, 0, lineContext(content, line)));
+  }
+}
+function extractSalesforceMarkup(content, filePath) {
+  const normalized = filePath.replaceAll("\\", "/");
+  const extension = path3.posix.extname(normalized).toLowerCase();
+  const kind = MARKUP_KIND[extension] ?? "salesforce_markup";
+  const symbols = [
+    symbol(filePath, markupArtifactName(normalized, extension), kind, 1, countContentLines(content))
+  ];
+  const refs = [];
+  const isAura = [".cmp", ".app", ".evt", ".intf", ".design", ".auradoc", ".tokens"].includes(extension);
+  const markupNoComments = stripXmlComments(content);
+  if (isAura) {
+    addAttributeSymbols(symbols, markupNoComments, filePath, "aura:attribute", "aura_attribute");
+    addAttributeSymbols(symbols, markupNoComments, filePath, "aura:handler", "aura_handler");
+    addAttributeSymbols(symbols, markupNoComments, filePath, "aura:registerEvent", "aura_event");
+    addAttributeSymbols(symbols, markupNoComments, filePath, "design:attribute", "aura_design_attribute");
+  }
+  attributeRefs(refs, markupNoComments, filePath, "controller");
+  attributeRefs(refs, markupNoComments, filePath, "extensions", true);
+  const actionRe = isAura ? /\{!\s*c\.([A-Za-z_$][\w$]*)(?:[^}\w$][^}]*)?\}/gi : /\baction\s*=\s*["']\{!\s*(?:c\.)?([A-Za-z_$][\w$]*)(?:[^}\w$][^}]*)?\}["']/gi;
+  for (const match of markupNoComments.matchAll(actionRe)) {
+    const line = matchLine(markupNoComments, match.index ?? 0);
+    refs.push(ref(filePath, match[1] ?? "", line, 0, lineContext(content, line)));
+  }
+  for (const match of markupNoComments.matchAll(/\bc:[A-Za-z_$][\w$]*/g)) {
+    const line = matchLine(markupNoComments, match.index ?? 0);
+    refs.push(ref(filePath, match[0], line, 0, lineContext(content, line)));
+  }
+  return {
+    symbols: dedupe(symbols, (entry) => `${entry.name}\0${entry.kind}\0${entry.lineStart}`),
+    refs: dedupe(refs, (entry) => `${entry.filePath}\0${entry.name}\0${entry.line}\0${entry.col}`)
+  };
+}
+
+// src/languages/ipynb_idx.ts
+init_define_import_meta_env();
+function normalizeSource(source) {
+  if (typeof source === "string") return source;
+  if (!Array.isArray(source)) return "";
+  const lines2 = source.filter((s) => typeof s === "string");
+  if (lines2.length === 0) return "";
+  const noneEndWithNewline = lines2.every((l) => !l.endsWith("\n"));
+  return noneEndWithNewline ? lines2.join("\n") : lines2.join("");
+}
+function resolveKernelLanguage(metadata) {
+  const kernelspecLang = metadata?.kernelspec?.language;
+  if (typeof kernelspecLang === "string" && kernelspecLang !== "") return kernelspecLang.toLowerCase();
+  const infoLang = metadata?.language_info?.name;
+  if (typeof infoLang === "string" && infoLang !== "") return infoLang.toLowerCase();
+  return void 0;
+}
+function ipynbToVirtualSource(raw) {
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return { content: "", cellLanguage: null };
+  }
+  if (typeof data !== "object" || data === null) return { content: "", cellLanguage: null };
+  const nb = data;
+  if (!Array.isArray(nb.cells)) return { content: "", cellLanguage: null };
+  const declared = resolveKernelLanguage(nb.metadata);
+  const isPython = declared === void 0 || declared === "python" || declared === "python3";
+  if (!isPython) return { content: "", cellLanguage: null };
+  const blocks = [];
+  nb.cells.forEach((cell, index) => {
+    if (typeof cell !== "object" || cell === null) return;
+    const c = cell;
+    if (c.cell_type === "code") {
+      const src = normalizeSource(c.source).replace(/\n+$/, "");
+      blocks.push(`# %% cell ${index}
+${src}`);
+    } else if (c.cell_type === "markdown") {
+      const src = normalizeSource(c.source).replace(/\n+$/, "");
+      const commented = src.split("\n").map((line) => line === "" ? "#" : `# ${line}`).join("\n");
+      blocks.push(`# %% [markdown] cell ${index}
+${commented}`);
+    }
+  });
+  return { content: blocks.join("\n\n"), cellLanguage: "python" };
+}
+
+// src/parser_treesitter.ts
+init_define_import_meta_env();
+var TSJS_KIND_BY_TYPE = /* @__PURE__ */ new Map([
+  ["function_declaration", "function"],
+  ["generator_function_declaration", "function"],
+  ["class_declaration", "class"],
+  ["abstract_class_declaration", "class"],
+  ["method_definition", "method"],
+  ["interface_declaration", "interface"],
+  ["type_alias_declaration", "type"],
+  ["enum_declaration", "enum"],
+  // Interface members and abstract methods are distinct node types from concrete method_definition.
+  ["method_signature", "method"],
+  ["property_signature", "var"],
+  ["abstract_method_signature", "method"],
+  // Ambient function declarations in .d.ts files parse as function_signature.
+  ["function_signature", "function"],
+  // `namespace Foo { ... }` (and the legacy `module Foo { ... }` synonym) parses as
+  // `internal_module`; `declare module "some-string" { ... }` (an ambient module declaration,
+  // common in .d.ts files) parses as `module` -- a distinct node type from either. Neither had a
+  // kind-map entry, so the namespace/module declaration itself was silently invisible to
+  // `symbol`/`outline`/`skeleton`/`read`, even though everything nested inside it still indexed
+  // fine (the walk recurses into every node's children regardless of the parent's kind-map
+  // membership) -- the same container-drop shape already fixed for C++ `namespace_definition`
+  // and Rust `mod_item`. Both node types expose their name on the standard `name` field
+  // (an identifier, nested_identifier, or string), so `nodeName` resolves it without special-casing.
+  ["internal_module", "namespace"],
+  ["module", "namespace"]
+]);
+var TSJS_TYPE_MEMBER_TYPES = /* @__PURE__ */ new Set(["property_signature", "method_signature"]);
+var TSJS_TYPE_WRAPPER_TYPES = /* @__PURE__ */ new Set([
+  "parenthesized_type",
+  "union_type",
+  "intersection_type",
+  "array_type",
+  "readonly_type",
+  "tuple_type",
+  "optional_type",
+  "rest_type",
+  "generic_type",
+  "type_arguments"
+]);
+function isNamedTypeMember(node) {
+  const parent = node.parent;
+  if (parent === null) return false;
+  if (parent.type === "interface_body" || parent.type === "class_body") return true;
+  if (parent.type !== "object_type") return false;
+  let owner = parent.parent;
+  while (owner !== null && TSJS_TYPE_WRAPPER_TYPES.has(owner.type)) owner = owner.parent;
+  return owner !== null && owner.type === "type_alias_declaration";
+}
+function leadingTsDecorators(node) {
+  const decorators = [];
+  let cur = node.previousNamedSibling;
+  while (cur !== null && cur.type === "decorator") {
+    decorators.unshift(cur);
+    cur = cur.previousNamedSibling;
+  }
+  return decorators;
+}
+function nodeName(node) {
+  const named = node.childForFieldName("name");
+  if (named !== null) return named.text;
+  return null;
+}
+var SPEC_DECLARATION_OWNER = /* @__PURE__ */ new Map([
+  ["variable_declarator", /* @__PURE__ */ new Set(["lexical_declaration", "variable_declaration"])],
+  ["var_spec", /* @__PURE__ */ new Set(["var_declaration"])],
+  ["const_spec", /* @__PURE__ */ new Set(["const_declaration"])],
+  ["type_spec", /* @__PURE__ */ new Set(["type_declaration"])]
+]);
+var PREFIX_WRAPPER_TYPES = /* @__PURE__ */ new Set(["export_statement", "ambient_declaration"]);
+function widenToDeclaration(node) {
+  let widened = node;
+  const owner = SPEC_DECLARATION_OWNER.get(widened.type);
+  if (owner !== void 0) {
+    const decl = widened.parent;
+    if (decl === null || !owner.has(decl.type)) return widened;
+    let specs = 0;
+    for (const c of decl.namedChildren) if (c.type === widened.type) specs++;
+    if (specs !== 1) return widened;
+    if (decl.startPosition.row !== widened.startPosition.row) return widened;
+    widened = decl;
+  }
+  for (; ; ) {
+    const parent = widened.parent;
+    if (parent === null || !PREFIX_WRAPPER_TYPES.has(parent.type)) return widened;
+    widened = parent;
+  }
+}
+function makeSymbol(filePath, name, kind, node, lines2, style) {
+  const ranged = widenToDeclaration(node);
+  const lineStart = ranged.startPosition.row + 1;
+  return {
+    filePath,
+    name,
+    kind,
+    lineStart,
+    lineEnd: ranged.endPosition.row + 1,
+    body: ranged.text,
+    docstring: lines2 !== void 0 && style !== void 0 ? precedingDocComment(lines2, lineStart, style) : "",
+    parent: ""
+  };
+}
+function fanOutElidesBodies(nameCount, declarationChars) {
+  return nameCount > 1 && nameCount * declarationChars > SYMBOL_BODY_CHAR_CAP;
+}
+function collectPatternBindings(node) {
+  const names = [];
+  const walk = (n) => {
+    if (n.type === "identifier" || n.type === "shorthand_property_identifier_pattern") {
+      if (n.text !== "") names.push(n.text);
+      return;
+    }
+    if (n.type === "assignment_pattern" || n.type === "object_assignment_pattern") {
+      const left = n.childForFieldName("left");
+      if (left !== null) walk(left);
+      return;
+    }
+    if (n.type === "pair_pattern") {
+      const value = n.childForFieldName("value");
+      if (value !== null) walk(value);
+      return;
+    }
+    for (const child of n.namedChildren) walk(child);
+  };
+  walk(node);
+  return names;
+}
+var TSJS_FN_SCOPE_TYPES = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "function_expression",
+  "arrow_function",
+  "method_definition",
+  "generator_function",
+  "generator_function_declaration"
+]);
+function extractTsJsSymbols(root, filePath, lines2) {
+  const out = [];
+  const visit = (node, insideFunction) => {
+    const kind = TSJS_KIND_BY_TYPE.get(node.type);
+    const isLocalFunction = insideFunction && (node.type === "function_declaration" || node.type === "generator_function_declaration");
+    const isAnonymousTypeMember = TSJS_TYPE_MEMBER_TYPES.has(node.type) && !isNamedTypeMember(node);
+    if (kind !== void 0 && !isLocalFunction && !isAnonymousTypeMember) {
+      const name = nodeName(node);
+      if (name !== null && name !== "") {
+        const decorators = leadingTsDecorators(node);
+        if (decorators.length === 0) {
+          out.push(makeSymbol(filePath, name, kind, node, lines2, "c"));
+        } else {
+          const lineStart = decorators[0].startPosition.row + 1;
+          const decoratedEnd = widenToDeclaration(node).endPosition.row + 1;
+          out.push({
+            filePath,
+            name,
+            kind,
+            lineStart,
+            lineEnd: decoratedEnd,
+            // Read the body off the file rather than gluing the decorator and the node
+            // together with a newline: `@dec export class X {}` has no newline between
+            // them, and the glued form both invents one and drops the `export` that sits
+            // between the two nodes. A decorated declaration yields one symbol, so taking
+            // its whole span cannot fan out.
+            // The trailing replace keeps a convention the rest of the index follows: a
+            // tree-sitter node never carries the indentation of its own first line,
+            // because it starts at the first real character. Reading the span off the
+            // file would otherwise make decorated symbols the one shape that does.
+            body: lines2.slice(lineStart - 1, decoratedEnd).join("\n").replace(/^[ \t]+/, ""),
+            docstring: precedingDocComment(lines2, lineStart, "c"),
+            parent: ""
+          });
+        }
+      }
+    }
+    if (!insideFunction && (node.type === "lexical_declaration" || node.type === "variable_declaration")) {
+      for (const child of node.namedChildren) {
+        if (child.type !== "variable_declarator") continue;
+        const name = child.childForFieldName("name");
+        const value = child.childForFieldName("value");
+        if (name === null) continue;
+        if (name.type === "identifier") {
+          const isFn = value !== null && (value.type === "arrow_function" || value.type === "function_expression" || value.type === "function");
+          out.push(makeSymbol(filePath, name.text, isFn ? "function" : "variable", child, lines2, "c"));
+        } else {
+          const bindings = collectPatternBindings(name);
+          const elideBodies = fanOutElidesBodies(bindings.length, child.text.length);
+          for (const bound of bindings) {
+            const sym = makeSymbol(filePath, bound, "variable", child, lines2, "c");
+            out.push(elideBodies ? { ...sym, body: "" } : sym);
+          }
+        }
+      }
+    }
+    if (node.type === "public_field_definition" || node.type === "field_definition") {
+      const fieldName = node.childForFieldName("name") ?? node.childForFieldName("property");
+      const value = node.childForFieldName("value");
+      if (fieldName !== null && value !== null && (value.type === "arrow_function" || value.type === "function_expression" || value.type === "function")) {
+        out.push(makeSymbol(filePath, fieldName.text, "method", node, lines2, "c"));
+      }
+    }
+    const childInside = insideFunction || TSJS_FN_SCOPE_TYPES.has(node.type);
+    for (const child of node.namedChildren) {
+      visit(child, childInside);
+    }
+  };
+  visit(root, false);
+  return out;
+}
+var PY_KIND_BY_TYPE = /* @__PURE__ */ new Map([
+  ["function_definition", "function"],
+  ["class_definition", "class"],
+  // PEP 695 (Python 3.12) `type X = ...` / `type X[T] = ...` statement. Its node carries no
+  // `name` field (only `left`/`right`, both wrapping a `type` node — see
+  // pythonTypeAliasName below), so nodeName() alone can never resolve it; without this entry
+  // every PEP 695 type alias in a 3.12+ codebase was silently invisible to symbol/read/outline.
+  ["type_alias_statement", "type"]
+]);
+function pythonTypeAliasName(node) {
+  const left = node.childForFieldName("left");
+  if (left === null) return null;
+  let cur = left;
+  while (cur !== null) {
+    if (cur.type === "identifier") return cur.text;
+    cur = cur.namedChildren[0] ?? null;
+  }
+  return null;
+}
+function extractPythonSymbols(root, filePath) {
+  const out = [];
+  const visit = (node, insideClass) => {
+    const baseKind = PY_KIND_BY_TYPE.get(node.type);
+    if (baseKind !== void 0) {
+      const name = node.type === "type_alias_statement" ? pythonTypeAliasName(node) : nodeName(node);
+      if (name !== null && name !== "") {
+        const kind = node.type === "function_definition" && insideClass ? "method" : baseKind;
+        const rangeNode = node.parent?.type === "decorated_definition" ? node.parent : node;
+        const docstring = node.type === "type_alias_statement" ? "" : pythonDocstring(node);
+        out.push({
+          ...makeSymbol(filePath, name, kind, rangeNode),
+          docstring
+        });
+      }
+    }
+    for (const child of node.namedChildren) {
+      const childInsideClass = node.type === "class_definition" ? true : node.type === "function_definition" ? false : insideClass;
+      visit(child, childInsideClass);
+    }
+  };
+  visit(root, false);
+  return out;
+}
+function pythonDocstring(node) {
+  const block = node.childForFieldName("body");
+  if (block === null) return "";
+  const first = block.namedChildren[0];
+  if (first === void 0 || first.type !== "expression_statement") return "";
+  const str = first.namedChildren[0];
+  if (str === void 0 || str.type !== "string") return "";
+  return stripPythonStringQuotes(str.text);
+}
+function stripPythonStringQuotes(raw) {
+  let s = raw.trim();
+  s = s.replace(/^[A-Za-z]+/, "");
+  for (const q of ['"""', "'''", '"', "'"]) {
+    if (s.startsWith(q) && s.endsWith(q) && s.length >= q.length * 2) {
+      return s.slice(q.length, s.length - q.length).trim();
+    }
+  }
+  return s.trim();
+}
+var GO_KIND_BY_TYPE = /* @__PURE__ */ new Map([
+  ["function_declaration", "function"],
+  ["method_declaration", "method"],
+  // An interface's declared method set (`type Reader interface { Read(...) (int, error) }`) is
+  // parsed as `method_elem` -- a distinct node type from `method_declaration` (a concrete method
+  // with a receiver and body). `method_elem` exposes its own `name` field (a `field_identifier`),
+  // exactly like `method_declaration` does, but had no map entry: every method signature declared
+  // inside a Go interface -- the entire point of the interface -- was silently invisible to
+  // `symbol`/`outline`/`skeleton`/`read`, even though the interface type itself indexed fine via
+  // `type_spec` below.
+  ["method_elem", "method"],
+  // Go type/const/var names live on the nested *_spec node, not the *_declaration wrapper (which exposes no `name` field). A grouped `type (...)` / `const (...)` / `var (...)` block holds several specs, each reached by the namedChildren recursion in extractGoSymbols, so keying on the spec node yields one symbol per declared name. `type X = Y` parses as type_alias, which also carries the name field.
+  ["type_spec", "type"],
+  ["type_alias", "type"],
+  ["const_spec", "const"],
+  ["var_spec", "variable"]
+]);
+var GO_FN_SCOPE_TYPES = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "method_declaration",
+  "func_literal"
+]);
+var GO_LOCAL_KINDS = /* @__PURE__ */ new Set([
+  "var_spec",
+  "const_spec",
+  "type_spec",
+  "type_alias",
+  // A local interface type (`type Reader interface { Read(...) }` declared inside a func body) is
+  // itself excluded via `type_spec` above; its nested `method_elem` signatures must be excluded
+  // the same way, or a function-local interface's methods would leak into the index even though
+  // the interface type declaring them does not.
+  "method_elem"
+]);
+var GO_MULTI_NAME_SPECS = /* @__PURE__ */ new Set(["var_spec", "const_spec"]);
+function extractGoSymbols(root, filePath, lines2) {
+  const out = [];
+  const visit = (node, insideFunction) => {
+    const kind = GO_KIND_BY_TYPE.get(node.type);
+    if (kind !== void 0 && !(insideFunction && GO_LOCAL_KINDS.has(node.type))) {
+      if (GO_MULTI_NAME_SPECS.has(node.type)) {
+        const declared = node.namedChildren.filter(
+          (c) => c.type === "identifier" && c.text !== "" && c.text !== "_"
+        );
+        const elideBodies = fanOutElidesBodies(declared.length, node.text.length);
+        for (const child of declared) {
+          const sym = makeSymbol(filePath, child.text, kind, node, lines2, "c");
+          out.push(elideBodies ? { ...sym, body: "" } : sym);
+        }
+      } else {
+        const name = nodeName(node);
+        if (name !== null && name !== "") {
+          out.push(makeSymbol(filePath, name, kind, node, lines2, "c"));
+        }
+      }
+    }
+    const childInside = insideFunction || GO_FN_SCOPE_TYPES.has(node.type);
+    for (const child of node.namedChildren) {
+      visit(child, childInside);
+    }
+  };
+  visit(root, false);
+  return out;
+}
+var RUST_KIND_BY_TYPE = /* @__PURE__ */ new Map([
+  ["function_item", "function"],
+  ["struct_item", "struct"],
+  ["enum_item", "enum"],
+  ["impl_item", "impl"],
+  ["trait_item", "trait"],
+  ["type_item", "type"],
+  ["const_item", "const"],
+  // `mod foo { ... }` / `mod foo;` — Rust modules are ubiquitous (submodule trees, `#[cfg(test)]
+  // mod tests`) and parse as `mod_item`, which was absent here, so every module declaration was
+  // silently dropped from the index. Reuses the 'module' kind already used by the Ruby extractor.
+  // Not added to RUST_LOCAL_KINDS below: like a nested struct/fn, a mod declared inside a function
+  // body stays indexed (only value bindings — `const` — are treated as function-local noise).
+  ["mod_item", "module"],
+  // Unbodied `fn` signatures — trait required methods (`fn find(&self) -> u32;` inside a `trait`
+  // block) and `extern "C" { ... }` foreign-function declarations — parse as `function_signature_item`,
+  // NOT `function_item` (which requires a body). Absent here, so every trait interface method without
+  // a default body and every FFI declaration was silently dropped from the index: `token-goat symbol`
+  // / `read` returned nothing for them even though the trait/extern block itself indexed. Mapped to
+  // 'function', matching bodied `function_item`, so a trait's methods index whether or not they carry
+  // a default body. Not a value binding, so it never appears as a function-local — no RUST_LOCAL_KINDS
+  // entry needed.
+  ["function_signature_item", "function"],
+  // `extern "C" { ... }` / `extern "system" { ... }` foreign-module blocks -- unlike `trait_item`
+  // (which IS indexed, so a trait method rendered standalone still has its enclosing `trait Foo`
+  // symbol nearby for context), `foreign_mod_item` was entirely absent here, so an FFI declaration's
+  // `function_signature_item` was the ONLY trace of the block in the index -- its ABI string
+  // (`"C"` vs `"system"`, real calling-convention information) and any `#[link(name = "...")]`
+  // attribute naming the linked library were both invisible with no other symbol to find them on.
+  // Kept as its own entry (not folded into the child fn's body) to match how every other container
+  // in this extractor works: the parent supplies context, the child stays standalone.
+  ["foreign_mod_item", "extern"],
+  // `macro_rules! foo { ... }` declarative macros parse as `macro_definition`, which was absent
+  // here, so every `macro_rules!` definition was silently dropped from the index. Macros are
+  // uniquely painful to lose: an invocation site (`foo!(...)`) carries no path back to the
+  // definition, so without a name index there is no cheap way to jump from a call to the
+  // `macro_rules!` block. The name lives on the standard `name` field (an `identifier`), so
+  // `nodeName` resolves it like any other item. Like `mod`/`fn`/`trait` — a definition, not a
+  // value binding — so it is NOT added to RUST_LOCAL_KINDS: a macro nested in a function stays
+  // indexed, matching how nested fns/structs are kept and only `const`/`static` value bindings
+  // are treated as function-local noise.
+  ["macro_definition", "macro"],
+  // `static FOO: T = ...;` / `pub static mut COUNTER: T = ...;` bindings parse as `static_item`,
+  // which was absent here, so every `static` was silently dropped from the index — including the
+  // ubiquitous top-level `static` tables and `static mut` globals real Rust code carries. Like
+  // `const_item`, a `static` is a value binding, so it is ALSO added to RUST_LOCAL_KINDS below: a
+  // `static` declared inside a function body is function-local noise (it has `'static` lifetime but
+  // function scope) and must not pollute the global symbol index, matching how function-local
+  // `const` is excluded. Its name lives on the standard `name` field, so `nodeName` resolves it.
+  ["static_item", "static"],
+  // `union Foo { ... }` (C-style untagged unions, mostly FFI/unsafe code) parse as `union_item`,
+  // which was absent here, so every union was silently dropped from the index. A union is a type
+  // definition like `struct`/`enum` — NOT a value binding — so it stays indexed even when nested,
+  // and gets no RUST_LOCAL_KINDS entry (mirroring how nested structs/enums stay indexed). Its name
+  // lives on the standard `name` field.
+  ["union_item", "union"],
+  // `type Item;` (unbodied) / `type Item = Foo;` (with a default) declared inside a `trait { ... }`
+  // block — an associated type, the mechanism behind `Iterator::Item`, `Deref::Target`, and every
+  // other trait with a type member — parses as its OWN node type, `associated_type`, which is
+  // distinct from the free-standing `type_item` already mapped above (`type Alias = Foo;` at module
+  // scope). `associated_type` was absent here, so every trait associated-type declaration was
+  // silently dropped from the index, same failure shape as the `function_signature_item` gap fixed
+  // above for unbodied trait methods. Its name lives on the standard `name` field, so `nodeName`
+  // resolves it. Mapped to 'type', matching free-standing `type_item`, so both forms of "this is a
+  // type declaration" land under one kind. Not a value binding, so no RUST_LOCAL_KINDS entry —
+  // though in practice `associated_type` only ever appears inside a `trait`/`impl` body, never a fn.
+  ["associated_type", "type"]
+]);
+var RUST_FN_SCOPE_TYPES = /* @__PURE__ */ new Set(["function_item", "closure_expression"]);
+var RUST_LOCAL_KINDS = /* @__PURE__ */ new Set(["const_item", "static_item"]);
+function leadingRustAttributes(node) {
+  const attrs = [];
+  let cur = node.previousNamedSibling;
+  while (cur !== null && cur.type === "attribute_item") {
+    attrs.unshift(cur);
+    cur = cur.previousNamedSibling;
+  }
+  return attrs;
+}
+function extractRustSymbols(root, filePath, lines2) {
+  const out = [];
+  const visit = (node, insideFunction) => {
+    const kind = RUST_KIND_BY_TYPE.get(node.type);
+    if (kind !== void 0 && !(insideFunction && RUST_LOCAL_KINDS.has(node.type))) {
+      const name = node.type === "impl_item" ? node.childForFieldName("type")?.text ?? null : node.type === "foreign_mod_item" ? node.namedChildren.find((c) => c.type === "extern_modifier")?.text ?? "extern" : nodeName(node);
+      if (name !== null && name !== "") {
+        const attrs = leadingRustAttributes(node);
+        if (attrs.length === 0) {
+          out.push(makeSymbol(filePath, name, kind, node, lines2, "c"));
+        } else {
+          const lineStart = attrs[0].startPosition.row + 1;
+          out.push({
+            filePath,
+            name,
+            kind,
+            lineStart,
+            lineEnd: node.endPosition.row + 1,
+            body: [...attrs, node].map((n) => n.text).join("\n"),
+            docstring: precedingDocComment(lines2, lineStart, "c"),
+            parent: ""
+          });
+        }
+      }
+    }
+    const childInside = insideFunction || RUST_FN_SCOPE_TYPES.has(node.type);
+    for (const child of node.namedChildren) {
+      visit(child, childInside);
+    }
+  };
+  visit(root, false);
+  return out;
+}
+var RUBY_KIND_BY_TYPE = /* @__PURE__ */ new Map([
+  ["method", "method"],
+  ["singleton_method", "method"],
+  ["class", "class"],
+  ["module", "module"]
+]);
+function extractSimpleSymbols(root, filePath, kindByType, lines2, style, nameFor = nodeName) {
+  const out = [];
+  const visit = (node) => {
+    const kind = kindByType.get(node.type);
+    if (kind !== void 0) {
+      const name = nameFor(node);
+      if (name !== null && name !== "") {
+        out.push(makeSymbol(filePath, name, kind, node, lines2, style));
+      }
+    }
+    for (const child of node.namedChildren) {
+      visit(child);
+    }
+  };
+  visit(root);
+  return out;
+}
+function extractRubySymbols(root, filePath, lines2) {
+  return extractSimpleSymbols(root, filePath, RUBY_KIND_BY_TYPE, lines2, "hash");
+}
+var JAVA_KIND_BY_TYPE = /* @__PURE__ */ new Map([
+  ["method_declaration", "method"],
+  ["class_declaration", "class"],
+  ["interface_declaration", "interface"],
+  ["enum_declaration", "enum"],
+  ["constructor_declaration", "method"],
+  ["record_declaration", "class"],
+  ["annotation_type_declaration", "interface"],
+  // An annotation type's members (`String value() default "";`, `int count();` inside an
+  // `@interface` body) parse as `annotation_type_element_declaration` -- a distinct node type
+  // from `method_declaration`, even though it is the exact same "signature-shaped declaration"
+  // as an interface method. It exposes its own `name` field (an `identifier`), same shape as
+  // `method_declaration`, but had no map entry here: every annotation member was silently
+  // invisible to `symbol`/`outline`/`skeleton`/`read`, even though the annotation type itself
+  // indexed fine via `annotation_type_declaration` above. Mapped to 'method' to match how a
+  // Go interface's `method_elem` and a Rust trait's `function_signature_item` are folded into
+  // the same kind as their bodied counterparts.
+  ["annotation_type_element_declaration", "method"]
+]);
+function extractJavaSymbols(root, filePath, lines2) {
+  return extractSimpleSymbols(root, filePath, JAVA_KIND_BY_TYPE, lines2, "c");
+}
+var CPP_KIND_BY_TYPE = /* @__PURE__ */ new Map([
+  ["function_definition", "function"],
+  ["class_specifier", "class"],
+  ["struct_specifier", "struct"],
+  ["enum_specifier", "enum"],
+  // `union_specifier` exposes the same `name` field (a `type_identifier`) as struct/enum in both
+  // the C and C++ grammars, so a named union indexes as kind 'union' and is visible to `types`.
+  ["union_specifier", "union"],
+  // A `typedef ... Alias;` parses as `type_definition`; its aliased name lives on the nested
+  // `declarator` chain, not a `name` field. The dominant real-world form `typedef struct { ... }
+  // Alias;` (anonymous tag) otherwise indexes nothing at all: the inner struct/enum/union
+  // specifier has no `name`, and the alias itself was never reached. Kind 'type' matches how the
+  // TS/Go/Rust type aliases are indexed and is in `types`' TYPE_KINDS.
+  ["type_definition", "type"],
+  // `using Alias = Type;` (the C++11 alias-declaration form) parses as `alias_declaration`, a
+  // distinct node type from `type_definition` above -- it had no entry here, so every C++11-style
+  // type alias was silently invisible to symbol/outline/skeleton/types even though its `name`
+  // field (a `type_identifier`) resolves fine via the default nodeName() lookup, unlike typedef's
+  // declarator-chain descent (cTypedefAliasName). Kind 'type' matches type_definition's convention.
+  ["alias_declaration", "type"],
+  // `namespace Foo { ... }` (including the C++17 nested `namespace A::B { ... }` shorthand) parses
+  // as `namespace_definition`, which had no entry here, so the namespace itself was silently
+  // dropped from the index -- `symbol`/`outline`/`skeleton` never showed the declaration line,
+  // even though everything nested inside it still indexed (extractSimpleSymbols always recurses
+  // into children regardless of the parent's kind-map membership). The default `nodeName` lookup
+  // (childForFieldName('name')) resolves both the simple `namespace_identifier` case and the
+  // nested `nested_namespace_specifier` case (whose `.text` is the full `A::B` path) without any
+  // special-casing. An anonymous `namespace { ... }` has no `name` field, so `nodeName` returns
+  // null and it is correctly skipped -- matching how an anonymous struct/enum/union tag is only
+  // ever indexed via its typedef alias, never as a bare symbol of its own. Kind 'namespace', not
+  // 'module' (already used for Rust `mod`/Ruby `module`), since C++ namespaces are reopenable and
+  // additive rather than a single owning declaration -- and NOT added to graph_commands.ts's
+  // TYPE_KINDS, since a namespace is a container, not a type declaration (mirrors 'module' being
+  // absent from TYPE_KINDS for the same reason).
+  ["namespace_definition", "namespace"],
+  // A bodiless function prototype (`int add(int a, int b);`) parses as a plain `declaration`, NOT
+  // `function_definition` (which requires a `{ ... }` body) -- the dominant content of any C/C++
+  // header file, which is almost entirely prototypes forward-declaring functions defined
+  // elsewhere. Pre-fix, every one of these was silently dropped: `symbol`/`read`/`outline` on a
+  // header returned nothing for its declared API surface. `declaration` is also the node type for
+  // every plain variable/extern declaration (`int x;`, `extern int y;`) and for a function-pointer
+  // *variable* (`int (*fp)(int);`, whose declarator, confusingly, ALSO nests a `function_declarator`
+  // around a `parenthesized_declarator`), so this can't be a blanket kind-map entry the way
+  // struct/enum/union are -- `cFunctionPrototypeName` below does the real filtering by inspecting
+  // the declarator shape, and returns null (silently skipped, matching how an unnamed struct/enum
+  // tag is skipped) for anything that isn't a genuine function prototype.
+  ["declaration", "function"]
+]);
+function extractCppSymbols(root, filePath, lines2) {
+  return extractSimpleSymbols(
+    root,
+    filePath,
+    CPP_KIND_BY_TYPE,
+    lines2,
+    "c",
+    (node) => node.type === "function_definition" ? cFunctionName(node) : node.type === "type_definition" ? cTypedefAliasName(node) : node.type === "declaration" ? cFunctionPrototypeName(node) : nodeName(node)
+  );
+}
+function cFunctionPrototypeName(node) {
+  let cur = node.childForFieldName("declarator");
+  for (let i = 0; cur !== null && i < 16; i++) {
+    if (cur.type === "function_declarator") {
+      const inner = cur.childForFieldName("declarator");
+      if (inner === null) return null;
+      if (inner.type === "identifier" || inner.type === "field_identifier") return inner.text;
+      if (inner.type === "qualified_identifier") return lastSegment(inner.text);
+      return null;
+    }
+    if (cur.type === "pointer_declarator" || cur.type === "reference_declarator") {
+      cur = cur.childForFieldName("declarator");
+      continue;
+    }
+    return null;
+  }
+  return null;
+}
+function cTypedefAliasName(node) {
+  let cur = node.childForFieldName("declarator");
+  for (let i = 0; cur !== null && i < 16; i++) {
+    if (cur.type === "type_identifier") return cur.text;
+    const next = cur.childForFieldName("declarator");
+    cur = next ?? (cur.type === "parenthesized_declarator" ? cur.namedChildren[0] ?? null : null);
+  }
+  return null;
+}
+function lastSegment(text) {
+  const parts = text.split(/::|\./);
+  return parts[parts.length - 1] ?? text;
+}
+function cFunctionName(node) {
+  let cur = node.childForFieldName("declarator");
+  for (let i = 0; cur !== null && i < 16; i++) {
+    if (cur.type === "identifier" || cur.type === "field_identifier") return cur.text;
+    if (cur.type === "qualified_identifier") return lastSegment(cur.text);
+    cur = cur.childForFieldName("declarator");
+  }
+  return null;
+}
+
+// src/parser_refs.ts
+init_define_import_meta_env();
+var SCOPE_TYPES_BY_LANG = /* @__PURE__ */ new Map([
+  [
+    "typescript",
+    /* @__PURE__ */ new Set([
+      "function_declaration",
+      "generator_function_declaration",
+      "class_declaration",
+      "abstract_class_declaration",
+      "method_definition"
+    ])
+  ],
+  [
+    "javascript",
+    /* @__PURE__ */ new Set([
+      "function_declaration",
+      "generator_function_declaration",
+      "class_declaration",
+      "method_definition"
+    ])
+  ],
+  ["python", /* @__PURE__ */ new Set(["function_definition", "class_definition"])],
+  ["go", /* @__PURE__ */ new Set(["function_declaration", "method_declaration"])],
+  ["rust", /* @__PURE__ */ new Set(["function_item"])],
+  [
+    "java",
+    /* @__PURE__ */ new Set(["method_declaration", "constructor_declaration", "class_declaration"])
+  ],
+  ["c", /* @__PURE__ */ new Set(["function_definition"])],
+  ["cpp", /* @__PURE__ */ new Set(["function_definition"])],
+  ["ruby", /* @__PURE__ */ new Set(["method", "singleton_method", "class", "module"])]
+]);
+var CALL_TYPES_BY_LANG = /* @__PURE__ */ new Map([
+  ["typescript", /* @__PURE__ */ new Set(["call_expression", "new_expression"])],
+  ["javascript", /* @__PURE__ */ new Set(["call_expression", "new_expression"])],
+  ["python", /* @__PURE__ */ new Set(["call"])],
+  ["go", /* @__PURE__ */ new Set(["call_expression"])],
+  ["rust", /* @__PURE__ */ new Set(["call_expression", "macro_invocation"])],
+  ["java", /* @__PURE__ */ new Set(["method_invocation", "object_creation_expression"])],
+  ["c", /* @__PURE__ */ new Set(["call_expression"])],
+  ["cpp", /* @__PURE__ */ new Set(["call_expression", "new_expression"])],
+  ["ruby", /* @__PURE__ */ new Set(["call"])]
+]);
+var REF_NOISE_BY_LANG = /* @__PURE__ */ new Map([
+  [
+    "typescript",
+    /* @__PURE__ */ new Set([
+      "require",
+      "Boolean",
+      "Number",
+      "String",
+      "Array",
+      "Object",
+      "Symbol",
+      "BigInt",
+      "parseInt",
+      "parseFloat",
+      "isNaN",
+      "isFinite",
+      "setTimeout",
+      "setInterval",
+      "clearTimeout",
+      "clearInterval"
+    ])
+  ],
+  [
+    "python",
+    /* @__PURE__ */ new Set([
+      "print",
+      "len",
+      "range",
+      "str",
+      "int",
+      "float",
+      "bool",
+      "list",
+      "dict",
+      "set",
+      "tuple",
+      "type",
+      "isinstance",
+      "issubclass",
+      "hasattr",
+      "getattr",
+      "setattr",
+      "enumerate",
+      "zip",
+      "sorted",
+      "reversed",
+      "min",
+      "max",
+      "sum",
+      "abs",
+      "open",
+      "repr",
+      "super"
+    ])
+  ],
+  // go/rust/c/cpp/ruby below cover only genuinely bare-identifier builtins (Go's predeclared functions, Rust macros, C/POSIX libc, Ruby's Kernel methods) -- the same restriction the comment above REF_NOISE_BY_LANG already documents for every language. java is deliberately left unpopulated: Java has no unqualified global builtin equivalent to these (stdout access always goes through System.out.*, a member call captured by its property name, not a bare identifier), so a bare `name` field from method_invocation is far more likely to be a real same-class helper call than a builtin -- adding entries here would risk false-negative "unreferenced" callers reports for real user methods that happen to share a common name.
+  [
+    "go",
+    /* @__PURE__ */ new Set([
+      "len",
+      "cap",
+      "make",
+      "new",
+      "append",
+      "copy",
+      "delete",
+      "panic",
+      "recover",
+      "print",
+      "println"
+    ])
+  ],
+  [
+    "rust",
+    /* @__PURE__ */ new Set([
+      "println",
+      "print",
+      "eprintln",
+      "eprint",
+      "format",
+      "vec",
+      "write",
+      "writeln",
+      "assert",
+      "assert_eq",
+      "assert_ne",
+      "debug_assert",
+      "panic",
+      "todo",
+      "unimplemented",
+      "dbg"
+    ])
+  ],
+  [
+    "c",
+    /* @__PURE__ */ new Set([
+      "printf",
+      "sprintf",
+      "snprintf",
+      "scanf",
+      "malloc",
+      "calloc",
+      "realloc",
+      "free",
+      "memcpy",
+      "memset",
+      "memmove",
+      "strlen",
+      "strcpy",
+      "strcmp",
+      "exit",
+      "abort",
+      "assert"
+    ])
+  ],
+  [
+    "cpp",
+    /* @__PURE__ */ new Set([
+      "printf",
+      "sprintf",
+      "snprintf",
+      "scanf",
+      "malloc",
+      "calloc",
+      "realloc",
+      "free",
+      "memcpy",
+      "memset",
+      "memmove",
+      "strlen",
+      "strcpy",
+      "strcmp",
+      "exit",
+      "abort",
+      "assert"
+    ])
+  ],
+  [
+    "ruby",
+    /* @__PURE__ */ new Set([
+      "puts",
+      "print",
+      "p",
+      "pp",
+      "gets",
+      "require",
+      "require_relative",
+      "raise",
+      "loop",
+      "lambda",
+      "proc",
+      "sleep",
+      "exit",
+      "freeze"
+    ])
+  ]
+]);
+var JS_NOISE = REF_NOISE_BY_LANG.get("typescript") ?? /* @__PURE__ */ new Set();
+var EMPTY_STRING_SET = /* @__PURE__ */ new Set();
+function lastSegment2(text) {
+  const parts = text.split(/::|\./);
+  return parts[parts.length - 1] ?? text;
+}
+function scopeName(node, language) {
+  if ((language === "typescript" || language === "javascript") && node.type === "variable_declarator") {
+    const value = node.childForFieldName("value");
+    if (value !== null && (value.type === "arrow_function" || value.type === "function_expression" || value.type === "function")) {
+      return node.childForFieldName("name")?.text ?? null;
+    }
+    return null;
+  }
+  const scopeTypes = SCOPE_TYPES_BY_LANG.get(language);
+  if (scopeTypes !== void 0 && scopeTypes.has(node.type)) {
+    if ((language === "c" || language === "cpp") && node.type === "function_definition") {
+      return cFunctionName2(node);
+    }
+    return node.childForFieldName("name")?.text ?? null;
+  }
+  return null;
+}
+function cFunctionName2(node) {
+  let cur = node.childForFieldName("declarator");
+  for (let i = 0; cur !== null && i < 16; i++) {
+    if (cur.type === "identifier" || cur.type === "field_identifier") return cur.text;
+    if (cur.type === "qualified_identifier") return lastSegment2(cur.text);
+    cur = cur.childForFieldName("declarator");
+  }
+  return null;
+}
+function cppCalleeName(node) {
+  switch (node.type) {
+    case "identifier":
+    case "field_identifier":
+    case "type_identifier":
+      return node.text;
+    // An overloaded operator's name is its own node type, and it is the spelling the extractor gives the operator's definition too, so returning the text here is what makes the two match. Measured: `r.template operator()<int>(3)` parses as `dependent_name(template, template_method(operator_name "operator()", template_argument_list "<int>"))`, so without this case the name resolved to null and the field_expression fallback below recorded `template operator()<int>` -- a spelling no symbol row ever holds, leaving the call permanently unresolvable.
+    case "operator_name":
+      return node.text;
+    case "template_function":
+    case "template_method":
+    case "template_type": {
+      const name = node.childForFieldName("name");
+      return name !== null ? cppCalleeName(name) : null;
+    }
+    case "qualified_identifier": {
+      const name = node.childForFieldName("name");
+      return name !== null ? cppCalleeName(name) : lastSegment2(node.text);
+    }
+    case "dependent_name": {
+      const last = node.namedChildren[node.namedChildren.length - 1];
+      return last !== void 0 ? cppCalleeName(last) : null;
+    }
+    case "field_expression": {
+      const field = node.childForFieldName("field");
+      if (field === null) return null;
+      return cppCalleeName(field) ?? field.text;
+    }
+    default:
+      return null;
+  }
+}
+function calleeName(call, language) {
+  switch (language) {
+    case "typescript":
+    case "javascript": {
+      if (call.type === "new_expression") {
+        const c = call.childForFieldName("constructor");
+        if (c === null) return null;
+        if (c.type === "identifier") return c.text;
+        if (c.type === "member_expression") return c.childForFieldName("property")?.text ?? null;
+        return null;
+      }
+      const fn = call.childForFieldName("function");
+      if (fn === null) return null;
+      if (fn.type === "identifier") return fn.text;
+      if (fn.type === "member_expression") return fn.childForFieldName("property")?.text ?? null;
+      return null;
+    }
+    case "python": {
+      const fn = call.childForFieldName("function");
+      if (fn === null) return null;
+      if (fn.type === "identifier") return fn.text;
+      if (fn.type === "attribute") return fn.childForFieldName("attribute")?.text ?? null;
+      return null;
+    }
+    case "go": {
+      const fn = call.childForFieldName("function");
+      if (fn === null) return null;
+      if (fn.type === "identifier") return fn.text;
+      if (fn.type === "selector_expression") return fn.childForFieldName("field")?.text ?? null;
+      return null;
+    }
+    case "rust": {
+      if (call.type === "macro_invocation") {
+        const m = call.childForFieldName("macro");
+        return m !== null ? lastSegment2(m.text) : null;
+      }
+      const fn = call.childForFieldName("function");
+      if (fn === null) return null;
+      if (fn.type === "identifier") return fn.text;
+      if (fn.type === "field_expression") return fn.childForFieldName("field")?.text ?? null;
+      if (fn.type === "scoped_identifier") {
+        return fn.childForFieldName("name")?.text ?? lastSegment2(fn.text);
+      }
+      return null;
+    }
+    case "java": {
+      const n = call.childForFieldName("name") ?? call.childForFieldName("type");
+      return n !== null ? lastSegment2(n.text) : null;
+    }
+    case "c":
+    case "cpp": {
+      const fn = call.type === "new_expression" ? call.childForFieldName("type") : call.childForFieldName("function");
+      if (fn === null) return null;
+      return cppCalleeName(fn);
+    }
+    case "ruby": {
+      const m = call.childForFieldName("method");
+      return m?.text ?? null;
+    }
+    default:
+      return null;
+  }
+}
+var VALUE_WRAPPER_TYPES = /* @__PURE__ */ new Set([
+  "parenthesized_expression",
+  "as_expression",
+  "satisfies_expression",
+  "non_null_expression",
+  "type_assertion",
+  "instantiation_expression",
+  "await_expression",
+  "unary_expression",
+  // Python spells this as a bare `await` rather than with an `_expression` suffix.
+  "await"
+]);
+function unwrapValueIdentifier(node) {
+  if (node === null || node === void 0) return null;
+  if (node.type === "identifier") return node;
+  if (!VALUE_WRAPPER_TYPES.has(node.type)) return null;
+  for (const child of node.namedChildren) {
+    const inner = unwrapValueIdentifier(child);
+    if (inner !== null) return inner;
+  }
+  return null;
+}
+function pushValueIdentifier(result, node) {
+  const identifier = unwrapValueIdentifier(node);
+  if (identifier !== null) result.push(identifier);
+}
+function valueRefIdentifiers(node, language) {
+  const isJs = language === "typescript" || language === "javascript";
+  const isPy = language === "python";
+  if (!isJs && !isPy) return [];
+  const result = [];
+  if (isJs && node.type === "arguments" || isPy && node.type === "argument_list") {
+    for (const child of node.namedChildren) {
+      pushValueIdentifier(result, child);
+    }
+  }
+  if (isPy && node.type === "keyword_argument") {
+    const value = node.childForFieldName("value");
+    pushValueIdentifier(result, value);
+  }
+  if (isJs && node.type === "binary_expression") {
+    const operator = node.childForFieldName("operator")?.text;
+    if (operator === "??" || operator === "||" || operator === "&&") {
+      const left = node.childForFieldName("left");
+      const right = node.childForFieldName("right");
+      pushValueIdentifier(result, left);
+      pushValueIdentifier(result, right);
+    }
+  }
+  if (isJs && (node.type === "variable_declarator" || node.type === "assignment_expression")) {
+    const value = node.childForFieldName(node.type === "variable_declarator" ? "value" : "right");
+    pushValueIdentifier(result, value);
+  }
+  if (isPy && node.type === "assignment") {
+    const value = node.childForFieldName("right");
+    pushValueIdentifier(result, value);
+  }
+  if (isJs && node.type === "pair") {
+    const value = node.childForFieldName("value");
+    pushValueIdentifier(result, value);
+  }
+  if (isJs && (node.type === "required_parameter" || node.type === "optional_parameter")) {
+    const value = node.childForFieldName("value");
+    pushValueIdentifier(result, value);
+  }
+  if (isJs && node.type === "array" || isPy && (node.type === "list" || node.type === "tuple" || node.type === "set")) {
+    for (const child of node.namedChildren) {
+      pushValueIdentifier(result, child);
+    }
+  }
+  if (isJs && node.type === "ternary_expression") {
+    const consequence = node.childForFieldName("consequence");
+    const alternative = node.childForFieldName("alternative");
+    pushValueIdentifier(result, consequence);
+    pushValueIdentifier(result, alternative);
+  }
+  if (isPy && node.type === "conditional_expression" && node.namedChildren.length === 3) {
+    const consequence = node.namedChildren[0];
+    const alternative = node.namedChildren[2];
+    pushValueIdentifier(result, consequence);
+    pushValueIdentifier(result, alternative);
+  }
+  if (isJs && (node.type === "public_field_definition" || node.type === "field_definition")) {
+    const value = node.childForFieldName("value");
+    pushValueIdentifier(result, value);
+  }
+  if (node.type === "return_statement" && node.namedChildren.length === 1) {
+    const value = node.namedChildren[0];
+    pushValueIdentifier(result, value);
+  }
+  if (isJs && (node.type === "assignment_pattern" || node.type === "object_assignment_pattern")) {
+    const value = node.childForFieldName("right");
+    pushValueIdentifier(result, value);
+  }
+  if (isJs && node.type === "template_substitution" && node.namedChildren.length === 1) {
+    const value = node.namedChildren[0];
+    pushValueIdentifier(result, value);
+  }
+  if (isJs && node.type === "object") {
+    for (const child of node.namedChildren) {
+      if (child.type === "shorthand_property_identifier") result.push(child);
+    }
+  }
+  if (node.type === "decorator") pushValueIdentifier(result, node.namedChildren[0]);
+  if (isPy && node.type === "pair") pushValueIdentifier(result, node.childForFieldName("value"));
+  if (isPy && node.type === "interpolation") pushValueIdentifier(result, node.childForFieldName("expression"));
+  if (isJs && node.type === "augmented_assignment_expression") pushValueIdentifier(result, node.childForFieldName("right"));
+  if (isPy && node.type === "augmented_assignment") pushValueIdentifier(result, node.childForFieldName("right"));
+  if (isJs && node.type === "sequence_expression") {
+    for (const child of node.namedChildren) pushValueIdentifier(result, child);
+  }
+  if (isJs && node.type === "spread_element") pushValueIdentifier(result, node.namedChildren[0]);
+  if (isPy && (node.type === "list_splat" || node.type === "dictionary_splat")) pushValueIdentifier(result, node.namedChildren[0]);
+  if (isJs && node.type === "computed_property_name") pushValueIdentifier(result, node.namedChildren[0]);
+  if (isPy && (node.type === "list_comprehension" || node.type === "set_comprehension" || node.type === "generator_expression")) {
+    pushValueIdentifier(result, node.namedChildren[0]);
+  }
+  if (isPy && node.type === "for_in_clause") pushValueIdentifier(result, node.childForFieldName("right"));
+  if (isPy && node.type === "lambda") pushValueIdentifier(result, node.childForFieldName("body"));
+  if (isJs && node.type === "yield_expression") pushValueIdentifier(result, node.namedChildren[0]);
+  if (isPy && node.type === "yield") pushValueIdentifier(result, node.namedChildren[0]);
+  if (isPy && node.type === "raise_statement") pushValueIdentifier(result, node.namedChildren[0]);
+  if (isJs && (node.type === "extends_clause" || node.type === "class_heritage")) {
+    const base = node.namedChildren[0];
+    if (base !== void 0) {
+      if (base.type === "identifier") result.push(base);
+      else if (base.type === "member_expression") {
+        const object = base.childForFieldName("object");
+        if (object !== null && object.type === "identifier") result.push(object);
+      }
+    }
+  }
+  return result;
+}
+function extractRefs(root, filePath, language) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const callTypes = CALL_TYPES_BY_LANG.get(language) ?? EMPTY_STRING_SET;
+  const noise = language === "javascript" ? JS_NOISE : REF_NOISE_BY_LANG.get(language) ?? EMPTY_STRING_SET;
+  const stack = [];
+  const record = (name, node) => {
+    if (name.length <= 1 || noise.has(name)) return;
+    const line = node.startPosition.row + 1;
+    const key = `${name}\0${line}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    out.push({
+      filePath,
+      name,
+      line,
+      col: node.startPosition.column,
+      context: stack.length > 0 ? stack[stack.length - 1] ?? "" : ""
+    });
+  };
+  const visit = (node) => {
+    const enclosing = scopeName(node, language);
+    if (enclosing !== null && enclosing !== "") stack.push(enclosing);
+    if (callTypes.has(node.type)) {
+      const callee = calleeName(node, language);
+      if (callee !== null) record(callee, node);
+    }
+    for (const idNode of valueRefIdentifiers(node, language)) {
+      record(idNode.text, idNode);
+    }
+    for (const child of node.namedChildren) visit(child);
+    if (enclosing !== null && enclosing !== "") stack.pop();
+  };
+  visit(root);
+  return out;
+}
+
+// src/parser_structured.ts
+init_define_import_meta_env();
+function scanJsonValueEnd(content, start) {
+  const first = content[start];
+  if (first === void 0) return content.length;
+  if (first === '"') {
+    let escaping = false;
+    for (let j = start + 1; j < content.length; j++) {
+      const c = content[j];
+      if (escaping) {
+        escaping = false;
+        continue;
+      }
+      if (c === "\\") {
+        escaping = true;
+        continue;
+      }
+      if (c === '"') return j + 1;
+    }
+    return content.length;
+  }
+  if (first === "{" || first === "[") {
+    const stack = [];
+    let inStr = false;
+    let escaping = false;
+    for (let j = start; j < content.length; j++) {
+      const c = content[j];
+      if (inStr) {
+        if (escaping) {
+          escaping = false;
+          continue;
+        }
+        if (c === "\\") {
+          escaping = true;
+          continue;
+        }
+        if (c === '"') inStr = false;
+        continue;
+      }
+      if (c === '"') {
+        inStr = true;
+        continue;
+      }
+      if (c === "{" || c === "[") stack.push(c);
+      else if (c === "}" || c === "]") {
+        const open = stack.pop();
+        if (open !== (c === "}" ? "{" : "[")) return j;
+        if (stack.length === 0) return j + 1;
+      }
+    }
+    return content.length;
+  }
+  for (let j = start; j < content.length; j++) {
+    const c = content[j];
+    if (c === "," || c === "}" || c === "]" || c === "\n" || c === "\r") return j;
+  }
+  return content.length;
+}
+function countNewlines(s) {
+  let n = 0;
+  for (let i = 0; i < s.length; i++) if (s[i] === "\n") n++;
+  return n;
+}
+function extractMarkdownSymbols(content, filePath) {
+  const out = [];
+  const lines2 = content.split(/\r?\n/);
+  const unfenced = Array.from(eachUnfencedLine(lines2));
+  for (let u = 0; u < unfenced.length; u++) {
+    const [i, line] = unfenced[u];
+    const atxMatch = /^(#{1,6})\s+(.+?)(?:\s+#+\s*)?$/.exec(line);
+    if (atxMatch !== null && atxMatch[2] !== void 0) {
+      const name = atxMatch[2].trim();
+      if (name !== "") {
+        out.push({
+          filePath,
+          name,
+          kind: "heading",
+          lineStart: i + 1,
+          lineEnd: i + 1,
+          body: line.trim(),
+          docstring: "",
+          parent: ""
+        });
+      }
+      continue;
+    }
+    const trimmed = line.trim();
+    if (trimmed !== "" && !trimmed.startsWith("#") && !trimmed.startsWith("|") && !trimmed.startsWith("```") && !trimmed.startsWith("~~~") && !/^([-*+]|\d+\.)\s/.test(trimmed) && u + 1 < unfenced.length) {
+      const [nextIdx, nextLine] = unfenced[u + 1];
+      if (nextIdx === i + 1) {
+        const isUnderline = /^\s*(=+|-+)\s*$/.test(nextLine);
+        if (isUnderline) {
+          out.push({
+            filePath,
+            name: trimmed,
+            kind: "heading",
+            lineStart: i + 1,
+            lineEnd: i + 2,
+            body: `${trimmed}
+${nextLine.trim()}`,
+            docstring: "",
+            parent: ""
+          });
+          u++;
+        }
+      }
+    }
+  }
+  return out;
+}
+function blankJsonComments(raw) {
+  const out = [];
+  let inStr = false;
+  let esc = false;
+  for (let i = 0; i < raw.length; i++) {
+    const ch = raw[i] ?? "";
+    if (inStr) {
+      out.push(ch);
+      if (esc) esc = false;
+      else if (ch === "\\") esc = true;
+      else if (ch === '"') inStr = false;
+      continue;
+    }
+    if (ch === '"') {
+      inStr = true;
+      out.push(ch);
+      continue;
+    }
+    if (ch === "/" && raw[i + 1] === "/") {
+      while (i < raw.length && raw[i] !== "\n") {
+        out.push(" ");
+        i++;
+      }
+      if (i < raw.length) out.push("\n");
+      continue;
+    }
+    if (ch === "/" && raw[i + 1] === "*") {
+      out.push("  ");
+      i += 2;
+      while (i < raw.length && !(raw[i] === "*" && raw[i + 1] === "/")) {
+        out.push(raw[i] === "\n" ? "\n" : " ");
+        i++;
+      }
+      if (i < raw.length) {
+        out.push("  ");
+        i++;
+      }
+      continue;
+    }
+    out.push(ch);
+  }
+  return out.join("");
+}
+function extractJsonSymbols(raw, filePath) {
+  const out = [];
+  const content = raw.includes("/") ? blankJsonComments(raw) : raw;
+  try {
+    let depth = 0;
+    let inString = false;
+    let escaping = false;
+    let strChars = [];
+    let strStartLine = 1;
+    let strStartOffset = 0;
+    let depthWhenStringOpened = 0;
+    let line = 1;
+    for (let i = 0; i < content.length; i++) {
+      const ch = content[i];
+      if (ch === void 0) continue;
+      if (ch === "\n") line++;
+      if (escaping) {
+        escaping = false;
+        if (inString) strChars.push(ch);
+        continue;
+      }
+      if (ch === "\\" && inString) {
+        escaping = true;
+        continue;
+      }
+      if (ch === '"') {
+        if (!inString) {
+          inString = true;
+          strChars = [];
+          strStartLine = line;
+          strStartOffset = i;
+          depthWhenStringOpened = depth;
+        } else {
+          inString = false;
+          let k = i + 1;
+          while (k < content.length && /\s/.test(content[k] ?? "")) {
+            k++;
+          }
+          if (content[k] === ":" && depthWhenStringOpened === 1) {
+            let v = k + 1;
+            while (v < content.length && /\s/.test(content[v] ?? "")) {
+              v++;
+            }
+            const valueEnd = scanJsonValueEnd(content, v);
+            const body = raw.slice(strStartOffset, valueEnd);
+            const lineEnd = strStartLine + countNewlines(body);
+            out.push({
+              filePath,
+              name: strChars.join(""),
+              kind: "property",
+              lineStart: strStartLine,
+              lineEnd,
+              body,
+              docstring: "",
+              parent: ""
+            });
+          }
+        }
+        continue;
+      }
+      if (inString) {
+        strChars.push(ch);
+        continue;
+      }
+      if (ch === "{" || ch === "[") depth++;
+      else if (ch === "}" || ch === "]") depth--;
+    }
+  } catch {
+  }
+  return out;
+}
+function yamlOpenQuoteAfter(line, startIdx) {
+  const value = line.slice(startIdx);
+  const trimmed = value.replace(/^\s+/, "");
+  const q = trimmed[0];
+  if (q !== '"' && q !== "'") return null;
+  if (q === '"') {
+    let j2 = 1;
+    while (j2 < trimmed.length) {
+      if (trimmed[j2] === "\\") {
+        j2 += 2;
+        continue;
+      }
+      if (trimmed[j2] === '"') return null;
+      j2++;
+    }
+    return '"';
+  }
+  let j = 1;
+  while (j < trimmed.length) {
+    if (trimmed[j] === "'" && trimmed[j + 1] === "'") {
+      j += 2;
+      continue;
+    }
+    if (trimmed[j] === "'") return null;
+    j++;
+  }
+  return "'";
+}
+function yamlLineClosesQuote(line, quote) {
+  let i = 0;
+  while (i < line.length) {
+    if (quote === '"') {
+      if (line[i] === "\\") {
+        i += 2;
+        continue;
+      }
+      if (line[i] === '"') return true;
+    } else {
+      if (line[i] === "'" && line[i + 1] === "'") {
+        i += 2;
+        continue;
+      }
+      if (line[i] === "'") return true;
+    }
+    i++;
+  }
+  return false;
+}
+function extractYamlSymbols(content, filePath) {
+  const out = [];
+  const lines2 = content.split(/\r?\n/);
+  let openQuote = null;
+  for (let i = 0; i < lines2.length; i++) {
+    const line = lines2[i];
+    if (line === void 0) continue;
+    if (openQuote !== null) {
+      if (yamlLineClosesQuote(line, openQuote)) openQuote = null;
+      continue;
+    }
+    const match = /^([a-zA-Z_][\w.-]*)\s*:(?!\/\/)/.exec(line);
+    if (match !== null && match[1] !== void 0) {
+      out.push({
+        filePath,
+        name: match[1],
+        kind: "key",
+        lineStart: i + 1,
+        lineEnd: i + 1,
+        body: line.trim(),
+        docstring: "",
+        parent: ""
+      });
+      openQuote = yamlOpenQuoteAfter(line, match[0].length);
+    }
+  }
+  return out;
+}
+function lineOpenDelimiterAfter(line, startIdx) {
+  let pos = startIdx;
+  let open = null;
+  for (; ; ) {
+    if (open === null) {
+      const dIdx = line.indexOf('"""', pos);
+      const sIdx = line.indexOf("'''", pos);
+      if (dIdx === -1 && sIdx === -1) return null;
+      if (dIdx !== -1 && (sIdx === -1 || dIdx <= sIdx)) {
+        open = '"""';
+        pos = dIdx + 3;
+      } else {
+        open = "'''";
+        pos = sIdx + 3;
+      }
+    } else {
+      const closeIdx = line.indexOf(open, pos);
+      if (closeIdx === -1) return open;
+      open = null;
+      pos = closeIdx + 3;
+    }
+  }
+}
+function stripTomlComment(line) {
+  let inBasic = false;
+  let inLiteral = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (inBasic) {
+      if (ch === "\\") i++;
+      else if (ch === '"') inBasic = false;
+      continue;
+    }
+    if (inLiteral) {
+      if (ch === "'") inLiteral = false;
+      continue;
+    }
+    if (ch === '"') inBasic = true;
+    else if (ch === "'") inLiteral = true;
+    else if (ch === "#") return line.slice(0, i);
+  }
+  return line;
+}
+function tomlBracketDelta(line) {
+  const stripped = stripStringLiterals(line);
+  let delta = 0;
+  for (const ch of stripped) {
+    if (ch === "[") delta++;
+    else if (ch === "]") delta--;
+  }
+  return delta;
+}
+var TOML_SIMPLE_KEY = `(?:[A-Za-z0-9_-]+|"(?:[^"\\\\]|\\\\.)*"|'[^']*')`;
+var TOML_KEY_RE = new RegExp(`^\\s*(${TOML_SIMPLE_KEY}(?:\\s*\\.\\s*${TOML_SIMPLE_KEY})*)\\s*=`);
+function extractTomlSymbols(content, filePath) {
+  const out = [];
+  const lines2 = content.split(/\r?\n/);
+  function matchLine2(line, lineNum) {
+    const sectionMatch = /^\s*\[\[?\s*([^\]]+)\s*\]/.exec(line);
+    if (sectionMatch !== null && sectionMatch[1] !== void 0) {
+      out.push({
+        filePath,
+        name: sectionMatch[1].trim(),
+        kind: "section",
+        lineStart: lineNum + 1,
+        lineEnd: lineNum + 1,
+        body: line.trim(),
+        docstring: "",
+        parent: ""
+      });
+    }
+    const keyMatch = TOML_KEY_RE.exec(line);
+    if (keyMatch !== null && keyMatch[1] !== void 0) {
+      out.push({
+        filePath,
+        name: keyMatch[1],
+        kind: "key",
+        lineStart: lineNum + 1,
+        lineEnd: lineNum + 1,
+        body: line.trim(),
+        docstring: "",
+        parent: ""
+      });
+    }
+  }
+  let openDelim = null;
+  let arrayDepth = 0;
+  for (let i = 0; i < lines2.length; i++) {
+    const line = lines2[i];
+    if (line === void 0) continue;
+    if (openDelim !== null) {
+      const closeIdx = line.indexOf(openDelim);
+      if (closeIdx === -1) continue;
+      const restStart = closeIdx + openDelim.length;
+      matchLine2(line.slice(restStart), i);
+      openDelim = lineOpenDelimiterAfter(stripTomlComment(line.slice(restStart)), 0);
+      continue;
+    }
+    if (arrayDepth > 0) {
+      arrayDepth = Math.max(0, arrayDepth + tomlBracketDelta(stripTomlComment(line)));
+      continue;
+    }
+    matchLine2(line, i);
+    const code = stripTomlComment(line);
+    openDelim = lineOpenDelimiterAfter(code, 0);
+    if (openDelim === null) arrayDepth = Math.max(0, tomlBracketDelta(code));
+  }
+  return out;
+}
+function splitTopLevelSelectors(rawCapture, strippedCapture) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < strippedCapture.length; i++) {
+    const ch = strippedCapture[i];
+    if (ch === "(") depth += 1;
+    else if (ch === ")") depth = Math.max(0, depth - 1);
+    else if (ch === "," && depth === 0) {
+      parts.push(rawCapture.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(rawCapture.slice(start));
+  return parts;
+}
+function nextContentLineOpensBrace(lines2, i) {
+  for (let j = i + 1; j < lines2.length; j++) {
+    const next = lines2[j]?.trim() ?? "";
+    if (next.length === 0) continue;
+    return next === "{";
+  }
+  return false;
+}
+function extractCssSymbols(content, filePath) {
+  const out = [];
+  const lines2 = stripCstyleComments(content).split(/\r?\n/);
+  const rawLines = content.split(/\r?\n/);
+  let pending = [];
+  for (let i = 0; i < lines2.length; i++) {
+    const line = lines2[i];
+    if (line === void 0) continue;
+    const trimmed = line.trim();
+    if (trimmed.length === 0 && (rawLines[i]?.trim().length ?? 0) > 0) {
+      continue;
+    }
+    const strippedLine = stripStringLiterals(line);
+    const selectorLineMatch = /^[ \t]*([^{}@][^{]*)\{/d.exec(strippedLine);
+    if (selectorLineMatch !== null && selectorLineMatch[1] !== void 0) {
+      for (const p of pending) {
+        out.push({
+          filePath,
+          name: p.name,
+          kind: "selector",
+          lineStart: p.line,
+          lineEnd: p.line,
+          body: p.body,
+          docstring: "",
+          parent: ""
+        });
+      }
+      pending = [];
+      const captureRange = selectorLineMatch.indices?.[1];
+      const rawCapture = captureRange ? line.slice(captureRange[0], captureRange[1]) : selectorLineMatch[1];
+      const strippedCapture = captureRange ? strippedLine.slice(captureRange[0], captureRange[1]) : selectorLineMatch[1];
+      for (const part of splitTopLevelSelectors(rawCapture, strippedCapture)) {
+        const name = part.trim();
+        if (name) {
+          out.push({
+            filePath,
+            name,
+            kind: "selector",
+            lineStart: i + 1,
+            lineEnd: i + 1,
+            body: line.trim(),
+            docstring: "",
+            parent: ""
+          });
+        }
+      }
+      continue;
+    }
+    if (trimmed === "{") {
+      for (const p of pending) {
+        out.push({
+          filePath,
+          name: p.name,
+          kind: "selector",
+          lineStart: p.line,
+          lineEnd: p.line,
+          body: p.body,
+          docstring: "",
+          parent: ""
+        });
+      }
+      pending = [];
+      continue;
+    }
+    if (trimmed.length > 0 && !trimmed.startsWith("@") && !trimmed.includes("{") && !trimmed.includes("}") && !trimmed.includes(";")) {
+      const endsWithComma = trimmed.endsWith(",");
+      if (endsWithComma || pending.length > 0 || nextContentLineOpensBrace(lines2, i)) {
+        const name = endsWithComma ? trimmed.slice(0, -1).trim() : trimmed;
+        if (name) pending.push({ name, line: i + 1, body: trimmed });
+        continue;
+      }
+    }
+    pending = [];
+  }
+  return out;
+}
+function extractDockerfileSymbols(content, filePath) {
+  const out = [];
+  const lines2 = content.split(/\r?\n/);
+  let continuing = false;
+  for (let i = 0; i < lines2.length; i++) {
+    const line = lines2[i];
+    if (line === void 0) continue;
+    if (continuing) {
+      continuing = line.trimEnd().endsWith("\\");
+      continue;
+    }
+    const isComment = line.trim().startsWith("#");
+    const match = isComment ? null : /^\s*(FROM|RUN|COPY|ADD|EXPOSE|ENV|WORKDIR|CMD|ENTRYPOINT|ARG|LABEL|VOLUME|USER|HEALTHCHECK|ONBUILD|SHELL|STOPSIGNAL|MAINTAINER)\s+(.+)/i.exec(
+      line
+    );
+    if (match !== null && match[1] !== void 0) {
+      const cmd = match[1];
+      const arg = (match[2] ?? "").substring(0, 40);
+      const name = `${cmd} ${arg}`.trim();
+      out.push({
+        filePath,
+        name,
+        kind: "directive",
+        lineStart: i + 1,
+        lineEnd: i + 1,
+        body: line.trim(),
+        docstring: "",
+        parent: ""
+      });
+    }
+    continuing = !isComment && line.trimEnd().endsWith("\\");
+  }
+  return out;
+}
+var FALLBACK_PATTERNS = [
+  // Python
+  { re: /^[ \t]*(?:async\s+)?def\s+([A-Za-z_]\w*)/, kind: "function", style: "hash" },
+  { re: /^[ \t]*class\s+([A-Za-z_]\w*)/, kind: "class", style: "hash" },
+  // TS/JS function & class declarations (optionally exported/async)
+  {
+    re: /^[ \t]*(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s*(?:\*\s*)?([A-Za-z_$][\w$]*)/,
+    kind: "function",
+    style: "c"
+  },
+  {
+    re: /^[ \t]*(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)/,
+    kind: "class",
+    style: "c"
+  },
+  { re: /^[ \t]*(?:export\s+)?interface\s+([A-Za-z_$][\w$]*)/, kind: "interface", style: "c" },
+  { re: /^[ \t]*(?:export\s+)?type\s+([A-Za-z_$][\w$]*)\s*=/, kind: "type", style: "c" },
+  // const/let/var bound to an arrow or function expression
+  {
+    re: /^[ \t]*(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>/,
+    kind: "function",
+    style: "c"
+  },
+  // Rust / Go function & struct/type patterns
+  { re: /^[ \t]*(?:pub\s+)?(?:async\s+)?fn\s+([A-Za-z_]\w*)/, kind: "function", style: "c" },
+  { re: /^[ \t]*(?:pub\s+)?struct\s+([A-Za-z_]\w*)/, kind: "struct", style: "c" },
+  { re: /^[ \t]*func\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)/, kind: "function", style: "c" }
+];
+function extractWithRegex(content, filePath) {
+  const out = [];
+  const lines2 = content.split(/\r?\n/);
+  for (let i = 0; i < lines2.length; i++) {
+    const line = lines2[i];
+    if (line === void 0) continue;
+    for (const { re, kind, style } of FALLBACK_PATTERNS) {
+      const m = re.exec(line);
+      if (m !== null && m[1] !== void 0) {
+        out.push({
+          filePath,
+          name: m[1],
+          kind,
+          lineStart: i + 1,
+          lineEnd: i + 1,
+          body: line.trim(),
+          docstring: precedingDocComment(lines2, i + 1, style),
+          parent: ""
+        });
+        break;
+      }
+    }
+  }
+  return out;
+}
+
+// src/parser.ts
+var _require2 = createRequire2(import.meta.url);
+var COMPILER_ARTIFACT_REF_NAMES = /* @__PURE__ */ new Set(["__name"]);
+var REF_LANGUAGES = /* @__PURE__ */ new Set([
+  "typescript",
+  "javascript",
+  "python",
+  "go",
+  "rust",
+  "java",
+  "c",
+  "cpp",
+  "ruby"
+]);
+var _parserCtor;
+var _parserCtorError = null;
+var _parserCtorOverride = void 0;
+var _parserCtorErrorOverride = void 0;
+var _grammarCache = /* @__PURE__ */ new Map();
+function loadParserCtor() {
+  if (_parserCtorOverride !== void 0) return _parserCtorOverride;
+  if (_parserCtor !== void 0) return _parserCtor;
+  try {
+    _parserCtor = _require2("tree-sitter");
+  } catch (e) {
+    _parserCtor = null;
+    _parserCtorError = e instanceof Error ? e : new Error(String(e));
+  }
+  return _parserCtor;
+}
+function treeSitterCoreAvailable() {
+  return loadParserCtor() !== null;
+}
+function treeSitterCoreLoadError() {
+  return _parserCtorErrorOverride !== void 0 ? _parserCtorErrorOverride : _parserCtorError;
+}
+var CPP_HEADER_SNIFF_RE = /\bclass\s+\w|\bnamespace\s+\w|\btemplate\s*<|::\s*\w|\b(?:public|private|protected)\s*:/;
+var MAX_SYMBOL_BODY_CHARS = SYMBOL_BODY_CHAR_CAP;
+function boundSymbolBody(body) {
+  return body.length > MAX_SYMBOL_BODY_CHARS ? "" : body;
+}
+var MAX_SYMBOL_DOCSTRING_CHARS = 16 * 1024;
+var DOCSTRING_TRUNCATION_MARKER = "\n[... docstring truncated by token-goat ...]";
+function boundSymbolDocstring(docstring) {
+  if (docstring.length <= MAX_SYMBOL_DOCSTRING_CHARS) return docstring;
+  let end = MAX_SYMBOL_DOCSTRING_CHARS - DOCSTRING_TRUNCATION_MARKER.length;
+  const cutsSurrogatePair = end > 0 && docstring.charCodeAt(end - 1) >= 55296 && docstring.charCodeAt(end - 1) <= 56319;
+  if (cutsSurrogatePair) end -= 1;
+  return docstring.slice(0, Math.max(0, end)) + DOCSTRING_TRUNCATION_MARKER;
+}
+function loadGrammar(lang, filePath, content) {
+  const useTsx = lang === "typescript" && filePath !== void 0 && path4.extname(filePath).toLowerCase() === ".tsx";
+  const useCppHeader = lang === "c" && filePath !== void 0 && path4.extname(filePath).toLowerCase() === ".h" && content !== void 0 && CPP_HEADER_SNIFF_RE.test(content);
+  const cacheKey = useTsx ? "typescript:tsx" : useCppHeader ? "c:cpp-header" : lang;
+  const cached = _grammarCache.get(cacheKey);
+  if (cached !== void 0) return cached;
+  let grammar = null;
+  try {
+    if (lang === "typescript") {
+      const mod = _require2("tree-sitter-typescript");
+      grammar = useTsx ? mod.tsx : mod.typescript;
+    } else if (lang === "javascript") {
+      grammar = _require2("tree-sitter-javascript");
+    } else if (lang === "python") {
+      grammar = _require2("tree-sitter-python");
+    } else if (lang === "go") {
+      grammar = _require2("tree-sitter-go");
+    } else if (lang === "rust") {
+      grammar = _require2("tree-sitter-rust");
+    } else if (lang === "ruby") {
+      grammar = _require2("tree-sitter-ruby");
+    } else if (lang === "java") {
+      grammar = _require2("tree-sitter-java");
+    } else if (lang === "c") {
+      grammar = useCppHeader ? _require2("tree-sitter-cpp") : _require2("tree-sitter-c");
+    } else if (lang === "cpp") {
+      grammar = _require2("tree-sitter-cpp");
+    }
+  } catch {
+    grammar = null;
+  }
+  _grammarCache.set(cacheKey, grammar);
+  return grammar;
+}
+function isTreeSitterAvailable(lang) {
+  if (!TREE_SITTER_LANGUAGES.includes(lang)) return false;
+  return loadParserCtor() !== null && loadGrammar(lang) !== null;
+}
+var TREE_SITTER_GRAMMAR_PACKAGES = [
+  "tree-sitter-typescript",
+  "tree-sitter-javascript",
+  "tree-sitter-python",
+  "tree-sitter-go",
+  "tree-sitter-rust",
+  "tree-sitter-ruby",
+  "tree-sitter-java",
+  "tree-sitter-c",
+  "tree-sitter-cpp"
+];
+function missingTreeSitterGrammarPackages() {
+  return TREE_SITTER_GRAMMAR_PACKAGES.filter((pkg) => {
+    try {
+      _require2.resolve(pkg);
+      return false;
+    } catch {
+      return true;
+    }
+  });
+}
+function isLwcFile(filePath, extension) {
+  const normalized = filePath.replace(/\\/g, "/");
+  return /\/lwc\/[^/]+\/[^/]+$/i.test(normalized) && normalized.toLowerCase().endsWith(extension);
+}
+function mergeParseResults(...results) {
+  const symbols = [];
+  const refs = [];
+  const seenSymbols = /* @__PURE__ */ new Set();
+  const seenRefs = /* @__PURE__ */ new Set();
+  for (const result of results) {
+    for (const entry of result.symbols) {
+      const key = `${entry.filePath}\0${entry.name}\0${entry.kind}\0${entry.lineStart}`;
+      if (seenSymbols.has(key)) continue;
+      seenSymbols.add(key);
+      symbols.push(entry);
+    }
+    for (const entry of result.refs) {
+      const key = `${entry.filePath}\0${entry.name}\0${entry.line}\0${entry.col}`;
+      if (seenRefs.has(key)) continue;
+      seenRefs.add(key);
+      refs.push(entry);
+    }
+  }
+  return { symbols, refs };
+}
+function parseContent(content, filePath, language) {
+  if (content.charCodeAt(0) === 65279) {
+    content = content.slice(1);
+  }
+  if (language === "ipynb") {
+    const virtual = ipynbToVirtualSource(content);
+    if (virtual.cellLanguage === null) return { symbols: [], refs: [] };
+    return parseContent(virtual.content, filePath, "python");
+  }
+  const viaTreeSitter = parseWithTreeSitter(content, filePath, language);
+  if (viaTreeSitter !== null) return viaTreeSitter;
+  return extractNoTreeSitter(content, filePath, language);
+}
+function parseWithTreeSitter(content, filePath, language) {
+  if (!isTreeSitterAvailable(language)) return null;
+  try {
+    const Ctor = loadParserCtor();
+    const grammar = loadGrammar(language, filePath, content);
+    if (Ctor === null || grammar === null) return null;
+    const parser = new Ctor();
+    parser.setLanguage(grammar);
+    const tree = parser.parse(content);
+    const root = tree.rootNode;
+    let symbols;
+    if (language === "python") {
+      symbols = extractPythonSymbols(root, filePath);
+    } else if (language === "go") {
+      symbols = extractGoSymbols(root, filePath, content.split(/\r?\n/));
+    } else if (language === "rust") {
+      symbols = extractRustSymbols(root, filePath, content.split(/\r?\n/));
+    } else if (language === "ruby") {
+      symbols = extractRubySymbols(root, filePath, content.split(/\r?\n/));
+    } else if (language === "java") {
+      symbols = extractJavaSymbols(root, filePath, content.split(/\r?\n/));
+    } else if (language === "cpp" || language === "c") {
+      symbols = extractCppSymbols(root, filePath, content.split(/\r?\n/));
+    } else {
+      symbols = extractTsJsSymbols(root, filePath, content.split(/\r?\n/));
+    }
+    const refs = REF_LANGUAGES.has(language) ? extractRefs(root, filePath, language) : [];
+    const parsed = { symbols, refs };
+    return language === "javascript" && isLwcFile(filePath, ".js") ? mergeParseResults(parsed, extractLwcJavaScript(content, filePath)) : parsed;
+  } catch {
+    return null;
+  }
+}
+function parseSourceSymbolsTreeSitterOnly(content, filePath, language) {
+  const text = content.charCodeAt(0) === 65279 ? content.slice(1) : content;
+  const parsed = parseWithTreeSitter(text, filePath, language);
+  return parsed === null ? null : parsed.symbols;
+}
+var REGEX_ADAPTERS_SLOT = /* @__PURE__ */ Symbol.for("token-goat.regex-adapters");
+var adapterSlot = globalThis;
+async function loadRegexExtractors() {
+  adapterSlot[REGEX_ADAPTERS_SLOT] ??= await import("./token-goat-chunk-GIIHUSZX.mjs");
+}
+function regexAdapters() {
+  const loaded = adapterSlot[REGEX_ADAPTERS_SLOT];
+  if (loaded === void 0) throw new Error("token-goat: the regex language adapters are not loaded; await loadRegexExtractors() before parsing");
+  return loaded;
+}
+var noTreeSitterTable;
+function noTreeSitterExtractors() {
+  noTreeSitterTable ??= {
+    markdown: extractMarkdownSymbols,
+    json: extractJsonSymbols,
+    yaml: extractYamlSymbols,
+    toml: extractTomlSymbols,
+    css: extractCssSymbols,
+    dockerfile: extractDockerfileSymbols,
+    ...regexAdapters().ADAPTER_EXTRACTORS
+  };
+  return noTreeSitterTable;
+}
+function extractNoTreeSitter(content, filePath, language) {
+  const adapters = regexAdapters();
+  if (language === "salesforce_metadata") return adapters.extractSalesforceMetadata(content, filePath);
+  if (language === "salesforce_markup") return extractSalesforceMarkup(content, filePath);
+  if (language === "html" && isLwcFile(filePath, ".html")) {
+    const base = { symbols: adapters.ADAPTER_EXTRACTORS.html(content, filePath), refs: [] };
+    return mergeParseResults(base, extractLwcTemplate(content, filePath));
+  }
+  if (language === "vue") return adapters.extractVue(content, filePath);
+  if (language === "svelte") return adapters.extractSvelte(content, filePath);
+  if (language === "astro") return adapters.extractAstro(content, filePath);
+  if (language === "cobol") {
+    const r = adapters.extractCobol(content, filePath);
+    return { symbols: r.symbols, refs: r.refs };
+  }
+  if (language === "natural") {
+    const r = adapters.extractNatural(content, filePath);
+    return { symbols: r.symbols, refs: r.refs };
+  }
+  const parsed = {
+    symbols: extractSymbolsNoTreeSitter(content, filePath, language),
+    refs: []
+  };
+  return language === "javascript" && isLwcFile(filePath, ".js") ? mergeParseResults(parsed, extractLwcJavaScript(content, filePath)) : parsed;
+}
+function extractSymbolsNoTreeSitter(content, filePath, language) {
+  if (language === "unknown") return [];
+  return (noTreeSitterExtractors()[language] ?? extractWithRegex)(content, filePath);
+}
+function deleteFileRows(db, filePath) {
+  const folded = foldPath(filePath);
+  db.prepare(`DELETE FROM symbols WHERE ${pathEqClause("file_path")}`).run(folded);
+  db.prepare(`DELETE FROM refs WHERE ${pathEqClause("file_path")}`).run(folded);
+  db.prepare(`DELETE FROM files WHERE ${pathEqClause("path")}`).run(folded);
+}
+function isUnderSkipDir(filePath, skipDirs) {
+  if (skipDirs.length === 0) return false;
+  const segments = filePath.split(/[/\\]/);
+  return segments.slice(0, -1).some((seg) => skipDirs.includes(seg));
+}
+function isParseSkipEligible(filePath, cfg) {
+  if (isUnderSkipDir(filePath, cfg.skip_dirs)) return true;
+  if (cfg.skip_files.includes(path4.basename(filePath))) return true;
+  try {
+    const stat = fs2.statSync(filePath);
+    if (stat.size > cfg.large_file_skip_kb * 1024) return true;
+  } catch {
+  }
+  return false;
+}
+function writeParseResult(filePath, content, result, dbPath) {
+  const db = getDb(dbPath);
+  const sha = fingerprintContent(content);
+  const mtime = safeMtime(filePath);
+  const now = Date.now() / 1e3;
+  const priorRow = db.prepare(`SELECT sha, embed_sha FROM files WHERE ${pathEqClause("path")}`).get(foldPath(filePath));
+  const embedShaToCarry = priorRow !== void 0 && priorRow.sha === sha ? priorRow.embed_sha : null;
+  const writeAll = db.transaction(() => {
+    deleteFileRows(db, filePath);
+    db.prepare(
+      "INSERT INTO files (path, sha, mtime, language, indexed_at, parser_sha, embed_sha) VALUES (?, ?, ?, ?, ?, ?, ?)"
+    ).run(filePath, sha, mtime, result.language, now, PARSER_FINGERPRINT, embedShaToCarry);
+    const insSym = db.prepare(
+      "INSERT INTO symbols (file_path, name, kind, line_start, line_end, body, docstring, parent) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
+    );
+    for (const s of result.symbols) {
+      if (s.name === "" || s.kind === "") continue;
+      insSym.run(
+        s.filePath,
+        s.name,
+        s.kind,
+        s.lineStart,
+        s.lineEnd,
+        boundSymbolBody(s.body),
+        boundSymbolDocstring(s.docstring),
+        s.parent
+      );
+    }
+    const insRef = db.prepare(
+      "INSERT INTO refs (file_path, name, line, col, context) VALUES (?, ?, ?, ?, ?)"
+    );
+    for (const r of result.refs) {
+      if (r.name === "" || COMPILER_ARTIFACT_REF_NAMES.has(r.name)) continue;
+      insRef.run(r.filePath, r.name, r.line, r.col, r.context);
+    }
+  });
+  writeAll.immediate();
+}
+function indexFileSync(rawPath, dbPath = globalDbPath(), preReadBytes) {
+  const filePath = canonicalizeIndexPath(rawPath);
+  const ixCfg = loadConfig().indexing;
+  if (ixCfg !== void 0 && isParseSkipEligible(filePath, ixCfg)) {
+    const db = getDb(dbPath);
+    deleteFileRows(db, filePath);
+    deleteFileEmbeddings(db, filePath);
+    return;
+  }
+  const pathLanguage = detectLanguage(filePath);
+  let raw;
+  if (preReadBytes !== void 0) {
+    raw = preReadBytes;
+  } else {
+    try {
+      raw = fs2.readFileSync(filePath);
+    } catch (err) {
+      if (err.code === "ENOENT") return;
+      throw err;
+    }
+  }
+  const content = decodeSource(raw);
+  const language = refineLanguageByContent(filePath, pathLanguage, content);
+  const { symbols, refs } = parseContent(content, filePath, language);
+  writeParseResult(filePath, raw, { symbols, refs, language, duration: 0 }, dbPath);
+}
+var DISABLED_EMBED_SHA_PREFIX = "disabled:";
+function disabledEmbedSha(sha) {
+  return DISABLED_EMBED_SHA_PREFIX + sha;
+}
+var UNAVAILABLE_EMBED_SHA_PREFIX = "unavailable:";
+function unavailableEmbedSha(sha) {
+  return UNAVAILABLE_EMBED_SHA_PREFIX + sha;
+}
+var OVERSIZE_EMBED_SHA_PREFIX = "oversize:";
+function oversizeEmbedSha(sha, symbolOnlyKb) {
+  return `${OVERSIZE_EMBED_SHA_PREFIX}${symbolOnlyKb}:${sha}`;
+}
+var TIMEOUT_EMBED_SHA_PREFIX = "timeout:";
+function timeoutEmbedSha(sha, workMillis) {
+  return `${TIMEOUT_EMBED_SHA_PREFIX}${workMillis}:${sha}`;
+}
+function canonicalizeIndexPath(absPath) {
+  if (!isCaseInsensitiveFs()) return absPath;
+  let real;
+  try {
+    real = fs2.realpathSync.native(absPath);
+  } catch {
+    return absPath;
+  }
+  const cut = Math.max(absPath.lastIndexOf("/"), absPath.lastIndexOf("\\"));
+  const base = absPath.slice(cut + 1);
+  const realNorm = normalizePath(real);
+  const realBase = path4.basename(realNorm);
+  if (base === realBase) return absPath;
+  if (foldPath(base) !== foldPath(realBase)) return absPath;
+  const callerDir = cut < 0 ? normalizePath(path4.resolve(".")) : normalizePath(absPath.slice(0, cut));
+  if (foldPath(callerDir) !== foldPath(path4.dirname(realNorm))) return absPath;
+  return absPath.slice(0, cut + 1) + realBase;
+}
+function indexedPathSpellingIsStale(storedPath, absPath) {
+  if (!isCaseInsensitiveFs()) return false;
+  const stored = normalizePath(storedPath);
+  const candidate = normalizePath(path4.resolve(absPath));
+  if (foldPath(stored) !== foldPath(candidate)) return false;
+  let real;
+  try {
+    real = normalizePath(fs2.realpathSync.native(absPath));
+  } catch {
+    return false;
+  }
+  if (real === stored) return false;
+  if (foldPath(real) !== foldPath(stored)) return false;
+  const storedSegments = stored.split("/");
+  const realSegments = real.split("/");
+  if (storedSegments.length !== realSegments.length) return real !== stored;
+  const storedBase = storedSegments[storedSegments.length - 1];
+  const realBase = realSegments[realSegments.length - 1];
+  if (storedBase !== realBase) return true;
+  for (let i = storedSegments.length - 2; i >= 0; i--) {
+    if (storedSegments[i] !== realSegments[i]) {
+      if (storedSegments.slice(0, i + 1).join("/") === candidate.split("/").slice(0, i + 1).join("/")) {
+        continue;
+      }
+      return true;
+    }
+  }
+  return false;
+}
+function isEmbedFresh(storedEmbedSha, sha, embeddingsEnabled, depsAvailable, symbolOnlyKb) {
+  if (storedEmbedSha === void 0) return false;
+  if (!embeddingsEnabled) return storedEmbedSha === disabledEmbedSha(sha);
+  if (storedEmbedSha === sha) return true;
+  if (!depsAvailable && storedEmbedSha === unavailableEmbedSha(sha)) return true;
+  if (storedEmbedSha === oversizeEmbedSha(sha, symbolOnlyKb)) return true;
+  if (storedEmbedSha === timeoutEmbedSha(sha, MAX_DOCUMENT_WORK_MILLIS)) return true;
+  return false;
+}
+async function indexFileEmbeddings(rawPath, dbPath = globalDbPath(), sha, onError) {
+  const filePath = canonicalizeIndexPath(rawPath);
+  const ixCfg = loadConfig().indexing;
+  if (!ixCfg.embeddings_enabled) {
+    stampEmbedSha(getDb(dbPath), filePath, sha, disabledEmbedSha);
+    return;
+  }
+  if (filePath.toLowerCase().endsWith(".profile-meta.xml")) {
+    const db = getDb(dbPath);
+    deleteFileEmbeddings(db, filePath);
+    stampEmbedSha(db, filePath, sha, (s) => s);
+    return;
+  }
+  if (isEmbeddableDocument(filePath)) {
+    let extracted;
+    let refusedOnTheClock = false;
+    try {
+      extracted = await extractEmbeddableDocumentText(filePath);
+    } catch (err) {
+      if (!isDocumentRefusal(err)) {
+        onError?.(err);
+        return;
+      }
+      refusedOnTheClock = isTransientDocumentRefusal(err);
+      extracted = null;
+    }
+    if (extracted === null || extracted.trim().length === 0) {
+      const db = getDb(dbPath);
+      deleteFileEmbeddings(db, filePath);
+      stampEmbedSha(db, filePath, sha, (s) => refusedOnTheClock ? timeoutEmbedSha(s, MAX_DOCUMENT_WORK_MILLIS) : s);
+      return;
+    }
+    if (extracted.length > ixCfg.large_file_symbol_only_kb * 1024) {
+      const db = getDb(dbPath);
+      deleteFileEmbeddings(db, filePath);
+      stampEmbedSha(db, filePath, sha, (s) => oversizeEmbedSha(s, ixCfg.large_file_symbol_only_kb));
+      return;
+    }
+    try {
+      const db = getDb(dbPath);
+      const outcome = await indexFile(db, filePath, extracted, []);
+      stampEmbedSha(db, filePath, sha, (s) => outcome === "unavailable" ? unavailableEmbedSha(s) : s);
+    } catch (err) {
+      onError?.(err);
+    }
+    return;
+  }
+  let content;
+  try {
+    content = decodeSource(await fs2.promises.readFile(filePath));
+  } catch {
+    return;
+  }
+  content = redactIfDotenv(filePath, content);
+  if (detectLanguage(filePath) === "ipynb") {
+    const virtual = ipynbToVirtualSource(content);
+    if (virtual.cellLanguage === null) {
+      const db = getDb(dbPath);
+      deleteFileEmbeddings(db, filePath);
+      stampEmbedSha(db, filePath, sha, (s) => s);
+      return;
+    }
+    content = virtual.content;
+  }
+  if (content.length > ixCfg.large_file_symbol_only_kb * 1024) {
+    const db = getDb(dbPath);
+    deleteFileEmbeddings(db, filePath);
+    stampEmbedSha(db, filePath, sha, (s) => oversizeEmbedSha(s, ixCfg.large_file_symbol_only_kb));
+    return;
+  }
+  if (detectLanguage(filePath) === "salesforce_metadata" && content.length > 512 * 1024) {
+    const db = getDb(dbPath);
+    deleteFileEmbeddings(db, filePath);
+    stampEmbedSha(db, filePath, sha, (s) => s);
+    return;
+  }
+  try {
+    const db = getDb(dbPath);
+    const boundaries = buildEmbeddingBoundaries(filePath, content, dbPath);
+    const outcome = await indexFile(db, filePath, content, boundaries);
+    stampEmbedSha(db, filePath, sha, (s) => outcome === "unavailable" ? unavailableEmbedSha(s) : s);
+  } catch (err) {
+    onError?.(err);
+  }
+}
+function stampEmbedSha(db, filePath, sha, makeValue) {
+  if (sha === void 0) return;
+  db.prepare(`UPDATE files SET embed_sha = ? WHERE ${pathEqClause("path")} AND sha = ?`).run(
+    makeValue(sha),
+    foldPath(filePath),
+    sha
+  );
+}
+function safeMtime(filePath) {
+  try {
+    return fs2.statSync(filePath).mtimeMs / 1e3;
+  } catch {
+    return 0;
+  }
+}
+
+// src/section_reader.ts
+init_define_import_meta_env();
+import { readFileSync as readFileSync3 } from "node:fs";
+function parseHeadingSpec(spec, headers) {
+  const m = /^([^#\r\n]+)#(\d+)$/.exec(spec);
+  if (m !== null && m[1] !== void 0 && m[2] !== void 0) {
+    const specLower = spec.trim().toLowerCase();
+    const isLiteralHeading = headers?.some((h) => h.heading.trim().toLowerCase() === specLower) ?? false;
+    if (isLiteralHeading) {
+      return { base: spec.trim(), ordinal: null };
+    }
+    return { base: m[1].trim(), ordinal: Number.parseInt(m[2], 10) };
+  }
+  return { base: spec.trim(), ordinal: null };
+}
+function normalizeHeading(s) {
+  let n = s.replace(/[—–]/g, "-");
+  n = n.replace(/\s*\([^)]+\)\s*$/, "");
+  n = n.replace(/^\d+\.\s+/, "");
+  return n.replace(/\s+/g, " ").trim();
+}
+function normalizeHeadingStrip(s) {
+  let n = s.replace(/\s*[—–].*$/, "");
+  n = n.replace(/\s*\([^)]+\)\s*$/, "");
+  n = n.replace(/^\d+\.\s+/, "");
+  return n.replace(/\s+/g, " ").trim();
+}
+var MIN_WIDEN_WORD_LEN = 3;
+var MARKDOWN_HEADER_RE = /^(#{1,6})\s+([^\r\n]+?)(?:\s+#+)?\s*$/;
+var TABLE_HEADER_RE = /^\s*\[+\s*([^\]]+?)\s*\]+\s*(?:[#;].*)?$/;
+var PYTHON_HEADER_RE = /^(\s*)(?:async\s+)?(?:def|class)\s+([A-Za-z_]\w*)/;
+var KEYVALUE_HEADER_RE = /^([A-Za-z_][\w.-]*)\s*(?:=|:(?!\/\/))/;
+var ENV_KEYVALUE_HEADER_RE = /^(?:export\s+)?([A-Za-z_][\w.-]*)\s*(?:=|:(?!\/\/))/;
+function findMarkdownHeaders(lines2) {
+  const headers = [];
+  const unfenced = Array.from(eachUnfencedLine(lines2));
+  for (let u = 0; u < unfenced.length; u++) {
+    const [i, line] = unfenced[u];
+    const m = MARKDOWN_HEADER_RE.exec(line);
+    if (m !== null && m[1] !== void 0 && m[2] !== void 0) {
+      headers.push({ heading: m[2].trim(), level: m[1].length, index: i });
+      continue;
+    }
+    const trimmed = line.trim();
+    if (trimmed !== "" && !trimmed.startsWith("#") && !trimmed.startsWith("|") && !trimmed.startsWith("```") && !trimmed.startsWith("~~~") && !/^([-*+]|\d+\.)\s/.test(trimmed) && u + 1 < unfenced.length) {
+      const [nextIdx, nextLine] = unfenced[u + 1];
+      if (nextIdx === i + 1) {
+        const eqMatch = /^\s*(=+)\s*$/.exec(nextLine);
+        const dashMatch = /^\s*(-+)\s*$/.exec(nextLine);
+        if (eqMatch !== null) {
+          headers.push({ heading: trimmed, level: 1, index: i });
+          u++;
+          continue;
+        } else if (dashMatch !== null) {
+          headers.push({ heading: trimmed, level: 2, index: i });
+          u++;
+          continue;
+        }
+      }
+    }
+  }
+  return headers;
+}
+function findTableHeaders(lines2, isToml) {
+  const headers = [];
+  let openDelim = null;
+  let arrayDepth = 0;
+  for (let i = 0; i < lines2.length; i++) {
+    const line = lines2[i];
+    if (line === void 0) continue;
+    if (openDelim !== null) {
+      const closeIdx = line.indexOf(openDelim);
+      if (closeIdx === -1) continue;
+      const restStart = closeIdx + openDelim.length;
+      const m2 = TABLE_HEADER_RE.exec(line.slice(restStart));
+      if (m2 !== null && m2[1] !== void 0) headers.push({ heading: m2[1].trim(), level: 1, index: i });
+      openDelim = lineOpenDelimiterAfter(stripTomlComment(line.slice(restStart)), 0);
+      continue;
+    }
+    if (isToml && arrayDepth > 0) {
+      arrayDepth = Math.max(0, arrayDepth + tomlBracketDelta(stripTomlComment(line)));
+      continue;
+    }
+    const m = TABLE_HEADER_RE.exec(line);
+    if (m !== null && m[1] !== void 0) headers.push({ heading: m[1].trim(), level: 1, index: i });
+    if (isToml) {
+      const code = stripTomlComment(line);
+      openDelim = lineOpenDelimiterAfter(code, 0);
+      if (openDelim === null) arrayDepth = Math.max(0, tomlBracketDelta(code));
+    }
+  }
+  return headers;
+}
+var VB_REGION_RE = /^\s*#\s*Region\s+"((?:[^"]|"")*)"/i;
+var VB_END_REGION_RE = /^\s*#\s*End\s+Region\b/i;
+function extractShellBannerHeading(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("#")) return null;
+  if (trimmed.startsWith("#!")) return null;
+  const mdMatch = /^(#{2,6})[^\S\r\n]+(\S(?:.*?\S)?)(?:[^\S\r\n]+#+)?$/.exec(trimmed);
+  if (mdMatch && mdMatch[1] && mdMatch[2]) {
+    const text = mdMatch[2].trim();
+    if (text && !/^[-=]+$/.test(text)) {
+      return { heading: text, level: mdMatch[1].length };
+    }
+  }
+  const ruleMatch = /^#\s*[-=]{2,}\s*(\S(?:.*?\S)?)\s*[-=]{2,}$/.exec(trimmed);
+  if (ruleMatch && ruleMatch[1]) {
+    const text = ruleMatch[1].trim();
+    if (text && !/^[-=]+$/.test(text)) {
+      return { heading: text, level: 1 };
+    }
+  }
+  const bracketMatch = /^#\s*\[([a-zA-Z0-9_.\-\s]+)\]$/.exec(trimmed);
+  if (bracketMatch && bracketMatch[1]) {
+    const text = bracketMatch[1].trim();
+    if (text) {
+      return { heading: text, level: 1 };
+    }
+  }
+  const regionMatch = /^#\s*(?:REGION|SECTION):\s*(\S.*)$/i.exec(trimmed);
+  if (regionMatch && regionMatch[1]) {
+    const text = regionMatch[1].trim();
+    if (text) {
+      return { heading: text, level: 1 };
+    }
+  }
+  return null;
+}
+function findShellBannerHeaders(lines2) {
+  const headers = [];
+  for (let i = 0; i < lines2.length; i++) {
+    const line = lines2[i] ?? "";
+    const banner = extractShellBannerHeading(line);
+    if (banner !== null) {
+      headers.push({ heading: banner.heading, level: banner.level, index: i });
+    }
+  }
+  return headers;
+}
+function findVbRegionHeaders(lines2) {
+  const headers = [];
+  const open = [];
+  for (let i = 0; i < lines2.length; i++) {
+    const line = lines2[i] ?? "";
+    const m = VB_REGION_RE.exec(line);
+    if (m !== null) {
+      open.push(headers.length);
+      headers.push({ heading: (m[1] ?? "").replace(/""/g, '"'), level: open.length, index: i });
+      continue;
+    }
+    if (VB_END_REGION_RE.test(line)) {
+      const pos = open.pop();
+      const h = pos === void 0 ? void 0 : headers[pos];
+      if (pos !== void 0 && h !== void 0) headers[pos] = { ...h, endIndex: i + 1 };
+    }
+  }
+  return headers;
+}
+function headerEndIndex(headers, kind, headerPos, totalLines) {
+  const explicit = headers[headerPos]?.endIndex;
+  if (explicit !== void 0) return explicit;
+  return kind === "table-toml" ? tableSectionEndIndex(headers, headerPos, totalLines) : sectionEndIndex(headers, headerPos, totalLines);
+}
+function findPythonHeaders(lines2) {
+  const headers = [];
+  const indentStack = [];
+  let openDelim = null;
+  for (let i = 0; i < lines2.length; i++) {
+    const line = lines2[i];
+    if (line === void 0) continue;
+    if (openDelim !== null) {
+      const closeIdx = line.indexOf(openDelim);
+      if (closeIdx === -1) continue;
+      openDelim = lineOpenDelimiterAfter(line, closeIdx + openDelim.length);
+      continue;
+    }
+    const m = PYTHON_HEADER_RE.exec(line);
+    if (m === null || m[1] === void 0 || m[2] === void 0) {
+      openDelim = lineOpenDelimiterAfter(line, 0);
+      continue;
+    }
+    const indent = m[1].replace(/\t/g, "    ").length;
+    while (indentStack.length > 0 && indent <= (indentStack[indentStack.length - 1] ?? -1)) {
+      indentStack.pop();
+    }
+    const level = indentStack.length + 1;
+    indentStack.push(indent);
+    headers.push({ heading: m[2], level, index: i });
+    openDelim = lineOpenDelimiterAfter(line, 0);
+  }
+  return headers;
+}
+function findKeyValueHeaders(lines2, language) {
+  const headers = [];
+  const isEnv = language === "env_file";
+  let openQuote = null;
+  for (let i = 0; i < lines2.length; i++) {
+    const line = lines2[i];
+    if (line === void 0) continue;
+    if (openQuote !== null) {
+      const closed = isEnv ? _lineClosesQuote(line, openQuote) : yamlLineClosesQuote(line, openQuote);
+      if (closed) openQuote = null;
+      continue;
+    }
+    const scanned = isEnv ? line.replace(/^[ \t]+/, "") : line;
+    const m = (isEnv ? ENV_KEYVALUE_HEADER_RE : KEYVALUE_HEADER_RE).exec(scanned);
+    if (m === null || m[1] === void 0) continue;
+    headers.push({ heading: m[1], level: 1, index: i });
+    openQuote = isEnv ? _detectOpenQuote(scanned.slice(m[0].length)) : yamlOpenQuoteAfter(line, m[0].length);
+  }
+  return headers;
+}
+function findHtmlHeaders(text) {
+  const lineIndex = buildLineIndex(text);
+  const headers = [];
+  for (const hm of findHtmlHeadingMatches(text)) {
+    if (!hm.heading) continue;
+    const index = offsetToLine(lineIndex, hm.offset) - 1;
+    headers.push({ heading: hm.heading, level: hm.level, index });
+  }
+  return headers;
+}
+function findHeaders(text, language) {
+  const lines2 = text.split("\n");
+  if (language === "markdown") return { headers: findMarkdownHeaders(lines2), kind: "markdown" };
+  if (language === "html" || language === "liquid") return { headers: findHtmlHeaders(text), kind: "markdown" };
+  if (language === "toml") return { headers: findTableHeaders(lines2, true), kind: "table-toml" };
+  if (language === "python") return { headers: findPythonHeaders(lines2), kind: "python" };
+  if (language === "bash") {
+    const banners = findShellBannerHeaders(lines2);
+    if (banners.length > 0) return { headers: banners, kind: "banner" };
+  }
+  if (language === "vb") return { headers: findVbRegionHeaders(lines2), kind: "region" };
+  if (language === "ini") return { headers: findTableHeaders(lines2, false), kind: "table-flat" };
+  if (language === "yaml" || language === "env_file")
+    return { headers: findKeyValueHeaders(lines2, language), kind: "keyvalue" };
+  const md = findMarkdownHeaders(lines2);
+  if (md.length > 0) return { headers: md, kind: "markdown" };
+  const tbl = findTableHeaders(lines2, false);
+  if (tbl.length > 0) return { headers: tbl, kind: "table-toml" };
+  return { headers: findKeyValueHeaders(lines2, language), kind: "keyvalue" };
+}
+function sectionEndIndex(headers, headerPos, totalLines) {
+  const current = headers[headerPos];
+  if (current === void 0) return totalLines;
+  for (let j = headerPos + 1; j < headers.length; j++) {
+    const next = headers[j];
+    if (next === void 0) continue;
+    if (next.level <= current.level) return next.index;
+  }
+  return totalLines;
+}
+function tableSectionEndIndex(headers, headerPos, totalLines) {
+  const current = headers[headerPos];
+  if (current === void 0) return totalLines;
+  const prefix = current.heading + ".";
+  for (let j = headerPos + 1; j < headers.length; j++) {
+    const next = headers[j];
+    if (next === void 0) continue;
+    if (next.heading.startsWith(prefix)) continue;
+    return next.index;
+  }
+  return totalLines;
+}
+function resolveHeaderPos(headers, base, ordinal) {
+  const target = base.toLowerCase();
+  const normalizedTarget = normalizeHeading(base).toLowerCase();
+  const strippedTarget = normalizeHeadingStrip(base).toLowerCase();
+  const exactMatches = [];
+  const normalizedMatches = [];
+  const strippedMatches = [];
+  for (let i = 0; i < headers.length; i++) {
+    const h = headers[i];
+    if (h === void 0) continue;
+    const headingLower = h.heading.toLowerCase();
+    if (headingLower === target) {
+      exactMatches.push(i);
+    } else if (normalizeHeading(h.heading).toLowerCase() === normalizedTarget) {
+      normalizedMatches.push(i);
+    } else if (normalizeHeadingStrip(h.heading).toLowerCase() === strippedTarget) {
+      strippedMatches.push(i);
+    }
+  }
+  const matches = exactMatches.length > 0 ? exactMatches : normalizedMatches.length > 0 ? normalizedMatches : strippedMatches;
+  if (matches.length > 0) {
+    const pick = ordinal === null ? 0 : ordinal - 1;
+    const headerPos = matches[pick];
+    if (headerPos === void 0) return null;
+    let occurrences = null;
+    if (ordinal === null && matches.length > 1) {
+      occurrences = [];
+      for (const i of matches) {
+        const h = headers[i];
+        if (h !== void 0) occurrences.push(h.index + 1);
+      }
+    }
+    return { headerPos, redirectedFrom: null, occurrences };
+  }
+  if (ordinal !== null || normalizedTarget.length === 0) return null;
+  let prefixPos = -1;
+  const distinct = /* @__PURE__ */ new Set();
+  for (let i = 0; i < headers.length; i++) {
+    const h = headers[i];
+    if (h === void 0) continue;
+    const norm = normalizeHeading(h.heading).toLowerCase();
+    if (norm.startsWith(normalizedTarget)) {
+      distinct.add(norm);
+      if (prefixPos === -1) prefixPos = i;
+    }
+  }
+  if (distinct.size === 1 && prefixPos !== -1) {
+    const chosen = headers[prefixPos];
+    if (chosen === void 0) return null;
+    return { headerPos: prefixPos, redirectedFrom: base, occurrences: null };
+  }
+  const queryWords = normalizedTarget.split(/\s+/).filter((w) => w.length >= MIN_WIDEN_WORD_LEN);
+  if (queryWords.length === 0) return null;
+  const widenedMatches = [];
+  for (let i = 0; i < headers.length; i++) {
+    const h = headers[i];
+    if (h === void 0) continue;
+    const headingWords = normalizeHeading(h.heading).toLowerCase().split(/\s+/);
+    const allWordsMatch = queryWords.every((qw) => headingWords.some((hw) => hw.includes(qw)));
+    if (allWordsMatch) widenedMatches.push(i);
+  }
+  if (widenedMatches.length !== 1) return null;
+  const widenedPos = widenedMatches[0];
+  if (widenedPos === void 0) return null;
+  return { headerPos: widenedPos, redirectedFrom: base, occurrences: null };
+}
+function buildSectionResult(headers, kind, lines2, headerPos, redirectedFrom) {
+  const header = headers[headerPos];
+  if (header === void 0) return null;
+  const endIndex = headerEndIndex(headers, kind, headerPos, lines2.length);
+  let endExclusive = endIndex;
+  while (endExclusive > header.index + 1 && (lines2[endExclusive - 1] === "" || lines2[endExclusive - 1] === "\r")) {
+    endExclusive--;
+  }
+  const content = lines2.slice(header.index, endExclusive).join("\n");
+  const result = {
+    heading: header.heading,
+    content,
+    lineStart: header.index + 1,
+    lineEnd: endExclusive
+  };
+  return redirectedFrom === null ? result : { ...result, redirectedFrom };
+}
+function resolveSectionFromText(text, headingSpec, language) {
+  const { headers, kind } = findHeaders(text, language);
+  const { base, ordinal } = parseHeadingSpec(headingSpec, headers);
+  if (base.length === 0) return null;
+  const lines2 = text.split("\n");
+  const resolved = resolveHeaderPos(headers, base, ordinal);
+  if (resolved === null) return null;
+  const built = buildSectionResult(headers, kind, lines2, resolved.headerPos, resolved.redirectedFrom);
+  if (built === null || resolved.occurrences === null) return built;
+  return { ...built, occurrences: resolved.occurrences };
+}
+function extractSection(text, headingSpec) {
+  return resolveSectionFromText(text, headingSpec, "unknown");
+}
+function readTextForSections(filePath, readFn) {
+  let text;
+  if (readFn !== void 0) {
+    const read = readFn(filePath);
+    if (read === null) return null;
+    text = read;
+  } else {
+    try {
+      text = decodeSource(readFileSync3(filePath));
+    } catch {
+      return null;
+    }
+  }
+  if (text.charCodeAt(0) === 65279) {
+    text = text.slice(1);
+  }
+  return redactIfDotenv(filePath, text);
+}
+function readSection(filePath, headingSpec, readFn) {
+  const text = readTextForSections(filePath, readFn);
+  if (text === null) return null;
+  return resolveSectionFromText(text, headingSpec, refineLanguageByContent(filePath, detectLanguage(filePath), text));
+}
+function findContainingSection(filePath, lineStart, lineEnd, readFn) {
+  const text = readTextForSections(filePath, readFn);
+  if (text === null) return null;
+  const language = refineLanguageByContent(filePath, detectLanguage(filePath), text);
+  const { headers, kind } = findHeaders(text, language);
+  if (headers.length === 0) return null;
+  const lines2 = text.split("\n");
+  let bestPos = -1;
+  let bestHeaderLine = -1;
+  for (let i = 0; i < headers.length; i++) {
+    const header = headers[i];
+    if (header === void 0) continue;
+    const endIndex = headerEndIndex(headers, kind, i, lines2.length);
+    const sectionLineStart = header.index + 1;
+    if (sectionLineStart <= lineStart && lineEnd <= endIndex) {
+      if (header.index > bestHeaderLine) {
+        bestHeaderLine = header.index;
+        bestPos = i;
+      }
+    }
+  }
+  if (bestPos === -1) return null;
+  const result = buildSectionResult(headers, kind, lines2, bestPos, null);
+  if (result === null) return null;
+  const bestHeader = headers[bestPos];
+  if (bestHeader === void 0) return result;
+  const target = bestHeader.heading.toLowerCase();
+  const matches = [];
+  for (let i = 0; i < headers.length; i++) {
+    const h = headers[i];
+    if (h !== void 0 && h.heading.toLowerCase() === target) matches.push(i);
+  }
+  if (matches.length <= 1) return result;
+  const ordinal = matches.indexOf(bestPos) + 1;
+  return { ...result, heading: `${bestHeader.heading}#${ordinal}` };
+}
+function listSections(filePath, readFn) {
+  const text = readTextForSections(filePath, readFn);
+  if (text === null) return [];
+  const language = refineLanguageByContent(filePath, detectLanguage(filePath), text);
+  const { headers } = findHeaders(text, language);
+  return headers.map((h) => h.heading);
+}
+
+export {
+  isEmbeddableDocument,
+  ipynbToVirtualSource,
+  eachUnfencedLine,
+  checkEmbeddingPreflight,
+  OVER_FETCH_FACTOR,
+  MAX_OVER_FETCH,
+  isAvailable,
+  embeddingBackendLoadError,
+  embedTexts,
+  searchSemantic,
+  mergeNearbyHits,
+  embeddingsDepsAvailable,
+  deleteFileEmbeddings,
+  ensureEmbeddingProvenance,
+  MARKDOWN_SIZE_THRESHOLD,
+  extractMarkdownHeadings,
+  formatHeadingTreeParts,
+  getWellKnownSections,
+  extractChangelogVersionHint,
+  PARSER_FINGERPRINT,
+  treeSitterCoreAvailable,
+  treeSitterCoreLoadError,
+  isTreeSitterAvailable,
+  missingTreeSitterGrammarPackages,
+  parseSourceSymbolsTreeSitterOnly,
+  loadRegexExtractors,
+  deleteFileRows,
+  isParseSkipEligible,
+  indexFileSync,
+  indexedPathSpellingIsStale,
+  isEmbedFresh,
+  indexFileEmbeddings,
+  extractShellBannerHeading,
+  extractSection,
+  readSection,
+  findContainingSection,
+  listSections
+};