@eventcatalog/core 4.7.3 → 4.7.5

package/dist/federation/source-provider.cjs

@@ -0,0 +1,265 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/federation/source-provider.ts
+var source_provider_exports = {};
+__export(source_provider_exports, {
+  createFederationSourceProvider: () => createFederationSourceProvider
+});
+module.exports = __toCommonJS(source_provider_exports);
+
+// src/federation/filesystem-source-provider.ts
+var import_node_crypto = require("crypto");
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var import_sdk = __toESM(require("@eventcatalog/sdk"), 1);
+var FILESYSTEM_SOURCE_PREFIX = "file:";
+var isWithinDirectory = (directory, target) => {
+  const relativePath = import_node_path.default.relative(directory, target);
+  return relativePath === "" || !relativePath.startsWith(`..${import_node_path.default.sep}`) && relativePath !== ".." && !import_node_path.default.isAbsolute(relativePath);
+};
+var assertPortableRelativePath = (filePath, label, allowRoot = true) => {
+  const portablePath = filePath.replaceAll("\\", "/");
+  const normalizedPath = import_node_path.default.posix.normalize(portablePath);
+  const isUnsafe = filePath.includes("\\") || filePath.includes("\0") || import_node_path.default.posix.isAbsolute(normalizedPath) || /^[a-zA-Z]:\//.test(normalizedPath) || normalizedPath === ".." || normalizedPath.startsWith("../") || !allowRoot && (normalizedPath === "." || normalizedPath === "");
+  if (isUnsafe) throw new Error(`${label} "${filePath}" escapes its filesystem source`);
+  return normalizedPath;
+};
+var getSourceRoot = (projectDirectory, source) => {
+  if (!source.source.startsWith(FILESYSTEM_SOURCE_PREFIX)) {
+    throw new Error(`Unsupported federation source "${source.source}". Expected file:path/to/catalog.`);
+  }
+  const locator = source.source.slice(FILESYSTEM_SOURCE_PREFIX.length);
+  if (!locator.trim()) throw new Error(`Filesystem federation source "${source.id}" requires a path after "file:".`);
+  return import_node_path.default.resolve(projectDirectory, locator);
+};
+var getCatalogDirectory = async (projectDirectory, source) => {
+  if (source.ref) throw new Error(`Filesystem federation source "${source.id}" does not support "ref".`);
+  const sourceRoot = getSourceRoot(projectDirectory, source);
+  const catalogPath = assertPortableRelativePath(source.path ?? ".", "Catalog path");
+  const catalogDirectory = import_node_path.default.resolve(sourceRoot, ...catalogPath.split("/"));
+  if (!isWithinDirectory(sourceRoot, catalogDirectory)) {
+    throw new Error(`Catalog path "${source.path}" escapes source "${source.id}"`);
+  }
+  try {
+    const [realSourceRoot, realCatalogDirectory] = await Promise.all([import_promises.default.realpath(sourceRoot), import_promises.default.realpath(catalogDirectory)]);
+    if (!isWithinDirectory(realSourceRoot, realCatalogDirectory)) {
+      throw new Error(`Catalog path "${source.path}" escapes source "${source.id}"`);
+    }
+    if (!(await import_promises.default.stat(realCatalogDirectory)).isDirectory()) {
+      throw new Error(`Filesystem federation source "${source.id}" is not a directory: ${catalogDirectory}`);
+    }
+    return realCatalogDirectory;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Filesystem federation source "${source.id}" does not exist: ${catalogDirectory}`, { cause: error });
+    }
+    throw error;
+  }
+};
+var getArtifactPath = async (catalogDirectory, source, artifactPath) => {
+  const normalizedPath = assertPortableRelativePath(artifactPath, "Federated artifact path", false);
+  const filePath = import_node_path.default.resolve(catalogDirectory, ...normalizedPath.split("/"));
+  if (!isWithinDirectory(catalogDirectory, filePath)) {
+    throw new Error(`Federated artifact path "${artifactPath}" escapes source "${source.id}"`);
+  }
+  try {
+    const realFilePath = await import_promises.default.realpath(filePath);
+    if (!isWithinDirectory(catalogDirectory, realFilePath)) {
+      throw new Error(`Federated artifact path "${artifactPath}" escapes source "${source.id}"`);
+    }
+    return realFilePath;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Federated artifact not found for "${source.id}": ${artifactPath}`, { cause: error });
+    }
+    throw error;
+  }
+};
+var createFileSystemSourceProvider = (projectDirectory) => ({
+  async resolve(source) {
+    const catalogDirectory = await getCatalogDirectory(projectDirectory, source);
+    const localIndex = await (0, import_sdk.default)(catalogDirectory).buildIndex({
+      source: source.id,
+      commit: "local",
+      includeFederated: false
+    });
+    const snapshot = (0, import_node_crypto.createHash)("sha256").update(JSON.stringify(localIndex)).digest("hex").slice(0, 12);
+    const index = { ...localIndex, commit: `local:${snapshot}` };
+    const bytes = Buffer.from(JSON.stringify(index));
+    return { bytes, index, commit: index.commit, generated: true };
+  },
+  async fetchContent({ source, path: artifactPath }) {
+    const catalogDirectory = await getCatalogDirectory(projectDirectory, source);
+    return import_promises.default.readFile(await getArtifactPath(catalogDirectory, source, artifactPath));
+  }
+});
+
+// src/federation/github-source-provider.ts
+var import_node_child_process = require("child_process");
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_node_os = __toESM(require("os"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var import_node_util = require("util");
+var import_sdk2 = __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_path2.default.posix.normalize(catalogPath.replaceAll("\\", "/"));
+  if (catalogPath.includes("\\") || import_node_path2.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_path2.default.posix.normalize(source.path ?? ".");
+  const directory = await import_promises2.default.mkdtemp(import_node_path2.default.join(import_node_os.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_promises2.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_path2.default.resolve(directory, source.path ?? ".");
+  const relativeCatalogDirectory = import_node_path2.default.relative(directory, catalogDirectory);
+  if (relativeCatalogDirectory.startsWith("..") || import_node_path2.default.isAbsolute(relativeCatalogDirectory)) {
+    throw new Error(`Catalog path "${source.path}" escapes source "${source.id}"`);
+  }
+  const index = await (0, import_sdk2.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_path2.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_sdk2.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_path2.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/source-provider.ts
+var createFederationSourceProvider = (projectDirectory, providers = {}) => {
+  const github = providers.github ?? createGitHubSourceProvider();
+  const filesystem = providers.filesystem ?? createFileSystemSourceProvider(projectDirectory);
+  const getProvider = (source) => {
+    if (source.source.startsWith("github:")) return github;
+    if (source.source.startsWith("file:")) return filesystem;
+    throw new Error(`Unsupported federation source "${source.source}" for "${source.id}". Supported protocols: github:, file:.`);
+  };
+  return {
+    async resolve(source) {
+      return getProvider(source).resolve(source);
+    },
+    async fetchContent(request) {
+      return getProvider(request.source).fetchContent(request);
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createFederationSourceProvider
+});

package/dist/federation/source-provider.d.cts

@@ -0,0 +1,11 @@
+import { FederationSourceProvider } from './types.cjs';
+import '@eventcatalog/sdk';
+import '../eventcatalog.config.cjs';
+
+type FederationSourceProviders = {
+    github?: FederationSourceProvider;
+    filesystem?: FederationSourceProvider;
+};
+declare const createFederationSourceProvider: (projectDirectory: string, providers?: FederationSourceProviders) => FederationSourceProvider;
+
+export { createFederationSourceProvider };

package/dist/federation/source-provider.d.ts

@@ -0,0 +1,11 @@
+import { FederationSourceProvider } from './types.js';
+import '@eventcatalog/sdk';
+import '../eventcatalog.config.js';
+
+type FederationSourceProviders = {
+    github?: FederationSourceProvider;
+    filesystem?: FederationSourceProvider;
+};
+declare const createFederationSourceProvider: (projectDirectory: string, providers?: FederationSourceProviders) => FederationSourceProvider;
+
+export { createFederationSourceProvider };

package/dist/federation/source-provider.js

@@ -0,0 +1,8 @@
+import {
+  createFederationSourceProvider
+} from "../chunk-A2RZR3U4.js";
+import "../chunk-SDZQJTJW.js";
+import "../chunk-352FGP6W.js";
+export {
+  createFederationSourceProvider
+};

package/dist/generate.cjs

@@ -108,7 +108,7 @@ var getEventCatalogConfigFile = async (projectDirectory) => {
 var import_picocolors = __toESM(require("picocolors"), 1);
 
 // package.json
-var version = "4.7.3";
+var version = "4.7.5";
 
 // src/constants.ts
 var VERSION = version;
@@ -147,6 +147,29 @@ var logger = {
   warning: (message, tag = "warn") => {
     console.log(formatMessage(tag, message, import_picocolors.default.yellow));
   },
+  line: (message = "") => {
+    console.log(message);
+  },
+  diagnostic: (severity, message, rule, attributes = []) => {
+    const isError = severity === "error";
+    const color = isError ? import_picocolors.default.red : import_picocolors.default.yellow;
+    const icon = isError ? "\u2716" : "\u26A0";
+    const label = `${icon} ${severity.padEnd(7)} ${message}`;
+    const ruleSpacing = " ".repeat(Math.max(2, 72 - label.length));
+    console.log(`  ${color(icon)} ${color(severity.padEnd(7))} ${message}${ruleSpacing}${import_picocolors.default.gray(rule)}`);
+    for (const attribute of attributes) {
+      console.log(`             - ${import_picocolors.default.dim(`${attribute.label}:`)} ${attribute.value}`);
+    }
+  },
+  diagnosticSummary: (errors, warnings) => {
+    const total = errors + warnings;
+    const color = errors > 0 ? import_picocolors.default.red : import_picocolors.default.yellow;
+    const icon = errors > 0 ? "\u2716" : "\u26A0";
+    const problems = `${total} problem${total === 1 ? "" : "s"}`;
+    const errorCount = `${errors} error${errors === 1 ? "" : "s"}`;
+    const warningCount = `${warnings} warning${warnings === 1 ? "" : "s"}`;
+    console.log(color(`${icon} ${problems} (${errorCount}, ${warningCount})`));
+  },
   dim: (message) => {
     console.log(import_picocolors.default.dim(message));
   }

package/dist/generate.js

@@ -1,8 +1,8 @@
 import {
   generate
-} from "./chunk-XXJX3WWF.js";
-import "./chunk-IALEXWSE.js";
-import "./chunk-V4FAVGI7.js";
+} from "./chunk-EUZT4RKY.js";
+import "./chunk-QQPH6RCB.js";
+import "./chunk-ZBPMCEXS.js";
 import "./chunk-6QENHZZP.js";
 export {
   generate

package/dist/utils/cli-logger.cjs

@@ -36,7 +36,7 @@ module.exports = __toCommonJS(cli_logger_exports);
 var import_picocolors = __toESM(require("picocolors"), 1);
 
 // package.json
-var version = "4.7.3";
+var version = "4.7.5";
 
 // src/constants.ts
 var VERSION = version;
@@ -75,6 +75,29 @@ var logger = {
   warning: (message, tag = "warn") => {
     console.log(formatMessage(tag, message, import_picocolors.default.yellow));
   },
+  line: (message = "") => {
+    console.log(message);
+  },
+  diagnostic: (severity, message, rule, attributes = []) => {
+    const isError = severity === "error";
+    const color = isError ? import_picocolors.default.red : import_picocolors.default.yellow;
+    const icon = isError ? "\u2716" : "\u26A0";
+    const label = `${icon} ${severity.padEnd(7)} ${message}`;
+    const ruleSpacing = " ".repeat(Math.max(2, 72 - label.length));
+    console.log(`  ${color(icon)} ${color(severity.padEnd(7))} ${message}${ruleSpacing}${import_picocolors.default.gray(rule)}`);
+    for (const attribute of attributes) {
+      console.log(`             - ${import_picocolors.default.dim(`${attribute.label}:`)} ${attribute.value}`);
+    }
+  },
+  diagnosticSummary: (errors, warnings) => {
+    const total = errors + warnings;
+    const color = errors > 0 ? import_picocolors.default.red : import_picocolors.default.yellow;
+    const icon = errors > 0 ? "\u2716" : "\u26A0";
+    const problems = `${total} problem${total === 1 ? "" : "s"}`;
+    const errorCount = `${errors} error${errors === 1 ? "" : "s"}`;
+    const warningCount = `${warnings} warning${warnings === 1 ? "" : "s"}`;
+    console.log(color(`${icon} ${problems} (${errorCount}, ${warningCount})`));
+  },
   dim: (message) => {
     console.log(import_picocolors.default.dim(message));
   }

package/dist/utils/cli-logger.d.cts

@@ -4,6 +4,12 @@ declare const logger: {
     success: (message: string, tag?: string) => void;
     error: (message: string, tag?: string) => void;
     warning: (message: string, tag?: string) => void;
+    line: (message?: string) => void;
+    diagnostic: (severity: "error" | "warning", message: string, rule: string, attributes?: {
+        label: string;
+        value: string;
+    }[]) => void;
+    diagnosticSummary: (errors: number, warnings: number) => void;
     dim: (message: string) => void;
 };
 

package/dist/utils/cli-logger.d.ts

@@ -4,6 +4,12 @@ declare const logger: {
     success: (message: string, tag?: string) => void;
     error: (message: string, tag?: string) => void;
     warning: (message: string, tag?: string) => void;
+    line: (message?: string) => void;
+    diagnostic: (severity: "error" | "warning", message: string, rule: string, attributes?: {
+        label: string;
+        value: string;
+    }[]) => void;
+    diagnosticSummary: (errors: number, warnings: number) => void;
     dim: (message: string) => void;
 };
 

package/dist/utils/cli-logger.js

@@ -1,7 +1,7 @@
 import {
   logger
-} from "../chunk-IALEXWSE.js";
-import "../chunk-V4FAVGI7.js";
+} from "../chunk-QQPH6RCB.js";
+import "../chunk-ZBPMCEXS.js";
 export {
   logger
 };

package/package.json

@@ -7,7 +7,7 @@
   },
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",
-  "version": "4.7.3",
+  "version": "4.7.5",
   "publishConfig": {
     "access": "public"
   },
@@ -119,8 +119,8 @@
     "update-notifier": "^7.3.1",
     "uuid": "^11.1.1",
     "zod": "^4.3.6",
-    "@eventcatalog/linter": "1.1.12",
-    "@eventcatalog/sdk": "2.27.2",
+    "@eventcatalog/linter": "1.1.14",
+    "@eventcatalog/sdk": "2.27.4",
     "@eventcatalog/visualiser": "^4.1.3"
   },
   "devDependencies": {

package/dist/chunk-ZR6AH5Z2.js

@@ -1,204 +0,0 @@
-import {
-  createFederationContentCache
-} from "./chunk-R7Z5ALYI.js";
-import {
-  createGitHubSourceProvider
-} from "./chunk-352FGP6W.js";
-import {
-  composePublicAssets
-} from "./chunk-5EPNFDT5.js";
-import {
-  getEventCatalogConfigFile
-} from "./chunk-6QENHZZP.js";
-
-// src/federation/federate.ts
-import { createHash } from "crypto";
-import fs from "fs/promises";
-import path from "path";
-import createSDK, { hydrate, resolve } from "@eventcatalog/sdk";
-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 fs.writeFile(temporaryPath, `${JSON.stringify(lock, null, 2)}
-`, "utf8");
-    await fs.rename(temporaryPath, lockPath);
-  } finally {
-    await fs.rm(temporaryPath, { force: true });
-  }
-};
-var readLock = async (lockPath) => {
-  try {
-    return JSON.parse(await fs.readFile(lockPath, "utf8"));
-  } catch (error) {
-    if (error.code === "ENOENT") return void 0;
-    throw new Error(`Cannot read federation lock at "${lockPath}"`, { cause: error });
-  }
-};
-var pathExists = async (filePath) => {
-  try {
-    await fs.access(filePath);
-    return true;
-  } catch (error) {
-    if (error.code === "ENOENT") return false;
-    throw error;
-  }
-};
-var cleanupPreviousFederation = async (projectDirectory, onProgress) => {
-  const outDir = path.join(projectDirectory, "federated");
-  const lockPath = path.join(projectDirectory, "eventcatalog.lock");
-  const previousLock = await readLock(lockPath);
-  const hadFederatedOutput = await pathExists(outDir);
-  const hadLock = previousLock !== void 0;
-  if (!hadFederatedOutput && !hadLock) return;
-  await fs.rm(outDir, { recursive: true, force: true });
-  const publicResult = await composePublicAssets({
-    projectDirectory,
-    federatedDirectory: outDir,
-    assets: [],
-    previousFiles: previousLock?.publicFiles
-  });
-  await fs.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 = path.join(projectDirectory, "federated");
-  const lockPath = path.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 createSDK(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 = resolve([localIndex, ...remoteIndexes]);
-  if (ownershipGraph.conflicts.length > 0) {
-    options.onProgress?.({ type: "resolved", graph: ownershipGraph });
-    throw new FederationConflictError(ownershipGraph.conflicts);
-  }
-  const graph = 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 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:${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;
-};
-
-export {
-  FederationConflictError,
-  federateCatalog
-};