@eventcatalog/core 4.7.3 → 4.7.4

package/dist/eventcatalog.config.d.cts

@@ -79,11 +79,11 @@ type GeneratorConfig = string | Record<string, unknown> | [string, Record<string
 type FederationSourceConfig = {
     /** Stable source id used by the lockfile and federation graph. */
     id: string;
-    /** Source locator, for example github:acme/payments. */
+    /** Source locator, for example github:acme/payments or file:../payments. */
     source: string;
-    /** Directory containing the source catalog. @default '.' */
+    /** Directory containing the source catalog, relative to the GitHub repository or filesystem source. @default '.' */
     path?: string;
-    /** Branch or tag to federate. @default 'main' */
+    /** Branch or tag to federate from a GitHub source. Not supported for filesystem sources. @default 'main' */
     ref?: string;
     /** Materialize source files or retain graph references only. @default 'hydrate' */
     mode?: 'hydrate' | 'reference';

package/dist/eventcatalog.config.d.ts

@@ -79,11 +79,11 @@ type GeneratorConfig = string | Record<string, unknown> | [string, Record<string
 type FederationSourceConfig = {
     /** Stable source id used by the lockfile and federation graph. */
     id: string;
-    /** Source locator, for example github:acme/payments. */
+    /** Source locator, for example github:acme/payments or file:../payments. */
     source: string;
-    /** Directory containing the source catalog. @default '.' */
+    /** Directory containing the source catalog, relative to the GitHub repository or filesystem source. @default '.' */
     path?: string;
-    /** Branch or tag to federate. @default 'main' */
+    /** Branch or tag to federate from a GitHub source. Not supported for filesystem sources. @default 'main' */
     ref?: string;
     /** Materialize source files or retain graph references only. @default 'hydrate' */
     mode?: 'hydrate' | 'reference';

package/dist/eventcatalog.js

@@ -2,18 +2,20 @@ import {
   runMigrations
 } from "./chunk-XUAF2H54.js";
 import "./chunk-CA4U2JP7.js";
+import {
+  log_build_default
+} from "./chunk-ZIABX6SP.js";
+import "./chunk-FDXJIZ74.js";
+import "./chunk-K2XIENVT.js";
 import {
   FederationConflictError,
   federateCatalog
-} from "./chunk-ZR6AH5Z2.js";
+} from "./chunk-RIUHZZRA.js";
+import "./chunk-A2RZR3U4.js";
 import "./chunk-R7Z5ALYI.js";
+import "./chunk-SDZQJTJW.js";
 import "./chunk-352FGP6W.js";
 import "./chunk-5EPNFDT5.js";
-import {
-  log_build_default
-} from "./chunk-GINIJSFI.js";
-import "./chunk-SMDTRRED.js";
-import "./chunk-K2XIENVT.js";
 import {
   getProjectOutDir,
   isAuthEnabled,
@@ -22,10 +24,10 @@ import {
 } from "./chunk-B7HCX5HM.js";
 import {
   generate
-} from "./chunk-XXJX3WWF.js";
+} from "./chunk-7QTCSRAC.js";
 import {
   logger
-} from "./chunk-IALEXWSE.js";
+} from "./chunk-ZXVQXBTT.js";
 import {
   resolve_catalog_dependencies_default
 } from "./chunk-LHR4G2UO.js";
@@ -45,7 +47,7 @@ import {
 import "./chunk-W5JQON7Z.js";
 import {
   VERSION
-} from "./chunk-V4FAVGI7.js";
+} from "./chunk-TLWM7WRZ.js";
 import {
   linkCoreNodeModules,
   resolveInstalledCoreNodeModules

package/dist/federation/federate.cjs

@@ -34,10 +34,10 @@ __export(federate_exports, {
   federateCatalog: () => federateCatalog
 });
 module.exports = __toCommonJS(federate_exports);
-var import_node_crypto3 = require("crypto");
-var import_promises5 = __toESM(require("fs/promises"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
-var import_sdk2 = __toESM(require("@eventcatalog/sdk"), 1);
+var import_node_crypto4 = require("crypto");
+var import_promises6 = __toESM(require("fs/promises"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+var import_sdk3 = __toESM(require("@eventcatalog/sdk"), 1);
 
 // src/eventcatalog-config-file-utils.js
 var import_promises = require("fs/promises");
@@ -149,13 +149,230 @@ var createFederationContentCache = (projectDirectory, options = {}) => {
   };
 };
 
+// src/federation/public-assets.ts
+var import_node_crypto2 = require("crypto");
+var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_node_path3 = __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_promises3.default.lstat(filePath);
+    return stat.isFile() ? getContentHash2(await import_promises3.default.readFile(filePath)) : void 0;
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+};
+var getSafePath = (directory, relativePath) => {
+  const normalizedPath = import_node_path3.default.posix.normalize(relativePath);
+  const unsafe = relativePath.length === 0 || relativePath.includes("\0") || relativePath.includes("\\") || import_node_path3.default.posix.isAbsolute(relativePath) || /^[a-zA-Z]:\//.test(relativePath) || normalizedPath !== relativePath || normalizedPath === ".." || normalizedPath.startsWith("../");
+  if (unsafe) return void 0;
+  const resolvedDirectory = import_node_path3.default.resolve(directory);
+  const resolvedPath = import_node_path3.default.resolve(resolvedDirectory, relativePath);
+  const relativeResolvedPath = import_node_path3.default.relative(resolvedDirectory, resolvedPath);
+  if (relativeResolvedPath === "" || relativeResolvedPath === ".." || relativeResolvedPath.startsWith(`..${import_node_path3.default.sep}`) || import_node_path3.default.isAbsolute(relativeResolvedPath)) {
+    return void 0;
+  }
+  return resolvedPath;
+};
+var listFiles = async (directory, relativeDirectory = "") => {
+  let entries;
+  try {
+    entries = await import_promises3.default.readdir(import_node_path3.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_path3.default.join(relativeDirectory, entry.name);
+      if (entry.isDirectory()) return listFiles(directory, relativePath);
+      return entry.isFile() ? [relativePath.split(import_node_path3.default.sep).join("/")] : [];
+    })
+  );
+  return files.flat().sort();
+};
+var pathExists = async (filePath) => {
+  try {
+    await import_promises3.default.lstat(filePath);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+};
+var hasBlockingParent = async (publicDirectory, destinationPath) => {
+  let currentPath = import_node_path3.default.dirname(destinationPath);
+  while (currentPath !== publicDirectory) {
+    try {
+      if (!(await import_promises3.default.lstat(currentPath)).isDirectory()) return true;
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    currentPath = import_node_path3.default.dirname(currentPath);
+  }
+  return false;
+};
+var pruneEmptyDirectories = async (publicDirectory, filePath) => {
+  let currentPath = import_node_path3.default.dirname(filePath);
+  while (currentPath !== publicDirectory) {
+    try {
+      await import_promises3.default.rmdir(currentPath);
+    } catch (error) {
+      if (!["ENOENT", "ENOTEMPTY"].includes(error.code ?? "")) throw error;
+      if (error.code === "ENOTEMPTY") return;
+    }
+    currentPath = import_node_path3.default.dirname(currentPath);
+  }
+};
+var composePublicAssets = async ({
+  projectDirectory,
+  federatedDirectory,
+  assets,
+  previousFiles = {},
+  collisionPaths = /* @__PURE__ */ new Set()
+}) => {
+  const publicDirectory = import_node_path3.default.resolve(projectDirectory, "public");
+  const federatedPublicDirectory = import_node_path3.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_promises3.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_promises3.default.readFile(sourcePath);
+    await import_promises3.default.mkdir(import_node_path3.default.dirname(destinationPath), { recursive: true });
+    await import_promises3.default.writeFile(destinationPath, content);
+    files[relativePath] = { source: asset.resolvedFrom.source, hash: getContentHash2(content) };
+    copied += 1;
+    if (collisionPaths.has(`public/${relativePath}`)) overwritten += 1;
+  }
+  await import_promises3.default.rm(federatedPublicDirectory, { recursive: true, force: true });
+  return { files, copied, skipped, overwritten, removed };
+};
+
+// src/federation/filesystem-source-provider.ts
+var import_node_crypto3 = require("crypto");
+var import_promises4 = __toESM(require("fs/promises"), 1);
+var import_node_path4 = __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_path4.default.relative(directory, target);
+  return relativePath === "" || !relativePath.startsWith(`..${import_node_path4.default.sep}`) && relativePath !== ".." && !import_node_path4.default.isAbsolute(relativePath);
+};
+var assertPortableRelativePath = (filePath, label, allowRoot = true) => {
+  const portablePath = filePath.replaceAll("\\", "/");
+  const normalizedPath = import_node_path4.default.posix.normalize(portablePath);
+  const isUnsafe = filePath.includes("\\") || filePath.includes("\0") || import_node_path4.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_path4.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_path4.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_promises4.default.realpath(sourceRoot), import_promises4.default.realpath(catalogDirectory)]);
+    if (!isWithinDirectory(realSourceRoot, realCatalogDirectory)) {
+      throw new Error(`Catalog path "${source.path}" escapes source "${source.id}"`);
+    }
+    if (!(await import_promises4.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_path4.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_promises4.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_crypto3.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_promises4.default.readFile(await getArtifactPath(catalogDirectory, source, artifactPath));
+  }
+});
+
 // src/federation/github-source-provider.ts
 var import_node_child_process = require("child_process");
-var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_promises5 = __toESM(require("fs/promises"), 1);
 var import_node_os2 = __toESM(require("os"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
 var import_node_util = require("util");
-var import_sdk = __toESM(require("@eventcatalog/sdk"), 1);
+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);
@@ -164,8 +381,8 @@ var parseGitHubSource = (source) => {
 };
 var assertSafeCatalogPath = (source) => {
   const catalogPath = source.path ?? ".";
-  const normalized = import_node_path3.default.posix.normalize(catalogPath.replaceAll("\\", "/"));
-  if (catalogPath.includes("\\") || import_node_path3.default.posix.isAbsolute(normalized) || normalized === ".." || normalized.startsWith("../")) {
+  const normalized = import_node_path5.default.posix.normalize(catalogPath.replaceAll("\\", "/"));
+  if (catalogPath.includes("\\") || import_node_path5.default.posix.isAbsolute(normalized) || normalized === ".." || normalized.startsWith("../")) {
     throw new Error(`Catalog path "${catalogPath}" escapes source "${source.id}"`);
   }
 };
@@ -208,8 +425,8 @@ var getGitEnvironment = (token) => {
 };
 var createCheckout = (executeFile, token) => async (source, ref, callback) => {
   const { owner, repository } = parseGitHubSource(source);
-  const catalogPath = import_node_path3.default.posix.normalize(source.path ?? ".");
-  const directory = await import_promises3.default.mkdtemp(import_node_path3.default.join(import_node_os2.default.tmpdir(), "eventcatalog-federation-"));
+  const catalogPath = import_node_path5.default.posix.normalize(source.path ?? ".");
+  const directory = await import_promises5.default.mkdtemp(import_node_path5.default.join(import_node_os2.default.tmpdir(), "eventcatalog-federation-"));
   const env = getGitEnvironment(token);
   try {
     const git = (args) => executeFile("git", args, { cwd: directory, env, encoding: "utf8" });
@@ -223,25 +440,25 @@ var createCheckout = (executeFile, token) => async (source, ref, callback) => {
     await git(["checkout", "--quiet", "--detach", "FETCH_HEAD"]);
     return await callback(directory);
   } finally {
-    await import_promises3.default.rm(directory, { recursive: true, force: true });
+    await import_promises5.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_path3.default.resolve(directory, source.path ?? ".");
-  const relativeCatalogDirectory = import_node_path3.default.relative(directory, catalogDirectory);
-  if (relativeCatalogDirectory.startsWith("..") || import_node_path3.default.isAbsolute(relativeCatalogDirectory)) {
+  const catalogDirectory = import_node_path5.default.resolve(directory, source.path ?? ".");
+  const relativeCatalogDirectory = import_node_path5.default.relative(directory, catalogDirectory);
+  if (relativeCatalogDirectory.startsWith("..") || import_node_path5.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 });
+  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_path3.default.posix.join(source.path ?? ".", "catalog.index.json");
+  const indexPath = import_node_path5.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")));
+  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}"`);
   }
@@ -261,7 +478,7 @@ var createGitHubSourceProvider = (options = {}) => {
     },
     async fetchContent({ source, commit, path: artifactPath }) {
       assertSafeCatalogPath(source);
-      const catalogPath = import_node_path3.default.posix.join(source.path ?? ".", artifactPath);
+      const catalogPath = import_node_path5.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;
@@ -269,134 +486,23 @@ var createGitHubSourceProvider = (options = {}) => {
   };
 };
 
-// src/federation/public-assets.ts
-var import_node_crypto2 = require("crypto");
-var import_promises4 = __toESM(require("fs/promises"), 1);
-var import_node_path4 = __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_promises4.default.lstat(filePath);
-    return stat.isFile() ? getContentHash2(await import_promises4.default.readFile(filePath)) : void 0;
-  } catch (error) {
-    if (error.code === "ENOENT") return void 0;
-    throw error;
-  }
-};
-var getSafePath = (directory, relativePath) => {
-  const normalizedPath = import_node_path4.default.posix.normalize(relativePath);
-  const unsafe = relativePath.length === 0 || relativePath.includes("\0") || relativePath.includes("\\") || import_node_path4.default.posix.isAbsolute(relativePath) || /^[a-zA-Z]:\//.test(relativePath) || normalizedPath !== relativePath || normalizedPath === ".." || normalizedPath.startsWith("../");
-  if (unsafe) return void 0;
-  const resolvedDirectory = import_node_path4.default.resolve(directory);
-  const resolvedPath = import_node_path4.default.resolve(resolvedDirectory, relativePath);
-  const relativeResolvedPath = import_node_path4.default.relative(resolvedDirectory, resolvedPath);
-  if (relativeResolvedPath === "" || relativeResolvedPath === ".." || relativeResolvedPath.startsWith(`..${import_node_path4.default.sep}`) || import_node_path4.default.isAbsolute(relativeResolvedPath)) {
-    return void 0;
-  }
-  return resolvedPath;
-};
-var listFiles = async (directory, relativeDirectory = "") => {
-  let entries;
-  try {
-    entries = await import_promises4.default.readdir(import_node_path4.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_path4.default.join(relativeDirectory, entry.name);
-      if (entry.isDirectory()) return listFiles(directory, relativePath);
-      return entry.isFile() ? [relativePath.split(import_node_path4.default.sep).join("/")] : [];
-    })
-  );
-  return files.flat().sort();
-};
-var pathExists = async (filePath) => {
-  try {
-    await import_promises4.default.lstat(filePath);
-    return true;
-  } catch (error) {
-    if (error.code === "ENOENT") return false;
-    throw error;
-  }
-};
-var hasBlockingParent = async (publicDirectory, destinationPath) => {
-  let currentPath = import_node_path4.default.dirname(destinationPath);
-  while (currentPath !== publicDirectory) {
-    try {
-      if (!(await import_promises4.default.lstat(currentPath)).isDirectory()) return true;
-    } catch (error) {
-      if (error.code !== "ENOENT") throw error;
-    }
-    currentPath = import_node_path4.default.dirname(currentPath);
-  }
-  return false;
-};
-var pruneEmptyDirectories = async (publicDirectory, filePath) => {
-  let currentPath = import_node_path4.default.dirname(filePath);
-  while (currentPath !== publicDirectory) {
-    try {
-      await import_promises4.default.rmdir(currentPath);
-    } catch (error) {
-      if (!["ENOENT", "ENOTEMPTY"].includes(error.code ?? "")) throw error;
-      if (error.code === "ENOTEMPTY") return;
-    }
-    currentPath = import_node_path4.default.dirname(currentPath);
-  }
-};
-var composePublicAssets = async ({
-  projectDirectory,
-  federatedDirectory,
-  assets,
-  previousFiles = {},
-  collisionPaths = /* @__PURE__ */ new Set()
-}) => {
-  const publicDirectory = import_node_path4.default.resolve(projectDirectory, "public");
-  const federatedPublicDirectory = import_node_path4.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_promises4.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;
+// 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);
     }
-    const asset = publicAssetsByPath.get(relativePath);
-    if (!asset) throw new Error(`Cannot identify the source of federated public asset "${relativePath}"`);
-    const content = await import_promises4.default.readFile(sourcePath);
-    await import_promises4.default.mkdir(import_node_path4.default.dirname(destinationPath), { recursive: true });
-    await import_promises4.default.writeFile(destinationPath, content);
-    files[relativePath] = { source: asset.resolvedFrom.source, hash: getContentHash2(content) };
-    copied += 1;
-    if (collisionPaths.has(`public/${relativePath}`)) overwritten += 1;
-  }
-  await import_promises4.default.rm(federatedPublicDirectory, { recursive: true, force: true });
-  return { files, copied, skipped, overwritten, removed };
+  };
 };
 
 // src/federation/federate.ts
@@ -421,16 +527,16 @@ var validateSources = (sources) => {
 var writeLock = async (lockPath, lock) => {
   const temporaryPath = `${lockPath}.tmp-${process.pid}`;
   try {
-    await import_promises5.default.writeFile(temporaryPath, `${JSON.stringify(lock, null, 2)}
+    await import_promises6.default.writeFile(temporaryPath, `${JSON.stringify(lock, null, 2)}
 `, "utf8");
-    await import_promises5.default.rename(temporaryPath, lockPath);
+    await import_promises6.default.rename(temporaryPath, lockPath);
   } finally {
-    await import_promises5.default.rm(temporaryPath, { force: true });
+    await import_promises6.default.rm(temporaryPath, { force: true });
   }
 };
 var readLock = async (lockPath) => {
   try {
-    return JSON.parse(await import_promises5.default.readFile(lockPath, "utf8"));
+    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 });
@@ -438,7 +544,7 @@ var readLock = async (lockPath) => {
 };
 var pathExists2 = async (filePath) => {
   try {
-    await import_promises5.default.access(filePath);
+    await import_promises6.default.access(filePath);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") return false;
@@ -446,20 +552,20 @@ var pathExists2 = async (filePath) => {
   }
 };
 var cleanupPreviousFederation = async (projectDirectory, onProgress) => {
-  const outDir = import_node_path5.default.join(projectDirectory, "federated");
-  const lockPath = import_node_path5.default.join(projectDirectory, "eventcatalog.lock");
+  const outDir = import_node_path6.default.join(projectDirectory, "federated");
+  const lockPath = import_node_path6.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_promises5.default.rm(outDir, { recursive: true, force: true });
+  await import_promises6.default.rm(outDir, { recursive: true, force: true });
   const publicResult = await composePublicAssets({
     projectDirectory,
     federatedDirectory: outDir,
     assets: [],
     previousFiles: previousLock?.publicFiles
   });
-  await import_promises5.default.rm(lockPath, { force: true });
+  await import_promises6.default.rm(lockPath, { force: true });
   onProgress?.({
     type: "cleanup:complete",
     federated: hadFederatedOutput,
@@ -482,7 +588,7 @@ var federateCatalog = async (projectDirectory, options = {}) => {
   }
   validateSources(sources);
   if (options.useCache === false) options.onProgress?.({ type: "cache:disabled" });
-  const provider = options.provider ?? createGitHubSourceProvider();
+  const provider = options.provider ?? createFederationSourceProvider(projectDirectory);
   const resolvedSources = [];
   for (const [index, source] of sources.entries()) {
     const current = index + 1;
@@ -504,13 +610,13 @@ var federateCatalog = async (projectDirectory, options = {}) => {
       throw new Error(`Failed to federate source "${source.id}": ${message}`, { cause: error });
     }
   }
-  const outDir = import_node_path5.default.join(projectDirectory, "federated");
-  const lockPath = import_node_path5.default.join(projectDirectory, "eventcatalog.lock");
+  const outDir = import_node_path6.default.join(projectDirectory, "federated");
+  const lockPath = import_node_path6.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({
+  const localIndex = await (0, import_sdk3.default)(projectDirectory).buildIndex({
     source: config.cId,
     commit: "local",
     hashContent: false,
@@ -518,18 +624,18 @@ var federateCatalog = async (projectDirectory, options = {}) => {
   });
   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]);
+  const ownershipGraph = (0, import_sdk3.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);
+  const graph = (0, import_sdk3.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, {
+  const hydrateResult = await (0, import_sdk3.hydrate)(graph, {
     outDir,
     cache: createFederationContentCache(projectDirectory, {
       read: options.useCache !== false,
@@ -563,7 +669,7 @@ var federateCatalog = async (projectDirectory, options = {}) => {
     lockVersion: 1,
     sources: resolvedSources.map(({ config: source, resolved }) => ({
       id: source.id,
-      digest: `sha256:${(0, import_node_crypto3.createHash)("sha256").update(resolved.bytes).digest("hex")}`,
+      digest: `sha256:${(0, import_node_crypto4.createHash)("sha256").update(resolved.bytes).digest("hex")}`,
       commit: resolved.commit,
       resolvedAt
     })).sort((left, right) => left.id.localeCompare(right.id)),