token-goat 2.9.13 → 2.9.15

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

@@ -0,0 +1,2430 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  registerReset
+} from "./token-goat-chunk-EEIDFMEM.mjs";
+import {
+  Database
+} from "./token-goat-chunk-OSUFN2FV.mjs";
+import {
+  SYMBOL_BODY_CHAR_CAP,
+  countContentLines,
+  dataDir,
+  ensureDirSync,
+  escapeRegExp,
+  foldCase,
+  foldPath,
+  sleepSync
+} from "./token-goat-chunk-PM76YS22.mjs";
+import {
+  safeJoin
+} from "./token-goat-chunk-ERTXEKB6.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/languages/common.ts
+init_define_import_meta_env();
+
+// src/doc_comment.ts
+init_define_import_meta_env();
+function precedingDocComment(lines, lineStart, style) {
+  const aboveIdx = lineStart - 2;
+  if (aboveIdx < 0 || aboveIdx >= lines.length) return "";
+  const aboveLine = lines[aboveIdx];
+  if (aboveLine === void 0) return "";
+  const aboveTrimmed = aboveLine.trim();
+  if (style === "vb") {
+    if (!aboveTrimmed.startsWith("'''")) return "";
+    const collected = [];
+    for (let i = aboveIdx; i >= 0; i--) {
+      const trimmed = (lines[i] ?? "").trim();
+      if (!trimmed.startsWith("'''")) break;
+      collected.unshift(trimmed.replace(/^'''\s?/, ""));
+    }
+    return collected.join("\n").trim();
+  }
+  if (style === "hash") {
+    if (!aboveTrimmed.startsWith("#")) return "";
+    const collected = [];
+    let i = aboveIdx;
+    while (i >= 0) {
+      const line = lines[i];
+      if (line === void 0) break;
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("#")) break;
+      collected.unshift(trimmed.replace(/^#+\s?/, ""));
+      i--;
+    }
+    return collected.join("\n").trim();
+  }
+  if (aboveTrimmed.endsWith("*/")) {
+    let blockStart = aboveIdx;
+    while (blockStart >= 0) {
+      const l = lines[blockStart];
+      if (l === void 0) break;
+      if (l.trim().startsWith("/*")) break;
+      blockStart--;
+    }
+    if (blockStart < 0) return "";
+    const opener = lines[blockStart];
+    if (opener === void 0 || !opener.trim().startsWith("/*")) return "";
+    const region = lines.slice(blockStart, aboveIdx + 1);
+    const joined = region.join("\n").trimEnd();
+    if (joined.indexOf("*/") !== joined.length - 2) return "";
+    return region.map(
+      (l) => l.trim().replace(/^\/\*+/, "").replace(/\*+\/$/, "").replace(/^\*\s?/, "").trim()
+    ).filter((l) => l !== "").join("\n");
+  }
+  if (aboveTrimmed.startsWith("//")) {
+    const collected = [];
+    let i = aboveIdx;
+    while (i >= 0) {
+      const line = lines[i];
+      if (line === void 0) break;
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("//")) break;
+      collected.unshift(trimmed.replace(/^\/\/[/!]?\s?/, ""));
+      i--;
+    }
+    return collected.join("\n").trim();
+  }
+  return "";
+}
+
+// src/languages/common.ts
+function buildLineIndex(text) {
+  const idx = [0];
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] === "\n") idx.push(i + 1);
+  }
+  return idx;
+}
+function offsetToLine(lineIndex, offset) {
+  let lo = 0;
+  let hi = lineIndex.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    const lineStart = lineIndex[mid];
+    if (lineStart === void 0 || lineStart > offset) {
+      hi = mid - 1;
+    } else {
+      lo = mid;
+    }
+  }
+  return lo + 1;
+}
+function stripCstyleComments(text, lineCommentRe) {
+  const lines = text.split("\n");
+  let inComment = false;
+  const outLines = [];
+  for (const line of lines) {
+    const { code, inComment: nextInComment } = stripBlockCommentSpan(line, inComment);
+    outLines.push(code);
+    inComment = nextInComment;
+  }
+  let out = outLines.join("\n");
+  if (lineCommentRe !== void 0) {
+    out = out.replace(lineCommentRe, (m) => " ".repeat(m.length));
+  }
+  return out;
+}
+function stripXmlComments(text) {
+  const lines = text.split("\n");
+  let inComment = false;
+  const outLines = [];
+  for (const line of lines) {
+    let result = "";
+    let j = 0;
+    while (j < line.length) {
+      if (!inComment) {
+        const open = line.indexOf("<!--", j);
+        if (open === -1) {
+          result += line.slice(j);
+          break;
+        }
+        result += line.slice(j, open);
+        const close = line.indexOf("-->", open + 4);
+        if (close === -1) {
+          result += " ".repeat(line.length - open);
+          inComment = true;
+          break;
+        }
+        result += " ".repeat(close + 3 - open);
+        j = close + 3;
+        inComment = false;
+      } else {
+        const close = line.indexOf("-->", j);
+        if (close === -1) {
+          result += " ".repeat(line.length - j);
+          break;
+        }
+        result += " ".repeat(close + 3 - j);
+        j = close + 3;
+        inComment = false;
+      }
+    }
+    outLines.push(result);
+  }
+  return outLines.join("\n");
+}
+function scanQuotedStringEnd(content, start) {
+  const quote = content[start];
+  const n = content.length;
+  let j = start + 1;
+  while (j < n) {
+    if (content[j] === "\\" && j + 1 < n) {
+      j += 2;
+      continue;
+    }
+    if (content[j] === quote) {
+      j++;
+      break;
+    }
+    if (quote !== "`" && content[j] === "\n") {
+      j++;
+      break;
+    }
+    j++;
+  }
+  return j;
+}
+function stripJsComments(content) {
+  let out = "";
+  let i = 0;
+  const n = content.length;
+  while (i < n) {
+    const ch = content[i];
+    if (ch === "/" && content[i + 1] === "/") {
+      let j = i;
+      while (j < n && content[j] !== "\n") j++;
+      out += " ".repeat(j - i);
+      i = j;
+      continue;
+    }
+    if (ch === "/" && content[i + 1] === "*") {
+      let j = i + 2;
+      while (j < n && !(content[j] === "*" && content[j + 1] === "/")) j++;
+      const end = j < n ? j + 2 : n;
+      out += content.slice(i, end).replace(/[^\n]/g, " ");
+      i = end;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const j = scanQuotedStringEnd(content, i);
+      out += content.slice(i, j);
+      i = j;
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  return out;
+}
+function stripHashComments(text) {
+  return text.split("\n").map((line) => {
+    for (let i = 0; i < line.length; i++) {
+      if (line[i] === "#" && !isInsideStringLiteral(line, i)) {
+        return line.slice(0, i) + " ".repeat(line.length - i);
+      }
+    }
+    return line;
+  }).join("\n");
+}
+var HTML_COMMENT_RE = /<!--[\s\S]*?-->/g;
+var HTML_SCRIPT_BODY_RE = /(<script\b[^>]*>)([\s\S]*?)(<\/script\s*>)/gi;
+var HTML_CDATA_RE = /<!\[CDATA\[[\s\S]*?\]\]>/g;
+var LIQUID_COMMENT_RE = /{%-?\s*comment\s*-?%}[\s\S]*?{%-?\s*endcomment\s*-?%}/gi;
+function maskHtmlNoise(text) {
+  let out = text.replace(
+    HTML_SCRIPT_BODY_RE,
+    (_m, open, body, close) => open + body.replace(/[^\n]/g, " ") + close
+  );
+  out = out.replace(HTML_COMMENT_RE, (m) => m.replace(/[^\n]/g, " "));
+  out = out.replace(LIQUID_COMMENT_RE, (m) => m.replace(/[^\n]/g, " "));
+  out = out.replace(HTML_CDATA_RE, (m) => m.replace(/[^\n]/g, " "));
+  return out;
+}
+var HTML_HEADING_RE = /<h([1-6])[^>]*>(.*?)<\/h\1>/gis;
+var HTML_HEADING_TAG_STRIP_RE = /<[^>]+>/g;
+function findHtmlHeadingMatches(content) {
+  const masked = maskHtmlNoise(content);
+  const matches = [];
+  for (const m of masked.matchAll(HTML_HEADING_RE)) {
+    const level = parseInt(m[1] ?? "1", 10);
+    const raw = m[2] ?? "";
+    const heading = raw.replace(HTML_HEADING_TAG_STRIP_RE, "").trim();
+    matches.push({ level, heading, offset: m.index ?? 0, tag: m[0] ?? "" });
+  }
+  return matches;
+}
+function isInsideStringLiteral(line, index, from = 0, opts = {}) {
+  let openQuote = null;
+  let i = from;
+  while (i < index) {
+    const ch = line[i];
+    if (opts.symbolLiterals === true && openQuote === null && ch === "'") {
+      const len = scalaCharLiteralLength(line, i);
+      i += len === 0 ? 1 : len;
+      continue;
+    }
+    if (openQuote !== null && ch === "\\" && i + 1 < line.length) {
+      i += 2;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      if (openQuote === null) {
+        openQuote = ch;
+      } else if (openQuote === ch) {
+        openQuote = null;
+      }
+    }
+    i++;
+  }
+  return openQuote !== null;
+}
+function nextBlockCommentOpen(line, from) {
+  const lineCommentIdx = lineCommentStartIndex(line, ["//"], from);
+  let open = line.indexOf("/*", from);
+  while (open !== -1 && (isInsideStringLiteral(line, open, from) || lineCommentIdx !== -1 && open >= lineCommentIdx)) {
+    open = line.indexOf("/*", open + 1);
+  }
+  return open;
+}
+function stripBlockCommentSpan(line, inComment) {
+  let code = "";
+  let j = 0;
+  let comment = inComment;
+  while (j < line.length) {
+    if (!comment) {
+      const open = nextBlockCommentOpen(line, j);
+      if (open === -1) {
+        code += line.slice(j);
+        break;
+      }
+      code += line.slice(j, open);
+      const close = line.indexOf("*/", open + 2);
+      if (close === -1) {
+        code += " ".repeat(line.length - open);
+        comment = true;
+        break;
+      }
+      code += " ".repeat(close + 2 - open);
+      j = close + 2;
+      comment = false;
+    } else {
+      const close = line.indexOf("*/", j);
+      if (close === -1) {
+        code += " ".repeat(line.length - j);
+        break;
+      }
+      code += " ".repeat(close + 2 - j);
+      j = close + 2;
+      comment = false;
+    }
+  }
+  return { code, inComment: comment };
+}
+function stripNestedBlockCommentSpan(line, depth) {
+  let code = "";
+  let j = 0;
+  let d = depth;
+  while (j < line.length) {
+    if (d === 0) {
+      const open = nextBlockCommentOpen(line, j);
+      if (open === -1) {
+        code += line.slice(j);
+        break;
+      }
+      code += line.slice(j, open);
+      code += "  ";
+      j = open + 2;
+      d = 1;
+    } else {
+      const open = line.indexOf("/*", j);
+      const close = line.indexOf("*/", j);
+      if (close === -1 && open === -1) {
+        code += " ".repeat(line.length - j);
+        break;
+      }
+      const next = close === -1 ? open : open === -1 ? close : Math.min(open, close);
+      code += " ".repeat(next + 2 - j);
+      d = Math.max(0, d + (next === open ? 1 : -1));
+      j = next + 2;
+    }
+  }
+  return { code, depth: d };
+}
+function stripLineComment(line, markers = ["//"], opts = {}) {
+  const cutIdx = lineCommentStartIndex(line, markers, 0, opts);
+  return cutIdx === -1 ? line : line.slice(0, cutIdx);
+}
+function lineCommentStartIndex(line, markers, from = 0, opts = {}) {
+  let cutIdx = -1;
+  for (const marker of markers) {
+    let idx = line.indexOf(marker, from);
+    while (idx !== -1 && isInsideStringLiteral(line, idx, from, opts)) {
+      idx = line.indexOf(marker, idx + 1);
+    }
+    if (idx !== -1 && (cutIdx === -1 || idx < cutIdx)) cutIdx = idx;
+  }
+  return cutIdx;
+}
+function scalaCharLiteralLength(line, index) {
+  if (line[index] !== "'") return 0;
+  if (line[index + 1] === "\\") {
+    if (line[index + 2] === "u") {
+      let i = index + 3;
+      while (line[i] === "u") i++;
+      return /^[0-9a-fA-F]{4}$/.test(line.slice(i, i + 4)) && line[i + 4] === "'" ? i + 5 - index : 0;
+    }
+    return line[index + 2] !== void 0 && line[index + 3] === "'" ? 4 : 0;
+  }
+  return line[index + 1] !== void 0 && line[index + 1] !== "'" && line[index + 2] === "'" ? 3 : 0;
+}
+function stripStringLiterals(line, opts = {}) {
+  const openDelim = (idx) => {
+    const q = line[idx];
+    if (opts.tripleQuotes && line[idx + 1] === q && line[idx + 2] === q) return q + q + q;
+    return q;
+  };
+  let out = "";
+  let i = 0;
+  const stack = [];
+  while (i < line.length) {
+    const ch = line[i];
+    if (ch === "\n") {
+      out += ch;
+      i++;
+      stack.length = 0;
+      continue;
+    }
+    const top = stack[stack.length - 1];
+    if (top === void 0) {
+      if (opts.symbolLiterals === true && ch === "'" && scalaCharLiteralLength(line, i) === 0) {
+        out += ch;
+        i++;
+        continue;
+      }
+      if (ch === '"' || ch === "'") {
+        const bareBraceHole = ch === '"' && i > 0 && line[i - 1] === "$";
+        const delim = openDelim(i);
+        stack.push({ kind: "string", quote: delim, bareBraceHole });
+        out += delim;
+        i += delim.length;
+        continue;
+      }
+      out += ch;
+      i++;
+      continue;
+    }
+    if (top.kind === "hole") {
+      if (opts.symbolLiterals === true && ch === "'" && scalaCharLiteralLength(line, i) === 0) {
+        out += ch;
+        i++;
+        continue;
+      }
+      if (ch === '"' || ch === "'") {
+        const bareBraceHole = ch === '"' && i > 0 && line[i - 1] === "$";
+        const delim = openDelim(i);
+        stack.push({ kind: "string", quote: delim, bareBraceHole });
+        out += delim;
+        i += delim.length;
+        continue;
+      }
+      if (ch === "{") {
+        top.depth++;
+        out += ch;
+        i++;
+        continue;
+      }
+      if (ch === "}") {
+        if (top.depth > 0) {
+          top.depth--;
+        } else {
+          stack.pop();
+        }
+        out += ch;
+        i++;
+        continue;
+      }
+      out += ch;
+      i++;
+      continue;
+    }
+    if (ch === "\\" && i + 1 < line.length && line[i + 1] !== "\n") {
+      out += "  ";
+      i += 2;
+      continue;
+    }
+    if (ch === top.quote[0] && (top.quote.length === 1 || line.startsWith(top.quote, i))) {
+      stack.pop();
+      out += top.quote;
+      i += top.quote.length;
+      continue;
+    }
+    if (top.quote === '"') {
+      if (top.bareBraceHole && ch === "{") {
+        if (line[i + 1] === "{") {
+          out += "  ";
+          i += 2;
+          continue;
+        }
+        stack.push({ kind: "hole", depth: 0 });
+        out += ch;
+        i++;
+        continue;
+      }
+      if (!top.bareBraceHole && ch === "$" && line[i + 1] === "{") {
+        stack.push({ kind: "hole", depth: 0 });
+        out += line.slice(i, i + 2);
+        i += 2;
+        continue;
+      }
+      if (!top.bareBraceHole && ch === "{" && line[i + 1] === "$") {
+        stack.push({ kind: "hole", depth: 0 });
+        out += ch;
+        i++;
+        continue;
+      }
+    }
+    out += " ";
+    i++;
+  }
+  return out;
+}
+function closingQuoteRunEnd(text, from, quote, len, runClose) {
+  for (let i = from; i < text.length; i++) {
+    if (text[i] !== quote) continue;
+    let run = 0;
+    while (text[i + run] === quote) run++;
+    if (run >= len) return runClose === "last" ? i + run : i + len;
+    i += run - 1;
+  }
+  return -1;
+}
+var MULTILINE_CLOSER_ANCHOR = {
+  // An Elixir heredoc is terminated only by a delimiter run that begins its own line, preceded by nothing but the whitespace that also sets the indentation stripped from the body (Elixir syntax reference, section "Strings", heredocs). A run appearing mid-line inside the body is content.
+  elixir: "lineStart",
+  // The closing delimiter of a Swift multi-line string literal has to appear on a line of its own, and its indentation sets what is stripped from each body line (The Swift Programming Language, "Strings and Characters", section "Multiline String Literals"). The same section's rules apply to the extended-delimiter multi-line form (`#"""`), whose only reachable state here is the cross-line one.
+  swift: "lineStart",
+  // A PHP heredoc or nowdoc closes on its identifier at the start of a line; PHP 7.3 allowed that identifier to be indented and to be followed by other characters (PHP language reference, "Strings", section "Heredoc text"). Read by the heredoc/nowdoc branch, which builds its anchor regex from this value.
+  php: "lineStart",
+  // A PowerShell here-string terminator (`"@` / `'@`) must be the first characters on its line, with no leading whitespace at all, which is the one language here that is stricter than `'lineStart'` (about_Quoting_Rules, "Here-Strings").
+  powershell: "column0",
+  // Kotlin's raw string is terminated by the next `"""` wherever it falls, so `val s = """a"""` on one line is a complete literal (Kotlin language specification, "Expressions", section "String literals").
+  kotlin: "anywhere",
+  // Scala's multi-line string literal is likewise terminated by the next run of three quotes on any line (Scala language specification, section 1.3.5 "Character Literals and String Literals").
+  scala: "anywhere",
+  // Dart's multi-line string production is a delimiter, content, then the delimiter, with no rule about where on a line the closing delimiter falls (Dart Programming Language Specification, section "Strings").
+  dart: "anywhere",
+  // A GraphQL block string closes at the next `"""` wherever it sits: the spec's BlockString production places no positional rule on the closing delimiter, and a one-line description such as `"""A user."""` is the ordinary form (GraphQL specification, section 2.9.4 "String Value").
+  graphql: "anywhere",
+  // C# has two cross-line forms and they disagree, so the language-level value is the permissive one. A verbatim string (`@"..."`) closes on the next non-doubled quote wherever it sits and has no positional rule (C# language reference, "String literals"). A multi-line raw string literal does require its closing run to begin its own line (C# language reference, "Raw string literals"), but that rule is unreachable as a mis-pairing here: the same section forbids the content from holding a quote run as long as the delimiter, so no run inside the body can be mistaken for the closer in the first place, and the run-length rule already in `closingQuoteRunEnd` is what enforces it.
+  csharp: "anywhere",
+  // R has no fixed-delimiter multi-line form and no positional rule: an ordinary character constant runs to its next unescaped quote (R Language Definition, section 10.3.1 "Literal constants") and a raw constant to its mirrored closing punctuation (R base help page `?Quotes`, "Raw character constants"), on whatever line either lands.
+  r: "anywhere"
+};
+function closerSearchStart(line, from, anchor) {
+  if (anchor === "anywhere") return from;
+  const indent = anchor === "column0" ? 0 : /^[ \t]*/.exec(line)?.[0].length ?? 0;
+  return from <= indent ? indent : -1;
+}
+var TRIPLE_QUOTE_RUN_CLOSE = {
+  kotlin: "last",
+  scala: "last",
+  // A GraphQL block string ends at the first `"""` run, because its grammar excludes that sequence from the body outright rather than letting the longest run win (GraphQL specification, section 2.9.4 "String Value", the BlockString production).
+  graphql: "first",
+  // Swift's closing delimiter has to stand alone on its own line (The Swift Programming Language, "Strings and Characters", section "Multiline String Literals"), so no run longer than three ever terminates a valid Swift literal; it is grouped with Kotlin and Scala so that the same-line and cross-line paths agree, not to assert a rule Swift itself defines.
+  swift: "last",
+  csharp: "last",
+  // An Elixir heredoc cannot open and close on one line, because its opening `"""` must be followed by a newline, so only the cross-line closer is reachable for valid Elixir and that path has always consumed the whole run.
+  elixir: "last",
+  dart: "first",
+  // No triple-quoted literal at all: PHP uses heredoc/nowdoc, PowerShell `@"`/`@'` here-strings, R ordinary and raw character constants. Present only because the Record is exhaustive; the value is never read for these three.
+  php: "last",
+  powershell: "last",
+  r: "last"
+};
+function quoteRunCloser(line, from, quote, len, state) {
+  const anchor = state.closerAnchor ?? "anywhere";
+  const start = closerSearchStart(line, from, anchor);
+  if (start === -1) return null;
+  if (anchor !== "anywhere") {
+    let run = 0;
+    while (line[start + run] === quote) run++;
+    if (run < len) return null;
+  }
+  const end = closingQuoteRunEnd(line, start, quote, len, state.runClose ?? "last");
+  return end === -1 ? null : { maskEnd: end };
+}
+function findMultilineCloser(line, from, state) {
+  switch (state.kind) {
+    case "heredoc":
+    case "nowdoc": {
+      const indent = (state.closerAnchor ?? "anywhere") === "column0" ? "" : "[ \\t]*";
+      const re = new RegExp(`^${indent}${escapeRegExp(state.identifier)}\\b`);
+      const m = re.exec(line);
+      return m ? { maskEnd: m[0].length } : null;
+    }
+    case "sigil": {
+      const end = elixirSigilEnd(line, from, state);
+      return end === -1 ? null : { maskEnd: end };
+    }
+    case "tripleSingleQuote": {
+      return quoteRunCloser(line, from, "'", 3, state);
+    }
+    case "tripleQuote": {
+      const n = state.identifier !== "" ? parseInt(state.identifier, 10) : 3;
+      return quoteRunCloser(line, from, '"', n, state);
+    }
+    case "rRaw":
+    case "swiftExtended": {
+      const anchor = state.closerAnchor ?? "anywhere";
+      if (anchor !== "anywhere") {
+        const start = closerSearchStart(line, from, anchor);
+        if (start === -1 || !line.startsWith(state.identifier, start)) return null;
+        return { maskEnd: start + state.identifier.length };
+      }
+      const idx = line.indexOf(state.identifier, from);
+      return idx === -1 ? null : { maskEnd: idx + state.identifier.length };
+    }
+    case "rString": {
+      const idx = findRQuoteEnd(line, from, state.identifier);
+      return idx === -1 ? null : { maskEnd: idx + 1 };
+    }
+    case "verbatim": {
+      if (!state.interpolated) {
+        let j2 = from;
+        while (j2 < line.length) {
+          if (line[j2] === '"') {
+            if (line[j2 + 1] === '"') {
+              j2 += 2;
+              continue;
+            }
+            return { maskEnd: j2 + 1 };
+          }
+          j2++;
+        }
+        return null;
+      }
+      let j = from;
+      let holeDepth = 0;
+      let nestedQuote = null;
+      while (j < line.length) {
+        const c = line[j];
+        if (nestedQuote !== null) {
+          if (c === "\\" && j + 1 < line.length) {
+            j += 2;
+            continue;
+          }
+          if (c === nestedQuote) {
+            nestedQuote = null;
+          }
+          j++;
+          continue;
+        }
+        if (holeDepth > 0) {
+          if (c === '"' || c === "'") {
+            nestedQuote = c;
+            j++;
+            continue;
+          }
+          if (c === "{") holeDepth++;
+          else if (c === "}") holeDepth--;
+          j++;
+          continue;
+        }
+        if (c === "{") {
+          holeDepth = 1;
+          j++;
+          continue;
+        }
+        if (c === '"') {
+          if (line[j + 1] === '"') {
+            j += 2;
+            continue;
+          }
+          return { maskEnd: j + 1 };
+        }
+        j++;
+      }
+      return null;
+    }
+    case "psHereDouble":
+    case "psHereSingle": {
+      const start = closerSearchStart(line, from, state.closerAnchor ?? "anywhere");
+      const terminator = state.kind === "psHereDouble" ? '"@' : "'@";
+      if (start === -1 || !line.startsWith(terminator, start)) return null;
+      return { maskEnd: start + terminator.length };
+    }
+    default:
+      return null;
+  }
+}
+var MULTILINE_OPENER_COMMENT_MARKERS = {
+  php: ["//", "#"],
+  kotlin: ["//"],
+  graphql: ["#"],
+  csharp: ["//"],
+  powershell: ["#"],
+  swift: ["//"],
+  elixir: ["#"],
+  scala: ["//"],
+  dart: ["//"],
+  r: ["#"]
+};
+var MULTILINE_OPENER_BLOCK_COMMENT_LANGS = /* @__PURE__ */ new Set(["php", "kotlin", "csharp", "swift", "scala", "dart"]);
+var R_RAW_OPENER_RE = /[rR](["'])(-*)([([{])/y;
+var R_RAW_CLOSE_BRACKET = { "(": ")", "[": "]", "{": "}" };
+var R_IDENT_CHAR_RE = /[A-Za-z0-9._]/;
+function matchRRawOpener(text, index) {
+  const ch = text[index];
+  if (ch !== "r" && ch !== "R") return null;
+  if (R_IDENT_CHAR_RE.test(text[index - 1] ?? "")) return null;
+  R_RAW_OPENER_RE.lastIndex = index;
+  const m = R_RAW_OPENER_RE.exec(text);
+  if (m === null) return null;
+  const close = R_RAW_CLOSE_BRACKET[m[3] ?? ""];
+  if (close === void 0) return null;
+  return { openerEnd: index + m[0].length, closer: `${close}${m[2] ?? ""}${m[1] ?? ""}` };
+}
+var GROOVY_OPERAND_BEFORE = /* @__PURE__ */ new Set([..."([{,;=+-*/%<>!&|^~?:"]);
+var MAX_GROOVY_SLASHY_BODY = 1024;
+var GROOVY_OPERAND_KEYWORDS = /* @__PURE__ */ new Set(["return", "case", "in", "new", "assert", "instanceof"]);
+function groovyOperandPosition(text, index) {
+  let i = index - 1;
+  while (i >= 0 && (text[i] === " " || text[i] === "	")) i--;
+  if (i < 0) return true;
+  const ch = text[i];
+  if (ch === "\n" || ch === "\r") return true;
+  if (GROOVY_OPERAND_BEFORE.has(ch)) return true;
+  if (!/[\w$]/.test(ch)) return false;
+  let j = i;
+  while (j >= 0 && /[\w$]/.test(text[j])) j--;
+  return GROOVY_OPERAND_KEYWORDS.has(text.slice(j + 1, i + 1));
+}
+function matchGroovySlashy(text, index) {
+  const dollar = text[index] === "$" && text[index + 1] === "/";
+  if (!dollar) {
+    if (text[index] !== "/") return null;
+    const next = text[index + 1];
+    if (next === "/" || next === "*") return null;
+    if (!groovyOperandPosition(text, index)) return null;
+  }
+  const bodyStart = index + (dollar ? 2 : 1);
+  const limit = Math.min(text.length, bodyStart + MAX_GROOVY_SLASHY_BODY);
+  for (let i = bodyStart; i < limit; i++) {
+    const ch = text[i];
+    if (dollar) {
+      if (ch === "$" && (text[i + 1] === "$" || text[i + 1] === "/")) {
+        i++;
+        continue;
+      }
+      if (ch === "/" && text[i + 1] === "$") return { bodyStart, bodyEnd: i, end: i + 2 };
+      continue;
+    }
+    if (ch === "\\" && text[i + 1] === "/") {
+      i++;
+      continue;
+    }
+    if (ch === "\n") return null;
+    if (ch === "/") return { bodyStart, bodyEnd: i, end: i + 1 };
+  }
+  return null;
+}
+var ELIXIR_SIGIL_CLOSER = { "(": ")", "[": "]", "{": "}", "<": ">", "/": "/", "|": "|", '"': '"', "'": "'" };
+var ELIXIR_SIGIL_OPENER = { ")": "(", "]": "[", "}": "{", ">": "<" };
+function matchElixirSigilOpener(line, index) {
+  if (line[index] !== "~") return null;
+  let i = index + 1;
+  const first = line[i] ?? "";
+  let escapes;
+  if (first >= "a" && first <= "z") {
+    escapes = true;
+    i++;
+  } else if (first >= "A" && first <= "Z") {
+    escapes = false;
+    while (i < line.length && (line[i] ?? "") >= "A" && (line[i] ?? "") <= "Z") i++;
+  } else {
+    return null;
+  }
+  const delim = line[i] ?? "";
+  const closer = ELIXIR_SIGIL_CLOSER[delim];
+  if (closer === void 0) return null;
+  if ((delim === '"' || delim === "'") && line[i + 1] === delim && line[i + 2] === delim) return null;
+  return { openerEnd: i + 1, closer, escapes };
+}
+function elixirSigilEnd(line, from, state) {
+  const closer = state.identifier;
+  const opener = ELIXIR_SIGIL_OPENER[closer];
+  for (let i = from; i < line.length; i++) {
+    const ch = line[i];
+    if (state.escapes === true && ch === "\\") {
+      i++;
+      continue;
+    }
+    if (opener !== void 0 && ch === opener) {
+      state.depth = (state.depth ?? 0) + 1;
+      continue;
+    }
+    if (ch === closer) {
+      if ((state.depth ?? 0) > 0) {
+        state.depth = (state.depth ?? 0) - 1;
+        continue;
+      }
+      return i + 1;
+    }
+  }
+  return -1;
+}
+var SWIFT_EXTENDED_OPENER_RE = /(#+)("""|")/y;
+function matchSwiftExtendedOpener(text, index) {
+  if (text[index] !== "#") return null;
+  SWIFT_EXTENDED_OPENER_RE.lastIndex = index;
+  const m = SWIFT_EXTENDED_OPENER_RE.exec(text);
+  if (m === null) return null;
+  const hashes = m[1] ?? "";
+  const multiline = m[2] === '"""';
+  return { openerEnd: index + m[0].length, multiline, closer: `${multiline ? '"""' : '"'}${hashes}` };
+}
+var BASH_WORD_TERMINATORS = /* @__PURE__ */ new Set([" ", "	", "\n", "|", "&", ";", "(", ")", "<", ">"]);
+function matchBashHeredocOpener(text, index) {
+  if (text[index] !== "<" || text[index + 1] !== "<") return null;
+  if (text[index - 1] === "<" || text[index + 2] === "<") return null;
+  let i = index + 2;
+  if (text[i] === "-") i++;
+  while (text[i] === " " || text[i] === "	") i++;
+  let terminator = "";
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === "'") {
+      const close = text.indexOf("'", i + 1);
+      if (close === -1) return null;
+      terminator += text.slice(i + 1, close);
+      i = close + 1;
+      continue;
+    }
+    if (ch === '"') {
+      let j = i + 1;
+      for (; j < text.length; j++) {
+        if (text[j] === "\\") {
+          terminator += text[j + 1] ?? "";
+          j++;
+          continue;
+        }
+        if (text[j] === '"') break;
+        terminator += text[j];
+      }
+      if (j >= text.length) return null;
+      i = j + 1;
+      continue;
+    }
+    if (ch === "\\") {
+      if (i + 1 >= text.length) break;
+      terminator += text[i + 1];
+      i += 2;
+      continue;
+    }
+    if (ch === void 0 || BASH_WORD_TERMINATORS.has(ch)) break;
+    terminator += ch;
+    i++;
+  }
+  if (terminator === "") return null;
+  return { openerEnd: i, terminator };
+}
+function findRQuoteEnd(line, start, quote) {
+  for (let j = start; j < line.length; j++) {
+    const c = line[j];
+    if (c === "\\") {
+      j++;
+      continue;
+    }
+    if (c === quote) return j;
+  }
+  return -1;
+}
+function isInsideSameLineBlockComment(line, idx, from = 0) {
+  let comment = false;
+  let j = from;
+  while (j < idx) {
+    if (!comment) {
+      const open = line.indexOf("/*", j);
+      if (open === -1 || open >= idx) return false;
+      if (isInsideStringLiteral(line, open, from)) {
+        j = open + 2;
+        continue;
+      }
+      comment = true;
+      j = open + 2;
+    } else {
+      const close = line.indexOf("*/", j);
+      if (close === -1 || close >= idx) return true;
+      comment = false;
+      j = close + 2;
+    }
+  }
+  return comment;
+}
+function findMultilineOpener(line, from, lang) {
+  const commentIdx = lineCommentStartIndex(line, MULTILINE_OPENER_COMMENT_MARKERS[lang], from);
+  const isCommented = (idx) => commentIdx !== -1 && idx >= commentIdx || MULTILINE_OPENER_BLOCK_COMMENT_LANGS.has(lang) && isInsideSameLineBlockComment(line, idx, from);
+  if (lang === "php") {
+    const re = /<<<\s*(['"]?)([A-Za-z_]\w*)\1/g;
+    re.lastIndex = from;
+    const m = re.exec(line);
+    if (!m || isInsideStringLiteral(line, m.index, from) || isCommented(m.index)) return null;
+    const identifier = m[2] ?? "";
+    const kind = m[1] === "'" ? "nowdoc" : "heredoc";
+    return { openStart: m.index, closesSameLine: null, state: { kind, identifier, closerAnchor: MULTILINE_CLOSER_ANCHOR[lang] } };
+  }
+  if (lang === "kotlin" || lang === "swift" || lang === "scala" || lang === "graphql") {
+    let swiftExt = null;
+    if (lang === "swift") {
+      for (let h = line.indexOf("#", from); h !== -1; h = line.indexOf("#", h + 1)) {
+        const ext = matchSwiftExtendedOpener(line, h);
+        if (ext === null || isInsideStringLiteral(line, h, from) || isCommented(h)) continue;
+        const extClose = line.indexOf(ext.closer, ext.openerEnd);
+        const extState = { kind: "swiftExtended", identifier: ext.closer, closerAnchor: MULTILINE_CLOSER_ANCHOR[lang] };
+        if (extClose !== -1) {
+          swiftExt = { openStart: h, closesSameLine: extClose + ext.closer.length, state: extState };
+          break;
+        }
+        if (ext.multiline) {
+          swiftExt = { openStart: h, closesSameLine: null, state: extState };
+          break;
+        }
+      }
+    }
+    const idx = line.indexOf('"""', from);
+    if (swiftExt !== null && (idx === -1 || swiftExt.openStart < idx)) return swiftExt;
+    if (idx === -1 || isInsideStringLiteral(line, idx, from) || isCommented(idx)) return null;
+    const runClose = TRIPLE_QUOTE_RUN_CLOSE[lang];
+    const tripleState = { kind: "tripleQuote", identifier: "3", runClose, closerAnchor: MULTILINE_CLOSER_ANCHOR[lang] };
+    const closeEnd = closingQuoteRunEnd(line, idx + 3, '"', 3, runClose);
+    if (closeEnd !== -1) {
+      return { openStart: idx, closesSameLine: closeEnd, state: tripleState };
+    }
+    return { openStart: idx, closesSameLine: null, state: tripleState };
+  }
+  if (lang === "elixir" || lang === "dart") {
+    const candidates = [];
+    const dq = line.indexOf('"""', from);
+    if (dq !== -1) candidates.push([dq, "tripleQuote", '"""']);
+    const sq = line.indexOf("'''", from);
+    if (sq !== -1) candidates.push([sq, "tripleSingleQuote", "'''"]);
+    candidates.sort((a, b) => a[0] - b[0]);
+    const first = candidates[0];
+    if (lang === "elixir") {
+      for (let t = line.indexOf("~", from); t !== -1; t = line.indexOf("~", t + 1)) {
+        if (first !== void 0 && first[0] < t) break;
+        const open = matchElixirSigilOpener(line, t);
+        if (open === null || isInsideStringLiteral(line, t, from) || isCommented(t)) continue;
+        const state2 = { kind: "sigil", identifier: open.closer, depth: 0, escapes: open.escapes };
+        const end = elixirSigilEnd(line, open.openerEnd, state2);
+        return { openStart: t, closesSameLine: end === -1 ? null : end, state: state2 };
+      }
+    }
+    if (first === void 0) return null;
+    const [idx, kind, delim] = first;
+    if (isInsideStringLiteral(line, idx, from) || isCommented(idx)) return null;
+    const runClose = TRIPLE_QUOTE_RUN_CLOSE[lang];
+    const state = { kind, identifier: "3", runClose, closerAnchor: MULTILINE_CLOSER_ANCHOR[lang] };
+    const closeEnd = closingQuoteRunEnd(line, idx + 3, delim[0] ?? '"', 3, runClose);
+    if (closeEnd !== -1) return { openStart: idx, closesSameLine: closeEnd, state };
+    return { openStart: idx, closesSameLine: null, state };
+  }
+  if (lang === "r") {
+    const limit = commentIdx === -1 ? line.length : commentIdx;
+    let i = from;
+    while (i < limit) {
+      const ch = line[i] ?? "";
+      if (ch === "`") {
+        const end = line.indexOf("`", i + 1);
+        if (end === -1 || end >= limit) return null;
+        i = end + 1;
+        continue;
+      }
+      const raw = matchRRawOpener(line, i);
+      if (raw !== null) {
+        const closeIdx = line.indexOf(raw.closer, raw.openerEnd);
+        if (closeIdx === -1) return { openStart: i, closesSameLine: null, state: { kind: "rRaw", identifier: raw.closer, closerAnchor: MULTILINE_CLOSER_ANCHOR[lang] } };
+        i = closeIdx + raw.closer.length;
+        continue;
+      }
+      if (ch === '"' || ch === "'") {
+        const closeIdx = findRQuoteEnd(line, i + 1, ch);
+        if (closeIdx === -1) return { openStart: i, closesSameLine: null, state: { kind: "rString", identifier: ch, closerAnchor: MULTILINE_CLOSER_ANCHOR[lang] } };
+        i = closeIdx + 1;
+        continue;
+      }
+      i++;
+    }
+    return null;
+  }
+  if (lang === "csharp") {
+    const tripleRe = /"{3,}/g;
+    tripleRe.lastIndex = from;
+    const tripleM = tripleRe.exec(line);
+    let tripleIdx = tripleM ? tripleM.index : -1;
+    const tripleLen = tripleM ? tripleM[0].length : 0;
+    if (tripleIdx !== -1 && (isInsideStringLiteral(line, tripleIdx, from) || isCommented(tripleIdx))) tripleIdx = -1;
+    const verbRe = /\$?@\$?"/g;
+    verbRe.lastIndex = from;
+    const verbM = verbRe.exec(line);
+    let verbIdx = verbM ? verbM.index : -1;
+    if (verbIdx !== -1 && isCommented(verbIdx)) verbIdx = -1;
+    if (verbIdx !== -1 && isInsideStringLiteral(line, verbIdx, from)) verbIdx = -1;
+    if (tripleIdx === -1 && verbIdx === -1) return null;
+    const useTriple = tripleIdx !== -1 && (verbIdx === -1 || tripleIdx < verbIdx);
+    if (useTriple) {
+      const rawState = { kind: "tripleQuote", identifier: String(tripleLen), runClose: TRIPLE_QUOTE_RUN_CLOSE.csharp, closerAnchor: MULTILINE_CLOSER_ANCHOR[lang] };
+      const closeEnd = closingQuoteRunEnd(line, tripleIdx + tripleLen, '"', tripleLen, rawState.runClose ?? "last");
+      if (closeEnd !== -1) {
+        return { openStart: tripleIdx, closesSameLine: closeEnd, state: rawState };
+      }
+      return { openStart: tripleIdx, closesSameLine: null, state: rawState };
+    }
+    const quoteIdx = verbIdx + (verbM?.[0].length ?? 1) - 1;
+    const interpolated = (verbM?.[0] ?? "").includes("$");
+    const closer = findMultilineCloser(line, quoteIdx + 1, { kind: "verbatim", identifier: "", interpolated });
+    if (closer !== null) {
+      return { openStart: verbIdx, closesSameLine: closer.maskEnd, state: { kind: "verbatim", identifier: "", interpolated } };
+    }
+    return { openStart: verbIdx, closesSameLine: null, state: { kind: "verbatim", identifier: "", interpolated } };
+  }
+  if (lang === "powershell") {
+    const re = /@("|')\s*$/;
+    const tail = line.slice(from);
+    const m = re.exec(tail);
+    if (!m) return null;
+    const openStart = from + m.index;
+    if (isCommented(openStart)) return null;
+    if (isInsideStringLiteral(line, openStart, from)) return null;
+    const kind = m[1] === '"' ? "psHereDouble" : "psHereSingle";
+    return { openStart, closesSameLine: null, state: { kind, identifier: "", closerAnchor: MULTILINE_CLOSER_ANCHOR[lang] } };
+  }
+  return null;
+}
+function stripMultilineStringSpan(line, state, lang) {
+  let code = "";
+  let i = 0;
+  let cur = state;
+  while (i < line.length) {
+    if (cur !== null) {
+      const closed = findMultilineCloser(line, i, cur);
+      if (closed === null) {
+        code += " ".repeat(line.length - i);
+        i = line.length;
+        continue;
+      }
+      code += " ".repeat(closed.maskEnd - i);
+      i = closed.maskEnd;
+      cur = null;
+      continue;
+    }
+    const opened = findMultilineOpener(line, i, lang);
+    if (opened === null) {
+      code += line.slice(i);
+      break;
+    }
+    code += line.slice(i, opened.openStart);
+    if (opened.closesSameLine !== null) {
+      code += " ".repeat(opened.closesSameLine - opened.openStart);
+      i = opened.closesSameLine;
+      cur = null;
+    } else {
+      code += " ".repeat(line.length - opened.openStart);
+      i = line.length;
+      cur = opened.state;
+    }
+  }
+  return { code, state: cur };
+}
+function makeSpanSymbol(filePath, name, kind, span, parent = "", lines, style) {
+  return {
+    filePath,
+    name,
+    kind,
+    lineStart: span.startLine,
+    lineEnd: span.endLine,
+    body: span.body,
+    docstring: lines !== void 0 && style !== void 0 ? precedingDocComment(lines, span.startLine, style) : "",
+    parent
+  };
+}
+function makeLineSymbol(filePath, name, kind, line, sig, parent, lines, style) {
+  return {
+    filePath,
+    name,
+    kind,
+    lineStart: line,
+    lineEnd: line,
+    body: sig ?? "",
+    docstring: lines !== void 0 && style !== void 0 ? precedingDocComment(lines, line, style) : "",
+    parent: parent ?? ""
+  };
+}
+function makeSymbolEmitter(symbols, sections, seen, filePath, maxSymbols = 1e4, maxHeadingLen = 120) {
+  return function emit(name, kind, line) {
+    if (!name || name.length > maxHeadingLen) return;
+    if (symbols.length >= maxSymbols) return;
+    const key = `${name}\0${kind}\0${line}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    symbols.push({
+      filePath,
+      name,
+      kind,
+      lineStart: line,
+      lineEnd: line,
+      body: "",
+      docstring: "",
+      parent: ""
+    });
+    sections.push({ heading: name, level: 1, line, endLine: line });
+  };
+}
+function assignFlatEndLines(sections, totalLines) {
+  for (let i = 0; i < sections.length; i++) {
+    const s = sections[i];
+    if (s === void 0) continue;
+    let j = i + 1;
+    while (j < sections.length && (sections[j]?.line ?? 0) <= s.line) j++;
+    const next = sections[j];
+    const end = next !== void 0 ? next.line - 1 : totalLines;
+    s.endLine = end < s.line ? s.line : end;
+  }
+}
+function propagateEndLinesToSymbols(symbols, sections) {
+  const sectionMap = /* @__PURE__ */ new Map();
+  for (const sec of sections) {
+    const key = `${sec.heading}\0${sec.line}`;
+    const queue = sectionMap.get(key);
+    if (queue !== void 0) queue.push(sec.endLine);
+    else sectionMap.set(key, [sec.endLine]);
+  }
+  return symbols.map((sym) => {
+    const key = `${sym.name}\0${sym.lineStart}`;
+    const endLine = sectionMap.get(key)?.shift();
+    if (endLine !== void 0 && endLine !== sym.lineEnd) {
+      return { ...sym, lineEnd: endLine };
+    }
+    return sym;
+  });
+}
+function tripleQuoteDelimiters(opts) {
+  const delims = [];
+  if (opts?.tripleQuote === true) delims.push('"""');
+  if (opts?.tripleSingleQuote === true) delims.push("'''");
+  return delims;
+}
+function quoteRunLength(content, i) {
+  let n = 0;
+  while (content[i + n] === '"') n++;
+  return n;
+}
+function skipRawStringQuotes(content, from, min) {
+  return closingQuoteRunEnd(content, from, '"', min, "last");
+}
+function stepPowershellString(content, i, quote) {
+  const ch = content[i];
+  if (quote === '"' && ch === "`") return { next: i + 1, open: true };
+  return { next: i, open: ch !== quote };
+}
+function opensCsharpVerbatimString(content, i) {
+  const prev = content[i - 1];
+  return prev === "@" || prev === "$" && content[i - 2] === "@";
+}
+function toLineCommentPrefixes(prefix) {
+  if (prefix === void 0) return [];
+  return typeof prefix === "string" ? [prefix] : prefix;
+}
+function atLineComment(content, i, prefixes, exceptions) {
+  if (exceptions.some((e) => content.startsWith(e, i))) return false;
+  return prefixes.some((prefix) => content.startsWith(prefix, i));
+}
+function skipBlockComment(content, start, block, nested) {
+  let i = start + block[0].length;
+  let depth = 1;
+  while (i < content.length) {
+    if (nested && content.startsWith(block[0], i)) {
+      depth++;
+      i += block[0].length;
+      continue;
+    }
+    if (content.startsWith(block[1], i)) {
+      depth--;
+      i += block[1].length;
+      if (depth === 0) return i;
+      continue;
+    }
+    i++;
+  }
+  return -1;
+}
+function findMatchingBraceEndLine(content, openBraceIndex, totalLines, lineIndex, lineCommentPrefix, opts) {
+  const linePrefixes = toLineCommentPrefixes(lineCommentPrefix);
+  const lineExceptions = opts?.lineCommentExceptions ?? [];
+  const block = opts?.blockComment;
+  const backtick = opts?.backtickQuote === true;
+  const escapes = opts?.stringEscapes ?? "backslash";
+  const nestedBlock = opts?.nestedBlockComments === true;
+  const rawString = opts?.rawStringQuotes === true;
+  const rRaw = opts?.rRawStrings === true;
+  const tripleDelims = tripleQuoteDelimiters(opts);
+  const lineString = opts?.lineStringPrefix;
+  let depth = 0;
+  let quote = null;
+  let verbatim = false;
+  for (let i = openBraceIndex; i < content.length; i++) {
+    const ch = content[i];
+    if (quote !== null) {
+      if (verbatim) {
+        if (ch === quote) {
+          if (content[i + 1] === quote) {
+            i++;
+            continue;
+          }
+          quote = null;
+          verbatim = false;
+        }
+        continue;
+      }
+      if (escapes === "powershell") {
+        const step = stepPowershellString(content, i, quote);
+        i = step.next;
+        if (!step.open) quote = null;
+        continue;
+      }
+      if (ch === "\\") {
+        i++;
+        continue;
+      }
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (block !== void 0 && content.startsWith(block[0], i)) {
+      const end = skipBlockComment(content, i, block, nestedBlock);
+      i = end === -1 ? content.length : end - 1;
+      continue;
+    }
+    if (atLineComment(content, i, linePrefixes, lineExceptions)) {
+      while (i < content.length && content[i] !== "\n") i++;
+      continue;
+    }
+    if (lineString !== void 0 && content.startsWith(lineString, i)) {
+      while (i < content.length && content[i] !== "\n") i++;
+      continue;
+    }
+    if (rRaw) {
+      const rOpen = matchRRawOpener(content, i);
+      if (rOpen !== null) {
+        const end = content.indexOf(rOpen.closer, rOpen.openerEnd);
+        i = end === -1 ? content.length : end + rOpen.closer.length - 1;
+        continue;
+      }
+    }
+    if (rawString && ch === '"') {
+      const run = quoteRunLength(content, i);
+      if (run >= 3) {
+        const end = skipRawStringQuotes(content, i + run, run);
+        i = end === -1 ? content.length : end - 1;
+        continue;
+      }
+    }
+    const tripleAt = tripleDelims.find((t) => content.startsWith(t, i));
+    if (tripleAt !== void 0) {
+      const end = closingQuoteRunEnd(content, i + 3, tripleAt[0] ?? '"', 3, opts?.tripleQuoteRunClose ?? "last");
+      i = end === -1 ? content.length : end - 1;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || backtick && ch === "`") {
+      quote = ch;
+      verbatim = escapes === "csharp" && ch === '"' && opensCsharpVerbatimString(content, i);
+      continue;
+    }
+    if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        return offsetToLine(lineIndex, i);
+      }
+    }
+  }
+  return opts?.noMatchValue ?? totalLines;
+}
+function assignBraceBlockSpans(symbols, content, opts = {}) {
+  const lineCommentPrefix = opts.lineComment;
+  const stringEscapes = opts.stringEscapes ?? "backslash";
+  const nestedBlockComments = opts.nestedBlockComments ?? false;
+  const tripleQuote = opts.tripleQuote ?? false;
+  const lineStringPrefix = opts.lineStringPrefix;
+  const firstLinePrefix = toLineCommentPrefixes(lineCommentPrefix)[0];
+  if (symbols.length === 0) return [...symbols];
+  const lines = content.split("\n");
+  const totalLines = lines.length;
+  const lineIndex = buildLineIndex(content);
+  const starts = [...new Set(symbols.map((s) => s.lineStart))].sort((a, b) => a - b);
+  const scanContent = opts.multilineLang === void 0 ? content : maskMultilineStrings(content, opts.multilineLang);
+  const blockComment = opts.blockComment !== void 0 ? opts.blockComment ?? void 0 : firstLinePrefix === "//" ? ["/*", "*/"] : firstLinePrefix === "#" ? ["<#", "#>"] : void 0;
+  const scanOpts = {
+    noMatchValue: -1,
+    stringEscapes,
+    tripleQuote,
+    rawStringQuotes: opts.rawStringQuotes ?? false,
+    tripleSingleQuote: opts.tripleSingleQuote ?? false,
+    tripleQuoteRunClose: opts.tripleQuoteRunClose ?? "last",
+    ...blockComment === void 0 ? {} : { blockComment, nestedBlockComments },
+    ...lineStringPrefix === void 0 ? {} : { lineStringPrefix },
+    ...opts.lineCommentExceptions === void 0 ? {} : { lineCommentExceptions: opts.lineCommentExceptions }
+  };
+  return symbols.map((sym) => {
+    if (sym.lineEnd !== sym.lineStart) return sym;
+    const nextStart = starts.find((s) => s > sym.lineStart);
+    const lastSearchLine = Math.min(nextStart !== void 0 ? nextStart - 1 : totalLines, sym.lineStart + BRACE_SEARCH_MAX_LINES);
+    const openIndex = findBlockOpenBrace(scanContent, lineIndex, sym.lineStart, lastSearchLine, lineCommentPrefix, scanOpts);
+    if (openIndex === null) return sym;
+    const endLine = findMatchingBraceEndLine(
+      scanContent,
+      openIndex,
+      totalLines,
+      lineIndex,
+      lineCommentPrefix,
+      scanOpts
+    );
+    if (endLine <= sym.lineStart) return sym;
+    return { ...sym, lineEnd: endLine, body: lines.slice(sym.lineStart - 1, endLine).join("\n") };
+  });
+}
+var BRACE_SEARCH_MAX_LINES = 10;
+function maskMultilineStrings(content, lang) {
+  let state = null;
+  const parts = [];
+  let pos = 0;
+  for (; ; ) {
+    const nl = content.indexOf("\n", pos);
+    const end = nl === -1 ? content.length : nl;
+    const lineEnd = end > pos && content[end - 1] === "\r" ? end - 1 : end;
+    const masked = stripMultilineStringSpan(content.slice(pos, lineEnd), state, lang);
+    state = masked.state;
+    parts.push(masked.code, content.slice(lineEnd, end));
+    if (nl === -1) break;
+    parts.push("\n");
+    pos = nl + 1;
+  }
+  return parts.join("");
+}
+function findBlockOpenBrace(content, lineIndex, startLine, lastSearchLine, lineCommentPrefix, opts) {
+  const blockComment = opts?.blockComment;
+  const stringEscapes = opts?.stringEscapes ?? "backslash";
+  const nestedBlockComments = opts?.nestedBlockComments === true;
+  const rawString = opts?.rawStringQuotes === true;
+  const tripleDelims = tripleQuoteDelimiters(opts);
+  const lineString = opts?.lineStringPrefix;
+  const linePrefixes = toLineCommentPrefixes(lineCommentPrefix);
+  const lineExceptions = opts?.lineCommentExceptions ?? [];
+  const from = lineIndex[startLine - 1];
+  if (from === void 0) return null;
+  const to = lineIndex[lastSearchLine] ?? content.length;
+  let quote = null;
+  let parenDepth = 0;
+  let linesSeen = 0;
+  let atLineStart = false;
+  let verbatim = false;
+  for (let i = from; i < to; i++) {
+    const ch = content[i];
+    if (ch === void 0) break;
+    if (quote !== null) {
+      if (verbatim) {
+        if (ch === quote) {
+          if (content[i + 1] === quote) {
+            i++;
+            continue;
+          }
+          quote = null;
+          verbatim = false;
+        }
+        continue;
+      }
+      if (stringEscapes === "powershell") {
+        const step = stepPowershellString(content, i, quote);
+        i = step.next;
+        if (!step.open) quote = null;
+        continue;
+      }
+      if (ch === "\\") {
+        i++;
+        continue;
+      }
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === "\n") {
+      linesSeen++;
+      atLineStart = true;
+      continue;
+    }
+    if (blockComment !== void 0 && content.startsWith(blockComment[0], i)) {
+      const end = skipBlockComment(content, i, blockComment, nestedBlockComments);
+      if (end === -1) return null;
+      i = end - 1;
+      continue;
+    }
+    if (atLineComment(content, i, linePrefixes, lineExceptions)) {
+      while (i + 1 < to && content[i + 1] !== "\n") i++;
+      continue;
+    }
+    if (atLineStart && !/\s/.test(ch)) {
+      atLineStart = false;
+      if (parenDepth === 0 && linesSeen >= 1 && startsWithBlockKeyword(content, i, to)) return null;
+    }
+    if (lineString !== void 0 && content.startsWith(lineString, i)) {
+      while (i + 1 < to && content[i + 1] !== "\n") i++;
+      continue;
+    }
+    if (rawString && ch === '"') {
+      const run = quoteRunLength(content, i);
+      if (run >= 3) {
+        const end = skipRawStringQuotes(content, i + run, run);
+        if (end === -1) return null;
+        i = end - 1;
+        continue;
+      }
+    }
+    const tripleAt = tripleDelims.find((t) => content.startsWith(t, i));
+    if (tripleAt !== void 0) {
+      const end = closingQuoteRunEnd(content, i + 3, tripleAt[0] ?? '"', 3, opts?.tripleQuoteRunClose ?? "last");
+      if (end === -1) return null;
+      i = end - 1;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      verbatim = stringEscapes === "csharp" && ch === '"' && opensCsharpVerbatimString(content, i);
+      continue;
+    }
+    if (ch === "(" || ch === "[") parenDepth++;
+    else if (ch === ")" || ch === "]") {
+      if (parenDepth > 0) parenDepth--;
+    } else if (ch === ";") return null;
+    else if (ch === "}" && parenDepth === 0) return null;
+    else if (ch === "{") return i;
+  }
+  return null;
+}
+var BLOCK_OPENING_KEYWORDS = /* @__PURE__ */ new Set([
+  "if",
+  "for",
+  "while",
+  "do",
+  "switch",
+  "when",
+  "match",
+  "try",
+  "foreach",
+  "loop",
+  "guard",
+  "repeat",
+  "unless",
+  "until"
+]);
+function startsWithBlockKeyword(content, i, to) {
+  const first = content[i];
+  if (first === void 0 || !/[A-Za-z_]/.test(first)) return false;
+  let j = i + 1;
+  while (j < to && /[A-Za-z0-9_]/.test(content[j])) j++;
+  return BLOCK_OPENING_KEYWORDS.has(content.slice(i, j));
+}
+function lastContentLine(rawLines) {
+  let n = rawLines.length;
+  while (n > 0 && rawLines[n - 1].trim() === "") n--;
+  return Math.max(1, n);
+}
+function nestedAngleClause(depth) {
+  let inner = "[^<>]*";
+  for (let i = 0; i < depth; i++) inner = "[^<>]*(?:<" + inner + ">[^<>]*)*";
+  return "<" + inner + ">";
+}
+var GENERIC_CLAUSE = nestedAngleClause(4);
+
+// src/languages/ini_idx.ts
+init_define_import_meta_env();
+var MAX_SECTIONS = 200;
+var MAX_HEADING_LEN = 200;
+var MAX_ENV_KEYS = 200;
+var HEADER_RE = /^\[([^\]\r\n]+)\]\s*(?:[;#].*)?$/;
+var ENV_KEY_RE = /^(?:export\s+)?([A-Za-z_][\w.-]*)\s*(?:=|:(?!\/\/))/;
+function extractIni(content, filePath) {
+  const symbols = [];
+  const sections = [];
+  const seen = /* @__PURE__ */ new Set();
+  const lines = content.split(/\r?\n/);
+  const totalLines = countContentLines(content);
+  for (let i = 0; i < lines.length; i++) {
+    if (symbols.length >= MAX_SECTIONS) break;
+    const line = lines[i] ?? "";
+    if (!line || line[0] !== "[") continue;
+    const m = HEADER_RE.exec(line);
+    if (m === null) continue;
+    const name = m[1]?.trim() ?? "";
+    if (!name || name.length > MAX_HEADING_LEN) continue;
+    const key = `${name}\0${i + 1}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    symbols.push(makeLineSymbol(filePath, name, "ini_section", i + 1));
+    sections.push({ heading: name, level: 1, line: i + 1, endLine: i + 1 });
+  }
+  sections.sort((a, b) => a.line - b.line);
+  assignFlatEndLines(sections, totalLines);
+  return propagateEndLinesToSymbols(symbols, sections);
+}
+function _isEscapedQuote(line, i, q) {
+  if (q === "'") return false;
+  let backslashes = 0;
+  let j = i - 1;
+  while (j >= 0 && line[j] === "\\") {
+    backslashes++;
+    j--;
+  }
+  return backslashes % 2 === 1;
+}
+function _lineClosesQuote(line, q) {
+  for (let i = 0; i < line.length; i++) {
+    if (line[i] === q && !_isEscapedQuote(line, i, q)) return true;
+  }
+  return false;
+}
+function _detectOpenQuote(value) {
+  const trimmed = value.replace(/^\s+/, "");
+  const q = trimmed[0];
+  if (q !== '"' && q !== "'") return null;
+  for (let i = 1; i < trimmed.length; i++) {
+    if (trimmed[i] === q && !_isEscapedQuote(trimmed, i, q)) return null;
+  }
+  return q;
+}
+function extractEnv(content, filePath) {
+  const symbols = [];
+  const seen = /* @__PURE__ */ new Set();
+  const lines = content.split(/\r?\n/);
+  let openQuote = null;
+  for (let i = 0; i < lines.length; i++) {
+    if (symbols.length >= MAX_ENV_KEYS) break;
+    const line = lines[i] ?? "";
+    if (openQuote !== null) {
+      if (_lineClosesQuote(line, openQuote)) openQuote = null;
+      continue;
+    }
+    const trimmed = line.replace(/^[ \t]+/, "");
+    if (!trimmed || trimmed[0] === "#" || trimmed[0] === ";") continue;
+    const m = ENV_KEY_RE.exec(trimmed);
+    if (m === null) continue;
+    const name = m[1]?.trim() ?? "";
+    if (!name || name.length > MAX_HEADING_LEN) continue;
+    const key = `${name}\0${i + 1}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    symbols.push(makeLineSymbol(filePath, name, "env_key", i + 1));
+    openQuote = _detectOpenQuote(trimmed.slice(m[0].length));
+  }
+  return symbols;
+}
+
+// src/parser_types.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+// src/languages/sniff.ts
+init_define_import_meta_env();
+var SNIFF_CHARS = 8192;
+var ABL_MARKER_RES = [
+  /^&ANALYZE-SUSPEND\b/i,
+  /^&(?:SCOPED|GLOBAL)-DEFINE\s/i,
+  /^(?:ROUTINE|BLOCK)-LEVEL\s+ON\s+ERROR\s+UNDO\b/i,
+  /^DEF(?:INE)?\s+(?:NEW\s+)?(?:GLOBAL\s+)?(?:SHARED\s+)?(?:VAR|VARIABLE|TEMP-TABLE|BUFFER|QUERY|STREAM|DATASET|FRAME|(?:INPUT|OUTPUT|INPUT-OUTPUT)\s+PARAM(?:ETER)?)\s/i,
+  /^FUNCTION\s+[\w-]+\s+RETURNS\s/i,
+  /^FOR\s+EACH\s/i,
+  /^END\s+(?:PROCEDURE|FUNCTION|CLASS|INTERFACE|METHOD|CONSTRUCTOR)\s*\.$/i,
+  /^USING\s+[\w.*-]+(?:\s+FROM\s+(?:ASSEMBLY|PROPATH))?\s*\.$/i
+];
+var ABL_HEADER_RE = /^(?:PROCEDURE\s+[\w-]+|(?:CLASS|INTERFACE)\s+[\w.-]+)(?:\s|:)/i;
+var ABL_SNIFF_CHARS = SNIFF_CHARS;
+function isAblSource(content) {
+  const head = content.slice(0, ABL_SNIFF_CHARS);
+  if (head.includes("\0")) return false;
+  for (const raw of head.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (line === "") continue;
+    if (ABL_MARKER_RES.some((re) => re.test(line))) return true;
+    if (ABL_HEADER_RE.test(line) && line.endsWith(":")) return true;
+  }
+  return false;
+}
+var SNIFF_FUNCTION_RE = /^function\b\s*(?:(?:\[[\w\s,~]*\]|[A-Za-z]\w*)\s*=\s*)?[A-Za-z]\w*(?:\.[A-Za-z]\w*)?\s*(?:\(|[%#;,]|$)/;
+var SNIFF_CLASSDEF_RE = /^classdef\b\s*(?:\([^)]*\)\s*)?[A-Za-z]\w*\s*(?:<|[%#]|$)/;
+function isMatlabSource(content) {
+  for (const raw of content.slice(0, SNIFF_CHARS).split("\n")) {
+    const line = raw.trim();
+    if (SNIFF_FUNCTION_RE.test(line) || SNIFF_CLASSDEF_RE.test(line)) return true;
+  }
+  return false;
+}
+function isObjcSource(content) {
+  return /^[ \t]*(?:#[ \t]*import[ \t]*[<"]|@(?:interface|implementation|protocol)\b)/m.test(content.slice(0, SNIFF_CHARS));
+}
+function isObjcHeader(content) {
+  return /^[ \t]*@(?:interface|protocol)\b/m.test(content.slice(0, SNIFF_CHARS));
+}
+function isPascalSource(content) {
+  const head = content.slice(0, SNIFF_CHARS);
+  let i = 0;
+  for (; ; ) {
+    while (i < head.length && /\s/.test(head[i])) i++;
+    if (head[i] === "{") {
+      const end = head.indexOf("}", i);
+      if (end < 0) return false;
+      i = end + 1;
+    } else if (head.startsWith("(*", i)) {
+      const end = head.indexOf("*)", i);
+      if (end < 0) return false;
+      i = end + 2;
+    } else if (head.startsWith("//", i)) {
+      const end = head.indexOf("\n", i);
+      if (end < 0) return false;
+      i = end + 1;
+    } else {
+      break;
+    }
+  }
+  return /^(?:unit|program|library)[ \t\r\n]+[A-Za-z_][\w.]*[ \t\r\n]*[;(]/i.test(head.slice(i, i + 300));
+}
+var PERL_MARKER_RE = /^(?:#!.*\bperl\b|[ \t]*use[ \t]+(?:strict|warnings|Test::More|Test2::V0|Test::Simple)\b|[ \t]*package[ \t]+[\w:]+[ \t]*;|[ \t]*my[ \t]+[$@%]|[ \t]*sub[ \t]+\w+[ \t]*\{)/m;
+function isPerlSource(content) {
+  const head = content.slice(0, SNIFF_CHARS);
+  return PERL_MARKER_RE.test(head) && !/^[ \t]*use[ \t]+v6\b/m.test(head);
+}
+function isPrologSource(content) {
+  const head = content.slice(0, SNIFF_CHARS);
+  if (PERL_MARKER_RE.test(head)) return false;
+  return /^:-/m.test(head) || /^[a-z]\w*(?:\([^()\n]*\))?[ \t]*:-/m.test(head);
+}
+var LATEX_CLASS_MARKER_RE = /\\(?:ProvidesClass|documentclass)\b/;
+function isLatexClassFile(content) {
+  return LATEX_CLASS_MARKER_RE.test(content.slice(0, SNIFF_CHARS));
+}
+
+// src/language_specs.ts
+init_define_import_meta_env();
+var CODE = { symbolBearing: true, sourceHints: true, grepSource: true, diffable: true };
+var DATA = { symbolBearing: false, sourceHints: false, grepSource: false, diffable: false };
+var LANGUAGE_SPECS = [
+  { id: "typescript", extraction: "tree-sitter", extensions: [".ts", ".tsx", ".mts", ".cts"], ...CODE, fence: "typescript", fenceByExtension: { ".tsx": "tsx" } },
+  { id: "javascript", extraction: "tree-sitter", extensions: [".js", ".jsx", ".mjs", ".cjs"], ...CODE, fence: "javascript", fenceByExtension: { ".jsx": "jsx" } },
+  // Bazel and Starlark (`.bzl`, `.star`, BUILD/WORKSPACE/MODULE.bazel) are a Python dialect: `def` and top-level calls such as `load(...)` parse with the Python grammar (https://github.com/bazelbuild/starlark/blob/master/spec.md).
+  { id: "python", extraction: "tree-sitter", extensions: [".py", ".pyi", ".bzl", ".star"], basenames: ["build.bazel", "workspace.bazel", "module.bazel"], exactBasenames: ["BUILD", "WORKSPACE"], ...CODE, fence: "python" },
+  { id: "go", extraction: "tree-sitter", extensions: [".go"], ...CODE, fence: "go" },
+  { id: "rust", extraction: "tree-sitter", extensions: [".rs"], ...CODE, fence: "rust" },
+  // Rake task files, Gemfile, Rakefile and the other extensionless Ruby DSL files are plain Ruby syntax.
+  { id: "ruby", extraction: "tree-sitter", extensions: [".rb", ".ruby", ".rake"], basenames: ["gemfile", "rakefile", "vagrantfile", "guardfile", "podfile", "capfile", "fastfile", "brewfile"], ...CODE, fence: "ruby" },
+  { id: "java", extraction: "tree-sitter", extensions: [".java"], ...CODE, fence: "java" },
+  // `.h` is C unless it declares an Objective-C `@interface` or `@protocol` (refineLanguageByContent); a C++ header parses with the C grammar.
+  { id: "c", extraction: "tree-sitter", extensions: [".c", ".h"], label: "C", ...CODE, fence: "c" },
+  { id: "cpp", extraction: "tree-sitter", extensions: [".cpp", ".cc", ".cxx", ".hpp", ".hxx"], label: "C++", ...CODE, fence: "cpp" },
+  // zsh, ksh and bats scripts share the POSIX `name() {` and `function name {` function forms the bash adapter reads.
+  { id: "bash", extraction: "regex", extensions: [".sh", ".bash", ".zsh", ".ksh", ".bats"], ...DATA, symbolBearing: true, fence: "bash" },
+  // MDX headings are plain ATX; `.rst` needs an underline heading parser this adapter lacks, so it stays unmapped.
+  { id: "markdown", extraction: "regex", extensions: [".md", ".markdown", ".mdx"], ...DATA, fence: "markdown" },
+  { id: "toml", extraction: "regex", extensions: [".toml"], basenames: ["cargo.toml", "pyproject.toml"], label: "TOML", ...DATA, diffable: true, fence: "toml" },
+  // JSON with comments (`.jsonc`) and Avro schemas (`.avsc`) read with the JSON adapter, which skips `//` and `/* */` comments.
+  { id: "json", extraction: "regex", extensions: [".json", ".jsonc", ".avsc"], basenames: ["package.json", "tsconfig.json"], label: "JSON", ...DATA, diffable: true, fence: "json" },
+  { id: "yaml", extraction: "regex", extensions: [".yaml", ".yml"], label: "YAML", ...DATA, diffable: true, fence: "yaml" },
+  { id: "css", extraction: "regex", extensions: [".css", ".scss", ".sass", ".less"], label: "CSS", ...DATA, grepSource: true, diffable: true, fence: "css", fenceByExtension: { ".scss": "scss", ".sass": "sass", ".less": "less" } },
+  { id: "dockerfile", extraction: "regex", extensions: [], basenames: ["dockerfile"], ...DATA, fence: "dockerfile" },
+  { id: "csharp", extraction: "regex", extensions: [".cs"], label: "C#", ...CODE, fence: "csharp" },
+  { id: "php", extraction: "regex", extensions: [".php"], label: "PHP", ...CODE, fence: "php" },
+  { id: "html", extraction: "regex", extensions: [".html", ".htm"], label: "HTML", ...DATA, fence: "html" },
+  { id: "liquid", extraction: "regex", extensions: [".liquid"], ...DATA, fence: "liquid" },
+  // Six template dialects, each masking its own delimiters out then handing off to the HTML
+  // extractor (src/languages/templates_idx.ts) -- markup formats, so DATA defaults like html/liquid.
+  { id: "jinja2", extraction: "regex", extensions: [".j2", ".jinja", ".jinja2"], label: "Jinja2", ...DATA, fence: "jinja" },
+  { id: "handlebars", extraction: "regex", extensions: [".hbs", ".handlebars"], label: "Handlebars", ...DATA, fence: "handlebars" },
+  { id: "erb", extraction: "regex", extensions: [".erb"], label: "ERB", ...DATA, fence: "erb" },
+  { id: "ejs", extraction: "regex", extensions: [".ejs"], label: "EJS", ...DATA, fence: "ejs" },
+  { id: "nunjucks", extraction: "regex", extensions: [".njk"], label: "Nunjucks", ...DATA, fence: "html" },
+  { id: "twig", extraction: "regex", extensions: [".twig"], label: "Twig", ...DATA, fence: "twig" },
+  { id: "kotlin", extraction: "regex", extensions: [".kt", ".kts"], ...CODE, fence: "kotlin" },
+  { id: "swift", extraction: "regex", extensions: [".swift"], ...CODE, fence: "swift" },
+  { id: "scala", extraction: "regex", extensions: [".scala", ".sc"], ...CODE, fence: "scala" },
+  { id: "lua", extraction: "regex", extensions: [".lua"], ...CODE, fence: "lua" },
+  { id: "elixir", extraction: "regex", extensions: [".ex", ".exs"], ...CODE, fence: "elixir" },
+  { id: "dart", extraction: "regex", extensions: [".dart"], ...CODE, fence: "dart" },
+  { id: "zig", extraction: "regex", extensions: [".zig"], ...CODE, fence: "zig" },
+  { id: "r", extraction: "regex", extensions: [".r"], ...CODE, fence: "r" },
+  { id: "graphql", extraction: "regex", extensions: [".graphql", ".gql"], label: "GraphQL", ...DATA, symbolBearing: true, fence: "graphql" },
+  // Oracle PL/SQL sources: package spec and body, standalone procedure/function, trigger, and object type spec and body.
+  { id: "sql", extraction: "regex", extensions: [".sql", ".pks", ".pkb", ".pls", ".plsql", ".pck", ".prc", ".fnc", ".trg", ".tps", ".tpb"], label: "SQL", ...DATA, symbolBearing: true, diffable: true, fence: "sql" },
+  { id: "ini", extraction: "regex", extensions: [".ini", ".cfg", ".conf"], label: "INI", ...DATA, fence: "ini" },
+  // `.mk` fragments (config.mk, rules.mk) share a bare Makefile's syntax.
+  { id: "makefile", extraction: "regex", extensions: [".mk"], basenames: ["makefile", "gnumakefile", "bsdmakefile"], ...DATA, fence: "makefile", basenameImportsExtension: ".mk" },
+  { id: "proto", extraction: "regex", extensions: [".proto"], label: "Protocol Buffers", ...DATA, symbolBearing: true, fence: "protobuf" },
+  { id: "terraform", extraction: "regex", extensions: [".tf", ".tfvars", ".hcl"], ...DATA, symbolBearing: true, fence: "hcl" },
+  // `.env` and `.env.<suffix>` are matched by parser_types.ts's DOTENV_VARIANT_RE before this table.
+  { id: "env_file", extraction: "regex", extensions: [".env"], basenames: [".envrc"], label: "env file", ...DATA },
+  { id: "powershell", extraction: "regex", extensions: [".ps1", ".psm1"], label: "PowerShell", ...CODE, fence: "powershell" },
+  // VB.NET, VB6/VBA standard modules, VBScript and VB6 forms. A VB6 class module shares `.cls` with Apex (and LaTeX) and is told apart by content in refineLanguageByContent.
+  { id: "vb", extraction: "regex", extensions: [".vb", ".bas", ".vbs", ".frm"], label: "Visual Basic", ...CODE, fence: "vb", fenceByExtension: { ".vb": "vbnet", ".vbs": "vbscript" } },
+  {
+    id: "cobol",
+    extraction: "own-result",
+    extensions: [".cbl", ".cob", ".cobol", ".cpy"],
+    label: "COBOL",
+    ...CODE,
+    fence: "cobol",
+    partialRefsReason: "PERFORM, GO TO and CALL 'literal' are recorded as references, but a paragraph also runs by falling through from the one above it and a program can be called through a data item holding its name, so `dead` skips COBOL"
+  },
+  // Natural object sources as NaturalONE and SYSOBJH export them. Maps (.nsm) and DDMs (.nsd) are layouts, not code, and stay unmapped.
+  {
+    id: "natural",
+    extraction: "own-result",
+    extensions: [".nsp", ".nsn", ".nss", ".nsa", ".nsl", ".nsg", ".nsc", ".nsh"],
+    label: "Natural",
+    ...CODE,
+    fence: "natural",
+    partialRefsReason: "PERFORM, CALLNAT 'literal' and FETCH 'literal' are recorded as references, but an object can also be called through a variable holding its name, so `dead` skips Natural"
+  },
+  { id: "abap", extraction: "regex", extensions: [".abap"], label: "ABAP", ...CODE, fence: "abap" },
+  { id: "sas", extraction: "regex", extensions: [".sas"], label: "SAS", ...CODE, fence: "sas" },
+  { id: "pli", extraction: "regex", extensions: [".pli", ".pl1"], label: "PL/I", ...CODE, fence: "pli" },
+  // `.rpg` stays unmapped: RPG II and RPG III sources use it, and their fixed layout predates the ILE RPG forms this adapter reads.
+  { id: "rpg", extraction: "regex", extensions: [".rpgle", ".sqlrpgle"], label: "RPG", ...CODE, fence: "rpgle" },
+  { id: "jcl", extraction: "regex", extensions: [".jcl"], label: "JCL", ...CODE, fence: "jcl" },
+  // `.mm` is always Objective-C++. A `.m` (MATLAB uses it too) is Objective-C only on an `#import`, `@interface`, `@implementation` or `@protocol` line, and a `.h` only on `@interface` or `@protocol`: refineLanguageByContent in parser_types.ts decides.
+  { id: "objc", extraction: "regex", extensions: [".mm"], label: "Objective-C", ...CODE, fence: "objectivec" },
+  // Gradle build scripts and Jenkinsfiles are Groovy.
+  { id: "groovy", extraction: "regex", extensions: [".groovy", ".gvy", ".gradle"], basenames: ["jenkinsfile"], label: "Groovy", ...CODE, fence: "groovy", basenameImportsExtension: ".groovy" },
+  // A Prolog `.pl` stays unknown (refineLanguageByContent), and a `.t` is Perl only on a Perl marker line.
+  { id: "perl", extraction: "regex", extensions: [".pl", ".pm"], label: "Perl", ...CODE, fence: "perl" },
+  { id: "solidity", extraction: "regex", extensions: [".sol"], label: "Solidity", ...CODE, fence: "solidity" },
+  { id: "thrift", extraction: "regex", extensions: [".thrift"], label: "Thrift", ...DATA, symbolBearing: true, fence: "thrift" },
+  { id: "glsl", extraction: "regex", extensions: [".glsl", ".vert", ".frag", ".comp", ".geom", ".tesc", ".tese"], label: "GLSL", ...CODE, fence: "glsl" },
+  // `.fx` stays unmapped: other languages use it too.
+  { id: "hlsl", extraction: "regex", extensions: [".hlsl", ".hlsli"], label: "HLSL", ...CODE, fence: "hlsl" },
+  { id: "wgsl", extraction: "regex", extensions: [".wgsl"], label: "WGSL", ...CODE, fence: "wgsl" },
+  { id: "metal", extraction: "regex", extensions: [".metal"], label: "Metal", ...CODE, fence: "metal" },
+  // `.f`, `.for` and `.f77` are read as fixed form unless code starts in column 1. `.fpp` stays unmapped: it is used for both forms.
+  { id: "fortran", extraction: "regex", extensions: [".f", ".for", ".f77", ".f90", ".f95", ".f03", ".f08"], label: "Fortran", ...CODE, fence: "fortran" },
+  // `.inc` stays unmapped (many languages use it), and a `.pp` (Puppet uses it too) is Pascal only on a unit, program or library header: refineLanguageByContent in parser_types.ts decides. Text-form `.dfm` forms list their components.
+  { id: "pascal", extraction: "regex", extensions: [".pas", ".dpr", ".dpk", ".lpr", ".dfm"], label: "Pascal", ...CODE, fence: "pascal" },
+  // MATLAB has no extension of its own: a `.m` that is not Objective-C is MATLAB only on a `function` or `classdef` header line, which refineLanguageByContent in parser_types.ts checks, so a Mathematica or Mercury `.m` stays unknown.
+  { id: "matlab", extraction: "regex", extensions: [], label: "MATLAB", ...CODE, fence: "matlab" },
+  { id: "cmake", extraction: "regex", extensions: [".cmake"], basenames: ["cmakelists.txt"], label: "CMake", ...CODE, fence: "cmake", basenameImportsExtension: ".cmake" },
+  // One adapter for the three assembly dialects that share these extensions: GNU as (`.s`, and `.S` through the lowercase lookup), NASM (`.asm`, `.nasm`) and IBM High Level Assembler (`.asm`), which the adapter tells apart by content. `.inc` stays unmapped: many languages use it.
+  { id: "asm", extraction: "regex", extensions: [".s", ".asm", ".nasm"], label: "Assembly", ...CODE, fence: "asm" },
+  { id: "batch", extraction: "regex", extensions: [".bat", ".cmd"], label: "Windows batch", ...CODE, fence: "batch" },
+  { id: "erlang", extraction: "regex", extensions: [".erl", ".hrl"], label: "Erlang", ...CODE, fence: "erlang" },
+  { id: "vhdl", extraction: "regex", extensions: [".vhd", ".vhdl"], label: "VHDL", ...CODE, fence: "vhdl" },
+  // Five Lisp-family dialects, each its own row: none shares an extractor (see common_lisp.ts's
+  // module doc for why their lexical rules stay separate rather than a single Lisp masker).
+  { id: "common_lisp", extraction: "regex", extensions: [".lisp", ".lsp", ".cl"], label: "Common Lisp", ...CODE, fence: "lisp" },
+  { id: "scheme", extraction: "regex", extensions: [".scm", ".ss"], label: "Scheme", ...CODE, fence: "scheme" },
+  { id: "racket", extraction: "regex", extensions: [".rkt", ".rktl"], label: "Racket", ...CODE, fence: "racket" },
+  { id: "clojure", extraction: "regex", extensions: [".clj", ".cljs", ".cljc"], label: "Clojure", ...CODE, fence: "clojure" },
+  { id: "emacs_lisp", extraction: "regex", extensions: [".el"], label: "Emacs Lisp", ...CODE, fence: "lisp" },
+  // `.lhs` (literate Haskell) is deliberately not claimed here -- see haskell.ts's module doc.
+  { id: "haskell", extraction: "regex", extensions: [".hs"], label: "Haskell", ...CODE, fence: "haskell" },
+  // `.mli` interface files share `.ml`'s lexical rules (comments, strings, quoted strings) and are read with the same extractor -- see ocaml.ts's module doc.
+  { id: "ocaml", extraction: "regex", extensions: [".ml", ".mli"], label: "OCaml", ...CODE, fence: "ocaml" },
+  // `.fsi` signature files and `.fsx` scripts share `.fs`'s lexical rules and are read with the same extractor -- see fsharp.ts's module doc.
+  { id: "fsharp", extraction: "regex", extensions: [".fs", ".fsi", ".fsx"], label: "F#", ...CODE, fence: "fsharp" },
+  { id: "nix", extraction: "regex", extensions: [".nix"], label: "Nix", ...CODE, fence: "nix" },
+  // OpenEdge ABL has no extension of its own: a `.p` or `.w` (Pascal and CWEB use them too) or a `.cls` (Apex, VB6, LaTeX) is ABL only when its head carries an ABL marker, which refineLanguageByContent in parser_types.ts checks. The path-only hooks see a `.p` or `.w` as unknown and a `.cls` as Apex.
+  { id: "abl", extraction: "regex", extensions: [], label: "OpenEdge ABL", ...CODE, fence: "abl" },
+  { id: "apex", extraction: "regex", extensions: [".cls", ".trigger"], label: "Apex", ...CODE, fence: "apex" },
+  // Matched by the `-meta.xml` suffix in detectLanguage, not by an extension.
+  { id: "salesforce_metadata", extraction: "regex", extensions: [], label: "Salesforce metadata", ...DATA, symbolBearing: true, sourceHints: true, grepSource: true, fence: "xml" },
+  { id: "salesforce_markup", extraction: "own-result", extensions: [".cmp", ".app", ".evt", ".intf", ".design", ".auradoc", ".tokens", ".page", ".component", ".email"], label: "Salesforce markup", ...DATA, symbolBearing: true, sourceHints: true, grepSource: true, fence: "xml" },
+  { id: "vue", extraction: "own-result", extensions: [".vue"], ...DATA, fence: "vue" },
+  { id: "svelte", extraction: "own-result", extensions: [".svelte"], ...DATA, fence: "svelte" },
+  { id: "astro", extraction: "own-result", extensions: [".astro"], ...DATA, fence: "astro" },
+  // Notebooks index through their code cells as Python, in parser.ts's ipynb branch.
+  { id: "ipynb", extraction: "own-result", extensions: [".ipynb"], label: "Jupyter notebook", ...DATA, fence: "json" }
+];
+var SPEC_BY_ID = new Map(LANGUAGE_SPECS.map((s) => [s.id, s]));
+function rows() {
+  return LANGUAGE_SPECS;
+}
+var EXTENSION_LANGUAGE = new Map(
+  LANGUAGE_SPECS.flatMap((s) => s.extensions.map((e) => [e, s.id]))
+);
+var FILENAME_LANGUAGE = new Map(
+  rows().flatMap((s) => (s.basenames ?? []).map((b) => [b, s.id]))
+);
+var EXACT_FILENAME_LANGUAGE = new Map(
+  rows().flatMap((s) => (s.exactBasenames ?? []).map((b) => [b, s.id]))
+);
+var TREE_SITTER_LANGUAGES = LANGUAGE_SPECS.filter((s) => s.extraction === "tree-sitter").map((s) => s.id);
+function languageHasFlag(language, flag) {
+  return SPEC_BY_ID.get(language)?.[flag] === true;
+}
+function languageLabel(language) {
+  if (language === "unknown") return "this file type";
+  return SPEC_BY_ID.get(language)?.label ?? language;
+}
+function fenceFor(language, ext) {
+  const spec = SPEC_BY_ID.get(language);
+  if (spec === void 0) return "";
+  return spec.fenceByExtension?.[ext] ?? spec.fence ?? "";
+}
+function basenameImportsExtension(language) {
+  return SPEC_BY_ID.get(language)?.basenameImportsExtension;
+}
+function partialRefsReason(language) {
+  return SPEC_BY_ID.get(language)?.partialRefsReason;
+}
+
+// src/parser_types.ts
+var DOTENV_VARIANT_RE = /^\.env(\..+)?$/;
+var VB6_HEADER_SCAN_LINES = 40;
+function isVb6ClassModule(content) {
+  if (content.includes("\0")) return false;
+  const lines = (content.charCodeAt(0) === 65279 ? content.slice(1) : content).split(/\r?\n/, VB6_HEADER_SCAN_LINES);
+  const first = lines.find((l) => l.trim() !== "");
+  if (first !== void 0 && /^VERSION\s+1\.0\s+CLASS\b/i.test(first.trim())) return true;
+  return lines.some((l) => /^Attribute\s+VB_Name\s*=\s*"/i.test(l.trim()));
+}
+function refineLanguageByContent(filePath, language, content) {
+  const sniff = CONTENT_SNIFFS.get(path.extname(filePath).toLowerCase());
+  if (sniff === void 0 || sniff.from !== language) return language;
+  return sniff.refine(content) ?? language;
+}
+var LANGUAGE_SNIFF_BYTES = 8192;
+function sniffHead(content) {
+  const head = content.slice(0, LANGUAGE_SNIFF_BYTES);
+  return Buffer.byteLength(head, "utf8") <= LANGUAGE_SNIFF_BYTES ? head : Buffer.from(head, "utf8").subarray(0, LANGUAGE_SNIFF_BYTES).toString("utf8");
+}
+var ablOrUnknown = (c) => isAblSource(c) ? "abl" : void 0;
+var clsRefine = (c) => {
+  if (isVb6ClassModule(c)) return "vb";
+  const abl = ablOrUnknown(c);
+  if (abl !== void 0) return abl;
+  if (isLatexClassFile(c)) return "unknown";
+  return void 0;
+};
+var CONTENT_SNIFFS = /* @__PURE__ */ new Map([
+  [".cls", { from: "apex", refine: clsRefine }],
+  [".p", { from: "unknown", refine: ablOrUnknown }],
+  [".w", { from: "unknown", refine: ablOrUnknown }],
+  [".m", { from: "unknown", refine: (c) => isObjcSource(sniffHead(c)) ? "objc" : isMatlabSource(sniffHead(c)) ? "matlab" : void 0 }],
+  [".pp", { from: "unknown", refine: (c) => isPascalSource(sniffHead(c)) ? "pascal" : void 0 }],
+  [".h", { from: "c", refine: (c) => isObjcHeader(sniffHead(c)) ? "objc" : void 0 }],
+  [".pl", { from: "perl", refine: (c) => isPrologSource(sniffHead(c)) ? "unknown" : void 0 }],
+  [".t", { from: "unknown", refine: (c) => isPerlSource(sniffHead(c)) ? "perl" : void 0 }]
+]);
+function needsContentSniff(filePath, language) {
+  return CONTENT_SNIFFS.get(path.extname(filePath).toLowerCase())?.from === language;
+}
+function detectLanguageOfFile(filePath) {
+  const language = detectLanguage(filePath);
+  if (!needsContentSniff(filePath, language)) return language;
+  try {
+    const fd = fs.openSync(filePath, "r");
+    try {
+      const buf = Buffer.alloc(LANGUAGE_SNIFF_BYTES);
+      const n = fs.readSync(fd, buf, 0, buf.length, 0);
+      return refineLanguageByContent(filePath, language, buf.subarray(0, n).toString("utf8"));
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch {
+    return language;
+  }
+}
+function detectLanguage(filePath) {
+  const exactBase = path.basename(filePath);
+  const base = exactBase.toLowerCase();
+  if (DOTENV_VARIANT_RE.test(base)) return "env_file";
+  const byName = EXACT_FILENAME_LANGUAGE.get(exactBase) ?? FILENAME_LANGUAGE.get(base);
+  if (byName !== void 0) return byName;
+  if (base.endsWith("-meta.xml")) {
+    return "salesforce_metadata";
+  }
+  const ext = path.extname(base).toLowerCase();
+  return EXTENSION_LANGUAGE.get(ext) ?? "unknown";
+}
+var UNSUPPORTED_LANGUAGE_EXTENSIONS = /* @__PURE__ */ new Map([
+  [".rpg", "RPG II or RPG III"],
+  [".nsm", "Natural map"],
+  [".nsd", "Natural DDM"]
+]);
+function nonTreeSitterLanguageCount() {
+  return LANGUAGE_SPECS.filter((s) => s.extraction !== "tree-sitter" && s.id !== "ipynb").length;
+}
+function unsupportedLanguageName(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return UNSUPPORTED_LANGUAGE_EXTENSIONS.get(ext);
+}
+
+// src/dotenv_redact.ts
+init_define_import_meta_env();
+var DOTENV_VALUE_PLACEHOLDER = "[REDACTED:dotenv_value]";
+var ASSIGNMENT_RE = /^(\s*(?:export\s+)?[A-Za-z_][\w.-]*\s*(?:\+?=|:(?!\/\/)))/;
+var SAFE_LINE_RE = /^\s*(?:[#;].*)?$/;
+function isDotenvPath(filePath) {
+  return detectLanguage(filePath) === "env_file";
+}
+function redactDotenvValues(text) {
+  const lines = text.split("\n");
+  const out = [];
+  let openQuote = null;
+  for (const raw of lines) {
+    const hasCr = raw.endsWith("\r");
+    const line = hasCr ? raw.slice(0, -1) : raw;
+    const eol = hasCr ? "\r" : "";
+    const emit = (s) => {
+      out.push(`${s}${eol}`);
+    };
+    if (openQuote !== null) {
+      if (_lineClosesQuote(line, openQuote)) openQuote = null;
+      emit(DOTENV_VALUE_PLACEHOLDER);
+      continue;
+    }
+    if (SAFE_LINE_RE.test(line)) {
+      emit(line);
+      continue;
+    }
+    const m = ASSIGNMENT_RE.exec(line);
+    if (m === null || m[1] === void 0) {
+      emit(DOTENV_VALUE_PLACEHOLDER);
+      continue;
+    }
+    const prefix = m[1];
+    openQuote = _detectOpenQuote(line.slice(prefix.length));
+    emit(`${prefix}${DOTENV_VALUE_PLACEHOLDER}`);
+  }
+  return out.join("\n");
+}
+function redactIfDotenv(filePath, text) {
+  return isDotenvPath(filePath) ? redactDotenvValues(text) : text;
+}
+
+// src/db.ts
+init_define_import_meta_env();
+import * as fs2 from "node:fs";
+import { createRequire } from "node:module";
+import * as path2 from "node:path";
+var _require = createRequire(import.meta.url);
+var _connections = /* @__PURE__ */ new Map();
+var SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS files (
+  path TEXT PRIMARY KEY,
+  sha TEXT,
+  mtime REAL,
+  language TEXT,
+  indexed_at REAL,
+  embed_sha TEXT,
+  retry_count INTEGER NOT NULL DEFAULT 0,
+  parser_sha TEXT
+);
+-- Expression index on TG_LOWER(path) -- see pathEqClause (sql_path.ts) and TG_LOWER's
+-- registration above. TG_LOWER is registered { deterministic: true }, which is required for
+-- SQLite to index an expression at all; without it CREATE INDEX on a function call throws
+-- "non-deterministic functions prohibited in index expressions". Because pathEqClause emits
+-- this exact 'TG_LOWER(path) = ?' text for every case-insensitive-filesystem query, the planner
+-- matches it against this index and uses SEARCH instead of a full table SCAN, without requiring
+-- any writer to populate a separate folded column (verified via EXPLAIN QUERY PLAN in
+-- db.test.ts / sql_path.test.ts). CREATE INDEX IF NOT EXISTS is purely additive and safe to run
+-- against an already-populated table on every connection open, unlike an ALTER TABLE column add
+-- -- no MIGRATIONS entry or SCHEMA_VERSION bump is needed for this index.
+CREATE INDEX IF NOT EXISTS idx_files_path_folded ON files(TG_LOWER(path));
+
+CREATE TABLE IF NOT EXISTS symbols (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  file_path TEXT,
+  name TEXT,
+  kind TEXT,
+  line_start INTEGER,
+  line_end INTEGER,
+  body TEXT,
+  docstring TEXT,
+  parent TEXT NOT NULL DEFAULT ''
+);
+CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);
+CREATE INDEX IF NOT EXISTS idx_symbols_file ON symbols(file_path);
+CREATE INDEX IF NOT EXISTS idx_symbols_name_kind ON symbols(name, kind);
+CREATE INDEX IF NOT EXISTS idx_symbols_file_folded ON symbols(TG_LOWER(file_path));
+CREATE INDEX IF NOT EXISTS idx_symbols_file_name_folded ON symbols(TG_LOWER(file_path), name);
+-- Partial index backing checkSymbolBodySize (cli_doctor.ts), which every SessionStart hook runs.
+-- Its predicate cannot be served by any index above, so the check had to read the whole symbols
+-- table -- 226 MB / 231324 rows here, 229 ms per session start, and the early-exit LIMIT 1 never
+-- fires on a healthy index because there is nothing to find. Indexing the *violating* rows only
+-- makes the check a lookup into a b-tree that is empty on a healthy index: measured 229 ms -> 0.0
+-- ms, 4 KB on disk, and no measurable insert cost (-0.2%, within noise, over 40000 real rows),
+-- because SQLite evaluates the predicate and skips the b-tree write for every row under the cap.
+-- SQLite uses a partial index only where the query's WHERE implies the index's, so the probe in
+-- cli_doctor.ts spells its comparison the same way and against the same constant. That makes the
+-- threshold part of the stored schema -- see SYMBOL_BODY_CHAR_CAP in constants.ts for what
+-- changing it requires. A query with a lower threshold correctly gets a full scan instead, so no
+-- other reader can be served stale rows by this index.
+CREATE INDEX IF NOT EXISTS idx_symbols_oversized_body ON symbols(id) WHERE LENGTH(body) > ${SYMBOL_BODY_CHAR_CAP};
+
+CREATE TABLE IF NOT EXISTS refs (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  file_path TEXT,
+  name TEXT,
+  line INTEGER,
+  col INTEGER,
+  context TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_refs_name ON refs(name);
+CREATE INDEX IF NOT EXISTS idx_refs_file ON refs(file_path);
+CREATE INDEX IF NOT EXISTS idx_refs_file_folded ON refs(TG_LOWER(file_path));
+CREATE INDEX IF NOT EXISTS idx_refs_file_name_folded ON refs(TG_LOWER(file_path), name);
+
+CREATE TABLE IF NOT EXISTS chunks (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  file_path TEXT,
+  start_line INTEGER,
+  end_line INTEGER,
+  text TEXT,
+  kind TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_chunks_file ON chunks(file_path);
+CREATE INDEX IF NOT EXISTS idx_chunks_file_folded ON chunks(TG_LOWER(file_path));
+CREATE INDEX IF NOT EXISTS idx_chunks_file_kind_folded ON chunks(TG_LOWER(file_path), kind);
+
+-- Tracks every project root a hook has ever seen an edit for, so the worker's periodic sweep
+-- (sweepKnownRoots in index_prune.ts) knows which roots to auto-prune without scanning the
+-- entire shared files table for distinct top-level directories on every cycle. Purely additive
+-- (no SCHEMA_VERSION bump needed): last_seen_ms is refreshed on every observed edit,
+-- first_missing_ms is set the first sweep that finds the root unreachable and cleared the
+-- moment it's seen reachable again -- see sweepKnownRoots' grace-period logic.
+CREATE TABLE IF NOT EXISTS known_roots (
+  root TEXT PRIMARY KEY,
+  last_seen_ms REAL NOT NULL,
+  first_missing_ms REAL
+);
+
+-- Resume point for a budget-truncated reconcile sweep (reconcile.ts), one row per project root. A
+-- project too large to finish a sweep inside DEFAULT_RECONCILE_BUDGET_MS would otherwise scan the
+-- same deterministic (git ls-files) prefix every session forever, leaving every file after the
+-- budget cutoff permanently unchecked. last_scanned_path is the last tracked file the sweep
+-- finished examining before its budget ran out; the next sweep rotates its scan order to resume
+-- right after that file, wrapping back to the start, so repeated truncated sweeps eventually cover
+-- the whole project. Cleared (row deleted) the moment a sweep completes a full lap without running
+-- out of budget. Purely additive (no SCHEMA_VERSION bump needed): a missing row just means "start
+-- from the beginning", the same as a fresh database.
+CREATE TABLE IF NOT EXISTS reconcile_cursor (
+  root TEXT PRIMARY KEY,
+  last_scanned_path TEXT NOT NULL,
+  updated_at REAL NOT NULL
+);
+
+-- Cross-cache full-text search index for 'token-goat recall' (recall_index.ts). One row
+-- per bash-output/web-output/mcp-output blob-store entry (see disk_cache.ts), refreshed
+-- in place (ON CONFLICT DO UPDATE) whenever storeBashOutput/storeWebOutput/storeMcpOutput
+-- write that entry, so recall never needs a separate rebuild step. row_id is a plain
+-- surrogate integer key -- entry_id is the real blob-store id (bash/mcp ids are hex,
+-- web ids are the cache's own scheme) and is not unique on its own since bash-output and
+-- mcp-output ids share one namespace (BASH_OUTPUT_SUBDIR) while web-output ids are a
+-- separate namespace; cache_type disambiguates.
+CREATE TABLE IF NOT EXISTS cache_recall (
+  row_id INTEGER PRIMARY KEY AUTOINCREMENT,
+  cache_type TEXT NOT NULL,
+  entry_id TEXT NOT NULL,
+  label TEXT,
+  content TEXT,
+  stored_at REAL,
+  UNIQUE(cache_type, entry_id)
+);
+CREATE INDEX IF NOT EXISTS idx_cache_recall_type ON cache_recall(cache_type);
+
+-- Per-emission ledger for 'token-goat hint-stats' (hint_stats.ts). One row per hint
+-- emission event (a hook returning a 'context' HookOutput classified as a discretionary
+-- efficiency nudge, as opposed to a mandatory informational injection -- see hint_stats.ts's
+-- doc comment for the exact category list and what is deliberately excluded). correlator is a
+-- best-effort file-path/output-id substring extracted from the hint's own text, used to check
+-- whether a later Bash tool call in the same session actually followed the hint's specific
+-- pointer (see resolvePendingHintsForEvent) -- NULL when no such pointer could be extracted,
+-- in which case the row is inserted already resolved with acted_on=0 (counted as emitted, never
+-- eligible for auto-detected credit). calls_remaining is the countdown of subsequent tool-use
+-- events still eligible to resolve this row before it is considered timed out.
+CREATE TABLE IF NOT EXISTS hint_emissions (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  category TEXT NOT NULL,
+  session_id TEXT NOT NULL,
+  harness TEXT NOT NULL,
+  correlator TEXT,
+  emitted_at REAL NOT NULL,
+  resolved INTEGER NOT NULL DEFAULT 0,
+  acted_on INTEGER NOT NULL DEFAULT 0,
+  calls_remaining INTEGER NOT NULL DEFAULT 0,
+  bytes_emitted INTEGER
+);
+CREATE INDEX IF NOT EXISTS idx_hint_emissions_category ON hint_emissions(category);
+CREATE INDEX IF NOT EXISTS idx_hint_emissions_session_pending ON hint_emissions(session_id, resolved);
+
+-- Manual efficacy votes for a hint category (token-goat hint-stats --mark-effective/--mark-ineffective),
+-- kept separate from hint_emissions' automatic acted_on signal so the two are never silently
+-- blended -- see hint_stats.ts's doc comment on why some categories only support this manual signal.
+CREATE TABLE IF NOT EXISTS hint_manual_marks (
+  category TEXT PRIMARY KEY,
+  effective_count INTEGER NOT NULL DEFAULT 0,
+  ineffective_count INTEGER NOT NULL DEFAULT 0
+);
+
+-- Durable counter backing hint_stats.ts's backoff-threshold probe-recovery schedule: how many
+-- CONSECUTIVE suppressed occasions have elapsed for (category, harness) since a hint in this
+-- category was last actually shown (either organically, because shouldSuppress no longer holds,
+-- or via a prior probe). shouldSuppress itself stays a pure function of hint_emissions -- this
+-- table exists only because a suppressed occasion is deliberately never written to
+-- hint_emissions (see that table's own comment), so without a separate durable counter here
+-- there would be no way to know "how many suppressed occasions have we seen" across the
+-- short-lived hook CLI processes that call applyHintTracking. Keyed by (category, harness), not
+-- category alone, to match shouldSuppress/categoryStats' own per-harness scoping -- unlike
+-- hint_manual_marks (a human-entered vote, deliberately not harness-split).
+CREATE TABLE IF NOT EXISTS hint_suppression_probes (
+  category TEXT NOT NULL,
+  harness TEXT NOT NULL,
+  streak INTEGER NOT NULL DEFAULT 0,
+  PRIMARY KEY (category, harness)
+);
+
+-- Free-text architecture/rationale notes (the "why" layer -- see notes.ts), attached either to
+-- a whole file (symbol = '') or to one specific indexed symbol within it (symbol = that
+-- symbol's name). '' rather than NULL for the whole-file case because SQLite's UNIQUE treats
+-- NULLs as pairwise-distinct (never conflicting with each other), which would let note-add
+-- accumulate unlimited duplicate whole-file notes for the same file instead of upserting one;
+-- '' is a real, comparable value so UNIQUE(file_path, symbol) enforces "at most one note per
+-- attachment point" for both cases identically. 'fingerprint' is a SHA-256 digest (see
+-- fingerprintContent in fingerprint.ts) captured at write time of exactly what the note
+-- describes -- the resolved symbol's current body text for a symbol-scoped note, or a stable
+-- digest of the file's current top-level symbol manifest (name:kind:line-range per symbol,
+-- sorted) for a file-scoped note -- so 'token-goat note-list --stale-only' can recompute the
+-- same fingerprint against the live index later and flag a mismatch (see notes.ts's
+-- isNoteStale). Staleness detection is purely advisory: nothing here ever auto-rewrites or
+-- deletes a note's content, only flags that the code it describes has moved since it was
+-- written -- a human/agent re-review decides what to do with a stale note.
+CREATE TABLE IF NOT EXISTS notes (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  file_path TEXT NOT NULL,
+  symbol TEXT NOT NULL DEFAULT '',
+  content TEXT NOT NULL,
+  fingerprint TEXT NOT NULL,
+  created_at REAL NOT NULL,
+  updated_at REAL NOT NULL,
+  UNIQUE(file_path, symbol)
+);
+CREATE INDEX IF NOT EXISTS idx_notes_file_folded ON notes(TG_LOWER(file_path));
+
+-- Baseline for skill_version_drift.ts's one-shot nudge: the token-goat CLI version (and its
+-- flat command-name set, JSON-encoded) active the moment the token-goat skill's body was
+-- last (re)loaded into this session -- see hooks_skill.ts's postSkillHandler. A session that
+-- keeps running after the CLI is upgraded has no other way to learn that new surgical-read
+-- commands now exist (the skill only re-announces itself on an explicit reload), so
+-- checkSkillVersionDrift compares this snapshot against the live command set on each user turn
+-- and fires the nudge exactly once (notified_at) per (re)load. session_id is the primary key
+-- because only one skill (token-goat) is ever tracked here.
+CREATE TABLE IF NOT EXISTS skill_version_snapshots (
+  session_id TEXT PRIMARY KEY,
+  skill_name TEXT NOT NULL,
+  loaded_version TEXT NOT NULL,
+  loaded_commands_json TEXT NOT NULL,
+  notified_at REAL
+);
+
+-- Which embedding stack produced the vectors currently in chunk_vectors -- the model, its
+-- pinned revision, and the inference runtime (see embeddingProvenance in embeddings.ts). The
+-- vector table itself is vec0(rowid, embedding) and has nowhere to record this, so without
+-- this row a database that was embedded by one stack and then added to by another holds two
+-- incomparable sets of vectors under one index, with nothing able to tell them apart. That is
+-- not hypothetical: global.db is machine-wide across every project on the machine (see
+-- constants.ts), so upgrading the runtime, or changing the model or its pinned revision, mixes
+-- old and new vectors for as long as the old files go untouched. Measured drift between two
+-- runtime versions of the same quantized model is 0.9925-0.9978 cosine on the final vector --
+-- small, but enough to reorder near-ties, and invisible to every existing check.
+--
+-- Single-row by construction (the CHECK pins the key), because there is exactly one vector
+-- table per database. An EMPTY table on a database that already holds chunks means the vectors
+-- predate this stamp and their provenance is unknowable -- see ensureEmbeddingProvenance, which
+-- treats that exactly like a mismatch. That is what makes this work without a migration step.
+CREATE TABLE IF NOT EXISTS embedding_provenance (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  provenance TEXT NOT NULL
+);
+`;
+var FTS_TOKENIZER = "unicode61 remove_diacritics 2";
+var FTS_SQL = `
+CREATE VIRTUAL TABLE IF NOT EXISTS symbols_fts USING fts5(
+  name,
+  body,
+  docstring,
+  content='symbols',
+  content_rowid='id',
+  tokenize='${FTS_TOKENIZER}'
+);
+CREATE TRIGGER IF NOT EXISTS symbols_ai AFTER INSERT ON symbols BEGIN
+  INSERT INTO symbols_fts(rowid, name, body, docstring)
+  VALUES (new.id, new.name, new.body, new.docstring);
+END;
+CREATE TRIGGER IF NOT EXISTS symbols_ad AFTER DELETE ON symbols BEGIN
+  INSERT INTO symbols_fts(symbols_fts, rowid, name, body, docstring)
+  VALUES ('delete', old.id, old.name, old.body, old.docstring);
+END;
+CREATE TRIGGER IF NOT EXISTS symbols_au AFTER UPDATE ON symbols BEGIN
+  INSERT INTO symbols_fts(symbols_fts, rowid, name, body, docstring)
+  VALUES ('delete', old.id, old.name, old.body, old.docstring);
+  INSERT INTO symbols_fts(rowid, name, body, docstring)
+  VALUES (new.id, new.name, new.body, new.docstring);
+END;
+
+-- Content-linked FTS5 mirror of cache_recall (recall_index.ts), same shape as symbols_fts
+-- above. An INSERT ... ON CONFLICT DO UPDATE against cache_recall fires the AFTER UPDATE
+-- trigger (not AFTER INSERT) on the conflicting row, same as any other SQLite upsert, so the
+-- delete+reinsert pattern below keeps the fts index correct on a re-indexed (overwritten)
+-- entry, not just a brand-new one.
+CREATE VIRTUAL TABLE IF NOT EXISTS cache_recall_fts USING fts5(
+  label,
+  content,
+  content='cache_recall',
+  content_rowid='row_id',
+  tokenize='${FTS_TOKENIZER}'
+);
+CREATE TRIGGER IF NOT EXISTS cache_recall_ai AFTER INSERT ON cache_recall BEGIN
+  INSERT INTO cache_recall_fts(rowid, label, content)
+  VALUES (new.row_id, new.label, new.content);
+END;
+CREATE TRIGGER IF NOT EXISTS cache_recall_ad AFTER DELETE ON cache_recall BEGIN
+  INSERT INTO cache_recall_fts(cache_recall_fts, rowid, label, content)
+  VALUES ('delete', old.row_id, old.label, old.content);
+END;
+CREATE TRIGGER IF NOT EXISTS cache_recall_au AFTER UPDATE ON cache_recall BEGIN
+  INSERT INTO cache_recall_fts(cache_recall_fts, rowid, label, content)
+  VALUES ('delete', old.row_id, old.label, old.content);
+  INSERT INTO cache_recall_fts(rowid, label, content)
+  VALUES (new.row_id, new.label, new.content);
+END;
+`;
+var SCHEMA_VERSION = 14;
+function alterTableIdempotent(conn, sql) {
+  try {
+    conn.exec(sql);
+  } catch (err) {
+    if (!(err instanceof Error) || !/duplicate column/i.test(err.message)) throw err;
+  }
+}
+function purgeDotenvEmbeddings(conn) {
+  let paths;
+  try {
+    paths = conn.prepare("SELECT DISTINCT file_path FROM chunks").all().map((r) => r.file_path).filter(isDotenvPath);
+  } catch {
+    return;
+  }
+  if (paths.length === 0) return;
+  for (const p of paths) {
+    try {
+      conn.prepare("DELETE FROM chunk_vectors WHERE rowid IN (SELECT id FROM chunks WHERE file_path = ?)").run(p);
+    } catch {
+    }
+    conn.prepare("DELETE FROM chunks WHERE file_path = ?").run(p);
+    try {
+      conn.prepare("UPDATE files SET embed_sha = NULL WHERE path = ?").run(p);
+    } catch {
+    }
+  }
+}
+function rebuildFtsAtCurrentTokenizer(conn) {
+  try {
+    const declarations = conn.prepare("SELECT sql FROM sqlite_master WHERE name IN ('symbols_fts','cache_recall_fts')").all();
+    const current = declarations.map((d) => /tokenize\s*=\s*'([^']*)'/.exec(d.sql ?? "")?.[1] ?? "");
+    if (current.length === 2 && current.every((t) => t === FTS_TOKENIZER)) return;
+    conn.transaction(() => {
+      conn.exec("DROP TABLE IF EXISTS symbols_fts; DROP TABLE IF EXISTS cache_recall_fts;");
+      conn.exec(FTS_SQL);
+      conn.exec("INSERT INTO symbols_fts(symbols_fts) VALUES('rebuild');");
+      conn.exec("INSERT INTO cache_recall_fts(cache_recall_fts) VALUES('rebuild');");
+    }).immediate();
+  } catch {
+  }
+}
+var MIGRATIONS = {
+  // v1 -> v2: adds files.embed_sha, tracked separately from files.sha so embedding freshness can be gated independently of parse freshness (see makeIndexer in worker.ts). A pre-existing v1 database's `files` table predates the column, so it needs an explicit ALTER TABLE here; a brand-new database already has the column from SCHEMA_SQL's CREATE TABLE above, so the ALTER TABLE would fail with "duplicate column name" there -- swallow exactly that error and rethrow anything else, so a genuine ALTER TABLE failure is never silently lost.
+  1: (conn) => alterTableIdempotent(conn, "ALTER TABLE files ADD COLUMN embed_sha TEXT"),
+  // v2 -> v3: adds files.retry_count, a durable per-path counter for consecutive transient-read-failure requeues (see MAX_TRANSIENT_RETRIES / requeueDirtyPath / clearRetryCount in worker.ts). Previously this counter lived only in an in-memory Map inside worker.ts, which meant the retry-count reset -- run at the time in the short-lived hook CLI process -- could never actually reach the long-lived detached daemon process's own copy of that Map: they are different Node processes with no shared memory, so the reset was a silent no-op in the real deployed topology. Persisting the counter in `files` makes it visible to both processes via the one thing they do share: the index DB. Same swallow-duplicate-column pattern as v1 -> v2 above.
+  2: (conn) => alterTableIdempotent(conn, "ALTER TABLE files ADD COLUMN retry_count INTEGER NOT NULL DEFAULT 0"),
+  // v8 -> v9: adds symbols.parent (see SCHEMA_VERSION comment above for why). A pre-existing v8 database's `symbols` table predates the column, so it needs an explicit ALTER TABLE here; a brand-new database already has the column from SCHEMA_SQL's CREATE TABLE above, so the ALTER TABLE would fail with "duplicate column name" there -- swallow exactly that error and rethrow anything else, same pattern as v1 -> v2 / v2 -> v3 above.
+  8: (conn) => alterTableIdempotent(conn, "ALTER TABLE symbols ADD COLUMN parent TEXT NOT NULL DEFAULT ''"),
+  // v9 -> v10: adds hint_emissions.bytes_emitted (see SCHEMA_VERSION comment above for why). A pre-existing v9 database's `hint_emissions` table predates the column, so it needs an explicit ALTER TABLE here; a brand-new database already has the column from SCHEMA_SQL's CREATE TABLE above, so the ALTER TABLE would fail with "duplicate column name" there -- swallow exactly that error and rethrow anything else, same pattern as v1 -> v2 / v2 -> v3 / v8 -> v9 above.
+  9: (conn) => alterTableIdempotent(conn, "ALTER TABLE hint_emissions ADD COLUMN bytes_emitted INTEGER"),
+  // v10 -> v11: purge chunks (and their vectors) for dotenv files. Until this version, a tracked `.env` was chunked and embedded verbatim on the git path, so `semantic` returned its values -- see dotenv_redact.ts. Redacting from now on is not enough on its own: the embed-freshness gate (isEmbedFresh in parser.ts) skips a file whose bytes have not changed, so an already-indexed .env would have kept serving its pre-fix chunks indefinitely. Deleting the rows here both removes the stored secrets and, by clearing embed_sha, makes the next drain re-embed the file through the redacting path.
+  10: purgeDotenvEmbeddings,
+  // v12 -> v13: adds files.parser_sha, the digest of the extraction logic that produced this file's rows, tracked separately from files.sha for the same reason embed_sha is -- content freshness and parse freshness are different questions, and the content sha alone could only ever answer the first. A pre-existing v12 database's `files` table predates the column, so it needs an explicit ALTER TABLE here; a brand-new database already has it from SCHEMA_SQL's CREATE TABLE above, so the ALTER TABLE would fail with "duplicate column name" there -- swallow exactly that error and rethrow anything else, same pattern as v1 -> v2 / v2 -> v3 / v8 -> v9 / v9 -> v10 above. Deliberately left NULL for every existing row rather than backfilled with the current fingerprint: NULL is the truthful answer (nobody recorded which parser wrote those rows), and it is also the answer that makes the freshness gates reparse them once, which is exactly what a database indexed by an older parser needs. v13 -> v14: changes both FTS5 tables' tokenizer to `unicode61 remove_diacritics 2`, so a search for `Noi` or `Viet` finds `Hà Nội` and `Việt Nam` -- combining marks that `remove_diacritics 1`, FTS5's default, leaves in place. This is the first schema change that `CREATE VIRTUAL TABLE IF NOT EXISTS` cannot express at all rather than merely cannot express on a populated table: against an existing virtual table that statement is a silent no-op, so without MIGRATIONS[13] the new tokenizer would reach only databases created after this release. The step drops both tables, re-runs FTS_SQL to re-create them at the current declaration, and rebuilds each from its content table.
+  12: (conn) => alterTableIdempotent(conn, "ALTER TABLE files ADD COLUMN parser_sha TEXT"),
+  // v13 -> v14: re-creates both FTS5 tables at the tokenizer FTS_SQL currently declares (see the SCHEMA_VERSION comment above for why no `IF NOT EXISTS` form can do this).
+  13: rebuildFtsAtCurrentTokenizer
+};
+function runMigrations(conn, fromVersion, toVersion) {
+  for (let v = fromVersion; v < toVersion; v++) {
+    MIGRATIONS[v]?.(conn);
+  }
+}
+var WAL_SWITCH_DEADLINE_MS = 15e3;
+function enableWalWithRetry(conn, budgetMs = WAL_SWITCH_DEADLINE_MS) {
+  const deadline = Date.now() + budgetMs;
+  let lastError;
+  for (; ; ) {
+    try {
+      const mode = conn.pragma("journal_mode = WAL", { simple: true });
+      if (String(mode).toLowerCase() === "wal") return;
+      lastError = new Error(`got: ${String(mode)}`);
+    } catch (e) {
+      lastError = e;
+    }
+    try {
+      if (String(conn.pragma("journal_mode", { simple: true })).toLowerCase() === "wal") return;
+    } catch {
+    }
+    if (Date.now() >= deadline) {
+      throw new Error(`db: failed to enable WAL mode (${lastError instanceof Error ? lastError.message : String(lastError)})`);
+    }
+    sleepSync(25);
+  }
+}
+function initConnection(conn) {
+  conn.pragma("busy_timeout = 15000");
+  enableWalWithRetry(conn);
+  conn.pragma("synchronous = NORMAL");
+  conn.pragma("cache_size = -32000");
+  conn.pragma("temp_store = MEMORY");
+  conn.pragma("mmap_size = 134217728");
+  conn.function(
+    "TG_LOWER",
+    { deterministic: true },
+    (value) => value === null ? null : foldCase(String(value))
+  );
+  const storedVersion = Number(conn.pragma("user_version", { simple: true }));
+  if (storedVersion > SCHEMA_VERSION) {
+    throw new Error(
+      `db: index schema version ${storedVersion} is newer than this token-goat build supports (expected ${SCHEMA_VERSION}). Update token-goat, or delete the stale index database and let it rebuild.`
+    );
+  }
+  conn.exec(SCHEMA_SQL);
+  try {
+    conn.exec(FTS_SQL);
+  } catch {
+  }
+  try {
+    const sqliteVec = _require("sqlite-vec");
+    sqliteVec.load(conn);
+    conn.exec(
+      `CREATE VIRTUAL TABLE IF NOT EXISTS chunk_vectors USING vec0(
+         embedding float[384]
+       );`
+    );
+  } catch {
+  }
+  if (storedVersion < SCHEMA_VERSION) {
+    runMigrations(conn, storedVersion, SCHEMA_VERSION);
+    conn.pragma(`user_version = ${SCHEMA_VERSION}`);
+  }
+}
+function resolveDbPath(dbPath) {
+  if (path2.isAbsolute(dbPath)) return dbPath;
+  if (dbPath.includes("/") || dbPath.includes("\\")) return path2.resolve(dbPath);
+  return safeJoin(dataDir(), dbPath);
+}
+function connectionKey(dbPath) {
+  const resolved = resolveDbPath(dbPath);
+  return { resolved, key: foldPath(resolved) };
+}
+function getDb(dbPath) {
+  const { resolved, key } = connectionKey(dbPath);
+  const existing = _connections.get(key);
+  if (existing !== void 0) return existing;
+  const dir = path2.dirname(resolved);
+  try {
+    ensureDirSync(dir);
+  } catch (e) {
+    if (e.code !== "EEXIST" || !fs2.existsSync(dir)) throw e;
+  }
+  const conn = new Database(resolved);
+  try {
+    initConnection(conn);
+  } catch (e) {
+    try {
+      conn.close();
+    } catch {
+    }
+    throw e;
+  }
+  _connections.set(key, conn);
+  return conn;
+}
+function closeAllDbs() {
+  for (const conn of _connections.values()) {
+    try {
+      conn.close();
+    } catch {
+    }
+  }
+  _connections.clear();
+}
+registerReset(closeAllDbs);
+
+export {
+  precedingDocComment,
+  buildLineIndex,
+  offsetToLine,
+  stripCstyleComments,
+  stripXmlComments,
+  scanQuotedStringEnd,
+  stripJsComments,
+  stripHashComments,
+  maskHtmlNoise,
+  findHtmlHeadingMatches,
+  isInsideStringLiteral,
+  stripBlockCommentSpan,
+  stripNestedBlockCommentSpan,
+  stripLineComment,
+  stripStringLiterals,
+  matchRRawOpener,
+  matchGroovySlashy,
+  matchBashHeredocOpener,
+  stripMultilineStringSpan,
+  makeSpanSymbol,
+  makeLineSymbol,
+  makeSymbolEmitter,
+  assignFlatEndLines,
+  propagateEndLinesToSymbols,
+  findMatchingBraceEndLine,
+  assignBraceBlockSpans,
+  lastContentLine,
+  GENERIC_CLAUSE,
+  extractIni,
+  _lineClosesQuote,
+  _detectOpenQuote,
+  extractEnv,
+  isAblSource,
+  isMatlabSource,
+  isObjcSource,
+  isObjcHeader,
+  isPascalSource,
+  isPerlSource,
+  isPrologSource,
+  FILENAME_LANGUAGE,
+  TREE_SITTER_LANGUAGES,
+  languageHasFlag,
+  languageLabel,
+  fenceFor,
+  basenameImportsExtension,
+  partialRefsReason,
+  refineLanguageByContent,
+  detectLanguageOfFile,
+  detectLanguage,
+  nonTreeSitterLanguageCount,
+  unsupportedLanguageName,
+  isDotenvPath,
+  redactIfDotenv,
+  getDb
+};