@eventcatalog/core 4.10.4 → 4.10.6

package/dist/eventcatalog.cjs

@@ -29,10 +29,10 @@ var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 // src/eventcatalog.ts
 var import_commander = require("commander");
 var import_node_child_process2 = require("child_process");
-var import_node_path17 = require("path");
+var import_node_path18 = require("path");
 var import_node_http = __toESM(require("http"), 1);
 var import_fs3 = __toESM(require("fs"), 1);
-var import_node_path18 = __toESM(require("path"), 1);
+var import_node_path19 = __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.10.4";
+var version = "4.10.6";
 
 // src/constants.ts
 var VERSION = version;
@@ -299,6 +299,9 @@ async function raiseEvent(eventData) {
 
 // src/analytics/count-resources.js
 var import_glob = require("glob");
+var import_node_crypto = require("crypto");
+var import_promises2 = require("fs/promises");
+var import_node_path3 = __toESM(require("path"), 1);
 var RESOURCE_PATTERNS = {
   adrs: ["**/adrs/*/index.@(md|mdx)"],
   agents: ["**/agents/*/index.@(md|mdx)"],
@@ -339,6 +342,23 @@ async function countResources(projectDir) {
   }
   return counts;
 }
+async function hashCatalogContent(projectDir) {
+  const hash = (0, import_node_crypto.createHash)("sha256");
+  const files = /* @__PURE__ */ new Set();
+  for (const pattern of Object.values(RESOURCE_PATTERNS).flat()) {
+    for (const file of await (0, import_glob.glob)(pattern, { cwd: projectDir, ignore: DEFAULT_IGNORES })) {
+      files.add(file);
+    }
+  }
+  for (const file of [...files].sort()) {
+    try {
+      hash.update(file);
+      hash.update(await (0, import_promises2.readFile)(import_node_path3.default.join(projectDir, file)));
+    } catch {
+    }
+  }
+  return hash.digest("hex").slice(0, 16);
+}
 function serializeCounts(counts) {
   return Object.entries(counts).map(([k, v]) => `${k}:${v}`).join(",");
 }
@@ -412,7 +432,7 @@ var reportCloudResourceInventory = async (configFile, resourceCounts) => {
     })
   });
 };
-var main = async (projectDir, { isEventCatalogStarterEnabled: isEventCatalogStarterEnabled2, isEventCatalogScaleEnabled: isEventCatalogScaleEnabled2, isBackstagePluginEnabled }) => {
+var main = async (projectDir, { isEventCatalogStarterEnabled: isEventCatalogStarterEnabled2, isEventCatalogScaleEnabled: isEventCatalogScaleEnabled2, isBackstagePluginEnabled, command = "build" }) => {
   try {
     await verifyRequiredFieldsAreInCatalogConfigFile(projectDir);
     const configFile = await getEventCatalogConfigFile(projectDir);
@@ -429,11 +449,18 @@ var main = async (projectDir, { isEventCatalogStarterEnabled: isEventCatalogStar
     }
     const features = await getFeatures(configFile);
     const resourceCounts = await countResources(projectDir);
+    const contentHash = await hashCatalogContent(projectDir);
     await reportCloudResourceInventory(configFile, resourceCounts);
     await raiseEvent({
-      command: "build",
+      command,
       org: organizationName,
       cId,
+      // CI redeploys and human-run builds are different signals; tag rather than suppress
+      ci: process.env.CI ? "true" : "false",
+      // The commercial plan, separate from the generators list, so telemetry joins cleanly to licensing
+      plan: isEventCatalogScaleEnabled2 ? "scale" : isEventCatalogStarterEnabled2 ? "starter" : "none",
+      backstage: isBackstagePluginEnabled ? "true" : "false",
+      contentHash,
       generators: generatorNames.toString(),
       features: Object.keys(features).map((feature) => `${feature}:${features[feature]}`).join(","),
       directorySources: serializeDirectorySources(configFile),
@@ -449,7 +476,7 @@ var import_watcher = __toESM(require("@parcel/watcher"), 1);
 var import_node_fs2 = __toESM(require("fs"), 1);
 
 // src/map-catalog-to-astro.js
-var import_node_path3 = __toESM(require("path"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 var CUSTOM_PAGE_EXTENSIONS = [".astro", ".ts", ".js", ".mjs"];
 var COLLECTION_KEYS = [
   "agents",
@@ -479,10 +506,10 @@ function mapCatalogToAstro({ filePath, astroDir, projectDir }) {
   }
   const baseTargetPaths = getBaseTargetPaths(relativeFilePath);
   const relativeTargetPath = getRelativeTargetPath(relativeFilePath);
-  return baseTargetPaths.map((base) => import_node_path3.default.join(astroDir, base, relativeTargetPath));
+  return baseTargetPaths.map((base) => import_node_path4.default.join(astroDir, base, relativeTargetPath));
 }
 function removeBasePath(fullPath, basePath) {
-  const relativePath = import_node_path3.default.relative(basePath, fullPath);
+  const relativePath = import_node_path4.default.relative(basePath, fullPath);
   return relativePath.startsWith("..") ? fullPath : relativePath;
 }
 function isCollectionKey(key) {
@@ -493,21 +520,21 @@ function isLikeC4Source(filePath) {
 }
 var hasExtension = (str) => /\.[a-zA-Z0-9]{2,}$/.test(str);
 function getCustomPageTargetPaths(filePath, astroDir) {
-  const filePathArr = filePath.split(import_node_path3.default.sep).filter(Boolean);
+  const filePathArr = filePath.split(import_node_path4.default.sep).filter(Boolean);
   if (filePathArr[0] !== "pages") {
     return null;
   }
-  const customPagePath = import_node_path3.default.join(astroDir, "src", "custom-pages", ...filePathArr.slice(1));
-  if (CUSTOM_PAGE_EXTENSIONS.includes(import_node_path3.default.extname(filePath).toLowerCase())) {
+  const customPagePath = import_node_path4.default.join(astroDir, "src", "custom-pages", ...filePathArr.slice(1));
+  if (CUSTOM_PAGE_EXTENSIONS.includes(import_node_path4.default.extname(filePath).toLowerCase())) {
     return [customPagePath];
   }
   if (!hasExtension(filePath)) {
-    return [customPagePath, import_node_path3.default.join(astroDir, "public", "generated", ...filePathArr)];
+    return [customPagePath, import_node_path4.default.join(astroDir, "public", "generated", ...filePathArr)];
   }
-  return [import_node_path3.default.join(astroDir, "public", "generated", ...filePathArr)];
+  return [import_node_path4.default.join(astroDir, "public", "generated", ...filePathArr)];
 }
 function isCatalogRelated(filePath) {
-  const filePathArr = filePath.split(import_node_path3.default.sep).filter(Boolean);
+  const filePathArr = filePath.split(import_node_path4.default.sep).filter(Boolean);
   if ([
     "eventcatalog.config.js",
     // config file at root
@@ -528,38 +555,38 @@ function isCatalogRelated(filePath) {
   return false;
 }
 function getBaseTargetPaths(filePath) {
-  const filePathArr = filePath.split(import_node_path3.default.sep).filter(Boolean);
+  const filePathArr = filePath.split(import_node_path4.default.sep).filter(Boolean);
   if (isCollectionKey(filePathArr[0])) {
     if (hasExtension(filePath)) {
-      return [import_node_path3.default.join("public", "generated")];
+      return [import_node_path4.default.join("public", "generated")];
     }
-    return [import_node_path3.default.join("public", "generated")];
+    return [import_node_path4.default.join("public", "generated")];
   }
   if (filePathArr[0] == "components") {
-    return [import_node_path3.default.join("src", "custom-defined-components")];
+    return [import_node_path4.default.join("src", "custom-defined-components")];
   }
   if (filePathArr[0] == "snippets") {
-    return [import_node_path3.default.join("src")];
+    return [import_node_path4.default.join("src")];
   }
   if (filePathArr[0] == "public") {
-    return [import_node_path3.default.join("public")];
+    return [import_node_path4.default.join("public")];
   }
-  return [import_node_path3.default.join("/")];
+  return [import_node_path4.default.join("/")];
 }
 function getRelativeTargetPath(filePath) {
-  const filePathArr = filePath.split(import_node_path3.default.sep).filter(Boolean);
+  const filePathArr = filePath.split(import_node_path4.default.sep).filter(Boolean);
   if (filePathArr[0] == "public" || filePathArr[0] == "components") {
     filePathArr.shift();
   }
   if (filePathArr[0] == "snippets") {
-    return import_node_path3.default.join("snippets", ...filePathArr.slice(1));
+    return import_node_path4.default.join("snippets", ...filePathArr.slice(1));
   }
   const relativePath = [];
   for (let i = filePathArr.length - 1; i >= 0; i--) {
     relativePath.unshift(filePathArr[i]);
     if (isCollectionKey(filePathArr[i]) && filePathArr[i] != "snippets") break;
   }
-  return import_node_path3.default.join(...relativePath);
+  return import_node_path4.default.join(...relativePath);
 }
 
 // src/watcher.js
@@ -656,21 +683,21 @@ function retryEPERM(fn) {
 
 // src/catalog-to-astro-content-directory.js
 var import_glob2 = require("glob");
-var path5 = __toESM(require("path"), 1);
+var path6 = __toESM(require("path"), 1);
 var import_fs = __toESM(require("fs"), 1);
 var import_url2 = require("url");
 var import_node_os2 = __toESM(require("os"), 1);
 
 // src/custom-components.js
-var import_promises2 = __toESM(require("fs/promises"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
+var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
 var isCustomComponentPath = (projectDirectory, filePath) => {
-  const [rootDirectory, childDirectory] = import_node_path4.default.relative(projectDirectory, filePath).split(import_node_path4.default.sep);
+  const [rootDirectory, childDirectory] = import_node_path5.default.relative(projectDirectory, filePath).split(import_node_path5.default.sep);
   return rootDirectory === "components" || rootDirectory === "federated" && childDirectory === "components";
 };
 var readDirectory = async (directory) => {
   try {
-    return await import_promises2.default.readdir(directory, { withFileTypes: true });
+    return await import_promises3.default.readdir(directory, { withFileTypes: true });
   } catch (error) {
     if (error.code === "ENOENT") return [];
     throw error;
@@ -678,57 +705,57 @@ var readDirectory = async (directory) => {
 };
 var mergeDirectory = async (sourceDirectory, destinationDirectory) => {
   for (const entry of await readDirectory(sourceDirectory)) {
-    const sourcePath = import_node_path4.default.join(sourceDirectory, entry.name);
-    const destinationPath = import_node_path4.default.join(destinationDirectory, entry.name);
+    const sourcePath = import_node_path5.default.join(sourceDirectory, entry.name);
+    const destinationPath = import_node_path5.default.join(destinationDirectory, entry.name);
     if (entry.isDirectory()) {
-      const destinationEntry = await import_promises2.default.stat(destinationPath).catch((error) => {
+      const destinationEntry = await import_promises3.default.stat(destinationPath).catch((error) => {
         if (error.code === "ENOENT") return void 0;
         throw error;
       });
       if (destinationEntry && !destinationEntry.isDirectory()) {
-        await import_promises2.default.rm(destinationPath, { recursive: true, force: true });
+        await import_promises3.default.rm(destinationPath, { recursive: true, force: true });
       }
-      await import_promises2.default.mkdir(destinationPath, { recursive: true });
+      await import_promises3.default.mkdir(destinationPath, { recursive: true });
       await mergeDirectory(sourcePath, destinationPath);
       continue;
     }
-    await import_promises2.default.rm(destinationPath, { recursive: true, force: true });
-    await import_promises2.default.copyFile(sourcePath, destinationPath);
+    await import_promises3.default.rm(destinationPath, { recursive: true, force: true });
+    await import_promises3.default.copyFile(sourcePath, destinationPath);
   }
 };
 var syncCustomComponents = async (projectDirectory, catalogDirectory) => {
-  const destinationDirectory = import_node_path4.default.join(catalogDirectory, "src", "custom-defined-components");
-  const destinationParent = import_node_path4.default.dirname(destinationDirectory);
-  await import_promises2.default.mkdir(destinationParent, { recursive: true });
-  const stagingDirectory = await import_promises2.default.mkdtemp(import_node_path4.default.join(destinationParent, ".custom-defined-components.staging-"));
+  const destinationDirectory = import_node_path5.default.join(catalogDirectory, "src", "custom-defined-components");
+  const destinationParent = import_node_path5.default.dirname(destinationDirectory);
+  await import_promises3.default.mkdir(destinationParent, { recursive: true });
+  const stagingDirectory = await import_promises3.default.mkdtemp(import_node_path5.default.join(destinationParent, ".custom-defined-components.staging-"));
   try {
-    await mergeDirectory(import_node_path4.default.join(projectDirectory, "federated", "components"), stagingDirectory);
-    await mergeDirectory(import_node_path4.default.join(projectDirectory, "components"), stagingDirectory);
-    await import_promises2.default.rm(destinationDirectory, { recursive: true, force: true });
-    await import_promises2.default.rename(stagingDirectory, destinationDirectory);
+    await mergeDirectory(import_node_path5.default.join(projectDirectory, "federated", "components"), stagingDirectory);
+    await mergeDirectory(import_node_path5.default.join(projectDirectory, "components"), stagingDirectory);
+    await import_promises3.default.rm(destinationDirectory, { recursive: true, force: true });
+    await import_promises3.default.rename(stagingDirectory, destinationDirectory);
   } finally {
-    await import_promises2.default.rm(stagingDirectory, { recursive: true, force: true });
+    await import_promises3.default.rm(stagingDirectory, { recursive: true, force: true });
   }
 };
 
 // src/catalog-to-astro-content-directory.js
 var __filename2 = (0, import_url2.fileURLToPath)(importMetaUrl);
-var rootPkg = path5.resolve(path5.dirname(__filename2), "../");
+var rootPkg = path6.resolve(path6.dirname(__filename2), "../");
 var copyFiles = async (source, target) => {
-  const files = await (0, import_glob2.glob)(path5.join(source, "**"), {
+  const files = await (0, import_glob2.glob)(path6.join(source, "**"), {
     nodir: true,
     windowsPathsNoEscape: import_node_os2.default.platform() == "win32",
     ignore: ["node_modules/**", "**/dist/**", "**/teams", "**/users", "**/*.mdx", "**/*.md", "**/package.json", "**/Dockerfile"]
   });
-  const snippets = await (0, import_glob2.glob)(path5.join(source, "snippets/**/*.mdx"), {
+  const snippets = await (0, import_glob2.glob)(path6.join(source, "snippets/**/*.mdx"), {
     nodir: true,
     windowsPathsNoEscape: import_node_os2.default.platform() == "win32"
   });
   if (snippets.length > 0) {
     files.push(...snippets);
   }
-  if (import_fs.default.existsSync(path5.join(source, ".env"))) {
-    files.push(path5.join(source, ".env"));
+  if (import_fs.default.existsSync(path6.join(source, ".env"))) {
+    files.push(path6.join(source, ".env"));
   }
   for (const file of files) {
     if (isCustomComponentPath(source, file)) continue;
@@ -743,9 +770,9 @@ var copyFiles = async (source, target) => {
   }
 };
 var clearCustomPages = async (target) => {
-  const customPagesDir = path5.join(target, "src", "custom-pages");
+  const customPagesDir = path6.join(target, "src", "custom-pages");
   if (import_fs.default.existsSync(customPagesDir)) import_fs.default.rmSync(customPagesDir, { recursive: true });
-  const staleCodeFiles = await (0, import_glob2.glob)(path5.join(target, "public", "generated", "pages", "**/*.{astro,ts,js,mjs}"), {
+  const staleCodeFiles = await (0, import_glob2.glob)(path6.join(target, "public", "generated", "pages", "**/*.{astro,ts,js,mjs}"), {
     nodir: true,
     windowsPathsNoEscape: import_node_os2.default.platform() == "win32"
   });
@@ -754,8 +781,8 @@ var clearCustomPages = async (target) => {
   }
 };
 var removeGeneratedLikeC4Sources = async (target) => {
-  const generatedDir = path5.join(target, "public", "generated");
-  const files = await (0, import_glob2.glob)(path5.join(generatedDir, "**/*.{c4,likec4}"), {
+  const generatedDir = path6.join(target, "public", "generated");
+  const files = await (0, import_glob2.glob)(path6.join(generatedDir, "**/*.{c4,likec4}"), {
     nodir: true,
     windowsPathsNoEscape: import_node_os2.default.platform() == "win32"
   });
@@ -764,12 +791,12 @@ var removeGeneratedLikeC4Sources = async (target) => {
   }
 };
 var catalogToAstro = async (source, astroDir) => {
-  const astroContentDir = path5.join(astroDir, "src/content/");
+  const astroContentDir = path6.join(astroDir, "src/content/");
   if (import_fs.default.existsSync(astroContentDir)) import_fs.default.rmSync(astroContentDir, { recursive: true });
   import_fs.default.mkdirSync(astroContentDir);
   await verifyRequiredFieldsAreInCatalogConfigFile(source);
-  if (!import_fs.default.existsSync(path5.join(source, "eventcatalog.styles.css"))) {
-    import_fs.default.writeFileSync(path5.join(source, "eventcatalog.styles.css"), "");
+  if (!import_fs.default.existsSync(path6.join(source, "eventcatalog.styles.css"))) {
+    import_fs.default.writeFileSync(path6.join(source, "eventcatalog.styles.css"), "");
   }
   await clearCustomPages(astroDir);
   await removeGeneratedLikeC4Sources(astroDir);
@@ -778,7 +805,7 @@ var catalogToAstro = async (source, astroDir) => {
 };
 
 // src/resolve-catalog-dependencies.js
-var import_node_path5 = __toESM(require("path"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
 var import_node_fs3 = __toESM(require("fs"), 1);
 var import_gray_matter2 = __toESM(require("gray-matter"), 1);
 var resolve_catalog_dependencies_default = async (catalogDir, core2) => {
@@ -787,7 +814,7 @@ var resolve_catalog_dependencies_default = async (catalogDir, core2) => {
   if (!dependencies) {
     return;
   }
-  const dependenciesDir = import_node_path5.default.join(catalogDir, "dependencies");
+  const dependenciesDir = import_node_path6.default.join(catalogDir, "dependencies");
   if (import_node_fs3.default.existsSync(dependenciesDir)) {
     import_node_fs3.default.rmSync(dependenciesDir, { recursive: true, force: true });
   }
@@ -811,8 +838,8 @@ var resolve_catalog_dependencies_default = async (catalogDir, core2) => {
         },
         frontmatter
       );
-      const resourceFile = import_node_path5.default.join(dependenciesDir, resourceType, dependency.id, `index.md`);
-      import_node_fs3.default.mkdirSync(import_node_path5.default.dirname(resourceFile), { recursive: true });
+      const resourceFile = import_node_path6.default.join(dependenciesDir, resourceType, dependency.id, `index.md`);
+      import_node_fs3.default.mkdirSync(import_node_path6.default.dirname(resourceFile), { recursive: true });
       import_node_fs3.default.writeFileSync(resourceFile, markdown);
     }
   }
@@ -823,7 +850,7 @@ var resolve_catalog_dependencies_default = async (catalogDir, core2) => {
 var import_boxen = __toESM(require("boxen"), 1);
 
 // src/features.ts
-var import_node_path6 = require("path");
+var import_node_path7 = require("path");
 var import_node_fs4 = __toESM(require("fs"), 1);
 var getProjectOutDir = async () => {
   const config = await getEventCatalogConfigFile(process.env.PROJECT_DIR || "");
@@ -839,7 +866,7 @@ var isIndexedSearchEnabled = async () => {
 };
 var isAuthEnabled = async () => {
   const directory = process.env.PROJECT_DIR || process.cwd();
-  const hasAuthConfig = import_node_fs4.default.existsSync((0, import_node_path6.join)(directory, "eventcatalog.auth.js"));
+  const hasAuthConfig = import_node_fs4.default.existsSync((0, import_node_path7.join)(directory, "eventcatalog.auth.js"));
   return hasAuthConfig;
 };
 
@@ -852,7 +879,7 @@ var import_node_fs5 = __toESM(require("fs"), 1);
 var import_glob3 = require("glob");
 var import_node_os3 = __toESM(require("os"), 1);
 var import_gray_matter3 = __toESM(require("gray-matter"), 1);
-var import_node_path7 = __toESM(require("path"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
 var DISABLE_CHANNEL_MIGRATION_ENV = "EVENTCATALOG_DISABLE_CHANNEL_MIGRATION";
 var isChannelMigrationDisabled = () => {
   return ["true", "1", "yes"].includes((process.env[DISABLE_CHANNEL_MIGRATION_ENV] ?? "").toLowerCase());
@@ -861,7 +888,7 @@ var message_channels_to_service_channels_default = async (dir2) => {
   if (isChannelMigrationDisabled()) {
     return { status: "skipped", message: `Channel migration disabled by ${DISABLE_CHANNEL_MIGRATION_ENV}` };
   }
-  const PROJECT_DIR = import_node_path7.default.join(dir2 || process.env.PROJECT_DIR);
+  const PROJECT_DIR = import_node_path8.default.join(dir2 || process.env.PROJECT_DIR);
   const messages = await (0, import_glob3.glob)(
     [
       "**/events/*/index.mdx",
@@ -968,7 +995,7 @@ var runMigrations = async (dir2) => {
 };
 
 // eventcatalog/src/enterprise/fields/field-indexer.ts
-var import_node_path8 = __toESM(require("path"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
 var import_node_fs7 = __toESM(require("fs"), 1);
 
 // eventcatalog/src/enterprise/fields/fields-db.ts
@@ -1334,22 +1361,22 @@ function getAvroTypeName(type) {
 function walkAvroRecord(schema, prefix, fields) {
   if (!schema.fields || !Array.isArray(schema.fields)) return;
   for (const field of schema.fields) {
-    const path18 = prefix ? `${prefix}.${field.name}` : field.name;
+    const path19 = prefix ? `${prefix}.${field.name}` : field.name;
     const isOptional = Array.isArray(field.type) && field.type.includes("null");
     const typeName = getAvroTypeName(field.type);
     fields.push({
-      path: path18,
+      path: path19,
       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, path18, fields);
+      walkAvroRecord(innerType, path19, 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, `${path18}[]`, fields);
+      walkAvroRecord(arrayType.items, `${path19}[]`, fields);
     }
   }
 }
@@ -1380,32 +1407,32 @@ function walkJsonSchema(node, prefix, requiredList, rootSchema, fields) {
   }
   if (!node.properties) return;
   for (const [name, prop] of Object.entries(node.properties)) {
-    const path18 = prefix ? `${prefix}.${name}` : name;
+    const path19 = 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: path18, type: type2, description: resolved.description || "", required: isRequired });
+        fields.push({ path: path19, type: type2, description: resolved.description || "", required: isRequired });
         if (resolved.properties) {
-          walkJsonSchema(resolved, path18, resolved.required || [], rootSchema, fields);
+          walkJsonSchema(resolved, path19, resolved.required || [], rootSchema, fields);
         }
       } else {
-        fields.push({ path: path18, type: "$ref", description: "", required: isRequired });
+        fields.push({ path: path19, 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: path18, type, description: prop.description || "", required: isRequired });
+    fields.push({ path: path19, type, description: prop.description || "", required: isRequired });
     if (typeList.includes("object") && prop.properties) {
-      walkJsonSchema(prop, path18, prop.required || [], rootSchema, fields);
+      walkJsonSchema(prop, path19, prop.required || [], rootSchema, fields);
     }
     if (typeList.includes("array") && prop.items) {
       if (prop.items.type === "object" && prop.items.properties) {
-        walkJsonSchema(prop.items, `${path18}[]`, prop.items.required || [], rootSchema, fields);
+        walkJsonSchema(prop.items, `${path19}[]`, prop.items.required || [], rootSchema, fields);
       }
     }
   }
@@ -1423,7 +1450,7 @@ function resolveLocalRef(ref, rootSchema) {
 
 // eventcatalog/src/enterprise/fields/field-indexer.ts
 function detectFormat(fileName) {
-  const ext = import_node_path8.default.extname(fileName).toLowerCase();
+  const ext = import_node_path9.default.extname(fileName).toLowerCase();
   if (ext === ".proto") return "proto";
   if (ext === ".avro" || ext === ".avsc") return "avro";
   return "json-schema";
@@ -1431,8 +1458,8 @@ function detectFormat(fileName) {
 async function buildFieldsIndex(catalogDir, outputDir) {
   const sdkModule = await import("@eventcatalog/sdk");
   const sdk = sdkModule.default(catalogDir);
-  const dbDir = import_node_path8.default.join(outputDir || catalogDir, ".eventcatalog");
-  const dbPath = import_node_path8.default.join(dbDir, "fields.db");
+  const dbDir = import_node_path9.default.join(outputDir || catalogDir, ".eventcatalog");
+  const dbPath = import_node_path9.default.join(dbDir, "fields.db");
   if (!import_node_fs7.default.existsSync(dbDir)) {
     import_node_fs7.default.mkdirSync(dbDir, { recursive: true });
   }
@@ -1517,8 +1544,8 @@ async function buildFieldsIndex(catalogDir, outputDir) {
 }
 
 // src/search-indexer.ts
-var import_promises3 = __toESM(require("fs/promises"), 1);
-var import_node_path9 = __toESM(require("path"), 1);
+var import_promises4 = __toESM(require("fs/promises"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
 var import_glob4 = require("glob");
 var import_gray_matter4 = __toESM(require("gray-matter"), 1);
 var RESOURCE_COLLECTIONS = {
@@ -1581,9 +1608,9 @@ var markdownToSearchText = (content) => {
 };
 var inferDocIdFromFile = (relativePath, frontmatterId) => {
   if (frontmatterId) return frontmatterId;
-  const fileName = import_node_path9.default.posix.basename(removeExtension(relativePath));
+  const fileName = import_node_path10.default.posix.basename(removeExtension(relativePath));
   if (fileName.toLowerCase() === "index") {
-    return import_node_path9.default.posix.basename(import_node_path9.default.posix.dirname(relativePath));
+    return import_node_path10.default.posix.basename(import_node_path10.default.posix.dirname(relativePath));
   }
   return stripNumericPrefix(fileName);
 };
@@ -1601,10 +1628,10 @@ var findResourceSegment = (segments) => {
   return match;
 };
 var readResourceFrontmatter = async (projectDir, resourcePath) => {
-  const candidates = [import_node_path9.default.join(projectDir, resourcePath, "index.mdx"), import_node_path9.default.join(projectDir, resourcePath, "index.md")];
+  const candidates = [import_node_path10.default.join(projectDir, resourcePath, "index.mdx"), import_node_path10.default.join(projectDir, resourcePath, "index.md")];
   for (const candidate of candidates) {
     try {
-      const file = await import_promises3.default.readFile(candidate, "utf8");
+      const file = await import_promises4.default.readFile(candidate, "utf8");
       return (0, import_gray_matter4.default)(file).data;
     } catch {
     }
@@ -1626,7 +1653,7 @@ var deriveRecordFromPath = async ({
   }
   if (segments[0] === "docs") {
     const customPath = normalizeUrlPath(removeExtension(segments.slice(1).join("/")));
-    const title = data.title || data.label || import_node_path9.default.posix.basename(customPath) || "Custom docs";
+    const title = data.title || data.label || import_node_path10.default.posix.basename(customPath) || "Custom docs";
     return {
       url: buildUrl(`/docs/custom/${customPath}`, config),
       title,
@@ -1742,9 +1769,9 @@ var collectSearchRecords = async ({
   });
   const records = await Promise.all(
     files.map(async (file) => {
-      const raw = await import_promises3.default.readFile(file, "utf8");
+      const raw = await import_promises4.default.readFile(file, "utf8");
       const parsed = (0, import_gray_matter4.default)(raw);
-      const relativePath = normalizePath(import_node_path9.default.relative(projectDir, file));
+      const relativePath = normalizePath(import_node_path10.default.relative(projectDir, file));
       const baseRecord = await deriveRecordFromPath({
         projectDir,
         relativePath,
@@ -1792,7 +1819,7 @@ var getSearchOutputPath = ({
   if (searchOutputPath) {
     return searchOutputPath;
   }
-  return import_node_path9.default.join(outDir, isServer ? "client" : "", "pagefind");
+  return import_node_path10.default.join(outDir, isServer ? "client" : "", "pagefind");
 };
 var buildSearchIndex = async ({ projectDir, outDir, config, isServer, searchOutputPath }) => {
   const records = await collectSearchRecords({ projectDir, config });
@@ -1828,7 +1855,7 @@ var buildSearchIndex = async ({ projectDir, outDir, config, isServer, searchOutp
     }
   }
   const outputPath = getSearchOutputPath({ outDir, isServer, searchOutputPath });
-  await import_promises3.default.rm(outputPath, { recursive: true, force: true });
+  await import_promises4.default.rm(outputPath, { recursive: true, force: true });
   const writeResult = await index.writeFiles({ outputPath });
   if (writeResult.errors?.length) {
     errors.push(...writeResult.errors.map((error) => error.message || String(error)));
@@ -1847,7 +1874,7 @@ ${errors.join("\n")}`);
 
 // src/core-node-modules.ts
 var import_fs2 = __toESM(require("fs"), 1);
-var import_node_path10 = __toESM(require("path"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
 var isDirectory = (directory) => {
   try {
     return import_fs2.default.statSync(directory).isDirectory();
@@ -1857,7 +1884,7 @@ var isDirectory = (directory) => {
 };
 var hasAstroDependency = (nodeModulesDirectory) => {
   const astroBin = process.platform === "win32" ? "astro.cmd" : "astro";
-  return import_fs2.default.existsSync(import_node_path10.default.join(nodeModulesDirectory, "astro", "package.json")) || import_fs2.default.existsSync(import_node_path10.default.join(nodeModulesDirectory, ".bin", astroBin));
+  return import_fs2.default.existsSync(import_node_path11.default.join(nodeModulesDirectory, "astro", "package.json")) || import_fs2.default.existsSync(import_node_path11.default.join(nodeModulesDirectory, ".bin", astroBin));
 };
 var isSymbolicLink = (targetPath) => {
   try {
@@ -1877,20 +1904,20 @@ var resolveInstalledCoreNodeModules = (currentDir2) => {
   const candidates = [];
   const seen = /* @__PURE__ */ new Set();
   const addCandidate = (candidate) => {
-    const resolvedCandidate = import_node_path10.default.resolve(candidate);
+    const resolvedCandidate = import_node_path11.default.resolve(candidate);
     if (!seen.has(resolvedCandidate)) {
       candidates.push(resolvedCandidate);
       seen.add(resolvedCandidate);
     }
   };
-  addCandidate(import_node_path10.default.resolve(currentDir2, "..", "node_modules"));
-  let directory = import_node_path10.default.resolve(currentDir2);
+  addCandidate(import_node_path11.default.resolve(currentDir2, "..", "node_modules"));
+  let directory = import_node_path11.default.resolve(currentDir2);
   while (true) {
-    if (import_node_path10.default.basename(directory) === "node_modules") {
+    if (import_node_path11.default.basename(directory) === "node_modules") {
       addCandidate(directory);
     }
-    addCandidate(import_node_path10.default.join(directory, "node_modules"));
-    const parentDirectory = import_node_path10.default.dirname(directory);
+    addCandidate(import_node_path11.default.join(directory, "node_modules"));
+    const parentDirectory = import_node_path11.default.dirname(directory);
     if (parentDirectory === directory) {
       break;
     }
@@ -1929,28 +1956,28 @@ var createAstroDevLineFilter = () => {
 };
 
 // src/federation/federate.ts
-var import_node_crypto4 = require("crypto");
-var import_promises9 = __toESM(require("fs/promises"), 1);
-var import_node_path16 = __toESM(require("path"), 1);
+var import_node_crypto5 = require("crypto");
+var import_promises10 = __toESM(require("fs/promises"), 1);
+var import_node_path17 = __toESM(require("path"), 1);
 var import_sdk3 = __toESM(require("@eventcatalog/sdk"), 1);
 
 // src/federation/content-cache.ts
-var import_node_crypto = require("crypto");
-var import_promises4 = __toESM(require("fs/promises"), 1);
-var import_node_path11 = __toESM(require("path"), 1);
-var getContentHash = (content) => `sha256:${(0, import_node_crypto.createHash)("sha256").update(content).digest("hex")}`;
+var import_node_crypto2 = require("crypto");
+var import_promises5 = __toESM(require("fs/promises"), 1);
+var import_node_path12 = __toESM(require("path"), 1);
+var getContentHash = (content) => `sha256:${(0, import_node_crypto2.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_path11.default.join(projectDirectory, ".eventcatalog-cache", "federation", "content");
-  const getCachePath = (key) => import_node_path11.default.join(cacheDirectory, encodeURIComponent(key));
+  const cacheDirectory = import_node_path12.default.join(projectDirectory, ".eventcatalog-cache", "federation", "content");
+  const getCachePath = (key) => import_node_path12.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_promises4.default.readFile(cachePath);
+        const content = await import_promises5.default.readFile(cachePath);
         if (getContentHash(content) !== key) {
-          await import_promises4.default.rm(cachePath, { force: true });
+          await import_promises5.default.rm(cachePath, { force: true });
           return void 0;
         }
         options.onHit?.(key);
@@ -1962,14 +1989,14 @@ var createFederationContentCache = (projectDirectory, options = {}) => {
     },
     async set(key, content) {
       if (!isContentHash(key) || getContentHash(content) !== key) return;
-      await import_promises4.default.mkdir(cacheDirectory, { recursive: true });
+      await import_promises5.default.mkdir(cacheDirectory, { recursive: true });
       const cachePath = getCachePath(key);
-      const temporaryPath = `${cachePath}.tmp-${process.pid}-${(0, import_node_crypto.randomUUID)()}`;
+      const temporaryPath = `${cachePath}.tmp-${process.pid}-${(0, import_node_crypto2.randomUUID)()}`;
       try {
-        await import_promises4.default.writeFile(temporaryPath, content);
-        await import_promises4.default.rename(temporaryPath, cachePath);
+        await import_promises5.default.writeFile(temporaryPath, content);
+        await import_promises5.default.rename(temporaryPath, cachePath);
       } finally {
-        await import_promises4.default.rm(temporaryPath, { force: true });
+        await import_promises5.default.rm(temporaryPath, { force: true });
       }
     }
   };
@@ -2132,21 +2159,21 @@ var import_license = require("@eventcatalog/license");
 var isFederationEnabled = () => (0, import_license.isEventCatalogEnterpriseEnabled)();
 
 // src/federation/output-transaction.ts
-var import_promises5 = __toESM(require("fs/promises"), 1);
-var import_node_path12 = __toESM(require("path"), 1);
+var import_promises6 = __toESM(require("fs/promises"), 1);
+var import_node_path13 = __toESM(require("path"), 1);
 var getSafePublicPath = (publicDirectory, 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("../");
+  const normalizedPath = import_node_path13.default.posix.normalize(relativePath);
+  const unsafe = relativePath.length === 0 || relativePath.includes("\0") || relativePath.includes("\\") || import_node_path13.default.posix.isAbsolute(relativePath) || /^[a-zA-Z]:\//.test(relativePath) || normalizedPath !== relativePath || normalizedPath === ".." || normalizedPath.startsWith("../");
   if (unsafe) return void 0;
-  const destinationPath = import_node_path12.default.resolve(publicDirectory, relativePath);
-  const relativeDestinationPath = import_node_path12.default.relative(publicDirectory, destinationPath);
-  return relativeDestinationPath !== "" && relativeDestinationPath !== ".." && !relativeDestinationPath.startsWith(`..${import_node_path12.default.sep}`) && !import_node_path12.default.isAbsolute(relativeDestinationPath) ? destinationPath : void 0;
+  const destinationPath = import_node_path13.default.resolve(publicDirectory, relativePath);
+  const relativeDestinationPath = import_node_path13.default.relative(publicDirectory, destinationPath);
+  return relativeDestinationPath !== "" && relativeDestinationPath !== ".." && !relativeDestinationPath.startsWith(`..${import_node_path13.default.sep}`) && !import_node_path13.default.isAbsolute(relativeDestinationPath) ? destinationPath : void 0;
 };
 var beginFederationOutputTransaction = async (projectDirectory, outDir, relativePublicPaths) => {
-  const transactionDirectory = await import_promises5.default.mkdtemp(import_node_path12.default.join(projectDirectory, ".eventcatalog-federation-transaction-"));
-  const previousOutDir = import_node_path12.default.join(transactionDirectory, "federated");
-  const publicBackupDirectory = import_node_path12.default.join(transactionDirectory, "public");
-  const publicDirectory = import_node_path12.default.resolve(projectDirectory, "public");
+  const transactionDirectory = await import_promises6.default.mkdtemp(import_node_path13.default.join(projectDirectory, ".eventcatalog-federation-transaction-"));
+  const previousOutDir = import_node_path13.default.join(transactionDirectory, "federated");
+  const publicBackupDirectory = import_node_path13.default.join(transactionDirectory, "public");
+  const publicDirectory = import_node_path13.default.resolve(projectDirectory, "public");
   const publicSnapshots = [];
   const missingPublicDirectories = /* @__PURE__ */ new Set();
   let hadPreviousOutDir = false;
@@ -2155,45 +2182,45 @@ var beginFederationOutputTransaction = async (projectDirectory, outDir, relative
       const destinationPath = getSafePublicPath(publicDirectory, relativePath);
       if (!destinationPath) continue;
       try {
-        const stat = await import_promises5.default.lstat(destinationPath);
+        const stat = await import_promises6.default.lstat(destinationPath);
         if (!stat.isFile()) continue;
-        const backupPath = import_node_path12.default.join(publicBackupDirectory, `${publicSnapshots.length}`);
-        await import_promises5.default.mkdir(import_node_path12.default.dirname(backupPath), { recursive: true });
-        await import_promises5.default.copyFile(destinationPath, backupPath);
+        const backupPath = import_node_path13.default.join(publicBackupDirectory, `${publicSnapshots.length}`);
+        await import_promises6.default.mkdir(import_node_path13.default.dirname(backupPath), { recursive: true });
+        await import_promises6.default.copyFile(destinationPath, backupPath);
         publicSnapshots.push({ backupPath, destinationPath, state: "file" });
       } catch (error) {
         const code = error.code;
         if (code === "ENOTDIR") continue;
         if (code !== "ENOENT") throw error;
         publicSnapshots.push({ destinationPath, state: "missing" });
-        let directory = import_node_path12.default.dirname(destinationPath);
+        let directory = import_node_path13.default.dirname(destinationPath);
         while (directory !== publicDirectory) {
           try {
-            await import_promises5.default.lstat(directory);
+            await import_promises6.default.lstat(directory);
             break;
           } catch (directoryError) {
             const directoryCode = directoryError.code;
             if (directoryCode === "ENOTDIR") break;
             if (directoryCode !== "ENOENT") throw directoryError;
             missingPublicDirectories.add(directory);
-            directory = import_node_path12.default.dirname(directory);
+            directory = import_node_path13.default.dirname(directory);
           }
         }
       }
     }
     try {
-      await import_promises5.default.rename(outDir, previousOutDir);
+      await import_promises6.default.rename(outDir, previousOutDir);
       hadPreviousOutDir = true;
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
     }
   } catch (error) {
-    await import_promises5.default.rm(transactionDirectory, { recursive: true, force: true });
+    await import_promises6.default.rm(transactionDirectory, { recursive: true, force: true });
     throw error;
   }
   return {
     commit: async () => {
-      await import_promises5.default.rm(transactionDirectory, { recursive: true, force: true }).catch(() => void 0);
+      await import_promises6.default.rm(transactionDirectory, { recursive: true, force: true }).catch(() => void 0);
     },
     rollback: async () => {
       const rollbackErrors = [];
@@ -2204,28 +2231,28 @@ var beginFederationOutputTransaction = async (projectDirectory, outDir, relative
           rollbackErrors.push(error);
         }
       };
-      await attempt(() => import_promises5.default.rm(outDir, { recursive: true, force: true }));
-      if (hadPreviousOutDir) await attempt(() => import_promises5.default.rename(previousOutDir, outDir));
+      await attempt(() => import_promises6.default.rm(outDir, { recursive: true, force: true }));
+      if (hadPreviousOutDir) await attempt(() => import_promises6.default.rename(previousOutDir, outDir));
       for (const snapshot of publicSnapshots) {
         if (snapshot.state === "missing") {
-          await attempt(() => import_promises5.default.rm(snapshot.destinationPath, { force: true }));
+          await attempt(() => import_promises6.default.rm(snapshot.destinationPath, { force: true }));
           continue;
         }
         await attempt(async () => {
-          await import_promises5.default.mkdir(import_node_path12.default.dirname(snapshot.destinationPath), { recursive: true });
-          await import_promises5.default.copyFile(snapshot.backupPath, snapshot.destinationPath);
+          await import_promises6.default.mkdir(import_node_path13.default.dirname(snapshot.destinationPath), { recursive: true });
+          await import_promises6.default.copyFile(snapshot.backupPath, snapshot.destinationPath);
         });
       }
       for (const directory of [...missingPublicDirectories].sort((left, right) => right.length - left.length)) {
         await attempt(async () => {
           try {
-            await import_promises5.default.rmdir(directory);
+            await import_promises6.default.rmdir(directory);
           } catch (error) {
             if (!["ENOENT", "ENOTEMPTY"].includes(error.code ?? "")) throw error;
           }
         });
       }
-      await attempt(() => import_promises5.default.rm(transactionDirectory, { recursive: true, force: true }));
+      await attempt(() => import_promises6.default.rm(transactionDirectory, { recursive: true, force: true }));
       if (rollbackErrors.length > 0) throw new AggregateError(rollbackErrors, "Failed to restore the previous federation output");
     }
   };
@@ -2247,27 +2274,27 @@ var withFederationOutputTransaction = async (projectDirectory, outDir, relativeP
 };
 
 // src/federation/public-assets.ts
-var import_node_crypto2 = require("crypto");
-var import_promises6 = __toESM(require("fs/promises"), 1);
-var import_node_path13 = __toESM(require("path"), 1);
-var getContentHash2 = (content) => `sha256:${(0, import_node_crypto2.createHash)("sha256").update(content).digest("hex")}`;
+var import_node_crypto3 = require("crypto");
+var import_promises7 = __toESM(require("fs/promises"), 1);
+var import_node_path14 = __toESM(require("path"), 1);
+var getContentHash2 = (content) => `sha256:${(0, import_node_crypto3.createHash)("sha256").update(content).digest("hex")}`;
 var getFileHash = async (filePath) => {
   try {
-    const stat = await import_promises6.default.lstat(filePath);
-    return stat.isFile() ? getContentHash2(await import_promises6.default.readFile(filePath)) : void 0;
+    const stat = await import_promises7.default.lstat(filePath);
+    return stat.isFile() ? getContentHash2(await import_promises7.default.readFile(filePath)) : void 0;
   } catch (error) {
     if (error.code === "ENOENT") return void 0;
     throw error;
   }
 };
 var getSafePath = (directory, relativePath) => {
-  const normalizedPath = import_node_path13.default.posix.normalize(relativePath);
-  const unsafe = relativePath.length === 0 || relativePath.includes("\0") || relativePath.includes("\\") || import_node_path13.default.posix.isAbsolute(relativePath) || /^[a-zA-Z]:\//.test(relativePath) || normalizedPath !== relativePath || normalizedPath === ".." || normalizedPath.startsWith("../");
+  const normalizedPath = import_node_path14.default.posix.normalize(relativePath);
+  const unsafe = relativePath.length === 0 || relativePath.includes("\0") || relativePath.includes("\\") || import_node_path14.default.posix.isAbsolute(relativePath) || /^[a-zA-Z]:\//.test(relativePath) || normalizedPath !== relativePath || normalizedPath === ".." || normalizedPath.startsWith("../");
   if (unsafe) return void 0;
-  const resolvedDirectory = import_node_path13.default.resolve(directory);
-  const resolvedPath = import_node_path13.default.resolve(resolvedDirectory, relativePath);
-  const relativeResolvedPath = import_node_path13.default.relative(resolvedDirectory, resolvedPath);
-  if (relativeResolvedPath === "" || relativeResolvedPath === ".." || relativeResolvedPath.startsWith(`..${import_node_path13.default.sep}`) || import_node_path13.default.isAbsolute(relativeResolvedPath)) {
+  const resolvedDirectory = import_node_path14.default.resolve(directory);
+  const resolvedPath = import_node_path14.default.resolve(resolvedDirectory, relativePath);
+  const relativeResolvedPath = import_node_path14.default.relative(resolvedDirectory, resolvedPath);
+  if (relativeResolvedPath === "" || relativeResolvedPath === ".." || relativeResolvedPath.startsWith(`..${import_node_path14.default.sep}`) || import_node_path14.default.isAbsolute(relativeResolvedPath)) {
     return void 0;
   }
   return resolvedPath;
@@ -2275,23 +2302,23 @@ var getSafePath = (directory, relativePath) => {
 var listFiles = async (directory, relativeDirectory = "") => {
   let entries;
   try {
-    entries = await import_promises6.default.readdir(import_node_path13.default.join(directory, relativeDirectory), { withFileTypes: true });
+    entries = await import_promises7.default.readdir(import_node_path14.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_path13.default.join(relativeDirectory, entry.name);
+      const relativePath = import_node_path14.default.join(relativeDirectory, entry.name);
       if (entry.isDirectory()) return listFiles(directory, relativePath);
-      return entry.isFile() ? [relativePath.split(import_node_path13.default.sep).join("/")] : [];
+      return entry.isFile() ? [relativePath.split(import_node_path14.default.sep).join("/")] : [];
     })
   );
   return files.flat().sort();
 };
 var pathExists = async (filePath) => {
   try {
-    await import_promises6.default.lstat(filePath);
+    await import_promises7.default.lstat(filePath);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") return false;
@@ -2299,27 +2326,27 @@ var pathExists = async (filePath) => {
   }
 };
 var hasBlockingParent = async (publicDirectory, destinationPath) => {
-  let currentPath = import_node_path13.default.dirname(destinationPath);
+  let currentPath = import_node_path14.default.dirname(destinationPath);
   while (currentPath !== publicDirectory) {
     try {
-      if (!(await import_promises6.default.lstat(currentPath)).isDirectory()) return true;
+      if (!(await import_promises7.default.lstat(currentPath)).isDirectory()) return true;
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
     }
-    currentPath = import_node_path13.default.dirname(currentPath);
+    currentPath = import_node_path14.default.dirname(currentPath);
   }
   return false;
 };
 var pruneEmptyDirectories = async (publicDirectory, filePath) => {
-  let currentPath = import_node_path13.default.dirname(filePath);
+  let currentPath = import_node_path14.default.dirname(filePath);
   while (currentPath !== publicDirectory) {
     try {
-      await import_promises6.default.rmdir(currentPath);
+      await import_promises7.default.rmdir(currentPath);
     } catch (error) {
       if (!["ENOENT", "ENOTEMPTY"].includes(error.code ?? "")) throw error;
       if (error.code === "ENOTEMPTY") return;
     }
-    currentPath = import_node_path13.default.dirname(currentPath);
+    currentPath = import_node_path14.default.dirname(currentPath);
   }
 };
 var composePublicAssets = async ({
@@ -2329,8 +2356,8 @@ var composePublicAssets = async ({
   previousFiles = {},
   collisionPaths = /* @__PURE__ */ new Set()
 }) => {
-  const publicDirectory = import_node_path13.default.resolve(projectDirectory, "public");
-  const federatedPublicDirectory = import_node_path13.default.resolve(federatedDirectory, "public");
+  const publicDirectory = import_node_path14.default.resolve(projectDirectory, "public");
+  const federatedPublicDirectory = import_node_path14.default.resolve(federatedDirectory, "public");
   const sourceFiles = await listFiles(federatedPublicDirectory);
   const sourceFileSet = new Set(sourceFiles);
   const managedFiles = /* @__PURE__ */ new Set();
@@ -2343,7 +2370,7 @@ var composePublicAssets = async ({
     if (sourceFileSet.has(relativePath)) continue;
     const destinationPath = getSafePath(publicDirectory, relativePath);
     if (!destinationPath) continue;
-    await import_promises6.default.rm(destinationPath, { force: true });
+    await import_promises7.default.rm(destinationPath, { force: true });
     await pruneEmptyDirectories(publicDirectory, destinationPath);
     removed += 1;
   }
@@ -2365,31 +2392,31 @@ var composePublicAssets = async ({
     }
     const asset = publicAssetsByPath.get(relativePath);
     if (!asset) throw new Error(`Cannot identify the source of federated public asset "${relativePath}"`);
-    const content = await import_promises6.default.readFile(sourcePath);
-    await import_promises6.default.mkdir(import_node_path13.default.dirname(destinationPath), { recursive: true });
-    await import_promises6.default.writeFile(destinationPath, content);
+    const content = await import_promises7.default.readFile(sourcePath);
+    await import_promises7.default.mkdir(import_node_path14.default.dirname(destinationPath), { recursive: true });
+    await import_promises7.default.writeFile(destinationPath, content);
     files[relativePath] = { source: asset.resolvedFrom.source, hash: getContentHash2(content) };
     copied += 1;
     if (collisionPaths.has(`public/${relativePath}`)) overwritten += 1;
   }
-  await import_promises6.default.rm(federatedPublicDirectory, { recursive: true, force: true });
+  await import_promises7.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_promises7 = __toESM(require("fs/promises"), 1);
-var import_node_path14 = __toESM(require("path"), 1);
+var import_node_crypto4 = require("crypto");
+var import_promises8 = __toESM(require("fs/promises"), 1);
+var import_node_path15 = __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_path14.default.relative(directory, target);
-  return relativePath === "" || !relativePath.startsWith(`..${import_node_path14.default.sep}`) && relativePath !== ".." && !import_node_path14.default.isAbsolute(relativePath);
+  const relativePath = import_node_path15.default.relative(directory, target);
+  return relativePath === "" || !relativePath.startsWith(`..${import_node_path15.default.sep}`) && relativePath !== ".." && !import_node_path15.default.isAbsolute(relativePath);
 };
 var assertPortableRelativePath = (filePath, label, allowRoot = true) => {
   const portablePath = filePath.replaceAll("\\", "/");
-  const normalizedPath = import_node_path14.default.posix.normalize(portablePath);
-  const isUnsafe = filePath.includes("\\") || filePath.includes("\0") || import_node_path14.default.posix.isAbsolute(normalizedPath) || /^[a-zA-Z]:\//.test(normalizedPath) || normalizedPath === ".." || normalizedPath.startsWith("../") || !allowRoot && (normalizedPath === "." || normalizedPath === "");
+  const normalizedPath = import_node_path15.default.posix.normalize(portablePath);
+  const isUnsafe = filePath.includes("\\") || filePath.includes("\0") || import_node_path15.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;
 };
@@ -2399,22 +2426,22 @@ var getSourceRoot = (projectDirectory, source) => {
   }
   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_path14.default.resolve(projectDirectory, locator);
+  return import_node_path15.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_path14.default.resolve(sourceRoot, ...catalogPath.split("/"));
+  const catalogDirectory = import_node_path15.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_promises7.default.realpath(sourceRoot), import_promises7.default.realpath(catalogDirectory)]);
+    const [realSourceRoot, realCatalogDirectory] = await Promise.all([import_promises8.default.realpath(sourceRoot), import_promises8.default.realpath(catalogDirectory)]);
     if (!isWithinDirectory(realSourceRoot, realCatalogDirectory)) {
       throw new Error(`Catalog path "${source.path}" escapes source "${source.id}"`);
     }
-    if (!(await import_promises7.default.stat(realCatalogDirectory)).isDirectory()) {
+    if (!(await import_promises8.default.stat(realCatalogDirectory)).isDirectory()) {
       throw new Error(`Filesystem federation source "${source.id}" is not a directory: ${catalogDirectory}`);
     }
     return realCatalogDirectory;
@@ -2427,12 +2454,12 @@ var getCatalogDirectory = async (projectDirectory, source) => {
 };
 var getArtifactPath = async (catalogDirectory, source, artifactPath) => {
   const normalizedPath = assertPortableRelativePath(artifactPath, "Federated artifact path", false);
-  const filePath = import_node_path14.default.resolve(catalogDirectory, ...normalizedPath.split("/"));
+  const filePath = import_node_path15.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_promises7.default.realpath(filePath);
+    const realFilePath = await import_promises8.default.realpath(filePath);
     if (!isWithinDirectory(catalogDirectory, realFilePath)) {
       throw new Error(`Federated artifact path "${artifactPath}" escapes source "${source.id}"`);
     }
@@ -2452,22 +2479,22 @@ var createFileSystemSourceProvider = (projectDirectory) => ({
       commit: "local",
       includeFederated: false
     });
-    const snapshot = (0, import_node_crypto3.createHash)("sha256").update(JSON.stringify(localIndex)).digest("hex").slice(0, 12);
+    const snapshot = (0, import_node_crypto4.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_promises7.default.readFile(await getArtifactPath(catalogDirectory, source, artifactPath));
+    return import_promises8.default.readFile(await getArtifactPath(catalogDirectory, source, artifactPath));
   }
 });
 
 // src/federation/github-source-provider.ts
 var import_node_child_process = require("child_process");
-var import_promises8 = __toESM(require("fs/promises"), 1);
+var import_promises9 = __toESM(require("fs/promises"), 1);
 var import_node_os4 = __toESM(require("os"), 1);
-var import_node_path15 = __toESM(require("path"), 1);
+var import_node_path16 = __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);
@@ -2478,8 +2505,8 @@ var parseGitHubSource = (source) => {
 };
 var assertSafeCatalogPath = (source) => {
   const catalogPath = source.path ?? ".";
-  const normalized = import_node_path15.default.posix.normalize(catalogPath.replaceAll("\\", "/"));
-  if (catalogPath.includes("\\") || import_node_path15.default.posix.isAbsolute(normalized) || normalized === ".." || normalized.startsWith("../")) {
+  const normalized = import_node_path16.default.posix.normalize(catalogPath.replaceAll("\\", "/"));
+  if (catalogPath.includes("\\") || import_node_path16.default.posix.isAbsolute(normalized) || normalized === ".." || normalized.startsWith("../")) {
     throw new Error(`Catalog path "${catalogPath}" escapes source "${source.id}"`);
   }
 };
@@ -2522,8 +2549,8 @@ var getGitEnvironment = (token) => {
 };
 var createCheckout = (executeFile, token) => async (source, ref, callback) => {
   const { owner, repository } = parseGitHubSource(source);
-  const catalogPath = import_node_path15.default.posix.normalize(source.path ?? ".");
-  const directory = await import_promises8.default.mkdtemp(import_node_path15.default.join(import_node_os4.default.tmpdir(), "eventcatalog-federation-"));
+  const catalogPath = import_node_path16.default.posix.normalize(source.path ?? ".");
+  const directory = await import_promises9.default.mkdtemp(import_node_path16.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" });
@@ -2537,22 +2564,22 @@ var createCheckout = (executeFile, token) => async (source, ref, callback) => {
     await git(["checkout", "--quiet", "--detach", "FETCH_HEAD"]);
     return await callback(directory);
   } finally {
-    await import_promises8.default.rm(directory, { recursive: true, force: true });
+    await import_promises9.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_path15.default.resolve(directory, source.path ?? ".");
-  const relativeCatalogDirectory = import_node_path15.default.relative(directory, catalogDirectory);
-  if (relativeCatalogDirectory.startsWith("..") || import_node_path15.default.isAbsolute(relativeCatalogDirectory)) {
+  const catalogDirectory = import_node_path16.default.resolve(directory, source.path ?? ".");
+  const relativeCatalogDirectory = import_node_path16.default.relative(directory, catalogDirectory);
+  if (relativeCatalogDirectory.startsWith("..") || import_node_path16.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_path15.default.posix.join(source.path ?? ".", "catalog.index.json");
+  const indexPath = import_node_path16.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")));
@@ -2575,7 +2602,7 @@ var createGitHubSourceProvider = (options = {}) => {
     },
     async fetchContent({ source, commit, path: artifactPath }) {
       assertSafeCatalogPath(source);
-      const catalogPath = import_node_path15.default.posix.join(source.path ?? ".", artifactPath);
+      const catalogPath = import_node_path16.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;
@@ -2661,16 +2688,16 @@ var createDiagnosticGraph = (graph, ownershipGraph, remoteSourceIds, localSource
 var writeLock = async (lockPath, lock) => {
   const temporaryPath = `${lockPath}.tmp-${process.pid}`;
   try {
-    await import_promises9.default.writeFile(temporaryPath, `${JSON.stringify(lock, null, 2)}
+    await import_promises10.default.writeFile(temporaryPath, `${JSON.stringify(lock, null, 2)}
 `, "utf8");
-    await import_promises9.default.rename(temporaryPath, lockPath);
+    await import_promises10.default.rename(temporaryPath, lockPath);
   } finally {
-    await import_promises9.default.rm(temporaryPath, { force: true });
+    await import_promises10.default.rm(temporaryPath, { force: true });
   }
 };
 var readLock = async (lockPath) => {
   try {
-    return JSON.parse(await import_promises9.default.readFile(lockPath, "utf8"));
+    return JSON.parse(await import_promises10.default.readFile(lockPath, "utf8"));
   } catch (error) {
     if (error.code === "ENOENT") return void 0;
     throw new Error(`Cannot read federation lock at "${lockPath}"`, { cause: error });
@@ -2678,7 +2705,7 @@ var readLock = async (lockPath) => {
 };
 var pathExists2 = async (filePath) => {
   try {
-    await import_promises9.default.access(filePath);
+    await import_promises10.default.access(filePath);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") return false;
@@ -2686,8 +2713,8 @@ var pathExists2 = async (filePath) => {
   }
 };
 var cleanupPreviousFederation = async (projectDirectory, onProgress) => {
-  const outDir = import_node_path16.default.join(projectDirectory, "federated");
-  const lockPath = import_node_path16.default.join(projectDirectory, "eventcatalog.lock");
+  const outDir = import_node_path17.default.join(projectDirectory, "federated");
+  const lockPath = import_node_path17.default.join(projectDirectory, "eventcatalog.lock");
   const previousLock = await readLock(lockPath);
   const hadFederatedOutput = await pathExists2(outDir);
   const hadLock = previousLock !== void 0;
@@ -2703,7 +2730,7 @@ var cleanupPreviousFederation = async (projectDirectory, onProgress) => {
         assets: [],
         previousFiles: previousLock?.publicFiles
       });
-      await import_promises9.default.rm(lockPath, { force: true });
+      await import_promises10.default.rm(lockPath, { force: true });
       return result;
     }
   );
@@ -2752,8 +2779,8 @@ var federateCatalog = async (projectDirectory, options = {}) => {
       throw new Error(`Failed to federate source "${source.id}": ${message}`, { cause: error });
     }
   }
-  const outDir = import_node_path16.default.join(projectDirectory, "federated");
-  const lockPath = import_node_path16.default.join(projectDirectory, "eventcatalog.lock");
+  const outDir = import_node_path17.default.join(projectDirectory, "federated");
+  const lockPath = import_node_path17.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);
@@ -2826,7 +2853,7 @@ var federateCatalog = async (projectDirectory, options = {}) => {
         lockVersion: 1,
         sources: resolvedSources.map(({ config: source, resolved }) => ({
           id: source.id,
-          digest: `sha256:${(0, import_node_crypto4.createHash)("sha256").update(resolved.bytes).digest("hex")}`,
+          digest: `sha256:${(0, import_node_crypto5.createHash)("sha256").update(resolved.bytes).digest("hex")}`,
           commit: resolved.commit,
           resolvedAt
         })).sort((left, right) => left.id.localeCompare(right.id)),
@@ -2851,14 +2878,14 @@ var federateCatalog = async (projectDirectory, options = {}) => {
 
 // src/eventcatalog.ts
 var import_license2 = require("@eventcatalog/license");
-var currentDir = import_node_path18.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
+var currentDir = import_node_path19.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
 var program = new import_commander.Command().version(VERSION);
-var dir = import_node_path18.default.resolve(process.env.PROJECT_DIR || process.cwd());
-var core = import_node_path18.default.resolve(process.env.CATALOG_DIR || (0, import_node_path17.join)(dir, ".eventcatalog-core"));
-var eventCatalogDir = import_node_path18.default.resolve((0, import_node_path17.join)(currentDir, "../eventcatalog/"));
+var dir = import_node_path19.default.resolve(process.env.PROJECT_DIR || process.cwd());
+var core = import_node_path19.default.resolve(process.env.CATALOG_DIR || (0, import_node_path18.join)(dir, ".eventcatalog-core"));
+var eventCatalogDir = import_node_path19.default.resolve((0, import_node_path18.join)(currentDir, "../eventcatalog/"));
 var getInstalledEventCatalogVersion = () => {
   try {
-    const pkg = import_fs3.default.readFileSync((0, import_node_path17.join)(dir, "package.json"), "utf8");
+    const pkg = import_fs3.default.readFileSync((0, import_node_path18.join)(dir, "package.json"), "utf8");
     const json = JSON.parse(pkg);
     return json.dependencies["@eventcatalog/core"];
   } catch (error) {
@@ -2924,12 +2951,12 @@ var startDevPrewarm = ({
 var buildDevSearchIndex = async ({ config }) => {
   const result = await buildSearchIndex({
     projectDir: dir,
-    outDir: import_node_path18.default.join(core, "public"),
-    searchOutputPath: import_node_path18.default.join(core, "public", "pagefind"),
+    outDir: import_node_path19.default.join(core, "public"),
+    searchOutputPath: import_node_path19.default.join(core, "public", "pagefind"),
     config,
     isServer: false
   });
-  logger.info(`Indexed ${result.records} page(s) into ${import_node_path18.default.relative(core, result.outputPath)}`, "search");
+  logger.info(`Indexed ${result.records} page(s) into ${import_node_path19.default.relative(core, result.outputPath)}`, "search");
 };
 var warnIfIndexedSearchUsesAuth = async () => {
   if (!await isAuthEnabled()) {
@@ -3044,12 +3071,12 @@ var copyCore = () => {
   import_fs3.default.cpSync(eventCatalogDir, core, {
     recursive: true,
     filter: (src) => {
-      const relativePath = import_node_path18.default.relative(eventCatalogDir, src);
-      const pathParts = relativePath.split(import_node_path18.default.sep);
+      const relativePath = import_node_path19.default.relative(eventCatalogDir, src);
+      const pathParts = relativePath.split(import_node_path19.default.sep);
       return !pathParts.some((part) => [".astro", "dist", "node_modules"].includes(part));
     }
   });
-  const coreNodeModules = import_node_path18.default.join(core, "node_modules");
+  const coreNodeModules = import_node_path19.default.join(core, "node_modules");
   const installedCoreNodeModules = resolveInstalledCoreNodeModules(currentDir);
   linkCoreNodeModules({ coreNodeModules, installedCoreNodeModules });
 };
@@ -3108,8 +3135,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_path18.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path18.default.join(dir, ".env") });
+  if (import_fs3.default.existsSync(import_node_path19.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path19.default.join(dir, ".env") });
   }
   if (options.debug) {
     logger.info("Debug mode enabled", "debug");
@@ -3129,6 +3156,12 @@ program.command("dev").description("Run development server of EventCatalog").opt
   );
   const isEventCatalogStarter = await (0, import_license2.isEventCatalogStarterEnabled)();
   const isEventCatalogScale = await (0, import_license2.isEventCatalogScaleEnabled)();
+  void log_build_default(dir, {
+    isEventCatalogStarterEnabled: isEventCatalogStarter,
+    isEventCatalogScaleEnabled: isEventCatalogScale,
+    isBackstagePluginEnabled: canEmbedPages || isEventCatalogScale,
+    command: "dev"
+  });
   if (isServer) {
     try {
       logger.info("Building fields index...", "fields");
@@ -3189,8 +3222,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_path18.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path18.default.join(dir, ".env") });
+  if (import_fs3.default.existsSync(import_node_path19.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path19.default.join(dir, ".env") });
   }
   await verifyRequiredFieldsAreInCatalogConfigFile(dir);
   copyCore();
@@ -3204,7 +3237,8 @@ program.command("build").description("Run build of EventCatalog").action(async (
   await log_build_default(dir, {
     isEventCatalogStarterEnabled: isEventCatalogStarter,
     isEventCatalogScaleEnabled: isEventCatalogScale,
-    isBackstagePluginEnabled: canEmbedPages || isEventCatalogScale
+    isBackstagePluginEnabled: canEmbedPages || isEventCatalogScale,
+    command: "build"
   });
   await resolve_catalog_dependencies_default(dir, core);
   await runMigrations(dir);
@@ -3240,7 +3274,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_path18.default.resolve(dir, await getProjectOutDir());
+    const outDir = import_node_path19.default.resolve(dir, await getProjectOutDir());
     logger.info("Building indexed search...", "search");
     const result = await buildSearchIndex({
       projectDir: dir,
@@ -3248,7 +3282,7 @@ program.command("build").description("Run build of EventCatalog").action(async (
       config,
       isServer
     });
-    logger.info(`Indexed ${result.records} page(s) into ${import_node_path18.default.relative(dir, result.outputPath)}`, "search");
+    logger.info(`Indexed ${result.records} page(s) into ${import_node_path19.default.relative(dir, result.outputPath)}`, "search");
   }
 });
 var previewCatalog = async ({
@@ -3275,7 +3309,7 @@ var startServerCatalog = async ({
   isEventCatalogStarter = false,
   isEventCatalogScale = false
 }) => {
-  const serverEntryPath = import_node_path18.default.join(dir, "dist", "server", "entry.mjs");
+  const serverEntryPath = import_node_path19.default.join(dir, "dist", "server", "entry.mjs");
   await runCommandWithFilteredOutput({
     command: `node "${serverEntryPath}"`,
     cwd: core,
@@ -3292,8 +3326,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_path18.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path18.default.join(dir, ".env") });
+  if (import_fs3.default.existsSync(import_node_path19.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path19.default.join(dir, ".env") });
   }
   const canEmbedPages = await (0, import_license2.isFeatureEnabled)(
     "@eventcatalog/backstage-plugin-eventcatalog",
@@ -3311,8 +3345,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_path18.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path18.default.join(dir, ".env") });
+  if (import_fs3.default.existsSync(import_node_path19.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path19.default.join(dir, ".env") });
   }
   const canEmbedPages = await (0, import_license2.isFeatureEnabled)(
     "@eventcatalog/backstage-plugin-eventcatalog",
@@ -3339,22 +3373,22 @@ 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_path18.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path18.default.join(dir, ".env") });
+  if (import_fs3.default.existsSync(import_node_path19.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path19.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_path18.default.join(dir, "exports");
+  const exportsDir = import_node_path19.default.join(dir, "exports");
   ensureDir(exportsDir);
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  const exportFile = import_node_path18.default.join(exportsDir, `catalog-${date}.json`);
+  const exportFile = import_node_path19.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_path18.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path18.default.join(dir, ".env") });
+  if (import_fs3.default.existsSync(import_node_path19.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path19.default.join(dir, ".env") });
   }
   await generate(dir);
 });
@@ -3427,7 +3461,7 @@ var reportFederationProgress = (event, verbose = false) => {
       }
       return;
     case "hydrating":
-      logger.info(`Hydrating federated content into ${import_node_path18.default.relative(dir, event.outDir)}/...`, "federation");
+      logger.info(`Hydrating federated content into ${import_node_path19.default.relative(dir, event.outDir)}/...`, "federation");
       return;
     case "hydrate:cache":
       if (event.files === 1 || event.files % 25 === 0) {
@@ -3450,13 +3484,13 @@ var reportFederationProgress = (event, verbose = false) => {
         `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(`Recorded resolved source state in ${import_node_path18.default.relative(dir, event.result.lockPath)}`, "federation");
+      logger.info(`Recorded resolved source state in ${import_node_path19.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.").option("-v, --verbose", "Show detailed federation diagnostics.").action(async (commandOptions) => {
   logger.welcome();
-  if (import_fs3.default.existsSync(import_node_path18.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path18.default.join(dir, ".env") });
+  if (import_fs3.default.existsSync(import_node_path19.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path19.default.join(dir, ".env") });
   }
   logger.info("Starting federation...", "federation");
   let cleanedPreviousOutput = false;