token-goat 2.9.29 → 2.9.30

package/dist/{token-goat-chunk-VMFWNHGR.mjs → token-goat-chunk-RHXKCZX3.mjs}

@@ -1,10 +1,19 @@
 import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
+  ATX_CLASS_BREAK_RE,
+  ATX_DOT_BREAK_RE,
+  matchAtxHeading,
+  matchCssSelectorSpan,
+  matchRuleBannerTitle,
+  matchTableHeaderName,
+  matchTomlSectionName
+} from "./token-goat-chunk-EVMZJ27Z.mjs";
+import {
+  ownProjectScope,
   pathEqClause,
-  projectScopeClause,
   querySymbols
-} from "./token-goat-chunk-435UQTKD.mjs";
+} from "./token-goat-chunk-HYBFA5X3.mjs";
 import {
   TREE_SITTER_LANGUAGES,
   _detectOpenQuote,
@@ -22,37 +31,38 @@ import {
   stripJsComments,
   stripStringLiterals,
   stripXmlComments
-} from "./token-goat-chunk-7CPMDFGB.mjs";
+} from "./token-goat-chunk-VL3YIFHZ.mjs";
 import {
+  findProject,
   fingerprintContent,
   loadConfig
-} from "./token-goat-chunk-TGOXNAHW.mjs";
+} from "./token-goat-chunk-7IN2MKDS.mjs";
 import {
   registerReset
 } from "./token-goat-chunk-YZAAZU2S.mjs";
+import {
+  DocumentRefusedError,
+  MAX_DOCUMENT_WORK_MILLIS
+} from "./token-goat-chunk-Y4AFKTHK.mjs";
 import {
   countContentLines,
   decodeSource,
   ensureDirSync
-} from "./token-goat-chunk-XYWPOSCN.mjs";
+} from "./token-goat-chunk-GOLEOXZP.mjs";
 import {
   foldPath,
   isCaseInsensitiveFs
-} from "./token-goat-chunk-TCQANXYC.mjs";
+} from "./token-goat-chunk-AM5V6GSX.mjs";
 import {
   displaySafeText,
   normalizePath
-} from "./token-goat-chunk-NMTKNYGF.mjs";
+} from "./token-goat-chunk-FNFBKLRD.mjs";
 import {
   SYMBOL_BODY_CHAR_CAP,
   dataDir,
   ensureDataDirPrivate,
   globalDbPath
-} from "./token-goat-chunk-MELOKFDJ.mjs";
-import {
-  DocumentRefusedError,
-  MAX_DOCUMENT_WORK_MILLIS
-} from "./token-goat-chunk-Y4AFKTHK.mjs";
+} from "./token-goat-chunk-VES7EL7O.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -74,28 +84,28 @@ function isTransientDocumentRefusal(err) {
 async function extractEmbeddableDocumentText(filePath) {
   switch (path.extname(filePath).toLowerCase()) {
     case ".pdf": {
-      const { extractPdfText, readPdfFileWithinBounds } = await import("./token-goat-chunk-YOOVFPTP.mjs");
+      const { extractPdfText, readPdfFileWithinBounds } = await import("./token-goat-chunk-W3QCJS6G.mjs");
       const { text } = await extractPdfText(await readPdfFileWithinBounds(filePath));
       return text;
     }
     case ".docx":
-      return await (await import("./token-goat-chunk-BGYOZ6DO.mjs")).docxText(filePath);
+      return await (await import("./token-goat-chunk-B45VMIIH.mjs")).docxText(filePath);
     case ".pptx":
-      return await (await import("./token-goat-chunk-LZNBQTDK.mjs")).pptxAllSlidesText(filePath, true);
+      return await (await import("./token-goat-chunk-WY3L4DVT.mjs")).pptxAllSlidesText(filePath, true);
     case ".xlsx":
-      return await (await import("./token-goat-chunk-GLXRTTLE.mjs")).allSheetsHeadText(filePath, XLSX_SHEET_ROW_CAP);
+      return await (await import("./token-goat-chunk-64FBPDTK.mjs")).allSheetsHeadText(filePath, XLSX_SHEET_ROW_CAP);
     default:
       return null;
   }
 }
 
+// src/embeddings.ts
+init_define_import_meta_env();
+
 // 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";
+import * as fs3 from "node:fs";
+import * as path4 from "node:path";
 
 // src/embed_tokenizer.ts
 init_define_import_meta_env();
@@ -109,20 +119,20 @@ var UnsupportedTokenizerError = class extends Error {
 function fail(message) {
   throw new UnsupportedTokenizerError(message);
 }
-function asRecord(value, path7) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) fail(`${path7} is not an object`);
+function asRecord(value, path10) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) fail(`${path10} is not an object`);
   return value;
 }
-function asString(value, path7) {
-  if (typeof value !== "string") fail(`${path7} is not a string`);
+function asString(value, path10) {
+  if (typeof value !== "string") fail(`${path10} is not a string`);
   return value;
 }
-function asArray(value, path7) {
-  if (!Array.isArray(value)) fail(`${path7} is not an array`);
+function asArray(value, path10) {
+  if (!Array.isArray(value)) fail(`${path10} is not an array`);
   return value;
 }
-function expectValue(actual, wanted, path7) {
-  if (actual !== wanted) fail(`${path7} is ${JSON.stringify(actual)}, expected ${JSON.stringify(wanted)}`);
+function expectValue(actual, wanted, path10) {
+  if (actual !== wanted) fail(`${path10} 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;
@@ -310,68 +320,25 @@ var BertWordPiece = class _BertWordPiece {
   }
 };
 
-// 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 = 4;
-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);
+// src/embed_runtime.ts
+init_define_import_meta_env();
+import * as fs2 from "node:fs";
+import { createRequire } from "node:module";
+import * as path3 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/pinned_file.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import * as path2 from "node:path";
+async function sha256Of(filePath) {
+  return (await import("./token-goat-chunk-H2K3QP6H.mjs")).sha256Of(filePath);
 }
 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;
-  }
+  return (await import("./token-goat-chunk-H2K3QP6H.mjs")).copyFromSharedCache(shared, file, target);
+}
+async function downloadPinned(url, file, target) {
+  return (await import("./token-goat-chunk-H2K3QP6H.mjs")).downloadPinned(url, file, target);
 }
 function publishToSharedCache(shared, file, target) {
   const destination = path2.join(shared, file.name);
@@ -391,38 +358,104 @@ function publishToSharedCache(shared, file, target) {
     }
   }
 }
-var _ort = null;
-var _ortError = null;
-var _ortLoadAttempted = false;
-function ensureRuntimeLoaded() {
-  if (_ortLoadAttempted) return;
-  _ortLoadAttempted = true;
+
+// src/embed_runtime.ts
+var _require = createRequire(import.meta.url);
+var ORT_WEB_VERSION = "1.30.0";
+var ORT_WEB_WASM = {
+  name: "ort-wasm-simd-threaded.wasm",
+  sha256: "3398c10d07d229bd91b364548e130e0e51a8e5704b88c7c083ebbeb78842dee2",
+  bytes: 14239897
+};
+var WEB_RETRY_AFTER_MS = 10 * 60 * 1e3;
+var START_FAILURE_HOLD_MS = 24 * 60 * 60 * 1e3;
+var NATIVE_RUNTIME_INSTALL = "install the native runtime with: npm install -g onnxruntime-node (drop -g if token-goat is a project dependency)";
+var RUNTIME_UNAVAILABLE_ADVICE = `The WebAssembly runtime is downloaded once from registry.npmjs.org (onnxruntime-web ${ORT_WEB_VERSION}), so check network access and network.offline; or ${NATIVE_RUNTIME_INSTALL}`;
+var _chosen = null;
+var _nodeOrt = null;
+var _nodeError = null;
+var _webFailure = null;
+var _recordChecked = false;
+function asError(e) {
+  return e instanceof Error ? e : new Error(String(e));
+}
+function chooseRuntime() {
+  if (_chosen !== null) return _chosen;
   try {
-    _ort = _require("onnxruntime-node");
+    _nodeOrt = _require("onnxruntime-node");
+    _chosen = "onnxruntime-node";
   } catch (e) {
-    _ortError = e instanceof Error ? e : new Error(String(e));
+    _nodeError = asError(e);
+    _chosen = "onnxruntime-web";
+  }
+  return _chosen;
+}
+function recentWebFailure() {
+  if (_webFailure === null && !_recordChecked) {
+    _recordChecked = true;
+    _webFailure = recordedStartFailure();
+  }
+  if (_webFailure === null) return null;
+  if (Date.now() - _webFailure.at >= (_webFailure.started ? START_FAILURE_HOLD_MS : WEB_RETRY_AFTER_MS) || _webFailure.started && !fs2.existsSync(startFailurePath())) {
+    _webFailure = null;
+    return null;
   }
+  return _webFailure.error;
+}
+function startFailurePath() {
+  return path3.join(wasmDir(), "start-failure.json");
+}
+var NODE_OPTIONS_AT_START = process.env["NODE_OPTIONS"] ?? "";
+function startFailureKey() {
+  let build = "";
+  try {
+    const self = fs2.statSync(fileURLToPath(import.meta.url));
+    build = `${self.size}:${self.mtimeMs}`;
+  } catch {
+  }
+  return JSON.stringify([ORT_WEB_VERSION, ORT_WEB_WASM.sha256, build, process.execPath, process.version, process.platform, process.arch, process.execArgv, NODE_OPTIONS_AT_START]);
+}
+function recordedStartFailure() {
+  const file = startFailurePath();
+  try {
+    const parsed = JSON.parse(fs2.readFileSync(file, "utf8"));
+    if (parsed.key !== startFailureKey() || typeof parsed.message !== "string" || typeof parsed.at !== "number") return null;
+    const when = new Date(parsed.at).toISOString();
+    return {
+      error: new Error(`${parsed.message} (in an earlier run, at ${when}; it is tried again once Node, its flags or token-goat change, or a day after, and deleting ${file} tries it at once)`),
+      at: parsed.at,
+      started: true
+    };
+  } catch {
+    return null;
+  }
+}
+function activeRuntime() {
+  return chooseRuntime();
+}
+function nativeRuntimeLoadError() {
+  chooseRuntime();
+  return _nodeError;
 }
 function isRuntimeAvailable() {
-  ensureRuntimeLoaded();
-  return _ort !== null && _ortError === null;
+  if (chooseRuntime() === "onnxruntime-node") return true;
+  return recentWebFailure() === null;
 }
 function runtimeLoadError() {
-  ensureRuntimeLoaded();
-  return _ortError;
+  if (chooseRuntime() === "onnxruntime-node") return null;
+  return recentWebFailure();
 }
 function runtimeVersion() {
-  ensureRuntimeLoaded();
-  if (_ort === null) return "unknown";
+  if (chooseRuntime() === "onnxruntime-web") return ORT_WEB_VERSION;
   try {
-    let dir = path2.dirname(_require.resolve("onnxruntime-node"));
+    let dir = path3.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"));
+      const manifest = path3.join(dir, "package.json");
+      if (fs2.existsSync(manifest)) {
+        const parsed = JSON.parse(fs2.readFileSync(manifest, "utf8"));
         if (parsed.name === "onnxruntime-node" && typeof parsed.version === "string") return parsed.version;
       }
-      const up = path2.dirname(dir);
+      const up = path3.dirname(dir);
       if (up === dir) break;
       dir = up;
     }
@@ -430,52 +463,101 @@ function runtimeVersion() {
   }
   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")));
-  });
+function wasmDir() {
+  return path3.join(dataDir(), "models", "onnxruntime-web", ORT_WEB_VERSION);
 }
-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());
-    });
+function sharedWasmCacheDir() {
+  const raw = process.env["TOKEN_GOAT_MODEL_CACHE_DIR"]?.trim();
+  if (!raw) return null;
+  return path3.join(raw, "onnxruntime-web", ORT_WEB_VERSION);
+}
+function wasmBinaryPresent() {
+  const roots = [wasmDir(), sharedWasmCacheDir()].filter((d) => d !== null);
+  return roots.some((root) => {
     try {
-      fs.rmSync(temp, { force: true, maxRetries: 20, retryDelay: 25 });
+      return fs2.statSync(path3.join(root, ORT_WEB_WASM.name)).size === ORT_WEB_WASM.bytes;
     } catch {
+      return false;
+    }
+  });
+}
+async function ensureWasmBinary() {
+  return (await import("./token-goat-chunk-4LCCNRTG.mjs")).ensureWasmBinary(webHost());
+}
+function webHost() {
+  return {
+    version: ORT_WEB_VERSION,
+    wasm: ORT_WEB_WASM,
+    dir: wasmDir(),
+    sharedDir: sharedWasmCacheDir(),
+    publish: publishToSharedCache,
+    startFailure: { path: startFailurePath(), key: startFailureKey() },
+    failed(e, started) {
+      const error = asError(e);
+      _webFailure = { error, at: Date.now(), started };
+      return error;
     }
-    throw e;
+  };
+}
+async function createInferenceSession(modelPath, threads) {
+  if (chooseRuntime() === "onnxruntime-node") {
+    const ort = _nodeOrt;
+    return { session: await ort.InferenceSession.create(modelPath, { intraOpNumThreads: threads, interOpNumThreads: 1 }), Tensor: ort.Tensor };
   }
+  const remembered = recentWebFailure();
+  if (remembered) throw remembered;
+  return (await import("./token-goat-chunk-4LCCNRTG.mjs")).createWebSession(modelPath, threads, webHost());
+}
+registerReset(() => {
+  _chosen = null;
+  _nodeOrt = null;
+  _nodeError = null;
+  _webFailure = null;
+  _recordChecked = false;
+});
+
+// src/embed_model.ts
+var DEFAULT_MODEL = "Xenova/bge-small-en-v1.5";
+var DEFAULT_DIM = 384;
+var DEFAULT_EMBED_THREADS = 4;
+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 path4.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 fs3.statSync(path4.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 path4.join(raw, ...DEFAULT_MODEL.split("/"), PINNED_MODEL_REVISION);
+}
+function download(file, target) {
+  return downloadPinned(downloadUrl(file), file, target);
 }
 var _inFlightModelDownload = null;
 function ensureModelFiles(modelName = DEFAULT_MODEL) {
@@ -504,14 +586,14 @@ async function _ensureModelFilesInner(_modelName) {
   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 target = path4.join(dir, file.name);
+    if (fs3.existsSync(target)) {
       const digest = await sha256Of(target);
       if (digest === file.sha256) continue;
-      fs.rmSync(target, { force: true });
+      fs3.rmSync(target, { force: true });
     }
     if (shared) {
-      ensureDirSync(path2.dirname(target));
+      ensureDirSync(path4.dirname(target));
       if (await copyFromSharedCache(shared, file, target)) continue;
     }
     if (offline) {
@@ -519,7 +601,7 @@ async function _ensureModelFilesInner(_modelName) {
         `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));
+    ensureDirSync(path4.dirname(target));
     console.warn(
       `Downloading the embedding model, once (${file.name}, ${Math.round(file.bytes / 1024 / 1024)} MB) into ${dir}`
     );
@@ -557,17 +639,13 @@ var EmbeddingModel = class _EmbeddingModel {
   tensorFactory;
   static async load(modelName = DEFAULT_MODEL) {
     if (!isRuntimeAvailable()) {
-      throw new Error(`onnxruntime-node is not available: ${_ortError?.message ?? "unknown error"}`);
+      throw new Error(`the inference runtime is not available: ${runtimeLoadError()?.message ?? "unknown error"}`);
     }
     const dir = await ensureModelFiles(modelName);
-    const tokenizer = BertWordPiece.fromJson(fs.readFileSync(path2.join(dir, "tokenizer.json"), "utf8"));
-    const ort = _ort;
+    const tokenizer = BertWordPiece.fromJson(fs3.readFileSync(path4.join(dir, "tokenizer.json"), "utf8"));
     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);
+    const { session, Tensor } = await createInferenceSession(path4.join(dir, "onnx", "model_quantized.onnx"), threads);
+    return new _EmbeddingModel(tokenizer, session, Tensor);
   }
   /** Wordpieces `text` becomes under this model's own tokenizer, markers excluded. */
   countTokens(text) {
@@ -603,8 +681,10 @@ async function checkEmbeddingPreflight(options) {
   const cfg = loadConfig();
   const enabled = cfg.indexing?.embeddings_enabled ?? true;
   const mDir = modelDir();
+  const rt = activeRuntime();
   const rtVer = runtimeVersion();
   const rtAvail = isRuntimeAvailable();
+  const binaryPresent = rt === "onnxruntime-web" ? wasmBinaryPresent() : null;
   const filesPresent = modelFilesPresent();
   let warmed = false;
   const buildResult = (params) => {
@@ -617,8 +697,10 @@ async function checkEmbeddingPreflight(options) {
       message: params.message,
       summary: params.message,
       modelName,
+      runtime: rt,
       runtimeVersion: rtVer,
       runtimeAvailable: rtAvail,
+      runtimeBinaryPresent: binaryPresent,
       configEnabled: enabled,
       modelFilesPresent: filesPresent,
       modelWarmed: warmed,
@@ -644,11 +726,19 @@ async function checkEmbeddingPreflight(options) {
     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)",
+      message: `Inference runtime is not available: ${err?.message ?? "unknown error"}`,
+      suggestion: RUNTIME_UNAVAILABLE_ADVICE,
       ...err?.message ? { error: err.message } : {}
     });
   }
+  if (binaryPresent === false && cfg?.network?.offline) {
+    return buildResult({
+      status: "missing_runtime",
+      available: false,
+      message: `The WebAssembly inference runtime's ${ORT_WEB_WASM.name} is not downloaded yet and offline mode (network.offline) prevents fetching it`,
+      suggestion: `Copy ${ORT_WEB_WASM.name} from the onnxruntime-web package's dist/ into ${wasmDir()}, or ${NATIVE_RUNTIME_INSTALL}`
+    });
+  }
   if (!filesPresent && cfg?.network?.offline) {
     return buildResult({
       status: "missing_model_files",
@@ -691,33 +781,27 @@ async function checkEmbeddingPreflight(options) {
   });
 }
 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 = "702c126bffd8439e";
+var EMBED_FINGERPRINT = "98753e3639c3c9e1";
 var EMBED_KIND_FINGERPRINTS = /* @__PURE__ */ new Map([
-  ["docx", "a39e82e795d46ed1"],
-  ["markdown", "c65dd62705244608"],
-  ["pdf", "9a0ea76d66dfd358"],
-  ["pptx", "b60b30cb38a801e2"],
-  ["xlsx", "e5b358c460b6507f"]
+  ["docx", "ea76a9e656cab4a7"],
+  ["markdown", "7c9b8d7beb37ac60"],
+  ["pdf", "ef7a41b66bc04bc1"],
+  ["pptx", "8b18b531b42106e7"],
+  ["xlsx", "67a12e733136381e"]
 ]);
 var PRE_KIND_EMBED_FINGERPRINT = "b7b2ff71de288d13";
 var SPLIT_EMBED_FINGERPRINT = "2310db32d9bc8a2b";
 
 // src/embed_stamp.ts
 init_define_import_meta_env();
-import * as path3 from "node:path";
+import * as path5 from "node:path";
 function embedKindForPath(filePath) {
-  if (isEmbeddableDocument(filePath)) return path3.extname(filePath).toLowerCase().slice(1);
+  if (isEmbeddableDocument(filePath)) return path5.extname(filePath).toLowerCase().slice(1);
   if (detectLanguage(filePath) === "markdown") return "markdown";
   return null;
 }
@@ -749,6 +833,8 @@ async function buildExtractorWithRetry(pipelineFn, modelName) {
     try {
       return await pipelineFn("feature-extraction", modelName);
     } catch (e) {
+      const { failedAtOf } = await import("./token-goat-chunk-COTXZHTS.mjs");
+      if (failedAtOf(e) !== null) throw e;
       lastError = e;
       if (attempt < PIPELINE_RETRY_ATTEMPTS) await sleep(PIPELINE_RETRY_DELAY_MS * attempt);
     }
@@ -1073,7 +1159,7 @@ function chunkFile(filePath, content, chunkSize = MAX_CHUNK_CHARS, overlap = 200
 function insertChunkVector(stmt, rowid, embedding) {
   stmt.run(BigInt(rowid), packVec(embedding));
 }
-async function upsertChunks(db, chunks) {
+async function upsertChunks(db, chunks, expectedSha) {
   if (chunks.length === 0) {
     return "embedded";
   }
@@ -1099,6 +1185,10 @@ async function upsertChunks(db, chunks) {
     VALUES (?, ?)
   `);
   const tx = db.transaction(() => {
+    if (expectedSha !== void 0) {
+      const current = db.prepare(`SELECT sha FROM files WHERE ${pathEqClause("path")}`).pluck().get(foldPath(filePath));
+      if (current !== expectedSha) return "stale";
+    }
     deleteFileEmbeddings(db, filePath);
     for (let i = 0; i < chunks.length; i++) {
       const chunk = chunks[i];
@@ -1115,9 +1205,9 @@ async function upsertChunks(db, chunks) {
       );
       insertChunkVector(vectorInsertStmt, chunkResult.lastInsertRowid, embedding);
     }
+    return "embedded";
   });
-  tx.immediate();
-  return "embedded";
+  return tx.immediate();
 }
 var BACKFILL_MULTIPLIER = 3;
 function countStoredVectors(db) {
@@ -1135,10 +1225,10 @@ function fetchScopedHits(db, queryVec, k, maxDistance, rootDir) {
   if (!rows || rows.length === 0) {
     return { hits: [], candidateCount: 0 };
   }
-  const scope = rootDir !== void 0 ? projectScopeClause("file_path") : void 0;
+  const scope = rootDir !== void 0 ? ownProjectScope("file_path", rootDir) : 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 scopeParams = scope?.params;
   const hits = [];
   for (const row of rows) {
     if (!row) {
@@ -1161,7 +1251,7 @@ function fetchScopedHits(db, queryVec, k, maxDistance, rootDir) {
   return { hits, candidateCount: rows.length };
 }
 function fetchScopedExactHits(db, queryVec, limit, maxDistance, rootDir) {
-  const scope = projectScopeClause("c.file_path");
+  const scope = ownProjectScope("c.file_path", rootDir);
   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
@@ -1171,7 +1261,7 @@ function fetchScopedExactHits(db, queryVec, limit, maxDistance, rootDir) {
        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);
+  ).all(packVec(queryVec), ...scope.params, maxDistance, limit);
   const hits = [];
   for (const row of rows) {
     if (!row || typeof row.distance !== "number" || !Number.isFinite(row.distance) || row.distance > maxDistance) {
@@ -1248,82 +1338,14 @@ function rerankHits(hits, query, topK) {
   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 = []) {
+async function indexFile(db, filePath, content, boundaries = [], expectedSha) {
   let chunks = chunkFile(filePath, content, void 0, void 0, boundaries);
   if (chunks.length > 0) {
     if (embeddingsDepsAvailable(db)) {
       const { countTokens } = await getExtractor(DEFAULT_MODEL);
       if (countTokens !== void 0) chunks = chunkFile(filePath, content, void 0, void 0, boundaries, countTokens);
     }
-    return upsertChunks(db, chunks);
+    return upsertChunks(db, chunks, expectedSha);
   }
   deleteFileEmbeddings(db, filePath);
   return "embedded";
@@ -1406,7 +1428,7 @@ function resetEmbeddingsForKinds(db, kinds) {
   return paths.length;
 }
 function backendId() {
-  return `onnxruntime-node@${majorMinor(runtimeVersion())}`;
+  return `${activeRuntime()}@${majorMinor(runtimeVersion())}`;
 }
 function majorMinor(version) {
   const parts = version.split(".");
@@ -1419,15 +1441,21 @@ function vectorSpaceOf(provenance) {
 }
 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;
+  if (stored === current) {
+    _provenanceChecked.add(db);
+    return;
+  }
   const keepVectors = stored !== void 0 && vectorSpaceOf(stored) === vectorSpaceOf(current);
-  const cleared = stored !== void 0 && keepVectors ? resetStaleChunking(db, stored, current) : resetAllEmbeddings(db, false);
-  db.prepare(
-    "INSERT INTO embedding_provenance (id, provenance) VALUES (1, ?) ON CONFLICT(id) DO UPDATE SET provenance = excluded.provenance"
-  ).run(current);
+  const cleared = db.transaction(() => {
+    const count = stored !== void 0 && keepVectors ? resetStaleChunking(db, stored, current) : resetAllEmbeddings(db, false);
+    db.prepare(
+      "INSERT INTO embedding_provenance (id, provenance) VALUES (1, ?) ON CONFLICT(id) DO UPDATE SET provenance = excluded.provenance"
+    ).run(current);
+    return count;
+  }).immediate();
+  _provenanceChecked.add(db);
   if (cleared > 0 && !keepVectors) {
     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.`
@@ -1469,65 +1497,110 @@ function _pathPriorityPenalty(filePath) {
   return 0;
 }
 
+// src/skip_scope.ts
+init_define_import_meta_env();
+import * as os from "node:os";
+import * as path6 from "node:path";
+var declaredRoot;
+function withDeclaredSkipScopeRoot(root, fn) {
+  const previous = declaredRoot;
+  declaredRoot = root;
+  try {
+    return fn();
+  } finally {
+    declaredRoot = previous;
+  }
+}
+function pathSegments(p) {
+  return p.split(/[/\\]/).filter((s) => s.length > 0);
+}
+function outermostProjectRoot(filePath) {
+  const first = findProject(path6.dirname(filePath));
+  if (first === null) return void 0;
+  const home = foldPath(os.homedir()).replace(/\\/g, "/");
+  let root = first.root;
+  for (; ; ) {
+    const parent = path6.dirname(root);
+    if (parent === root) return root;
+    const outer = findProject(parent);
+    if (outer === null || outer.root === root) return root;
+    const outerFolded = foldPath(outer.root).replace(/\\/g, "/").replace(/\/+$/, "");
+    if (home === outerFolded || home.startsWith(`${outerFolded}/`)) return root;
+    root = outer.root;
+  }
+}
+function hasSkipSegmentBelowRoot(filePath, projectRoot, isSkipSegment) {
+  const dirSegments = pathSegments(filePath).slice(0, -1);
+  if (!dirSegments.some(isSkipSegment)) return false;
+  const root = projectRoot ?? declaredRoot ?? outermostProjectRoot(filePath);
+  if (root === void 0) return true;
+  const rootSegments = pathSegments(root);
+  if (rootSegments.length > dirSegments.length) return true;
+  for (let i = 0; i < rootSegments.length; i++) {
+    if (foldPath(rootSegments[i] ?? "") !== foldPath(dirSegments[i] ?? "")) return true;
+  }
+  return dirSegments.slice(rootSegments.length).some(isSkipSegment);
+}
+
 // src/parser_stamp.ts
 init_define_import_meta_env();
 
 // src/parser_fingerprint.ts
 init_define_import_meta_env();
-var PARSER_FINGERPRINT = "2d89b6499a42ed1d";
+var PARSER_FINGERPRINT = "c8a3aa41909be8c0";
 var LANGUAGE_PARSER_FINGERPRINTS = /* @__PURE__ */ new Map([
-  ["abap", "ace64ed1a90c6fe2"],
-  ["abl", "49747d3ea4a63996"],
-  ["apache", "dc4c4c1a4535edaa"],
-  ["apex", "ba09f466435bac98"],
-  ["asm", "381803d9b7d37222"],
-  ["bash", "d79de6bc5521aa1c"],
-  ["batch", "ae1b1353f77a0e3d"],
-  ["caddy", "e4a8a743ed862a26"],
-  ["clojure", "45cb3fbe66685d67"],
-  ["cmake", "54a50f9ec5f77ee1"],
-  ["common_lisp", "59dfcd3bcf2b12d6"],
-  ["csharp", "ffd0d771ab250bb7"],
-  ["dart", "e70f3adc4f21925e"],
-  ["elixir", "e4a41c6c2111456f"],
-  ["emacs_lisp", "8d1165fa3e1c1294"],
-  ["erlang", "864920c971acb5d8"],
-  ["fortran", "6c3c979574ba3634"],
-  ["fsharp", "3d12f87ae36bd8c8"],
-  ["graphql", "d3097d428382f6a6"],
-  ["groovy", "9c6deaeb58514162"],
-  ["haskell", "f71bcbe8ad0c822c"],
-  ["jcl", "2df5befa1e1bf338"],
-  ["kotlin", "35bd48532ca099f9"],
-  ["liquid", "b690060daff453e3"],
-  ["lua", "b819c32f3e285380"],
-  ["makefile", "90b4f22a02906869"],
-  ["matlab", "6987f5931cb0115c"],
-  ["nginx", "e09eee0153d68597"],
-  ["nix", "f2c0fe5157ea42d4"],
-  ["objc", "00fe927b86fce11a"],
-  ["ocaml", "d30ade0b53bab229"],
-  ["pascal", "eb9634ba12f9c034"],
-  ["perl", "1914f4f683566235"],
-  ["php", "0d5dbaf75addd247"],
-  ["pli", "e0750ee540a9ec21"],
-  ["powershell", "c34d22937b367114"],
-  ["proto", "fc07b91d857f3775"],
-  ["r", "dc0bf5a6f1145c18"],
-  ["racket", "a3a1aad82f7ad007"],
-  ["rpg", "b377ec9a51a52784"],
-  ["salesforce_metadata", "f143c6eef872cb92"],
-  ["sas", "b6162f794de7b72e"],
-  ["scala", "3208d9f8b987936c"],
-  ["scheme", "7c67037a020cfebc"],
-  ["solidity", "c399df7b96ac4bac"],
-  ["sql", "8456d9445630f7fc"],
-  ["swift", "f7e06269477c3a87"],
-  ["terraform", "1ef21f729614d340"],
-  ["thrift", "33d6cdadd7446f83"],
-  ["vb", "c07ca9e16e0d3e67"],
-  ["vhdl", "8ca86b768f29b646"],
-  ["zig", "e10a8a352adc898a"]
+  ["abap", "accec34183d6fc45"],
+  ["abl", "b721e43e5720a56d"],
+  ["apache", "6e840e4ac38d88c1"],
+  ["apex", "6e621f41fce0d396"],
+  ["asm", "845db656efdc0fca"],
+  ["bash", "656e307df22168bb"],
+  ["batch", "d20823bbe2a8eec4"],
+  ["caddy", "b0f8fdf4ea685095"],
+  ["clojure", "85b583da30a1a44e"],
+  ["cmake", "1e0b257e06742425"],
+  ["common_lisp", "b6c3bc62b3a255a5"],
+  ["csharp", "68d9c4bb7fb18e1c"],
+  ["dart", "40a3921e9143f0f4"],
+  ["elixir", "719739d859fb5a25"],
+  ["emacs_lisp", "463153969879ead0"],
+  ["erlang", "3aaebe53622499d3"],
+  ["fortran", "7ecf0ab7c3f52b6f"],
+  ["fsharp", "b9c219bd5fbdc8b5"],
+  ["graphql", "34c5923656df5406"],
+  ["groovy", "780274c5b5c7d79a"],
+  ["haskell", "942d08d94feba789"],
+  ["jcl", "d0868f4420b941ea"],
+  ["kotlin", "df0ce105cba0fc0b"],
+  ["liquid", "436055b0a6b64ceb"],
+  ["lua", "ded20290e6d00d06"],
+  ["makefile", "dbbd6b32d5cc62eb"],
+  ["matlab", "d8a2f8c83f070614"],
+  ["nginx", "63248e67cc521def"],
+  ["nix", "056a50108db861a6"],
+  ["objc", "c21c0d7c13775c0f"],
+  ["ocaml", "22bf5a0eaa2b5f80"],
+  ["pascal", "24579492a16ad7e4"],
+  ["perl", "bd8ac6c679b29abe"],
+  ["php", "b823c3df1138d2b7"],
+  ["pli", "38f7027519e34e39"],
+  ["powershell", "70dd31bfbcf69a68"],
+  ["proto", "9c42c66e3fee093f"],
+  ["r", "5db6f150582b5550"],
+  ["racket", "e900071a3d70d0b3"],
+  ["rpg", "5839e0f9c099c11b"],
+  ["salesforce_metadata", "a4408c65eb712933"],
+  ["sas", "7e8a6772363c76a1"],
+  ["scala", "72c64544a81c0c98"],
+  ["scheme", "592b9b37b5494f0e"],
+  ["solidity", "3f0947056f925fad"],
+  ["sql", "5d423d87e7a0c2b3"],
+  ["swift", "3c7306bc8c96279d"],
+  ["terraform", "ead711fa99e96a85"],
+  ["thrift", "a773492ef26655c7"],
+  ["vb", "97ade1ad9cd06689"],
+  ["vhdl", "cd0e1ee6c5da9bd1"],
+  ["zig", "9034a79cede0b52f"]
 ]);
 
 // src/parser_stamp.ts
@@ -1537,13 +1610,13 @@ function parserFingerprintForLanguage(language) {
 
 // src/parser.ts
 init_define_import_meta_env();
-import * as fs2 from "node:fs";
+import * as fs4 from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import * as path6 from "node:path";
+import * as path9 from "node:path";
 
 // src/asset_extensions.ts
 init_define_import_meta_env();
-import * as path4 from "node:path";
+import * as path7 from "node:path";
 var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".png",
   ".jpg",
@@ -1558,7 +1631,7 @@ var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".heif"
 ]);
 function isImagePath(p) {
-  return IMAGE_EXTENSIONS.has(path4.extname(p).toLowerCase());
+  return IMAGE_EXTENSIONS.has(path7.extname(p).toLowerCase());
 }
 var NON_TEXT_ASSET_EXTENSIONS = /* @__PURE__ */ new Set([
   ...IMAGE_EXTENSIONS,
@@ -1606,7 +1679,7 @@ var NON_TEXT_ASSET_EXTENSIONS = /* @__PURE__ */ new Set([
   ".sqlite3"
 ]);
 function isNonTextAsset(p) {
-  return NON_TEXT_ASSET_EXTENSIONS.has(path4.extname(p).toLowerCase());
+  return NON_TEXT_ASSET_EXTENSIONS.has(path7.extname(p).toLowerCase());
 }
 var NON_TEXT_ASSET_SET_ID = (() => {
   const joined = [...NON_TEXT_ASSET_EXTENSIONS].sort().join(",");
@@ -1628,9 +1701,14 @@ init_define_import_meta_env();
 init_define_import_meta_env();
 function* eachUnfencedLine(lines) {
   let fence = null;
+  let inComment = false;
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
     if (line === void 0) continue;
+    if (inComment) {
+      if (line.includes("-->")) inComment = false;
+      continue;
+    }
     const fm = /^\s*(`{3,}|~{3,})([^\n]*)$/.exec(line);
     if (fm !== null && fm[1] !== void 0) {
       const run = fm[1];
@@ -1644,10 +1722,28 @@ function* eachUnfencedLine(lines) {
       continue;
     }
     if (fence !== null) continue;
+    if (/^ {0,3}<!--/.test(line)) {
+      inComment = !line.includes("-->");
+      continue;
+    }
     yield [i, line];
   }
 }
 
+// src/markdown_frontmatter.ts
+init_define_import_meta_env();
+function frontMatterEndIndex(lines) {
+  const first = lines[0];
+  if (first === void 0) return 0;
+  const open = first.replace(/^\uFEFF/, "").trimEnd();
+  if (open !== "---" && open !== "+++") return 0;
+  for (let i = 1; i < lines.length; i++) {
+    const t = (lines[i] ?? "").trimEnd();
+    if (t === open || open === "---" && t === "...") return i + 1;
+  }
+  return 0;
+}
+
 // src/hints/markdown_hints.ts
 var MARKDOWN_SIZE_THRESHOLD = 4e3;
 var MAX_HEADINGS = 40;
@@ -1655,47 +1751,44 @@ var MAX_OUTPUT_LINES = 60;
 function extractMarkdownHeadings(content, limit = MAX_HEADINGS) {
   const headings = [];
   const lines = content.split("\n");
-  const unfenced = Array.from(eachUnfencedLine(lines));
+  const fmEnd = frontMatterEndIndex(lines);
+  const unfenced = Array.from(eachUnfencedLine(lines)).filter(([i]) => i >= fmEnd);
+  let paraStart = -1;
   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;
+    if (!line) {
+      paraStart = -1;
+      continue;
+    }
+    const atx = matchAtxHeading(line, ATX_CLASS_BREAK_RE, true);
+    if (atx !== null) {
       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;
-        }
+      if (atx.level <= maxLevel && atx.name) {
+        headings.push({
+          level: atx.level,
+          text: atx.name,
+          lineNumber: i + 1
+        });
+        if (headings.length >= limit) break;
       }
+      paraStart = -1;
       continue;
     }
+    if (paraStart !== -1 && i !== unfenced[u - 1][0] + 1) paraStart = -1;
     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;
-        }
-      }
+    if (paraStart !== -1 && /^(=+|-+)$/.test(trimmed)) {
+      headings.push({
+        level: trimmed.startsWith("=") ? 1 : 2,
+        text: unfenced.slice(paraStart, u).map(([, text]) => text.trim()).join(" "),
+        lineNumber: unfenced[paraStart][0] + 1
+      });
+      paraStart = -1;
+      if (headings.length >= limit) break;
+      continue;
     }
+    const isText = trimmed !== "" && !trimmed.startsWith("#") && !trimmed.startsWith("|") && !trimmed.startsWith("```") && !trimmed.startsWith("~~~") && !/^([-*+]|\d+\.)\s/.test(trimmed) && !/^(=+|-+)$/.test(trimmed);
+    if (!isText) paraStart = -1;
+    else if (paraStart === -1) paraStart = u;
   }
   return headings;
 }
@@ -1783,11 +1876,11 @@ function buildEmbeddingBoundaries(filePath, content, dbPath) {
 
 // src/languages/salesforce_frontend.ts
 init_define_import_meta_env();
-import * as path5 from "node:path";
+import * as path8 from "node:path";
 function bundleName(filePath) {
   const normalized = filePath.replaceAll("\\", "/");
-  const parent = path5.posix.basename(path5.posix.dirname(normalized));
-  const base = path5.posix.basename(normalized).replace(/\.[^.]+$/, "");
+  const parent = path8.posix.basename(path8.posix.dirname(normalized));
+  const base = path8.posix.basename(normalized).replace(/\.[^.]+$/, "");
   return parent === "lwc" || parent === "aura" ? base : parent;
 }
 function lwcTagAlias(name) {
@@ -1885,7 +1978,7 @@ var MARKUP_KIND = {
 };
 function markupArtifactName(filePath, extension) {
   if (extension === ".page" || extension === ".component" || extension === ".email") {
-    return path5.posix.basename(filePath.replaceAll("\\", "/")).replace(new RegExp(`${extension.replace(".", "\\.")}$`, "i"), "");
+    return path8.posix.basename(filePath.replaceAll("\\", "/")).replace(new RegExp(`${extension.replace(".", "\\.")}$`, "i"), "");
   }
   return bundleName(filePath);
 }
@@ -1905,7 +1998,7 @@ function attributeRefs(refs, content, lineIndex, filePath, attribute, split = fa
 }
 function extractSalesforceMarkup(content, filePath) {
   const normalized = filePath.replaceAll("\\", "/");
-  const extension = path5.posix.extname(normalized).toLowerCase();
+  const extension = path8.posix.extname(normalized).toLowerCase();
   const kind = MARKUP_KIND[extension] ?? "salesforce_markup";
   const symbols = [
     symbol(filePath, markupArtifactName(normalized, extension), kind, 1, countContentLines(content))
@@ -2157,6 +2250,39 @@ function isModuleWrapperCallback(node) {
   }
   return false;
 }
+var TSJS_FN_VALUE_TYPES = /* @__PURE__ */ new Set(["arrow_function", "function_expression", "function"]);
+function isModuleExports(node) {
+  if (node.type !== "member_expression") return false;
+  const obj = node.childForFieldName("object");
+  const prop = node.childForFieldName("property");
+  return obj !== null && prop !== null && obj.type === "identifier" && obj.text === "module" && prop.text === "exports";
+}
+function commonJsAssignmentSymbol(stmt, filePath, lines) {
+  const assign = stmt.namedChildren[0];
+  if (assign === void 0 || assign.type !== "assignment_expression") return null;
+  const left = assign.childForFieldName("left");
+  const right = assign.childForFieldName("right");
+  if (left === null || right === null || left.type !== "member_expression") return null;
+  const isFn = TSJS_FN_VALUE_TYPES.has(right.type);
+  if (isModuleExports(left)) {
+    const own = right.type === "function_expression" || right.type === "class" ? right.childForFieldName("name") : null;
+    if (own === null || own.text === "") return null;
+    return makeSymbol(filePath, own.text, right.type === "class" ? "class" : "function", stmt, lines, "c");
+  }
+  if (!isFn) return null;
+  const obj = left.childForFieldName("object");
+  const prop = left.childForFieldName("property");
+  if (obj === null || prop === null || prop.type !== "property_identifier") return null;
+  if (obj.type === "identifier" && obj.text === "exports") return makeSymbol(filePath, prop.text, "function", stmt, lines, "c");
+  if (isModuleExports(obj)) return makeSymbol(filePath, prop.text, "function", stmt, lines, "c");
+  if (obj.type === "member_expression" && obj.childForFieldName("property")?.text === "prototype") {
+    const owner = obj.childForFieldName("object");
+    if (owner === null) return null;
+    const sym = makeSymbol(filePath, prop.text, "method", stmt, lines, "c");
+    return { ...sym, parent: owner.text };
+  }
+  return null;
+}
 function extractTsJsSymbols(root, filePath, lines) {
   const out = [];
   const visit = (node, insideFunction) => {
@@ -2213,6 +2339,10 @@ function extractTsJsSymbols(root, filePath, lines) {
         }
       }
     }
+    if (!insideFunction && node.type === "expression_statement") {
+      const assigned = commonJsAssignmentSymbol(node, filePath, lines);
+      if (assigned !== null) out.push(assigned);
+    }
     if (node.type === "public_field_definition" || node.type === "field_definition") {
       const fieldName = node.childForFieldName("name") ?? node.childForFieldName("property");
       const value = node.childForFieldName("value");
@@ -2342,6 +2472,12 @@ var GO_LOCAL_KINDS = /* @__PURE__ */ new Set([
   "method_elem"
 ]);
 var GO_MULTI_NAME_SPECS = /* @__PURE__ */ new Set(["var_spec", "const_spec"]);
+function goReceiverType(node) {
+  const receiver = node.childForFieldName("receiver");
+  const param = receiver?.namedChildren.find((c) => c.type === "parameter_declaration");
+  const typeText = param?.childForFieldName("type")?.text ?? "";
+  return typeText.replace(/\[[^\]]*\]/g, "").replace(/[*()\s]/g, "");
+}
 function extractGoSymbols(root, filePath, lines) {
   const out = [];
   const visit = (node, insideFunction) => {
@@ -2359,7 +2495,9 @@ function extractGoSymbols(root, filePath, lines) {
       } else {
         const name = nodeName(node);
         if (name !== null && name !== "") {
-          out.push(makeSymbol(filePath, name, kind, node, lines, "c"));
+          const sym = makeSymbol(filePath, name, kind, node, lines, "c");
+          const receiverType = node.type === "method_declaration" ? goReceiverType(node) : "";
+          out.push(receiverType !== "" ? { ...sym, parent: receiverType } : sym);
         }
       }
     }
@@ -2450,12 +2588,18 @@ function leadingRustAttributes(node) {
   }
   return attrs;
 }
+function rustImplTypeName(type) {
+  if (type === null) return null;
+  const inner = type.type === "generic_type" || type.type === "reference_type" ? type.childForFieldName("type") : null;
+  if (inner !== null) return rustImplTypeName(inner);
+  return type.type === "scoped_type_identifier" ? type.childForFieldName("name")?.text ?? type.text : type.text;
+}
 function extractRustSymbols(root, filePath, lines) {
   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);
+      const name = node.type === "impl_item" ? rustImplTypeName(node.childForFieldName("type")) : 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) {
@@ -2489,14 +2633,16 @@ var RUBY_KIND_BY_TYPE = /* @__PURE__ */ new Map([
   ["class", "class"],
   ["module", "module"]
 ]);
-function extractSimpleSymbols(root, filePath, kindByType, lines, style, nameFor = nodeName) {
+function extractSimpleSymbols(root, filePath, kindByType, lines, style, nameFor = nodeName, parentFor) {
   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, lines, style));
+        const sym = makeSymbol(filePath, name, kind, node, lines, style);
+        const parent = parentFor === void 0 ? "" : parentFor(node);
+        out.push(parent !== "" ? { ...sym, parent } : sym);
       }
     }
     for (const child of node.namedChildren) {
@@ -2586,21 +2732,46 @@ function extractCppSymbols(root, filePath, lines) {
     CPP_KIND_BY_TYPE,
     lines,
     "c",
-    (node) => node.type === "function_definition" ? cFunctionName(node) : node.type === "type_definition" ? cTypedefAliasName(node) : node.type === "declaration" ? cFunctionPrototypeName(node) : nodeName(node)
+    (node) => node.type === "function_definition" ? cFunctionName(node) : node.type === "type_definition" ? cTypedefAliasName(node) : node.type === "declaration" ? cFunctionPrototypeName(node) : C_TAG_SPECIFIER_TYPES.has(node.type) && node.childForFieldName("body") === null ? null : nodeName(node),
+    cMethodParent
   );
 }
+var C_TAG_SPECIFIER_TYPES = /* @__PURE__ */ new Set(["struct_specifier", "class_specifier", "union_specifier", "enum_specifier"]);
+function cMethodParent(node) {
+  if (node.type !== "function_definition" && node.type !== "declaration") return "";
+  const body = node.parent;
+  const owner = body?.parent ?? null;
+  if (body !== null && body.type === "field_declaration_list" && owner !== null && (owner.type === "class_specifier" || owner.type === "struct_specifier" || owner.type === "union_specifier")) {
+    return owner.childForFieldName("name")?.text ?? "";
+  }
+  let cur = node.childForFieldName("declarator");
+  for (let i = 0; cur !== null && i < 16; i++) {
+    if (cur.type === "qualified_identifier") {
+      let inner = cur;
+      for (let j = 0; j < 16; j++) {
+        const next = inner.childForFieldName("name");
+        if (next === null || next.type !== "qualified_identifier") break;
+        inner = next;
+      }
+      const scope = inner.childForFieldName("scope");
+      return scope === null ? "" : scope.text.replace(/<.*$/s, "").trim();
+    }
+    cur = innerDeclarator(cur);
+  }
+  return "";
+}
 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 === "identifier" || inner.type === "field_identifier" || inner.type === "destructor_name" || inner.type === "operator_name") 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");
+      cur = innerDeclarator(cur);
       continue;
     }
     return null;
@@ -2620,12 +2791,18 @@ function lastSegment(text) {
   const parts = text.split(/::|\./);
   return parts[parts.length - 1] ?? text;
 }
+function innerDeclarator(node) {
+  const named = node.childForFieldName("declarator");
+  if (named !== null) return named;
+  return node.type === "reference_declarator" ? node.namedChildren[0] ?? null : null;
+}
 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 === "destructor_name" || cur.type === "operator_name") return cur.text;
     if (cur.type === "qualified_identifier") return lastSegment(cur.text);
-    cur = cur.childForFieldName("declarator");
+    cur = innerDeclarator(cur);
   }
   return null;
 }
@@ -2664,8 +2841,8 @@ var SCOPE_TYPES_BY_LANG = /* @__PURE__ */ new Map([
   ["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"])],
+  ["typescript", /* @__PURE__ */ new Set(["call_expression", "new_expression", "jsx_self_closing_element", "jsx_opening_element"])],
+  ["javascript", /* @__PURE__ */ new Set(["call_expression", "new_expression", "jsx_self_closing_element", "jsx_opening_element"])],
   ["python", /* @__PURE__ */ new Set(["call"])],
   ["go", /* @__PURE__ */ new Set(["call_expression"])],
   ["rust", /* @__PURE__ */ new Set(["call_expression", "macro_invocation"])],
@@ -2827,7 +3004,13 @@ var REF_NOISE_BY_LANG = /* @__PURE__ */ new Map([
       "proc",
       "sleep",
       "exit",
-      "freeze"
+      "freeze",
+      "private",
+      "protected",
+      "public",
+      "module_function",
+      "block_given?",
+      "binding"
     ])
   ]
 ]);
@@ -2837,6 +3020,19 @@ function lastSegment2(text) {
   const parts = text.split(/::|\./);
   return parts[parts.length - 1] ?? text;
 }
+var TSJS_FUNCTION_VALUE_TYPES = /* @__PURE__ */ new Set(["arrow_function", "function_expression", "function"]);
+function tsJsFunctionValuedMemberName(node) {
+  const isField = node.type === "public_field_definition" || node.type === "field_definition";
+  const isPair = node.type === "pair" && node.parent?.type === "object";
+  if (!isField && !isPair) return void 0;
+  const value = node.childForFieldName("value");
+  if (value === null || !TSJS_FUNCTION_VALUE_TYPES.has(value.type)) return void 0;
+  if (isField) return (node.childForFieldName("name") ?? node.childForFieldName("property"))?.text;
+  const key = node.childForFieldName("key");
+  if (key === null || key.type !== "identifier" && key.type !== "property_identifier" && key.type !== "string") return void 0;
+  const name = key.text.replace(/^['"]|['"]$/g, "");
+  return name === "" ? void 0 : name;
+}
 function scopeName(node, language) {
   if ((language === "typescript" || language === "javascript") && node.type === "variable_declarator") {
     const value = node.childForFieldName("value");
@@ -2845,6 +3041,10 @@ function scopeName(node, language) {
     }
     return null;
   }
+  if (language === "typescript" || language === "javascript") {
+    const member = tsJsFunctionValuedMemberName(node);
+    if (member !== void 0) return member;
+  }
   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") {
@@ -2899,6 +3099,14 @@ function calleeName(call, language) {
   switch (language) {
     case "typescript":
     case "javascript": {
+      if (call.type === "jsx_self_closing_element" || call.type === "jsx_opening_element") {
+        const tag = call.childForFieldName("name");
+        if (tag === null) return null;
+        if (tag.type === "identifier") return /^[A-Z]/.test(tag.text) ? tag.text : null;
+        if (tag.type === "member_expression") return tag.childForFieldName("property")?.text ?? null;
+        if (tag.type === "nested_identifier") return lastSegment2(tag.text);
+        return null;
+      }
       if (call.type === "new_expression") {
         const c = call.childForFieldName("constructor");
         if (c === null) return null;
@@ -2942,7 +3150,9 @@ function calleeName(call, language) {
     }
     case "java": {
       const n = call.childForFieldName("name") ?? call.childForFieldName("type");
-      return n !== null ? lastSegment2(n.text) : null;
+      if (n === null) return null;
+      const named = n.type === "generic_type" ? n.namedChildren[0] ?? n : n;
+      return lastSegment2(named.text);
     }
     case "c":
     case "cpp": {
@@ -3092,12 +3302,43 @@ function valueRefIdentifiers(node, language) {
   }
   return result;
 }
+var RUBY_FRESH_SCOPES = /* @__PURE__ */ new Set(["program", "method", "singleton_method", "class", "singleton_class", "module"]);
+var RUBY_BLOCK_SCOPES = /* @__PURE__ */ new Set(["block", "do_block", "lambda"]);
+var RUBY_IMPLICIT_PARAM = /^(?:it|_[1-9])$/;
+function sameNode2(a, b) {
+  return a !== null && a.type === b.type && a.startPosition.row === b.startPosition.row && a.startPosition.column === b.startPosition.column && a.endPosition.column === b.endPosition.column;
+}
+function rubyIsLocal(scopes, name) {
+  for (let i = scopes.length - 1; i >= 0; i--) {
+    const scope = scopes[i];
+    if (scope.vars.has(name)) return true;
+    if (!scope.inherits) return false;
+  }
+  return false;
+}
+function rubyIdentifierRole(node) {
+  const parent = node.parent;
+  if (parent === null) return "use";
+  const t = parent.type;
+  if (t === "method" || t === "singleton_method") return sameNode2(parent.childForFieldName("name"), node) ? "skip" : "use";
+  if (t === "call") return sameNode2(parent.childForFieldName("method"), node) ? "skip" : "use";
+  if (t === "alias" || t === "undef" || t === "scope_resolution") return "skip";
+  if (t.endsWith("_parameters") || t === "destructured_parameter") return "declare";
+  if (t.endsWith("_parameter")) return sameNode2(parent.childForFieldName("name"), node) ? "declare" : "use";
+  if (t === "assignment" || t === "operator_assignment") return sameNode2(parent.childForFieldName("left"), node) ? "declare" : "use";
+  if (t === "left_assignment_list" || t === "rest_assignment" || t === "destructured_left_assignment" || t === "exception_variable") return "declare";
+  if (t === "for") return sameNode2(parent.childForFieldName("pattern"), node) ? "declare" : "use";
+  if (t === "in_clause") return sameNode2(parent.childForFieldName("pattern"), node) ? "declare" : "use";
+  if (t.endsWith("_pattern")) return "declare";
+  return "use";
+}
 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 rubyScopes = [];
   const record = (name, node) => {
     if (name.length <= 1 || noise.has(name)) return;
     const line = node.startPosition.row + 1;
@@ -3115,6 +3356,12 @@ function extractRefs(root, filePath, language) {
   const visit = (node) => {
     const enclosing = scopeName(node, language);
     if (enclosing !== null && enclosing !== "") stack.push(enclosing);
+    let rubyScoped = false;
+    if (language === "ruby") {
+      rubyScoped = RUBY_FRESH_SCOPES.has(node.type) || RUBY_BLOCK_SCOPES.has(node.type);
+      if (rubyScoped) rubyScopes.push({ vars: /* @__PURE__ */ new Set(), inherits: RUBY_BLOCK_SCOPES.has(node.type) });
+      visitRubyBinding(node);
+    }
     if (callTypes.has(node.type)) {
       const callee = calleeName(node, language);
       if (callee !== null) record(callee, node);
@@ -3123,8 +3370,22 @@ function extractRefs(root, filePath, language) {
       record(idNode.text, idNode);
     }
     for (const child of node.namedChildren) visit(child);
+    if (rubyScoped) rubyScopes.pop();
     if (enclosing !== null && enclosing !== "") stack.pop();
   };
+  const visitRubyBinding = (node) => {
+    const scope = rubyScopes[rubyScopes.length - 1];
+    if (scope === void 0) return;
+    if (node.type === "keyword_pattern" && node.childForFieldName("value") === null) {
+      const key = node.childForFieldName("key");
+      if (key !== null) scope.vars.add(key.text);
+      return;
+    }
+    if (node.type !== "identifier") return;
+    const role = rubyIdentifierRole(node);
+    if (role === "declare") scope.vars.add(node.text);
+    else if (role === "use" && !RUBY_IMPLICIT_PARAM.test(node.text) && !rubyIsLocal(rubyScopes, node.text)) record(node.text, node);
+  };
   visit(root);
   return out;
 }
@@ -3195,13 +3456,18 @@ function countNewlines(s) {
 function extractMarkdownSymbols(content, filePath) {
   const out = [];
   const lines = content.split(/\r?\n/);
-  const unfenced = Array.from(eachUnfencedLine(lines));
+  const fmEnd = frontMatterEndIndex(lines);
+  const unfenced = Array.from(eachUnfencedLine(lines)).filter(([i]) => i >= fmEnd);
+  const bounds = [];
+  let paraStart = -1;
   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();
+    const atx = matchAtxHeading(line, ATX_DOT_BREAK_RE, false);
+    if (atx !== null) {
+      const name = atx.name;
+      let at = -1;
       if (name !== "") {
+        at = out.length;
         out.push({
           filePath,
           name,
@@ -3213,29 +3479,47 @@ function extractMarkdownSymbols(content, filePath) {
           parent: ""
         });
       }
+      bounds.push({ line: i + 1, level: atx.level, at });
+      paraStart = -1;
       continue;
     }
+    if (paraStart !== -1 && i !== unfenced[u - 1][0] + 1) paraStart = -1;
     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++;
-        }
+    if (paraStart !== -1 && /^(=+|-+)$/.test(trimmed)) {
+      const para = unfenced.slice(paraStart, u).map(([, text]) => text.trim());
+      const at = out.length;
+      out.push({
+        filePath,
+        name: para.join(" "),
+        kind: "heading",
+        lineStart: unfenced[paraStart][0] + 1,
+        lineEnd: i + 1,
+        body: `${para.join("\n")}
+${trimmed}`,
+        docstring: "",
+        parent: ""
+      });
+      bounds.push({ line: unfenced[paraStart][0] + 1, level: trimmed.startsWith("=") ? 1 : 2, at });
+      paraStart = -1;
+      continue;
+    }
+    const isText = trimmed !== "" && !trimmed.startsWith("#") && !trimmed.startsWith("|") && !trimmed.startsWith("```") && !trimmed.startsWith("~~~") && !/^([-*+]|\d+\.)\s/.test(trimmed) && !/^(=+|-+)$/.test(trimmed);
+    if (!isText) paraStart = -1;
+    else if (paraStart === -1) paraStart = u;
+  }
+  for (let k = 0; k < bounds.length; k++) {
+    const cur = bounds[k];
+    const sym = out[cur.at];
+    if (sym === void 0) continue;
+    let end = lines.length;
+    for (let j = k + 1; j < bounds.length; j++) {
+      if (bounds[j].level <= cur.level) {
+        end = bounds[j].line - 1;
+        break;
       }
     }
+    while (end > sym.lineEnd && (lines[end - 1] ?? "").trim() === "") end--;
+    out[cur.at] = { ...sym, lineEnd: Math.max(sym.lineEnd, end) };
   }
   return out;
 }
@@ -3401,10 +3685,13 @@ function yamlLineClosesQuote(line, quote) {
   }
   return false;
 }
+var YAML_TOP_KEY_RE = /^(?:([a-zA-Z_0-9][\w.-]*)|"((?:[^"\\]|\\.)*)"|'((?:[^']|'')*)')\s*:(?!\/\/)/;
 function extractYamlSymbols(content, filePath) {
   const out = [];
   const lines = content.split(/\r?\n/);
   let openQuote = null;
+  const boundaries = [];
+  const keyAt = /* @__PURE__ */ new Map();
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
     if (line === void 0) continue;
@@ -3412,11 +3699,18 @@ function extractYamlSymbols(content, filePath) {
       if (yamlLineClosesQuote(line, openQuote)) openQuote = null;
       continue;
     }
-    const match = /^([a-zA-Z_][\w.-]*)\s*:(?!\/\/)/.exec(line);
-    if (match !== null && match[1] !== void 0) {
+    if (/^(?:---|\.\.\.)(?:\s|$)/.test(line)) {
+      boundaries.push(i);
+      continue;
+    }
+    const match = YAML_TOP_KEY_RE.exec(line);
+    if (match !== null) {
+      const name = match[2] !== void 0 ? match[2].replace(/\\(["\\/])/g, "$1") : match[3] !== void 0 ? match[3].replace(/''/g, "'") : match[1] ?? "";
+      boundaries.push(i);
+      keyAt.set(i, out.length);
       out.push({
         filePath,
-        name: match[1],
+        name,
         kind: "key",
         lineStart: i + 1,
         lineEnd: i + 1,
@@ -3427,6 +3721,12 @@ function extractYamlSymbols(content, filePath) {
       openQuote = yamlOpenQuoteAfter(line, match[0].length);
     }
   }
+  for (const [start, at] of keyAt) {
+    const sym = out[at];
+    let end = (boundaries.find((b) => b > start) ?? lines.length) - 1;
+    while (end > start && (lines[end].trim() === "" || lines[end].startsWith("#"))) end--;
+    out[at] = { ...sym, lineEnd: end + 1, body: lines.slice(start, end + 1).join("\n").trim() };
+  }
   return out;
 }
 function lineOpenDelimiterAfter(line, startIdx) {
@@ -3487,11 +3787,11 @@ function extractTomlSymbols(content, filePath) {
   const out = [];
   const lines = content.split(/\r?\n/);
   function matchLine(line, lineNum) {
-    const sectionMatch = /^\s*\[\[?\s*([^\]]+)\s*\]/.exec(line);
-    if (sectionMatch !== null && sectionMatch[1] !== void 0) {
+    const sectionName = matchTomlSectionName(line);
+    if (sectionName !== null) {
       out.push({
         filePath,
-        name: sectionMatch[1].trim(),
+        name: sectionName.trim(),
         kind: "section",
         lineStart: lineNum + 1,
         lineEnd: lineNum + 1,
@@ -3536,6 +3836,14 @@ function extractTomlSymbols(content, filePath) {
     openDelim = lineOpenDelimiterAfter(code, 0);
     if (openDelim === null) arrayDepth = Math.max(0, tomlBracketDelta(code));
   }
+  const headers = out.filter((sym) => sym.kind === "section");
+  headers.forEach((sym, h) => {
+    const next = headers[h + 1];
+    let end = (next === void 0 ? lines.length : next.lineStart - 1) - 1;
+    while (end > sym.lineStart - 1 && (lines[end].trim() === "" || lines[end].trim().startsWith("#"))) end--;
+    const at = out.indexOf(sym);
+    out[at] = { ...sym, lineEnd: end + 1, body: lines.slice(sym.lineStart - 1, end + 1).join("\n").trim() };
+  });
   return out;
 }
 function splitTopLevelSelectors(rawCapture, strippedCapture) {
@@ -3562,68 +3870,75 @@ function nextContentLineOpensBrace(lines, i) {
   }
   return false;
 }
+function ruleEndIdx(blanked, startIdx, braceCol) {
+  let depth = 0;
+  for (let i = startIdx; i < blanked.length; i++) {
+    const text = blanked[i] ?? "";
+    for (let c = i === startIdx ? braceCol : 0; c < text.length; c++) {
+      if (text[c] === "{") depth++;
+      else if (text[c] === "}" && --depth === 0) return i;
+    }
+  }
+  return startIdx;
+}
+function stripCssLineComment(line) {
+  let inUrl = false;
+  for (let c = 0; c < line.length; c++) {
+    if (inUrl) {
+      if (line[c] === ")") inUrl = false;
+    } else if (line[c] === "/" && line[c + 1] === "/") {
+      return line.slice(0, c);
+    } else if (line[c] === "(" && /url$/i.test(line.slice(Math.max(0, c - 3), c))) {
+      inUrl = true;
+    }
+  }
+  return line;
+}
 function extractCssSymbols(content, filePath) {
   const out = [];
   const lines = stripCstyleComments(content).split(/\r?\n/);
   const rawLines = content.split(/\r?\n/);
   let pending = [];
+  const lineComments = /\.(?:scss|sass|less)$/i.test(filePath);
+  const blanked = lines.map((l) => lineComments ? stripCssLineComment(stripStringLiterals(l)) : stripStringLiterals(l));
+  const spanEntry = (name, startIdx, endIdx) => ({
+    filePath,
+    name,
+    kind: "selector",
+    lineStart: startIdx + 1,
+    lineEnd: endIdx + 1,
+    body: endIdx > startIdx ? rawLines.slice(startIdx, endIdx + 1).join("\n") : (lines[startIdx] ?? "").trim(),
+    docstring: "",
+    parent: ""
+  });
+  const flushPending = (endIdx) => {
+    for (const p of pending) out.push(spanEntry(p.name, p.line - 1, endIdx));
+    pending = [];
+  };
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
     if (line === void 0) continue;
-    const trimmed = line.trim();
+    const trimmed = (lineComments ? line.slice(0, (blanked[i] ?? "").length) : 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];
+    const strippedLine = blanked[i] ?? "";
+    const selectorSpan = matchCssSelectorSpan(strippedLine);
+    if (selectorSpan !== null) {
+      const endIdx = ruleEndIdx(blanked, i, selectorSpan.end);
+      flushPending(endIdx);
+      const rawCapture = line.slice(selectorSpan.start, selectorSpan.end);
+      const strippedCapture = strippedLine.slice(selectorSpan.start, selectorSpan.end);
       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: ""
-          });
+          out.push(spanEntry(name, i, endIdx));
         }
       }
       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 = [];
+      flushPending(ruleEndIdx(blanked, i, blanked[i]?.indexOf("{") ?? 0));
       continue;
     }
     if (trimmed.length > 0 && !trimmed.startsWith("@") && !trimmed.includes("{") && !trimmed.includes("}") && !trimmed.includes(";")) {
@@ -3638,23 +3953,52 @@ function extractCssSymbols(content, filePath) {
   }
   return out;
 }
+var DOCKERFILE_HEREDOC_RE = /(?<!<)<<(-?)(["']?)([A-Za-z_][\w.-]*)\2/g;
+function endsWithContinuation(line) {
+  return line.trimEnd().endsWith("\\");
+}
+function dockerfileInstructionEnd(lines, i) {
+  let end = i;
+  let continued = endsWithContinuation(lines[i] ?? "");
+  while (continued && end + 1 < lines.length) {
+    end++;
+    const next = lines[end] ?? "";
+    if (!next.trim().startsWith("#")) continued = endsWithContinuation(next);
+  }
+  return end;
+}
+function dockerfileHeredocEnd(lines, i, end) {
+  const text = lines.slice(i, end + 1).join("\n");
+  let cursor = end;
+  for (const m of text.matchAll(DOCKERFILE_HEREDOC_RE)) {
+    const stripTabs = m[1] === "-";
+    let close = -1;
+    for (let j = cursor + 1; j < lines.length; j++) {
+      const candidate = stripTabs ? (lines[j] ?? "").replace(/^\t+/, "") : lines[j] ?? "";
+      if (candidate.trimEnd() === m[3]) {
+        close = j;
+        break;
+      }
+    }
+    if (close === -1) return end;
+    cursor = close;
+  }
+  return cursor;
+}
 function extractDockerfileSymbols(content, filePath) {
   const out = [];
   const lines = content.split(/\r?\n/);
-  let continuing = false;
   for (let i = 0; i < lines.length; i++) {
     const line = lines[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(
+    if (line.trim().startsWith("#")) continue;
+    let end = dockerfileInstructionEnd(lines, i);
+    const match = /^\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];
+      if (/^(?:RUN|COPY|ADD)$/i.test(cmd)) end = dockerfileHeredocEnd(lines, i, end);
       const arg = (match[2] ?? "").substring(0, 40);
       const name = `${cmd} ${arg}`.trim();
       out.push({
@@ -3662,13 +4006,13 @@ function extractDockerfileSymbols(content, filePath) {
         name,
         kind: "directive",
         lineStart: i + 1,
-        lineEnd: i + 1,
-        body: line.trim(),
+        lineEnd: end + 1,
+        body: lines.slice(i, end + 1).join("\n").trim(),
         docstring: "",
         parent: ""
       });
     }
-    continuing = !isComment && line.trimEnd().endsWith("\\");
+    i = end;
   }
   return out;
 }
@@ -3738,7 +4082,8 @@ var REF_LANGUAGES = /* @__PURE__ */ new Set([
   "java",
   "c",
   "cpp",
-  "ruby"
+  "ruby",
+  "csharp"
 ]);
 var _parserCtor;
 var _parserCtorError = null;
@@ -3789,8 +4134,8 @@ function boundRefContext(context, col) {
   return (start > 0 ? REF_CONTEXT_ELISION : "") + context.slice(start, end) + (end < context.length ? REF_CONTEXT_ELISION : "");
 }
 function loadGrammar(lang, filePath, content) {
-  const useTsx = lang === "typescript" && filePath !== void 0 && path6.extname(filePath).toLowerCase() === ".tsx";
-  const useCppHeader = lang === "c" && filePath !== void 0 && path6.extname(filePath).toLowerCase() === ".h" && content !== void 0 && CPP_HEADER_SNIFF_RE.test(content);
+  const useTsx = lang === "typescript" && filePath !== void 0 && path9.extname(filePath).toLowerCase() === ".tsx";
+  const useCppHeader = lang === "c" && filePath !== void 0 && path9.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;
@@ -3926,7 +4271,7 @@ function parseSourceSymbolsTreeSitterOnly(content, filePath, language) {
 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-KOPIR3KZ.mjs");
+  adapterSlot[REGEX_ADAPTERS_SLOT] ??= await import("./token-goat-chunk-A3CK6N5Z.mjs");
 }
 function regexAdapters() {
   const loaded = adapterSlot[REGEX_ADAPTERS_SLOT];
@@ -3965,6 +4310,17 @@ function extractNoTreeSitter(content, filePath, language) {
     const r = adapters.extractNatural(content, filePath);
     return { symbols: r.symbols, refs: r.refs };
   }
+  if (language === "csharp") {
+    const r = adapters.extractCsharp(content, filePath);
+    const symbols = adapters.assignBraceBlockSpans(r.symbols, content, {
+      lineComment: "//",
+      stringEscapes: "csharp",
+      rawStringQuotes: true,
+      expressionBodies: true,
+      interpolation: "csharp"
+    });
+    return { symbols, refs: r.refs };
+  }
   const parsed = {
     symbols: extractSymbolsNoTreeSitter(content, filePath, language),
     refs: []
@@ -3981,16 +4337,19 @@ function deleteFileRows(db, filePath) {
   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) {
+function isMinifiedBundlePath(filePath) {
+  return /(?:\.min\.(?:js|mjs|cjs|css)|-min\.js)$/i.test(path9.basename(filePath));
+}
+function isUnderSkipDir(filePath, skipDirs, projectRoot) {
   if (skipDirs.length === 0) return false;
-  const segments = filePath.split(/[/\\]/);
-  return segments.slice(0, -1).some((seg) => skipDirs.includes(seg));
+  return hasSkipSegmentBelowRoot(filePath, projectRoot, (seg) => skipDirs.includes(seg));
 }
-function isParseSkipEligible(filePath, cfg) {
-  if (isUnderSkipDir(filePath, cfg.skip_dirs)) return true;
-  if (cfg.skip_files.includes(path6.basename(filePath))) return true;
+function isParseSkipEligible(filePath, cfg, projectRoot) {
+  if (isUnderSkipDir(filePath, cfg.skip_dirs, projectRoot)) return true;
+  if (cfg.skip_files.includes(path9.basename(filePath))) return true;
+  if (cfg.skip_minified !== false && isMinifiedBundlePath(filePath)) return true;
   try {
-    const stat = fs2.statSync(filePath);
+    const stat = fs4.statSync(filePath);
     if (stat.size > cfg.large_file_skip_kb * 1024) return true;
   } catch {
   }
@@ -4061,7 +4420,7 @@ function indexFileSync(rawPath, dbPath = globalDbPath(), preReadBytes) {
     raw = preReadBytes;
   } else {
     try {
-      raw = fs2.readFileSync(filePath);
+      raw = fs4.readFileSync(filePath);
     } catch (err) {
       if (err.code === "ENOENT") return;
       throw err;
@@ -4113,28 +4472,28 @@ function canonicalizeIndexPath(rawPath) {
   if (!isCaseInsensitiveFs()) return absPath;
   let real;
   try {
-    real = fs2.realpathSync.native(absPath);
+    real = fs4.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 = path6.basename(realNorm);
+  const realBase = path9.basename(realNorm);
   if (base === realBase) return absPath;
   if (foldPath(base) !== foldPath(realBase)) return absPath;
-  const callerDir = cut < 0 ? normalizePath(path6.resolve(".")) : normalizePath(absPath.slice(0, cut));
-  if (foldPath(callerDir) !== foldPath(path6.dirname(realNorm))) return absPath;
+  const callerDir = cut < 0 ? normalizePath(path9.resolve(".")) : normalizePath(absPath.slice(0, cut));
+  if (foldPath(callerDir) !== foldPath(path9.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(path6.resolve(absPath));
+  const candidate = normalizePath(path9.resolve(absPath));
   if (foldPath(stored) !== foldPath(candidate)) return false;
   let real;
   try {
-    real = normalizePath(fs2.realpathSync.native(absPath));
+    real = normalizePath(fs4.realpathSync.native(absPath));
   } catch {
     return false;
   }
@@ -4214,7 +4573,8 @@ async function indexFileEmbeddings(rawPath, dbPath = globalDbPath(), sha, onErro
     }
     try {
       const db = getDb(dbPath);
-      const outcome = await indexFile(db, filePath, extracted, []);
+      const outcome = await indexFile(db, filePath, extracted, [], sha);
+      if (outcome === "stale") return;
       if (outcome !== "unavailable" && enforceStoredChunkCap(db, filePath, sha, ixCfg.max_chunks_per_file)) return;
       stampEmbedSha(db, filePath, sha, (s) => outcome === "unavailable" ? unavailableEmbedSha(s) : s);
     } catch (err) {
@@ -4224,7 +4584,7 @@ async function indexFileEmbeddings(rawPath, dbPath = globalDbPath(), sha, onErro
   }
   let content;
   try {
-    content = decodeSource(await fs2.promises.readFile(filePath));
+    content = decodeSource(await fs4.promises.readFile(filePath));
   } catch {
     return;
   }
@@ -4261,7 +4621,8 @@ async function indexFileEmbeddings(rawPath, dbPath = globalDbPath(), sha, onErro
   }
   try {
     const db = getDb(dbPath);
-    const outcome = await indexFile(db, filePath, content, boundaries);
+    const outcome = await indexFile(db, filePath, content, boundaries, sha);
+    if (outcome === "stale") return;
     if (outcome !== "unavailable" && enforceStoredChunkCap(db, filePath, sha, ixCfg.max_chunks_per_file)) return;
     stampEmbedSha(db, filePath, sha, (s) => outcome === "unavailable" ? unavailableEmbedSha(s) : s);
   } catch (err) {
@@ -4278,7 +4639,7 @@ function stampEmbedSha(db, filePath, sha, makeValue) {
 }
 function safeMtime(filePath) {
   try {
-    return fs2.statSync(filePath).mtimeMs / 1e3;
+    return fs4.statSync(filePath).mtimeMs / 1e3;
   } catch {
     return 0;
   }
@@ -4286,7 +4647,7 @@ function safeMtime(filePath) {
 
 // src/section_reader.ts
 init_define_import_meta_env();
-import { readFileSync as readFileSync3 } from "node:fs";
+import { readFileSync as readFileSync4 } 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) {
@@ -4312,38 +4673,33 @@ function normalizeHeadingStrip(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(lines) {
   const headers = [];
-  const unfenced = Array.from(eachUnfencedLine(lines));
+  const fmEnd = frontMatterEndIndex(lines);
+  const unfenced = Array.from(eachUnfencedLine(lines)).filter(([i]) => i >= fmEnd);
+  let paraStart = -1;
   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 });
+    const atx = matchAtxHeading(line, ATX_CLASS_BREAK_RE, true);
+    if (atx !== null) {
+      headers.push({ heading: atx.name, level: atx.level, index: i });
+      paraStart = -1;
       continue;
     }
+    if (paraStart !== -1 && i !== unfenced[u - 1][0] + 1) paraStart = -1;
     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;
-        }
-      }
+    if (paraStart !== -1 && /^(=+|-+)$/.test(trimmed)) {
+      const heading = unfenced.slice(paraStart, u).map(([, text]) => text.trim()).join(" ");
+      headers.push({ heading, level: trimmed.startsWith("=") ? 1 : 2, index: unfenced[paraStart][0] });
+      paraStart = -1;
+      continue;
     }
+    const isText = trimmed !== "" && !trimmed.startsWith("#") && !trimmed.startsWith("|") && !trimmed.startsWith("```") && !trimmed.startsWith("~~~") && !/^([-*+]|\d+\.)\s/.test(trimmed) && !/^(=+|-+)$/.test(trimmed);
+    if (!isText) paraStart = -1;
+    else if (paraStart === -1) paraStart = u;
   }
   return headers;
 }
@@ -4358,8 +4714,8 @@ function findTableHeaders(lines, isToml) {
       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 });
+      const name2 = matchTableHeaderName(line.slice(restStart));
+      if (name2 !== null) headers.push({ heading: name2.trim(), level: 1, index: i });
       openDelim = lineOpenDelimiterAfter(stripTomlComment(line.slice(restStart)), 0);
       continue;
     }
@@ -4367,8 +4723,8 @@ function findTableHeaders(lines, isToml) {
       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 });
+    const name = matchTableHeaderName(line);
+    if (name !== null) headers.push({ heading: name.trim(), level: 1, index: i });
     if (isToml) {
       const code = stripTomlComment(line);
       openDelim = lineOpenDelimiterAfter(code, 0);
@@ -4390,9 +4746,9 @@ function extractShellBannerHeading(line) {
       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();
+  const ruleTitle = matchRuleBannerTitle(trimmed);
+  if (ruleTitle) {
+    const text = ruleTitle.trim();
     if (text && !/^[-=]+$/.test(text)) {
       return { heading: text, level: 1 };
     }
@@ -4750,7 +5106,7 @@ function readTextForSections(filePath, readFn) {
     text = read;
   } else {
     try {
-      text = decodeSource(readFileSync3(filePath));
+      text = decodeSource(readFileSync4(filePath));
     } catch {
       return null;
     }
@@ -4820,19 +5176,32 @@ export {
   extractChangelogVersionHint,
   isImagePath,
   isNonTextAsset,
+  ORT_WEB_VERSION,
+  ORT_WEB_WASM,
+  NATIVE_RUNTIME_INSTALL,
+  RUNTIME_UNAVAILABLE_ADVICE,
+  activeRuntime,
+  nativeRuntimeLoadError,
+  runtimeVersion,
+  wasmBinaryPresent,
+  ensureWasmBinary,
+  DEFAULT_MODEL,
+  modelDir,
   modelFilesPresent,
   ensureModelFiles,
   checkEmbeddingPreflight,
+  DEFAULT_DISTANCE_THRESHOLD,
   OVER_FETCH_FACTOR,
   MAX_OVER_FETCH,
   isAvailable,
   embeddingBackendLoadError,
   embedTexts,
   searchSemantic,
-  mergeNearbyHits,
   embeddingsDepsAvailable,
   deleteFileEmbeddings,
   ensureEmbeddingProvenance,
+  withDeclaredSkipScopeRoot,
+  hasSkipSegmentBelowRoot,
   parserFingerprintForLanguage,
   treeSitterCoreAvailable,
   treeSitterCoreLoadError,