token-goat 2.9.30 → 2.9.31

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

@@ -0,0 +1,1298 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  Database
+} from "./token-goat-chunk-XB5KKOCG.mjs";
+import {
+  assignFlatEndLines,
+  makeLineSymbol,
+  propagateEndLinesToSymbols
+} from "./token-goat-chunk-OUKDTVNU.mjs";
+import {
+  registerReset
+} from "./token-goat-chunk-YZAAZU2S.mjs";
+import {
+  countContentLines,
+  ensureDirSync
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  foldCase,
+  foldPath,
+  isCaseInsensitiveFs,
+  sleepSync
+} from "./token-goat-chunk-AM5V6GSX.mjs";
+import {
+  normalizePath,
+  safeJoin
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  SYMBOL_BODY_CHAR_CAP,
+  dataDir,
+  globalDbPath
+} from "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// 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/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" },
+  { id: "nginx", extraction: "regex", extensions: [".nginx"], basenames: ["nginx.conf"], label: "Nginx", ...DATA, symbolBearing: true, diffable: true, fence: "nginx" },
+  // `basenames` is matched against a lower-cased basename, so `Caddyfile` is spelled in lower case here; the display spelling is the label's job.
+  { id: "caddy", extraction: "regex", extensions: [".caddy"], basenames: ["caddyfile", "caddy.conf"], label: "Caddyfile", ...DATA, symbolBearing: true, diffable: true, fence: "caddy" },
+  { id: "apache", extraction: "regex", extensions: [".apache", ".apache2"], basenames: ["httpd.conf", "apache2.conf", ".htaccess"], label: "Apache Config", ...DATA, symbolBearing: true, diffable: true, fence: "apache" },
+  // `.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
+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/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/sql_path.ts
+init_define_import_meta_env();
+function pathEqClause(column) {
+  return isCaseInsensitiveFs() ? `TG_LOWER(${column}) = ?` : `${column} = ?`;
+}
+function pathSuffixClause(column) {
+  const col = isCaseInsensitiveFs() ? `TG_LOWER(${column})` : column;
+  return {
+    // Both separators are accepted because not every writer into `symbols` stores a normalizePath'd (forward-slash) file_path, and the JS-side path-boundary test this narrowing feeds treats `/` and `\` alike.
+    clause: `(${col} = ? OR substr(${col}, -length(?)) = ? OR substr(${col}, -length(?)) = ?)`,
+    params: (baseName) => {
+      const folded = foldPath(baseName);
+      return [folded, `/${folded}`, `/${folded}`, `\\${folded}`, `\\${folded}`];
+    }
+  };
+}
+function projectScopeClause(column) {
+  const caseInsensitive = isCaseInsensitiveFs();
+  const col = caseInsensitive ? `TG_LOWER(${column})` : column;
+  return {
+    // Parenthesised so an OR anywhere in the surrounding WHERE cannot bind tighter than the pair.
+    clause: `(${col} >= ? AND ${col} < ?)`,
+    params: (root) => {
+      const folded = caseInsensitive ? foldPath(normalizePath(root)) : normalizePath(root);
+      const lower = folded.endsWith("/") ? folded : `${folded}/`;
+      const upper = `${lower.slice(0, -1)}0`;
+      return [lower, upper];
+    }
+  };
+}
+function pathSpellings(filePath) {
+  const key = normalizePath(filePath);
+  if (!key.includes("/") && !key.includes("\\")) return [key];
+  const alt = key.includes("/") ? key.replace(/\//g, "\\") : key.replace(/\\/g, "/");
+  return [key, alt];
+}
+function filePathSpellingsClause(column, filePath) {
+  const params = pathSpellings(filePath).map(foldPath);
+  const clause = params.map(() => pathEqClause(column)).join(" OR ");
+  return { clause: params.length > 1 ? `(${clause})` : clause, params };
+}
+function fileRowByIndexKey(db, filePath, columns) {
+  const statement = db.prepare(`SELECT ${columns} FROM files WHERE ${pathEqClause("path")}`);
+  for (const spelling of pathSpellings(filePath)) {
+    const row = statement.get(foldPath(spelling));
+    if (row !== void 0) return row;
+  }
+  return void 0;
+}
+
+// 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));
+
+-- Transient-read-failure counters, keyed by path. See the note above SCHEMA_SQL for why they are not in files.
+CREATE TABLE IF NOT EXISTS index_retries (
+  path TEXT PRIMARY KEY,
+  retry_count INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_index_retries_path_folded ON index_retries(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 (symbol_body_probe.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
+-- symbol_body_probe.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
+);
+
+-- Projects indexed on purpose, see indexed_roots.ts.
+CREATE TABLE IF NOT EXISTS indexed_roots (
+  root TEXT PRIMARY KEY,
+  indexed_ms 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
+-- file-path/output-id pointer the hint carries, used to check
+-- whether a later Bash tool call in the same session actually followed the hint's specific
+-- pointer (see resolvePendingHintsForEvent). Supplied by the hint builder itself via
+-- HookOutput's correlators field wherever one exists, and only fallen back to a regex scrape
+-- of the rendered hint text (hint_stats.ts's extractPathCorrelator, whose doc comment records
+-- what that scrape actually measured) where it does not. A row can name SEVERAL files -- the
+-- sed/awk line-range hint joins one per file into one emission -- stored newline-separated and
+-- matched on any member; see joinCorrelators. NULL when no pointer could be supplied or extracted,
+-- in which case the row is inserted already resolved and observable=0: there is nothing a later
+-- command could do that this row would recognize, so no verdict about it was ever observed.
+-- observable=1 is the normal case. Efficacy counts only observable rows, numerator and denominator
+-- both, because an unobservable row's acted_on is a fabrication in whichever direction the code
+-- picked and averaging fabrications into a measured rate is how 174 of bash_redirect's 698 rows
+-- came to hold its efficacy down to 0.86% when the observed figure was 1.15%. calls_remaining is
+-- the countdown of subsequent tool-use events still eligible to resolve this row before it is
+-- considered timed out. A displayed, observable row with resolved=0 is pending: nothing has
+-- scored it yet. Nothing sweeps these on a clock, so a session that ends mid-window leaves its
+-- rows pending for good, and efficacy and suppression count only resolved rows -- counting a
+-- pending one as not acted on is what muted bash_redirect at 1 in 11 when its scored rows stood
+-- at 1 in 6. displayed=0 marks a detection that never reached the agent -- auto-
+-- suppressed, or declined by a hint's own net-benefit gate -- recorded so the ledger can answer
+-- how often a hint fired at all, which it previously could not: a suppressed detection left no
+-- trace, so a fully-muted category was indistinguishable from one that had stopped triggering.
+-- Such a row is always observable=0 and bytes_emitted=0: nothing was shown, so nothing was spent
+-- and no verdict was available. It shares hint_emissions' 180-day retention (pruneHintEmissions
+-- in stats.ts deletes on emitted_at alone), deliberately unlike hint_suppression_probes, which is
+-- one upserted row per key rather than a growing log and is therefore never pruned.
+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,
+  observable INTEGER NOT NULL DEFAULT 1,
+  displayed INTEGER NOT NULL DEFAULT 1
+);
+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 = 17;
+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. Superseded since: the counter shares the DB but no longer the table, because holding it in `files` meant a never-indexed path got a `files` row the moment one read failed, and three readers take a `files` row to mean the file is indexed -- see the `index_retries` comment in SCHEMA_SQL above. This column is still created for databases that predate that move; nothing reads or writes it.
+  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,
+  // v14 -> v15: adds hint_emissions.observable and backfills it from the column that always implied it. A pre-existing v14 database's `hint_emissions` 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 v8 -> v9 / v9 -> v10 / v12 -> v13 above. The backfill is exact rather than a guess: until this version a NULL correlator was the only way a row could be born with nothing to wait for, so `correlator IS NULL` identifies precisely the population the new column names. It runs unconditionally after the ALTER because alterTableIdempotent swallows the duplicate-column case, and re-running the UPDATE on an already-migrated database sets the same rows to the same values.
+  14: (conn) => {
+    alterTableIdempotent(conn, "ALTER TABLE hint_emissions ADD COLUMN observable INTEGER NOT NULL DEFAULT 1");
+    conn.prepare("UPDATE hint_emissions SET observable = 0 WHERE correlator IS NULL").run();
+  },
+  // v15 -> v16: adds hint_emissions.displayed (see the SCHEMA_VERSION comment above for why). A pre-existing v15 database's `hint_emissions` 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 v8 -> v9 / v9 -> v10 / v12 -> v13 / v14 -> v15 above. No backfill, unlike v14 -> v15: until this version a row was only ever written when a hint was actually shown, so the column's own DEFAULT 1 is already the truth for every existing row, and an UPDATE would be a no-op dressed up as a migration step.
+  15: (conn) => alterTableIdempotent(conn, "ALTER TABLE hint_emissions ADD COLUMN displayed INTEGER NOT NULL DEFAULT 1"),
+  // v16 -> v17: backfills indexed_roots.
+  16: backfillIndexedRoots
+};
+function backfillIndexedRoots(conn) {
+  const scope = projectScopeClause("file_path");
+  const hasSymbols = conn.prepare(`SELECT 1 FROM symbols WHERE ${scope.clause} LIMIT 1`);
+  const insert = conn.prepare("INSERT OR IGNORE INTO indexed_roots (root, indexed_ms) VALUES (?, ?)");
+  const roots = conn.prepare("SELECT root, last_seen_ms FROM known_roots").all();
+  for (const { root, last_seen_ms } of roots) {
+    if (hasSymbols.get(...scope.params(root)) !== void 0) insert.run(normalizePath(root), last_seen_ms);
+  }
+}
+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, stopOn) {
+  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;
+      if (isDamagedDatabaseError(e) || stopOn?.(e) === true) throw walSwitchError(e);
+    }
+    try {
+      if (String(conn.pragma("journal_mode", { simple: true })).toLowerCase() === "wal") return;
+    } catch {
+    }
+    if (Date.now() >= deadline) throw walSwitchError(lastError);
+    sleepSync(25);
+  }
+}
+function isDamagedDatabaseError(e) {
+  const code = e?.code;
+  return typeof code === "string" && /^SQLITE_(?:NOTADB|CORRUPT)/.test(code);
+}
+function walSwitchError(lastError) {
+  return new Error(`db: failed to enable WAL mode (${lastError instanceof Error ? lastError.message : String(lastError)})`, { cause: lastError });
+}
+var HOOK_DB_WAIT_MS = 250;
+var _hookWaits = false;
+function limitDbWaitsForHook(on = true) {
+  _hookWaits = on;
+}
+function connectionWaitBudgets() {
+  return _hookWaits ? { busyMs: HOOK_DB_WAIT_MS, walSwitchMs: HOOK_DB_WAIT_MS } : { busyMs: 15e3, walSwitchMs: WAL_SWITCH_DEADLINE_MS };
+}
+function initConnection(conn, walStopOn) {
+  const waits = connectionWaitBudgets();
+  conn.pragma(`busy_timeout = ${waits.busyMs}`);
+  enableWalWithRetry(conn, waits.walSwitchMs, walStopOn);
+  conn.pragma("synchronous = NORMAL");
+  conn.pragma("cache_size = -32000");
+  conn.pragma("temp_store = MEMORY");
+  conn.pragma("mmap_size = 134217728");
+  registerTgLower(conn);
+  const storedVersion = Number(conn.pragma("user_version", { simple: true }));
+  if (storedVersion > SCHEMA_VERSION) throw newerSchemaError(storedVersion);
+  conn.exec(SCHEMA_SQL);
+  try {
+    conn.exec(FTS_SQL);
+  } catch {
+  }
+  if (loadSqliteVec(conn)) {
+    try {
+      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 newerSchemaError(storedVersion) {
+  return 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.`
+  );
+}
+function registerTgLower(conn) {
+  conn.function(
+    "TG_LOWER",
+    { deterministic: true },
+    (value) => value === null ? null : foldCase(String(value))
+  );
+}
+function loadSqliteVec(conn) {
+  try {
+    const sqliteVec = _require("sqlite-vec");
+    sqliteVec.load(conn);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var _readOnlyFallback;
+var _readOnlyConnections = /* @__PURE__ */ new Map();
+function allowReadOnlyIndex(onFirstUse) {
+  _readOnlyFallback = { onFirstUse, used: false };
+}
+function isReadOnlyDb(dbPath) {
+  if (_readOnlyFallback === void 0) return false;
+  try {
+    getDb(dbPath, { create: false });
+  } catch {
+    return false;
+  }
+  return _readOnlyConnections.has(connectionKey(dbPath).key);
+}
+var WRITE_ACCESS_SQLITE_CODE_RE = /^SQLITE_(?:CANTOPEN|READONLY|PERM|IOERR_ACCESS|IOERR_SHMOPEN)/;
+var WRITE_ACCESS_FS_CODES = /* @__PURE__ */ new Set(["EACCES", "EPERM", "EROFS"]);
+function isWriteAccessError(e) {
+  for (let cur = e, depth = 0; cur instanceof Error && depth < 4; cur = cur.cause, depth++) {
+    const code = cur.code;
+    if (typeof code === "string" && (WRITE_ACCESS_SQLITE_CODE_RE.test(code) || WRITE_ACCESS_FS_CODES.has(code))) return true;
+  }
+  return false;
+}
+function writeRefusal(resolved) {
+  let fd;
+  try {
+    fd = fs2.openSync(resolved, "r+");
+  } catch (e) {
+    return isWriteAccessError(e) ? e : void 0;
+  }
+  fs2.closeSync(fd);
+  return void 0;
+}
+function openReadOnlyAt(resolved, immutable, busyTimeoutMs = 15e3) {
+  const conn = new Database(resolved, { readonly: true, fileMustExist: true, immutable });
+  try {
+    conn.pragma(`busy_timeout = ${busyTimeoutMs}`);
+    return { conn, storedVersion: Number(conn.pragma("user_version", { simple: true })) };
+  } catch (e) {
+    try {
+      conn.close();
+    } catch {
+    }
+    throw e;
+  }
+}
+function openIndexReadOnly(resolved) {
+  let opened;
+  try {
+    opened = openReadOnlyAt(resolved, false);
+  } catch (e) {
+    if (!isWriteAccessError(e)) throw e;
+    opened = openReadOnlyAt(resolved, true);
+  }
+  const { conn, storedVersion } = opened;
+  try {
+    if (storedVersion > SCHEMA_VERSION) throw newerSchemaError(storedVersion);
+    if (storedVersion < SCHEMA_VERSION) {
+      throw new Error(
+        `db: index schema version ${storedVersion} predates this token-goat build (expected ${SCHEMA_VERSION}) and cannot be upgraded without write access. Run token-goat once where its data directory is writable.`
+      );
+    }
+    registerTgLower(conn);
+    loadSqliteVec(conn);
+  } catch (e) {
+    try {
+      conn.close();
+    } catch {
+    }
+    throw e;
+  }
+  return conn;
+}
+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) };
+}
+var PROBE_BUSY_TIMEOUT_MS = 250;
+function withProbeIndex(fn, dbPath) {
+  const resolved = resolveDbPath(dbPath ?? globalDbPath());
+  if (!fs2.existsSync(resolved)) return null;
+  let conn = null;
+  try {
+    let opened;
+    try {
+      opened = openReadOnlyAt(resolved, false, PROBE_BUSY_TIMEOUT_MS);
+    } catch (e) {
+      if (!isWriteAccessError(e)) throw e;
+      opened = openReadOnlyAt(resolved, true, PROBE_BUSY_TIMEOUT_MS);
+    }
+    conn = opened.conn;
+    if (opened.storedVersion !== SCHEMA_VERSION) return null;
+    registerTgLower(conn);
+    return fn(conn);
+  } catch {
+    return null;
+  } finally {
+    if (conn) {
+      try {
+        conn.close();
+      } catch {
+      }
+    }
+  }
+}
+var _emptyIndex;
+function getReadDb(dbPath) {
+  return getDb(dbPath, { create: false });
+}
+function getDb(dbPath, opts = {}) {
+  const { resolved, key } = connectionKey(dbPath);
+  const existing = _connections.get(key);
+  if (existing !== void 0) return existing;
+  if (opts.create === false && !fs2.existsSync(resolved)) {
+    if (_emptyIndex === void 0) {
+      _emptyIndex = new Database(":memory:");
+      registerTgLower(_emptyIndex);
+      _emptyIndex.exec(SCHEMA_SQL);
+      try {
+        _emptyIndex.exec(FTS_SQL);
+      } catch {
+      }
+    }
+    return _emptyIndex;
+  }
+  const fallback = _readOnlyFallback;
+  if (fallback !== void 0) {
+    const readOnly = _readOnlyConnections.get(key);
+    if (readOnly !== void 0) return readOnly;
+    const refused = writeRefusal(resolved);
+    if (refused !== void 0) return openReadOnlyFallback(resolved, key, fallback, refused);
+  }
+  const dir = path2.dirname(resolved);
+  try {
+    ensureDirSync(dir);
+  } catch (e) {
+    if (e.code !== "EEXIST" || !fs2.existsSync(dir)) throw e;
+  }
+  let conn;
+  try {
+    conn = new Database(resolved);
+    initConnection(conn, fallback !== void 0 ? isWriteAccessError : void 0);
+  } catch (e) {
+    try {
+      conn?.close();
+    } catch {
+    }
+    if (fallback !== void 0 && isWriteAccessError(e)) return openReadOnlyFallback(resolved, key, fallback, e);
+    throw e;
+  }
+  _connections.set(key, conn);
+  return conn;
+}
+function openReadOnlyFallback(resolved, key, fallback, writeError) {
+  let conn;
+  try {
+    conn = openIndexReadOnly(resolved);
+  } catch (e) {
+    throw isWriteAccessError(e) || !fs2.existsSync(resolved) ? writeError : e;
+  }
+  _readOnlyConnections.set(key, conn);
+  if (!fallback.used) {
+    fallback.used = true;
+    fallback.onFirstUse();
+  }
+  return conn;
+}
+function closeDb(dbPath) {
+  const { key } = connectionKey(dbPath);
+  for (const cache of [_connections, _readOnlyConnections]) {
+    const conn = cache.get(key);
+    if (conn === void 0) continue;
+    try {
+      conn.close();
+    } catch {
+    }
+    cache.delete(key);
+  }
+}
+function closeAllDbs() {
+  try {
+    _emptyIndex?.close();
+  } catch {
+  }
+  _emptyIndex = void 0;
+  for (const cache of [_connections, _readOnlyConnections]) {
+    for (const conn of cache.values()) {
+      try {
+        conn.close();
+      } catch {
+      }
+    }
+    cache.clear();
+  }
+}
+registerReset(closeAllDbs, { perRequest: true });
+registerReset(() => {
+  _readOnlyFallback = void 0;
+}, { perRequest: true });
+registerReset(() => {
+  _hookWaits = false;
+}, { perRequest: true });
+
+export {
+  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,
+  pathEqClause,
+  pathSuffixClause,
+  projectScopeClause,
+  filePathSpellingsClause,
+  fileRowByIndexKey,
+  limitDbWaitsForHook,
+  allowReadOnlyIndex,
+  isReadOnlyDb,
+  withProbeIndex,
+  getReadDb,
+  getDb,
+  closeDb
+};