@vibgrate/cli 2026.728.3 → 2026.728.4

package/dist/chunk-G4HTI4ZM.js

@@ -0,0 +1,1537 @@
+import { findNodes } from './chunk-J7LKEB2R.js';
+import { extractLiteralNeedles, residualForSymbolSearch } from './chunk-EETK7S43.js';
+import { stableStringify } from './chunk-ZKNB4YH4.js';
+import { hashString } from './chunk-JFGYT6BI.js';
+import * as fs3 from 'fs';
+import * as path3 from 'path';
+import * as os from 'os';
+import { execFileSync, spawnSync } from 'child_process';
+import { Worker } from 'worker_threads';
+
+var ECOSYSTEMS = ["npm", "pypi", "go", "rust", "ruby", "php", "dotnet", "swift", "dart", "java"];
+function inventory(root) {
+  const manifests = findManifests(root);
+  const records = [];
+  records.push(...npmDeps(manifests.npm));
+  records.push(...pypiDeps(manifests.pypi));
+  records.push(...goDeps(manifests.go));
+  records.push(...cargoDeps(manifests.rust));
+  records.push(...rubyDeps(manifests.ruby));
+  records.push(...phpDeps(manifests.php));
+  records.push(...dotnetDeps(manifests.dotnet));
+  records.push(...swiftDeps(manifests.swift));
+  records.push(...dartDeps(manifests.dart));
+  records.push(...javaDeps(manifests.java));
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = records.filter((r) => {
+    const key = `${r.ecosystem}\0${r.name}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  deduped.sort((a, b) => a.ecosystem.localeCompare(b.ecosystem) || a.name.localeCompare(b.name));
+  const counts = { total: deduped.length };
+  for (const e of ECOSYSTEMS) counts[e] = 0;
+  for (const r of deduped) counts[r.ecosystem]++;
+  return { records: deduped, counts };
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "out",
+  ".vibgrate",
+  "vendor",
+  ".venv",
+  "venv",
+  "env",
+  "__pycache__",
+  "target",
+  ".next",
+  ".nuxt",
+  "coverage",
+  ".cache"
+]);
+var MANIFEST_BY_FILE = {
+  "package.json": "npm",
+  "requirements.txt": "pypi",
+  "pyproject.toml": "pypi",
+  "go.mod": "go",
+  "Cargo.toml": "rust",
+  Gemfile: "ruby",
+  "composer.json": "php",
+  "Package.swift": "swift",
+  "pubspec.yaml": "dart",
+  "pom.xml": "java",
+  "build.gradle": "java",
+  "build.gradle.kts": "java"
+};
+function findManifests(root) {
+  const set = Object.fromEntries(ECOSYSTEMS.map((e) => [e, []]));
+  const MAX_ENTRIES = 2e4;
+  let scanned = 0;
+  const walk = (dir, depth) => {
+    if (depth > 8 || scanned > MAX_ENTRIES) return;
+    let entries;
+    try {
+      entries = fs3.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      scanned++;
+      if (scanned > MAX_ENTRIES) break;
+      if (e.isDirectory()) {
+        if (!SKIP_DIRS.has(e.name) && !e.name.startsWith(".")) walk(path3.join(dir, e.name), depth + 1);
+        continue;
+      }
+      const eco = MANIFEST_BY_FILE[e.name] ?? (/\.(cs|fs)proj$/i.test(e.name) ? "dotnet" : void 0);
+      if (eco) set[eco].push(path3.join(dir, e.name));
+    }
+  };
+  walk(root, 0);
+  for (const e of ECOSYSTEMS) set[e].sort();
+  return set;
+}
+function npmDeps(files) {
+  const out = [];
+  for (const file of files) {
+    let pkg;
+    try {
+      pkg = JSON.parse(fs3.readFileSync(file, "utf8"));
+    } catch {
+      continue;
+    }
+    const dir = path3.dirname(file);
+    const all = { ...pkg.dependencies, ...pkg.devDependencies };
+    for (const [name, declared] of Object.entries(all)) {
+      out.push({ name, ecosystem: "npm", declared, installed: installedNpmVersion(dir, name) });
+    }
+  }
+  return out;
+}
+function installedNpmVersion(dir, name) {
+  let cur = dir;
+  for (let i = 0; i < 12; i++) {
+    const p = path3.join(cur, "node_modules", name, "package.json");
+    try {
+      return JSON.parse(fs3.readFileSync(p, "utf8")).version;
+    } catch {
+    }
+    const parent = path3.dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  return void 0;
+}
+function installedTreeVersion(root, ecosystem, name) {
+  if (ecosystem === "pypi") return installedPypiVersion(root, name);
+  if (ecosystem === "php") return installedPhpVersion(root, name);
+  return void 0;
+}
+function normalizePep503(name) {
+  return name.trim().toLowerCase().replace(/[-_.]+/g, "-");
+}
+function sitePackagesDirs(base) {
+  const out = [];
+  try {
+    for (const d of fs3.readdirSync(path3.join(base, "lib"))) {
+      if (d.startsWith("python")) out.push(path3.join(base, "lib", d, "site-packages"));
+    }
+  } catch {
+  }
+  out.push(path3.join(base, "Lib", "site-packages"));
+  return out;
+}
+function installedPypiVersion(root, name) {
+  const target = normalizePep503(name);
+  for (const venv of [".venv", "venv", "env", ".tox"]) {
+    for (const sp of sitePackagesDirs(path3.join(root, venv))) {
+      let entries;
+      try {
+        entries = fs3.readdirSync(sp);
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        const m = /^(.+?)-(\d[^-]*)\.dist-info$/.exec(entry);
+        if (m && normalizePep503(m[1]) === target) return m[2];
+      }
+    }
+  }
+  return void 0;
+}
+function installedPhpVersion(root, name) {
+  let data;
+  try {
+    data = JSON.parse(fs3.readFileSync(path3.join(root, "vendor", "composer", "installed.json"), "utf8"));
+  } catch {
+    return void 0;
+  }
+  const pkgs = Array.isArray(data) ? data : data.packages;
+  if (!Array.isArray(pkgs)) return void 0;
+  const p = pkgs.find((x) => x && typeof x === "object" && x.name === name);
+  return typeof p?.version === "string" ? p.version.replace(/^v/, "") : void 0;
+}
+function pypiDeps(files) {
+  const byName = /* @__PURE__ */ new Map();
+  const add = (name, declared) => {
+    const clean = name.trim().replace(/\[.*\]$/, "");
+    if (!clean || clean.toLowerCase() === "python") return;
+    if (!byName.has(clean)) byName.set(clean, { name: clean, ecosystem: "pypi", declared: declared.trim() || "*" });
+  };
+  for (const file of files) {
+    let text;
+    try {
+      text = fs3.readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    if (path3.basename(file) === "requirements.txt") {
+      for (const line of text.split("\n")) {
+        const t = line.trim();
+        if (!t || t.startsWith("#") || t.startsWith("-")) continue;
+        const m = /^([A-Za-z0-9._-]+(?:\[[^\]]*\])?)\s*([<>=!~).*]+.*)?$/.exec(t);
+        if (m) add(m[1], m[2] ?? "*");
+      }
+    } else {
+      for (const dep of pep621Dependencies(text)) {
+        const m = /^([A-Za-z0-9._-]+(?:\[[^\]]*\])?)\s*(.*)$/.exec(dep.trim());
+        if (m) add(m[1], m[2] ?? "*");
+      }
+      for (const [name, spec] of poetryDependencies(text)) add(name, spec);
+    }
+  }
+  return [...byName.values()];
+}
+function pep621Dependencies(text) {
+  const section = sectionBody(text, "project");
+  if (!section) return [];
+  const start = /dependencies\s*=\s*\[/.exec(section);
+  if (!start) return [];
+  let depth = 0;
+  let inStr = false;
+  let strCh = "";
+  const out = [];
+  let cur = "";
+  for (let i = start.index + start[0].length - 1; i < section.length; i++) {
+    const ch = section[i];
+    if (inStr) {
+      if (ch === strCh) {
+        out.push(cur);
+        inStr = false;
+      } else cur += ch;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inStr = true;
+      strCh = ch;
+      cur = "";
+    } else if (ch === "[") depth++;
+    else if (ch === "]") {
+      depth--;
+      if (depth === 0) break;
+    }
+  }
+  return out;
+}
+function poetryDependencies(text) {
+  const out = [];
+  const lines = text.split("\n");
+  let inDeps = false;
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (line.startsWith("[")) {
+      inDeps = /^\[tool\.poetry(\.group\.[^.\]]+)?\.dependencies\]$/.test(line);
+      continue;
+    }
+    if (!inDeps || !line || line.startsWith("#")) continue;
+    const m = /^([A-Za-z0-9._-]+)\s*=\s*["']([^"']*)["']/.exec(line);
+    if (m) out.push([m[1], m[2] || "*"]);
+  }
+  return out;
+}
+function sectionBody(text, name) {
+  const lines = text.split("\n");
+  let capturing = false;
+  const body = [];
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (/^\[/.test(line)) {
+      if (capturing) break;
+      capturing = line === `[${name}]`;
+      continue;
+    }
+    if (capturing) body.push(raw);
+  }
+  return capturing || body.length ? body.join("\n") : null;
+}
+function goDeps(files) {
+  const out = [];
+  for (const mod of files) {
+    let text;
+    try {
+      text = fs3.readFileSync(mod, "utf8");
+    } catch {
+      continue;
+    }
+    const re = /^\s*(?:require\s+)?([\w./-]+)\s+v(\S+)/gm;
+    let m;
+    while (m = re.exec(text)) {
+      if (m[1] === "go" || m[1] === "require" || m[1].startsWith("module")) continue;
+      out.push({ name: m[1], ecosystem: "go", declared: `v${m[2]}` });
+    }
+  }
+  return out;
+}
+function cargoDeps(files) {
+  const out = [];
+  for (const file of files) {
+    let text;
+    try {
+      text = fs3.readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    for (const table of ["dependencies", "dev-dependencies", "build-dependencies"]) {
+      const body = sectionBody(text, table);
+      if (!body) continue;
+      for (const raw of body.split("\n")) {
+        const line = raw.trim();
+        if (!line || line.startsWith("#")) continue;
+        const m = /^([A-Za-z0-9._-]+)\s*=\s*(.+)$/.exec(line);
+        if (!m) continue;
+        const rhs = m[2].trim();
+        let declared = "*";
+        if (rhs.startsWith('"')) {
+          const sm = /^"([^"]+)"/.exec(rhs);
+          if (sm) declared = sm[1];
+        } else if (rhs.startsWith("{")) {
+          const vm = /version\s*=\s*"([^"]+)"/.exec(rhs);
+          if (vm) declared = vm[1];
+        }
+        out.push({ name: m[1], ecosystem: "rust", declared });
+      }
+    }
+  }
+  return out;
+}
+function rubyDeps(files) {
+  const out = [];
+  for (const file of files) {
+    let text;
+    try {
+      text = fs3.readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    const re = /^\s*gem\s+["']([^"']+)["']\s*(?:,\s*["']([^"']+)["'])?/gm;
+    let m;
+    while (m = re.exec(text)) out.push({ name: m[1], ecosystem: "ruby", declared: m[2] ?? "*" });
+  }
+  return out;
+}
+function phpDeps(files) {
+  const out = [];
+  for (const file of files) {
+    let pkg;
+    try {
+      pkg = JSON.parse(fs3.readFileSync(file, "utf8"));
+    } catch {
+      continue;
+    }
+    const all = { ...pkg.require, ...pkg["require-dev"] };
+    for (const [name, declared] of Object.entries(all)) {
+      if (!name.includes("/")) continue;
+      out.push({ name, ecosystem: "php", declared });
+    }
+  }
+  return out;
+}
+function dotnetDeps(files) {
+  const out = [];
+  for (const file of files) {
+    let text;
+    try {
+      text = fs3.readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    const tagRe = /<PackageReference\b[^>]*>/gi;
+    let m;
+    while (m = tagRe.exec(text)) {
+      const inc = /Include\s*=\s*"([^"]+)"/i.exec(m[0]);
+      if (!inc) continue;
+      const ver = /Version\s*=\s*"([^"]+)"/i.exec(m[0]);
+      out.push({ name: inc[1], ecosystem: "dotnet", declared: ver?.[1] ?? "*" });
+    }
+  }
+  return out;
+}
+function swiftDeps(files) {
+  const out = [];
+  for (const file of files) {
+    let text;
+    try {
+      text = fs3.readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    const re = /\.package\(/g;
+    let m;
+    while (m = re.exec(text)) {
+      const win = text.slice(m.index, m.index + 200);
+      const urlM = /url:\s*"([^"]+)"/.exec(win);
+      if (!urlM) continue;
+      const name = (urlM[1].replace(/\.git$/, "").split("/").filter(Boolean).pop() ?? urlM[1]).toLowerCase();
+      const verM = /"(\d+\.\d+(?:\.\d+)?)"/.exec(win.slice(urlM.index + urlM[0].length));
+      out.push({ name, ecosystem: "swift", declared: verM?.[1] ?? "*" });
+    }
+  }
+  return out;
+}
+function dartDeps(files) {
+  const out = [];
+  for (const file of files) {
+    let text;
+    try {
+      text = fs3.readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    let section = "";
+    for (const raw of text.split("\n")) {
+      const top = /^([a-z_]+):\s*$/.exec(raw);
+      if (top) {
+        section = top[1];
+        continue;
+      }
+      if (section !== "dependencies" && section !== "dev_dependencies") continue;
+      const m = /^  ([A-Za-z0-9_.]+):\s*(\S.*)?$/.exec(raw);
+      if (!m || m[1] === "flutter" || m[1] === "sdk") continue;
+      const declared = (m[2] ?? "").replace(/^["']|["']$/g, "").trim() || "*";
+      out.push({ name: m[1], ecosystem: "dart", declared });
+    }
+  }
+  return out;
+}
+function javaDeps(files) {
+  const out = [];
+  for (const file of files) {
+    let text;
+    try {
+      text = fs3.readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    if (path3.basename(file) === "pom.xml") {
+      for (const block of text.match(/<dependency>[\s\S]*?<\/dependency>/g) ?? []) {
+        const g = /<groupId>([^<]+)<\/groupId>/.exec(block);
+        const a = /<artifactId>([^<]+)<\/artifactId>/.exec(block);
+        if (!g || !a) continue;
+        const v = /<version>([^<]+)<\/version>/.exec(block);
+        const declared = v ? v[1].trim().startsWith("${") ? "*" : v[1].trim() : "*";
+        out.push({ name: `${g[1].trim()}:${a[1].trim()}`, ecosystem: "java", declared });
+      }
+    } else {
+      const re = /(?:implementation|api|compileOnly|runtimeOnly|testImplementation|testRuntimeOnly|annotationProcessor)\s*[(]?\s*["']([\w.-]+):([\w.-]+):([^"']+)["']/g;
+      let m;
+      while (m = re.exec(text)) out.push({ name: `${m[1]}:${m[2]}`, ecosystem: "java", declared: m[3] });
+    }
+  }
+  return out;
+}
+async function enrichOnline(records, fetchImpl = globalThis.fetch) {
+  for (const r of records) {
+    if (r.ecosystem !== "npm" || !r.installed) continue;
+    try {
+      const res = await fetchImpl(`https://registry.npmjs.org/${encodeURIComponent(r.name)}/latest`);
+      if (!res.ok) continue;
+      const data = await res.json();
+      r.latest = data.version;
+      r.drift = classify(r.installed, r.latest);
+    } catch {
+      r.drift = "unknown";
+    }
+  }
+}
+function classify(installed, latest) {
+  if (!latest) return "unknown";
+  const a = installed.split(".").map(Number);
+  const b = latest.split(".").map(Number);
+  if (a[0] !== b[0]) return "major";
+  if (a[1] !== b[1]) return "minor";
+  if (a[2] !== b[2]) return "patch";
+  return "current";
+}
+function lockfileVersion(root, ecosystem, name) {
+  if (ecosystem === "npm") return packageLockVersion(root, name) ?? yarnLockVersion(root, name);
+  if (ecosystem === "pypi") return pypiLockVersion(root, name);
+  if (ecosystem === "rust") return tomlPackageLock(root, "Cargo.lock", name, rustName);
+  if (ecosystem === "ruby") return gemfileLock(root, name);
+  if (ecosystem === "php") return composerLock(root, name);
+  if (ecosystem === "dotnet") return packagesLock(root, name);
+  if (ecosystem === "swift") return packageResolved(root, name);
+  if (ecosystem === "dart") return pubspecLock(root, name);
+  if (ecosystem === "java") return gradleLock(root, name);
+  return void 0;
+}
+function gradleLock(root, name) {
+  let text;
+  try {
+    text = fs3.readFileSync(path3.join(root, "gradle.lockfile"), "utf8");
+  } catch {
+    return void 0;
+  }
+  const m = new RegExp(`^${escapeRegExp(name)}:([^=\\s]+)=`, "m").exec(text);
+  return m ? m[1] : void 0;
+}
+function packageResolved(root, name) {
+  let data;
+  try {
+    data = JSON.parse(fs3.readFileSync(path3.join(root, "Package.resolved"), "utf8"));
+  } catch {
+    return void 0;
+  }
+  const pins = data.pins ?? data.object?.pins;
+  if (!Array.isArray(pins)) return void 0;
+  const target = name.toLowerCase();
+  for (const p of pins) {
+    const id = (p.identity ?? p.package ?? "").toLowerCase();
+    if (id === target && p.state?.version) return p.state.version;
+  }
+  return void 0;
+}
+function pubspecLock(root, name) {
+  let text;
+  try {
+    text = fs3.readFileSync(path3.join(root, "pubspec.lock"), "utf8");
+  } catch {
+    return void 0;
+  }
+  let inPkg = false;
+  for (const line of text.split("\n")) {
+    const key = /^  ([A-Za-z0-9_.]+):\s*$/.exec(line);
+    if (key) {
+      inPkg = key[1] === name;
+      continue;
+    }
+    if (inPkg) {
+      const vm = /^\s+version:\s*"?([^"\s]+)"?/.exec(line);
+      if (vm) return vm[1];
+    }
+  }
+  return void 0;
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function gemfileLock(root, name) {
+  let text;
+  try {
+    text = fs3.readFileSync(path3.join(root, "Gemfile.lock"), "utf8");
+  } catch {
+    return void 0;
+  }
+  const m = new RegExp(`^    ${escapeRegExp(name)} \\((\\d[^)]*)\\)`, "m").exec(text);
+  return m ? m[1] : void 0;
+}
+function composerLock(root, name) {
+  let data;
+  try {
+    data = JSON.parse(fs3.readFileSync(path3.join(root, "composer.lock"), "utf8"));
+  } catch {
+    return void 0;
+  }
+  for (const section of ["packages", "packages-dev"]) {
+    const arr = data[section];
+    if (!Array.isArray(arr)) continue;
+    const p = arr.find((x) => x && x.name === name);
+    if (p && typeof p.version === "string") return p.version.replace(/^v/, "");
+  }
+  return void 0;
+}
+function packagesLock(root, name) {
+  let data;
+  try {
+    data = JSON.parse(fs3.readFileSync(path3.join(root, "packages.lock.json"), "utf8"));
+  } catch {
+    return void 0;
+  }
+  const target = name.toLowerCase();
+  for (const fw of Object.values(data.dependencies ?? {})) {
+    if (!fw || typeof fw !== "object") continue;
+    for (const [id, v] of Object.entries(fw)) {
+      if (id.toLowerCase() === target && v && typeof v.resolved === "string") return v.resolved;
+    }
+  }
+  return void 0;
+}
+function pep503(name) {
+  return name.trim().toLowerCase().replace(/[-_.]+/g, "-");
+}
+function rustName(name) {
+  return name.trim().toLowerCase();
+}
+function pypiLockVersion(root, name) {
+  return tomlPackageLock(root, "poetry.lock", name, pep503) ?? tomlPackageLock(root, "uv.lock", name, pep503) ?? pipfileLock(root, name);
+}
+function tomlPackageLock(root, file, name, normalize) {
+  let text;
+  try {
+    text = fs3.readFileSync(path3.join(root, file), "utf8");
+  } catch {
+    return void 0;
+  }
+  const target = normalize(name);
+  for (const block of text.split(/\[\[package\]\]/)) {
+    const nm = /(?:^|\n)\s*name\s*=\s*"([^"]+)"/.exec(block);
+    if (nm && normalize(nm[1]) === target) {
+      const ver = /(?:^|\n)\s*version\s*=\s*"([^"]+)"/.exec(block);
+      if (ver) return ver[1];
+    }
+  }
+  return void 0;
+}
+function pipfileLock(root, name) {
+  let data;
+  try {
+    data = JSON.parse(fs3.readFileSync(path3.join(root, "Pipfile.lock"), "utf8"));
+  } catch {
+    return void 0;
+  }
+  const target = pep503(name);
+  for (const section of ["default", "develop"]) {
+    const deps = data[section];
+    if (!deps || typeof deps !== "object") continue;
+    for (const [k, v] of Object.entries(deps)) {
+      if (pep503(k) === target && v && typeof v.version === "string") {
+        return v.version.replace(/^==/, "");
+      }
+    }
+  }
+  return void 0;
+}
+function packageLockVersion(root, name) {
+  let data;
+  try {
+    data = JSON.parse(fs3.readFileSync(path3.join(root, "package-lock.json"), "utf8"));
+  } catch {
+    return void 0;
+  }
+  const top = data.packages?.[`node_modules/${name}`]?.version;
+  if (typeof top === "string") return top;
+  const v1 = data.dependencies?.[name]?.version;
+  return typeof v1 === "string" ? v1 : void 0;
+}
+function yarnLockVersion(root, name) {
+  let text;
+  try {
+    text = fs3.readFileSync(path3.join(root, "yarn.lock"), "utf8");
+  } catch {
+    return void 0;
+  }
+  let inBlock = false;
+  for (const line of text.split("\n")) {
+    if (line && !/^\s/.test(line) && !line.startsWith("#")) {
+      inBlock = headerNamesPackage(line, name);
+    } else if (inBlock) {
+      const m = /^\s+version:?\s+"?([^"\s]+)"?/.exec(line);
+      if (m) return m[1];
+    }
+  }
+  return void 0;
+}
+function headerNamesPackage(header, name) {
+  return header.replace(/:\s*$/, "").split(",").some((spec) => {
+    const s = spec.trim().replace(/^"|"$/g, "");
+    const at = s.lastIndexOf("@");
+    if (at <= 0) return false;
+    const specName = s.slice(0, at);
+    return specName === name;
+  });
+}
+
+// src/engine/lib.ts
+var LIB_SCHEMA = "vg-lib/1.0";
+function catalogPath(root) {
+  return path3.join(root, "vibgrate.lib.json");
+}
+function libDir(root) {
+  return path3.join(root, ".vibgrate", "lib");
+}
+function libId(name) {
+  return name.trim().toLowerCase().replace(/^@/, "").replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+}
+function loadCatalog(root) {
+  const file = catalogPath(root);
+  if (fs3.existsSync(file)) {
+    try {
+      const data = JSON.parse(fs3.readFileSync(file, "utf8"));
+      if (data.schemaVersion === LIB_SCHEMA && data.libraries) return data;
+    } catch {
+    }
+  }
+  return { schemaVersion: LIB_SCHEMA, libraries: {} };
+}
+function saveCatalog(root, catalog) {
+  fs3.writeFileSync(catalogPath(root), `${stableStringify(catalog, 2)}
+`);
+}
+function resolveLib(catalog, name) {
+  const id = libId(name);
+  if (catalog.libraries[id]) return catalog.libraries[id];
+  const lower = name.toLowerCase();
+  const all = Object.values(catalog.libraries);
+  return all.find((e) => e.name.toLowerCase() === lower) ?? all.find((e) => e.id.includes(id) || e.name.toLowerCase().includes(lower));
+}
+function installedVersion(root, name) {
+  const rec = inventory(root).records.find((r) => r.name === name);
+  return rec?.installed ?? rec?.declared;
+}
+var stripRange = (v) => v?.replace(/^[v^~>=<\s]+/, "");
+function resolveVersion(root, name) {
+  const rec = inventory(root).records.find((r) => r.name === name);
+  const declared = rec?.declared;
+  const installed = rec?.installed ?? (rec ? installedTreeVersion(root, rec.ecosystem, name) : void 0);
+  const lockfile = rec ? lockfileVersion(root, rec.ecosystem, name) : void 0;
+  let mismatch;
+  if (lockfile && installed && stripRange(lockfile) !== stripRange(installed)) {
+    mismatch = {
+      lockfile,
+      installed,
+      note: `lockfile pins ${lockfile} but the installed tree has ${installed} \u2014 your install is out of sync with the lockfile (re-install or commit the lock)`
+    };
+  }
+  const served = lockfile ?? installed ?? declared;
+  const source = lockfile ? "lockfile" : installed ? "installed" : declared ? "declared" : "unknown";
+  return { served, source, lockfile, installed, declared, mismatch };
+}
+function driftFor(root, entry) {
+  const installed = installedVersion(root, entry.name);
+  if (!installed || entry.version === "*") return { cataloged: entry.version, installed, drift: "unknown" };
+  const norm = (v) => v.replace(/^[v^~>=<\s]+/, "");
+  const a = norm(entry.version);
+  const b = norm(installed);
+  if (a === b) return { cataloged: entry.version, installed, drift: "current" };
+  return { cataloged: entry.version, installed, drift: cmp(a, b) < 0 ? "behind" : "ahead" };
+}
+function cmp(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const d = (pa[i] || 0) - (pb[i] || 0);
+    if (d) return d;
+  }
+  return 0;
+}
+function parseGitSource(source) {
+  if (source.startsWith("git+")) return source.slice(4);
+  if (/^git@[^:]+:/.test(source)) return source;
+  if (/\.git\/?$/.test(source)) return source;
+  return null;
+}
+async function addLibrary(source, opts) {
+  const { root } = opts;
+  let content;
+  let type = "local";
+  const gitUrl = parseGitSource(source);
+  if (gitUrl) {
+    if (!opts.allowNetwork) {
+      throw new Error(`refusing to clone ${source} without --online (offline by default)`);
+    }
+    content = cloneAndReadGit(gitUrl);
+    type = "git";
+  } else if (/^https?:\/\//.test(source)) {
+    if (!opts.allowNetwork) {
+      throw new Error(`refusing to fetch ${source} without --online (offline by default)`);
+    }
+    const res = await (opts.fetchImpl ?? globalThis.fetch)(source);
+    if (!res.ok) throw new Error(`fetch failed (${res.status}) for ${source}`);
+    content = await res.text();
+    type = source.endsWith("llms.txt") ? "llms.txt" : source.endsWith(".json") ? "openapi" : "website";
+  } else {
+    const abs = path3.resolve(root, source);
+    if (!fs3.existsSync(abs)) throw new Error(`source not found: ${source}`);
+    content = readLocal(abs);
+    type = "local";
+  }
+  const name = opts.name ?? inferName(source);
+  const id = libId(name);
+  const version = opts.version ?? installedVersion(root, name) ?? "*";
+  fs3.mkdirSync(libDir(root), { recursive: true });
+  const docFileAbs = path3.join(libDir(root), `${id}.md`);
+  fs3.writeFileSync(docFileAbs, content);
+  const entry = {
+    id,
+    name,
+    version,
+    source: { type, location: source },
+    docFile: path3.relative(root, docFileAbs).split(path3.sep).join("/"),
+    docHash: hashString(content),
+    bytes: Buffer.byteLength(content, "utf8")
+  };
+  const catalog = loadCatalog(root);
+  catalog.libraries[id] = entry;
+  saveCatalog(root, catalog);
+  return entry;
+}
+function readDoc(root, entry) {
+  const abs = path3.resolve(root, entry.docFile);
+  return fs3.existsSync(abs) ? fs3.readFileSync(abs, "utf8") : "";
+}
+function npmPackageDir(root, name) {
+  let cur = root;
+  for (let i = 0; i < 12; i++) {
+    const dir = path3.join(cur, "node_modules", name);
+    if (fs3.existsSync(path3.join(dir, "package.json"))) return dir;
+    const parent = path3.dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  return void 0;
+}
+var README_CANDIDATES = ["llms.txt", "README.md", "README.mdx", "README", "readme.md"];
+function packageDocsMarkdown(dir, query) {
+  const docsDir = path3.join(dir, "docs");
+  if (!fs3.existsSync(docsDir) || !fs3.statSync(docsDir).isDirectory()) return void 0;
+  const files = [];
+  const walk = (d, depth) => {
+    if (depth > 3 || files.length >= 40) return;
+    let entries;
+    try {
+      entries = fs3.readdirSync(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const e of entries) {
+      if (files.length >= 40) return;
+      const full = path3.join(d, e.name);
+      if (e.isDirectory()) {
+        if (e.name.startsWith(".") || e.name === "node_modules") continue;
+        walk(full, depth + 1);
+      } else if (e.isFile() && /\.(md|mdx)$/i.test(e.name)) {
+        files.push(full);
+      }
+    }
+  };
+  walk(docsDir, 0);
+  if (!files.length) return void 0;
+  const terms = (query ?? "").toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length > 2);
+  const scored = files.map((f) => {
+    let body = "";
+    try {
+      body = fs3.readFileSync(f, "utf8");
+    } catch {
+      return { f, body: "", score: -1 };
+    }
+    const lc = `${path3.basename(f)}
+${body}`.toLowerCase();
+    const score = terms.length ? terms.filter((t) => lc.includes(t)).length : 1;
+    return { f, body, score };
+  });
+  const picked = (terms.length ? scored.filter((s) => s.score > 0).sort((a, b) => b.score - a.score || a.f.localeCompare(b.f)) : scored).filter((s) => s.body.trim()).slice(0, terms.length ? 8 : 5);
+  if (!picked.length) return void 0;
+  const text = picked.map((s) => `<!-- ${path3.relative(dir, s.f).split(path3.sep).join("/")} -->
+${s.body.trim()}`).join("\n\n");
+  return {
+    text,
+    files: picked.map((s) => path3.relative(dir, s.f).split(path3.sep).join("/"))
+  };
+}
+function localPackageDocs(root, name, opts) {
+  const dir = npmPackageDir(root, name);
+  if (!dir) return void 0;
+  const version = resolveVersion(root, name).served;
+  let primary;
+  for (const f of README_CANDIDATES) {
+    const p = path3.join(dir, f);
+    try {
+      const docs = fs3.readFileSync(p, "utf8");
+      if (docs.trim()) {
+        primary = { docs, source: path3.relative(root, p).split(path3.sep).join("/") };
+        break;
+      }
+    } catch {
+    }
+  }
+  const extra = packageDocsMarkdown(dir, opts?.query);
+  if (primary && extra) {
+    return {
+      docs: `${primary.docs.trim()}
+
+## Package docs
+
+${extra.text}`,
+      version,
+      source: `${primary.source}+docs/`,
+      readmeOnly: false
+    };
+  }
+  if (primary) {
+    return { ...primary, version, readmeOnly: true };
+  }
+  if (extra) {
+    return {
+      docs: extra.text,
+      version,
+      source: path3.relative(root, path3.join(dir, "docs")).split(path3.sep).join("/") + "/",
+      readmeOnly: false
+    };
+  }
+  try {
+    const pkg = JSON.parse(fs3.readFileSync(path3.join(dir, "package.json"), "utf8"));
+    if (pkg.description?.trim()) {
+      return {
+        docs: `# ${name}
+
+${pkg.description}`,
+        version: version ?? pkg.version,
+        source: path3.relative(root, path3.join(dir, "package.json")).split(path3.sep).join("/"),
+        readmeOnly: true
+      };
+    }
+  } catch {
+  }
+  return void 0;
+}
+function typesFromPkg(dir, pkg) {
+  const tryRel = (rel) => {
+    if (typeof rel !== "string") return void 0;
+    const p = path3.join(dir, rel);
+    return fs3.existsSync(p) ? p : void 0;
+  };
+  const top = tryRel(pkg.types) ?? tryRel(pkg.typings);
+  if (top) return top;
+  const exp = pkg.exports;
+  if (!exp || typeof exp !== "object") return void 0;
+  const roots = [];
+  if ("." in exp) roots.push(exp["."]);
+  else roots.push(...Object.values(exp));
+  for (const entry of roots) {
+    if (typeof entry === "string") {
+      const hit = tryRel(entry.endsWith(".d.ts") ? entry : void 0);
+      if (hit) return hit;
+      continue;
+    }
+    if (entry && typeof entry === "object") {
+      const o = entry;
+      for (const key of ["types", "typings", "import", "require", "default"]) {
+        const v = o[key];
+        if (typeof v === "string") {
+          const hit = tryRel(v.endsWith(".ts") || v.endsWith(".d.ts") || v.endsWith(".mts") || v.endsWith(".cts") ? v : void 0);
+          if (hit) return hit;
+        } else if (v && typeof v === "object" && typeof v.types === "string") {
+          const hit = tryRel(v.types);
+          if (hit) return hit;
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function dtsEntry(dir) {
+  try {
+    const pkg = JSON.parse(fs3.readFileSync(path3.join(dir, "package.json"), "utf8"));
+    const fromPkg = typesFromPkg(dir, pkg);
+    if (fromPkg) return fromPkg;
+  } catch {
+  }
+  for (const c of [
+    "index.d.ts",
+    "dist/index.d.ts",
+    "dist/types/index.d.ts",
+    "lib/index.d.ts",
+    "types/index.d.ts",
+    "build/index.d.ts"
+  ]) {
+    const p = path3.join(dir, c);
+    if (fs3.existsSync(p)) return p;
+  }
+  return void 0;
+}
+var MAX_DTS_FILES = 30;
+var MAX_DTS_BYTES = 512e3;
+function collectDtsFiles(dir) {
+  const out = [];
+  const walk = (d, depth) => {
+    if (depth > 4 || out.length >= MAX_DTS_FILES) return;
+    let entries;
+    try {
+      entries = fs3.readdirSync(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const e of entries) {
+      if (out.length >= MAX_DTS_FILES) return;
+      if (e.name === "node_modules" || e.name.startsWith(".")) continue;
+      const full = path3.join(d, e.name);
+      if (e.isDirectory()) walk(full, depth + 1);
+      else if (e.isFile() && /\.d\.(ts|mts|cts)$/.test(e.name)) out.push(full);
+    }
+  };
+  walk(dir, 0);
+  return out;
+}
+function extractDtsApi(src, maxDecls = 200) {
+  const out = [];
+  let depth = 0;
+  let capture = null;
+  for (const raw of src.split("\n")) {
+    const line = raw.trim();
+    if (capture === null && depth === 0 && /^export\s+\{[^}]+\}/.test(line)) {
+      out.push(raw.trim());
+      if (out.length >= maxDecls) break;
+      continue;
+    }
+    if (capture === null && depth === 0 && /^export\b/.test(line) && !/^export\s+(\{|\*|default\b|type\s+\{)/.test(line)) {
+      capture = [];
+    }
+    if (capture) capture.push(raw);
+    for (const ch of raw) {
+      if (ch === "{") depth++;
+      else if (ch === "}") depth = Math.max(0, depth - 1);
+    }
+    if (capture && depth === 0 && /[;}]\s*$/.test(line)) {
+      out.push(capture.join("\n").trim());
+      capture = null;
+      if (out.length >= maxDecls) break;
+    }
+  }
+  return out;
+}
+function reExportNames(decl) {
+  const m = /^export\s*\{([^}]+)\}/.exec(decl.trim());
+  if (!m) return [];
+  const names = [];
+  for (const part of m[1].split(",")) {
+    const n = part.trim().split(/\s+as\s+/i).pop()?.trim();
+    if (n && /^[A-Za-z_$][\w$]*$/.test(n)) names.push(n);
+  }
+  return names;
+}
+function localApiSurface(root, name, query) {
+  const dir = npmPackageDir(root, name);
+  if (!dir) return void 0;
+  const entry = dtsEntry(dir);
+  const files = entry ? [entry, ...collectDtsFiles(dir).filter((f) => f !== entry)] : collectDtsFiles(dir);
+  if (!files.length) return void 0;
+  const allDecls = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const f of files) {
+    let src;
+    try {
+      const st = fs3.statSync(f);
+      if (st.size > MAX_DTS_BYTES) continue;
+      src = fs3.readFileSync(f, "utf8");
+    } catch {
+      continue;
+    }
+    for (const d of extractDtsApi(src)) {
+      if (seen.has(d)) continue;
+      seen.add(d);
+      allDecls.push(d);
+      if (allDecls.length >= 400) break;
+    }
+    if (allDecls.length >= 400) break;
+  }
+  if (!allDecls.length) return void 0;
+  const terms = (query ?? "").split(/[^A-Za-z0-9_$]+/).filter((w) => w.length > 2);
+  if (terms.length) {
+    const lcTerms = terms.map((t) => t.toLowerCase());
+    const matched = allDecls.filter((d) => {
+      const lc = d.toLowerCase();
+      return lcTerms.some((t) => lc.includes(t));
+    });
+    const expanded = [];
+    const expandedSeen = /* @__PURE__ */ new Set();
+    for (const d of matched) {
+      const names = reExportNames(d);
+      if (names.length) {
+        for (const n of names) {
+          const fuller = allDecls.find(
+            (x) => !/^export\s*\{/.test(x) && new RegExp(`\\b${n}\\b`).test(x)
+          );
+          const pick = fuller ?? d;
+          if (!expandedSeen.has(pick)) {
+            expandedSeen.add(pick);
+            expanded.push(pick);
+          }
+        }
+      } else if (!expandedSeen.has(d)) {
+        expandedSeen.add(d);
+        expanded.push(d);
+      }
+    }
+    if (expanded.length) return expanded.slice(0, 40).join("\n\n");
+  }
+  return allDecls.slice(0, 80).join("\n\n");
+}
+function cloneAndReadGit(url) {
+  const dir = fs3.mkdtempSync(path3.join(os.tmpdir(), "vg-lib-git-"));
+  try {
+    execFileSync("git", ["clone", "--depth", "1", "--quiet", url, dir], {
+      stdio: ["ignore", "ignore", "pipe"]
+    });
+  } catch (err) {
+    fs3.rmSync(dir, { recursive: true, force: true });
+    const detail = err instanceof Error && err.message ? `: ${err.message.split("\n")[0]}` : "";
+    throw new Error(`git clone failed for ${url}${detail}`);
+  }
+  try {
+    return readGitDocs(dir);
+  } finally {
+    fs3.rmSync(dir, { recursive: true, force: true });
+  }
+}
+function readGitDocs(dir) {
+  const docsDir = path3.join(dir, "docs");
+  if (fs3.existsSync(docsDir) && fs3.statSync(docsDir).isDirectory()) return readLocal(docsDir);
+  const readme = ["README.md", "README.mdx", "README.txt", "README.rst", "readme.md"].map((f) => path3.join(dir, f)).find((p) => fs3.existsSync(p));
+  if (readme) return fs3.readFileSync(readme, "utf8");
+  return readLocal(dir);
+}
+function readLocal(abs) {
+  const stat = fs3.statSync(abs);
+  if (stat.isFile()) return fs3.readFileSync(abs, "utf8");
+  const parts = [];
+  const files = fs3.readdirSync(abs, { withFileTypes: true }).filter((e) => e.isFile() && /\.(md|mdx|txt|rst)$/i.test(e.name)).map((e) => e.name).sort();
+  for (const f of files) parts.push(`<!-- ${f} -->
+${fs3.readFileSync(path3.join(abs, f), "utf8")}`);
+  return parts.join("\n\n");
+}
+function inferName(source) {
+  const cleaned = source.replace(/^git\+/, "").replace(/\.git\/?$/i, "");
+  const base = cleaned.replace(/\/+$/, "").split(/[/:]/).pop() ?? cleaned;
+  return base.replace(/\.(md|mdx|txt|rst|json)$/i, "").replace(/^llms$/, "docs");
+}
+var MAX_FILE_BYTES = 1e6;
+var PREVIEW_CHARS = 120;
+var NUL = "\0";
+var PARALLEL_MIN_BYTES = 64e6;
+var PARALLEL_MIN_FILES = 2e3;
+var ROW_CAP = 1e4;
+async function scanCandidates(root, files, needle, opts) {
+  const needleLower = needle.toLowerCase();
+  if (!needleLower || files.length === 0) return { hits: [], total: 0, truncated: false };
+  if (files.length < PARALLEL_MIN_FILES && !process.env.VG_PARALLEL_MIN_BYTES) {
+    return opts.collectAll ? scanInline(root, files, needleLower, ROW_CAP, false, void 0) : scanInline(root, files, needleLower, opts.budget, true, void 0);
+  }
+  const { over, sizes } = measure(root, files);
+  if (!over) {
+    return opts.collectAll ? scanInline(root, files, needleLower, ROW_CAP, false, sizes) : scanInline(root, files, needleLower, opts.budget, true, sizes);
+  }
+  const out = await scanParallel(root, files, needleLower);
+  if (!opts.collectAll && out.hits.length > opts.budget) {
+    out.hits.length = opts.budget;
+    out.truncated = true;
+  }
+  return out;
+}
+function parallelMinBytes() {
+  const v = Number(process.env.VG_PARALLEL_MIN_BYTES);
+  return Number.isFinite(v) && v >= 0 ? v : PARALLEL_MIN_BYTES;
+}
+function measure(root, files) {
+  const threshold = parallelMinBytes();
+  const sizes = /* @__PURE__ */ new Map();
+  let total = 0;
+  for (const rel of files) {
+    let size;
+    try {
+      size = fs3.statSync(path3.join(root, rel)).size;
+    } catch {
+      continue;
+    }
+    sizes.set(rel, size);
+    if (size <= MAX_FILE_BYTES) total += size;
+    if (total >= threshold) return { over: true, sizes };
+  }
+  return { over: false, sizes };
+}
+function matchLines(text, needleLower) {
+  const low = text.toLowerCase();
+  if (!low.includes(needleLower)) return [];
+  const lowLines = low.split("\n");
+  const rawLines = text.split("\n");
+  const hits = [];
+  for (let i = 0; i < lowLines.length; i++) {
+    if (lowLines[i].includes(needleLower)) hits.push({ line: i + 1, preview: rawLines[i].trim().slice(0, PREVIEW_CHARS) });
+  }
+  return hits;
+}
+function readCandidate(abs, knownSize) {
+  try {
+    const size = knownSize ?? fs3.statSync(abs).size;
+    if (size > MAX_FILE_BYTES) return null;
+    const text = fs3.readFileSync(abs, "utf8");
+    return text.includes(NUL) ? null : text;
+  } catch {
+    return null;
+  }
+}
+function scanInline(root, files, needleLower, cap, stopAtCap, sizes) {
+  const hits = [];
+  let total = 0;
+  let truncated = false;
+  for (const rel of files) {
+    const text = readCandidate(path3.join(root, rel), sizes?.get(rel));
+    if (text === null) continue;
+    for (const h of matchLines(text, needleLower)) {
+      total++;
+      if (hits.length < cap) hits.push({ file: rel, line: h.line, preview: h.preview });
+      else {
+        truncated = true;
+        if (stopAtCap) return { hits, total, truncated };
+      }
+    }
+  }
+  return { hits, total, truncated };
+}
+async function scanParallel(root, files, needleLower) {
+  const n = Math.min(files.length, Math.max(2, Math.min(8, os.cpus().length - 1)));
+  const shards = Array.from({ length: n }, () => []);
+  files.forEach((f, i) => shards[i % n].push(f));
+  let results;
+  try {
+    results = await Promise.all(shards.map((shard) => runWorker(root, shard, needleLower)));
+  } catch {
+    return scanInline(root, files, needleLower, ROW_CAP, false, void 0);
+  }
+  const hits = [];
+  let total = 0;
+  let truncated = false;
+  for (const r of results) {
+    total += r.total;
+    truncated = truncated || r.truncated;
+    for (const h of r.hits) hits.push(h);
+  }
+  hits.sort((a, b) => a.file < b.file ? -1 : a.file > b.file ? 1 : a.line - b.line);
+  if (hits.length > ROW_CAP) {
+    hits.length = ROW_CAP;
+    truncated = true;
+  }
+  return { hits, total, truncated };
+}
+var WORKER_SOURCE = [
+  "const { parentPort, workerData } = require('worker_threads');",
+  "const fs = require('fs');",
+  "const path = require('path');",
+  `const MAX = ${MAX_FILE_BYTES};`,
+  `const PREVIEW = ${PREVIEW_CHARS};`,
+  `const CAP = ${ROW_CAP};`,
+  "const NUL = String.fromCharCode(0);",
+  "const NL = String.fromCharCode(10);",
+  "const { root, files, needleLower } = workerData;",
+  "const hits = []; let total = 0, truncated = false;",
+  "for (const rel of files) {",
+  "  const abs = path.join(root, rel);",
+  "  let text;",
+  '  try { if (fs.statSync(abs).size > MAX) continue; text = fs.readFileSync(abs, "utf8"); } catch { continue; }',
+  "  if (text.includes(NUL)) continue;",
+  "  const low = text.toLowerCase();",
+  "  if (!low.includes(needleLower)) continue;",
+  "  const lowLines = low.split(NL); const rawLines = text.split(NL);",
+  "  for (let i = 0; i < lowLines.length; i++) {",
+  "    if (!lowLines[i].includes(needleLower)) continue;",
+  "    total++;",
+  "    if (hits.length < CAP) hits.push({ file: rel, line: i + 1, preview: rawLines[i].trim().slice(0, PREVIEW) });",
+  "    else truncated = true;",
+  "  }",
+  "}",
+  "parentPort.postMessage({ hits, total, truncated });"
+].join("\n");
+function runWorker(root, files, needleLower) {
+  return new Promise((resolve2, reject) => {
+    const w = new Worker(WORKER_SOURCE, { eval: true, workerData: { root, files, needleLower } });
+    let settled = false;
+    w.once("message", (m) => {
+      settled = true;
+      resolve2(m);
+    });
+    w.once("error", reject);
+    w.once("exit", (code) => {
+      if (!settled && code !== 0) reject(new Error(`literal-scan worker exited with code ${code}`));
+    });
+  });
+}
+
+// src/engine/search.ts
+var IGNORE_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".vibgrate",
+  "node_modules",
+  "dist",
+  "build",
+  "out",
+  "target",
+  "vendor",
+  "__pycache__",
+  // .NET intermediate output and coverage reports: purely generated trees that a
+  // C#/coverage-heavy repo pays for on every literal sweep. `bin` is deliberately
+  // NOT here — plenty of repos keep real scripts in bin/ (rails, node CLIs), and
+  // completeness beats speed; the binary-extension skip below keeps a .NET bin/
+  // cheap anyway.
+  "obj",
+  "coverage"
+]);
+var MAX_FILES_SCANNED = 2e4;
+var BINARY_EXTS = /* @__PURE__ */ new Set([
+  ".dll",
+  ".pdb",
+  ".exe",
+  ".so",
+  ".dylib",
+  ".a",
+  ".lib",
+  ".o",
+  ".class",
+  ".jar",
+  ".wasm",
+  ".node",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".ico",
+  ".icns",
+  ".bmp",
+  ".zip",
+  ".gz",
+  ".tgz",
+  ".bz2",
+  ".xz",
+  ".7z",
+  ".rar",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".mp3",
+  ".mp4",
+  ".mov",
+  ".avi",
+  ".pdf"
+]);
+function hasBinaryExt(rel) {
+  return BINARY_EXTS.has(path3.extname(rel).toLowerCase());
+}
+function toPosix(rel) {
+  return path3.sep === "\\" ? rel.replaceAll("\\", "/") : rel;
+}
+async function searchSymbols(graph, root, query, limit) {
+  let q = query.trim();
+  if (!q) return { matches: [], moreAvailable: false, hint: "query is required" };
+  const quoted = /^(["'`])(.+)\1$/.exec(q);
+  if (quoted && quoted[2].trim()) q = quoted[2].trim();
+  const embeddedNeedles = extractLiteralNeedles(q);
+  const scanNeedle = embeddedNeedles.length === 0 ? q : embeddedNeedles.length === 1 && embeddedNeedles[0] === q ? q : [...embeddedNeedles].sort((a, b) => b.length - a.length)[0];
+  const symbolQuery = embeddedNeedles.length > 0 ? residualForSymbolSearch(q) : q;
+  const isUrl = /^https?:\/\//i.test(scanNeedle) || embeddedNeedles.some((n) => /^https?:\/\//i.test(n));
+  const isPhrase = Boolean(quoted) || isUrl || embeddedNeedles.length > 0 || /\s/.test(q) || /[/\\]/.test(q) && !q.includes(":") && !/[*?]/.test(q);
+  let nodes = [];
+  if (symbolQuery.trim()) {
+    nodes = findNodes(graph, symbolQuery).filter((n) => n.kind !== "file");
+    if (nodes.length === 0) {
+      nodes = fileSymbolNodes(graph, symbolQuery);
+    }
+    if (nodes.length === 0 && isPhrase) {
+      nodes = reconstructedIdentifierNodes(graph, symbolQuery);
+    }
+    if (nodes.length === 0) {
+      const tokens = queryTokens(symbolQuery);
+      if (tokens.length >= 2) nodes = multiTokenNodes(graph, tokens);
+    }
+  }
+  const symbolCap = isPhrase ? Math.max(1, Math.floor(limit / 3)) : limit;
+  const symbolHits = nodes.slice(0, symbolCap).map((n, i) => ({
+    kind: n.kind,
+    name: n.qualifiedName,
+    file: n.file,
+    line: n.span.start,
+    score: Math.round((1 - i / Math.max(nodes.length, 1)) * 100) / 100
+  }));
+  const spare = limit - symbolHits.length;
+  const textHits = [];
+  let truncatedScan = false;
+  let totalTextMatches;
+  const skipScan = !isPhrase && hasExactSymbolMatch(nodes, symbolQuery || q);
+  if (spare > 0 && !skipScan) {
+    const seen = new Set(symbolHits.map((h) => `${h.file}:${h.line}`));
+    const scan = await scanFiles(root, scanNeedle, spare, seen, textHits, isPhrase);
+    truncatedScan = scan.truncated;
+    if (isPhrase) totalTextMatches = scan.total;
+  }
+  const matches = isPhrase ? [...textHits, ...symbolHits] : [...symbolHits, ...textHits];
+  if (matches.length === 0) {
+    const empty = {
+      matches,
+      moreAvailable: false,
+      hint: "no symbol or text match \u2014 for meaning-level questions (symptoms, relationships, what-breaks-if) use query_graph"
+    };
+    if (totalTextMatches !== void 0) empty.totalTextMatches = totalTextMatches;
+    return empty;
+  }
+  const literalTruncated = totalTextMatches !== void 0 && totalTextMatches > textHits.length;
+  const moreAvailable = isPhrase ? literalTruncated || truncatedScan : nodes.length > symbolHits.length || truncatedScan;
+  const result = { matches, moreAvailable };
+  if (totalTextMatches !== void 0) result.totalTextMatches = totalTextMatches;
+  if (literalTruncated) {
+    result.hint = `showing ${textHits.length} of ${totalTextMatches}${truncatedScan ? "+" : ""} literal matches \u2014 raise limit or narrow the query to get them all`;
+  }
+  return result;
+}
+function fileSymbolNodes(graph, q) {
+  if (!/[/\\]/.test(q) && !/\.\w+$/.test(q)) return [];
+  const norm = q.replaceAll("\\", "/").replace(/^\.\//, "");
+  const inFile = graph.nodes.filter(
+    (n) => n.kind !== "file" && (n.file === norm || n.file.endsWith(`/${norm}`))
+  );
+  return [...inFile].sort((a, b) => b.importance - a.importance || a.qualifiedName.localeCompare(b.qualifiedName));
+}
+function hasExactSymbolMatch(nodes, q) {
+  if (nodes.length === 0) return false;
+  if (/^(.*):(\d+)$/.test(q)) return true;
+  const lower = q.toLowerCase();
+  return nodes.some((n) => n.id === q || n.qualifiedName.toLowerCase() === lower || n.name.toLowerCase() === lower);
+}
+function queryTokens(q) {
+  return [...new Set(q.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length >= 2))];
+}
+function reconstructedIdentifierNodes(graph, q) {
+  const words = q.trim().split(/\s+/).filter(Boolean);
+  if (words.length < 2) return [];
+  const concat = findNodes(graph, words.join(""));
+  if (concat.length) return concat.filter((n) => n.kind !== "file");
+  const snake = findNodes(graph, words.join("_"));
+  return snake.filter((n) => n.kind !== "file");
+}
+function multiTokenNodes(graph, tokens) {
+  const scored = [];
+  for (const n of graph.nodes) {
+    if (n.kind === "file") continue;
+    const name = n.name.toLowerCase();
+    const qn = n.qualifiedName.toLowerCase();
+    let hits = 0;
+    let exact = false;
+    for (const t of tokens) {
+      if (name === t || qn === t) {
+        hits++;
+        exact = true;
+      } else if (qn.includes(t)) hits++;
+    }
+    if (exact || hits >= 2) scored.push({ node: n, hits, exact });
+  }
+  return scored.sort((a, b) => Number(b.exact) - Number(a.exact) || b.hits - a.hits || b.node.importance - a.node.importance || a.node.qualifiedName.localeCompare(b.node.qualifiedName)).map((e) => e.node);
+}
+async function scanFiles(root, needle, budget, seen, out, countAll) {
+  const listing = listCandidateFiles(root, needle);
+  const outcome = await scanCandidates(root, listing.files, needle, { collectAll: countAll, budget });
+  let overlap = 0;
+  for (const h of outcome.hits) {
+    if (seen.has(`${h.file}:${h.line}`)) {
+      overlap++;
+      continue;
+    }
+    seen.add(`${h.file}:${h.line}`);
+    if (out.length < budget) out.push({ kind: "text", file: h.file, line: h.line, preview: h.preview });
+  }
+  return { total: outcome.total - overlap, truncated: listing.truncated || outcome.truncated };
+}
+function listCandidateFiles(root, needle) {
+  return ripgrepCandidates(root, needle) ?? walkCandidatesCached(root);
+}
+var LISTING_TTL_MS = 2e3;
+var listingCache = /* @__PURE__ */ new Map();
+function listingTtlMs() {
+  const v = Number(process.env.VG_LISTING_TTL_MS);
+  return Number.isFinite(v) && v >= 0 ? v : LISTING_TTL_MS;
+}
+function walkCandidatesCached(root) {
+  const ttl = listingTtlMs();
+  if (ttl > 0) {
+    const hit = listingCache.get(root);
+    if (hit && Date.now() - hit.at < ttl) return hit.listing;
+  }
+  const listing = walkCandidates(root);
+  if (ttl > 0) listingCache.set(root, { listing, at: Date.now() });
+  return listing;
+}
+function walkCandidates(root) {
+  const files = [];
+  let truncated = false;
+  const stack = [root];
+  while (stack.length) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = fs3.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      if (e.name.startsWith(".") || IGNORE_DIRS.has(e.name)) continue;
+      const abs = path3.join(dir, e.name);
+      if (e.isDirectory()) {
+        stack.push(abs);
+        continue;
+      }
+      if (hasBinaryExt(e.name)) continue;
+      if (files.length >= MAX_FILES_SCANNED) {
+        truncated = true;
+        continue;
+      }
+      files.push(toPosix(path3.relative(root, abs)));
+    }
+  }
+  files.sort();
+  return { files, truncated };
+}
+var rgAvailable;
+function hasRipgrep() {
+  if (process.env.VG_DISABLE_RIPGREP) return false;
+  if (rgAvailable === void 0) {
+    try {
+      rgAvailable = spawnSync("rg", ["--version"], { stdio: "ignore", timeout: 3e3 }).status === 0;
+    } catch {
+      rgAvailable = false;
+    }
+  }
+  return rgAvailable;
+}
+function ripgrepCandidates(root, needle) {
+  if (!hasRipgrep()) return null;
+  const globs = [...IGNORE_DIRS].flatMap((d) => ["--glob", `!**/${d}/**`, "--glob", `!${d}/**`]);
+  const res = spawnSync(
+    "rg",
+    ["--files-with-matches", "--fixed-strings", "--ignore-case", "--no-ignore", "--no-messages", ...globs, "--", needle, "."],
+    { cwd: root, encoding: "utf8", timeout: 15e3, maxBuffer: 32 * 1024 * 1024 }
+  );
+  if (res.error || res.status !== 0 && res.status !== 1 || res.signal) return null;
+  const files = parseRgFileList(res.stdout);
+  if (files.length > MAX_FILES_SCANNED) return { files: files.slice(0, MAX_FILES_SCANNED), truncated: true };
+  return { files, truncated: false };
+}
+function parseRgFileList(stdout, sep3 = path3.sep) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of stdout.split("\n")) {
+    if (!raw) continue;
+    const posix = sep3 === "\\" ? raw.replaceAll("\\", "/") : raw;
+    const rel = posix.startsWith("./") ? posix.slice(2) : posix;
+    if (!rel) continue;
+    const segs = rel.split("/");
+    if (segs.some((s) => s.startsWith(".") || IGNORE_DIRS.has(s))) continue;
+    if (hasBinaryExt(rel)) continue;
+    seen.add(rel);
+  }
+  return [...seen].sort();
+}
+
+export { ECOSYSTEMS, addLibrary, catalogPath, driftFor, enrichOnline, inventory, libDir, libId, loadCatalog, localApiSurface, localPackageDocs, readDoc, resolveLib, resolveVersion, saveCatalog, searchSymbols };
+//# sourceMappingURL=chunk-G4HTI4ZM.js.map
+//# sourceMappingURL=chunk-G4HTI4ZM.js.map