@eventcatalog/core 4.6.1 → 4.6.3

package/dist/eventcatalog.cjs

@@ -28,11 +28,11 @@ var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 
 // src/eventcatalog.ts
 var import_commander = require("commander");
-var import_node_child_process = require("child_process");
-var import_node_path10 = require("path");
+var import_node_child_process2 = require("child_process");
+var import_node_path14 = require("path");
 var import_node_http = __toESM(require("http"), 1);
 var import_fs3 = __toESM(require("fs"), 1);
-var import_node_path11 = __toESM(require("path"), 1);
+var import_node_path15 = __toESM(require("path"), 1);
 var import_node_url = require("url");
 
 // src/generate.js
@@ -144,7 +144,7 @@ var verifyRequiredFieldsAreInCatalogConfigFile = async (projectDirectory) => {
 var import_picocolors = __toESM(require("picocolors"), 1);
 
 // package.json
-var version = "4.6.1";
+var version = "4.6.3";
 
 // src/constants.ts
 var VERSION = version;
@@ -1256,22 +1256,22 @@ function getAvroTypeName(type) {
 function walkAvroRecord(schema, prefix, fields) {
   if (!schema.fields || !Array.isArray(schema.fields)) return;
   for (const field of schema.fields) {
-    const path11 = prefix ? `${prefix}.${field.name}` : field.name;
+    const path15 = prefix ? `${prefix}.${field.name}` : field.name;
     const isOptional = Array.isArray(field.type) && field.type.includes("null");
     const typeName = getAvroTypeName(field.type);
     fields.push({
-      path: path11,
+      path: path15,
       type: typeName,
       description: field.doc || "",
       required: !isOptional
     });
     const innerType = Array.isArray(field.type) ? field.type.find((t) => typeof t === "object" && t.type === "record") : typeof field.type === "object" && field.type.type === "record" ? field.type : null;
     if (innerType) {
-      walkAvroRecord(innerType, path11, fields);
+      walkAvroRecord(innerType, path15, fields);
     }
     const arrayType = Array.isArray(field.type) ? field.type.find((t) => typeof t === "object" && t.type === "array") : typeof field.type === "object" && field.type.type === "array" ? field.type : null;
     if (arrayType && typeof arrayType.items === "object" && arrayType.items.type === "record") {
-      walkAvroRecord(arrayType.items, `${path11}[]`, fields);
+      walkAvroRecord(arrayType.items, `${path15}[]`, fields);
     }
   }
 }
@@ -1302,32 +1302,32 @@ function walkJsonSchema(node, prefix, requiredList, rootSchema, fields) {
   }
   if (!node.properties) return;
   for (const [name, prop] of Object.entries(node.properties)) {
-    const path11 = prefix ? `${prefix}.${name}` : name;
+    const path15 = prefix ? `${prefix}.${name}` : name;
     const isRequired = requiredList.includes(name);
     if (prop.$ref) {
       const resolved = resolveLocalRef(prop.$ref, rootSchema);
       if (resolved) {
         const rawRefType = resolved.type || "object";
         const type2 = Array.isArray(rawRefType) ? [...rawRefType].sort().join(" | ") : rawRefType;
-        fields.push({ path: path11, type: type2, description: resolved.description || "", required: isRequired });
+        fields.push({ path: path15, type: type2, description: resolved.description || "", required: isRequired });
         if (resolved.properties) {
-          walkJsonSchema(resolved, path11, resolved.required || [], rootSchema, fields);
+          walkJsonSchema(resolved, path15, resolved.required || [], rootSchema, fields);
         }
       } else {
-        fields.push({ path: path11, type: "$ref", description: "", required: isRequired });
+        fields.push({ path: path15, type: "$ref", description: "", required: isRequired });
       }
       continue;
     }
     const rawType = prop.type || (prop.enum ? "enum" : prop.$ref ? "$ref" : "object");
     const typeList = Array.isArray(rawType) ? rawType : [rawType];
     const type = Array.isArray(rawType) ? [...rawType].sort().join(" | ") : rawType;
-    fields.push({ path: path11, type, description: prop.description || "", required: isRequired });
+    fields.push({ path: path15, type, description: prop.description || "", required: isRequired });
     if (typeList.includes("object") && prop.properties) {
-      walkJsonSchema(prop, path11, prop.required || [], rootSchema, fields);
+      walkJsonSchema(prop, path15, prop.required || [], rootSchema, fields);
     }
     if (typeList.includes("array") && prop.items) {
       if (prop.items.type === "object" && prop.items.properties) {
-        walkJsonSchema(prop.items, `${path11}[]`, prop.items.required || [], rootSchema, fields);
+        walkJsonSchema(prop.items, `${path15}[]`, prop.items.required || [], rootSchema, fields);
       }
     }
   }
@@ -1845,16 +1845,496 @@ var createAstroDevLineFilter = () => {
   };
 };
 
+// src/federation/federate.ts
+var import_node_crypto3 = require("crypto");
+var import_promises6 = __toESM(require("fs/promises"), 1);
+var import_node_path13 = __toESM(require("path"), 1);
+var import_sdk2 = __toESM(require("@eventcatalog/sdk"), 1);
+
+// src/federation/content-cache.ts
+var import_node_crypto = require("crypto");
+var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
+var getContentHash = (content) => `sha256:${(0, import_node_crypto.createHash)("sha256").update(content).digest("hex")}`;
+var isContentHash = (key) => /^sha256:[a-f0-9]{64}$/i.test(key);
+var createFederationContentCache = (projectDirectory, options = {}) => {
+  const cacheDirectory = import_node_path10.default.join(projectDirectory, ".eventcatalog-cache", "federation", "content");
+  const getCachePath = (key) => import_node_path10.default.join(cacheDirectory, encodeURIComponent(key));
+  return {
+    async get(key) {
+      if (options.read === false || !isContentHash(key)) return void 0;
+      const cachePath = getCachePath(key);
+      try {
+        const content = await import_promises3.default.readFile(cachePath);
+        if (getContentHash(content) !== key) {
+          await import_promises3.default.rm(cachePath, { force: true });
+          return void 0;
+        }
+        options.onHit?.(key);
+        return content;
+      } catch (error) {
+        if (error.code === "ENOENT") return void 0;
+        throw error;
+      }
+    },
+    async set(key, content) {
+      if (!isContentHash(key) || getContentHash(content) !== key) return;
+      await import_promises3.default.mkdir(cacheDirectory, { recursive: true });
+      const cachePath = getCachePath(key);
+      const temporaryPath = `${cachePath}.tmp-${process.pid}-${(0, import_node_crypto.randomUUID)()}`;
+      try {
+        await import_promises3.default.writeFile(temporaryPath, content);
+        await import_promises3.default.rename(temporaryPath, cachePath);
+      } finally {
+        await import_promises3.default.rm(temporaryPath, { force: true });
+      }
+    }
+  };
+};
+
+// src/federation/github-source-provider.ts
+var import_node_child_process = require("child_process");
+var import_promises4 = __toESM(require("fs/promises"), 1);
+var import_node_os4 = __toESM(require("os"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
+var import_node_util = require("util");
+var import_sdk = __toESM(require("@eventcatalog/sdk"), 1);
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var parseGitHubSource = (source) => {
+  const match = /^github:([^/]+)\/(.+)$/.exec(source.source);
+  if (!match) throw new Error(`Unsupported federation source "${source.source}". Expected github:owner/repository.`);
+  return { owner: match[1], repository: match[2] };
+};
+var assertSafeCatalogPath = (source) => {
+  const catalogPath = source.path ?? ".";
+  const normalized = import_node_path11.default.posix.normalize(catalogPath.replaceAll("\\", "/"));
+  if (catalogPath.includes("\\") || import_node_path11.default.posix.isAbsolute(normalized) || normalized === ".." || normalized.startsWith("../")) {
+    throw new Error(`Catalog path "${catalogPath}" escapes source "${source.id}"`);
+  }
+};
+var encodePath = (value) => value.split("/").filter(Boolean).map(encodeURIComponent).join("/");
+var rawUrl = (source, ref, filePath) => {
+  const { owner, repository } = parseGitHubSource(source);
+  return `https://raw.githubusercontent.com/${encodeURIComponent(owner)}/${encodeURIComponent(repository)}/${encodeURIComponent(
+    ref
+  )}/${encodePath(filePath)}`;
+};
+var contentsApiUrl = (source, ref, filePath) => {
+  const { owner, repository } = parseGitHubSource(source);
+  return `https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repository)}/contents/${encodePath(
+    filePath
+  )}?ref=${encodeURIComponent(ref)}`;
+};
+var fetchBytes = async (source, ref, filePath, fetcher, token) => {
+  const url = token ? contentsApiUrl(source, ref, filePath) : rawUrl(source, ref, filePath);
+  const response = token ? await fetcher(url, {
+    headers: {
+      Accept: "application/vnd.github.raw+json",
+      Authorization: `Bearer ${token}`,
+      "X-GitHub-Api-Version": "2026-03-10"
+    }
+  }) : await fetcher(url);
+  if (response.status === 404) return void 0;
+  if (!response.ok) throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
+  return Buffer.from(await response.arrayBuffer());
+};
+var getGitEnvironment = (token) => {
+  if (!token) return process.env;
+  const inheritedCount = Number.parseInt(process.env.GIT_CONFIG_COUNT ?? "0", 10);
+  const configIndex = Number.isInteger(inheritedCount) && inheritedCount >= 0 ? inheritedCount : 0;
+  return {
+    ...process.env,
+    GIT_CONFIG_COUNT: String(configIndex + 1),
+    [`GIT_CONFIG_KEY_${configIndex}`]: "http.https://github.com/.extraheader",
+    [`GIT_CONFIG_VALUE_${configIndex}`]: `AUTHORIZATION: basic ${Buffer.from(`x-access-token:${token}`).toString("base64")}`
+  };
+};
+var createCheckout = (executeFile, token) => async (source, ref, callback) => {
+  const { owner, repository } = parseGitHubSource(source);
+  const catalogPath = import_node_path11.default.posix.normalize(source.path ?? ".");
+  const directory = await import_promises4.default.mkdtemp(import_node_path11.default.join(import_node_os4.default.tmpdir(), "eventcatalog-federation-"));
+  const env = getGitEnvironment(token);
+  try {
+    const git = (args) => executeFile("git", args, { cwd: directory, env, encoding: "utf8" });
+    await git(["init", "--quiet"]);
+    await git(["remote", "add", "origin", `https://github.com/${owner}/${repository}.git`]);
+    if (catalogPath !== ".") {
+      await git(["sparse-checkout", "init", "--cone"]);
+      await git(["sparse-checkout", "set", catalogPath]);
+    }
+    await git(["fetch", "--quiet", "--depth", "1", "origin", ref]);
+    await git(["checkout", "--quiet", "--detach", "FETCH_HEAD"]);
+    return await callback(directory);
+  } finally {
+    await import_promises4.default.rm(directory, { recursive: true, force: true });
+  }
+};
+var generateIndex = async (source, ref, checkout, executeFile) => checkout(source, ref, async (directory) => {
+  const { stdout } = await executeFile("git", ["rev-parse", "HEAD"], { cwd: directory, encoding: "utf8" });
+  const commit = stdout.trim();
+  const catalogDirectory = import_node_path11.default.resolve(directory, source.path ?? ".");
+  const relativeCatalogDirectory = import_node_path11.default.relative(directory, catalogDirectory);
+  if (relativeCatalogDirectory.startsWith("..") || import_node_path11.default.isAbsolute(relativeCatalogDirectory)) {
+    throw new Error(`Catalog path "${source.path}" escapes source "${source.id}"`);
+  }
+  const index = await (0, import_sdk.default)(catalogDirectory).buildIndex({ source: source.id, commit });
+  return { bytes: Buffer.from(JSON.stringify(index)), index, commit, generated: true };
+});
+var fetchPublishedIndex = async (source, ref, fetcher, token) => {
+  const indexPath = import_node_path11.default.posix.join(source.path ?? ".", "catalog.index.json");
+  const bytes = await fetchBytes(source, ref, indexPath, fetcher, token);
+  if (!bytes) return void 0;
+  const index = (0, import_sdk.parseIndex)(JSON.parse(bytes.toString("utf8")));
+  if (index.source !== source.id) {
+    throw new Error(`Published index source "${index.source}" does not match configured id "${source.id}"`);
+  }
+  return { bytes, index, commit: index.commit, generated: false };
+};
+var createGitHubSourceProvider = (options = {}) => {
+  const fetcher = options.fetch ?? ((url, init) => fetch(url, init));
+  const executeFile = options.execFile ?? ((file, args, execOptions) => execFileAsync(file, args, execOptions));
+  const configuredToken = options.token ?? process.env.EVENTCATALOG_GITHUB_TOKEN ?? process.env.GITHUB_TOKEN;
+  const token = configuredToken?.trim() || void 0;
+  const checkout = options.checkout ?? createCheckout(executeFile, token);
+  return {
+    async resolve(source) {
+      assertSafeCatalogPath(source);
+      const ref = source.ref ?? "main";
+      return await fetchPublishedIndex(source, ref, fetcher, token) ?? generateIndex(source, ref, checkout, executeFile);
+    },
+    async fetchContent({ source, commit, path: artifactPath }) {
+      assertSafeCatalogPath(source);
+      const catalogPath = import_node_path11.default.posix.join(source.path ?? ".", artifactPath);
+      const content = await fetchBytes(source, commit, catalogPath, fetcher, token);
+      if (!content) throw new Error(`Federated artifact not found for "${source.id}": ${artifactPath}`);
+      return content;
+    }
+  };
+};
+
+// src/federation/public-assets.ts
+var import_node_crypto2 = require("crypto");
+var import_promises5 = __toESM(require("fs/promises"), 1);
+var import_node_path12 = __toESM(require("path"), 1);
+var getContentHash2 = (content) => `sha256:${(0, import_node_crypto2.createHash)("sha256").update(content).digest("hex")}`;
+var getFileHash = async (filePath) => {
+  try {
+    const stat = await import_promises5.default.lstat(filePath);
+    return stat.isFile() ? getContentHash2(await import_promises5.default.readFile(filePath)) : void 0;
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+};
+var getSafePath = (directory, relativePath) => {
+  const normalizedPath = import_node_path12.default.posix.normalize(relativePath);
+  const unsafe = relativePath.length === 0 || relativePath.includes("\0") || relativePath.includes("\\") || import_node_path12.default.posix.isAbsolute(relativePath) || /^[a-zA-Z]:\//.test(relativePath) || normalizedPath !== relativePath || normalizedPath === ".." || normalizedPath.startsWith("../");
+  if (unsafe) return void 0;
+  const resolvedDirectory = import_node_path12.default.resolve(directory);
+  const resolvedPath = import_node_path12.default.resolve(resolvedDirectory, relativePath);
+  const relativeResolvedPath = import_node_path12.default.relative(resolvedDirectory, resolvedPath);
+  if (relativeResolvedPath === "" || relativeResolvedPath === ".." || relativeResolvedPath.startsWith(`..${import_node_path12.default.sep}`) || import_node_path12.default.isAbsolute(relativeResolvedPath)) {
+    return void 0;
+  }
+  return resolvedPath;
+};
+var listFiles = async (directory, relativeDirectory = "") => {
+  let entries;
+  try {
+    entries = await import_promises5.default.readdir(import_node_path12.default.join(directory, relativeDirectory), { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  const files = await Promise.all(
+    entries.map(async (entry) => {
+      const relativePath = import_node_path12.default.join(relativeDirectory, entry.name);
+      if (entry.isDirectory()) return listFiles(directory, relativePath);
+      return entry.isFile() ? [relativePath.split(import_node_path12.default.sep).join("/")] : [];
+    })
+  );
+  return files.flat().sort();
+};
+var pathExists = async (filePath) => {
+  try {
+    await import_promises5.default.lstat(filePath);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+};
+var hasBlockingParent = async (publicDirectory, destinationPath) => {
+  let currentPath = import_node_path12.default.dirname(destinationPath);
+  while (currentPath !== publicDirectory) {
+    try {
+      if (!(await import_promises5.default.lstat(currentPath)).isDirectory()) return true;
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    currentPath = import_node_path12.default.dirname(currentPath);
+  }
+  return false;
+};
+var pruneEmptyDirectories = async (publicDirectory, filePath) => {
+  let currentPath = import_node_path12.default.dirname(filePath);
+  while (currentPath !== publicDirectory) {
+    try {
+      await import_promises5.default.rmdir(currentPath);
+    } catch (error) {
+      if (!["ENOENT", "ENOTEMPTY"].includes(error.code ?? "")) throw error;
+      if (error.code === "ENOTEMPTY") return;
+    }
+    currentPath = import_node_path12.default.dirname(currentPath);
+  }
+};
+var composePublicAssets = async ({
+  projectDirectory,
+  federatedDirectory,
+  assets,
+  previousFiles = {},
+  collisionPaths = /* @__PURE__ */ new Set()
+}) => {
+  const publicDirectory = import_node_path12.default.resolve(projectDirectory, "public");
+  const federatedPublicDirectory = import_node_path12.default.resolve(federatedDirectory, "public");
+  const sourceFiles = await listFiles(federatedPublicDirectory);
+  const sourceFileSet = new Set(sourceFiles);
+  const managedFiles = /* @__PURE__ */ new Set();
+  for (const [relativePath, previousFile] of Object.entries(previousFiles)) {
+    const destinationPath = getSafePath(publicDirectory, relativePath);
+    if (destinationPath && await getFileHash(destinationPath) === previousFile.hash) managedFiles.add(relativePath);
+  }
+  let removed = 0;
+  for (const relativePath of managedFiles) {
+    if (sourceFileSet.has(relativePath)) continue;
+    const destinationPath = getSafePath(publicDirectory, relativePath);
+    if (!destinationPath) continue;
+    await import_promises5.default.rm(destinationPath, { force: true });
+    await pruneEmptyDirectories(publicDirectory, destinationPath);
+    removed += 1;
+  }
+  const publicAssetsByPath = new Map(
+    assets.filter((asset) => asset.path.startsWith("public/")).map((asset) => [asset.path.slice("public/".length), asset])
+  );
+  const files = {};
+  let copied = 0;
+  let skipped = 0;
+  let overwritten = 0;
+  for (const relativePath of sourceFiles) {
+    const sourcePath = getSafePath(federatedPublicDirectory, relativePath);
+    const destinationPath = getSafePath(publicDirectory, relativePath);
+    if (!sourcePath || !destinationPath) throw new Error(`Unsafe federated public asset path "${relativePath}"`);
+    const mainCatalogOwnsPath = await pathExists(destinationPath) && !managedFiles.has(relativePath) || await hasBlockingParent(publicDirectory, destinationPath);
+    if (mainCatalogOwnsPath) {
+      skipped += 1;
+      continue;
+    }
+    const asset = publicAssetsByPath.get(relativePath);
+    if (!asset) throw new Error(`Cannot identify the source of federated public asset "${relativePath}"`);
+    const content = await import_promises5.default.readFile(sourcePath);
+    await import_promises5.default.mkdir(import_node_path12.default.dirname(destinationPath), { recursive: true });
+    await import_promises5.default.writeFile(destinationPath, content);
+    files[relativePath] = { source: asset.resolvedFrom.source, hash: getContentHash2(content) };
+    copied += 1;
+    if (collisionPaths.has(`public/${relativePath}`)) overwritten += 1;
+  }
+  await import_promises5.default.rm(federatedPublicDirectory, { recursive: true, force: true });
+  return { files, copied, skipped, overwritten, removed };
+};
+
+// src/federation/federate.ts
+var FederationConflictError = class extends Error {
+  conflicts;
+  constructor(conflicts) {
+    const details = conflicts.map((conflict) => `${conflict.id}: ${conflict.sources.join(", ")}`).join("\n");
+    super(`Federation conflicts prevent hydration:
+${details}`);
+    this.name = "FederationConflictError";
+    this.conflicts = conflicts;
+  }
+};
+var validateSources = (sources) => {
+  const ids = /* @__PURE__ */ new Set();
+  for (const source of sources) {
+    if (!source.id?.trim()) throw new Error("Every federation source requires a stable id.");
+    if (ids.has(source.id)) throw new Error(`Federation source id "${source.id}" is configured more than once.`);
+    ids.add(source.id);
+  }
+};
+var writeLock = async (lockPath, lock) => {
+  const temporaryPath = `${lockPath}.tmp-${process.pid}`;
+  try {
+    await import_promises6.default.writeFile(temporaryPath, `${JSON.stringify(lock, null, 2)}
+`, "utf8");
+    await import_promises6.default.rename(temporaryPath, lockPath);
+  } finally {
+    await import_promises6.default.rm(temporaryPath, { force: true });
+  }
+};
+var readLock = async (lockPath) => {
+  try {
+    return JSON.parse(await import_promises6.default.readFile(lockPath, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw new Error(`Cannot read federation lock at "${lockPath}"`, { cause: error });
+  }
+};
+var pathExists2 = async (filePath) => {
+  try {
+    await import_promises6.default.access(filePath);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+};
+var cleanupPreviousFederation = async (projectDirectory, onProgress) => {
+  const outDir = import_node_path13.default.join(projectDirectory, "federated");
+  const lockPath = import_node_path13.default.join(projectDirectory, "eventcatalog.lock");
+  const previousLock = await readLock(lockPath);
+  const hadFederatedOutput = await pathExists2(outDir);
+  const hadLock = previousLock !== void 0;
+  if (!hadFederatedOutput && !hadLock) return;
+  await import_promises6.default.rm(outDir, { recursive: true, force: true });
+  const publicResult = await composePublicAssets({
+    projectDirectory,
+    federatedDirectory: outDir,
+    assets: [],
+    previousFiles: previousLock?.publicFiles
+  });
+  await import_promises6.default.rm(lockPath, { force: true });
+  onProgress?.({
+    type: "cleanup:complete",
+    federated: hadFederatedOutput,
+    publicFiles: publicResult.removed,
+    lock: hadLock
+  });
+};
+var federateCatalog = async (projectDirectory, options = {}) => {
+  const config = await getEventCatalogConfigFile(projectDirectory);
+  const sources = config.federation?.sources ?? [];
+  options.onProgress?.({ type: "configured", sources: sources.length });
+  if (sources.length === 0) {
+    await cleanupPreviousFederation(projectDirectory, options.onProgress);
+    return null;
+  }
+  if (options.isFederationEnabled && !await options.isFederationEnabled()) {
+    throw new Error(
+      "Cannot federate catalogs: EventCatalog federation is an Enterprise feature. Visit https://www.eventcatalog.dev/pricing to enable federation."
+    );
+  }
+  validateSources(sources);
+  if (options.useCache === false) options.onProgress?.({ type: "cache:disabled" });
+  const provider = options.provider ?? createGitHubSourceProvider();
+  const resolvedSources = [];
+  for (const [index, source] of sources.entries()) {
+    const current = index + 1;
+    options.onProgress?.({ type: "source:start", source, current, total: sources.length });
+    try {
+      const resolved = await provider.resolve(source);
+      resolvedSources.push({ config: source, resolved });
+      options.onProgress?.({
+        type: "source:complete",
+        source,
+        current,
+        total: sources.length,
+        commit: resolved.commit,
+        resources: resolved.index.resources.length,
+        generated: resolved.generated
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to federate source "${source.id}": ${message}`, { cause: error });
+    }
+  }
+  const outDir = import_node_path13.default.join(projectDirectory, "federated");
+  const lockPath = import_node_path13.default.join(projectDirectory, "eventcatalog.lock");
+  const previousLock = await readLock(lockPath);
+  const resources = resolvedSources.reduce((total, source) => total + source.resolved.index.resources.length, 0);
+  const remoteIndexes = resolvedSources.map(({ resolved }) => resolved.index);
+  options.onProgress?.({ type: "local:start" });
+  const localIndex = await (0, import_sdk2.default)(projectDirectory).buildIndex({
+    source: config.cId,
+    commit: "local",
+    hashContent: false,
+    includeFederated: false
+  });
+  options.onProgress?.({ type: "local:complete", resources: localIndex.resources.length });
+  options.onProgress?.({ type: "resolving", resources, localResources: localIndex.resources.length });
+  const ownershipGraph = (0, import_sdk2.resolve)([localIndex, ...remoteIndexes]);
+  if (ownershipGraph.conflicts.length > 0) {
+    options.onProgress?.({ type: "resolved", graph: ownershipGraph });
+    throw new FederationConflictError(ownershipGraph.conflicts);
+  }
+  const graph = (0, import_sdk2.resolve)(remoteIndexes);
+  options.onProgress?.({ type: "resolved", graph });
+  const sourcesById = new Map(sources.map((source) => [source.id, source]));
+  options.onProgress?.({ type: "hydrating", outDir });
+  let hydratedFiles = 0;
+  let cachedFiles = 0;
+  const hydrateResult = await (0, import_sdk2.hydrate)(graph, {
+    outDir,
+    cache: createFederationContentCache(projectDirectory, {
+      read: options.useCache !== false,
+      onHit: () => {
+        cachedFiles += 1;
+        options.onProgress?.({ type: "hydrate:cache", files: cachedFiles });
+      }
+    }),
+    modes: Object.fromEntries(sources.map((source) => [source.id, source.mode ?? "hydrate"])),
+    fetch: async ({ source: sourceId, commit, path: artifactPath }) => {
+      const source = sourcesById.get(sourceId);
+      if (!source) throw new Error(`Cannot fetch content for unconfigured source "${sourceId}"`);
+      const content = await provider.fetchContent({ source, commit, path: artifactPath });
+      hydratedFiles += 1;
+      options.onProgress?.({ type: "hydrate:file", files: hydratedFiles, source: sourceId, path: artifactPath });
+      return content;
+    }
+  });
+  const publicResult = await composePublicAssets({
+    projectDirectory,
+    federatedDirectory: outDir,
+    assets: graph.assets,
+    previousFiles: previousLock?.publicFiles,
+    collisionPaths: new Set(
+      graph.warnings.filter((warning) => warning.kind === "asset-collision").map((warning) => warning.path)
+    )
+  });
+  options.onProgress?.({ type: "public:complete", result: publicResult });
+  const resolvedAt = (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+  await writeLock(lockPath, {
+    lockVersion: 1,
+    sources: resolvedSources.map(({ config: source, resolved }) => ({
+      id: source.id,
+      digest: `sha256:${(0, import_node_crypto3.createHash)("sha256").update(resolved.bytes).digest("hex")}`,
+      commit: resolved.commit,
+      resolvedAt
+    })).sort((left, right) => left.id.localeCompare(right.id)),
+    publicFiles: publicResult.files
+  });
+  const result = {
+    sources: sources.length,
+    resources,
+    graph,
+    hydrate: hydrateResult,
+    public: publicResult,
+    outDir,
+    lockPath
+  };
+  options.onProgress?.({ type: "complete", result });
+  return result;
+};
+
 // src/eventcatalog.ts
 var import_license = require("@eventcatalog/license");
-var currentDir = import_node_path11.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
+var currentDir = import_node_path15.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
 var program = new import_commander.Command().version(VERSION);
-var dir = import_node_path11.default.resolve(process.env.PROJECT_DIR || process.cwd());
-var core = import_node_path11.default.resolve(process.env.CATALOG_DIR || (0, import_node_path10.join)(dir, ".eventcatalog-core"));
-var eventCatalogDir = import_node_path11.default.resolve((0, import_node_path10.join)(currentDir, "../eventcatalog/"));
+var dir = import_node_path15.default.resolve(process.env.PROJECT_DIR || process.cwd());
+var core = import_node_path15.default.resolve(process.env.CATALOG_DIR || (0, import_node_path14.join)(dir, ".eventcatalog-core"));
+var eventCatalogDir = import_node_path15.default.resolve((0, import_node_path14.join)(currentDir, "../eventcatalog/"));
 var getInstalledEventCatalogVersion = () => {
   try {
-    const pkg = import_fs3.default.readFileSync((0, import_node_path10.join)(dir, "package.json"), "utf8");
+    const pkg = import_fs3.default.readFileSync((0, import_node_path14.join)(dir, "package.json"), "utf8");
     const json = JSON.parse(pkg);
     return json.dependencies["@eventcatalog/core"];
   } catch (error) {
@@ -1884,7 +2364,7 @@ var startDevPrewarm = ({
   initialDelayMs = 500
 }) => {
   let attempt = 0;
-  const hit = (requestPath) => new Promise((resolve2) => {
+  const hit = (requestPath) => new Promise((resolve3) => {
     const req = import_node_http.default.get(
       {
         hostname: "127.0.0.1",
@@ -1894,13 +2374,13 @@ var startDevPrewarm = ({
       },
       (res) => {
         res.resume();
-        resolve2(true);
+        resolve3(true);
       }
     );
-    req.on("error", () => resolve2(false));
+    req.on("error", () => resolve3(false));
     req.on("timeout", () => {
       req.destroy();
-      resolve2(false);
+      resolve3(false);
     });
   });
   const tick = async () => {
@@ -1920,12 +2400,12 @@ var startDevPrewarm = ({
 var buildDevSearchIndex = async ({ config }) => {
   const result = await buildSearchIndex({
     projectDir: dir,
-    outDir: import_node_path11.default.join(core, "public"),
-    searchOutputPath: import_node_path11.default.join(core, "public", "pagefind"),
+    outDir: import_node_path15.default.join(core, "public"),
+    searchOutputPath: import_node_path15.default.join(core, "public", "pagefind"),
     config,
     isServer: false
   });
-  logger.info(`Indexed ${result.records} page(s) into ${import_node_path11.default.relative(core, result.outputPath)}`, "search");
+  logger.info(`Indexed ${result.records} page(s) into ${import_node_path15.default.relative(core, result.outputPath)}`, "search");
 };
 var warnIfIndexedSearchUsesAuth = async () => {
   if (!await isAuthEnabled()) {
@@ -1982,8 +2462,8 @@ var runCommandWithFilteredOutput = async ({
   shouldFilterLine,
   transformLine = (line) => line
 }) => {
-  await new Promise((resolve2, reject) => {
-    const child = (0, import_node_child_process.spawn)(command, {
+  await new Promise((resolve3, reject) => {
+    const child = (0, import_node_child_process2.spawn)(command, {
       cwd,
       env: {
         ...process.env,
@@ -2025,7 +2505,7 @@ var runCommandWithFilteredOutput = async ({
       stdoutBuffer = flush(stdoutBuffer, process.stdout, true);
       stderrBuffer = flush(stderrBuffer, process.stderr, true);
       if (code === 0) {
-        resolve2();
+        resolve3();
         return;
       }
       reject(new Error(`Command failed with exit code ${code}: ${command}`));
@@ -2040,12 +2520,12 @@ var copyCore = () => {
   import_fs3.default.cpSync(eventCatalogDir, core, {
     recursive: true,
     filter: (src) => {
-      const relativePath = import_node_path11.default.relative(eventCatalogDir, src);
-      const pathParts = relativePath.split(import_node_path11.default.sep);
+      const relativePath = import_node_path15.default.relative(eventCatalogDir, src);
+      const pathParts = relativePath.split(import_node_path15.default.sep);
       return !pathParts.some((part) => [".astro", "dist", "node_modules"].includes(part));
     }
   });
-  const coreNodeModules = import_node_path11.default.join(core, "node_modules");
+  const coreNodeModules = import_node_path15.default.join(core, "node_modules");
   const installedCoreNodeModules = resolveInstalledCoreNodeModules(currentDir);
   linkCoreNodeModules({ coreNodeModules, installedCoreNodeModules });
 };
@@ -2104,8 +2584,8 @@ program.command("dev").description("Run development server of EventCatalog").opt
   logger.info("Setting up EventCatalog...", "eventcatalog");
   const isServer = await isOutputServer();
   logger.info(isServer ? "EventCatalog is running in Server Mode" : "EventCatalog is running in Static Mode", "config");
-  if (import_fs3.default.existsSync(import_node_path11.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path11.default.join(dir, ".env") });
+  if (import_fs3.default.existsSync(import_node_path15.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path15.default.join(dir, ".env") });
   }
   if (options.debug) {
     logger.info("Debug mode enabled", "debug");
@@ -2185,8 +2665,8 @@ program.command("build").description("Run build of EventCatalog").action(async (
   logger.info("Building EventCatalog...", "build");
   const isServer = await isOutputServer();
   logger.info(isServer ? "EventCatalog is running in Server Mode" : "EventCatalog is running in Static Mode", "config");
-  if (import_fs3.default.existsSync(import_node_path11.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path11.default.join(dir, ".env") });
+  if (import_fs3.default.existsSync(import_node_path15.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path15.default.join(dir, ".env") });
   }
   await verifyRequiredFieldsAreInCatalogConfigFile(dir);
   copyCore();
@@ -2236,7 +2716,7 @@ program.command("build").description("Run build of EventCatalog").action(async (
   if (await isIndexedSearchEnabled()) {
     await warnIfIndexedSearchUsesAuth();
     const config = await getEventCatalogConfigFile(dir);
-    const outDir = import_node_path11.default.resolve(dir, await getProjectOutDir());
+    const outDir = import_node_path15.default.resolve(dir, await getProjectOutDir());
     logger.info("Building indexed search...", "search");
     const result = await buildSearchIndex({
       projectDir: dir,
@@ -2244,7 +2724,7 @@ program.command("build").description("Run build of EventCatalog").action(async (
       config,
       isServer
     });
-    logger.info(`Indexed ${result.records} page(s) into ${import_node_path11.default.relative(dir, result.outputPath)}`, "search");
+    logger.info(`Indexed ${result.records} page(s) into ${import_node_path15.default.relative(dir, result.outputPath)}`, "search");
   }
 });
 var previewCatalog = async ({
@@ -2271,7 +2751,7 @@ var startServerCatalog = async ({
   isEventCatalogStarter = false,
   isEventCatalogScale = false
 }) => {
-  const serverEntryPath = import_node_path11.default.join(dir, "dist", "server", "entry.mjs");
+  const serverEntryPath = import_node_path15.default.join(dir, "dist", "server", "entry.mjs");
   await runCommandWithFilteredOutput({
     command: `node "${serverEntryPath}"`,
     cwd: core,
@@ -2288,8 +2768,8 @@ var startServerCatalog = async ({
 program.command("preview").description("Serves the contents of your eventcatalog build directory").action(async (options, command) => {
   logger.welcome();
   logger.info("Starting preview of your build...", "preview");
-  if (import_fs3.default.existsSync(import_node_path11.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path11.default.join(dir, ".env") });
+  if (import_fs3.default.existsSync(import_node_path15.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path15.default.join(dir, ".env") });
   }
   const canEmbedPages = await (0, import_license.isFeatureEnabled)(
     "@eventcatalog/backstage-plugin-eventcatalog",
@@ -2307,8 +2787,8 @@ program.command("preview").description("Serves the contents of your eventcatalog
 program.command("start").description("Serves the contents of your eventcatalog build directory").action(async (options, command) => {
   logger.welcome();
   logger.info("Starting preview of your build...", "preview");
-  if (import_fs3.default.existsSync(import_node_path11.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path11.default.join(dir, ".env") });
+  if (import_fs3.default.existsSync(import_node_path15.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path15.default.join(dir, ".env") });
   }
   const canEmbedPages = await (0, import_license.isFeatureEnabled)(
     "@eventcatalog/backstage-plugin-eventcatalog",
@@ -2335,25 +2815,145 @@ program.command("start").description("Serves the contents of your eventcatalog b
 program.command("export").description("Export your EventCatalog using the SDK dumpCatalog function").option("--include-markdown", "Include markdown content in the export", false).action(async (options) => {
   logger.welcome();
   logger.info("Exporting EventCatalog...", "export");
-  if (import_fs3.default.existsSync(import_node_path11.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path11.default.join(dir, ".env") });
+  if (import_fs3.default.existsSync(import_node_path15.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path15.default.join(dir, ".env") });
   }
   const { default: initSDK } = await import("@eventcatalog/sdk");
   const sdk = initSDK(dir);
   const catalog = await sdk.dumpCatalog({ includeMarkdown: options.includeMarkdown });
-  const exportsDir = import_node_path11.default.join(dir, "exports");
+  const exportsDir = import_node_path15.default.join(dir, "exports");
   ensureDir(exportsDir);
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  const exportFile = import_node_path11.default.join(exportsDir, `catalog-${date}.json`);
+  const exportFile = import_node_path15.default.join(exportsDir, `catalog-${date}.json`);
   import_fs3.default.writeFileSync(exportFile, JSON.stringify(catalog, null, 2), "utf-8");
   logger.info(`Catalog exported to ${exportFile}`, "export");
 });
 program.command("generate [siteDir]").description("Start the generator scripts.").action(async () => {
-  if (import_fs3.default.existsSync(import_node_path11.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path11.default.join(dir, ".env") });
+  if (import_fs3.default.existsSync(import_node_path15.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path15.default.join(dir, ".env") });
   }
   await generate(dir);
 });
+var reportFederationProgress = (event) => {
+  switch (event.type) {
+    case "configured":
+      if (event.sources > 0)
+        logger.info(`Found ${event.sources} configured source${event.sources === 1 ? "" : "s"}`, "federation");
+      return;
+    case "cleanup:complete":
+      logger.success(
+        `No sources configured; removed previous federation output${event.publicFiles > 0 ? ` and ${event.publicFiles} managed public file${event.publicFiles === 1 ? "" : "s"}` : ""}.`,
+        "federation"
+      );
+      return;
+    case "cache:disabled":
+      logger.info("Content cache disabled; all federated files will be downloaded.", "federation");
+      return;
+    case "source:start":
+      logger.info(`[${event.current}/${event.total}] Fetching and indexing ${event.source.id}...`, "federation");
+      return;
+    case "source:complete":
+      logger.success(
+        `[${event.current}/${event.total}] ${event.source.id}: ${event.resources} resources at ${event.commit.slice(0, 7)}${event.generated ? " (index generated)" : " (published index)"}`,
+        "federation"
+      );
+      return;
+    case "local:start":
+      logger.info("Indexing central catalog ownership...", "federation");
+      return;
+    case "local:complete":
+      logger.success(
+        `Central catalog: ${event.resources} local resource${event.resources === 1 ? "" : "s"} found (excluding federated/)`,
+        "federation"
+      );
+      return;
+    case "resolving":
+      logger.info(
+        `Validating ownership across ${event.localResources} local resource${event.localResources === 1 ? "" : "s"} and ${event.resources} remote resource${event.resources === 1 ? "" : "s"}...`,
+        "federation"
+      );
+      return;
+    case "resolved":
+      if (event.graph.conflicts.length > 0) {
+        logger.error(
+          `${event.graph.conflicts.length} ownership conflict${event.graph.conflicts.length === 1 ? "" : "s"} found`,
+          "federation"
+        );
+        for (const conflict of event.graph.conflicts.slice(0, 10)) {
+          logger.error(`${conflict.id}: ${conflict.sources.join(", ")}`, "federation");
+        }
+        if (event.graph.conflicts.length > 10) {
+          logger.error(`...and ${event.graph.conflicts.length - 10} more`, "federation");
+        }
+        return;
+      }
+      logger.success(
+        `Graph resolved: ${event.graph.entities.length} remote resources, ${event.graph.edges.length} relationships`,
+        "federation"
+      );
+      if (event.graph.warnings.length > 0) {
+        logger.warning(
+          `${event.graph.warnings.length} federation warning${event.graph.warnings.length === 1 ? "" : "s"}`,
+          "federation"
+        );
+      }
+      if (event.graph.externals.length > 0) {
+        logger.warning(
+          `${event.graph.externals.length} reference${event.graph.externals.length === 1 ? "" : "s"} remain external`,
+          "federation"
+        );
+      }
+      return;
+    case "hydrating":
+      logger.info(`Hydrating federated content into ${import_node_path15.default.relative(dir, event.outDir)}/...`, "federation");
+      return;
+    case "hydrate:cache":
+      if (event.files === 1 || event.files % 25 === 0) {
+        logger.info(`Reused ${event.files} cached file${event.files === 1 ? "" : "s"}...`, "federation");
+      }
+      return;
+    case "hydrate:file":
+      if (event.files === 1 || event.files % 25 === 0) {
+        logger.info(`Fetched ${event.files} federated file${event.files === 1 ? "" : "s"}...`, "federation");
+      }
+      return;
+    case "public:complete":
+      logger.success(
+        `Public assets: ${event.result.copied} copied, ${event.result.skipped} preserved from the main catalog, ${event.result.removed} stale removed`,
+        "federation"
+      );
+      if (event.result.overwritten > 0) {
+        logger.warning(
+          `${event.result.overwritten} public asset conflict${event.result.overwritten === 1 ? "" : "s"} resolved using the last configured source`,
+          "federation"
+        );
+      }
+      return;
+    case "complete":
+      logger.success(
+        `Federation complete: ${event.result.sources} sources, ${event.result.resources} remote resources, ${event.result.hydrate.written} files written (${event.result.hydrate.fetched} downloaded, ${event.result.hydrate.written - event.result.hydrate.fetched} cached)`,
+        "federation"
+      );
+      logger.info(`Pinned source commits in ${import_node_path15.default.relative(dir, event.result.lockPath)}`, "federation");
+  }
+};
+program.command("federate").description("Fetch, resolve, and hydrate the catalogs configured in federation.sources.").option("--no-cache", "Download all federation content and refresh the cache.").action(async (commandOptions) => {
+  logger.welcome();
+  if (import_fs3.default.existsSync(import_node_path15.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path15.default.join(dir, ".env") });
+  }
+  logger.info("Starting federation...", "federation");
+  let cleanedPreviousOutput = false;
+  const result = await federateCatalog(dir, {
+    useCache: commandOptions.cache,
+    isFederationEnabled: import_license.isEventCatalogScaleEnabled,
+    onProgress: (event) => {
+      if (event.type === "cleanup:complete") cleanedPreviousOutput = true;
+      reportFederationProgress(event);
+    }
+  });
+  if (!result && !cleanedPreviousOutput) logger.warning("No federation sources configured; nothing to do.", "federation");
+});
 program.addHelpText(
   "after",
   `
@@ -2363,6 +2963,6 @@ program.addHelpText(
   `
 );
 program.parseAsync().then(() => process.exit(0)).catch((err) => {
-  console.error(err);
+  if (!(err instanceof FederationConflictError)) console.error(err);
   process.exit(1);
 });