@eventcatalog/core 5.0.1 → 5.1.0

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_path21 = require("path");
+var import_node_path22 = require("path");
 var import_node_http = __toESM(require("http"), 1);
 var import_fs = __toESM(require("fs"), 1);
-var import_node_path22 = __toESM(require("path"), 1);
+var import_node_path23 = __toESM(require("path"), 1);
 var import_node_url2 = require("url");
 var import_node_module3 = require("module");
 
@@ -174,7 +174,7 @@ var verifyRequiredFieldsAreInCatalogConfigFile = async (projectDirectory) => {
 var import_picocolors = __toESM(require("picocolors"), 1);
 
 // package.json
-var version = "5.0.1";
+var version = "5.1.0";
 
 // src/constants.ts
 var VERSION = version;
@@ -1412,22 +1412,22 @@ function getAvroTypeName(type) {
 function walkAvroRecord(schema, prefix, fields) {
   if (!schema.fields || !Array.isArray(schema.fields)) return;
   for (const field of schema.fields) {
-    const path21 = prefix ? `${prefix}.${field.name}` : field.name;
+    const path22 = prefix ? `${prefix}.${field.name}` : field.name;
     const isOptional = Array.isArray(field.type) && field.type.includes("null");
     const typeName = getAvroTypeName(field.type);
     fields.push({
-      path: path21,
+      path: path22,
       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, path21, fields);
+      walkAvroRecord(innerType, path22, 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, `${path21}[]`, fields);
+      walkAvroRecord(arrayType.items, `${path22}[]`, fields);
     }
   }
 }
@@ -1458,32 +1458,32 @@ function walkJsonSchema(node, prefix, requiredList, rootSchema, fields) {
   }
   if (!node.properties) return;
   for (const [name, prop] of Object.entries(node.properties)) {
-    const path21 = prefix ? `${prefix}.${name}` : name;
+    const path22 = 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: path21, type: type2, description: resolved.description || "", required: isRequired });
+        fields.push({ path: path22, type: type2, description: resolved.description || "", required: isRequired });
         if (resolved.properties) {
-          walkJsonSchema(resolved, path21, resolved.required || [], rootSchema, fields);
+          walkJsonSchema(resolved, path22, resolved.required || [], rootSchema, fields);
         }
       } else {
-        fields.push({ path: path21, type: "$ref", description: "", required: isRequired });
+        fields.push({ path: path22, 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: path21, type, description: prop.description || "", required: isRequired });
+    fields.push({ path: path22, type, description: prop.description || "", required: isRequired });
     if (typeList.includes("object") && prop.properties) {
-      walkJsonSchema(prop, path21, prop.required || [], rootSchema, fields);
+      walkJsonSchema(prop, path22, prop.required || [], rootSchema, fields);
     }
     if (typeList.includes("array") && prop.items) {
       if (prop.items.type === "object" && prop.items.properties) {
-        walkJsonSchema(prop.items, `${path21}[]`, prop.items.required || [], rootSchema, fields);
+        walkJsonSchema(prop.items, `${path22}[]`, prop.items.required || [], rootSchema, fields);
       }
     }
   }
@@ -1938,75 +1938,101 @@ ${errors.join("\n")}`);
   };
 };
 
-// src/catalog-runtime.ts
+// src/architecture-export.ts
 var import_node_fs9 = __toESM(require("fs"), 1);
 var import_node_path13 = __toESM(require("path"), 1);
+var import_exporters = require("@eventcatalog/exporters");
+var isCatalogAuthEnabled = ({
+  config,
+  projectDir,
+  isServer
+}) => Boolean(config?.auth?.enabled) && isServer && import_node_fs9.default.existsSync(import_node_path13.default.join(projectDir, "eventcatalog.auth.js"));
+var resolveArchitectureExport = (config, { authEnabled }) => {
+  const enabled = config?.exports?.html?.enabled;
+  if (enabled === false) return { enabled: false, reason: "disabled" };
+  if (authEnabled && enabled !== true) return { enabled: false, reason: "auth" };
+  return { enabled: true };
+};
+var getArchitectureExportPath = ({ outDir, isServer }) => import_node_path13.default.join(outDir, isServer ? "client" : "", "architecture.html");
+var writeArchitectureExport = ({
+  projectDir,
+  outDir,
+  isServer
+}) => (0, import_exporters.writeHtml)({
+  dir: projectDir,
+  outputPath: getArchitectureExportPath({ outDir, isServer }),
+  regenerateCommand: "npx eventcatalog build"
+});
+
+// src/catalog-runtime.ts
+var import_node_fs10 = __toESM(require("fs"), 1);
+var import_node_path14 = __toESM(require("path"), 1);
 var import_node_module2 = require("module");
 var require2 = (0, import_node_module2.createRequire)(importMetaUrl);
 var writeIfChanged = (file, content) => {
-  if (import_node_fs9.default.existsSync(file) && import_node_fs9.default.readFileSync(file, "utf8") === content) return;
-  import_node_fs9.default.mkdirSync(import_node_path13.default.dirname(file), { recursive: true });
-  import_node_fs9.default.writeFileSync(file, content);
+  if (import_node_fs10.default.existsSync(file) && import_node_fs10.default.readFileSync(file, "utf8") === content) return;
+  import_node_fs10.default.mkdirSync(import_node_path14.default.dirname(file), { recursive: true });
+  import_node_fs10.default.writeFileSync(file, content);
 };
 var importPath = (file) => file.replace(/\\/g, "/");
-var hasLegacyCatalogRuntime = (projectDirectory) => import_node_fs9.default.existsSync(import_node_path13.default.join(projectDirectory, ".eventcatalog-core"));
+var hasLegacyCatalogRuntime = (projectDirectory) => import_node_fs10.default.existsSync(import_node_path14.default.join(projectDirectory, ".eventcatalog-core"));
 var clearCatalogCache = (projectDirectory) => {
   const { cacheDirectory } = getRuntimePaths(projectDirectory);
-  import_node_fs9.default.rmSync(cacheDirectory, { recursive: true, force: true });
+  import_node_fs10.default.rmSync(cacheDirectory, { recursive: true, force: true });
 };
 var prepareCatalogRuntime = ({ projectDirectory, catalogDirectory, packageDirectory }) => {
-  const runtime = import_node_path13.default.resolve(catalogDirectory);
-  const source = import_node_path13.default.resolve(packageDirectory);
-  const project = import_node_path13.default.resolve(projectDirectory);
+  const runtime = import_node_path14.default.resolve(catalogDirectory);
+  const source = import_node_path14.default.resolve(packageDirectory);
+  const project = import_node_path14.default.resolve(projectDirectory);
   if (runtime === source || runtime === project) {
     throw new Error("The catalog runtime must be separate from the project and installed application directories.");
   }
-  import_node_fs9.default.mkdirSync(runtime, { recursive: true });
+  import_node_fs10.default.mkdirSync(runtime, { recursive: true });
   writeIfChanged(
-    import_node_path13.default.join(runtime, "content.config.ts"),
-    `export { collections } from ${JSON.stringify(importPath(import_node_path13.default.join(source, "src/content.config.ts")))};
+    import_node_path14.default.join(runtime, "content.config.ts"),
+    `export { collections } from ${JSON.stringify(importPath(import_node_path14.default.join(source, "src/content.config.ts")))};
 `
   );
-  const packageTsconfig = JSON.parse(import_node_fs9.default.readFileSync(import_node_path13.default.join(source, "tsconfig.json"), "utf8"));
+  const packageTsconfig = JSON.parse(import_node_fs10.default.readFileSync(import_node_path14.default.join(source, "tsconfig.json"), "utf8"));
   const paths = Object.fromEntries(
     Object.entries(packageTsconfig.compilerOptions.paths).map(([alias, targets]) => [
       alias,
-      targets.map((target) => importPath(import_node_path13.default.resolve(source, target)))
+      targets.map((target) => importPath(import_node_path14.default.resolve(source, target)))
     ])
   );
-  paths["@config"] = [importPath(import_node_path13.default.join(project, "eventcatalog.config.js"))];
-  paths["@catalog/styles"] = [importPath(import_node_path13.default.join(project, "eventcatalog.styles.css"))];
+  paths["@config"] = [importPath(import_node_path14.default.join(project, "eventcatalog.config.js"))];
+  paths["@catalog/styles"] = [importPath(import_node_path14.default.join(project, "eventcatalog.styles.css"))];
   paths["@catalog/components/*"] = [
-    importPath(import_node_path13.default.join(project, "components/*")),
-    importPath(import_node_path13.default.join(project, "federated/components/*"))
+    importPath(import_node_path14.default.join(project, "components/*")),
+    importPath(import_node_path14.default.join(project, "federated/components/*"))
   ];
-  paths["@catalog/snippets/*"] = [importPath(import_node_path13.default.join(project, "snippets/*"))];
+  paths["@catalog/snippets/*"] = [importPath(import_node_path14.default.join(project, "snippets/*"))];
   for (const specifier of ["astro", "astro/zod", "astro/loaders", "astro/runtime/server/index.js"]) {
     paths[specifier] = [importPath(require2.resolve(specifier).replace(/\.js$/, ".d.ts"))];
   }
   writeIfChanged(
-    import_node_path13.default.join(runtime, "tsconfig.json"),
+    import_node_path14.default.join(runtime, "tsconfig.json"),
     JSON.stringify(
       {
-        extends: importPath(import_node_path13.default.join(source, "tsconfig.json")),
+        extends: importPath(import_node_path14.default.join(source, "tsconfig.json")),
         compilerOptions: {
           baseUrl: ".",
           paths,
           typeRoots: [
-            importPath(import_node_path13.default.join(project, "node_modules/@types")),
-            importPath(import_node_path13.default.join(source, "../node_modules/@types")),
-            importPath(import_node_path13.default.join(source, "../node_modules")),
-            importPath(import_node_path13.default.join(project, "node_modules"))
+            importPath(import_node_path14.default.join(project, "node_modules/@types")),
+            importPath(import_node_path14.default.join(source, "../node_modules/@types")),
+            importPath(import_node_path14.default.join(source, "../node_modules")),
+            importPath(import_node_path14.default.join(project, "node_modules"))
           ]
         },
         include: [
-          importPath(import_node_path13.default.join(project, ".astro/types.d.ts")),
+          importPath(import_node_path14.default.join(project, ".astro/types.d.ts")),
           "content.config.ts",
-          importPath(import_node_path13.default.join(project, "components/**/*")),
-          importPath(import_node_path13.default.join(source, "src/**/*"))
+          importPath(import_node_path14.default.join(project, "components/**/*")),
+          importPath(import_node_path14.default.join(source, "src/**/*"))
         ],
         // Keep legacy generated files out of checks on an existing checkout.
-        exclude: (packageTsconfig.exclude ?? []).map((entry) => importPath(import_node_path13.default.resolve(source, entry)))
+        exclude: (packageTsconfig.exclude ?? []).map((entry) => importPath(import_node_path14.default.resolve(source, entry)))
       },
       null,
       2
@@ -2086,8 +2112,8 @@ var createAstroDevLineFilter = () => {
 };
 
 // src/astro-config-path.ts
-var import_node_path14 = __toESM(require("path"), 1);
-var getAstroConfigPath = (projectDirectory, configFile, paths = import_node_path14.default) => {
+var import_node_path15 = __toESM(require("path"), 1);
+var getAstroConfigPath = (projectDirectory, configFile, paths = import_node_path15.default) => {
   const relative = paths.relative(projectDirectory, configFile);
   const projectRoot = paths.parse(paths.resolve(projectDirectory)).root.toLowerCase();
   const configRoot = paths.parse(paths.resolve(configFile)).root.toLowerCase();
@@ -2102,18 +2128,18 @@ var getAstroConfigPath = (projectDirectory, configFile, paths = import_node_path
 // src/federation/federate.ts
 var import_node_crypto5 = require("crypto");
 var import_promises10 = __toESM(require("fs/promises"), 1);
-var import_node_path20 = __toESM(require("path"), 1);
+var import_node_path21 = __toESM(require("path"), 1);
 var import_sdk3 = __toESM(require("@eventcatalog/sdk"), 1);
 
 // src/federation/content-cache.ts
 var import_node_crypto2 = require("crypto");
 var import_promises5 = __toESM(require("fs/promises"), 1);
-var import_node_path15 = __toESM(require("path"), 1);
+var import_node_path16 = __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_path15.default.join(projectDirectory, ".eventcatalog-cache", "federation", "content");
-  const getCachePath = (key) => import_node_path15.default.join(cacheDirectory, encodeURIComponent(key));
+  const cacheDirectory = import_node_path16.default.join(projectDirectory, ".eventcatalog-cache", "federation", "content");
+  const getCachePath = (key) => import_node_path16.default.join(cacheDirectory, encodeURIComponent(key));
   return {
     async get(key) {
       if (options.read === false || !isContentHash(key)) return void 0;
@@ -2300,20 +2326,20 @@ var getVisibleFederationDiagnostics = (diagnostics, verbose) => diagnostics.filt
 
 // src/federation/output-transaction.ts
 var import_promises6 = __toESM(require("fs/promises"), 1);
-var import_node_path16 = __toESM(require("path"), 1);
+var import_node_path17 = __toESM(require("path"), 1);
 var getSafePublicPath = (publicDirectory, relativePath) => {
-  const normalizedPath = import_node_path16.default.posix.normalize(relativePath);
-  const unsafe = relativePath.length === 0 || relativePath.includes("\0") || relativePath.includes("\\") || import_node_path16.default.posix.isAbsolute(relativePath) || /^[a-zA-Z]:\//.test(relativePath) || normalizedPath !== relativePath || normalizedPath === ".." || normalizedPath.startsWith("../");
+  const normalizedPath = import_node_path17.default.posix.normalize(relativePath);
+  const unsafe = relativePath.length === 0 || relativePath.includes("\0") || relativePath.includes("\\") || import_node_path17.default.posix.isAbsolute(relativePath) || /^[a-zA-Z]:\//.test(relativePath) || normalizedPath !== relativePath || normalizedPath === ".." || normalizedPath.startsWith("../");
   if (unsafe) return void 0;
-  const destinationPath = import_node_path16.default.resolve(publicDirectory, relativePath);
-  const relativeDestinationPath = import_node_path16.default.relative(publicDirectory, destinationPath);
-  return relativeDestinationPath !== "" && relativeDestinationPath !== ".." && !relativeDestinationPath.startsWith(`..${import_node_path16.default.sep}`) && !import_node_path16.default.isAbsolute(relativeDestinationPath) ? destinationPath : void 0;
+  const destinationPath = import_node_path17.default.resolve(publicDirectory, relativePath);
+  const relativeDestinationPath = import_node_path17.default.relative(publicDirectory, destinationPath);
+  return relativeDestinationPath !== "" && relativeDestinationPath !== ".." && !relativeDestinationPath.startsWith(`..${import_node_path17.default.sep}`) && !import_node_path17.default.isAbsolute(relativeDestinationPath) ? destinationPath : void 0;
 };
 var beginFederationOutputTransaction = async (projectDirectory, outDir, relativePublicPaths) => {
-  const transactionDirectory = await import_promises6.default.mkdtemp(import_node_path16.default.join(projectDirectory, ".eventcatalog-federation-transaction-"));
-  const previousOutDir = import_node_path16.default.join(transactionDirectory, "federated");
-  const publicBackupDirectory = import_node_path16.default.join(transactionDirectory, "public");
-  const publicDirectory = import_node_path16.default.resolve(projectDirectory, "public");
+  const transactionDirectory = await import_promises6.default.mkdtemp(import_node_path17.default.join(projectDirectory, ".eventcatalog-federation-transaction-"));
+  const previousOutDir = import_node_path17.default.join(transactionDirectory, "federated");
+  const publicBackupDirectory = import_node_path17.default.join(transactionDirectory, "public");
+  const publicDirectory = import_node_path17.default.resolve(projectDirectory, "public");
   const publicSnapshots = [];
   const missingPublicDirectories = /* @__PURE__ */ new Set();
   let hadPreviousOutDir = false;
@@ -2324,8 +2350,8 @@ var beginFederationOutputTransaction = async (projectDirectory, outDir, relative
       try {
         const stat = await import_promises6.default.lstat(destinationPath);
         if (!stat.isFile()) continue;
-        const backupPath = import_node_path16.default.join(publicBackupDirectory, `${publicSnapshots.length}`);
-        await import_promises6.default.mkdir(import_node_path16.default.dirname(backupPath), { recursive: true });
+        const backupPath = import_node_path17.default.join(publicBackupDirectory, `${publicSnapshots.length}`);
+        await import_promises6.default.mkdir(import_node_path17.default.dirname(backupPath), { recursive: true });
         await import_promises6.default.copyFile(destinationPath, backupPath);
         publicSnapshots.push({ backupPath, destinationPath, state: "file" });
       } catch (error) {
@@ -2333,7 +2359,7 @@ var beginFederationOutputTransaction = async (projectDirectory, outDir, relative
         if (code === "ENOTDIR") continue;
         if (code !== "ENOENT") throw error;
         publicSnapshots.push({ destinationPath, state: "missing" });
-        let directory = import_node_path16.default.dirname(destinationPath);
+        let directory = import_node_path17.default.dirname(destinationPath);
         while (directory !== publicDirectory) {
           try {
             await import_promises6.default.lstat(directory);
@@ -2343,7 +2369,7 @@ var beginFederationOutputTransaction = async (projectDirectory, outDir, relative
             if (directoryCode === "ENOTDIR") break;
             if (directoryCode !== "ENOENT") throw directoryError;
             missingPublicDirectories.add(directory);
-            directory = import_node_path16.default.dirname(directory);
+            directory = import_node_path17.default.dirname(directory);
           }
         }
       }
@@ -2379,7 +2405,7 @@ var beginFederationOutputTransaction = async (projectDirectory, outDir, relative
           continue;
         }
         await attempt(async () => {
-          await import_promises6.default.mkdir(import_node_path16.default.dirname(snapshot.destinationPath), { recursive: true });
+          await import_promises6.default.mkdir(import_node_path17.default.dirname(snapshot.destinationPath), { recursive: true });
           await import_promises6.default.copyFile(snapshot.backupPath, snapshot.destinationPath);
         });
       }
@@ -2416,7 +2442,7 @@ var withFederationOutputTransaction = async (projectDirectory, outDir, relativeP
 // src/federation/public-assets.ts
 var import_node_crypto3 = require("crypto");
 var import_promises7 = __toESM(require("fs/promises"), 1);
-var import_node_path17 = __toESM(require("path"), 1);
+var import_node_path18 = __toESM(require("path"), 1);
 var getContentHash2 = (content) => `sha256:${(0, import_node_crypto3.createHash)("sha256").update(content).digest("hex")}`;
 var getFileHash = async (filePath) => {
   try {
@@ -2428,13 +2454,13 @@ var getFileHash = async (filePath) => {
   }
 };
 var getSafePath = (directory, relativePath) => {
-  const normalizedPath = import_node_path17.default.posix.normalize(relativePath);
-  const unsafe = relativePath.length === 0 || relativePath.includes("\0") || relativePath.includes("\\") || import_node_path17.default.posix.isAbsolute(relativePath) || /^[a-zA-Z]:\//.test(relativePath) || normalizedPath !== relativePath || normalizedPath === ".." || normalizedPath.startsWith("../");
+  const normalizedPath = import_node_path18.default.posix.normalize(relativePath);
+  const unsafe = relativePath.length === 0 || relativePath.includes("\0") || relativePath.includes("\\") || import_node_path18.default.posix.isAbsolute(relativePath) || /^[a-zA-Z]:\//.test(relativePath) || normalizedPath !== relativePath || normalizedPath === ".." || normalizedPath.startsWith("../");
   if (unsafe) return void 0;
-  const resolvedDirectory = import_node_path17.default.resolve(directory);
-  const resolvedPath = import_node_path17.default.resolve(resolvedDirectory, relativePath);
-  const relativeResolvedPath = import_node_path17.default.relative(resolvedDirectory, resolvedPath);
-  if (relativeResolvedPath === "" || relativeResolvedPath === ".." || relativeResolvedPath.startsWith(`..${import_node_path17.default.sep}`) || import_node_path17.default.isAbsolute(relativeResolvedPath)) {
+  const resolvedDirectory = import_node_path18.default.resolve(directory);
+  const resolvedPath = import_node_path18.default.resolve(resolvedDirectory, relativePath);
+  const relativeResolvedPath = import_node_path18.default.relative(resolvedDirectory, resolvedPath);
+  if (relativeResolvedPath === "" || relativeResolvedPath === ".." || relativeResolvedPath.startsWith(`..${import_node_path18.default.sep}`) || import_node_path18.default.isAbsolute(relativeResolvedPath)) {
     return void 0;
   }
   return resolvedPath;
@@ -2442,16 +2468,16 @@ var getSafePath = (directory, relativePath) => {
 var listFiles = async (directory, relativeDirectory = "") => {
   let entries;
   try {
-    entries = await import_promises7.default.readdir(import_node_path17.default.join(directory, relativeDirectory), { withFileTypes: true });
+    entries = await import_promises7.default.readdir(import_node_path18.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_path17.default.join(relativeDirectory, entry.name);
+      const relativePath = import_node_path18.default.join(relativeDirectory, entry.name);
       if (entry.isDirectory()) return listFiles(directory, relativePath);
-      return entry.isFile() ? [relativePath.split(import_node_path17.default.sep).join("/")] : [];
+      return entry.isFile() ? [relativePath.split(import_node_path18.default.sep).join("/")] : [];
     })
   );
   return files.flat().sort();
@@ -2466,19 +2492,19 @@ var pathExists = async (filePath) => {
   }
 };
 var hasBlockingParent = async (publicDirectory, destinationPath) => {
-  let currentPath = import_node_path17.default.dirname(destinationPath);
+  let currentPath = import_node_path18.default.dirname(destinationPath);
   while (currentPath !== publicDirectory) {
     try {
       if (!(await import_promises7.default.lstat(currentPath)).isDirectory()) return true;
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
     }
-    currentPath = import_node_path17.default.dirname(currentPath);
+    currentPath = import_node_path18.default.dirname(currentPath);
   }
   return false;
 };
 var pruneEmptyDirectories = async (publicDirectory, filePath) => {
-  let currentPath = import_node_path17.default.dirname(filePath);
+  let currentPath = import_node_path18.default.dirname(filePath);
   while (currentPath !== publicDirectory) {
     try {
       await import_promises7.default.rmdir(currentPath);
@@ -2486,7 +2512,7 @@ var pruneEmptyDirectories = async (publicDirectory, filePath) => {
       if (!["ENOENT", "ENOTEMPTY"].includes(error.code ?? "")) throw error;
       if (error.code === "ENOTEMPTY") return;
     }
-    currentPath = import_node_path17.default.dirname(currentPath);
+    currentPath = import_node_path18.default.dirname(currentPath);
   }
 };
 var composePublicAssets = async ({
@@ -2496,8 +2522,8 @@ var composePublicAssets = async ({
   previousFiles = {},
   collisionPaths = /* @__PURE__ */ new Set()
 }) => {
-  const publicDirectory = import_node_path17.default.resolve(projectDirectory, "public");
-  const federatedPublicDirectory = import_node_path17.default.resolve(federatedDirectory, "public");
+  const publicDirectory = import_node_path18.default.resolve(projectDirectory, "public");
+  const federatedPublicDirectory = import_node_path18.default.resolve(federatedDirectory, "public");
   const sourceFiles = await listFiles(federatedPublicDirectory);
   const sourceFileSet = new Set(sourceFiles);
   const managedFiles = /* @__PURE__ */ new Set();
@@ -2533,7 +2559,7 @@ 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_promises7.default.readFile(sourcePath);
-    await import_promises7.default.mkdir(import_node_path17.default.dirname(destinationPath), { recursive: true });
+    await import_promises7.default.mkdir(import_node_path18.default.dirname(destinationPath), { recursive: true });
     await import_promises7.default.writeFile(destinationPath, content);
     files[relativePath] = { source: asset.resolvedFrom.source, hash: getContentHash2(content) };
     copied += 1;
@@ -2546,17 +2572,17 @@ var composePublicAssets = async ({
 // src/federation/filesystem-source-provider.ts
 var import_node_crypto4 = require("crypto");
 var import_promises8 = __toESM(require("fs/promises"), 1);
-var import_node_path18 = __toESM(require("path"), 1);
+var import_node_path19 = __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_path18.default.relative(directory, target);
-  return relativePath === "" || !relativePath.startsWith(`..${import_node_path18.default.sep}`) && relativePath !== ".." && !import_node_path18.default.isAbsolute(relativePath);
+  const relativePath = import_node_path19.default.relative(directory, target);
+  return relativePath === "" || !relativePath.startsWith(`..${import_node_path19.default.sep}`) && relativePath !== ".." && !import_node_path19.default.isAbsolute(relativePath);
 };
 var assertPortableRelativePath = (filePath, label, allowRoot = true) => {
   const portablePath = filePath.replaceAll("\\", "/");
-  const normalizedPath = import_node_path18.default.posix.normalize(portablePath);
-  const isUnsafe = filePath.includes("\\") || filePath.includes("\0") || import_node_path18.default.posix.isAbsolute(normalizedPath) || /^[a-zA-Z]:\//.test(normalizedPath) || normalizedPath === ".." || normalizedPath.startsWith("../") || !allowRoot && (normalizedPath === "." || normalizedPath === "");
+  const normalizedPath = import_node_path19.default.posix.normalize(portablePath);
+  const isUnsafe = filePath.includes("\\") || filePath.includes("\0") || import_node_path19.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;
 };
@@ -2566,13 +2592,13 @@ 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_path18.default.resolve(projectDirectory, locator);
+  return import_node_path19.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_path18.default.resolve(sourceRoot, ...catalogPath.split("/"));
+  const catalogDirectory = import_node_path19.default.resolve(sourceRoot, ...catalogPath.split("/"));
   if (!isWithinDirectory(sourceRoot, catalogDirectory)) {
     throw new Error(`Catalog path "${source.path}" escapes source "${source.id}"`);
   }
@@ -2594,7 +2620,7 @@ var getCatalogDirectory = async (projectDirectory, source) => {
 };
 var getArtifactPath = async (catalogDirectory, source, artifactPath) => {
   const normalizedPath = assertPortableRelativePath(artifactPath, "Federated artifact path", false);
-  const filePath = import_node_path18.default.resolve(catalogDirectory, ...normalizedPath.split("/"));
+  const filePath = import_node_path19.default.resolve(catalogDirectory, ...normalizedPath.split("/"));
   if (!isWithinDirectory(catalogDirectory, filePath)) {
     throw new Error(`Federated artifact path "${artifactPath}" escapes source "${source.id}"`);
   }
@@ -2634,7 +2660,7 @@ var createFileSystemSourceProvider = (projectDirectory) => ({
 var import_node_child_process = require("child_process");
 var import_promises9 = __toESM(require("fs/promises"), 1);
 var import_node_os3 = __toESM(require("os"), 1);
-var import_node_path19 = __toESM(require("path"), 1);
+var import_node_path20 = __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);
@@ -2645,8 +2671,8 @@ var parseGitHubSource = (source) => {
 };
 var assertSafeCatalogPath = (source) => {
   const catalogPath = source.path ?? ".";
-  const normalized = import_node_path19.default.posix.normalize(catalogPath.replaceAll("\\", "/"));
-  if (catalogPath.includes("\\") || import_node_path19.default.posix.isAbsolute(normalized) || normalized === ".." || normalized.startsWith("../")) {
+  const normalized = import_node_path20.default.posix.normalize(catalogPath.replaceAll("\\", "/"));
+  if (catalogPath.includes("\\") || import_node_path20.default.posix.isAbsolute(normalized) || normalized === ".." || normalized.startsWith("../")) {
     throw new Error(`Catalog path "${catalogPath}" escapes source "${source.id}"`);
   }
 };
@@ -2689,8 +2715,8 @@ var getGitEnvironment = (token) => {
 };
 var createCheckout = (executeFile, token) => async (source, ref, callback) => {
   const { owner, repository } = parseGitHubSource(source);
-  const catalogPath = import_node_path19.default.posix.normalize(source.path ?? ".");
-  const directory = await import_promises9.default.mkdtemp(import_node_path19.default.join(import_node_os3.default.tmpdir(), "eventcatalog-federation-"));
+  const catalogPath = import_node_path20.default.posix.normalize(source.path ?? ".");
+  const directory = await import_promises9.default.mkdtemp(import_node_path20.default.join(import_node_os3.default.tmpdir(), "eventcatalog-federation-"));
   const env = getGitEnvironment(token);
   try {
     const git = (args) => executeFile("git", args, { cwd: directory, env, encoding: "utf8" });
@@ -2710,16 +2736,16 @@ var createCheckout = (executeFile, token) => async (source, ref, callback) => {
 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_path19.default.resolve(directory, source.path ?? ".");
-  const relativeCatalogDirectory = import_node_path19.default.relative(directory, catalogDirectory);
-  if (relativeCatalogDirectory.startsWith("..") || import_node_path19.default.isAbsolute(relativeCatalogDirectory)) {
+  const catalogDirectory = import_node_path20.default.resolve(directory, source.path ?? ".");
+  const relativeCatalogDirectory = import_node_path20.default.relative(directory, catalogDirectory);
+  if (relativeCatalogDirectory.startsWith("..") || import_node_path20.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_path19.default.posix.join(source.path ?? ".", "catalog.index.json");
+  const indexPath = import_node_path20.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")));
@@ -2742,7 +2768,7 @@ var createGitHubSourceProvider = (options = {}) => {
     },
     async fetchContent({ source, commit, path: artifactPath }) {
       assertSafeCatalogPath(source);
-      const catalogPath = import_node_path19.default.posix.join(source.path ?? ".", artifactPath);
+      const catalogPath = import_node_path20.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;
@@ -2853,8 +2879,8 @@ var pathExists2 = async (filePath) => {
   }
 };
 var cleanupPreviousFederation = async (projectDirectory, onProgress) => {
-  const outDir = import_node_path20.default.join(projectDirectory, "federated");
-  const lockPath = import_node_path20.default.join(projectDirectory, "eventcatalog.lock");
+  const outDir = import_node_path21.default.join(projectDirectory, "federated");
+  const lockPath = import_node_path21.default.join(projectDirectory, "eventcatalog.lock");
   const previousLock = await readLock(lockPath);
   const hadFederatedOutput = await pathExists2(outDir);
   const hadLock = previousLock !== void 0;
@@ -2914,8 +2940,8 @@ var federateCatalog = async (projectDirectory, options = {}) => {
       throw new Error(`Failed to federate source "${source.id}": ${message2}`, { cause: error });
     }
   }
-  const outDir = import_node_path20.default.join(projectDirectory, "federated");
-  const lockPath = import_node_path20.default.join(projectDirectory, "eventcatalog.lock");
+  const outDir = import_node_path21.default.join(projectDirectory, "federated");
+  const lockPath = import_node_path21.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);
@@ -3027,17 +3053,17 @@ Run npm i @eventcatalog/core to update`;
 };
 
 // src/eventcatalog.ts
-var currentDir = import_node_path22.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
-var astroCli = import_node_path22.default.join(import_node_path22.default.dirname((0, import_node_module3.createRequire)(importMetaUrl).resolve("astro/package.json")), "bin/astro.mjs");
+var currentDir = import_node_path23.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
+var astroCli = import_node_path23.default.join(import_node_path23.default.dirname((0, import_node_module3.createRequire)(importMetaUrl).resolve("astro/package.json")), "bin/astro.mjs");
 var ASTRO_IN_FOREGROUND = { ASTRO_DEV_BACKGROUND: "1", ASTRO_PREVIEW_BACKGROUND: "1" };
 var program = new import_commander.Command().version(VERSION);
-var dir = import_node_path22.default.resolve(process.env.PROJECT_DIR || process.cwd());
-var eventCatalogDir = import_node_path22.default.resolve((0, import_node_path21.join)(currentDir, "../eventcatalog/"));
-var astroConfigPath = () => getAstroConfigPath(dir, (0, import_node_path21.join)(eventCatalogDir, "astro.config.mjs"));
+var dir = import_node_path23.default.resolve(process.env.PROJECT_DIR || process.cwd());
+var eventCatalogDir = import_node_path23.default.resolve((0, import_node_path22.join)(currentDir, "../eventcatalog/"));
+var astroConfigPath = () => getAstroConfigPath(dir, (0, import_node_path22.join)(eventCatalogDir, "astro.config.mjs"));
 var { runtimeDirectory: core } = getRuntimePaths(dir);
 var getInstalledEventCatalogVersion = () => {
   try {
-    const pkg = import_fs.default.readFileSync((0, import_node_path21.join)(dir, "package.json"), "utf8");
+    const pkg = import_fs.default.readFileSync((0, import_node_path22.join)(dir, "package.json"), "utf8");
     const json = JSON.parse(pkg);
     return json.dependencies["@eventcatalog/core"];
   } catch (error) {
@@ -3106,12 +3132,12 @@ var startDevPrewarm = ({
 var buildDevSearchIndex = async ({ config }) => {
   const result = await buildSearchIndex({
     projectDir: dir,
-    outDir: import_node_path22.default.join(core, "public"),
-    searchOutputPath: import_node_path22.default.join(core, "public", "pagefind"),
+    outDir: import_node_path23.default.join(core, "public"),
+    searchOutputPath: import_node_path23.default.join(core, "public", "pagefind"),
     config,
     isServer: false
   });
-  logger.info(`Indexed ${result.records} page(s) into ${import_node_path22.default.relative(core, result.outputPath)}`, "search");
+  logger.info(`Indexed ${result.records} page(s) into ${import_node_path23.default.relative(core, result.outputPath)}`, "search");
 };
 var warnIfIndexedSearchUsesAuth = async () => {
   if (!await isAuthEnabled()) {
@@ -3293,8 +3319,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_fs.default.existsSync(import_node_path22.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path22.default.join(dir, ".env") });
+  if (import_fs.default.existsSync(import_node_path23.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path23.default.join(dir, ".env") });
   }
   if (options.debug) {
     logger.info("Debug mode enabled", "debug");
@@ -3372,8 +3398,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_fs.default.existsSync(import_node_path22.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path22.default.join(dir, ".env") });
+  if (import_fs.default.existsSync(import_node_path23.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path23.default.join(dir, ".env") });
   }
   await verifyRequiredFieldsAreInCatalogConfigFile(dir);
   const config = await getEventCatalogConfigFile(dir);
@@ -3410,7 +3436,7 @@ program.command("build").description("Run build of EventCatalog").action(async (
   });
   if (await isIndexedSearchEnabled()) {
     await warnIfIndexedSearchUsesAuth();
-    const outDir = import_node_path22.default.resolve(dir, await getProjectOutDir());
+    const outDir = import_node_path23.default.resolve(dir, await getProjectOutDir());
     logger.info("Building indexed search...", "search");
     const result = await buildSearchIndex({
       projectDir: dir,
@@ -3418,7 +3444,30 @@ program.command("build").description("Run build of EventCatalog").action(async (
       config,
       isServer
     });
-    logger.info(`Indexed ${result.records} page(s) into ${import_node_path22.default.relative(dir, result.outputPath)}`, "search");
+    logger.info(`Indexed ${result.records} page(s) into ${import_node_path23.default.relative(dir, result.outputPath)}`, "search");
+  }
+  const architectureExport = resolveArchitectureExport(config, {
+    authEnabled: isCatalogAuthEnabled({ config, projectDir: dir, isServer })
+  });
+  if (architectureExport.enabled) {
+    try {
+      const result = await writeArchitectureExport({
+        projectDir: dir,
+        outDir: import_node_path23.default.resolve(dir, await getProjectOutDir()),
+        isServer
+      });
+      logger.info(
+        `Wrote the architecture reference to ${import_node_path23.default.relative(dir, result.path)} (${Math.round(result.bytes / 1024)} KB in ${result.durationMs} ms)`,
+        "export"
+      );
+    } catch (err) {
+      logger.info(`Skipped the architecture reference: ${err.message}`, "export");
+    }
+  } else if (architectureExport.reason === "auth") {
+    logger.info(
+      "Skipped the architecture reference because auth is enabled and build output is served without it. Set exports.html.enabled to true to publish it anyway.",
+      "export"
+    );
   }
 });
 var previewCatalog = async ({ command }) => {
@@ -3449,7 +3498,7 @@ if (start) {
 }
 `;
 var startServerCatalog = async () => {
-  const serverEntryPath = import_node_path22.default.join(dir, "dist", "server", "entry.mjs");
+  const serverEntryPath = import_node_path23.default.join(dir, "dist", "server", "entry.mjs");
   const config = await getEventCatalogConfigFile(dir);
   const base = (config?.base || "/").replace(/\/$/, "");
   await runCommandWithFilteredOutput({
@@ -3468,16 +3517,16 @@ 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_fs.default.existsSync(import_node_path22.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path22.default.join(dir, ".env") });
+  if (import_fs.default.existsSync(import_node_path23.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path23.default.join(dir, ".env") });
   }
   await previewCatalog({ command });
 });
 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_fs.default.existsSync(import_node_path22.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path22.default.join(dir, ".env") });
+  if (import_fs.default.existsSync(import_node_path23.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path23.default.join(dir, ".env") });
   }
   const isServerOutput = await isOutputServer();
   if (isServerOutput) {
@@ -3491,22 +3540,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_fs.default.existsSync(import_node_path22.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path22.default.join(dir, ".env") });
+  if (import_fs.default.existsSync(import_node_path23.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path23.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_path22.default.join(dir, "exports");
+  const exportsDir = import_node_path23.default.join(dir, "exports");
   ensureDir(exportsDir);
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  const exportFile = import_node_path22.default.join(exportsDir, `catalog-${date}.json`);
+  const exportFile = import_node_path23.default.join(exportsDir, `catalog-${date}.json`);
   import_fs.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_fs.default.existsSync(import_node_path22.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path22.default.join(dir, ".env") });
+  if (import_fs.default.existsSync(import_node_path23.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path23.default.join(dir, ".env") });
   }
   await generate(dir);
 });
@@ -3579,7 +3628,7 @@ var reportFederationProgress = (event, verbose = false) => {
       }
       return;
     case "hydrating":
-      logger.info(`Hydrating federated content into ${import_node_path22.default.relative(dir, event.outDir)}/...`, "federation");
+      logger.info(`Hydrating federated content into ${import_node_path23.default.relative(dir, event.outDir)}/...`, "federation");
       return;
     case "hydrate:cache":
       if (event.files === 1 || event.files % 25 === 0) {
@@ -3602,13 +3651,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_path22.default.relative(dir, event.result.lockPath)}`, "federation");
+      logger.info(`Recorded resolved source state in ${import_node_path23.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_fs.default.existsSync(import_node_path22.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path22.default.join(dir, ".env") });
+  if (import_fs.default.existsSync(import_node_path23.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path23.default.join(dir, ".env") });
   }
   logger.info("Starting federation...", "federation");
   let cleanedPreviousOutput = false;