scriptonia 0.8.0 → 0.9.0-rc.2

package/dist/chunk-6TLQP3LV.js

@@ -0,0 +1,4048 @@
+#!/usr/bin/env node
+
+// ../packages/core/src/index.ts
+import { createHash, randomBytes } from "crypto";
+import path from "path";
+function canonicalize(value) {
+  return JSON.stringify(normalize(value));
+}
+function normalize(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return typeof value === "string" ? value.replace(/\r\n?/g, "\n") : value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new TypeError("canonical JSON rejects non-finite numbers");
+    return value;
+  }
+  if (Array.isArray(value)) return value.map(normalize);
+  if (typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, normalize(item)]));
+  }
+  throw new TypeError(`canonical JSON rejects ${typeof value}`);
+}
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function hashObject(value) {
+  return sha256(canonicalize(value));
+}
+function createId(prefix, at = Date.now()) {
+  return `${prefix}_${at.toString(36).padStart(9, "0")}${randomBytes(8).toString("hex")}`;
+}
+function normalizeRepoPath(input) {
+  if (input.includes("\0")) throw new Error("repository path contains a null byte");
+  const normalized = input.replaceAll("\\", "/").replace(/^\.\//, "");
+  if (path.posix.isAbsolute(normalized) || normalized === ".." || normalized.startsWith("../") || normalized.includes("/../")) {
+    throw new Error(`path escapes repository: ${input}`);
+  }
+  return path.posix.normalize(normalized);
+}
+function assertInside(root, candidate) {
+  const resolvedRoot = path.resolve(root);
+  const resolved = path.resolve(candidate);
+  if (resolved !== resolvedRoot && !resolved.startsWith(`${resolvedRoot}${path.sep}`)) throw new Error(`path escapes repository: ${candidate}`);
+  return resolved;
+}
+function aggregateGate(checks, incompleteBlocks = true) {
+  if (checks.some((item) => item.state === "FAIL" && item.enforcement === "block")) return "BLOCKED";
+  if (checks.some((item) => item.state === "FAIL" && item.enforcement === "action_required")) return "ACTION_REQUIRED";
+  if (checks.some((item) => item.state === "ERROR" || incompleteBlocks && item.state === "INCONCLUSIVE" && item.enforcement === "block")) return "INCOMPLETE";
+  if (checks.some((item) => item.state === "FAIL" || item.state === "INCONCLUSIVE")) return "PASS_WITH_WARNINGS";
+  return "PASS";
+}
+function exitCodeForGate(state) {
+  return state === "PASS" || state === "PASS_WITH_WARNINGS" ? 0 : state === "ACTION_REQUIRED" ? 2 : state === "BLOCKED" ? 3 : 4;
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+
+// ../packages/brain-census/src/walk.ts
+import fs from "fs";
+import path3 from "path";
+import { createHash as createHash2 } from "crypto";
+import { execFileSync } from "child_process";
+import ignore from "ignore";
+
+// ../packages/brain-census/src/languages.ts
+import path2 from "path";
+var EXTENSIONS = /* @__PURE__ */ new Map([
+  [".c", "c"],
+  [".h", "cpp"],
+  [".cc", "cpp"],
+  [".cp", "cpp"],
+  [".cpp", "cpp"],
+  [".cxx", "cpp"],
+  [".hh", "cpp"],
+  [".hpp", "cpp"],
+  [".hxx", "cpp"],
+  [".inc", "cpp"],
+  [".m", "objective-c"],
+  [".mm", "objective-c"],
+  [".cs", "csharp"],
+  [".css", "css"],
+  [".scss", "css"],
+  [".sass", "css"],
+  [".less", "css"],
+  [".dart", "dart"],
+  [".ex", "elixir"],
+  [".exs", "elixir"],
+  [".go", "go"],
+  [".graphql", "graphql"],
+  [".gql", "graphql"],
+  [".html", "html"],
+  [".htm", "html"],
+  [".java", "java"],
+  [".js", "javascript"],
+  [".jsx", "javascript"],
+  [".mjs", "javascript"],
+  [".cjs", "javascript"],
+  [".json", "json"],
+  [".jsonc", "json"],
+  [".kt", "kotlin"],
+  [".kts", "kotlin"],
+  [".lua", "lua"],
+  [".pl", "perl"],
+  [".pm", "perl"],
+  [".php", "php"],
+  [".proto", "proto"],
+  [".py", "python"],
+  [".pyi", "python"],
+  [".rb", "ruby"],
+  [".rs", "rust"],
+  [".scala", "scala"],
+  [".sh", "shell"],
+  [".bash", "shell"],
+  [".zsh", "shell"],
+  [".fish", "shell"],
+  [".sql", "sql"],
+  [".bzl", "starlark"],
+  [".bazel", "starlark"],
+  [".star", "starlark"],
+  [".swift", "swift"],
+  [".toml", "toml"],
+  [".ts", "typescript"],
+  [".tsx", "typescript"],
+  [".mts", "typescript"],
+  [".cts", "typescript"],
+  [".vue", "vue"],
+  [".xml", "xml"],
+  [".plist", "xml"],
+  [".yaml", "yaml"],
+  [".yml", "yaml"]
+]);
+var STARLARK_BASENAMES = /* @__PURE__ */ new Set(["BUILD", "WORKSPACE", "WORKSPACE.bzlmod", "MODULE.bazel"]);
+var CONFIG_BASENAMES = /* @__PURE__ */ new Set([
+  ".bazelignore",
+  ".bazelrc",
+  ".bazelversion",
+  ".clang-format",
+  ".clang-tidy",
+  ".dockerignore",
+  ".editorconfig",
+  ".env.example",
+  ".flake8",
+  ".gitignore",
+  ".npmrc",
+  ".nvmrc",
+  ".prettierrc",
+  ".yamllint",
+  "CMakeLists.txt",
+  "CODEOWNERS",
+  "Cargo.toml",
+  "Dockerfile",
+  "Gemfile",
+  "Gemfile.lock",
+  "Makefile",
+  "Podfile",
+  "analysis_options.yaml",
+  "build.gradle",
+  "build.gradle.kts",
+  "composer.json",
+  "composer.lock",
+  "deps.yaml",
+  "extensions_metadata.yaml",
+  "go.mod",
+  "go.sum",
+  "gradle.properties",
+  "MODULE.bazel.lock",
+  "package-lock.json",
+  "package.json",
+  "pnpm-lock.yaml",
+  "repository_locations.bzl",
+  "pnpm-workspace.yaml",
+  "pom.xml",
+  "pubspec.lock",
+  "pubspec.yaml",
+  "pyproject.toml",
+  "requirements.txt",
+  "settings.gradle",
+  "settings.gradle.kts",
+  "tsconfig.json",
+  "yarn.lock"
+]);
+var ASSET_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".7z",
+  ".a",
+  ".avi",
+  ".bin",
+  ".bmp",
+  ".cer",
+  ".class",
+  ".crt",
+  ".der",
+  ".dylib",
+  ".eot",
+  ".exe",
+  ".fuzz",
+  ".gif",
+  ".gold",
+  ".gz",
+  ".ico",
+  ".jar",
+  ".jpeg",
+  ".jpg",
+  ".key",
+  ".lockb",
+  ".mmdb",
+  ".mov",
+  ".mp3",
+  ".mp4",
+  ".o",
+  ".otf",
+  ".p12",
+  ".pdf",
+  ".pem",
+  ".pfx",
+  ".png",
+  ".so",
+  ".tar",
+  ".tgz",
+  ".ttf",
+  ".wav",
+  ".webm",
+  ".webp",
+  ".woff",
+  ".woff2",
+  ".xz",
+  ".zip"
+]);
+var CERTIFICATE_EXTENSIONS = /* @__PURE__ */ new Set([".cer", ".crt", ".der", ".key", ".p12", ".pem", ".pfx"]);
+var CORPUS_EXTENSIONS = /* @__PURE__ */ new Set([".fuzz", ".gold"]);
+function detectLanguage(filePath, sample = "") {
+  const base = path2.posix.basename(filePath);
+  if (STARLARK_BASENAMES.has(base) || base === "BUILD.bazel") return "starlark";
+  const extension = path2.posix.extname(base).toLowerCase();
+  const known = EXTENSIONS.get(extension);
+  if (known) return known;
+  const firstLine = sample.split(/\r?\n/, 1)[0] ?? "";
+  if (/^#!.*\bpython(?:3)?\b/.test(firstLine)) return "python";
+  if (/^#!.*\b(?:bash|sh|zsh|fish)\b/.test(firstLine)) return "shell";
+  if (/^#!.*\bnode\b/.test(firstLine)) return "javascript";
+  if (/^#!.*\bruby\b/.test(firstLine)) return "ruby";
+  return void 0;
+}
+function classifyFile(filePath, sample, binary) {
+  const normalized = filePath.replaceAll("\\", "/");
+  const lower = normalized.toLowerCase();
+  const base = path2.posix.basename(normalized);
+  const extension = path2.posix.extname(base).toLowerCase();
+  const language = detectLanguage(normalized, sample);
+  if (binary || ASSET_EXTENSIONS.has(extension)) return "asset";
+  if (isManifestConfigPath(normalized) || CONFIG_BASENAMES.has(base) || STARLARK_BASENAMES.has(base) || /\.(?:lock|config|conf|ini|properties)$/i.test(base)) return "config";
+  if (/(?:^|\/)(?:third_party|vendor|external)\//i.test(normalized)) return "vendor";
+  if (/(?:^|\/)generated(?:\/|$)/i.test(normalized) || /\.(?:g|freezed)\.dart$|\.pb\.go$|\.generated\.[^.]+$|\.min\.(?:js|css)$/i.test(base) || /generated|do not edit/i.test(sample.split(/\r?\n/).slice(0, 3).join("\n"))) return "generated";
+  if (/\.(?:md|mdx|rst|adoc|txt)$/i.test(extension) || /(?:^|\/)(?:docs?|adr|changelogs?)(?:\/|$)/i.test(normalized)) return "docs";
+  if (language && (/(?:^|\/)(?:test|tests|__tests__|spec|integration_test)(?:\/|$)/i.test(normalized) || /(?:_test\.dart|\.(?:test|spec)\.[cm]?[jt]sx?|test_[^/]+\.py)$/i.test(base))) return "test";
+  if (language) return "source";
+  if (lower.includes("/assets/") || lower.includes("/images/")) return "asset";
+  return "asset";
+}
+function analysisPolicy(filePath, fileClass, binary, oversized = false) {
+  const normalized = filePath.replaceAll("\\", "/");
+  const extension = path2.posix.extname(path2.posix.basename(normalized)).toLowerCase();
+  if (/(?:^|\/)(?:[^/]*_corpus|corpus)(?:\/|$)/i.test(normalized) || CORPUS_EXTENSIONS.has(extension)) {
+    return { analysisMode: "metadata_only", metadataOnlyReason: "corpus" };
+  }
+  if (CERTIFICATE_EXTENSIONS.has(extension)) {
+    return { analysisMode: "metadata_only", metadataOnlyReason: "certificate" };
+  }
+  if (fileClass === "generated" || /(?:^|\/)generated(?:\/|$)/i.test(normalized)) {
+    return { analysisMode: "metadata_only", metadataOnlyReason: "generated" };
+  }
+  if (fileClass === "config") return { analysisMode: "full" };
+  if (oversized) return { analysisMode: "metadata_only", metadataOnlyReason: "oversized" };
+  if (binary || fileClass === "asset") return { analysisMode: "metadata_only", metadataOnlyReason: "binary_asset" };
+  return { analysisMode: "full" };
+}
+function isKnownManifest(filePath) {
+  const base = path2.posix.basename(filePath);
+  return CONFIG_BASENAMES.has(base) || STARLARK_BASENAMES.has(base) || isManifestConfigPath(filePath);
+}
+function isManifestConfigPath(filePath) {
+  const base = path2.posix.basename(filePath);
+  return /(?:^|\/)BUILD(?:\.bazel)?$/i.test(filePath) || /(?:^|\/)\.github\/workflows\/[^/]+\.ya?ml$/i.test(filePath) || /^(?:Dockerfile(?:\..+)?|requirements(?:[-_.][^/]*)?\.txt|tsconfig(?:\.[^/]+)?\.json)$/i.test(base) || /^(?:docker-)?compose(?:\.[^/]+)?\.ya?ml$/i.test(base);
+}
+
+// ../packages/brain-census/src/walk.ts
+var NEVER_DESCEND = /* @__PURE__ */ new Set([
+  ".git",
+  ".scriptonia",
+  ".dart_tool",
+  ".next",
+  ".turbo",
+  ".venv",
+  "__pycache__",
+  "DerivedData",
+  "Microsoft VS Code",
+  "Pods",
+  "bazel-bin",
+  "bazel-out",
+  "bazel-testlogs",
+  "node_modules"
+]);
+var BUILTIN_IGNORE = [
+  ".git/",
+  ".scriptonia/",
+  ".dart_tool/",
+  ".next/",
+  ".turbo/",
+  ".venv/",
+  "**/__pycache__/",
+  "**/node_modules/",
+  "**/DerivedData/",
+  "**/Microsoft VS Code/",
+  "**/Pods/",
+  "**/.cache/",
+  "**/build/",
+  "**/coverage/",
+  "**/dist/",
+  "bazel-bin/",
+  "bazel-out/",
+  "bazel-testlogs/"
+];
+var DEFAULT_MAX_ASSET_BYTES = 2 * 1024 * 1024;
+function walkRepo(inputRoot, options = {}) {
+  const started = performance.now();
+  const root = fs.realpathSync(inputRoot);
+  const matcher = ignore().add(BUILTIN_IGNORE).add(options.extraIgnore ?? []);
+  const forcedMatcher = ignore().add(options.extraIgnore ?? []);
+  const tracked = gitTrackedPaths(root);
+  const trackedDirectories = /* @__PURE__ */ new Set();
+  for (const filename of tracked) {
+    let directory = path3.posix.dirname(filename);
+    while (directory !== ".") {
+      trackedDirectories.add(directory);
+      directory = path3.posix.dirname(directory);
+    }
+  }
+  const files = [];
+  const warnings = [];
+  let ignored = 0;
+  const maxAssetBytes = options.maxAssetBytes ?? DEFAULT_MAX_ASSET_BYTES;
+  const maxFileBytes = options.maxFileBytes ?? 128 * 1024 * 1024;
+  const maxTextBytes = options.maxTextBytes ?? 8 * 1024 * 1024;
+  const visit = (absoluteDir, relativeDir) => {
+    loadIgnoreFile(matcher, absoluteDir, relativeDir, warnings);
+    let entries;
+    try {
+      entries = fs.readdirSync(absoluteDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    } catch (error) {
+      warnings.push({ path: relativeDir || ".", kind: "unreadable", message: errorMessage(error) });
+      return;
+    }
+    for (const entry of entries) {
+      const relativeRaw = relativeDir ? `${relativeDir}/${entry.name}` : entry.name;
+      let relative;
+      try {
+        relative = normalizeRepoPath(relativeRaw);
+      } catch (error) {
+        warnings.push({ path: relativeRaw, kind: "invalid_path", message: errorMessage(error) });
+        continue;
+      }
+      const absolute = path3.join(root, ...relative.split("/"));
+      try {
+        assertInside(root, absolute);
+      } catch (error) {
+        warnings.push({ path: relative, kind: "invalid_path", message: errorMessage(error) });
+        continue;
+      }
+      let stat;
+      try {
+        stat = fs.lstatSync(absolute);
+      } catch (error) {
+        warnings.push({ path: relative, kind: "unreadable", message: errorMessage(error) });
+        continue;
+      }
+      if (stat.isSymbolicLink()) {
+        warnings.push({ path: relative, kind: "symlink", message: "symbolic link recorded as metadata and never followed" });
+        try {
+          const target = fs.readlinkSync(absolute);
+          const language = detectLanguage(relative);
+          const fileClass = classifyFile(relative, "", false);
+          const file = {
+            path: relative,
+            ...language ? { language } : {},
+            class: fileClass,
+            analysisMode: "metadata_only",
+            metadataOnlyReason: "symlink",
+            size: Buffer.byteLength(target),
+            loc: 0,
+            sha256: createHash2("sha256").update("symlink\0").update(target).digest("hex"),
+            binary: false,
+            mtimeMs: stat.mtimeMs
+          };
+          files.push(file);
+          options.onFile?.(file);
+        } catch (error) {
+          warnings.push({ path: relative, kind: "unreadable", message: errorMessage(error) });
+        }
+        continue;
+      }
+      if (entry.isDirectory()) {
+        if (NEVER_DESCEND.has(entry.name) || forcedMatcher.ignores(`${relative}/`) || matcher.ignores(`${relative}/`) && !trackedDirectories.has(relative)) {
+          ignored++;
+          continue;
+        }
+        visit(absolute, relative);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (forcedMatcher.ignores(relative) || matcher.ignores(relative) && entry.name !== ".gitignore" && !tracked.has(relative)) {
+        ignored++;
+        continue;
+      }
+      const manifest = isKnownManifest(relative);
+      const aboveAssetLimit = stat.size > maxAssetBytes && !manifest;
+      const oversized = stat.size > maxFileBytes && !manifest;
+      if (oversized) {
+        warnings.push({ path: relative, kind: "oversized", message: `file exceeds ${maxFileBytes} byte census limit` });
+      }
+      try {
+        const inspectText = stat.size <= maxTextBytes || manifest;
+        const hashed = hashFile(absolute, inspectText);
+        const fileClass = classifyFile(relative, hashed.sample, hashed.binary);
+        if (aboveAssetLimit && fileClass === "asset") {
+          warnings.push({ path: relative, kind: "oversized", message: `asset or binary exceeds ${maxAssetBytes} byte full-analysis limit; retained as metadata` });
+        }
+        const file = {
+          path: relative,
+          language: detectLanguage(relative, hashed.sample),
+          class: fileClass,
+          ...analysisPolicy(relative, fileClass, hashed.binary, oversized || !inspectText || aboveAssetLimit && fileClass === "asset"),
+          size: stat.size,
+          loc: hashed.loc,
+          sha256: hashed.sha256,
+          binary: hashed.binary,
+          mtimeMs: stat.mtimeMs
+        };
+        files.push(file);
+        options.onFile?.(file);
+      } catch (error) {
+        warnings.push({ path: relative, kind: "unreadable", message: errorMessage(error) });
+      }
+    }
+  };
+  visit(root, "");
+  return { root, files, warnings, ignored, elapsedMs: performance.now() - started };
+}
+function gitTrackedPaths(root) {
+  try {
+    const output = execFileSync("git", ["-C", root, "ls-files", "--cached", "-z"], {
+      encoding: "utf8",
+      maxBuffer: 64 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return new Set(output.split("\0").filter(Boolean).map((filename) => normalizeRepoPath(filename)));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function hashFile(filename, inspectText) {
+  const hash = createHash2("sha256");
+  const fd = fs.openSync(filename, "r");
+  const buffer = Buffer.allocUnsafe(64 * 1024);
+  let position = 0;
+  let sample = Buffer.alloc(0);
+  let binary = false;
+  let lineFeeds = 0;
+  try {
+    while (true) {
+      const bytes = fs.readSync(fd, buffer, 0, buffer.length, position);
+      if (!bytes) break;
+      position += bytes;
+      const chunk = buffer.subarray(0, bytes);
+      hash.update(chunk);
+      if (sample.length < 8192) sample = Buffer.concat([sample, chunk.subarray(0, 8192 - sample.length)]);
+      if (!binary && chunk.includes(0)) binary = true;
+      if (inspectText && !binary) {
+        for (const byte of chunk) if (byte === 10) lineFeeds++;
+      }
+    }
+  } finally {
+    fs.closeSync(fd);
+  }
+  return {
+    sha256: hash.digest("hex"),
+    loc: binary || !inspectText || position === 0 ? 0 : lineFeeds + 1,
+    binary,
+    sample: binary ? "" : sample.toString("utf8")
+  };
+}
+function loadIgnoreFile(matcher, absoluteDir, relativeDir, warnings) {
+  const filename = path3.join(absoluteDir, ".gitignore");
+  if (!fs.existsSync(filename)) return;
+  try {
+    const lines = fs.readFileSync(filename, "utf8").split(/\r?\n/);
+    for (const line of lines) matcher.add(scopeIgnorePattern(line, relativeDir));
+  } catch (error) {
+    warnings.push({ path: relativeDir ? `${relativeDir}/.gitignore` : ".gitignore", kind: "unreadable", message: errorMessage(error) });
+  }
+}
+function scopeIgnorePattern(line, base) {
+  if (!base || !line || /^\s*#/.test(line)) return line;
+  const negated = line.startsWith("!");
+  const prefix = negated ? "!" : "";
+  const body = negated ? line.slice(1) : line;
+  if (!body) return line;
+  if (body.startsWith("/")) return `${prefix}${base}/${body.slice(1)}`;
+  if (body.includes("/")) return `${prefix}${base}/${body}`;
+  return [`${prefix}${base}/${body}`, `${prefix}${base}/**/${body}`];
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// ../packages/brain-census/src/manifests.ts
+import fs2 from "fs";
+import path4 from "path";
+import { XMLParser } from "fast-xml-parser";
+import YAML from "yaml";
+import { z } from "zod";
+var DEFAULT_MANIFEST_PARSE_LIMITS = Object.freeze({
+  maxManifestFiles: 2e4,
+  maxManifestBytes: 16 * 1024 * 1024,
+  maxTotalBytes: 256 * 1024 * 1024,
+  maxExtractedEntries: 1e5,
+  maxNestingDepth: 128,
+  maxYamlAliases: 100,
+  maxTsconfigExtendsDepth: 5,
+  maxLineBytes: 1024 * 1024
+});
+var manifestDependencySchema = z.object({
+  name: z.string().min(1),
+  declared: z.string().optional(),
+  resolved: z.string().optional(),
+  dev: z.boolean().default(false)
+});
+var manifestFrameworkSchema = z.object({
+  name: z.string().min(1),
+  version: z.string().optional(),
+  kind: z.enum(["api", "build", "database", "library", "mobile", "runtime", "test", "web"])
+});
+var manifestFactsSchema = z.object({
+  id: z.string().min(1),
+  path: z.string().min(1),
+  kind: z.string().min(1),
+  product: z.object({ name: z.string().optional(), version: z.string().optional() }).optional(),
+  dependencies: z.array(manifestDependencySchema),
+  frameworks: z.array(manifestFrameworkSchema),
+  runtimes: z.array(z.object({ name: z.string(), version: z.string().optional() })),
+  scripts: z.record(z.string(), z.string()).optional(),
+  workspaces: z.array(z.string()).optional(),
+  aliases: z.array(z.object({ prefix: z.string(), targets: z.array(z.string()) })).optional(),
+  metadata: z.record(z.string(), z.unknown()).default({}),
+  errors: z.array(z.string())
+});
+var FRAMEWORKS = {
+  "@nestjs/core": { name: "NestJS", kind: "api" },
+  "@playwright/test": { name: "Playwright", kind: "test" },
+  "@sveltejs/kit": { name: "SvelteKit", kind: "web" },
+  "@vitejs/plugin-react": { name: "Vite", kind: "build" },
+  "com.android.tools.build:gradle": { name: "Android Gradle Plugin", kind: "build" },
+  django: { name: "Django", kind: "web" },
+  drizzle: { name: "Drizzle", kind: "database" },
+  express: { name: "Express", kind: "api" },
+  fastapi: { name: "FastAPI", kind: "api" },
+  fastify: { name: "Fastify", kind: "api" },
+  flutter: { name: "Flutter", kind: "mobile" },
+  gin: { name: "Gin", kind: "api" },
+  "junit:junit": { name: "JUnit", kind: "test" },
+  "org.junit.jupiter:junit-jupiter": { name: "JUnit Jupiter", kind: "test" },
+  "laravel/framework": { name: "Laravel", kind: "web" },
+  next: { name: "Next.js", kind: "web" },
+  prisma: { name: "Prisma", kind: "database" },
+  rails: { name: "Ruby on Rails", kind: "web" },
+  react: { name: "React", kind: "web" },
+  supabase_flutter: { name: "Supabase", kind: "database" },
+  "symfony/framework-bundle": { name: "Symfony", kind: "web" },
+  svelte: { name: "Svelte", kind: "web" },
+  vite: { name: "Vite", kind: "build" },
+  vitest: { name: "Vitest", kind: "test" },
+  vue: { name: "Vue", kind: "web" }
+};
+function parseManifests(rootInput, files, options = {}) {
+  const root = fs2.realpathSync(rootInput);
+  const limits = resolveLimits(options);
+  const detected = [...new Map(files.filter((file) => isParseableManifest(file.path)).map((file) => [file.path, file])).values()].sort((a, b) => a.path.localeCompare(b.path));
+  const context = {
+    root,
+    limits,
+    cache: /* @__PURE__ */ new Map(),
+    totalBytes: 0,
+    mavenModels: /* @__PURE__ */ new Map(),
+    manifestPaths: new Set(detected.map((file) => file.path))
+  };
+  const facts = new Array(detected.length);
+  const byPath = new Map(detected.map((file, index) => [file.path, { file, index }]));
+  const limitedFact = (file, index) => {
+    if (index >= limits.maxManifestFiles) {
+      return finalize(baseFacts(file.path, manifestKind(path4.posix.basename(file.path)), [
+        `resource limit exceeded: detected manifest ${index + 1} of ${detected.length}; maxManifestFiles=${limits.maxManifestFiles}`
+      ]));
+    }
+    return void 0;
+  };
+  detected.forEach((file, index) => {
+    const limited = limitedFact(file, index);
+    if (limited) facts[index] = limited;
+    else if (file.metadataOnlyReason !== "symlink") facts[index] = parseOne(context, file.path);
+  });
+  detected.forEach((file, index) => {
+    if (!facts[index]) facts[index] = parseManifestSymlink(context, file.path, byPath, facts);
+  });
+  return linkInternalMavenManifests(
+    facts.map((fact, index) => fact ?? finalize(baseFacts(detected[index].path, "manifest", ["manifest parser produced no fact"]))),
+    limits
+  );
+}
+function parseManifestSymlink(context, relative, detected, facts) {
+  try {
+    const absolute = assertInside(context.root, path4.join(context.root, ...relative.split("/")));
+    const rawTarget = fs2.readlinkSync(absolute);
+    if (path4.isAbsolute(rawTarget)) throw new Error("absolute symbolic link target");
+    const target = normalizeRepoPath(path4.posix.normalize(path4.posix.join(path4.posix.dirname(relative), rawTarget.replaceAll("\\", "/"))));
+    const targetEntry = detected.get(target);
+    if (!targetEntry) throw new Error(`target ${target} is not a detected supported manifest`);
+    if (targetEntry.file.metadataOnlyReason === "symlink") throw new Error(`target ${target} is another symbolic link`);
+    const source = facts[targetEntry.index];
+    if (!source) throw new Error(`target ${target} has no parsed fact`);
+    const alias = {
+      ...source,
+      id: "pending",
+      path: relative,
+      product: source.product ? { ...source.product } : void 0,
+      dependencies: source.dependencies.map((dependency) => ({ ...dependency })),
+      frameworks: source.frameworks.map((framework) => ({ ...framework })),
+      runtimes: source.runtimes.map((runtime) => ({ ...runtime })),
+      scripts: source.scripts ? { ...source.scripts } : void 0,
+      workspaces: source.workspaces ? [...source.workspaces] : void 0,
+      aliases: source.aliases?.map((entry) => ({ ...entry, targets: [...entry.targets] })),
+      metadata: {
+        ...source.metadata,
+        manifest_alias_target: target,
+        manifest_alias_target_sha256: targetEntry.file.sha256
+      },
+      errors: [...source.errors]
+    };
+    return finalize(alias);
+  } catch (error) {
+    return finalize(baseFacts(relative, manifestKind(path4.posix.basename(relative)), [`safe-read rejected symbolic link manifest: ${message(error)}`]));
+  }
+}
+function isParseableManifest(relative) {
+  const base = path4.posix.basename(relative);
+  if ([
+    ".bazelrc",
+    ".bazelversion",
+    "BUILD",
+    "BUILD.bazel",
+    "CMakeLists.txt",
+    "Dockerfile",
+    "MODULE.bazel",
+    "MODULE.bazel.lock",
+    "WORKSPACE",
+    "WORKSPACE.bzlmod",
+    "deps.yaml",
+    "extensions_metadata.yaml",
+    "repository_locations.bzl",
+    ".env.example",
+    "Cargo.toml",
+    "Gemfile",
+    "Gemfile.lock",
+    "analysis_options.yaml",
+    "composer.json",
+    "composer.lock",
+    "build.gradle",
+    "build.gradle.kts",
+    "gradle-wrapper.properties",
+    "gradle.properties",
+    "pom.xml",
+    "settings.gradle",
+    "settings.gradle.kts",
+    "package-lock.json",
+    "package.json",
+    "pnpm-lock.yaml",
+    "pnpm-workspace.yaml",
+    "pubspec.lock",
+    "pubspec.yaml",
+    "go.mod",
+    "pyproject.toml",
+    "yarn.lock"
+  ].includes(base)) return true;
+  return /^(?:Dockerfile(?:\..+)?|requirements(?:[-_.][^/]*)?\.txt|tsconfig(?:\.[^/]+)?\.json)$/i.test(base) || /^(?:docker-)?compose(?:\.[^/]+)?\.ya?ml$/i.test(base) || /(?:^|\/)\.github\/workflows\/[^/]+\.ya?ml$/i.test(relative);
+}
+function parseOne(context, relative) {
+  let text = "";
+  try {
+    text = readRepoText(context, relative);
+    validateManifestText(text, context.limits);
+  } catch (error) {
+    return finalize(baseFacts(relative, manifestKind(path4.posix.basename(relative)), [message(error)]));
+  }
+  const base = path4.posix.basename(relative);
+  try {
+    let result;
+    if (base === "package.json") result = parsePackageJson(context, relative, text);
+    else if (base === "package-lock.json") result = parsePackageLock(context, relative, text);
+    else if (base === "pnpm-lock.yaml") result = parsePnpmLock(context, relative, text);
+    else if (base === "yarn.lock") result = parseYarnLock(context, relative, text);
+    else if (base === "pnpm-workspace.yaml") result = parsePnpmWorkspace(context, relative, text);
+    else if (base === "pubspec.yaml") result = parsePubspec(context, relative, text);
+    else if (base === "pubspec.lock") result = parsePubspecLock(context, relative, text);
+    else if (base === "go.mod") result = parseGoMod(relative, text);
+    else if (base === "Cargo.toml") result = parseCargo(relative, text);
+    else if (base === "pom.xml") result = parseMaven(context, relative, text);
+    else if (base === "build.gradle" || base === "build.gradle.kts") result = parseGradleBuild(context, relative, text);
+    else if (base === "settings.gradle" || base === "settings.gradle.kts") result = parseGradleSettings(context, relative, text);
+    else if (base === "gradle-wrapper.properties") result = parseGradleWrapper(relative, text);
+    else if (base === "gradle.properties") result = parseGradleProperties(context, relative, text);
+    else if (base === "Gemfile") result = parseGemfile(context, relative, text);
+    else if (base === "Gemfile.lock") result = parseGemfileLock(relative, text);
+    else if (base === "composer.json") result = parseComposerJson(context, relative, text);
+    else if (base === "composer.lock") result = parseComposerLock(context, relative, text);
+    else if (base === "pyproject.toml") result = parsePyproject(relative, text);
+    else if (/^requirements(?:[-_.][^/]*)?\.txt$/i.test(base)) result = parseRequirements(relative, text);
+    else if (/^tsconfig(?:\.[^/]+)?\.json$/i.test(base)) result = parseTsconfig(context, relative, text);
+    else if (base === "analysis_options.yaml") result = parseAnalysisOptions(context, relative, text);
+    else if (base === ".env.example") result = parseEnvExample(relative, text);
+    else if (/^(?:docker-)?compose(?:\.[^/]+)?\.ya?ml$/i.test(base)) result = parseDockerCompose(context, relative, text);
+    else if (base === "repository_locations.bzl") result = parseRepositoryLocations(context, relative, text);
+    else if (base === "deps.yaml") result = parseDependencyMetadata(context, relative, text);
+    else if (base === "extensions_metadata.yaml") result = parseExtensionsMetadata(context, relative, text);
+    else if (base === "MODULE.bazel.lock") result = parseModuleBazelLock(context, relative, text);
+    else if (base === ".bazelrc") result = parseBazelRc(context, relative, text);
+    else if (base === ".bazelversion") result = parseBazelVersion(relative, text);
+    else if (["MODULE.bazel", "WORKSPACE", "WORKSPACE.bzlmod", "BUILD", "BUILD.bazel"].includes(base)) result = parseBazel(context, relative, text);
+    else if (base === "CMakeLists.txt") result = parseCmake(relative, text);
+    else if (/^Dockerfile(?:\..+)?$/i.test(base)) result = parseDockerfile(relative, text);
+    else if (/(?:^|\/)\.github\/workflows\//.test(relative)) result = parseWorkflow(context, relative, text);
+    else result = finalize(baseFacts(relative, "config", ["detected supported manifest has no registered parser"]));
+    return enforceFactBounds(result, context.limits);
+  } catch (error) {
+    return finalize(baseFacts(relative, manifestKind(base), [message(error)]));
+  }
+}
+function parsePackageJson(context, relative, text) {
+  const value = parseJson(context, text);
+  const declared = { ...record(value.dependencies), ...record(value.optionalDependencies), ...record(value.peerDependencies) };
+  const dev = record(value.devDependencies);
+  const exact = npmResolvedVersions(context, path4.posix.dirname(relative));
+  const dependencies = [
+    ...Object.entries(declared).map(([name, version]) => ({ name, declared: String(version), resolved: exact.get(name), dev: false })),
+    ...Object.entries(dev).map(([name, version]) => ({ name, declared: String(version), resolved: exact.get(name), dev: true }))
+  ].sort((a, b) => a.name.localeCompare(b.name));
+  const facts = baseFacts(relative, "npm", []);
+  facts.product = { name: string(value.name), version: string(value.version) };
+  facts.dependencies = dependencies;
+  facts.frameworks = inferFrameworks(dependencies);
+  facts.runtimes = [{ name: "Node.js", version: string(record(value.engines).node) }];
+  facts.scripts = stringRecord(value.scripts);
+  facts.workspaces = (Array.isArray(value.workspaces) ? value.workspaces : array(record(value.workspaces).packages)).map(String);
+  if (!facts.workspaces.length) delete facts.workspaces;
+  return finalize(facts);
+}
+function parsePackageLock(context, relative, text) {
+  const value = parseJson(context, text);
+  const packages = record(value.packages);
+  const dependencies = Object.entries(packages).flatMap(([key, raw]) => {
+    const marker = key.lastIndexOf("node_modules/");
+    if (marker < 0) return [];
+    const row = record(raw);
+    return [{ name: key.slice(marker + "node_modules/".length), resolved: string(row.version), dev: Boolean(row.dev) }];
+  });
+  for (const [name, raw] of Object.entries(record(value.dependencies))) {
+    const row = record(raw);
+    dependencies.push({ name, resolved: string(row.version), dev: Boolean(row.dev) });
+  }
+  const facts = baseFacts(relative, "npm-lock", []);
+  facts.dependencies = dedupeDependencies(dependencies);
+  return finalize(facts);
+}
+function parsePnpmLock(context, relative, text) {
+  const dependencies = pnpmResolvedDependencies(context, text);
+  const facts = baseFacts(relative, "pnpm-lock", []);
+  facts.dependencies = dependencies;
+  return finalize(facts);
+}
+function parseYarnLock(context, relative, text) {
+  const dependencies = yarnResolvedDependencies(context, text);
+  const facts = baseFacts(relative, "yarn-lock", []);
+  facts.dependencies = dependencies;
+  facts.metadata = { format: /^__metadata\s*:/m.test(text) ? "berry" : "classic", entries: dependencies.length };
+  if (text.trim() && dependencies.length === 0) facts.errors.push("yarn.lock contained no parseable package entries");
+  return finalize(facts);
+}
+function parsePnpmWorkspace(context, relative, text) {
+  const value = parseYamlRecord(context, text, "pnpm-workspace.yaml");
+  const packages = array(value.packages).map(String);
+  const catalogs = record(value.catalogs);
+  const dependencies = Object.values(catalogs).flatMap((catalog) => Object.entries(record(catalog)).map(([name, version]) => ({
+    name,
+    declared: string(version),
+    dev: false
+  })));
+  const facts = baseFacts(relative, "pnpm-workspace", []);
+  facts.workspaces = packages;
+  facts.dependencies = dedupeDependencies(dependencies);
+  facts.metadata = { package_patterns: packages, catalog_count: Object.keys(catalogs).length };
+  return finalize(facts);
+}
+function parsePubspec(context, relative, text) {
+  const value = parseYamlRecord(context, text, "pubspec.yaml");
+  const dependenciesRaw = record(value.dependencies);
+  const devRaw = record(value.dev_dependencies);
+  const lock = pubspecResolvedVersions(context, path4.posix.dirname(relative));
+  const dependencies = [
+    ...Object.entries(dependenciesRaw).map(([name, spec]) => ({ name, declared: yamlVersion(spec), resolved: lock.get(name), dev: false })),
+    ...Object.entries(devRaw).map(([name, spec]) => ({ name, declared: yamlVersion(spec), resolved: lock.get(name), dev: true }))
+  ].sort((a, b) => a.name.localeCompare(b.name));
+  const environment = record(value.environment);
+  const facts = baseFacts(relative, "pubspec", []);
+  facts.product = { name: string(value.name), version: string(value.version) };
+  facts.dependencies = dependencies;
+  facts.frameworks = inferFrameworks(dependencies);
+  if ("flutter" in value || "flutter" in dependenciesRaw || "flutter" in devRaw) facts.frameworks.unshift({ name: "Flutter", version: string(environment.flutter) ?? string(environment.sdk), kind: "mobile" });
+  facts.runtimes = [{ name: "Dart", version: string(environment.sdk) }];
+  return finalize(facts);
+}
+function parsePubspecLock(context, relative, text) {
+  const value = parseYamlRecord(context, text, "pubspec.lock");
+  const dependencies = Object.entries(record(value.packages)).map(([name, raw]) => ({ name, resolved: string(record(raw).version), dev: false }));
+  const facts = baseFacts(relative, "pubspec-lock", []);
+  facts.dependencies = dependencies.sort((a, b) => a.name.localeCompare(b.name));
+  return finalize(facts);
+}
+function parseGoMod(relative, text) {
+  const moduleName = text.match(/^module\s+(\S+)/m)?.[1];
+  const goVersion = text.match(/^go\s+(\S+)/m)?.[1];
+  const dependencies = [...text.matchAll(/^\s*([^\s/][^\s]*)\s+(v[^\s]+)(?:\s+\/\/\s+indirect)?$/gm)].map((match) => ({ name: match[1], resolved: match[2], dev: false }));
+  const emptyPlaceholder = text.trim().length === 0;
+  const facts = baseFacts(relative, "go", moduleName || emptyPlaceholder ? [] : ["go.mod is missing its required module directive"]);
+  facts.product = { name: moduleName };
+  facts.dependencies = dependencies;
+  facts.runtimes = [{ name: "Go", version: goVersion }];
+  facts.metadata = emptyPlaceholder ? { empty_placeholder: true } : {};
+  return finalize(facts);
+}
+function parseCargo(relative, text) {
+  const packageBlock = section(text, "package");
+  const dependencies = [
+    ...parseTomlDependencies(section(text, "dependencies"), false),
+    ...parseTomlDependencies(section(text, "dev-dependencies"), true)
+  ];
+  const facts = baseFacts(relative, "cargo", /^\s*\[(?:package|workspace)\]\s*$/m.test(text) ? [] : ["Cargo.toml has neither a [package] nor [workspace] table"]);
+  facts.product = { name: quoted(packageBlock, "name"), version: quoted(packageBlock, "version") };
+  facts.dependencies = dependencies;
+  facts.runtimes = [{ name: "Rust", version: quoted(packageBlock, "rust-version") }];
+  return finalize(facts);
+}
+var MAVEN_XML = new XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: "@_",
+  allowBooleanAttributes: true,
+  parseTagValue: false,
+  parseAttributeValue: false,
+  processEntities: false,
+  trimValues: true
+});
+function parseMaven(context, relative, text) {
+  const model = readMavenModel(context, relative, text, /* @__PURE__ */ new Set(), 0);
+  const managedVersions = mavenManagedVersions(model);
+  const direct = mavenDependencyRows(record(model.project.dependencies).dependency, model.properties, false, managedVersions);
+  const managed = mavenDependencyRows(record(record(model.project.dependencyManagement).dependencies).dependency, model.properties, true);
+  const dependencies = dedupeDependencies(direct.map(({ name, declared, dev }) => ({ name, ...declared ? { declared } : {}, dev })));
+  const modules = valueArray(record(model.project.modules).module).map((value) => resolveMavenValue(string(value), model.properties)).filter((value) => Boolean(value)).map((value) => mavenModulePomPath(context, relative, value));
+  const javaVersion = mavenJavaVersion(model);
+  const mavenVersion = mavenInheritedRequiredVersion(model, "requireMavenVersion");
+  const coordinate = model.groupId && model.artifactId ? `${model.groupId}:${model.artifactId}` : model.artifactId;
+  const platform = mavenPlatform(model, relative);
+  const facts = baseFacts(relative, "maven", model.artifactId ? [] : ["pom.xml is missing project.artifactId"]);
+  facts.product = { name: coordinate, version: model.version };
+  facts.dependencies = dependencies;
+  facts.frameworks = [
+    { name: "Maven", version: mavenVersion, kind: "build" },
+    ...inferFrameworks(dependencies)
+  ];
+  facts.runtimes = [{ name: "Java", version: javaVersion }];
+  if (modules.length) facts.workspaces = modules;
+  facts.metadata = {
+    coordinate,
+    group_id: model.groupId,
+    artifact_id: model.artifactId,
+    packaging: resolveMavenValue(string(model.project.packaging), model.properties) ?? "jar",
+    platform,
+    parent_coordinate: model.parentCoordinate,
+    parent_path: model.parentPath,
+    modules,
+    source_directory: model.sourceDirectory,
+    test_source_directory: model.testSourceDirectory,
+    direct_dependencies: direct,
+    direct_dependency_count: direct.length,
+    managed_dependencies: managed,
+    managed_dependency_count: managed.length
+  };
+  return finalize(facts);
+}
+function mavenModulePomPath(context, manifestPath, moduleSpecifier) {
+  const joined = normalizeRepoPath(path4.posix.join(path4.posix.dirname(manifestPath), moduleSpecifier));
+  if (context.manifestPaths.has(joined)) return joined;
+  const nestedPom = normalizeRepoPath(path4.posix.join(joined, "pom.xml"));
+  if (context.manifestPaths.has(nestedPom)) return nestedPom;
+  return joined.toLowerCase().endsWith(".xml") ? joined : nestedPom;
+}
+function readMavenModel(context, relative, text, seen, depth) {
+  if (depth > 16) throw new Error("Maven parent chain exceeds 16 local pom.xml files");
+  if (seen.has(relative)) throw new Error(`Maven parent cycle detected at ${relative}`);
+  const cached = context.mavenModels.get(relative);
+  if (cached) return cached;
+  const nextSeen = new Set(seen).add(relative);
+  const parsed = MAVEN_XML.parse(text);
+  const project = record(record(parsed).project);
+  if (!Object.keys(project).length) throw new Error("pom.xml root must be a project element");
+  const parent = record(project.parent);
+  let inherited;
+  let parentPath;
+  if (Object.keys(parent).length) {
+    const hasExplicitRelativePath = Object.prototype.hasOwnProperty.call(parent, "relativePath");
+    const configured = string(parent.relativePath);
+    const localSpecifier = hasExplicitRelativePath ? configured : "../pom.xml";
+    if (localSpecifier) {
+      try {
+        parentPath = normalizeRepoPath(path4.posix.join(path4.posix.dirname(relative), localSpecifier));
+      } catch {
+        parentPath = void 0;
+      }
+      if (parentPath && context.manifestPaths.has(parentPath)) {
+        const parentText = readRepoText(context, parentPath);
+        inherited = readMavenModel(context, parentPath, parentText, nextSeen, depth + 1);
+      } else {
+        parentPath = void 0;
+      }
+    }
+  }
+  const rawProperties = Object.fromEntries(Object.entries(record(project.properties)).flatMap(([key, value]) => {
+    const scalar = string(value);
+    return scalar === void 0 ? [] : [[key, scalar]];
+  }));
+  let properties = { ...inherited?.properties ?? {}, ...rawProperties };
+  const parentGroup = inherited?.groupId ?? resolveMavenValue(string(parent.groupId), properties);
+  const parentArtifact = inherited?.artifactId ?? resolveMavenValue(string(parent.artifactId), properties);
+  const parentVersion = inherited?.version ?? resolveMavenValue(string(parent.version), properties);
+  let groupId = resolveMavenValue(string(project.groupId), properties) ?? parentGroup;
+  let artifactId = resolveMavenValue(string(project.artifactId), properties);
+  let version = resolveMavenValue(string(project.version), properties) ?? parentVersion;
+  const builtins = {
+    "project.groupId": groupId,
+    "project.artifactId": artifactId,
+    "project.version": version,
+    "pom.groupId": groupId,
+    "pom.artifactId": artifactId,
+    "pom.version": version,
+    "project.parent.groupId": parentGroup,
+    "project.parent.artifactId": parentArtifact,
+    "project.parent.version": parentVersion
+  };
+  for (const [key, value] of Object.entries(builtins)) if (value !== void 0) properties[key] = value;
+  properties = resolveMavenProperties(properties);
+  groupId = resolveMavenValue(groupId, properties);
+  artifactId = resolveMavenValue(artifactId, properties);
+  version = resolveMavenValue(version, properties);
+  const build = record(project.build);
+  const sourceDirectory = resolveMavenValue(string(build.sourceDirectory), properties) ?? inherited?.sourceDirectory ?? "src/main/java";
+  const testSourceDirectory = resolveMavenValue(string(build.testSourceDirectory), properties) ?? inherited?.testSourceDirectory ?? "src/test/java";
+  const model = {
+    project,
+    groupId,
+    artifactId,
+    version,
+    properties,
+    ...parentPath ? { parentPath } : {},
+    ...parentGroup && parentArtifact ? { parentCoordinate: `${parentGroup}:${parentArtifact}${parentVersion ? `:${parentVersion}` : ""}` } : {},
+    sourceDirectory,
+    testSourceDirectory,
+    ...inherited ? { parent: inherited } : {}
+  };
+  context.mavenModels.set(relative, model);
+  return model;
+}
+function mavenDependencyRows(value, properties, managed, managedVersions = /* @__PURE__ */ new Map()) {
+  return valueArray(value).flatMap((raw) => {
+    const dependency = record(raw);
+    const groupId = resolveMavenValue(string(dependency.groupId), properties);
+    const artifactId = resolveMavenValue(string(dependency.artifactId), properties);
+    if (!groupId || !artifactId) return [];
+    const name = `${groupId}:${artifactId}`;
+    const version = resolveMavenValue(string(dependency.version), properties) ?? managedVersions.get(name);
+    const scope = resolveMavenValue(string(dependency.scope), properties)?.toLowerCase();
+    const classifier = resolveMavenValue(string(dependency.classifier), properties);
+    const dependencyType = resolveMavenValue(string(dependency.type), properties);
+    const optional = resolveMavenValue(string(dependency.optional), properties)?.toLowerCase();
+    const exclusions = valueArray(record(dependency.exclusions).exclusion).flatMap((rawExclusion) => {
+      const exclusion = record(rawExclusion);
+      const exclusionGroup = resolveMavenValue(string(exclusion.groupId), properties);
+      const exclusionArtifact = resolveMavenValue(string(exclusion.artifactId), properties);
+      return exclusionGroup && exclusionArtifact ? [`${exclusionGroup}:${exclusionArtifact}`] : [];
+    });
+    return [{
+      name,
+      ...version ? { declared: version } : {},
+      dev: scope === "test" || managed && scope === "test",
+      ...scope ? { scope } : {},
+      ...classifier ? { classifier } : {},
+      ...dependencyType ? { type: dependencyType } : {},
+      ...optional === "true" ? { optional: true } : optional === "false" ? { optional: false } : {},
+      ...exclusions.length ? { exclusions: [...new Set(exclusions)].sort() } : {}
+    }];
+  });
+}
+function mavenManagedVersions(model) {
+  const chain = [];
+  for (let current = model; current; current = current.parent) chain.unshift(current);
+  const versions = /* @__PURE__ */ new Map();
+  for (const current of chain) {
+    for (const dependency of mavenDependencyRows(
+      record(record(current.project.dependencyManagement).dependencies).dependency,
+      model.properties,
+      true
+    )) {
+      if (dependency.declared) versions.set(dependency.name, dependency.declared);
+    }
+  }
+  return versions;
+}
+function mavenPlatform(model, relative) {
+  const explicit = resolveMavenValue(
+    model.properties["variant.jvmEnvironmentVariantName"] ?? model.properties["variant.jvmEnvironment"],
+    model.properties
+  )?.trim().toLowerCase();
+  if (explicit) return explicit === "standard-jvm" ? "jre" : explicit;
+  const versionPlatform = model.version?.match(/-(android|jre)(?:$|[.-])/i)?.[1]?.toLowerCase();
+  if (versionPlatform) return versionPlatform;
+  return relative.startsWith("android/") ? "android" : void 0;
+}
+function resolveMavenProperties(input) {
+  const result = { ...input };
+  for (let pass = 0; pass < 16; pass += 1) {
+    let changed = false;
+    for (const [key, value] of Object.entries(result)) {
+      const resolved = resolveMavenValue(value, result);
+      if (resolved !== void 0 && resolved !== value) {
+        result[key] = resolved;
+        changed = true;
+      }
+    }
+    if (!changed) break;
+  }
+  return result;
+}
+function resolveMavenValue(value, properties) {
+  if (value === void 0) return void 0;
+  let output = value.trim();
+  for (let pass = 0; pass < 16; pass += 1) {
+    const next = output.replace(/\$\{([^}]+)\}/g, (whole, key) => properties[key] ?? whole);
+    if (next === output) break;
+    output = next;
+  }
+  return output || void 0;
+}
+function mavenJavaVersion(model) {
+  for (const key of ["maven.compiler.release", "maven.compiler.source", "java.version", "jdk.version"]) {
+    const value = resolveMavenValue(model.properties[key], model.properties);
+    if (value) return value;
+  }
+  for (const plugin of mavenPlugins(model.project)) {
+    if (string(plugin.artifactId) !== "maven-compiler-plugin") continue;
+    const configuration = record(plugin.configuration);
+    const configured = string(configuration.release) ?? string(configuration.source) ?? string(configuration.target);
+    const value = resolveMavenValue(configured, model.properties);
+    if (value) return value;
+  }
+  return mavenRequiredVersion(model.project, "requireJavaVersion", model.properties) ?? (model.parent ? mavenJavaVersion(model.parent) : void 0);
+}
+function mavenInheritedRequiredVersion(model, rule) {
+  return mavenRequiredVersion(model.project, rule, model.properties) ?? (model.parent ? mavenInheritedRequiredVersion(model.parent, rule) : void 0);
+}
+function mavenPlugins(project) {
+  const build = record(project.build);
+  return [
+    ...valueArray(record(build.plugins).plugin),
+    ...valueArray(record(record(build.pluginManagement).plugins).plugin)
+  ].map(record);
+}
+function mavenRequiredVersion(project, rule, properties) {
+  const stack = [project];
+  let visited = 0;
+  while (stack.length && visited < 1e5) {
+    const current = stack.pop();
+    visited += 1;
+    if (Array.isArray(current)) {
+      stack.push(...current);
+      continue;
+    }
+    const row = record(current);
+    if (!Object.keys(row).length) continue;
+    if (rule in row) {
+      const value = row[rule];
+      const configured = string(value) ?? string(record(value).version);
+      const resolved = resolveMavenValue(configured, properties);
+      if (resolved) return resolved;
+    }
+    stack.push(...Object.values(row));
+  }
+  return void 0;
+}
+function parseGradleBuild(context, relative, text) {
+  const dependencies = gradleDependencies(text);
+  const plugins = gradlePlugins(text);
+  const version = gradleWrapperVersion(context, path4.posix.dirname(relative));
+  const facts = baseFacts(relative, "gradle", []);
+  facts.dependencies = dependencies;
+  facts.frameworks = [
+    { name: "Gradle", version, kind: "build" },
+    ...inferFrameworks(dependencies)
+  ];
+  const javaVersion = gradleJavaVersion(text);
+  facts.runtimes = [{ name: "Java", version: javaVersion }];
+  facts.scripts = Object.fromEntries([...text.matchAll(/\b(?:tasks\.)?(?:register|create|named)\s*\(\s*["']([^"']+)["']/g)].map((match) => [match[1], "Gradle task"]));
+  if (!Object.keys(facts.scripts).length) delete facts.scripts;
+  facts.metadata = { plugins, dependency_count: dependencies.length };
+  return finalize(facts);
+}
+function parseGradleSettings(context, relative, text) {
+  const version = gradleWrapperVersion(context, path4.posix.dirname(relative));
+  const name = text.match(/\brootProject\.name\s*=\s*["']([^"']+)["']/)?.[1];
+  const modules = [...text.matchAll(/\binclude\s*\(([^)]*)\)|\binclude\s+([^\n]+)/g)].flatMap(
+    (match) => [...(match[1] ?? match[2] ?? "").matchAll(/["']([^"']+)["']/g)].map((value) => value[1].replace(/^:/, "").replaceAll(":", "/"))
+  );
+  const facts = baseFacts(relative, "gradle-settings", []);
+  facts.product = { name };
+  facts.frameworks = [{ name: "Gradle", version, kind: "build" }];
+  facts.workspaces = [...new Set(modules)].sort();
+  if (!facts.workspaces.length) delete facts.workspaces;
+  facts.metadata = { root_project_name: name, modules: facts.workspaces ?? [] };
+  return finalize(facts);
+}
+function parseGradleWrapper(relative, text) {
+  const version = gradleDistributionVersion(text);
+  const facts = baseFacts(relative, "gradle-wrapper", version ? [] : ["Gradle wrapper properties contain no versioned distributionUrl"]);
+  facts.frameworks = [{ name: "Gradle", version, kind: "build" }];
+  facts.metadata = { distribution_version: version };
+  return finalize(facts);
+}
+function parseGradleProperties(context, relative, text) {
+  const properties = propertyFile(text);
+  const facts = baseFacts(relative, "gradle-properties", []);
+  facts.frameworks = [{ name: "Gradle", version: gradleWrapperVersion(context, path4.posix.dirname(relative)), kind: "build" }];
+  facts.metadata = { keys: [...properties.keys()].sort(), key_count: properties.size };
+  return finalize(facts);
+}
+function gradleDependencies(text) {
+  const rows = [];
+  const coordinate = /["']([A-Za-z0-9_.-]+):([A-Za-z0-9_.-]+)(?::([^"']+))?["']/g;
+  for (const match of text.matchAll(coordinate)) {
+    const prefix = text.slice(Math.max(0, (match.index ?? 0) - 120), match.index).toLowerCase();
+    const configuration = prefix.match(/["']?([a-z][a-z0-9_]*)["']?\s*(?:\(|\s)\s*$/)?.[1] ?? "";
+    if (!/(?:api|implementation|compile|runtime|classpath|constraint|processor)/.test(configuration)) continue;
+    rows.push({
+      name: `${match[1]}:${match[2]}`,
+      ...match[3] ? { declared: match[3] } : {},
+      dev: /(?:test|benchmark)/.test(configuration)
+    });
+  }
+  return dedupeDependencies(rows);
+}
+function gradlePlugins(text) {
+  const plugins = [
+    ...[...text.matchAll(/\bid\s*\(\s*["']([^"']+)["']\s*\)\s*(?:version\s*["']([^"']+)["'])?/g)].map((match) => ({ id: match[1], ...match[2] ? { version: match[2] } : {} })),
+    ...[...text.matchAll(/\bapply\s*\(\s*plugin\s*=\s*["']([^"']+)["']/g)].map((match) => ({ id: match[1] })),
+    ...[...text.matchAll(/\bid\s+["']([^"']+)["']\s+version\s+["']([^"']+)["']/g)].map((match) => ({ id: match[1], version: match[2] }))
+  ];
+  return dedupeBy(plugins.sort((a, b) => a.id.localeCompare(b.id)), (plugin) => `${plugin.id}:${plugin.version ?? ""}`);
+}
+function gradleJavaVersion(text) {
+  const enumVersion = text.match(/JavaVersion\.VERSION_([0-9_]+)/)?.[1]?.replaceAll("_", ".");
+  if (enumVersion) return enumVersion;
+  return text.match(/JavaLanguageVersion\.of\s*\(\s*([0-9]+)\s*\)/)?.[1] ?? text.match(/(?:sourceCompatibility|targetCompatibility)\s*=\s*["']([^"']+)["']/)?.[1];
+}
+function gradleWrapperVersion(context, startDirectory) {
+  let directory = startDirectory === "." ? "" : startDirectory;
+  for (let depth = 0; depth < 16; depth += 1) {
+    const candidate = joinRepoPath(directory, "gradle/wrapper/gradle-wrapper.properties");
+    const text = tryReadRepoText(context, candidate);
+    const version = text ? gradleDistributionVersion(text) : void 0;
+    if (version) return version;
+    if (!directory) break;
+    const parent = path4.posix.dirname(directory);
+    directory = parent === "." ? "" : parent;
+  }
+  return void 0;
+}
+function gradleDistributionVersion(text) {
+  const url = propertyFile(text).get("distributionUrl")?.replaceAll("\\:", ":");
+  return url?.match(/gradle-([0-9][0-9A-Za-z.+-]*)-(?:all|bin)\.zip(?:$|[?#])/)?.[1];
+}
+function propertyFile(text) {
+  const result = /* @__PURE__ */ new Map();
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#") || line.startsWith("!")) continue;
+    const match = /^([^:=\s]+)\s*[:=]\s*(.*)$/.exec(line);
+    if (match?.[1]) result.set(match[1], match[2] ?? "");
+  }
+  return result;
+}
+function valueArray(value) {
+  return value === void 0 || value === null ? [] : Array.isArray(value) ? value : [value];
+}
+function parseGemfile(context, relative, text) {
+  const exact = gemResolvedVersions(context, path4.posix.dirname(relative));
+  const dependencies = [];
+  let developmentDepth = 0;
+  const invalidLines = [];
+  text.split(/\r?\n/).forEach((rawLine, index) => {
+    const line = rawLine.replace(/\s+#.*$/, "").trim();
+    if (line && /^gem\b/.test(line) && !/^gem\s+["'][^"']+["']/.test(line)) invalidLines.push(index + 1);
+    if (/^group\s+.*\b(?:development|test)\b.*\bdo\b/.test(line)) developmentDepth += 1;
+    const match = line.match(/^gem\s+["']([^"']+)["'](?:\s*,\s*["']([^"']+)["'])?/);
+    if (match?.[1]) dependencies.push({
+      name: match[1],
+      ...match[2] ? { declared: match[2] } : {},
+      ...exact.get(match[1]) ? { resolved: exact.get(match[1]) } : {},
+      dev: developmentDepth > 0
+    });
+    if (developmentDepth > 0 && /^end\b/.test(line)) developmentDepth -= 1;
+  });
+  const ruby = text.match(/^ruby\s+["']([^"']+)["']/m)?.[1];
+  const facts = baseFacts(relative, "bundler", invalidLines.length ? [`invalid Gemfile gem declaration at lines ${invalidLines.join(", ")}`] : []);
+  facts.dependencies = dedupeDependencies(dependencies);
+  facts.runtimes = [{ name: "Ruby", version: ruby }];
+  facts.frameworks = inferFrameworks(dependencies);
+  return finalize(facts);
+}
+function parseGemfileLock(relative, text) {
+  const dependencies = [];
+  let inSpecs = false;
+  for (const line of text.split(/\r?\n/)) {
+    if (/^(?:GEM|PATH|GIT)$/.test(line)) {
+      inSpecs = false;
+      continue;
+    }
+    if (/^  specs:$/.test(line)) {
+      inSpecs = true;
+      continue;
+    }
+    if (/^[A-Z][A-Z ]+$/.test(line)) {
+      inSpecs = false;
+      continue;
+    }
+    if (!inSpecs) continue;
+    const match = line.match(/^    ([A-Za-z0-9_.-]+) \(([^)]+)\)\s*$/);
+    if (match?.[1]) dependencies.push({ name: match[1], resolved: match[2], dev: false });
+  }
+  const facts = baseFacts(relative, "bundler-lock", []);
+  facts.dependencies = dedupeDependencies(dependencies);
+  facts.metadata = {
+    bundler_version: text.match(/^BUNDLED WITH\s*\n\s+([^\s]+)$/m)?.[1],
+    ruby_version: text.match(/^RUBY VERSION\s*\n\s+ruby\s+([^\s]+)$/m)?.[1]
+  };
+  if (text.trim() && !/^(?:GEM|PATH|GIT)\s*$/m.test(text)) facts.errors.push("Gemfile.lock contained no GEM, PATH, or GIT section");
+  return finalize(facts);
+}
+function parseComposerJson(context, relative, text) {
+  const value = parseJson(context, text);
+  const declared = record(value.require);
+  const dev = record(value["require-dev"]);
+  const exact = composerResolvedVersions(context, path4.posix.dirname(relative));
+  const dependencies = [
+    ...Object.entries(declared).filter(([name]) => name !== "php").map(([name, version]) => ({
+      name,
+      declared: string(version),
+      resolved: exact.get(name),
+      dev: false
+    })),
+    ...Object.entries(dev).map(([name, version]) => ({
+      name,
+      declared: string(version),
+      resolved: exact.get(name),
+      dev: true
+    }))
+  ];
+  const facts = baseFacts(relative, "composer", []);
+  facts.product = { name: string(value.name), version: string(value.version) };
+  facts.dependencies = dedupeDependencies(dependencies);
+  facts.frameworks = inferFrameworks(dependencies);
+  facts.runtimes = [{ name: "PHP", version: string(declared.php) }];
+  facts.scripts = composerScripts(value.scripts);
+  return finalize(facts);
+}
+function parseComposerLock(context, relative, text) {
+  const value = parseJson(context, text);
+  const dependencies = [
+    ...array(value.packages).flatMap((raw) => {
+      const row = record(raw);
+      const name = string(row.name);
+      return name ? [{ name, resolved: string(row.version), dev: false }] : [];
+    }),
+    ...array(value["packages-dev"]).flatMap((raw) => {
+      const row = record(raw);
+      const name = string(row.name);
+      return name ? [{ name, resolved: string(row.version), dev: true }] : [];
+    })
+  ];
+  const facts = baseFacts(relative, "composer-lock", []);
+  facts.dependencies = dedupeDependencies(dependencies);
+  facts.metadata = { content_hash: string(value["content-hash"]), plugin_api_version: string(value["plugin-api-version"]) };
+  return finalize(facts);
+}
+function parsePyproject(relative, text) {
+  const project = section(text, "project");
+  const poetry = section(text, "tool.poetry");
+  const dependencyLines = section(text, "tool.poetry.dependencies");
+  const dependencies = parseTomlDependencies(dependencyLines, false).filter((dependency) => dependency.name !== "python");
+  dependencies.push(...parseTomlDependencies(section(text, "tool.poetry.dev-dependencies"), true));
+  for (const group of sectionsMatching(text, /^tool\.poetry\.group\.[^.]+\.dependencies$/)) {
+    dependencies.push(...parseTomlDependencies(group.body, true));
+  }
+  const pyList = project.match(/dependencies\s*=\s*\[([\s\S]*?)\]/)?.[1] ?? "";
+  for (const match of pyList.matchAll(/["']([A-Za-z0-9_.-]+)([^"']*)["']/g)) dependencies.push({ name: match[1], declared: match[2]?.trim() || void 0, dev: false });
+  for (const optional of sectionsMatching(text, /^project\.optional-dependencies$/)) {
+    for (const match of optional.body.matchAll(/["']([A-Za-z0-9_.-]+)([^"']*)["']/g)) {
+      dependencies.push({ name: match[1], declared: match[2]?.trim() || void 0, dev: true });
+    }
+  }
+  const facts = baseFacts(relative, "pyproject", /^\s*\[[^\]]+\]\s*$/m.test(text) ? [] : ["pyproject.toml contains no TOML table"]);
+  facts.product = { name: quoted(project, "name") ?? quoted(poetry, "name"), version: quoted(project, "version") ?? quoted(poetry, "version") };
+  facts.dependencies = dedupeDependencies(dependencies);
+  facts.frameworks = inferFrameworks(facts.dependencies);
+  facts.runtimes = [{ name: "Python", version: quoted(project, "requires-python") ?? quoted(dependencyLines, "python") }];
+  return finalize(facts);
+}
+function parseRequirements(relative, text) {
+  const includes = [];
+  const constraints = [];
+  const directives = [];
+  const invalidLines = [];
+  const dependencies = text.split(/\r?\n/).flatMap((line, index) => {
+    const cleaned = line.replace(/^\s*#.*$/, "").replace(/\s+#.*$/, "").trim();
+    const include = cleaned.match(/^(?:-r|--require)\s+(.+)$/);
+    if (include?.[1]) {
+      includes.push(include[1].trim());
+      return [];
+    }
+    const constraint = cleaned.match(/^(?:-c|--constraint)\s+(.+)$/);
+    if (constraint?.[1]) {
+      constraints.push(constraint[1].trim());
+      return [];
+    }
+    if (!cleaned) return [];
+    if (cleaned.includes("git+")) {
+      const egg = cleaned.match(/[#&]egg=([A-Za-z0-9_.-]+)/)?.[1];
+      if (egg) return [{ name: egg, declared: cleaned, dev: /(?:dev|test)/i.test(path4.posix.basename(relative)) }];
+      invalidLines.push(index + 1);
+      return [];
+    }
+    if (cleaned.startsWith("-")) {
+      const directive = cleaned.match(/^(--?[A-Za-z][A-Za-z-]*)\b/)?.[1];
+      if (directive) directives.push(directive);
+      else invalidLines.push(index + 1);
+      return [];
+    }
+    const match = cleaned.match(/^([A-Za-z0-9_.-]+)\s*(.*)$/);
+    if (!match?.[1]) {
+      invalidLines.push(index + 1);
+      return [];
+    }
+    return [{ name: match[1], declared: match[2] || void 0, dev: /(?:dev|test)/i.test(path4.posix.basename(relative)) }];
+  });
+  const facts = baseFacts(relative, "requirements", invalidLines.length ? [`unparsed requirements syntax at lines ${invalidLines.slice(0, 20).join(", ")}${invalidLines.length > 20 ? "\u2026" : ""}`] : []);
+  facts.dependencies = dependencies;
+  facts.frameworks = inferFrameworks(dependencies);
+  facts.runtimes = [{ name: "Python" }];
+  facts.metadata = { includes, constraints, directives: [...new Set(directives)].sort() };
+  return finalize(facts);
+}
+function parseTsconfig(context, relative, text) {
+  const errors = [];
+  const layer = loadTsconfigLayer(context, relative, text, 0, /* @__PURE__ */ new Set(), errors);
+  const compiler = layer.compiler;
+  const aliases = Object.entries(record(compiler.paths)).map(([prefix, targets]) => ({ prefix, targets: array(targets).map(String) }));
+  const declaringDirectory = path4.posix.dirname(relative);
+  const resolutionOrigin = Object.prototype.hasOwnProperty.call(compiler, "baseUrl") ? layer.baseUrlOrigin : layer.pathsOrigin;
+  const baseDirectory = path4.posix.dirname(resolutionOrigin || relative);
+  const declaredBaseUrl = string(compiler.baseUrl) ?? "";
+  const effectiveBaseUrl = normalizeRelativeJoin(declaringDirectory, baseDirectory, declaredBaseUrl);
+  const facts = baseFacts(relative, "tsconfig", errors);
+  facts.runtimes = [{ name: "TypeScript", version: string(compiler.target) }];
+  facts.aliases = aliases;
+  facts.metadata = {
+    baseUrl: effectiveBaseUrl,
+    extends_chain: layer.chain,
+    external_extends: [...new Set(layer.externalExtends)].sort(),
+    paths_origin: layer.pathsOrigin,
+    base_url_origin: layer.baseUrlOrigin
+  };
+  return finalize(facts);
+}
+function loadTsconfigLayer(context, relative, providedText, depth, visiting, errors) {
+  if (depth > context.limits.maxTsconfigExtendsDepth) {
+    errors.push(`tsconfig extends depth exceeds ${context.limits.maxTsconfigExtendsDepth} at ${relative}`);
+    return { compiler: {}, chain: [], externalExtends: [], pathsOrigin: relative, baseUrlOrigin: relative };
+  }
+  if (visiting.has(relative)) {
+    errors.push(`tsconfig extends cycle detected at ${relative}`);
+    return { compiler: {}, chain: [], externalExtends: [], pathsOrigin: relative, baseUrlOrigin: relative };
+  }
+  visiting.add(relative);
+  let value;
+  try {
+    const text = providedText ?? readRepoText(context, relative);
+    validateManifestText(text, context.limits);
+    value = parseJson(context, text, true);
+  } catch (error) {
+    errors.push(`cannot parse extended tsconfig ${relative}: ${message(error)}`);
+    visiting.delete(relative);
+    return { compiler: {}, chain: [], externalExtends: [], pathsOrigin: relative, baseUrlOrigin: relative };
+  }
+  let effective = { compiler: {}, chain: [], externalExtends: [], pathsOrigin: relative, baseUrlOrigin: relative };
+  for (const specifier of tsconfigExtends(value.extends)) {
+    const target = resolveTsconfigExtends(relative, specifier);
+    if (!target) {
+      effective.externalExtends.push(specifier);
+      continue;
+    }
+    const parent = loadTsconfigLayer(context, target, void 0, depth + 1, visiting, errors);
+    effective = mergeTsconfigLayers(effective, parent);
+  }
+  const current = record(value.compilerOptions);
+  const mergedCompiler = { ...effective.compiler, ...current };
+  if (Object.prototype.hasOwnProperty.call(current, "paths")) effective.pathsOrigin = relative;
+  if (Object.prototype.hasOwnProperty.call(current, "baseUrl")) effective.baseUrlOrigin = relative;
+  effective.compiler = mergedCompiler;
+  effective.chain.push(relative);
+  visiting.delete(relative);
+  return effective;
+}
+function parseAnalysisOptions(context, relative, text) {
+  const value = parseYamlRecord(context, text, "analysis_options.yaml");
+  const analyzer = record(value.analyzer);
+  const linter = record(value.linter);
+  const plugins = array(analyzer.plugins).map(String);
+  const excludes = array(analyzer.exclude).map(String);
+  const rulesValue = linter.rules;
+  const lintRules = Array.isArray(rulesValue) ? rulesValue.map(String) : Object.entries(record(rulesValue)).filter(([, enabled]) => enabled !== false).map(([name]) => name);
+  const facts = baseFacts(relative, "dart-analysis-options", []);
+  facts.runtimes = [{ name: "Dart analyzer" }];
+  facts.metadata = { include: string(value.include), plugins, excludes, lint_rules: lintRules.sort() };
+  return finalize(facts);
+}
+function parseEnvExample(relative, text) {
+  const keys = [];
+  const invalidLines = [];
+  text.split(/\r?\n/).forEach((raw, index) => {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) return;
+    const match = line.match(/^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/);
+    if (match?.[1]) keys.push(match[1]);
+    else invalidLines.push(index + 1);
+  });
+  const facts = baseFacts(relative, "environment-template", invalidLines.length ? [`invalid dotenv assignment syntax at lines ${invalidLines.slice(0, 20).join(", ")}${invalidLines.length > 20 ? "\u2026" : ""}`] : []);
+  facts.metadata = { keys: [...new Set(keys)].sort(), key_count: new Set(keys).size };
+  return finalize(facts);
+}
+function parseDockerCompose(context, relative, text) {
+  const value = parseYamlRecord(context, text, "Docker Compose manifest");
+  if (!("services" in value) || !value.services || typeof value.services !== "object" || Array.isArray(value.services)) {
+    throw new Error("Docker Compose manifest must contain a services mapping");
+  }
+  const services = Object.entries(record(value.services)).map(([name, raw]) => {
+    const service = record(raw);
+    const environment = service.environment;
+    const environmentKeys = Array.isArray(environment) ? environment.flatMap((entry) => {
+      const key = String(entry).split("=", 1)[0]?.trim();
+      return key ? [key] : [];
+    }) : Object.keys(record(environment));
+    const build = typeof service.build === "string" ? service.build : string(record(service.build).context);
+    return {
+      name,
+      image: string(service.image),
+      build,
+      depends_on: Array.isArray(service.depends_on) ? service.depends_on.map(String) : Object.keys(record(service.depends_on)),
+      environment_keys: [...new Set(environmentKeys)].sort(),
+      env_files: array(service.env_file).map(String)
+    };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+  const facts = baseFacts(relative, "docker-compose", []);
+  facts.frameworks = [{ name: "Docker Compose", kind: "build" }];
+  facts.metadata = { service_count: services.length, services };
+  return finalize(facts);
+}
+function parseRepositoryLocations(context, relative, text) {
+  const repositories = starlarkRepositoryEntries(text);
+  const facts = baseFacts(relative, "bazel-repository-locations", []);
+  facts.dependencies = dedupeDependencies(repositories.map((entry) => ({
+    name: entry.name,
+    ...entry.version ? { declared: entry.version, resolved: entry.version } : {},
+    dev: false
+  })));
+  facts.frameworks = bazelFramework(context);
+  facts.metadata = {
+    repository_count: repositories.length,
+    repositories: repositories.slice(0, 500),
+    truncated: repositories.length > 500
+  };
+  return finalize(facts);
+}
+function parseDependencyMetadata(context, relative, text) {
+  const value = parseYaml(context, text);
+  const dependencies = collectYamlDependencies(value, void 0, [], /* @__PURE__ */ new WeakSet(), 0, context.limits.maxNestingDepth);
+  const facts = baseFacts(relative, "envoy-dependency-metadata", []);
+  facts.dependencies = dedupeDependencies(dependencies);
+  facts.frameworks = bazelFramework(context);
+  facts.metadata = {
+    dependency_count: facts.dependencies.length,
+    dependency_names: facts.dependencies.map((dependency) => dependency.name).slice(0, 1e3),
+    truncated: facts.dependencies.length > 1e3
+  };
+  return finalize(facts);
+}
+function parseExtensionsMetadata(context, relative, text) {
+  const value = parseYamlRecord(context, text, "extensions metadata");
+  const nested = record(value.extensions);
+  const source = Object.keys(nested).length ? nested : value;
+  const extensions = Object.entries(source).flatMap(([name, raw]) => {
+    const row = record(raw);
+    if (!Object.keys(row).length) return [];
+    return [{
+      name,
+      status: string(row.status),
+      security_posture: string(row.security_posture),
+      categories: array(row.categories).map(String),
+      type_urls: array(row.type_urls).map(String)
+    }];
+  }).sort((a, b) => a.name.localeCompare(b.name));
+  const facts = baseFacts(relative, "envoy-extensions-metadata", []);
+  facts.metadata = {
+    extension_count: extensions.length,
+    extensions: extensions.slice(0, 1e3),
+    truncated: extensions.length > 1e3
+  };
+  return finalize(facts);
+}
+function parseModuleBazelLock(context, relative, text) {
+  const value = parseJson(context, text);
+  const registryFiles = Object.keys(record(value.registryFileHashes));
+  const modules = registryFiles.flatMap((filename) => {
+    const match = filename.match(/\/modules\/([^/]+)\/([^/]+)\//);
+    return match?.[1] && match[2] ? [{ name: decodeURIComponent(match[1]), resolved: decodeURIComponent(match[2]), dev: false }] : [];
+  });
+  const moduleExtensions = Object.keys(record(value.moduleExtensions)).sort();
+  const facts = baseFacts(relative, "bazel-module-lock", []);
+  facts.dependencies = dedupeDependencies(modules);
+  facts.frameworks = bazelFramework(context);
+  facts.metadata = {
+    lock_file_version: typeof value.lockFileVersion === "number" ? value.lockFileVersion : string(value.lockFileVersion),
+    registry_file_count: registryFiles.length,
+    module_extension_count: moduleExtensions.length,
+    module_extensions: moduleExtensions.slice(0, 500),
+    generated_repository_count: countRecordEntriesNamed(value, "generatedRepoSpecs", context.limits.maxNestingDepth),
+    truncated: moduleExtensions.length > 500
+  };
+  return finalize(facts);
+}
+function parseBazelRc(context, relative, text) {
+  const commandCounts = /* @__PURE__ */ new Map();
+  const configs = /* @__PURE__ */ new Set();
+  const imports = [];
+  let optionCount = 0;
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.replace(/\s+#.*$/, "").trim();
+    if (!line || line.startsWith("#")) continue;
+    const [selector = "", ...options] = line.split(/\s+/);
+    if (selector === "import" || selector === "try-import") {
+      if (options[0]) imports.push(options[0]);
+      continue;
+    }
+    const [command = selector, config] = selector.split(":", 2);
+    commandCounts.set(command, (commandCounts.get(command) ?? 0) + 1);
+    if (config) configs.add(config);
+    optionCount += options.length;
+  }
+  const facts = baseFacts(relative, "bazel-config", []);
+  facts.frameworks = bazelFramework(context);
+  facts.metadata = {
+    commands: [...commandCounts].sort(([a], [b]) => a.localeCompare(b)).map(([command, lines]) => ({ command, lines })),
+    configs: [...configs].sort(),
+    imports: [...new Set(imports)].sort(),
+    option_count: optionCount
+  };
+  return finalize(facts);
+}
+function parseBazelVersion(relative, text) {
+  const version = text.trim() || void 0;
+  const facts = baseFacts(relative, "bazel-version", []);
+  facts.frameworks = [{ name: "Bazel", version, kind: "build" }];
+  facts.runtimes = version ? [{ name: "Bazel", version }] : [];
+  facts.metadata = { version };
+  return finalize(facts);
+}
+function parseBazel(context, relative, text) {
+  const base = path4.posix.basename(relative);
+  const kind = base.startsWith("BUILD") ? "bazel-build" : "bazel-workspace";
+  const dependencies = [...text.matchAll(/bazel_dep\s*\(\s*name\s*=\s*["']([^"']+)["'][\s\S]*?version\s*=\s*["']([^"']+)["']/g)].map((match) => ({ name: match[1], resolved: match[2], dev: false }));
+  const moduleCall = text.match(/module\s*\(([\s\S]*?)\)/)?.[1] ?? "";
+  const facts = baseFacts(relative, kind, []);
+  facts.product = { name: attribute(moduleCall, "name"), version: attribute(moduleCall, "version") };
+  facts.dependencies = dependencies;
+  facts.frameworks = bazelFramework(context);
+  facts.metadata = {
+    rule_count: [...text.matchAll(/(?:^|\n)\s*([a-zA-Z_][\w.]*)\s*\(/g)].length,
+    targets: [...text.matchAll(/\bname\s*=\s*["']([^"']+)["']/g)].map((match) => match[1]).slice(0, 500)
+  };
+  return finalize(facts);
+}
+function parseCmake(relative, text) {
+  const project = text.match(/project\s*\(\s*([^\s)]+)(?:\s+VERSION\s+([^\s)]+))?/i);
+  const facts = baseFacts(relative, "cmake", []);
+  facts.product = { name: project?.[1], version: project?.[2] };
+  facts.frameworks = [{ name: "CMake", version: text.match(/cmake_minimum_required\s*\(\s*VERSION\s+([^\s)]+)/i)?.[1], kind: "build" }];
+  return finalize(facts);
+}
+function parseDockerfile(relative, text) {
+  const images = [...text.matchAll(/^FROM\s+([^\s]+)(?:\s+AS\s+([^\s]+))?/gim)].map((match) => ({ image: match[1], stage: match[2] }));
+  const facts = baseFacts(relative, "docker", images.length ? [] : ["Dockerfile contains no FROM instruction"]);
+  facts.frameworks = [{ name: "Docker", kind: "build" }];
+  facts.metadata = { images };
+  return finalize(facts);
+}
+function parseWorkflow(context, relative, text) {
+  const value = parseYamlRecord(context, text, "GitHub Actions workflow");
+  if (!("jobs" in value) || !value.jobs || typeof value.jobs !== "object" || Array.isArray(value.jobs)) {
+    throw new Error("GitHub Actions workflow must contain a jobs mapping");
+  }
+  const jobs = Object.entries(record(value.jobs)).map(([id, row]) => ({ id, name: string(record(row).name) ?? id, uses: string(record(row).uses) }));
+  const facts = baseFacts(relative, "github-actions", []);
+  facts.metadata = { name: string(value.name), jobs };
+  return finalize(facts);
+}
+function baseFacts(relative, kind, errors) {
+  return { id: "pending", path: relative, kind, dependencies: [], frameworks: [], runtimes: [], metadata: {}, errors };
+}
+function linkInternalMavenManifests(facts, limits) {
+  const byCoordinate = /* @__PURE__ */ new Map();
+  for (const fact of facts) {
+    if (fact.kind !== "maven" || typeof fact.metadata.manifest_alias_target === "string") continue;
+    const coordinate = typeof fact.metadata.coordinate === "string" ? fact.metadata.coordinate : void 0;
+    if (!coordinate) continue;
+    const candidate = {
+      coordinate,
+      path: fact.path,
+      ...fact.product?.version ? { version: fact.product.version } : {},
+      ...typeof fact.metadata.platform === "string" ? { platform: fact.metadata.platform } : {}
+    };
+    const candidates = byCoordinate.get(coordinate) ?? [];
+    candidates.push(candidate);
+    byCoordinate.set(coordinate, candidates);
+  }
+  for (const candidates of byCoordinate.values()) candidates.sort((a, b) => a.path.localeCompare(b.path));
+  return facts.map((fact) => {
+    if (fact.kind !== "maven" || typeof fact.metadata.manifest_alias_target === "string") return fact;
+    const sourcePlatform = typeof fact.metadata.platform === "string" ? fact.metadata.platform : void 0;
+    const managed = valueArray(fact.metadata.managed_dependencies).flatMap((value) => {
+      const row = record(value);
+      const name = string(row.name);
+      if (!name) return [];
+      return [{ name, declared: string(row.declared), resolved: string(row.resolved), dev: Boolean(row.dev), managed: true }];
+    });
+    const dependencies = [
+      ...fact.dependencies.map((dependency) => ({ ...dependency, managed: false })),
+      ...managed
+    ];
+    const linked = [];
+    const ambiguities = [];
+    for (const dependency of dependencies) {
+      let candidates = (byCoordinate.get(dependency.name) ?? []).filter((candidate2) => candidate2.path !== fact.path);
+      if (!candidates.length) continue;
+      const version = dependency.resolved ?? dependency.declared;
+      if (version) {
+        if (version.includes("${") || /^[[(]/.test(version)) continue;
+        candidates = candidates.filter((candidate2) => candidate2.version === version);
+        if (!candidates.length) continue;
+      }
+      if (candidates.length > 1 && sourcePlatform) {
+        const samePlatform = candidates.filter((candidate2) => candidate2.platform === sourcePlatform);
+        if (samePlatform.length) candidates = samePlatform;
+      }
+      if (candidates.length !== 1) {
+        ambiguities.push({
+          coordinate: dependency.name,
+          ...version ? { version } : {},
+          ...sourcePlatform ? { platform: sourcePlatform } : {},
+          candidate_count: candidates.length
+        });
+        continue;
+      }
+      const candidate = candidates[0];
+      linked.push({
+        coordinate: dependency.name,
+        path: candidate.path,
+        ...version ? { version } : {},
+        ...candidate.platform ? { platform: candidate.platform } : {},
+        managed: dependency.managed
+      });
+    }
+    const uniqueLinks = dedupeBy(
+      linked.sort((a, b) => a.coordinate.localeCompare(b.coordinate) || a.path.localeCompare(b.path) || Number(a.managed) - Number(b.managed)),
+      (entry) => `${entry.coordinate}:${entry.path}:${entry.managed}`
+    );
+    const uniqueAmbiguities = dedupeBy(
+      ambiguities.sort((a, b) => a.coordinate.localeCompare(b.coordinate) || (a.version ?? "").localeCompare(b.version ?? "")),
+      (entry) => `${entry.coordinate}:${entry.version ?? ""}:${entry.platform ?? ""}:${entry.candidate_count}`
+    );
+    const metadata = { ...fact.metadata };
+    if (uniqueLinks.length) {
+      metadata.internal_dependency_paths = [...new Set(uniqueLinks.map((entry) => entry.path))].sort();
+      metadata.internal_dependencies = uniqueLinks;
+    }
+    if (uniqueAmbiguities.length) metadata.ambiguous_internal_dependencies = uniqueAmbiguities;
+    return enforceFactBounds({ ...fact, metadata, errors: [...fact.errors] }, limits);
+  });
+}
+function finalize(input) {
+  input.id = `manifest_${hashObject({ path: input.path, kind: input.kind, product: input.product, dependencies: input.dependencies, frameworks: input.frameworks, runtimes: input.runtimes, scripts: input.scripts, workspaces: input.workspaces, aliases: input.aliases, metadata: input.metadata, errors: input.errors }).slice(0, 24)}`;
+  input.frameworks = dedupeBy(input.frameworks, (item) => `${item.name}:${item.version ?? ""}:${item.kind}`);
+  input.runtimes = dedupeBy(input.runtimes, (item) => `${item.name}:${item.version ?? ""}`);
+  return manifestFactsSchema.parse(input);
+}
+function enforceFactBounds(input, limits) {
+  const overflows = [];
+  const truncate = (label, items) => {
+    if (items.length <= limits.maxExtractedEntries) return items;
+    overflows.push(`resource limit exceeded: ${label}=${items.length}; maxExtractedEntries=${limits.maxExtractedEntries}`);
+    return items.slice(0, limits.maxExtractedEntries);
+  };
+  input.dependencies = truncate("dependencies", input.dependencies);
+  input.frameworks = truncate("frameworks", input.frameworks);
+  input.runtimes = truncate("runtimes", input.runtimes);
+  if (input.workspaces) input.workspaces = truncate("workspaces", input.workspaces);
+  if (input.aliases) {
+    input.aliases = truncate("aliases", input.aliases).map((alias) => ({
+      ...alias,
+      targets: truncate(`alias targets (${alias.prefix})`, alias.targets)
+    }));
+  }
+  if (input.scripts) {
+    const entries = Object.entries(input.scripts);
+    if (entries.length > limits.maxExtractedEntries) {
+      overflows.push(`resource limit exceeded: scripts=${entries.length}; maxExtractedEntries=${limits.maxExtractedEntries}`);
+      input.scripts = Object.fromEntries(entries.slice(0, limits.maxExtractedEntries));
+    }
+  }
+  input.metadata = boundMetadata(input.metadata, "metadata", limits.maxExtractedEntries, overflows, 0, limits.maxNestingDepth);
+  input.errors = [.../* @__PURE__ */ new Set([...input.errors, ...overflows])];
+  return finalize(input);
+}
+function boundMetadata(value, label, maximum, errors, depth, maxDepth) {
+  if (depth > maxDepth) {
+    errors.push(`resource limit exceeded: ${label} depth exceeds maxNestingDepth=${maxDepth}`);
+    return null;
+  }
+  if (Array.isArray(value)) {
+    if (value.length > maximum) errors.push(`resource limit exceeded: ${label}=${value.length}; maxExtractedEntries=${maximum}`);
+    return value.slice(0, maximum).map((item, index) => boundMetadata(item, `${label}[${index}]`, maximum, errors, depth + 1, maxDepth));
+  }
+  if (!value || typeof value !== "object") return value;
+  const entries = Object.entries(value);
+  if (entries.length > maximum) errors.push(`resource limit exceeded: ${label} keys=${entries.length}; maxExtractedEntries=${maximum}`);
+  return Object.fromEntries(entries.slice(0, maximum).map(([key, item]) => [
+    key,
+    boundMetadata(item, `${label}.${key}`, maximum, errors, depth + 1, maxDepth)
+  ]));
+}
+function resolveLimits(options) {
+  const limits = { ...DEFAULT_MANIFEST_PARSE_LIMITS, ...options };
+  for (const [name, value] of Object.entries(limits)) {
+    if (!Number.isSafeInteger(value) || value <= 0) throw new Error(`${name} must be a positive safe integer`);
+  }
+  if (limits.maxTsconfigExtendsDepth > 5) throw new Error("maxTsconfigExtendsDepth cannot exceed the execution contract limit of 5");
+  if (limits.maxTotalBytes < limits.maxManifestBytes) throw new Error("maxTotalBytes cannot be lower than maxManifestBytes");
+  return limits;
+}
+function readRepoText(context, relativeInput) {
+  const relative = normalizeRepoPath(relativeInput);
+  const cached = context.cache.get(relative);
+  if (cached) {
+    if (!cached.ok) throw new Error(cached.error);
+    return cached.text;
+  }
+  const absolute = assertInside(context.root, path4.join(context.root, ...relative.split("/")));
+  const flags = fs2.constants.O_RDONLY | (fs2.constants.O_NOFOLLOW ?? 0);
+  let descriptor;
+  const chunks = [];
+  let bytes = 0;
+  try {
+    descriptor = fs2.openSync(absolute, flags);
+    const stat = fs2.fstatSync(descriptor);
+    if (!stat.isFile()) throw new Error("safe-read rejected non-regular manifest");
+    if (stat.size > context.limits.maxManifestBytes) {
+      throw new Error(`resource limit exceeded: file bytes=${stat.size}; maxManifestBytes=${context.limits.maxManifestBytes}`);
+    }
+    if (context.totalBytes + stat.size > context.limits.maxTotalBytes) {
+      throw new Error(`resource limit exceeded: total unique bytes would exceed maxTotalBytes=${context.limits.maxTotalBytes}`);
+    }
+    const buffer = Buffer.allocUnsafe(64 * 1024);
+    while (true) {
+      const read = fs2.readSync(descriptor, buffer, 0, buffer.length, null);
+      if (!read) break;
+      bytes += read;
+      if (bytes > context.limits.maxManifestBytes) {
+        throw new Error(`resource limit exceeded: file grew beyond maxManifestBytes=${context.limits.maxManifestBytes}`);
+      }
+      if (context.totalBytes + bytes > context.limits.maxTotalBytes) {
+        throw new Error(`resource limit exceeded: total unique bytes exceed maxTotalBytes=${context.limits.maxTotalBytes}`);
+      }
+      chunks.push(Buffer.from(buffer.subarray(0, read)));
+    }
+    context.totalBytes += bytes;
+    const text = Buffer.concat(chunks, bytes).toString("utf8");
+    context.cache.set(relative, { ok: true, text, bytes });
+    return text;
+  } catch (error) {
+    const detail = message(error);
+    context.cache.set(relative, { ok: false, error: detail });
+    throw new Error(detail);
+  } finally {
+    if (descriptor !== void 0) fs2.closeSync(descriptor);
+  }
+}
+function tryReadRepoText(context, relative) {
+  try {
+    return readRepoText(context, relative);
+  } catch {
+    return void 0;
+  }
+}
+function validateManifestText(text, limits) {
+  let lineBytes = 0;
+  let depth = 0;
+  let quote;
+  let escaped = false;
+  for (let index = 0; index < text.length; index += 1) {
+    const character = text[index];
+    lineBytes += Buffer.byteLength(character);
+    if (lineBytes > limits.maxLineBytes) throw new Error(`resource limit exceeded: line bytes exceed maxLineBytes=${limits.maxLineBytes}`);
+    if (character === "\n") {
+      lineBytes = 0;
+      continue;
+    }
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (character === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (character === quote) quote = void 0;
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      continue;
+    }
+    if (character === "{" || character === "[") {
+      depth += 1;
+      if (depth > limits.maxNestingDepth) throw new Error(`resource limit exceeded: nesting depth exceeds maxNestingDepth=${limits.maxNestingDepth}`);
+    } else if ((character === "}" || character === "]") && depth > 0) depth -= 1;
+  }
+}
+function parseJson(context, text, jsonc = false) {
+  const source = jsonc ? stripJsonComments(text).replace(/,\s*([}\]])/g, "$1") : text;
+  validateManifestText(source, context.limits);
+  const value = JSON.parse(source);
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("JSON manifest root must be an object");
+  return value;
+}
+function parseYaml(context, text) {
+  return YAML.parse(text, { maxAliasCount: context.limits.maxYamlAliases });
+}
+function parseYamlRecord(context, text, label) {
+  const value = parseYaml(context, text);
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} root must be a mapping`);
+  return value;
+}
+function inferFrameworks(dependencies) {
+  return dependencies.flatMap((dependency) => {
+    const mapping = FRAMEWORKS[dependency.name.toLowerCase()];
+    return mapping ? [{ ...mapping, version: dependency.resolved ?? dependency.declared }] : [];
+  });
+}
+function npmResolvedVersions(context, relativeDir) {
+  const result = /* @__PURE__ */ new Map();
+  const directories = [.../* @__PURE__ */ new Set([relativeDir, ""])];
+  for (const directory of directories) {
+    const packageLock = joinRepoPath(directory, "package-lock.json");
+    try {
+      const text = tryReadRepoText(context, packageLock);
+      if (text) {
+        const value = parseJson(context, text);
+        const packages = record(value.packages);
+        for (const [key, raw] of Object.entries(packages)) if (key.startsWith("node_modules/")) {
+          const version = string(record(raw).version);
+          if (version) result.set(key.slice("node_modules/".length), version);
+        }
+        for (const [name, raw] of Object.entries(record(value.dependencies))) {
+          const version = string(record(raw).version);
+          if (version) result.set(name, version);
+        }
+      }
+    } catch {
+    }
+    const pnpmText = tryReadRepoText(context, joinRepoPath(directory, "pnpm-lock.yaml"));
+    if (pnpmText) for (const dependency of pnpmResolvedDependencies(context, pnpmText)) {
+      if (dependency.resolved && !result.has(dependency.name)) result.set(dependency.name, dependency.resolved);
+    }
+    const yarnText = tryReadRepoText(context, joinRepoPath(directory, "yarn.lock"));
+    if (yarnText) for (const dependency of yarnResolvedDependencies(context, yarnText)) {
+      if (dependency.resolved && !result.has(dependency.name)) result.set(dependency.name, dependency.resolved);
+    }
+    if (result.size) return result;
+  }
+  return result;
+}
+function pubspecResolvedVersions(context, relativeDir) {
+  const result = /* @__PURE__ */ new Map();
+  try {
+    const text = tryReadRepoText(context, joinRepoPath(relativeDir, "pubspec.lock"));
+    if (!text) return result;
+    const value = parseYamlRecord(context, text, "pubspec.lock");
+    for (const [name, raw] of Object.entries(record(value.packages))) {
+      const version = string(record(raw).version);
+      if (version) result.set(name, version);
+    }
+  } catch {
+  }
+  return result;
+}
+function bazelFramework(context) {
+  let version;
+  try {
+    version = tryReadRepoText(context, ".bazelversion")?.trim() || void 0;
+  } catch {
+  }
+  return [{ name: "Bazel", version, kind: "build" }];
+}
+function pnpmResolvedDependencies(context, text) {
+  const value = parseYamlRecord(context, text, "pnpm-lock.yaml");
+  const snapshots = { ...record(value.packages), ...record(value.snapshots) };
+  const dependencies = Object.keys(snapshots).flatMap((key) => {
+    const cleaned = key.replace(/^\//, "").replace(/\(.+\)$/, "");
+    const modern = cleaned.match(/^(@[^/]+\/[^@]+|[^@/]+)@(.+)$/);
+    if (modern?.[1] && modern[2]) return [{ name: modern[1], resolved: modern[2], dev: false }];
+    const legacy = cleaned.match(/^(@[^/]+\/[^/]+|[^/]+)\/(.+)$/);
+    return legacy?.[1] && legacy[2] ? [{ name: legacy[1], resolved: legacy[2], dev: false }] : [];
+  });
+  return dedupeDependencies(dependencies);
+}
+function yarnResolvedDependencies(context, text) {
+  if (/^__metadata\s*:/m.test(text)) {
+    const value = parseYamlRecord(context, text, "yarn.lock");
+    const dependencies2 = Object.entries(value).flatMap(([selector, raw]) => {
+      if (selector === "__metadata") return [];
+      const row = record(raw);
+      const resolved = string(row.version);
+      return yarnSelectorNames(selector).map((name) => ({ name, resolved, dev: false }));
+    });
+    return dedupeDependencies(dependencies2);
+  }
+  const dependencies = [];
+  let selectors = [];
+  for (const line of text.split(/\r?\n/)) {
+    if (line && !/^\s/.test(line) && line.endsWith(":")) {
+      selectors = yarnSelectorNames(line.slice(0, -1));
+      continue;
+    }
+    const version = line.match(/^\s+version(?:\s+|:\s*)["']?([^"'\s]+)["']?\s*$/)?.[1];
+    if (!version || !selectors.length) continue;
+    dependencies.push(...selectors.map((name) => ({ name, resolved: version, dev: false })));
+    selectors = [];
+  }
+  return dedupeDependencies(dependencies);
+}
+function yarnSelectorNames(raw) {
+  return raw.split(/,\s*(?=["']?@?[^"']+@)/).flatMap((part) => {
+    const selector = part.trim().replace(/^["']|["']$/g, "");
+    const match = selector.match(/^(@[^/]+\/[^@]+|[^@]+)@/);
+    return match?.[1] ? [match[1]] : [];
+  });
+}
+function gemResolvedVersions(context, relativeDir) {
+  const result = /* @__PURE__ */ new Map();
+  const text = tryReadRepoText(context, joinRepoPath(relativeDir, "Gemfile.lock"));
+  if (!text) return result;
+  const facts = parseGemfileLock(joinRepoPath(relativeDir, "Gemfile.lock"), text);
+  for (const dependency of facts.dependencies) if (dependency.resolved) result.set(dependency.name, dependency.resolved);
+  return result;
+}
+function composerResolvedVersions(context, relativeDir) {
+  const result = /* @__PURE__ */ new Map();
+  const text = tryReadRepoText(context, joinRepoPath(relativeDir, "composer.lock"));
+  if (!text) return result;
+  try {
+    const value = parseJson(context, text);
+    for (const raw of [...array(value.packages), ...array(value["packages-dev"])]) {
+      const row = record(raw);
+      const name = string(row.name);
+      const version = string(row.version);
+      if (name && version) result.set(name, version);
+    }
+  } catch {
+  }
+  return result;
+}
+function composerScripts(value) {
+  const entries = Object.entries(record(value)).flatMap(([name, command]) => {
+    if (typeof command === "string") return [[name, command]];
+    if (Array.isArray(command) && command.every((item) => typeof item === "string")) return [[name, command.join(" && ")]];
+    return [];
+  });
+  return entries.length ? Object.fromEntries(entries) : void 0;
+}
+function tsconfigExtends(value) {
+  if (typeof value === "string") return [value];
+  return array(value).flatMap((entry) => typeof entry === "string" ? [entry] : []);
+}
+function resolveTsconfigExtends(from, specifier) {
+  if (!specifier.startsWith(".")) return void 0;
+  const base = path4.posix.normalize(path4.posix.join(path4.posix.dirname(from), specifier));
+  const withExtension = /\.json$/i.test(base) ? base : `${base}.json`;
+  return normalizeRepoPath(withExtension);
+}
+function mergeTsconfigLayers(left, right) {
+  const rightHasPaths = Object.prototype.hasOwnProperty.call(right.compiler, "paths");
+  const rightHasBaseUrl = Object.prototype.hasOwnProperty.call(right.compiler, "baseUrl");
+  return {
+    compiler: { ...left.compiler, ...right.compiler },
+    chain: [...left.chain, ...right.chain],
+    externalExtends: [...left.externalExtends, ...right.externalExtends],
+    pathsOrigin: rightHasPaths ? right.pathsOrigin : left.pathsOrigin,
+    baseUrlOrigin: rightHasBaseUrl ? right.baseUrlOrigin : left.baseUrlOrigin
+  };
+}
+function normalizeRelativeJoin(fromDirectory, originDirectory, baseUrl) {
+  const originBase = path4.posix.normalize(path4.posix.join(originDirectory, baseUrl || "."));
+  const result = path4.posix.relative(fromDirectory === "." ? "" : fromDirectory, originBase);
+  return result || ".";
+}
+function joinRepoPath(directory, filename) {
+  return directory && directory !== "." ? `${directory}/${filename}` : filename;
+}
+function starlarkRepositoryEntries(text) {
+  const entries = [];
+  const pattern = /(?:^|\n)[ \t]*(?:["']([^"']+)["']|([A-Za-z_][A-Za-z0-9_]*))[ \t]*(?:=|:)[ \t]*dict[ \t]*\(/g;
+  for (const match of text.matchAll(pattern)) {
+    const name = match[1] ?? match[2];
+    if (!name || /^[A-Z][A-Z0-9_]*$/.test(name) || match.index === void 0) continue;
+    const open = match.index + match[0].lastIndexOf("(");
+    const body = balancedParenthesisBody(text, open);
+    if (body === void 0) continue;
+    const entry = {
+      name,
+      project_name: attribute(body, "project_name"),
+      version: attribute(body, "version"),
+      project_url: attribute(body, "project_url"),
+      release_date: attribute(body, "release_date"),
+      sha256: attribute(body, "sha256")
+    };
+    if (!entry.project_name && !entry.version && !entry.project_url && !entry.sha256) continue;
+    entries.push(entry);
+  }
+  return dedupeBy(entries.sort((a, b) => a.name.localeCompare(b.name)), (entry) => entry.name);
+}
+function balancedParenthesisBody(text, open) {
+  if (text[open] !== "(") return void 0;
+  let depth = 0;
+  let quote;
+  for (let index = open; index < text.length; index++) {
+    if (quote) {
+      if (text[index] === "\\") {
+        index++;
+        continue;
+      }
+      if (text.startsWith(quote, index)) {
+        index += quote.length - 1;
+        quote = void 0;
+      }
+      continue;
+    }
+    if (text.startsWith('"""', index) || text.startsWith("'''", index)) {
+      quote = text.startsWith('"""', index) ? '"""' : "'''";
+      index += 2;
+      continue;
+    }
+    if (text[index] === '"' || text[index] === "'") {
+      quote = text[index];
+      continue;
+    }
+    if (text[index] === "(") depth++;
+    if (text[index] === ")" && --depth === 0) return text.slice(open + 1, index);
+  }
+  return void 0;
+}
+function collectYamlDependencies(value, nameHint, output = [], seen = /* @__PURE__ */ new WeakSet(), depth = 0, maxDepth = DEFAULT_MANIFEST_PARSE_LIMITS.maxNestingDepth) {
+  if (depth > maxDepth) throw new Error(`resource limit exceeded: YAML value depth exceeds maxNestingDepth=${maxDepth}`);
+  if (Array.isArray(value)) {
+    if (seen.has(value)) return output;
+    seen.add(value);
+    for (const item of value) collectYamlDependencies(item, void 0, output, seen, depth + 1, maxDepth);
+    return output;
+  }
+  const row = record(value);
+  if (!Object.keys(row).length) return output;
+  if (seen.has(row)) return output;
+  seen.add(row);
+  const explicitName = string(row.name) ?? string(row.repository) ?? string(row.repo) ?? string(row.canonical_name) ?? string(row.project_name);
+  const resolved = string(row.version) ?? string(row.release) ?? string(row.tag) ?? string(row.commit) ?? string(row.revision);
+  const locator = resolved ?? string(row.sha256) ?? string(row.project_url) ?? string(row.url);
+  const name = explicitName ?? (nameHint && locator ? nameHint : void 0);
+  if (name && locator) output.push({ name, ...resolved ? { declared: resolved, resolved } : {}, dev: Boolean(row.dev) });
+  for (const [key, item] of Object.entries(row)) if (item && typeof item === "object") collectYamlDependencies(item, key, output, seen, depth + 1, maxDepth);
+  return output;
+}
+function countRecordEntriesNamed(value, keyName, maxDepth) {
+  let count = 0;
+  const seen = /* @__PURE__ */ new WeakSet();
+  const pending = [{ value, depth: 0 }];
+  while (pending.length) {
+    const current = pending.pop();
+    if (current.depth > maxDepth) throw new Error(`resource limit exceeded: JSON value depth exceeds maxNestingDepth=${maxDepth}`);
+    if (!current.value || typeof current.value !== "object") continue;
+    if (seen.has(current.value)) continue;
+    seen.add(current.value);
+    if (Array.isArray(current.value)) {
+      for (const item of current.value) pending.push({ value: item, depth: current.depth + 1 });
+      continue;
+    }
+    for (const [key, item] of Object.entries(current.value)) {
+      if (key === keyName) count += Object.keys(record(item)).length;
+      pending.push({ value: item, depth: current.depth + 1 });
+    }
+  }
+  return count;
+}
+function parseTomlDependencies(text, dev) {
+  return text.split(/\r?\n/).flatMap((line) => {
+    const match = line.match(/^\s*([A-Za-z0-9_.-]+)\s*=\s*(.+?)\s*(?:#.*)?$/);
+    if (!match?.[1] || !match[2]) return [];
+    const quotedVersion = match[2].match(/["']([^"']+)["']/)?.[1];
+    const inlineVersion = match[2].match(/\bversion\s*=\s*["']([^"']+)["']/)?.[1];
+    return [{ name: match[1], declared: inlineVersion ?? quotedVersion, dev }];
+  });
+}
+function section(text, name) {
+  const lines = text.split(/\r?\n/);
+  const wanted = `[${name}]`;
+  const body = [];
+  let found = false;
+  for (const line of lines) {
+    const candidate = line.replace(/\s+#.*$/, "").trim();
+    if (candidate === wanted) {
+      found = true;
+      continue;
+    }
+    if (found && /^\[\[?.+\]\]?$/.test(candidate)) break;
+    if (found) body.push(line);
+  }
+  return body.join("\n");
+}
+function sectionsMatching(text, pattern) {
+  const output = [];
+  let active;
+  for (const line of text.split(/\r?\n/)) {
+    const header = line.replace(/\s+#.*$/, "").trim().match(/^\[([^\]]+)\]$/)?.[1];
+    if (header) {
+      if (active) output.push({ name: active.name, body: active.lines.join("\n") });
+      active = pattern.test(header) ? { name: header, lines: [] } : void 0;
+      pattern.lastIndex = 0;
+      continue;
+    }
+    active?.lines.push(line);
+  }
+  if (active) output.push({ name: active.name, body: active.lines.join("\n") });
+  return output;
+}
+function quoted(text, key) {
+  const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return text.match(new RegExp(`^\\s*${escaped}\\s*=\\s*["']([^"']+)["']`, "m"))?.[1];
+}
+function attribute(text, key) {
+  const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return text.match(new RegExp(`\\b${escaped}\\s*=\\s*["']([^"']+)["']`))?.[1];
+}
+function yamlVersion(value) {
+  if (typeof value === "string" || typeof value === "number") return String(value);
+  const row = record(value);
+  return string(row.version) ?? string(row.path) ?? string(row.git);
+}
+function stripJsonComments(value) {
+  let output = "";
+  let state = "code";
+  for (let index = 0; index < value.length; index += 1) {
+    const character = value[index] ?? "";
+    const next = value[index + 1] ?? "";
+    if (state === "string") {
+      output += character;
+      if (character === "\\" && next) {
+        output += next;
+        index += 1;
+      } else if (character === '"') state = "code";
+      continue;
+    }
+    if (state === "line") {
+      if (character === "\n") {
+        output += "\n";
+        state = "code";
+      } else output += " ";
+      continue;
+    }
+    if (state === "block") {
+      if (character === "*" && next === "/") {
+        output += "  ";
+        index += 1;
+        state = "code";
+      } else output += character === "\n" ? "\n" : " ";
+      continue;
+    }
+    if (character === '"') {
+      output += character;
+      state = "string";
+      continue;
+    }
+    if (character === "/" && next === "/") {
+      output += "  ";
+      index += 1;
+      state = "line";
+      continue;
+    }
+    if (character === "/" && next === "*") {
+      output += "  ";
+      index += 1;
+      state = "block";
+      continue;
+    }
+    output += character;
+  }
+  return output;
+}
+function manifestKind(base) {
+  return base.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "manifest";
+}
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function string(value) {
+  return typeof value === "string" || typeof value === "number" ? String(value) : void 0;
+}
+function array(value) {
+  return Array.isArray(value) ? value : [];
+}
+function stringRecord(value) {
+  const entries = Object.entries(record(value)).flatMap(([key, item]) => typeof item === "string" ? [[key, item]] : []);
+  return entries.length ? Object.fromEntries(entries) : void 0;
+}
+function dedupeDependencies(items) {
+  return dedupeBy(items.sort((a, b) => a.name.localeCompare(b.name)), (item) => `${item.name}:${item.resolved ?? item.declared ?? ""}:${item.dev}`);
+}
+function dedupeBy(items, key) {
+  const seen = /* @__PURE__ */ new Set();
+  return items.filter((item) => {
+    const value = key(item);
+    if (seen.has(value)) return false;
+    seen.add(value);
+    return true;
+  });
+}
+function message(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// ../packages/brain-census/src/stack.ts
+var DISPLAY = {
+  c: "C",
+  cpp: "C++",
+  csharp: "C#",
+  css: "CSS",
+  dart: "Dart",
+  elixir: "Elixir",
+  go: "Go",
+  graphql: "GraphQL",
+  html: "HTML",
+  java: "Java",
+  javascript: "JavaScript",
+  json: "JSON",
+  kotlin: "Kotlin",
+  lua: "Lua",
+  "objective-c": "Objective-C",
+  perl: "Perl",
+  php: "PHP",
+  proto: "Protobuf",
+  python: "Python",
+  ruby: "Ruby",
+  rust: "Rust",
+  scala: "Scala",
+  shell: "Shell",
+  sql: "SQL",
+  starlark: "Starlark",
+  swift: "Swift",
+  toml: "TOML",
+  typescript: "TypeScript",
+  vue: "Vue",
+  xml: "XML",
+  yaml: "YAML"
+};
+function synthesizeStack(files, manifests) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    if (!file.language || !["source", "test", "generated"].includes(file.class)) continue;
+    const current = counts.get(file.language) ?? { files: 0, loc: 0 };
+    current.files++;
+    current.loc += file.loc;
+    counts.set(file.language, current);
+  }
+  const totalLoc = [...counts.values()].reduce((sum, item) => sum + item.loc, 0);
+  const languages = [...counts.entries()].map(([language, value]) => ({ language, ...value, share: totalLoc ? value.loc / totalLoc : 0 })).sort((a, b) => b.loc - a.loc || a.language.localeCompare(b.language));
+  const frameworks = dedupe(manifests.flatMap((manifest) => manifest.frameworks), (item) => `${item.name}:${item.version ?? ""}:${item.kind}`);
+  const runtimes = dedupe(manifests.flatMap((manifest) => manifest.runtimes), (item) => `${item.name}:${item.version ?? ""}`);
+  const failures = manifests.flatMap((manifest) => manifest.errors.map((error) => `${manifest.path}: ${error}`));
+  if (!languages.length && !manifests.length) failures.push("no source language or supported manifest was detected");
+  const primaryFrameworks = summaryFrameworks(frameworks.filter((framework) => !["build", "test"].includes(framework.kind)));
+  const buildFrameworks = summaryFrameworks(frameworks.filter((framework) => framework.kind === "build"));
+  const summaryParts = [
+    ...primaryFrameworks.slice(0, 4).map(formatVersioned),
+    ...languages.filter((language) => language.share >= 0.05 || language === languages[0]).slice(0, 5).map((language) => DISPLAY[language.language]),
+    ...buildFrameworks.slice(0, 2).map(formatVersioned)
+  ];
+  const summary = [...new Set(summaryParts)].join(" \xB7 ") || "UNMAPPED";
+  const body = { summary, languages, frameworks, runtimes, manifests: manifests.length, failures };
+  return { id: `stack_${hashObject(body).slice(0, 24)}`, ...body };
+}
+function summaryFrameworks(items) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const current = byName.get(item.name);
+    if (!current || !current.version && item.version) byName.set(item.name, item);
+  }
+  return [...byName.values()];
+}
+function formatVersioned(item) {
+  return item.version ? `${item.name} ${item.version}` : item.name;
+}
+function dedupe(items, key) {
+  const seen = /* @__PURE__ */ new Set();
+  return items.filter((item) => {
+    const value = key(item);
+    if (seen.has(value)) return false;
+    seen.add(value);
+    return true;
+  });
+}
+
+// ../packages/brain-census/src/docs.ts
+function chunkMarkdown(path8, markdown, options = {}) {
+  const targetChars = options.targetChars ?? 1200;
+  const maxChars = options.maxChars ?? 2e3;
+  const normalized = markdown.replace(/\r\n?/g, "\n");
+  const lines = normalized.split("\n");
+  const chunks = [];
+  let breadcrumb = [];
+  let buffer = [];
+  let startLine = 1;
+  let searchCharacterOffset = 0;
+  let searchByteOffset = 0;
+  const flush = () => {
+    const content = buffer.join("\n").trim();
+    if (!content) {
+      buffer = [];
+      return;
+    }
+    for (let offset = 0; offset < content.length; offset += maxChars) {
+      const part = content.slice(offset, offset + maxChars).trim();
+      if (!part) continue;
+      const lineOffset = content.slice(0, offset).split("\n").length - 1;
+      const partLines = part.split("\n").length;
+      const heading = breadcrumb.join(" > ") || "Document";
+      const contentHash = sha256(part);
+      const partCharacterOffset = normalized.indexOf(part, searchCharacterOffset);
+      if (partCharacterOffset < 0) throw new Error(`document chunk cannot be mapped back to ${path8}`);
+      const startByte = searchByteOffset + Buffer.byteLength(normalized.slice(searchCharacterOffset, partCharacterOffset), "utf8");
+      const endByte = startByte + Buffer.byteLength(part, "utf8");
+      searchCharacterOffset = partCharacterOffset + part.length;
+      searchByteOffset = endByte;
+      chunks.push({
+        id: `doc_${hashObject({ path: path8, heading, startLine: startLine + lineOffset, contentHash }).slice(0, 24)}`,
+        path: path8,
+        heading,
+        content: part,
+        contentHash,
+        startLine: startLine + lineOffset,
+        endLine: startLine + lineOffset + partLines - 1,
+        estimatedTokens: Math.ceil(part.length / 4),
+        startByte,
+        endByte,
+        trust: "untrusted_repository_text"
+      });
+    }
+    buffer = [];
+  };
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index];
+    const heading = line.match(/^(#{1,3})\s+(.+?)\s*#*$/);
+    if (heading?.[1] && heading[2]) {
+      flush();
+      const depth = heading[1].length;
+      breadcrumb = [...breadcrumb.slice(0, depth - 1), heading[2].trim()];
+      startLine = index + 2;
+      continue;
+    }
+    if (!buffer.length) startLine = index + 1;
+    buffer.push(line);
+    if (buffer.join("\n").length >= targetChars && !line.trim()) flush();
+  }
+  flush();
+  return chunks;
+}
+
+// ../packages/brain-census/src/test-map.ts
+import path5 from "path";
+var NATIVE_IMPLEMENTATION_EXTENSIONS = [".c", ".cc", ".cpp", ".cxx", ".m", ".mm"];
+var NATIVE_HEADER_EXTENSIONS = [".h", ".hh", ".hpp", ".hxx"];
+var NATIVE_TEST_EXTENSIONS = new Set(NATIVE_IMPLEMENTATION_EXTENSIONS);
+function genericConventionPaths(testPath, files) {
+  const directory = path5.posix.dirname(testPath);
+  const basename = path5.posix.basename(testPath);
+  const transformed = basename.replace(/\.(?:test|spec)(?=\.[^.]+$)/i, "").replace(/_(?:test|spec)(?=\.[^.]+$)/i, "").replace(/^test_(?=[^.]+\.[^.]+$)/i, "");
+  if (transformed === basename) return [];
+  const directories = /* @__PURE__ */ new Set([directory]);
+  const segments = directory === "." ? [] : directory.split("/");
+  for (let index = 0; index < segments.length; index += 1) {
+    if (!/^(?:__tests__|tests?|spec)$/.test(segments[index] ?? "")) continue;
+    const without = [...segments.slice(0, index), ...segments.slice(index + 1)].join("/") || ".";
+    directories.add(without);
+    if (index === 0) for (const root of ["src", "source", "lib"]) directories.add([root, ...segments.slice(1)].join("/"));
+  }
+  const exactExtension = [...directories].map((candidate) => path5.posix.join(candidate, transformed)).filter((candidate) => files.has(candidate));
+  if (exactExtension.length > 0) return exactExtension;
+  const extension = path5.posix.extname(transformed).toLowerCase();
+  if (!NATIVE_TEST_EXTENSIONS.has(extension)) return [];
+  const stem = transformed.slice(0, -extension.length);
+  const nativeCounterparts = [...directories].flatMap((directory2) => [...NATIVE_IMPLEMENTATION_EXTENSIONS, ...NATIVE_HEADER_EXTENSIONS].map((candidateExtension) => path5.posix.join(directory2, `${stem}${candidateExtension}`))).filter((candidate) => files.has(candidate));
+  return nativeCounterparts.length === 1 ? nativeCounterparts : [];
+}
+function javaModuleRoot(testPath, markerIndex) {
+  return testPath.split("/").slice(0, markerIndex).join("/");
+}
+function javaProductionModule(testModule) {
+  const segments = testModule.split("/");
+  const module = segments.at(-1) ?? "";
+  if (module.endsWith("-tests")) segments[segments.length - 1] = module.slice(0, -"-tests".length);
+  return segments.filter(Boolean).join("/");
+}
+function javaFlavor(filePath) {
+  return filePath === "android" || filePath.startsWith("android/") ? "android" : "jre";
+}
+function javaConventionPath(testPath, files) {
+  const basename = path5.posix.basename(testPath);
+  const match = /^(.+?)(?:Test|Tests|Spec)\.java$/.exec(basename);
+  if (!match?.[1]) return void 0;
+  const targetBasename = `${match[1]}.java`;
+  const segments = testPath.split("/");
+  const markerIndex = segments.findLastIndex((segment) => /^(?:test|test-super|tests)$/.test(segment));
+  if (markerIndex < 0) return void 0;
+  const packageSegments = segments.slice(markerIndex + 1, -1);
+  const packageSuffix = [...packageSegments, targetBasename].join("/");
+  const testModule = javaModuleRoot(testPath, markerIndex);
+  const expectedModule = javaProductionModule(testModule);
+  const candidates = [...files].filter((candidate) => {
+    if (candidate === testPath || path5.posix.basename(candidate) !== targetBasename) return false;
+    if (!(candidate === packageSuffix || candidate.endsWith(`/${packageSuffix}`))) return false;
+    return !/(?:^|\/)(?:test|test-super|tests)(?:\/|$)/.test(candidate);
+  });
+  return candidates.sort((left, right) => {
+    const score = (candidate) => {
+      let value = javaFlavor(candidate) === javaFlavor(testPath) ? 1e6 : 0;
+      if (candidate.startsWith(`${expectedModule}/`)) value += 2e5;
+      if (candidate.startsWith(`${testModule}/`)) value += 15e4;
+      if (/(?:^|\/)src(?:\/|$)/.test(candidate)) value += 1e4;
+      return value;
+    };
+    return score(right) - score(left) || left.localeCompare(right);
+  })[0];
+}
+function findConventionalSourcePaths(testPath, files) {
+  const results = genericConventionPaths(testPath, files);
+  if (testPath.endsWith(".java")) {
+    const java = javaConventionPath(testPath, files);
+    if (java) results.push(java);
+  }
+  return [...new Set(results)].sort();
+}
+
+// ../packages/brain-ast/src/query-assets.ts
+import fs4 from "fs";
+import path7 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { Query } from "web-tree-sitter";
+import { z as z3 } from "zod";
+
+// ../packages/brain-ast/src/grammar-registry.ts
+import fs3 from "fs";
+import path6 from "path";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { setFlagsFromString } from "v8";
+import { z as z2 } from "zod";
+import { LANGUAGE_VERSION, Language, MIN_COMPATIBLE_VERSION, Parser } from "web-tree-sitter";
+var grammarEntrySchema = z2.object({
+  id: z2.string().min(1),
+  languages: z2.array(z2.string().min(1)).min(1),
+  extensions: z2.array(z2.string().startsWith(".")).optional(),
+  file: z2.string().min(1),
+  package_subpath: z2.string().min(1),
+  sha256: z2.string().regex(/^[a-f0-9]{64}$/),
+  abi: z2.number().int().positive()
+}).strict();
+var grammarManifestSchema = z2.object({
+  schema_version: z2.literal(1),
+  runtime: z2.object({
+    package: z2.literal("web-tree-sitter"),
+    version: z2.string(),
+    license: z2.string(),
+    abi_min: z2.number().int(),
+    abi_max: z2.number().int()
+  }).strict(),
+  source_package: z2.object({
+    name: z2.literal("tree-sitter-wasms"),
+    version: z2.string(),
+    license: z2.string(),
+    repository: z2.string().url()
+  }).strict(),
+  grammars: z2.array(grammarEntrySchema).min(1)
+}).strict();
+var defaultAssetRoot = fileURLToPath(new URL("../assets", import.meta.url));
+var require2 = createRequire(import.meta.url);
+var manifestCache = /* @__PURE__ */ new Map();
+var languageCache = /* @__PURE__ */ new Map();
+var runtimeInitialization;
+var initializedCorePath;
+var boundedWasmCompilationConfigured = false;
+var grammarLoadTail = Promise.resolve();
+function readUnsignedLeb(bytes, offset) {
+  let value = 0;
+  let shift = 0;
+  for (let cursor = offset; cursor < bytes.length && shift <= 28; cursor += 1, shift += 7) {
+    const byte = bytes[cursor];
+    if (byte === void 0) break;
+    value += (byte & 127) * 2 ** shift;
+    if ((byte & 128) === 0) return { value, nextOffset: cursor + 1 };
+  }
+  throw new GrammarLoadError("grammar_integrity", "invalid unsigned LEB128 value in Tree-sitter core WASM");
+}
+function encodeUnsignedLeb(value) {
+  if (!Number.isSafeInteger(value) || value < 0 || value > 4294967295) {
+    throw new GrammarLoadError("grammar_integrity", `cannot encode WASM unsigned integer ${value}`);
+  }
+  const encoded = [];
+  let remaining = value;
+  do {
+    let byte = remaining % 128;
+    remaining = Math.floor(remaining / 128);
+    if (remaining > 0) byte |= 128;
+    encoded.push(byte);
+  } while (remaining > 0);
+  return Uint8Array.from(encoded);
+}
+function addShellScannerCoreAlias(coreBytes) {
+  if (coreBytes.length < 8 || Buffer.from(coreBytes.subarray(0, 4)).toString("hex") !== "0061736d") {
+    throw new GrammarLoadError("grammar_integrity", "Tree-sitter core is not a valid WASM binary");
+  }
+  let sectionOffset = 8;
+  while (sectionOffset < coreBytes.length) {
+    const sectionId = coreBytes[sectionOffset];
+    if (sectionId === void 0) break;
+    const sectionSize = readUnsignedLeb(coreBytes, sectionOffset + 1);
+    const payloadStart = sectionSize.nextOffset;
+    const payloadEnd = payloadStart + sectionSize.value;
+    if (payloadEnd > coreBytes.length) {
+      throw new GrammarLoadError("grammar_integrity", "Tree-sitter core contains a truncated WASM section");
+    }
+    if (sectionId !== 7) {
+      sectionOffset = payloadEnd;
+      continue;
+    }
+    const exportCount = readUnsignedLeb(coreBytes, payloadStart);
+    let cursor = exportCount.nextOffset;
+    let sourceFunctionIndex;
+    let targetAlreadyPresent = false;
+    for (let index = 0; index < exportCount.value; index += 1) {
+      const nameLength = readUnsignedLeb(coreBytes, cursor);
+      const nameEnd = nameLength.nextOffset + nameLength.value;
+      if (nameEnd + 1 > payloadEnd) {
+        throw new GrammarLoadError("grammar_integrity", "Tree-sitter core contains a truncated WASM export");
+      }
+      const name = Buffer.from(coreBytes.subarray(nameLength.nextOffset, nameEnd)).toString("utf8");
+      const kind = coreBytes[nameEnd];
+      const itemIndex = readUnsignedLeb(coreBytes, nameEnd + 1);
+      if (name === "isalpha") targetAlreadyPresent = true;
+      if (name === "iswalpha" && kind === 0) sourceFunctionIndex = itemIndex.value;
+      cursor = itemIndex.nextOffset;
+    }
+    if (cursor !== payloadEnd) {
+      throw new GrammarLoadError("grammar_integrity", "Tree-sitter core WASM export section has trailing bytes");
+    }
+    if (targetAlreadyPresent) return coreBytes;
+    if (sourceFunctionIndex === void 0) {
+      throw new GrammarLoadError("grammar_integrity", "Tree-sitter core does not export iswalpha for the Bash scanner compatibility alias");
+    }
+    const aliasName = Buffer.from("isalpha", "utf8");
+    const alias = Buffer.concat([
+      Buffer.from(encodeUnsignedLeb(aliasName.length)),
+      aliasName,
+      Buffer.from([0]),
+      Buffer.from(encodeUnsignedLeb(sourceFunctionIndex))
+    ]);
+    const newPayload = Buffer.concat([
+      Buffer.from(encodeUnsignedLeb(exportCount.value + 1)),
+      Buffer.from(coreBytes.subarray(exportCount.nextOffset, payloadEnd)),
+      alias
+    ]);
+    return Buffer.concat([
+      Buffer.from(coreBytes.subarray(0, sectionOffset)),
+      Buffer.from([sectionId]),
+      Buffer.from(encodeUnsignedLeb(newPayload.length)),
+      newPayload,
+      Buffer.from(coreBytes.subarray(payloadEnd))
+    ]);
+  }
+  throw new GrammarLoadError("grammar_integrity", "Tree-sitter core WASM does not contain an export section");
+}
+var GrammarLoadError = class extends Error {
+  constructor(code, message2) {
+    super(message2);
+    this.code = code;
+    this.name = "GrammarLoadError";
+  }
+  code;
+};
+function configureBoundedWasmCompilation() {
+  if (boundedWasmCompilationConfigured) return;
+  boundedWasmCompilationConfigured = true;
+  setFlagsFromString("--no-wasm-tier-up --no-wasm-dynamic-tiering");
+}
+function safeAssetPath(root, relative) {
+  const candidate = path6.resolve(root, relative);
+  const resolvedRoot = path6.resolve(root);
+  if (candidate !== resolvedRoot && !candidate.startsWith(`${resolvedRoot}${path6.sep}`)) {
+    throw new GrammarLoadError("grammar_integrity", `grammar asset escapes its root: ${relative}`);
+  }
+  return candidate;
+}
+function loadGrammarManifest(assetRoot = defaultAssetRoot) {
+  const resolvedRoot = path6.resolve(assetRoot);
+  const cached = manifestCache.get(resolvedRoot);
+  if (cached) return cached;
+  const manifestPath = safeAssetPath(resolvedRoot, "grammar-manifest.json");
+  let parsed;
+  try {
+    parsed = JSON.parse(fs3.readFileSync(manifestPath, "utf8"));
+  } catch (error) {
+    throw new GrammarLoadError("grammar_unavailable", `cannot read grammar manifest at ${manifestPath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const manifest = grammarManifestSchema.parse(parsed);
+  if (manifest.grammars.some((grammar) => grammar.abi < manifest.runtime.abi_min || grammar.abi > manifest.runtime.abi_max)) {
+    throw new GrammarLoadError(
+      "grammar_integrity",
+      `grammar manifest contains an entry outside its declared ABI range ${manifest.runtime.abi_min}-${manifest.runtime.abi_max}`
+    );
+  }
+  manifestCache.set(resolvedRoot, manifest);
+  return manifest;
+}
+function grammarFor(language, filePath, assetRoot = defaultAssetRoot) {
+  const extension = path6.posix.extname(filePath.replaceAll("\\", "/")).toLowerCase();
+  const matches = loadGrammarManifest(assetRoot).grammars.filter((entry) => entry.languages.includes(language));
+  return matches.find((entry) => entry.extensions?.includes(extension)) ?? matches.find((entry) => !entry.extensions);
+}
+function resolveGrammarAsset(entry, assetRoot) {
+  const bundled = safeAssetPath(assetRoot, entry.file);
+  if (fs3.existsSync(bundled)) return bundled;
+  try {
+    return require2.resolve(`${loadGrammarManifest(assetRoot).source_package.name}/${entry.package_subpath}`);
+  } catch {
+    throw new GrammarLoadError("grammar_unavailable", `missing grammar ${entry.id}; expected ${bundled} or dependency subpath ${entry.package_subpath}`);
+  }
+}
+async function initializeRuntime(coreWasmPath, assetRoot) {
+  if (runtimeInitialization) {
+    if (coreWasmPath && initializedCorePath && path6.resolve(coreWasmPath) !== initializedCorePath) {
+      throw new GrammarLoadError("grammar_integrity", "Tree-sitter runtime was already initialized with a different core WASM");
+    }
+    return runtimeInitialization;
+  }
+  const resolvedCorePath = coreWasmPath ? path6.resolve(coreWasmPath) : require2.resolve("web-tree-sitter/tree-sitter.wasm");
+  initializedCorePath = resolvedCorePath;
+  const compatibleCore = addShellScannerCoreAlias(fs3.readFileSync(resolvedCorePath));
+  runtimeInitialization = Parser.init({ wasmBinary: compatibleCore }).then(() => {
+    const manifest = loadGrammarManifest(assetRoot);
+    if (manifest.runtime.abi_min !== MIN_COMPATIBLE_VERSION || manifest.runtime.abi_max !== LANGUAGE_VERSION) {
+      throw new GrammarLoadError(
+        "grammar_integrity",
+        `grammar manifest ABI range ${manifest.runtime.abi_min}-${manifest.runtime.abi_max} does not match runtime ${MIN_COMPATIBLE_VERSION}-${LANGUAGE_VERSION}`
+      );
+    }
+  });
+  return runtimeInitialization;
+}
+async function loadLanguageSerialized(bytes) {
+  const previous = grammarLoadTail.catch(() => void 0);
+  let release;
+  grammarLoadTail = new Promise((resolve) => {
+    release = resolve;
+  });
+  await previous;
+  try {
+    return await Language.load(bytes);
+  } finally {
+    release();
+  }
+}
+async function loadGrammar(language, filePath, options = {}) {
+  const assetRoot = path6.resolve(options.assetRoot ?? defaultAssetRoot);
+  const descriptor = grammarFor(language, filePath, assetRoot);
+  if (!descriptor) return void 0;
+  const assetPath = resolveGrammarAsset(descriptor, assetRoot);
+  const packagedCore = safeAssetPath(assetRoot, "tree-sitter.wasm");
+  const coreWasmPath = options.coreWasmPath ?? (fs3.existsSync(packagedCore) ? packagedCore : void 0);
+  const key = `${assetPath}:${descriptor.sha256}`;
+  let pending = languageCache.get(key);
+  if (!pending) {
+    pending = (async () => {
+      configureBoundedWasmCompilation();
+      await initializeRuntime(coreWasmPath, assetRoot);
+      const bytes = fs3.readFileSync(assetPath);
+      const actualHash = sha256(bytes);
+      if (actualHash !== descriptor.sha256) {
+        throw new GrammarLoadError("grammar_integrity", `grammar ${descriptor.id} hash mismatch: expected ${descriptor.sha256}, received ${actualHash}`);
+      }
+      const loaded = await loadLanguageSerialized(bytes);
+      if (loaded.abiVersion !== descriptor.abi || loaded.abiVersion < MIN_COMPATIBLE_VERSION || loaded.abiVersion > LANGUAGE_VERSION) {
+        throw new GrammarLoadError(
+          "grammar_integrity",
+          `grammar ${descriptor.id} ABI ${loaded.abiVersion} is incompatible with runtime ${MIN_COMPATIBLE_VERSION}-${LANGUAGE_VERSION}`
+        );
+      }
+      return {
+        descriptor,
+        language: loaded,
+        provenance: {
+          id: descriptor.id,
+          abi: loaded.abiVersion,
+          sha256: actualHash,
+          runtime: "web-tree-sitter@0.25.10",
+          source: `${loadGrammarManifest(assetRoot).source_package.repository}@${loadGrammarManifest(assetRoot).source_package.version}`,
+          license: loadGrammarManifest(assetRoot).source_package.license
+        },
+        assetPath
+      };
+    })();
+    languageCache.set(key, pending);
+  }
+  try {
+    return await pending;
+  } catch (error) {
+    languageCache.delete(key);
+    throw error;
+  }
+}
+
+// ../packages/brain-ast/src/query-assets.ts
+var AST_QUERY_VERSION = "1";
+var queryEntrySchema = z3.object({
+  id: z3.string().min(1),
+  languages: z3.array(z3.string().min(1)).min(1),
+  extensions: z3.array(z3.string().startsWith(".")).optional(),
+  file: z3.string().min(1),
+  sample_path: z3.string().min(1)
+}).strict();
+var queryManifestSchema = z3.object({
+  schema_version: z3.literal(1),
+  query_version: z3.literal(AST_QUERY_VERSION),
+  queries: z3.array(queryEntrySchema).min(1)
+}).strict();
+var defaultAssetRoot2 = fileURLToPath2(new URL("../assets", import.meta.url));
+var manifestCache2 = /* @__PURE__ */ new Map();
+var sourceCache = /* @__PURE__ */ new Map();
+var compiledCompatibility = /* @__PURE__ */ new WeakMap();
+function safeAssetPath2(root, relative) {
+  const resolvedRoot = path7.resolve(root);
+  const candidate = path7.resolve(resolvedRoot, relative);
+  if (candidate !== resolvedRoot && !candidate.startsWith(`${resolvedRoot}${path7.sep}`)) {
+    throw new Error(`AST query asset escapes its root: ${relative}`);
+  }
+  return candidate;
+}
+function loadAstQueryManifest(assetRoot = defaultAssetRoot2) {
+  const root = path7.resolve(assetRoot);
+  const cached = manifestCache2.get(root);
+  if (cached) return cached;
+  const manifestPath = safeAssetPath2(root, "queries/manifest.json");
+  const manifest = queryManifestSchema.parse(JSON.parse(fs4.readFileSync(manifestPath, "utf8")));
+  const ids = /* @__PURE__ */ new Set();
+  for (const query of manifest.queries) {
+    if (ids.has(query.id)) throw new Error(`duplicate AST query id: ${query.id}`);
+    ids.add(query.id);
+  }
+  manifestCache2.set(root, manifest);
+  return manifest;
+}
+function queryDescriptor(language, filePath, assetRoot) {
+  const extension = path7.posix.extname(filePath.replaceAll("\\", "/")).toLowerCase();
+  const candidates = loadAstQueryManifest(assetRoot).queries.filter((query) => query.languages.includes(language));
+  return candidates.find((query) => query.extensions?.includes(extension)) ?? candidates.find((query) => !query.extensions);
+}
+function loadAstQueryAsset(language, filePath, assetRoot = defaultAssetRoot2) {
+  const root = path7.resolve(assetRoot);
+  const descriptor = queryDescriptor(language, filePath, root);
+  if (!descriptor) return void 0;
+  const assetPath = safeAssetPath2(path7.join(root, "queries"), descriptor.file);
+  const cacheKey = `${descriptor.id}\0${assetPath}\0${AST_QUERY_VERSION}`;
+  const cached = sourceCache.get(cacheKey);
+  if (cached) return cached;
+  const source = fs4.readFileSync(assetPath, "utf8");
+  if (!source.trim()) throw new Error(`AST query asset is empty: ${descriptor.file}`);
+  const loaded = { descriptor, version: AST_QUERY_VERSION, source, sha256: sha256(source), path: assetPath };
+  sourceCache.set(cacheKey, loaded);
+  return loaded;
+}
+function assertAstQueryCompatible(language, filePath, grammar, assetRoot = defaultAssetRoot2) {
+  const asset = loadAstQueryAsset(language, filePath, assetRoot);
+  if (!asset) return void 0;
+  const cache = compiledCompatibility.get(grammar) ?? /* @__PURE__ */ new Set();
+  const identity = `${asset.descriptor.id}\0${asset.sha256}`;
+  if (!cache.has(identity)) {
+    const query = new Query(grammar, asset.source);
+    try {
+      if (!query.captureNames.includes("symbol") && !query.captureNames.includes("import")) {
+        throw new Error(`AST query ${asset.descriptor.id} has no symbol or import captures`);
+      }
+    } finally {
+      query.delete();
+    }
+    cache.add(identity);
+    compiledCompatibility.set(grammar, cache);
+  }
+  return asset;
+}
+
+// ../packages/brain-ast/src/types.ts
+var DEFAULT_AST_FILE_TIMEOUT_MS = 2e3;
+var AST_TYPE_DECLARATION_KINDS = [
+  "class",
+  "enum",
+  "interface",
+  "message",
+  "service",
+  "struct",
+  "trait",
+  "type"
+];
+var AST_TYPE_DECLARATION_KIND_SET = new Set(AST_TYPE_DECLARATION_KINDS);
+function isAstTypeDeclarationKind(kind) {
+  return AST_TYPE_DECLARATION_KIND_SET.has(kind);
+}
+function parserRuntimeForGrammar(grammar) {
+  if (grammar.runtime === "web-tree-sitter@0.25.10") return "web-tree-sitter";
+  if (grammar.runtime === "structural-fallback@1") return "structural-fallback";
+  return "unavailable";
+}
+
+// ../packages/brain-ast/src/fallback-parsers.ts
+import { performance as performance2 } from "perf_hooks";
+function locate(source) {
+  const starts = [0];
+  for (let index = 0; index < source.length; index += 1) if (source.charCodeAt(index) === 10) starts.push(index + 1);
+  function point(offset) {
+    let low = 0;
+    let high = starts.length - 1;
+    while (low <= high) {
+      const middle = Math.floor((low + high) / 2);
+      const value = starts[middle] ?? 0;
+      if (value <= offset) low = middle + 1;
+      else high = middle - 1;
+    }
+    const lineIndex = Math.max(0, high);
+    const start = starts[lineIndex] ?? 0;
+    return {
+      line: lineIndex + 1,
+      column: Buffer.byteLength(source.slice(start, offset), "utf8"),
+      byte: Buffer.byteLength(source.slice(0, start), "utf8") + Buffer.byteLength(source.slice(start, offset), "utf8")
+    };
+  }
+  return {
+    span(start, end) {
+      const first = point(Math.max(0, start));
+      const last = point(Math.max(start, end));
+      return {
+        startByte: first.byte,
+        endByte: last.byte,
+        startLine: first.line,
+        startColumn: first.column,
+        endLine: last.line,
+        endColumn: last.column
+      };
+    },
+    lineStart(lineIndex) {
+      return starts[lineIndex] ?? source.length;
+    }
+  };
+}
+function fallbackGrammar(id) {
+  return {
+    id: `${id}-structural`,
+    abi: 1,
+    sha256: sha256(`scriptonia:${id}:structural-fallback:1`),
+    runtime: "structural-fallback@1",
+    source: "@scriptonia/brain-ast",
+    license: "project"
+  };
+}
+function baseResult(input, language) {
+  const sourceSha256 = input.sourceSha256 ?? sha256(input.source);
+  return {
+    schemaVersion: 1,
+    path: normalizeRepoPath(input.path),
+    language,
+    sourceSha256,
+    parserRuntime: "structural-fallback",
+    grammar: fallbackGrammar(language),
+    sourceBytes: Buffer.byteLength(input.source, "utf8")
+  };
+}
+function factSymbol(base, kind, name, qualifiedName, signature, nodeType, span) {
+  return {
+    factId: `symbol_${sha256(`${base.sourceSha256}\0${base.path}\0${kind}\0${qualifiedName}\0${span.startByte}`).slice(0, 24)}`,
+    path: base.path,
+    language: base.language,
+    kind,
+    name,
+    qualifiedName,
+    signature: signature.replace(/\s+/g, " ").trim().slice(0, 1e3),
+    nodeType,
+    span,
+    confidence: "medium",
+    provenance: "structural_fallback"
+  };
+}
+function factImport(base, kind, specifier, importedNames, span) {
+  return {
+    factId: `import_${sha256(`${base.sourceSha256}\0${base.path}\0${kind}\0${specifier}\0${span.startByte}`).slice(0, 24)}`,
+    path: base.path,
+    language: base.language,
+    kind,
+    specifier,
+    importedNames,
+    span,
+    confidence: "medium",
+    provenance: "structural_fallback"
+  };
+}
+function stripComments(source) {
+  let output = "";
+  let state = "code";
+  for (let index = 0; index < source.length; index += 1) {
+    const char = source[index] ?? "";
+    const next = source[index + 1] ?? "";
+    if (state === "line") {
+      if (char === "\n") {
+        state = "code";
+        output += "\n";
+      } else output += " ";
+      continue;
+    }
+    if (state === "block") {
+      if (char === "*" && next === "/") {
+        output += "  ";
+        index += 1;
+        state = "code";
+      } else output += char === "\n" ? "\n" : " ";
+      continue;
+    }
+    if (state === "single" || state === "double") {
+      output += char;
+      if (char === "\\" && next) {
+        output += next;
+        index += 1;
+        continue;
+      }
+      if (state === "single" && char === "'" || state === "double" && char === '"') state = "code";
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      output += "  ";
+      index += 1;
+      state = "line";
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      output += "  ";
+      index += 1;
+      state = "block";
+      continue;
+    }
+    if (char === "#") {
+      output += " ";
+      state = "line";
+      continue;
+    }
+    if (char === "'") state = "single";
+    else if (char === '"') state = "double";
+    output += char;
+  }
+  return output;
+}
+function braceDelta(line) {
+  let delta = 0;
+  let quote;
+  for (let index = 0; index < line.length; index += 1) {
+    const char = line[index];
+    if (quote) {
+      if (char === "\\") index += 1;
+      else if (char === quote) quote = void 0;
+    } else if (char === "'" || char === '"') quote = char;
+    else if (char === "{") delta += 1;
+    else if (char === "}") delta -= 1;
+  }
+  return delta;
+}
+function parseProtoFallback(input) {
+  const startedAt = performance2.now();
+  const base = baseResult(input, "proto");
+  const locator = locate(input.source);
+  const cleaned = stripComments(input.source);
+  const lines = cleaned.split(/\n/);
+  const originalLines = input.source.split(/\n/);
+  const symbols = [];
+  const imports = [];
+  const diagnostics = [{ code: "grammar_unavailable", severity: "info", message: "Proto uses the deterministic structural parser; semantic type resolution is not claimed" }];
+  const scope = [];
+  let depth = 0;
+  let packageName = "";
+  let negativeDepth = false;
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+    const line = lines[lineIndex] ?? "";
+    const original = originalLines[lineIndex] ?? "";
+    const start = locator.lineStart(lineIndex);
+    const end = start + original.length;
+    const packageMatch = /^\s*package\s+([A-Za-z_][\w.]*)\s*;/.exec(line);
+    if (packageMatch?.[1]) {
+      packageName = packageMatch[1];
+      imports.push(factImport(base, "package", packageName, [], locator.span(start, end)));
+    }
+    const importMatch = /^\s*import\s+(?:public\s+|weak\s+)?["']([^"']+)["']\s*;/.exec(line);
+    if (importMatch?.[1]) imports.push(factImport(base, "import", importMatch[1], [], locator.span(start, end)));
+    const declaration = /^\s*(message|enum|service|oneof)\s+([A-Za-z_][\w]*)\b/.exec(line);
+    if (declaration?.[1] && declaration[2]) {
+      const kind = declaration[1] === "message" || declaration[1] === "oneof" ? "message" : declaration[1];
+      const names = [packageName, ...scope.map((entry) => entry.name), declaration[2]].filter(Boolean);
+      const symbol = factSymbol(base, kind, declaration[2], names.join("."), original, `proto_${declaration[1]}`, locator.span(start, end));
+      symbols.push(symbol);
+      if (line.includes("{")) scope.push({ name: declaration[2], depth, symbolIndex: symbols.length - 1 });
+    }
+    const rpc = /^\s*rpc\s+([A-Za-z_][\w]*)\s*\(/.exec(line);
+    if (rpc?.[1]) {
+      const names = [packageName, ...scope.map((entry) => entry.name), rpc[1]].filter(Boolean);
+      symbols.push(factSymbol(base, "rpc", rpc[1], names.join("."), original, "proto_rpc", locator.span(start, end)));
+    }
+    depth += braceDelta(line);
+    if (depth < 0) {
+      negativeDepth = true;
+      depth = 0;
+    }
+    while (scope.length > 0 && depth <= (scope.at(-1)?.depth ?? -1)) {
+      const closed = scope.pop();
+      if (!closed) continue;
+      const existing = symbols[closed.symbolIndex];
+      if (existing) existing.span = { ...existing.span, ...{ endByte: locator.span(start, end).endByte, endLine: lineIndex + 1, endColumn: Buffer.byteLength(original, "utf8") } };
+    }
+  }
+  const broken = negativeDepth || depth !== 0;
+  if (broken) diagnostics.push({ code: "parse_error", severity: "warning", message: "unbalanced Proto braces; extracted facts are partial" });
+  const parseMs = performance2.now() - startedAt;
+  const errorBytes = broken ? Math.min(base.sourceBytes, Math.max(1, Math.abs(depth))) : 0;
+  return {
+    schemaVersion: base.schemaVersion,
+    path: base.path,
+    language: base.language,
+    sourceSha256: base.sourceSha256,
+    parserRuntime: base.parserRuntime,
+    grammar: base.grammar,
+    status: broken ? "partial" : "parsed",
+    rootType: "proto_file",
+    symbols,
+    imports,
+    calls: [],
+    diagnostics,
+    coverage: { sourceBytes: base.sourceBytes, parsedBytes: base.sourceBytes - errorBytes, errorBytes, errorByteRatio: base.sourceBytes === 0 ? 0 : errorBytes / base.sourceBytes, errorNodes: broken ? 1 : 0, missingNodes: 0, parseMs }
+  };
+}
+function balancedCallArgumentCount(text) {
+  const open = text.indexOf("(");
+  const close = text.lastIndexOf(")");
+  if (open < 0 || close < open) return void 0;
+  const body = text.slice(open + 1, close).trim();
+  if (!body) return 0;
+  let count = 1;
+  let depth = 0;
+  let quote;
+  for (let index = 0; index < body.length; index += 1) {
+    const character = body[index];
+    if (quote) {
+      if (character === "\\") index += 1;
+      else if (character === quote) quote = void 0;
+      continue;
+    }
+    if (character === "'" || character === '"') quote = character;
+    else if ("([{<".includes(character ?? "")) depth += 1;
+    else if (")]}>".includes(character ?? "")) depth = Math.max(0, depth - 1);
+    else if (character === "," && depth === 0) count += 1;
+  }
+  return count;
+}
+function balancedCalls(source) {
+  const cleaned = stripComments(source);
+  const calls = [];
+  const pattern = /\b([A-Za-z_][\w.]*)\s*\(/g;
+  for (let match = pattern.exec(cleaned); match; match = pattern.exec(cleaned)) {
+    const name = match[1];
+    if (!name) continue;
+    const open = cleaned.indexOf("(", match.index + name.length);
+    let depth = 0;
+    let quote;
+    let end = open + 1;
+    let closed = false;
+    for (let index = open; index < cleaned.length; index += 1) {
+      const char = cleaned[index];
+      if (quote) {
+        if (char === "\\") index += 1;
+        else if (char === quote) quote = void 0;
+      } else if (char === "'" || char === '"') quote = char;
+      else if (char === "(") depth += 1;
+      else if (char === ")") {
+        depth -= 1;
+        if (depth === 0) {
+          end = index + 1;
+          closed = true;
+          break;
+        }
+      }
+    }
+    calls.push({ name, start: match.index, end, text: source.slice(match.index, end), closed });
+    if (closed) pattern.lastIndex = end;
+  }
+  return calls;
+}
+function parseStarlarkFallback(input) {
+  const startedAt = performance2.now();
+  const base = baseResult(input, "starlark");
+  const locator = locate(input.source);
+  const symbols = [];
+  const imports = [];
+  const calls = [];
+  const diagnostics = [{ code: "grammar_unavailable", severity: "info", message: "Bazel/Starlark uses the deterministic structural parser; macro expansion is recorded as unresolved" }];
+  const cleaned = stripComments(input.source);
+  const definitionPattern = /^[\t ]*def[\t ]+([A-Za-z_][\w]*)[\t ]*\([^\n]*/gm;
+  for (let match = definitionPattern.exec(cleaned); match; match = definitionPattern.exec(cleaned)) {
+    const name = match[1];
+    if (!name) continue;
+    const end = cleaned.indexOf("\n", match.index);
+    const finalEnd = end === -1 ? cleaned.length : end;
+    symbols.push(factSymbol(base, "function", name, name, input.source.slice(match.index, finalEnd), "starlark_function", locator.span(match.index, finalEnd)));
+  }
+  let unclosed = 0;
+  for (const call of balancedCalls(input.source)) {
+    if (!call.closed) unclosed += 1;
+    const callSpan = locator.span(call.start, call.end);
+    const argumentCount = call.closed ? balancedCallArgumentCount(call.text) : void 0;
+    calls.push({
+      factId: `call_${sha256(`${base.sourceSha256}\0${base.path}\0${call.name}\0${callSpan.startByte}`).slice(0, 24)}`,
+      path: base.path,
+      language: "starlark",
+      callee: call.name,
+      ...argumentCount === void 0 ? {} : { argumentCount },
+      span: callSpan,
+      confidence: "low",
+      resolution: "unresolved",
+      provenance: "structural_fallback"
+    });
+    const strings = [...call.text.matchAll(/["']([^"']+)["']/g)].map((match) => match[1]).filter((item) => Boolean(item));
+    if (call.name === "load" && strings[0]) {
+      imports.push(factImport(base, "load", strings[0], strings.slice(1), callSpan));
+      continue;
+    }
+    const targetName = /\bname\s*=\s*["']([^"']+)["']/.exec(call.text)?.[1];
+    if (targetName) {
+      const packagePath = base.path.replace(/(?:^|\/)(?:BUILD(?:\.bazel)?|[^/]+\.bzl)$/, "").replace(/^\//, "");
+      const label = `//${packagePath}${packagePath ? ":" : ""}${targetName}`;
+      symbols.push(factSymbol(base, "target", targetName, label, `${call.name}(name = ${JSON.stringify(targetName)})`, `bazel_${call.name}`, callSpan));
+    }
+  }
+  if (unclosed > 0) diagnostics.push({ code: "parse_error", severity: "warning", message: `${unclosed} unclosed Starlark call expression(s)` });
+  const parseMs = performance2.now() - startedAt;
+  const errorBytes = unclosed > 0 ? Math.min(base.sourceBytes, unclosed) : 0;
+  return {
+    schemaVersion: base.schemaVersion,
+    path: base.path,
+    language: base.language,
+    sourceSha256: base.sourceSha256,
+    parserRuntime: base.parserRuntime,
+    grammar: base.grammar,
+    status: unclosed > 0 ? "partial" : "parsed",
+    rootType: "starlark_file",
+    symbols,
+    imports,
+    calls,
+    diagnostics,
+    coverage: { sourceBytes: base.sourceBytes, parsedBytes: base.sourceBytes - errorBytes, errorBytes, errorByteRatio: base.sourceBytes === 0 ? 0 : errorBytes / base.sourceBytes, errorNodes: unclosed, missingNodes: 0, parseMs }
+  };
+}
+function parseStructuralFallback(input, language) {
+  if (language === "proto") return parseProtoFallback({ ...input, language });
+  if (language === "starlark") return parseStarlarkFallback({ ...input, language });
+  return void 0;
+}
+
+// ../packages/brain-ast/src/tree-sitter-parser.ts
+import { performance as performance3 } from "perf_hooks";
+import { Parser as Parser2 } from "web-tree-sitter";
+var SYMBOL_TYPES = /* @__PURE__ */ new Map([
+  ["class_specifier", "class"],
+  ["struct_specifier", "struct"],
+  ["enum_specifier", "enum"],
+  ["namespace_definition", "namespace"],
+  ["function_definition", "function"],
+  ["type_definition", "type"],
+  ["alias_declaration", "type"],
+  ["type_alias_declaration", "type"],
+  ["class_declaration", "class"],
+  ["interface_declaration", "interface"],
+  ["enum_declaration", "enum"],
+  ["annotation_type_declaration", "interface"],
+  ["record_declaration", "struct"],
+  ["method_declaration", "method"],
+  ["constructor_declaration", "method"],
+  ["function_declaration", "function"],
+  ["generator_function_declaration", "function"],
+  ["class_definition", "class"],
+  ["function_definition", "function"],
+  ["function_item", "function"],
+  ["struct_item", "struct"],
+  ["enum_item", "enum"],
+  ["trait_item", "trait"],
+  ["mod_item", "module"],
+  ["type_item", "type"],
+  ["const_item", "constant"],
+  ["static_item", "constant"],
+  ["method_definition", "method"],
+  ["abstract_method_signature", "method"],
+  ["function_signature", "function"],
+  ["method_signature", "method"],
+  ["getter_signature", "method"],
+  ["setter_signature", "method"],
+  ["object_declaration", "class"],
+  ["protocol_declaration", "interface"],
+  ["actor_declaration", "class"],
+  ["function_declaration", "function"],
+  ["function_definition", "function"],
+  ["method_definition", "method"]
+]);
+var IMPORT_TYPES = /* @__PURE__ */ new Set([
+  "preproc_include",
+  "import_declaration",
+  "import_statement",
+  "import_from_statement",
+  "export_statement",
+  "use_declaration",
+  "package_clause",
+  "package_declaration",
+  "library_import",
+  "part_directive",
+  "import_or_export"
+]);
+var CALL_TYPES = /* @__PURE__ */ new Set([
+  "call_expression",
+  "function_call",
+  "method_invocation",
+  "object_creation_expression",
+  "method_reference",
+  "command",
+  "command_substitution"
+]);
+var IDENTIFIER_TYPES = /* @__PURE__ */ new Set([
+  "identifier",
+  "field_identifier",
+  "type_identifier",
+  "property_identifier",
+  "simple_identifier",
+  "operator_name",
+  "constant",
+  "destructor_name"
+]);
+var SCOPE_KINDS = /* @__PURE__ */ new Set(["class", "interface", "module", "namespace", "service", "struct", "trait"]);
+var DECLARATION_WRAPPER_TYPES = /* @__PURE__ */ new Set(["ambient_declaration", "decorated_definition", "export_statement"]);
+var JAVASCRIPT_FAMILY = /* @__PURE__ */ new Set(["javascript", "typescript"]);
+var DART_WIDGET_BASES = /* @__PURE__ */ new Map([
+  ["ConsumerWidget", "consumer"],
+  ["StatefulWidget", "stateful"],
+  ["StatelessWidget", "stateless"]
+]);
+var MAX_SOURCE_BYTES = 32 * 1024 * 1024;
+var MAX_FACTS_PER_KIND = 5e4;
+function ancestor(node, predicate) {
+  for (let candidate = node.parent; candidate; candidate = candidate.parent) {
+    if (predicate(candidate)) return candidate;
+  }
+  return void 0;
+}
+function symbolKind(node, language) {
+  if (language === "kotlin" && node.type === "class_declaration" && /^interface\b/.test(node.text.trimStart())) {
+    return "interface";
+  }
+  if ((language === "c" || language === "cpp") && node.type === "function_definition" && ancestor(node, (candidate) => candidate.type === "function_definition")) return void 0;
+  if ((language === "c" || language === "cpp") && node.type === "function_definition" && !node.childForFieldName("type")) {
+    const declarator = node.childForFieldName("declarator");
+    const name = declarator ? innermostDeclaratorIdentifier(declarator)?.text.trim() : void 0;
+    const isClassMember = Boolean(ancestor(node, (candidate) => candidate.type === "class_specifier" || candidate.type === "struct_specifier"));
+    if (name && /^[A-Z][A-Z0-9_]{2,}$/.test(name) && !isClassMember && !declarator?.text.includes("::")) return void 0;
+  }
+  const direct = SYMBOL_TYPES.get(node.type);
+  if (direct) return direct;
+  if ((language === "c" || language === "cpp") && (node.type === "declaration" || node.type === "field_declaration")) {
+    const callable = callableDeclarator(node);
+    if (!callable) return void 0;
+    return node.type === "field_declaration" || Boolean(ancestor(node, (candidate) => candidate.type === "class_specifier" || candidate.type === "struct_specifier")) ? "method" : "function";
+  }
+  if (JAVASCRIPT_FAMILY.has(language) && node.type === "variable_declarator") {
+    const lexical = ancestor(node, (candidate) => candidate.type === "lexical_declaration");
+    if (lexical?.parent?.type === "export_statement" && /^const\b/.test(lexical.text.trimStart())) return "constant";
+  }
+  return void 0;
+}
+function callableDeclarator(node) {
+  let cursor = node.childForFieldName("declarator") ?? void 0;
+  const visited = /* @__PURE__ */ new Set();
+  while (cursor && !visited.has(cursor.id)) {
+    visited.add(cursor.id);
+    if (cursor.type === "function_declarator") return cursor;
+    cursor = cursor.childForFieldName("declarator") ?? void 0;
+  }
+  return void 0;
+}
+function spanFor(node) {
+  return {
+    startByte: node.startIndex,
+    endByte: node.endIndex,
+    startLine: node.startPosition.row + 1,
+    startColumn: node.startPosition.column,
+    endLine: node.endPosition.row + 1,
+    endColumn: node.endPosition.column
+  };
+}
+function firstNamedDescendant(node, predicate) {
+  const stack = [...node.namedChildren].filter((child) => child !== null).reverse();
+  while (stack.length > 0) {
+    const candidate = stack.pop();
+    if (!candidate) continue;
+    if (predicate(candidate)) return candidate;
+    for (const child of [...candidate.namedChildren].reverse()) if (child) stack.push(child);
+  }
+  return void 0;
+}
+function firstDescendantField(node, fieldName) {
+  const stack = [...node.namedChildren].filter((child) => child !== null).reverse();
+  while (stack.length > 0) {
+    const candidate = stack.pop();
+    if (!candidate) continue;
+    const field = candidate.childForFieldName(fieldName);
+    if (field?.text.trim()) return field;
+    for (const child of [...candidate.namedChildren].reverse()) if (child) stack.push(child);
+  }
+  return void 0;
+}
+function symbolName(node) {
+  const direct = node.childForFieldName("name");
+  if (direct?.text.trim()) return (innermostDeclaratorIdentifier(direct)?.text ?? direct.text).trim();
+  if (node.type === "namespace_definition") return void 0;
+  const declarator = node.childForFieldName("declarator");
+  if (declarator) {
+    const identifier2 = innermostDeclaratorIdentifier(declarator);
+    if (identifier2?.text.trim()) return identifier2.text.trim();
+  }
+  const descendantName = firstDescendantField(node, "name");
+  if (descendantName?.text.trim()) return descendantName.text.trim();
+  const identifier = firstNamedDescendant(node, (candidate) => IDENTIFIER_TYPES.has(candidate.type));
+  if (identifier?.text.trim()) return identifier.text.trim();
+  const head = node.text.slice(0, 500).replace(/\s+/g, " ");
+  return /\b(?:actor|class|def|enum|fn|func|fun|function|interface|namespace|object|protocol|record|struct|trait|type)\s+([A-Za-z_$][\w$]*)/.exec(head)?.[1] ?? /\b([A-Za-z_$][\w$]*)\s*\(/.exec(head)?.[1];
+}
+function innermostDeclaratorIdentifier(node) {
+  let cursor = node;
+  const visited = /* @__PURE__ */ new Set();
+  while (cursor && !visited.has(cursor.id)) {
+    visited.add(cursor.id);
+    if (IDENTIFIER_TYPES.has(cursor.type)) return cursor;
+    const explicitName = cursor.childForFieldName("name");
+    if (explicitName) {
+      const nested = innermostDeclaratorIdentifier(explicitName);
+      if (nested) return nested;
+    }
+    cursor = cursor.childForFieldName("declarator") ?? void 0;
+  }
+  return void 0;
+}
+function signatureFor(node) {
+  const body = node.childForFieldName("body");
+  const text = body ? node.text.slice(0, Math.max(0, body.startIndex - node.startIndex)) : node.text;
+  const normalized = text.replace(/\s+/g, " ").trim();
+  const exported = ancestor(node, (candidate) => candidate.type === "export_statement");
+  return `${exported && !/^export\b/.test(normalized) ? "export " : ""}${normalized}`.slice(0, 1e3);
+}
+function declarationAnchor(node) {
+  let anchor = node;
+  while (anchor.parent && DECLARATION_WRAPPER_TYPES.has(anchor.parent.type)) anchor = anchor.parent;
+  return anchor;
+}
+function isDocumentationComment(node, language) {
+  if (language === "dart") return node.type === "documentation_comment";
+  if (language === "java") return node.type === "block_comment" && node.text.trimStart().startsWith("/**");
+  if (!JAVASCRIPT_FAMILY.has(language) || node.type !== "comment") return false;
+  const text = node.text.trimStart();
+  return text.startsWith("/**") || text.startsWith("///");
+}
+function leadingDocComment(node, language) {
+  let cursor = declarationAnchor(node);
+  const comments = [];
+  for (let sibling = cursor.previousNamedSibling; sibling; sibling = sibling.previousNamedSibling) {
+    if (!isDocumentationComment(sibling, language)) break;
+    if (cursor.startPosition.row - sibling.endPosition.row > 1) break;
+    comments.unshift(sibling.text);
+    cursor = sibling;
+  }
+  const text = comments.join("\n").trim();
+  return text.length > 0 ? text : void 0;
+}
+function dartClassMetadata(node, language, kind) {
+  if (language !== "dart" || kind !== "class" || node.type !== "class_definition") return {};
+  const superclassNode = node.childForFieldName("superclass");
+  const superclassParts = superclassNode?.namedChildren.filter((child) => child !== null && child.type === "type_identifier").map((child) => child.text.trim()).filter(Boolean) ?? [];
+  const superclass = superclassParts.length > 0 ? superclassParts.join(".") : void 0;
+  const unqualifiedSuperclass = superclassParts.at(-1);
+  const widgetKind = unqualifiedSuperclass ? DART_WIDGET_BASES.get(unqualifiedSuperclass) : void 0;
+  return {
+    ...superclass ? { superclass } : {},
+    widget: widgetKind !== void 0,
+    ...widgetKind ? { widgetKind } : {}
+  };
+}
+function javaClassMetadata(node, language, kind) {
+  if (language !== "java" || kind !== "class" || node.type !== "class_declaration") return {};
+  const superclassNode = node.childForFieldName("superclass");
+  const superclass = superclassNode?.firstNamedChild?.text.trim();
+  return superclass ? { superclass } : {};
+}
+function javaSymbolVisibility(node, language, kind) {
+  if (language !== "java") return {};
+  const modifiers = node.namedChildren.find((child) => child?.type === "modifiers")?.text ?? "";
+  if (/(?:^|\s)public(?:\s|$)/.test(modifiers)) return { exported: true };
+  if (/(?:^|\s)(?:private|protected)(?:\s|$)/.test(modifiers)) return { exported: false };
+  if (kind !== "method" || node.type !== "method_declaration") return {};
+  const body = node.parent;
+  const declaration = body?.parent;
+  if (body?.type !== "interface_body" || declaration?.type !== "interface_declaration") return {};
+  return { exported: true };
+}
+function javaPackageName(root, language) {
+  if (language !== "java") return void 0;
+  const declaration = root.namedChildren.find((child) => child?.type === "package_declaration");
+  const value = declaration?.firstNamedChild?.text.trim();
+  return value || void 0;
+}
+function importFact(node, language, filePath, sourceHash) {
+  const text = node.text.trim();
+  let kind = "import";
+  let specifier;
+  let isStatic = false;
+  let wildcard = false;
+  if (node.type === "preproc_include" || /^#\s*include\b/.test(text)) {
+    kind = "include";
+    specifier = /[<"]([^>"]+)[>"]/.exec(text)?.[1];
+  } else if (/^export\b/.test(text)) {
+    kind = "export";
+    specifier = /\bfrom\s*["']([^"']+)["']/.exec(text)?.[1] ?? /^export\s*\*\s*["']([^"']+)["']/.exec(text)?.[1];
+  } else if (/^use\b/.test(text)) {
+    kind = "use";
+    specifier = text.replace(/^use\s+/, "").replace(/;$/, "").trim();
+  } else if (/^package\b/.test(text)) {
+    kind = "package";
+    specifier = text.replace(/^package\s+/, "").replace(/[;\s]+$/, "").trim();
+  } else if (language === "java" && node.type === "import_declaration") {
+    isStatic = /^import\s+static\b/.test(text);
+    specifier = text.replace(/^import\s+(?:static\s+)?/, "").replace(/[;\s]+$/, "").trim();
+    wildcard = specifier.endsWith(".*");
+  } else {
+    specifier = /["']([^"']+)["']/.exec(text)?.[1] ?? /^from\s+([^\s]+)\s+import\b/.exec(text)?.[1] ?? /^import\s+([^\s;,]+)/.exec(text)?.[1];
+  }
+  if (!specifier) return void 0;
+  const importedNames = text.match(/[A-Za-z_$][\w$]*/g)?.filter((name) => !["as", "export", "from", "import", "include", "package", "part", "show", "static", "use"].includes(name)) ?? [];
+  const span = spanFor(node);
+  return {
+    factId: `import_${sha256(`${sourceHash}\0${filePath}\0${kind}\0${specifier}\0${span.startByte}`).slice(0, 24)}`,
+    path: filePath,
+    language,
+    kind,
+    specifier,
+    importedNames: [...new Set(importedNames)].slice(0, 100),
+    ...isStatic ? { isStatic: true } : {},
+    ...wildcard ? { wildcard: true } : {},
+    span,
+    confidence: "high",
+    provenance: "tree_sitter"
+  };
+}
+function dynamicImportFact(node, language, filePath, sourceHash) {
+  if (!JAVASCRIPT_FAMILY.has(language) || node.type !== "call_expression") return void 0;
+  const calleeNode = node.childForFieldName("function") ?? node.firstNamedChild;
+  const callee = calleeNode?.text.trim();
+  if (callee !== "import" && callee !== "require") return void 0;
+  const argumentsNode = node.childForFieldName("arguments") ?? node.namedChildren.find((child) => child?.type === "arguments") ?? void 0;
+  const expression = argumentsNode?.namedChildren[0]?.text.trim();
+  if (!expression) return void 0;
+  const quoted2 = /^(?:'([^']+)'|"([^"]+)"|`([^`$]+)`)$/s.exec(expression);
+  const specifier = (quoted2?.[1] ?? quoted2?.[2] ?? quoted2?.[3] ?? expression).slice(0, 1e3);
+  if (!specifier) return void 0;
+  const kind = callee === "import" ? "dynamic_import" : "require";
+  const span = spanFor(node);
+  return {
+    factId: `import_${sha256(`${sourceHash}\0${filePath}\0${kind}\0${specifier}\0${span.startByte}`).slice(0, 24)}`,
+    path: filePath,
+    language,
+    kind,
+    specifier,
+    importedNames: [],
+    span,
+    confidence: quoted2 ? "high" : "medium",
+    provenance: "tree_sitter"
+  };
+}
+function callFact(node, language, filePath, sourceHash) {
+  const calleeNode = node.type === "object_creation_expression" ? node.childForFieldName("type") ?? node.firstNamedChild : node.childForFieldName("function") ?? node.childForFieldName("name") ?? node.firstNamedChild;
+  const callee = (node.type === "method_reference" ? node.text : calleeNode?.text)?.replace(/\s+/g, " ").trim();
+  if (!callee || callee.length > 300) return void 0;
+  const argumentsNode = node.childForFieldName("arguments") ?? node.namedChildren.find((child) => child?.type === "arguments") ?? void 0;
+  const span = spanFor(node);
+  return {
+    factId: `call_${sha256(`${sourceHash}\0${filePath}\0${callee}\0${span.startByte}`).slice(0, 24)}`,
+    path: filePath,
+    language,
+    callee,
+    ...argumentsNode ? { argumentCount: argumentsNode.namedChildCount } : {},
+    span,
+    confidence: "low",
+    resolution: "unresolved",
+    provenance: "tree_sitter"
+  };
+}
+function mergeErrorRanges(ranges) {
+  ranges.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+  let bytes = 0;
+  let start = -1;
+  let end = -1;
+  for (const [nextStart, nextEnd] of ranges) {
+    if (nextStart > end) {
+      if (end >= start) bytes += end - start;
+      start = nextStart;
+      end = nextEnd;
+    } else {
+      end = Math.max(end, nextEnd);
+    }
+  }
+  if (end >= start) bytes += end - start;
+  return bytes;
+}
+function syntaxRecoveryScore(root) {
+  const errorRanges = [];
+  let errorNodes = 0;
+  let missingNodes = 0;
+  const stack = [root];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (!node) continue;
+    if (node.isError) {
+      errorNodes += 1;
+      errorRanges.push([node.startIndex, node.endIndex]);
+    }
+    if (node.isMissing) missingNodes += 1;
+    for (const child of node.namedChildren) if (child) stack.push(child);
+  }
+  return { errorBytes: mergeErrorRanges(errorRanges), errorNodes, missingNodes };
+}
+function hasBetterSyntaxRecovery(candidate, baseline) {
+  if (candidate.errorBytes !== baseline.errorBytes) return candidate.errorBytes < baseline.errorBytes;
+  if (candidate.missingNodes !== baseline.missingNodes) return candidate.missingNodes < baseline.missingNodes;
+  return candidate.errorNodes < baseline.errorNodes;
+}
+function normalizeCppParserSource(source) {
+  const lines = source.split("\n");
+  const normalized = [];
+  const maskedRanges = [];
+  let byteOffset = 0;
+  let defineContinuation = false;
+  let invocationDepth = 0;
+  let maskedDefinitions = 0;
+  let maskedInvocations = 0;
+  let maskedSuffixes = 0;
+  const maskLine = (line) => " ".repeat(line.length);
+  const parenDelta = (line) => {
+    let delta = 0;
+    for (const character of line) {
+      if (character === "(") delta += 1;
+      else if (character === ")") delta -= 1;
+    }
+    return delta;
+  };
+  for (const line of lines) {
+    const lineBytes = Buffer.byteLength(line, "utf8");
+    const trimmed = line.trimStart();
+    if (!defineContinuation && /^#\s*define\b/.test(trimmed)) defineContinuation = true;
+    if (defineContinuation) {
+      normalized.push(maskLine(line));
+      maskedRanges.push([byteOffset, byteOffset + lineBytes]);
+      maskedDefinitions += 1;
+      defineContinuation = line.trimEnd().endsWith("\\");
+      byteOffset += lineBytes + 1;
+      continue;
+    }
+    const startsInvocation = invocationDepth === 0 && /^[A-Z][A-Z0-9_]{2,}\s*\(/.test(trimmed);
+    if (startsInvocation || invocationDepth > 0) {
+      invocationDepth += parenDelta(line);
+      normalized.push(maskLine(line));
+      maskedRanges.push([byteOffset, byteOffset + lineBytes]);
+      maskedInvocations += 1;
+      if (invocationDepth <= 0) invocationDepth = 0;
+      byteOffset += lineBytes + 1;
+      continue;
+    }
+    let rewritten = line;
+    const suffix = /\b([A-Z][A-Z0-9_]{2,})(?=\s*;\s*(?:\/\/.*)?$)/.exec(line);
+    if (suffix?.index !== void 0) {
+      const before = line.slice(0, suffix.index);
+      const closingParen = before.lastIndexOf(")");
+      const between = closingParen >= 0 ? before.slice(closingParen + 1) : "";
+      if (closingParen >= 0 && /^\s*(?:(?:const|final|noexcept|override)\s*)*$/.test(between)) {
+        const token = suffix[1];
+        const tokenIndex = suffix.index;
+        rewritten = `${line.slice(0, tokenIndex)}${" ".repeat(token.length)}${line.slice(tokenIndex + token.length)}`;
+        const tokenByte = byteOffset + Buffer.byteLength(line.slice(0, tokenIndex), "utf8");
+        maskedRanges.push([tokenByte, tokenByte + token.length]);
+        maskedSuffixes += 1;
+      }
+    }
+    normalized.push(rewritten);
+    byteOffset += lineBytes + 1;
+  }
+  return { source: normalized.join("\n"), maskedRanges, maskedDefinitions, maskedInvocations, maskedSuffixes };
+}
+function lexicalScopeEnd(node, language, source) {
+  if (language !== "c" && language !== "cpp") return node.endIndex;
+  const body = node.childForFieldName("body");
+  if (!body) return node.endIndex;
+  const bytes = Buffer.from(source, "utf8");
+  let opening = body.startIndex;
+  while (opening < Math.min(bytes.length, node.endIndex) && bytes[opening] !== 123) opening += 1;
+  if (opening >= Math.min(bytes.length, node.endIndex)) return node.endIndex;
+  let depth = 0;
+  let quote = 0;
+  let lineComment = false;
+  let blockComment = false;
+  for (let index = opening; index < bytes.length; index += 1) {
+    const current = bytes[index];
+    const next = bytes[index + 1];
+    if (lineComment) {
+      if (current === 10) lineComment = false;
+      continue;
+    }
+    if (blockComment) {
+      if (current === 42 && next === 47) {
+        blockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (quote !== 0) {
+      if (current === 92) {
+        index += 1;
+        continue;
+      }
+      if (current === quote) quote = 0;
+      continue;
+    }
+    if (current === 47 && next === 47) {
+      lineComment = true;
+      index += 1;
+      continue;
+    }
+    if (current === 47 && next === 42) {
+      blockComment = true;
+      index += 1;
+      continue;
+    }
+    if (current === 34 || current === 39) {
+      quote = current;
+      continue;
+    }
+    if (current === 123) depth += 1;
+    else if (current === 125) {
+      depth -= 1;
+      if (depth === 0) return index + 1;
+    }
+  }
+  return node.endIndex;
+}
+function extractFacts(root, language, filePath, sourceHash, sourceBytes, parseMs, parserSource, normalization) {
+  const symbols = [];
+  const imports = [];
+  const calls = [];
+  const diagnostics = [];
+  const errorRanges = [];
+  let errorNodes = 0;
+  let missingNodes = 0;
+  const packageName = javaPackageName(root, language);
+  const stack = [{
+    node: root,
+    scopes: packageName ? [{ name: packageName, endByte: Number.MAX_SAFE_INTEGER }] : []
+  }];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) continue;
+    const { node } = current;
+    const scopes = [...current.scopes];
+    while (scopes.length > 0 && scopes.at(-1).endByte <= node.startIndex) scopes.pop();
+    const scope = scopes.map((entry) => entry.name);
+    if (node.isMissing) {
+      missingNodes += 1;
+      if (diagnostics.length < 1e3) diagnostics.push({ code: "parse_error", severity: "warning", message: `parser inserted missing ${node.type}`, span: spanFor(node) });
+    }
+    if (node.isError) {
+      errorNodes += 1;
+      errorRanges.push([node.startIndex, node.endIndex]);
+      if (diagnostics.length < 1e3) diagnostics.push({ code: "parse_error", severity: "warning", message: "Tree-sitter could not parse this source range", span: spanFor(node) });
+    }
+    const recovered = node.isError || Boolean(ancestor(node, (candidate) => candidate.isError));
+    const kind = recovered ? void 0 : symbolKind(node, language);
+    let childScopes = scopes;
+    if (kind && symbols.length < MAX_FACTS_PER_KIND) {
+      const name = symbolName(node);
+      if (name) {
+        const span = spanFor(node);
+        const qualifiedName = [...scope, name].join(".");
+        const docComment = leadingDocComment(node, language);
+        const classMetadata = {
+          ...dartClassMetadata(node, language, kind),
+          ...javaClassMetadata(node, language, kind),
+          ...javaSymbolVisibility(node, language, kind)
+        };
+        symbols.push({
+          factId: `symbol_${sha256(`${sourceHash}\0${filePath}\0${kind}\0${qualifiedName}\0${span.startByte}`).slice(0, 24)}`,
+          path: filePath,
+          language,
+          kind,
+          name,
+          qualifiedName,
+          signature: signatureFor(node),
+          ...docComment ? { docComment } : {},
+          ...classMetadata,
+          nodeType: node.type,
+          span,
+          confidence: "high",
+          provenance: "tree_sitter"
+        });
+        if (SCOPE_KINDS.has(kind)) childScopes = [...scopes, {
+          name,
+          endByte: lexicalScopeEnd(node, language, parserSource)
+        }];
+      }
+    }
+    if (!recovered && IMPORT_TYPES.has(node.type) && !(language === "java" && node.type === "package_declaration") && imports.length < MAX_FACTS_PER_KIND) {
+      const fact = importFact(node, language, filePath, sourceHash);
+      if (fact) imports.push(fact);
+    }
+    if (!recovered && CALL_TYPES.has(node.type)) {
+      const dynamicImport = imports.length < MAX_FACTS_PER_KIND ? dynamicImportFact(node, language, filePath, sourceHash) : void 0;
+      if (dynamicImport) imports.push(dynamicImport);
+      else if (calls.length < MAX_FACTS_PER_KIND) {
+        const fact = callFact(node, language, filePath, sourceHash);
+        if (fact) calls.push(fact);
+      }
+    }
+    const children = node.namedChildren;
+    for (let index = children.length - 1; index >= 0; index -= 1) {
+      const child = children[index];
+      if (child) stack.push({ node: child, scopes: childScopes });
+    }
+  }
+  if (normalization && normalization.maskedRanges.length > 0) {
+    diagnostics.push({
+      code: "unsupported_construct",
+      severity: "warning",
+      message: `parser masked ${normalization.maskedDefinitions} C/C++ macro-definition lines, ${normalization.maskedInvocations} declaration-macro lines, and ${normalization.maskedSuffixes} declaration suffixes while preserving source offsets`
+    });
+  }
+  if (symbols.length >= MAX_FACTS_PER_KIND || imports.length >= MAX_FACTS_PER_KIND || calls.length >= MAX_FACTS_PER_KIND) {
+    diagnostics.push({ code: "unsupported_construct", severity: "warning", message: `fact extraction reached the per-file cap of ${MAX_FACTS_PER_KIND}` });
+  }
+  const errorBytes = mergeErrorRanges(errorRanges);
+  return {
+    symbols,
+    imports,
+    calls,
+    diagnostics,
+    coverage: {
+      sourceBytes,
+      parsedBytes: Math.max(0, sourceBytes - errorBytes),
+      errorBytes,
+      errorByteRatio: sourceBytes === 0 ? 0 : errorBytes / sourceBytes,
+      errorNodes,
+      missingNodes,
+      parseMs
+    }
+  };
+}
+async function parseWithTreeSitter(input) {
+  const filePath = normalizeRepoPath(input.path);
+  const language = input.language ?? detectLanguage(filePath, input.source.slice(0, 500));
+  if (!language) return void 0;
+  const sourceBytes = Buffer.byteLength(input.source, "utf8");
+  if (sourceBytes > MAX_SOURCE_BYTES) {
+    const sourceHash2 = input.sourceSha256 ?? sha256(input.source);
+    return {
+      schemaVersion: 1,
+      status: "failed",
+      path: filePath,
+      language,
+      sourceSha256: sourceHash2,
+      parserRuntime: "unavailable",
+      grammar: { id: "unloaded", abi: 0, sha256: "0".repeat(64), runtime: "unavailable", source: "none", license: "none" },
+      rootType: "",
+      symbols: [],
+      imports: [],
+      calls: [],
+      diagnostics: [{ code: "parser_failure", severity: "error", message: `source exceeds the ${MAX_SOURCE_BYTES}-byte parser limit` }],
+      coverage: { sourceBytes, parsedBytes: 0, errorBytes: sourceBytes, errorByteRatio: 1, errorNodes: 0, missingNodes: 0, parseMs: 0 }
+    };
+  }
+  let loaded;
+  try {
+    loaded = await loadGrammar(language, filePath, { assetRoot: input.assetRoot, coreWasmPath: input.coreWasmPath });
+  } catch (error) {
+    if (error instanceof GrammarLoadError) throw error;
+    throw new GrammarLoadError("grammar_unavailable", error instanceof Error ? error.message : String(error));
+  }
+  if (!loaded) return void 0;
+  assertAstQueryCompatible(language, filePath, loaded.language, input.assetRoot);
+  const sourceHash = input.sourceSha256 ?? sha256(input.source);
+  const parser = new Parser2();
+  parser.setLanguage(loaded.language);
+  const startedAt = performance3.now();
+  const timeoutMs = input.timeoutMs ?? DEFAULT_AST_FILE_TIMEOUT_MS;
+  let timedOut = false;
+  try {
+    const parseOptions = {
+      progressCallback: () => {
+        timedOut = performance3.now() - startedAt > timeoutMs;
+        return timedOut;
+      }
+    };
+    const rawTree = parser.parse(input.source, null, parseOptions);
+    const parseMs = performance3.now() - startedAt;
+    if (!rawTree) {
+      return {
+        schemaVersion: 1,
+        status: "failed",
+        path: filePath,
+        language,
+        sourceSha256: sourceHash,
+        parserRuntime: "web-tree-sitter",
+        grammar: loaded.provenance,
+        rootType: "",
+        symbols: [],
+        imports: [],
+        calls: [],
+        diagnostics: [{ code: timedOut ? "parse_timeout" : "parser_failure", severity: "error", message: timedOut ? `Tree-sitter exceeded ${timeoutMs}ms` : "Tree-sitter returned no syntax tree" }],
+        coverage: { sourceBytes, parsedBytes: 0, errorBytes: sourceBytes, errorByteRatio: sourceBytes === 0 ? 0 : 1, errorNodes: 0, missingNodes: 0, parseMs }
+      };
+    }
+    const trees = [rawTree];
+    try {
+      let selectedTree = rawTree;
+      let parserSource = input.source;
+      let selectedNormalization;
+      if (language === "c" || language === "cpp") {
+        const rawScore = syntaxRecoveryScore(rawTree.rootNode);
+        if (rawScore.errorNodes > 0 || rawScore.missingNodes > 0) {
+          const normalization = normalizeCppParserSource(input.source);
+          if (normalization.maskedRanges.length > 0) {
+            const normalizedTree = parser.parse(normalization.source, null, parseOptions);
+            if (normalizedTree) {
+              trees.push(normalizedTree);
+              const normalizedScore = syntaxRecoveryScore(normalizedTree.rootNode);
+              if (hasBetterSyntaxRecovery(normalizedScore, rawScore)) {
+                selectedTree = normalizedTree;
+                parserSource = normalization.source;
+                selectedNormalization = normalization;
+              }
+            }
+          }
+        }
+      }
+      const root = selectedTree.rootNode;
+      const totalParseMs = performance3.now() - startedAt;
+      const extracted = extractFacts(root, language, filePath, sourceHash, sourceBytes, totalParseMs, parserSource, selectedNormalization);
+      return {
+        schemaVersion: 1,
+        status: extracted.coverage.errorNodes > 0 || extracted.coverage.missingNodes > 0 || extracted.diagnostics.length > 0 ? "partial" : "parsed",
+        path: filePath,
+        language,
+        sourceSha256: sourceHash,
+        parserRuntime: "web-tree-sitter",
+        grammar: loaded.provenance,
+        rootType: root.type,
+        symbols: extracted.symbols,
+        imports: extracted.imports,
+        calls: extracted.calls,
+        diagnostics: extracted.diagnostics,
+        coverage: extracted.coverage
+      };
+    } finally {
+      for (const tree of trees) tree.delete();
+    }
+  } finally {
+    parser.delete();
+  }
+}
+
+// ../packages/brain-ast/src/parse-source.ts
+function unavailableResult(input, language, status, code, message2) {
+  const sourceBytes = Buffer.byteLength(input.source, "utf8");
+  return {
+    schemaVersion: 1,
+    status,
+    path: normalizeRepoPath(input.path),
+    language,
+    sourceSha256: sha256(input.source),
+    parserRuntime: "unavailable",
+    grammar: { id: "unavailable", abi: 0, sha256: "0".repeat(64), runtime: "unavailable", source: "none", license: "none" },
+    rootType: "",
+    symbols: [],
+    imports: [],
+    calls: [],
+    diagnostics: [{ code, severity: status === "failed" ? "error" : "warning", message: message2 }],
+    coverage: {
+      sourceBytes,
+      parsedBytes: 0,
+      errorBytes: status === "failed" ? sourceBytes : 0,
+      errorByteRatio: status === "failed" && sourceBytes > 0 ? 1 : 0,
+      errorNodes: 0,
+      missingNodes: 0,
+      parseMs: 0
+    }
+  };
+}
+async function parseSource(input) {
+  const actualSha = sha256(input.source);
+  if (input.sourceSha256 && input.sourceSha256 !== actualSha) {
+    throw new Error(`source hash mismatch for ${input.path}: expected ${input.sourceSha256}, received ${actualSha}`);
+  }
+  const normalized = { ...input, path: normalizeRepoPath(input.path), sourceSha256: actualSha };
+  const language = input.language ?? detectLanguage(normalized.path, input.source.slice(0, 500));
+  if (!language) return void 0;
+  const fallback = parseStructuralFallback(normalized, language);
+  if (fallback) return fallback;
+  try {
+    const parsed = await parseWithTreeSitter({ ...normalized, language });
+    return parsed ?? unavailableResult(normalized, language, "unsupported", "grammar_unavailable", `no parser runtime is registered for ${language}`);
+  } catch (error) {
+    if (error instanceof GrammarLoadError) {
+      return unavailableResult(normalized, language, "failed", error.code, error.message);
+    }
+    return unavailableResult(normalized, language, "failed", "parser_failure", error instanceof Error ? error.message : String(error));
+  }
+}
+
+// ../packages/brain-ast/src/worker-protocol.ts
+var AST_WORKER_PROTOCOL_VERSION = 1;
+function isAstWorkerRequest(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return candidate.protocolVersion === AST_WORKER_PROTOCOL_VERSION && candidate.type === "parse" && typeof candidate.jobId === "number" && Number.isSafeInteger(candidate.jobId) && candidate.jobId >= 0 && Boolean(candidate.input) && typeof candidate.input === "object" && typeof candidate.input.path === "string" && typeof candidate.input.source === "string";
+}
+function isAstWorkerResponse(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  if (candidate.protocolVersion !== AST_WORKER_PROTOCOL_VERSION || candidate.type !== "result" && candidate.type !== "error" || typeof candidate.jobId !== "number" || !Number.isSafeInteger(candidate.jobId) || candidate.jobId < 0 || typeof candidate.threadId !== "number" || !Number.isSafeInteger(candidate.threadId) || candidate.threadId <= 0) return false;
+  if (candidate.type === "result") return "result" in candidate;
+  const serialized = "error" in candidate ? candidate.error : void 0;
+  return Boolean(serialized) && typeof serialized === "object" && typeof serialized.name === "string" && typeof serialized.message === "string";
+}
+
+export {
+  canonicalize,
+  sha256,
+  hashObject,
+  createId,
+  normalizeRepoPath,
+  assertInside,
+  aggregateGate,
+  exitCodeForGate,
+  nowIso,
+  walkRepo,
+  parseManifests,
+  synthesizeStack,
+  chunkMarkdown,
+  findConventionalSourcePaths,
+  AST_QUERY_VERSION,
+  DEFAULT_AST_FILE_TIMEOUT_MS,
+  isAstTypeDeclarationKind,
+  parserRuntimeForGrammar,
+  parseSource,
+  AST_WORKER_PROTOCOL_VERSION,
+  isAstWorkerRequest,
+  isAstWorkerResponse
+};
+//# sourceMappingURL=chunk-6TLQP3LV.js.map