@vibgrate/cli 2026.722.2 → 2026.727.1

package/dist/chunk-5I4VSBWQ.js

@@ -0,0 +1,764 @@
+import { repositoryIdFromRoot, globalGraphPathForRef, globalGraphPath } from './chunk-BWPBB45M.js';
+import { detectGitRef } from './chunk-BPF3YX2U.js';
+import * as fs from 'fs';
+import * as path5 from 'path';
+
+function normalizeWorkspaceRoots(roots, base = process.cwd()) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const baseAbs = path5.resolve(base);
+  for (const r of roots) {
+    if (typeof r !== "string" || !r.trim()) continue;
+    const abs = path5.resolve(baseAbs, r.trim());
+    const id = repositoryIdFromRoot(abs);
+    if (seen.has(id)) continue;
+    seen.add(id);
+    out.push({
+      root: abs,
+      id,
+      label: path5.basename(abs) || abs
+    });
+  }
+  return out.sort((a, b) => a.root.localeCompare(b.root));
+}
+var BRIDGE_EDGE_SCHEMA_VERSION = "bridge-edge/0";
+function discoverBridgeEdges(members, readPackageJson, options = {}) {
+  const min = options.minConfidence ?? 0;
+  const packages = /* @__PURE__ */ new Map();
+  for (const m of members) {
+    const root = path5.resolve(m.root);
+    const pkg = readPackageJson(root);
+    const name = typeof pkg?.name === "string" ? pkg.name.trim() : "";
+    if (!name) continue;
+    const repositoryId = m.repositoryId ?? repositoryIdFromRoot(root);
+    packages.set(name, { root, repositoryId, name });
+  }
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const m of members) {
+    const fromRoot = path5.resolve(m.root);
+    const fromId = m.repositoryId ?? repositoryIdFromRoot(fromRoot);
+    const pkg = readPackageJson(fromRoot);
+    if (!pkg) continue;
+    const deps = collectDeps(pkg);
+    for (const [depName, range] of deps) {
+      const target = packages.get(depName);
+      if (!target) continue;
+      if (target.root === fromRoot) continue;
+      const { kind, confidence } = classifyDependency(range, fromRoot, target.root);
+      if (confidence < min) continue;
+      const key = `${fromId}->${target.repositoryId}:${depName}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      edges.push({
+        schemaVersion: BRIDGE_EDGE_SCHEMA_VERSION,
+        fromRepositoryId: fromId,
+        toRepositoryId: target.repositoryId,
+        fromRoot,
+        toRoot: target.root,
+        kind,
+        confidence,
+        evidence: `${path5.basename(fromRoot)} depends on ${depName} (${range})`,
+        packageName: depName
+      });
+    }
+  }
+  return edges.sort(
+    (a, b) => a.fromRoot.localeCompare(b.fromRoot) || a.toRoot.localeCompare(b.toRoot) || (a.packageName ?? "").localeCompare(b.packageName ?? "")
+  );
+}
+function highConfidenceBridges(edges) {
+  return edges.filter((e) => e.confidence >= 0.8);
+}
+function collectDeps(pkg) {
+  const out = [];
+  for (const field of ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"]) {
+    const block = pkg[field];
+    if (!block || typeof block !== "object") continue;
+    for (const [name, range] of Object.entries(block)) {
+      if (typeof name === "string" && typeof range === "string") out.push([name, range]);
+    }
+  }
+  return out.sort((a, b) => a[0].localeCompare(b[0]) || a[1].localeCompare(b[1]));
+}
+function classifyDependency(range, fromRoot, toRoot) {
+  const r = range.trim();
+  if (r.startsWith("workspace:") || r.startsWith("link:")) {
+    return { kind: "workspace-package", confidence: 0.95 };
+  }
+  if (r.startsWith("file:")) {
+    const rel = r.slice("file:".length).trim();
+    try {
+      const resolved = path5.resolve(fromRoot, rel);
+      if (path5.resolve(resolved) === path5.resolve(toRoot)) {
+        return { kind: "path-dependency", confidence: 0.9 };
+      }
+    } catch {
+    }
+    return { kind: "path-dependency", confidence: 0.75 };
+  }
+  return { kind: "workspace-package", confidence: 0.55 };
+}
+function parsePackageManifest(raw) {
+  try {
+    const o = JSON.parse(raw);
+    if (!o || typeof o !== "object") return null;
+    return o;
+  } catch {
+    return null;
+  }
+}
+function discoverInterfaceBridges(members, fs2, options = {}) {
+  const min = options.minConfidence ?? 0;
+  const maxFiles = options.maxFilesPerMember ?? 40;
+  const resolved = members.map((m) => ({
+    root: path5.resolve(m.root),
+    repositoryId: m.repositoryId ?? repositoryIdFromRoot(m.root)
+  }));
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (edge) => {
+    if (edge.confidence < min) return;
+    if (edge.fromRoot === edge.toRoot) return;
+    const key = `${edge.fromRepositoryId}->${edge.toRepositoryId}:${edge.kind}:${edge.evidence}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    edges.push(edge);
+  };
+  for (const from of resolved) {
+    const files = listCandidateFiles(from.root, fs2, maxFiles);
+    for (const file of files) {
+      const rel = path5.relative(from.root, file).replace(/\\/g, "/");
+      const raw = fs2.readFile(file);
+      if (!raw) continue;
+      if (isOpenApiCandidate(rel, raw)) {
+        for (const refPath of extractOpenApiRefs(raw)) {
+          const target = resolvePathToMember(from.root, refPath, resolved);
+          if (!target || target.root === from.root) continue;
+          push({
+            schemaVersion: BRIDGE_EDGE_SCHEMA_VERSION,
+            fromRepositoryId: from.repositoryId,
+            toRepositoryId: target.repositoryId,
+            fromRoot: from.root,
+            toRoot: target.root,
+            kind: "openapi-ref",
+            confidence: 0.7,
+            evidence: `openapi $ref in ${rel} \u2192 ${refPath}`
+          });
+        }
+      }
+      if (isComposeCandidate(rel)) {
+        for (const ctx of extractComposeBuildContexts(raw)) {
+          const target = resolvePathToMember(from.root, ctx, resolved);
+          if (!target || target.root === from.root) continue;
+          push({
+            schemaVersion: BRIDGE_EDGE_SCHEMA_VERSION,
+            fromRepositoryId: from.repositoryId,
+            toRepositoryId: target.repositoryId,
+            fromRoot: from.root,
+            toRoot: target.root,
+            kind: "compose-service",
+            confidence: 0.75,
+            evidence: `compose build context in ${rel} \u2192 ${ctx}`
+          });
+        }
+      }
+      if (isProtoCandidate(rel)) {
+        for (const imp of extractProtoImports(raw)) {
+          const target = resolveProtoImportToMember(from.root, imp, resolved, fs2);
+          if (!target || target.root === from.root) continue;
+          push({
+            schemaVersion: BRIDGE_EDGE_SCHEMA_VERSION,
+            fromRepositoryId: from.repositoryId,
+            toRepositoryId: target.repositoryId,
+            fromRoot: from.root,
+            toRoot: target.root,
+            kind: "protobuf-import",
+            confidence: 0.72,
+            evidence: `protobuf import in ${rel} \u2192 ${imp}`
+          });
+        }
+      }
+      if (isGraphqlCandidate(rel, raw)) {
+        for (const refPath of extractGraphqlRefs(raw)) {
+          const target = resolvePathToMember(from.root, refPath, resolved);
+          if (!target || target.root === from.root) continue;
+          push({
+            schemaVersion: BRIDGE_EDGE_SCHEMA_VERSION,
+            fromRepositoryId: from.repositoryId,
+            toRepositoryId: target.repositoryId,
+            fromRoot: from.root,
+            toRoot: target.root,
+            kind: "graphql-ref",
+            confidence: 0.68,
+            evidence: `graphql import in ${rel} \u2192 ${refPath}`
+          });
+        }
+      }
+    }
+  }
+  return edges.sort(
+    (a, b) => a.fromRoot.localeCompare(b.fromRoot) || a.toRoot.localeCompare(b.toRoot) || a.kind.localeCompare(b.kind) || a.evidence.localeCompare(b.evidence)
+  );
+}
+function listCandidateFiles(root, fs2, maxFiles) {
+  const out = [];
+  const walk = (dir, depth) => {
+    if (out.length >= maxFiles || depth > 4) return;
+    let names;
+    try {
+      names = fs2.readdir(dir);
+    } catch {
+      return;
+    }
+    for (const name of names.sort((a, b) => a.localeCompare(b))) {
+      if (out.length >= maxFiles) return;
+      if (name === "node_modules" || name === ".git" || name === "dist" || name === "build" || name === "coverage" || name === ".next") {
+        continue;
+      }
+      const abs = path5.join(dir, name);
+      if (fs2.isDirectory(abs)) {
+        walk(abs, depth + 1);
+        continue;
+      }
+      const lower = name.toLowerCase();
+      if (lower.endsWith(".proto") || lower.endsWith(".graphql") || lower.endsWith(".gql") || lower.endsWith(".yaml") || lower.endsWith(".yml") || lower.endsWith(".json") || lower.includes("openapi") || lower.includes("swagger") || lower.includes("compose")) {
+        out.push(abs);
+      }
+    }
+  };
+  walk(root, 0);
+  return out.sort((a, b) => a.localeCompare(b));
+}
+function isOpenApiCandidate(rel, raw) {
+  const lower = rel.toLowerCase();
+  if (lower.includes("openapi") || lower.includes("swagger")) return true;
+  if (/"openapi"\s*:/.test(raw) || /openapi:\s*['"]?\d/.test(raw)) return true;
+  if (/"swagger"\s*:/.test(raw) || /swagger:\s*['"]?\d/.test(raw)) return true;
+  return false;
+}
+function extractOpenApiRefs(raw) {
+  const out = /* @__PURE__ */ new Set();
+  const jsonRef = /"\$ref"\s*:\s*"([^"#][^"]*)"/g;
+  let m;
+  while ((m = jsonRef.exec(raw)) !== null) {
+    if (m[1] && !m[1].startsWith("http")) out.add(m[1]);
+  }
+  const yamlRef = /\$ref:\s*['"]?([^'"#\s][^'"\s]*)/g;
+  while ((m = yamlRef.exec(raw)) !== null) {
+    if (m[1] && !m[1].startsWith("http") && !m[1].startsWith("#")) out.add(m[1]);
+  }
+  return [...out].sort((a, b) => a.localeCompare(b));
+}
+function isComposeCandidate(rel) {
+  const base = path5.basename(rel).toLowerCase();
+  return base === "docker-compose.yml" || base === "docker-compose.yaml" || base === "compose.yml" || base === "compose.yaml" || base.includes("docker-compose");
+}
+function extractComposeBuildContexts(raw) {
+  const out = /* @__PURE__ */ new Set();
+  const lines = raw.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const simple = line.match(/^\s*build:\s*['"]?([^'"#\s][^'"#]*?)['"]?\s*(?:#.*)?$/);
+    if (simple?.[1] && !simple[1].startsWith("{") && !/^\s*$/.test(simple[1])) {
+      const v = simple[1].trim();
+      if (v && v !== "null" && !v.includes(":")) out.add(v);
+      continue;
+    }
+    if (/^\s*build:\s*$/.test(line) || /^\s*build:\s*\{\s*$/.test(line)) {
+      for (let j = i + 1; j < Math.min(i + 8, lines.length); j++) {
+        const ctx = (lines[j] ?? "").match(/^\s*context:\s*['"]?([^'"#\s][^'"#]*?)['"]?\s*(?:#.*)?$/);
+        if (ctx?.[1]) {
+          out.add(ctx[1].trim());
+          break;
+        }
+        if (/^\S/.test(lines[j] ?? "") || /^\s{0,2}\w/.test(lines[j] ?? "")) {
+          if ((lines[j] ?? "").match(/^\s{0,2}\S/) && !(lines[j] ?? "").match(/^\s{4,}/)) break;
+        }
+      }
+    }
+  }
+  return [...out].sort((a, b) => a.localeCompare(b));
+}
+function isProtoCandidate(rel) {
+  return rel.toLowerCase().endsWith(".proto");
+}
+function isGraphqlCandidate(rel, raw) {
+  const lower = rel.toLowerCase();
+  if (lower.endsWith(".graphql") || lower.endsWith(".gql")) return true;
+  if (lower.includes("schema") && /#\s*import\b/.test(raw)) return true;
+  return false;
+}
+function extractGraphqlRefs(raw) {
+  const out = /* @__PURE__ */ new Set();
+  const re = /#\s*import\s+(?:\*\s+from\s+)?["']([^"']+)["']/g;
+  let m;
+  while ((m = re.exec(raw)) !== null) {
+    if (m[1] && !m[1].startsWith("http")) out.add(m[1]);
+  }
+  return [...out].sort((a, b) => a.localeCompare(b));
+}
+function extractProtoImports(raw) {
+  const out = /* @__PURE__ */ new Set();
+  const re = /^\s*import\s+(?:public\s+|weak\s+)?["']([^"']+)["']\s*;/gm;
+  let m;
+  while ((m = re.exec(raw)) !== null) {
+    if (m[1] && !m[1].startsWith("google/protobuf/")) out.add(m[1]);
+  }
+  return [...out].sort((a, b) => a.localeCompare(b));
+}
+function resolvePathToMember(fromRoot, relOrAbs, members) {
+  let abs;
+  try {
+    abs = path5.isAbsolute(relOrAbs) ? path5.resolve(relOrAbs) : path5.resolve(fromRoot, relOrAbs);
+  } catch {
+    return null;
+  }
+  let best = null;
+  for (const m of members) {
+    if (abs === m.root || abs.startsWith(m.root + path5.sep)) {
+      if (!best || m.root.length > best.root.length) best = m;
+    }
+  }
+  return best;
+}
+function resolveProtoImportToMember(fromRoot, importPath, members, fs2) {
+  const candidates = [
+    path5.resolve(fromRoot, importPath),
+    ...members.map((m) => path5.resolve(m.root, importPath))
+  ];
+  for (const abs of candidates) {
+    const hit = resolvePathToMember(fromRoot, abs, members);
+    if (!hit) continue;
+    if (fs2.readFile(abs) !== null || pathIsUnder(abs, hit.root)) {
+      if (hit.root !== path5.resolve(fromRoot)) return hit;
+    }
+  }
+  const parts = importPath.replace(/\\/g, "/").split("/");
+  if (parts.length >= 2) {
+    const prefix = parts[0];
+    for (const m of members) {
+      if (path5.basename(m.root) === prefix && m.root !== path5.resolve(fromRoot)) return m;
+    }
+  }
+  return null;
+}
+function pathIsUnder(child, parent) {
+  const rel = path5.relative(path5.resolve(parent), path5.resolve(child));
+  return rel === "" || !rel.startsWith("..") && !path5.isAbsolute(rel);
+}
+var DISCOVER_WORKSPACES_VERSION = "discover-workspaces/0";
+function discoverWorkspaceRoots(primaryRoot, fs2, options = {}) {
+  const primary = path5.resolve(primaryRoot);
+  const maxDepth = options.maxDepth ?? 4;
+  const maxRoots = options.maxRoots ?? 64;
+  const byRoot = /* @__PURE__ */ new Map();
+  const add = (abs, source, label) => {
+    const root = path5.resolve(abs);
+    if (byRoot.has(root)) {
+      return;
+    }
+    if (byRoot.size >= maxRoots) return;
+    byRoot.set(root, {
+      root,
+      label: label ?? (path5.basename(root) || root),
+      source
+    });
+  };
+  add(primary, "explicit", path5.basename(primary) || primary);
+  for (const dir of expandPackageWorkspaces(primary, fs2, maxDepth)) {
+    add(dir, "package-workspaces");
+  }
+  for (const dir of expandPnpmWorkspace(primary, fs2, maxDepth)) {
+    add(dir, "pnpm-workspace");
+  }
+  for (const dir of expandGitSubmodules(primary, fs2)) {
+    add(dir, "git-submodule");
+  }
+  for (const dir of expandCodeWorkspace(primary, fs2)) {
+    add(dir, "code-workspace");
+  }
+  const roots = [...byRoot.values()].sort((a, b) => a.root.localeCompare(b.root));
+  return {
+    schemaVersion: DISCOVER_WORKSPACES_VERSION,
+    primaryRoot: primary,
+    roots
+  };
+}
+function expandPackageWorkspaces(primary, fs2, maxDepth) {
+  const pkgPath = path5.join(primary, "package.json");
+  const raw = fs2.readFile(pkgPath);
+  if (!raw) return [];
+  let pkg;
+  try {
+    pkg = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  const patterns = workspacePatterns(pkg.workspaces);
+  return expandGlobPatterns(primary, patterns, fs2, maxDepth);
+}
+function workspacePatterns(workspaces) {
+  if (Array.isArray(workspaces)) {
+    return workspaces.filter((p) => typeof p === "string" && p.trim().length > 0);
+  }
+  if (workspaces && typeof workspaces === "object" && Array.isArray(workspaces.packages)) {
+    return workspaces.packages.filter(
+      (p) => typeof p === "string" && p.trim().length > 0
+    );
+  }
+  return [];
+}
+function expandPnpmWorkspace(primary, fs2, maxDepth) {
+  const raw = fs2.readFile(path5.join(primary, "pnpm-workspace.yaml"));
+  if (!raw) return [];
+  const patterns = [];
+  let inPackages = false;
+  for (const line of raw.split(/\r?\n/)) {
+    if (/^packages\s*:/.test(line)) {
+      inPackages = true;
+      continue;
+    }
+    if (inPackages) {
+      if (/^\S/.test(line) && !/^\s/.test(line)) break;
+      const m = line.match(/^\s*-\s*['"]?([^'"]+)['"]?\s*$/);
+      if (m?.[1]) patterns.push(m[1].trim());
+    }
+  }
+  return expandGlobPatterns(primary, patterns, fs2, maxDepth);
+}
+function expandGitSubmodules(primary, fs2) {
+  const raw = fs2.readFile(path5.join(primary, ".gitmodules"));
+  if (!raw) return [];
+  const out = [];
+  for (const line of raw.split(/\r?\n/)) {
+    const m = line.match(/^\s*path\s*=\s*(.+)\s*$/);
+    if (!m?.[1]) continue;
+    const abs = path5.resolve(primary, m[1].trim());
+    if (fs2.exists(abs) && fs2.isDirectory(abs)) out.push(abs);
+  }
+  return out.sort((a, b) => a.localeCompare(b));
+}
+function expandCodeWorkspace(primary, fs2) {
+  const out = [];
+  const candidates = [
+    ...fs2.readdir(primary).filter((n) => n.endsWith(".code-workspace")).map((n) => path5.join(primary, n))
+  ];
+  for (const file of candidates) {
+    const raw = fs2.readFile(file);
+    if (!raw) continue;
+    let doc;
+    try {
+      doc = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    const base = path5.dirname(file);
+    for (const folder of doc.folders ?? []) {
+      if (typeof folder.path !== "string" || !folder.path.trim()) continue;
+      const abs = path5.resolve(base, folder.path.trim());
+      if (fs2.exists(abs) && fs2.isDirectory(abs)) out.push(abs);
+    }
+  }
+  return out.sort((a, b) => a.localeCompare(b));
+}
+function expandGlobPatterns(primary, patterns, fs2, maxDepth) {
+  const out = /* @__PURE__ */ new Set();
+  for (const pattern of patterns) {
+    const p = pattern.replace(/\\/g, "/").replace(/^\.\//, "");
+    if (!p || p.startsWith("..")) continue;
+    if (p.includes("*")) {
+      for (const hit of expandSimpleGlob(primary, p, fs2, maxDepth)) {
+        if (looksLikePackageRoot(hit, fs2)) out.add(hit);
+      }
+    } else {
+      const abs = path5.resolve(primary, p);
+      if (fs2.exists(abs) && fs2.isDirectory(abs) && looksLikePackageRoot(abs, fs2)) out.add(abs);
+    }
+  }
+  return [...out].sort((a, b) => a.localeCompare(b));
+}
+function expandSimpleGlob(primary, pattern, fs2, maxDepth) {
+  const parts = pattern.split("/").filter(Boolean);
+  let currents = [primary];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    const next = [];
+    const isLast = i === parts.length - 1;
+    for (const cur of currents) {
+      if (part === "**") {
+        for (const d of walkDirs(cur, fs2, Math.min(maxDepth, 3))) next.push(d);
+        continue;
+      }
+      if (part === "*") {
+        for (const name of fs2.readdir(cur)) {
+          const abs2 = path5.join(cur, name);
+          if (fs2.isDirectory(abs2)) next.push(abs2);
+        }
+        continue;
+      }
+      const abs = path5.join(cur, part);
+      if (fs2.exists(abs) && (isLast ? fs2.isDirectory(abs) || fs2.exists(abs) : fs2.isDirectory(abs))) {
+        next.push(abs);
+      }
+    }
+    currents = next;
+    if (!currents.length) break;
+  }
+  return currents.filter((d) => fs2.isDirectory(d));
+}
+function walkDirs(root, fs2, depth) {
+  if (depth <= 0) return [];
+  const out = [];
+  for (const name of fs2.readdir(root)) {
+    if (name === "node_modules" || name === ".git" || name === "dist" || name === "build") continue;
+    const abs = path5.join(root, name);
+    if (!fs2.isDirectory(abs)) continue;
+    out.push(abs);
+    out.push(...walkDirs(abs, fs2, depth - 1));
+  }
+  return out;
+}
+function looksLikePackageRoot(dir, fs2) {
+  return fs2.exists(path5.join(dir, "package.json"));
+}
+function nodeDiscoverFs() {
+  return {
+    readFile(absPath) {
+      try {
+        return fs.readFileSync(absPath, "utf8");
+      } catch {
+        return null;
+      }
+    },
+    readdir(absPath) {
+      try {
+        return fs.readdirSync(absPath).sort((a, b) => a.localeCompare(b));
+      } catch {
+        return [];
+      }
+    },
+    isDirectory(absPath) {
+      try {
+        return fs.statSync(absPath).isDirectory();
+      } catch {
+        return false;
+      }
+    },
+    exists(absPath) {
+      try {
+        return fs.existsSync(absPath);
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+
+// src/runtime/federation.ts
+var FEDERATION_SCHEMA_VERSION = "federation/0";
+function loadFederation(primaryRoot, options = {}) {
+  const primary = path5.resolve(primaryRoot);
+  const file = federationPath(primary);
+  if (!fs.existsSync(file)) {
+    if (options.requireFile) return null;
+    return singleMemberFederation(primary);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+  return parseFederationFile(primary, raw);
+}
+function loadOrDiscoverFederation(primaryRoot, options = {}) {
+  const primary = path5.resolve(primaryRoot);
+  const existing = loadFederation(primary, { requireFile: true });
+  if (existing) {
+    if (!existing.bridges?.length) {
+      existing.bridges = bridgesForMembers(existing.members, options.minBridgeConfidence);
+    }
+    return existing;
+  }
+  const dfs = options.discoverFs ?? nodeDiscoverFs();
+  const discovered = discoverWorkspaceRoots(primary, dfs);
+  const roots = discovered.roots.map((r) => r.root);
+  const fed = federationFromWorkspaceRoots(roots, { preferredPrimary: primary });
+  fed.bridges = bridgesForMembers(fed.members, options.minBridgeConfidence);
+  return fed;
+}
+function bridgesForMembers(members, minConfidence = 0.5) {
+  const memberRefs = members.map((m) => ({ root: m.root, repositoryId: m.repositoryId }));
+  const pkgEdges = discoverBridgeEdges(
+    memberRefs,
+    (root) => {
+      try {
+        const raw = fs.readFileSync(path5.join(root, "package.json"), "utf8");
+        return parsePackageManifest(raw);
+      } catch {
+        return null;
+      }
+    },
+    { minConfidence }
+  );
+  const ifaceEdges = discoverInterfaceBridges(
+    memberRefs,
+    {
+      readFile(absPath) {
+        try {
+          return fs.readFileSync(absPath, "utf8");
+        } catch {
+          return null;
+        }
+      },
+      readdir(absPath) {
+        try {
+          return fs.readdirSync(absPath).sort((a, b) => a.localeCompare(b));
+        } catch {
+          return [];
+        }
+      },
+      isDirectory(absPath) {
+        try {
+          return fs.statSync(absPath).isDirectory();
+        } catch {
+          return false;
+        }
+      }
+    },
+    { minConfidence }
+  );
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const e of [...pkgEdges, ...ifaceEdges].sort(
+    (a, b) => a.fromRoot.localeCompare(b.fromRoot) || a.toRoot.localeCompare(b.toRoot) || a.kind.localeCompare(b.kind) || a.evidence.localeCompare(b.evidence)
+  )) {
+    const key = `${e.fromRepositoryId}|${e.toRepositoryId}|${e.kind}|${e.evidence}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(e);
+  }
+  return out;
+}
+function federationPath(primaryRoot) {
+  return path5.join(path5.resolve(primaryRoot), ".vibgrate", "federation.json");
+}
+function singleMemberFederation(primaryRoot) {
+  const primary = path5.resolve(primaryRoot);
+  const [ws] = normalizeWorkspaceRoots([primary], primary);
+  return {
+    schemaVersion: FEDERATION_SCHEMA_VERSION,
+    primaryRoot: primary,
+    members: [
+      memberFromRoot(ws?.root ?? primary, "primary", ws?.label ?? (path5.basename(primary) || primary))
+    ]
+  };
+}
+function parseFederationFile(primaryRoot, raw) {
+  const primary = path5.resolve(primaryRoot);
+  if (!raw || typeof raw !== "object") return null;
+  const list = Array.isArray(raw.members) ? raw.members : [];
+  if (!list.length) return singleMemberFederation(primary);
+  const members = [];
+  const seen = /* @__PURE__ */ new Set();
+  let hasPrimary = false;
+  for (const entry of list) {
+    if (!entry || typeof entry.root !== "string" || !entry.root.trim()) continue;
+    const abs = path5.resolve(primary, entry.root.trim());
+    const id = repositoryIdFromRoot(abs);
+    if (seen.has(id)) continue;
+    seen.add(id);
+    const role = entry.role === "primary" || abs === primary ? "primary" : "member";
+    if (role === "primary") hasPrimary = true;
+    members.push(memberFromRoot(abs, role, typeof entry.label === "string" && entry.label.trim() ? entry.label.trim() : path5.basename(abs) || abs));
+  }
+  if (!members.length) return singleMemberFederation(primary);
+  if (!hasPrimary) {
+    const id = repositoryIdFromRoot(primary);
+    if (!seen.has(id)) {
+      members.unshift(memberFromRoot(primary, "primary", path5.basename(primary) || primary));
+    } else {
+      const existing = members.find((m) => m.repositoryId === id);
+      if (existing) existing.role = "primary";
+    }
+  }
+  members.sort((a, b) => {
+    if (a.role !== b.role) return a.role === "primary" ? -1 : 1;
+    return a.root.localeCompare(b.root);
+  });
+  const fed = {
+    schemaVersion: FEDERATION_SCHEMA_VERSION,
+    primaryRoot: primary,
+    members
+  };
+  if (Array.isArray(raw.bridges) && raw.bridges.length) {
+    fed.bridges = raw.bridges.filter((b) => b && typeof b === "object" && typeof b.fromRoot === "string" && typeof b.toRoot === "string").map((b) => ({
+      ...b,
+      fromRoot: path5.resolve(primary, b.fromRoot),
+      toRoot: path5.resolve(primary, b.toRoot)
+    }));
+  }
+  return fed;
+}
+function memberFromRoot(root, role, label) {
+  const git = detectGitRef(root);
+  const graphPath = git.kind !== "none" && git.ref ? globalGraphPathForRef(root, git.ref) : globalGraphPath(root);
+  return {
+    root,
+    label,
+    role,
+    repositoryId: repositoryIdFromRoot(root),
+    graphPath
+  };
+}
+function federationFromWorkspaceRoots(roots, options = {}) {
+  const normalized = normalizeWorkspaceRoots(roots, options.preferredPrimary ?? roots[0] ?? process.cwd());
+  if (!normalized.length) {
+    const fallback = path5.resolve(options.preferredPrimary ?? process.cwd());
+    return singleMemberFederation(fallback);
+  }
+  const preferred = options.preferredPrimary?.trim() ? path5.resolve(options.preferredPrimary.trim()) : normalized[0].root;
+  const primaryHit = normalized.find((r) => r.root === preferred) ?? normalized.find((r) => r.id === repositoryIdFromRoot(preferred)) ?? normalized[0];
+  const primaryRoot = primaryHit.root;
+  const members = normalized.map(
+    (ws) => memberFromRoot(ws.root, ws.root === primaryRoot ? "primary" : "member", ws.label)
+  );
+  members.sort((a, b) => {
+    if (a.role !== b.role) return a.role === "primary" ? -1 : 1;
+    return a.root.localeCompare(b.root);
+  });
+  return {
+    schemaVersion: FEDERATION_SCHEMA_VERSION,
+    primaryRoot,
+    members
+  };
+}
+function writeFederationFile(primaryRoot, federation) {
+  const primary = path5.resolve(primaryRoot);
+  const file = federationPath(primary);
+  fs.mkdirSync(path5.dirname(file), { recursive: true });
+  const body = {
+    schemaVersion: FEDERATION_SCHEMA_VERSION,
+    members: federation.members.map((m) => ({
+      // Prefer path relative to primary when possible so the file is portable.
+      root: path5.relative(primary, m.root) || ".",
+      label: m.label,
+      role: m.role
+    }))
+  };
+  if (federation.bridges?.length) {
+    body.bridges = federation.bridges.map((b) => ({
+      ...b,
+      fromRoot: path5.relative(primary, b.fromRoot) || ".",
+      toRoot: path5.relative(primary, b.toRoot) || "."
+    }));
+  }
+  fs.writeFileSync(file, `${JSON.stringify(body, null, 2)}
+`, "utf8");
+  return file;
+}
+
+export { FEDERATION_SCHEMA_VERSION, federationFromWorkspaceRoots, federationPath, highConfidenceBridges, loadFederation, loadOrDiscoverFederation, parseFederationFile, singleMemberFederation, writeFederationFile };
+//# sourceMappingURL=chunk-5I4VSBWQ.js.map
+//# sourceMappingURL=chunk-5I4VSBWQ.js.map