@eventcatalog/core 5.0.0-beta.3 → 5.0.0-beta.31

package/dist/eventcatalog.cjs

@@ -22,19 +22,19 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// ../../node_modules/.pnpm/tsup@8.5.0_jiti@2.7.0_postcss@8.5.15_tsx@4.21.0_typescript@5.9.3_yaml@2.9.0/node_modules/tsup/assets/cjs_shims.js
+// ../../node_modules/.pnpm/tsup@8.5.0_jiti@2.7.0_postcss@8.5.29_tsx@4.23.15_typescript@5.9.3_yaml@2.9.1/node_modules/tsup/assets/cjs_shims.js
 var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.src || new URL("main.js", document.baseURI).href;
 var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 
 // src/eventcatalog.ts
 var import_commander = require("commander");
 var import_node_child_process2 = require("child_process");
-var import_node_path20 = require("path");
+var import_node_path21 = require("path");
 var import_node_http = __toESM(require("http"), 1);
 var import_fs = __toESM(require("fs"), 1);
-var import_node_path21 = __toESM(require("path"), 1);
+var import_node_path22 = __toESM(require("path"), 1);
 var import_node_url2 = require("url");
-var import_node_module2 = require("module");
+var import_node_module3 = require("module");
 
 // src/generate.js
 var import_node_path3 = __toESM(require("path"), 1);
@@ -50,65 +50,58 @@ var import_promises = require("fs/promises");
 var import_node_fs = require("fs");
 var import_node_path = __toESM(require("path"), 1);
 var import_node_url = require("url");
-var import_node_os = require("os");
+var import_node_module = require("module");
 async function cleanup(projectDirectory) {
   const filePath = import_node_path.default.join(projectDirectory, "eventcatalog.config.mjs");
   if ((0, import_node_fs.existsSync)(filePath)) {
     await (0, import_promises.rm)(filePath);
   }
 }
-var findNodeModulesDirectory = (directory) => {
-  let currentDirectory = directory;
-  while (true) {
-    const nodeModulesDirectory = import_node_path.default.join(currentDirectory, "node_modules");
-    if ((0, import_node_fs.existsSync)(nodeModulesDirectory)) {
-      return nodeModulesDirectory;
-    }
-    const parentDirectory = import_node_path.default.dirname(currentDirectory);
-    if (parentDirectory === currentDirectory) {
-      return void 0;
-    }
-    currentDirectory = parentDirectory;
-  }
-};
-var linkNodeModulesIntoTempDirectory = async ({ projectDirectory, tempDir }) => {
-  const nodeModulesDirectory = findNodeModulesDirectory(projectDirectory);
-  if (!nodeModulesDirectory) {
-    return;
-  }
-  await (0, import_promises.symlink)(nodeModulesDirectory, import_node_path.default.join(tempDir, "node_modules"), "dir");
+var hidesConfigModuleTypeWarning = false;
+var loads = 0;
+var hideConfigModuleTypeWarning = () => {
+  if (hidesConfigModuleTypeWarning) return;
+  hidesConfigModuleTypeWarning = true;
+  const emitWarning = process.emitWarning;
+  process.emitWarning = function(warning, ...args) {
+    const code = typeof args[0] === "object" ? args[0]?.code : args[1];
+    const message2 = typeof warning === "string" ? warning : warning?.message;
+    if (code === "MODULE_TYPELESS_PACKAGE_JSON" && message2?.includes("eventcatalog.config.js")) return;
+    return emitWarning.call(this, warning, ...args);
+  };
 };
-var createTemporaryConfigDirectory = async (projectDirectory) => {
-  const nodeModulesDirectory = findNodeModulesDirectory(projectDirectory);
-  if (nodeModulesDirectory) {
-    return (0, import_promises.mkdtemp)(import_node_path.default.join(nodeModulesDirectory, ".eventcatalog-config-"));
+var AS_MODULE_QUERY = "eventcatalog-config-as-module";
+var loadsMarkedConfigsAsModules = false;
+var loadMarkedConfigsAsModules = () => {
+  if (loadsMarkedConfigsAsModules) return;
+  loadsMarkedConfigsAsModules = true;
+  const hook = `export async function load(url, context, nextLoad) {
+    return nextLoad(url, url.includes('${AS_MODULE_QUERY}=') ? { ...context, format: 'module' } : context);
+  }`;
+  (0, import_node_module.register)(`data:text/javascript,${encodeURIComponent(hook)}`);
+};
+var isCommonJSPackage = async (projectDirectory) => {
+  try {
+    const packageJson = JSON.parse(await (0, import_promises.readFile)(import_node_path.default.join(projectDirectory, "package.json"), "utf-8"));
+    return packageJson?.type === "commonjs";
+  } catch {
+    return false;
   }
-  const tempDir = await (0, import_promises.mkdtemp)(import_node_path.default.join((0, import_node_os.tmpdir)(), "eventcatalog-config-"));
-  await linkNodeModulesIntoTempDirectory({ projectDirectory, tempDir });
-  return tempDir;
 };
 var getEventCatalogConfigFile = async (projectDirectory) => {
-  let tempDir;
   try {
-    let configFilePath = import_node_path.default.join(projectDirectory, "eventcatalog.config.js");
-    const filePath = import_node_path.default.join(projectDirectory, "package.json");
-    const packageJson = JSON.parse(await (0, import_promises.readFile)(filePath, "utf-8"));
-    if (packageJson?.type !== "module") {
-      tempDir = await createTemporaryConfigDirectory(projectDirectory);
-      configFilePath = import_node_path.default.join(tempDir, "eventcatalog.config.mjs");
-      await (0, import_promises.copyFile)(import_node_path.default.join(projectDirectory, "eventcatalog.config.js"), configFilePath);
-    }
-    const configFileURL = `${(0, import_node_url.pathToFileURL)(configFilePath).href}?t=${Date.now()}`;
+    hideConfigModuleTypeWarning();
+    const asModule = await isCommonJSPackage(projectDirectory);
+    if (asModule) loadMarkedConfigsAsModules();
+    const configFileURL = (0, import_node_url.pathToFileURL)(import_node_path.default.join(projectDirectory, "eventcatalog.config.js")).href;
+    const query = `${asModule ? AS_MODULE_QUERY : "loaded"}=${Date.now()}-${loads++}`;
     const config = await import(
       /* @vite-ignore */
-      configFileURL
+      `${configFileURL}?${query}`
     );
     return config.default;
   } finally {
     await cleanup(projectDirectory);
-    if (tempDir) {
-      await (0, import_promises.rm)(tempDir, { recursive: true, force: true });
-    }
   }
 };
 
@@ -181,7 +174,7 @@ var verifyRequiredFieldsAreInCatalogConfigFile = async (projectDirectory) => {
 var import_picocolors = __toESM(require("picocolors"), 1);
 
 // package.json
-var version = "5.0.0-beta.3";
+var version = "5.0.0-beta.31";
 
 // src/constants.ts
 var VERSION = version;
@@ -191,8 +184,8 @@ var getTimestamp = () => {
   const now = /* @__PURE__ */ new Date();
   return now.toLocaleTimeString("en-US", { hour12: false });
 };
-var formatMessage = (tag, message, tagColor) => {
-  return `${import_picocolors.default.dim(getTimestamp())} ${tagColor(`[${tag}]`)} ${message}`;
+var formatMessage = (tag, message2, tagColor) => {
+  return `${import_picocolors.default.dim(getTimestamp())} ${tagColor(`[${tag}]`)} ${message2}`;
 };
 var logger = {
   welcome: () => {
@@ -208,28 +201,28 @@ var logger = {
     );
     console.log();
   },
-  info: (message, tag = "info") => {
-    console.log(formatMessage(tag, message, import_picocolors.default.blue));
+  info: (message2, tag = "info") => {
+    console.log(formatMessage(tag, message2, import_picocolors.default.blue));
   },
-  success: (message, tag = "success") => {
-    console.log(formatMessage(tag, message, import_picocolors.default.green));
+  success: (message2, tag = "success") => {
+    console.log(formatMessage(tag, message2, import_picocolors.default.green));
   },
-  error: (message, tag = "error") => {
-    console.log(formatMessage(tag, message, import_picocolors.default.red));
+  error: (message2, tag = "error") => {
+    console.log(formatMessage(tag, message2, import_picocolors.default.red));
   },
-  warning: (message, tag = "warn") => {
-    console.log(formatMessage(tag, message, import_picocolors.default.yellow));
+  warning: (message2, tag = "warn") => {
+    console.log(formatMessage(tag, message2, import_picocolors.default.yellow));
   },
-  line: (message = "") => {
-    console.log(message);
+  line: (message2 = "") => {
+    console.log(message2);
   },
-  diagnostic: (severity, message, rule, attributes = []) => {
+  diagnostic: (severity, message2, rule, attributes = []) => {
     const isError = severity === "error";
     const color = isError ? import_picocolors.default.red : import_picocolors.default.yellow;
     const icon = isError ? "\u2716" : "\u26A0";
-    const label = `${icon} ${severity.padEnd(7)} ${message}`;
+    const label = `${icon} ${severity.padEnd(7)} ${message2}`;
     const ruleSpacing = " ".repeat(Math.max(2, 72 - label.length));
-    console.log(`  ${color(icon)} ${color(severity.padEnd(7))} ${message}${ruleSpacing}${import_picocolors.default.gray(rule)}`);
+    console.log(`  ${color(icon)} ${color(severity.padEnd(7))} ${message2}${ruleSpacing}${import_picocolors.default.gray(rule)}`);
     for (const attribute of attributes) {
       console.log(`             - ${import_picocolors.default.dim(`${attribute.label}:`)} ${attribute.value}`);
     }
@@ -243,8 +236,8 @@ var logger = {
     const warningCount = `${warnings} warning${warnings === 1 ? "" : "s"}`;
     console.log(color(`${icon} ${problems} (${errorCount}, ${warningCount})`));
   },
-  dim: (message) => {
-    console.log(import_picocolors.default.dim(message));
+  dim: (message2) => {
+    console.log(import_picocolors.default.dim(message2));
   }
 };
 
@@ -295,16 +288,34 @@ var generate = async (PROJECT_DIRECTORY) => {
       for (const { plugin } of errors) {
         logger.error(`  - ${plugin}`, "generator");
       }
+      process.exitCode = 1;
     }
   } catch (error) {
     console.error(error);
     await cleanup(PROJECT_DIRECTORY);
+    process.exitCode = 1;
   }
 };
 
 // src/analytics/analytics.js
 var import_os = __toESM(require("os"), 1);
-async function raiseEvent(eventData) {
+
+// src/analytics/telemetry.ts
+var TELEMETRY_REQUEST_TIMEOUT_MS = 2e3;
+var isOptOutEnvValue = (value) => {
+  if (typeof value !== "string") return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized === "1" || normalized === "true";
+};
+var isTelemetryDisabled = (config, env) => {
+  if (isOptOutEnvValue(env.EVENTCATALOG_TELEMETRY_DISABLED)) return true;
+  if (isOptOutEnvValue(env.DO_NOT_TRACK)) return true;
+  return config?.telemetry === false;
+};
+
+// src/analytics/analytics.js
+async function raiseEvent(eventData, config) {
+  if (isTelemetryDisabled(config, process.env)) return;
   if (typeof eventData?.command !== "string" || typeof eventData?.cId !== "string") return;
   const url = "https://queue.simpleanalyticscdn.com/events";
   const userAgent = `@eventcatalog/eventcatalog@${VERSION} (${import_os.default.platform()}; ${import_os.default.arch()}; Node/${process.version})`;
@@ -326,7 +337,8 @@ async function raiseEvent(eventData) {
     const response = await fetch(url, {
       method: "POST",
       headers,
-      body: JSON.stringify(payload)
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(TELEMETRY_REQUEST_TIMEOUT_MS)
     });
     if (!response.ok) {
       throw new Error(`Failed to raise analytics event: ${response.status}`);
@@ -403,12 +415,16 @@ function serializeCounts(counts) {
 
 // src/utils/license-status.ts
 var import_boxen = __toESM(require("boxen"), 1);
+var import_picocolors2 = __toESM(require("picocolors"), 1);
 var import_license2 = require("@eventcatalog/license");
 
 // eventcatalog/src/utils/trial.ts
-var TRIAL_LENGTH_DAYS = 90;
+var TRIAL_LENGTH_DAYS = 60;
 var LICENSE_FAQ_URL = "https://www.eventcatalog.dev/license-faq";
 var LICENSE_RENEW_URL = "https://eventcatalog.cloud";
+var BUY_BUSINESS_URL = "https://www.eventcatalog.dev/buy?source=cli";
+var PRICING_URL = "https://www.eventcatalog.dev/pricing";
+var FREE_USE_NOTE = "Under $10M revenue and $10M raised, an individual or an open-source project? You qualify for Free Use; get a free key at eventcatalog.cloud.";
 var DAY_IN_MS = 24 * 60 * 60 * 1e3;
 var getTrialStatus = (tsd, now = Date.now()) => {
   if (typeof tsd !== "number" || !Number.isFinite(tsd) || tsd <= 0) return;
@@ -525,79 +541,157 @@ var getLicenseAnalytics = (license = { state: "none" }, tsd) => ({
 });
 var formatDate = (date) => date.toLocaleDateString(void 0, { dateStyle: "medium" });
 var formatDays = (days) => `${days} ${days === 1 ? "day" : "days"}`;
-var getTrialLine = (tsd, now) => {
+var PLAIN = { bold: (text) => text, dim: (text) => text, link: (text) => text };
+var COLOURS = { bold: import_picocolors2.default.bold, dim: import_picocolors2.default.dim, link: (text) => import_picocolors2.default.cyan(text) };
+var render = ({ headline, rows, links, note }, colours) => {
+  const width = Math.max(0, ...[...rows, ...links].map(([label]) => label.length));
+  const row = ([label, value]) => `${colours.dim(label.padEnd(width))}  ${value}`;
+  return [
+    colours.bold(headline),
+    ...rows.length ? ["", ...rows.map(row)] : [],
+    ...links.length ? ["", ...links.map(([label, url]) => row([label, colours.link(url)]))] : [],
+    ...note?.length ? ["", ...note.map(colours.dim)] : []
+  ].join("\n");
+};
+var FREE_USE_LINES = FREE_USE_NOTE.split(/(?<=\?) /);
+var message = (content) => ({
+  ...content,
+  text: render(content, PLAIN)
+});
+var getTrialRow = (tsd, now) => {
   const trial = getTrialStatus(tsd, now);
   if (!trial) return;
-  return trial.ended ? `Your ${TRIAL_LENGTH_DAYS}-day EventCatalog trial ended on ${formatDate(trial.endsAt)}.` : `${formatDays(trial.daysLeft)} left of your ${TRIAL_LENGTH_DAYS}-day EventCatalog trial (ends ${formatDate(trial.endsAt)}).`;
+  return [
+    "Trial",
+    trial.ended ? `Ended ${formatDate(trial.endsAt)}` : `${formatDays(trial.daysLeft)} left of ${TRIAL_LENGTH_DAYS} (ends ${formatDate(trial.endsAt)})`
+  ];
 };
 var getLicenseStatusMessage = (license, tsd, now = Date.now()) => {
+  const licensing = ["Licensing", LICENSE_FAQ_URL];
+  const renew = ["Renew", LICENSE_RENEW_URL];
+  const licensedTo = "org" in license && license.org ? [["Licensed to", license.org]] : [];
   if (license.state === "licensed") {
     const daysLeft = Math.max(0, Math.ceil((license.expiresAt.getTime() - now) / DAY_IN_MS2));
-    const licensedTo = license.org ? `Licensed to ${license.org}` : "Licensed";
     if (daysLeft < LICENSE_REMINDER_DAYS) {
-      return {
-        title: "EventCatalog Commercial License",
+      return message({
+        title: "EventCatalog license",
         color: "yellow",
-        text: [
-          licensedTo,
-          `Your license expires in ${formatDays(daysLeft)}, on ${formatDate(license.expiresAt)}.`,
-          `Renew it to keep using EventCatalog commercially: ${LICENSE_RENEW_URL}`
-        ].join("\n")
-      };
+        headline: `Your commercial license expires in ${formatDays(daysLeft)}`,
+        rows: [...licensedTo, ["Expires", formatDate(license.expiresAt)]],
+        links: [renew]
+      });
     }
-    return {
-      title: "EventCatalog Commercial License",
+    return message({
+      title: "EventCatalog license",
       color: "green",
-      text: `${licensedTo}
-Valid until ${formatDate(license.expiresAt)} (${formatDays(daysLeft)} left)`
-    };
+      headline: "Commercial license active",
+      rows: [...licensedTo, ["Valid until", `${formatDate(license.expiresAt)} (${formatDays(daysLeft)} left)`]],
+      links: []
+    });
   }
   if (license.state === "plan") return;
-  const trialLine = getTrialLine(tsd, now);
+  const trialRow = getTrialRow(tsd, now);
+  const trialRows = trialRow ? [trialRow] : [];
   if (license.state === "none") {
-    if (!trialLine) return;
-    const ended = getTrialStatus(tsd, now)?.ended;
-    return {
+    const trial = getTrialStatus(tsd, now);
+    if (!trial || !trialRow) return;
+    return message({
       title: "EventCatalog trial",
-      color: ended ? "yellow" : "green",
-      text: `${trialLine}
-Learn about licensing: ${LICENSE_FAQ_URL}`
-    };
+      color: trial.ended ? "yellow" : "green",
+      headline: trial.ended ? "Your EventCatalog trial has ended" : `You're on the ${TRIAL_LENGTH_DAYS}-day EventCatalog trial`,
+      rows: trialRows,
+      links: trial.ended ? [["Get a license", LICENSE_RENEW_URL], ["Buy Business", BUY_BUSINESS_URL], licensing] : [["Buy a license", PRICING_URL], licensing],
+      note: trial.ended ? FREE_USE_LINES : void 0
+    });
   }
   if (license.state === "expired") {
-    const expiredOn = license.expiresAt ? `expired on ${formatDate(license.expiresAt)} (${formatDays(Math.floor((now - license.expiresAt.getTime()) / DAY_IN_MS2))} ago)` : "has expired";
-    return {
-      title: "EventCatalog License Expired",
+    const expiredOn = license.expiresAt ? [
+      [
+        "Expired",
+        `${formatDate(license.expiresAt)} (${formatDays(Math.floor((now - license.expiresAt.getTime()) / DAY_IN_MS2))} ago)`
+      ]
+    ] : [];
+    return message({
+      title: "EventCatalog license",
       color: "yellow",
-      text: [
-        `Your EventCatalog commercial license${license.org ? ` for ${license.org}` : ""} ${expiredOn}.`,
-        `Renew it to keep using EventCatalog commercially: ${LICENSE_RENEW_URL}`,
-        trialLine,
-        `Learn about licensing: ${LICENSE_FAQ_URL}`
-      ].filter(Boolean).join("\n")
-    };
+      headline: "Your commercial license has expired",
+      // A catalog has a license or is on the trial: an expired license is renewed, not replaced by the trial
+      rows: [...licensedTo, ...expiredOn],
+      links: [renew, licensing]
+    });
   }
-  return {
+  return message({
     title: "EventCatalog license",
     color: "yellow",
-    text: [`Your license.jwt could not be verified: ${license.reason}.`, trialLine, `Learn about licensing: ${LICENSE_FAQ_URL}`].filter(Boolean).join("\n")
-  };
+    headline: "Your license.jwt couldn't be verified",
+    rows: [["Reason", license.reason.charAt(0).toUpperCase() + license.reason.slice(1)], ...trialRows],
+    links: [licensing]
+  });
 };
 var printLicenseStatus = (license, tsd) => {
-  const message = getLicenseStatusMessage(license, tsd);
-  if (!message) return;
+  const status = getLicenseStatusMessage(license, tsd);
+  if (!status) return;
   console.log(
-    (0, import_boxen.default)(message.text, {
-      padding: 1,
+    (0, import_boxen.default)(render(status, COLOURS), {
+      padding: { top: 1, bottom: 1, left: 2, right: 2 },
       margin: 1,
       borderStyle: "round",
-      borderColor: message.color,
-      title: message.title,
-      titleAlignment: "center"
+      borderColor: status.color,
+      title: status.title,
+      titleAlignment: "left"
     })
   );
 };
 
+// src/analytics/studio-usage.js
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+var DAY_IN_MS3 = 24 * 60 * 60 * 1e3;
+var DEFAULT_DATABASE_PATH = ".eventcatalog/eventcatalog.db";
+var getStudioMode = (configFile) => {
+  const enabled = configFile.studio?.enabled;
+  if (enabled === false) return "off";
+  return configFile.output === "server" && enabled === true ? "server" : "dev";
+};
+var getStorageType = (configFile) => configFile.storage?.type || "memory";
+var loadSqlite = () => {
+  const emitWarning = process.emitWarning;
+  process.emitWarning = function(warning, ...args) {
+    const type = typeof args[0] === "object" ? args[0]?.type : args[0];
+    const message2 = typeof warning === "string" ? warning : warning?.message;
+    if (type === "ExperimentalWarning" && message2?.startsWith("SQLite")) return;
+    return emitWarning.call(this, warning, ...args);
+  };
+  try {
+    return process.getBuiltinModule?.("node:sqlite");
+  } catch {
+    return void 0;
+  } finally {
+    process.emitWarning = emitWarning;
+  }
+};
+var UNKNOWN = "canvases:unknown";
+var serializeStudioUsage = (projectDirectory, configFile, now = Date.now()) => {
+  if (getStudioMode(configFile) === "off" || getStorageType(configFile) !== "sqlite") return UNKNOWN;
+  const file = import_node_path6.default.resolve(projectDirectory, configFile.storage.path ?? DEFAULT_DATABASE_PATH);
+  if (!import_node_fs3.default.existsSync(file)) return "canvases:0,changed7d:0,changed30d:0,deleted:0";
+  let database;
+  try {
+    const sqlite = loadSqlite();
+    if (!sqlite?.DatabaseSync) return UNKNOWN;
+    database = new sqlite.DatabaseSync(file, { readOnly: true });
+    const canvases = database.prepare(
+      "SELECT COUNT(*) AS total, SUM(updated_at >= ?) AS changed7d, SUM(updated_at >= ?) AS changed30d FROM studio_canvases"
+    ).get(now - 7 * DAY_IN_MS3, now - 30 * DAY_IN_MS3);
+    const { deleted } = database.prepare("SELECT COUNT(*) AS deleted FROM studio_deleted_canvases").get();
+    return `canvases:${canvases.total},changed7d:${canvases.changed7d ?? 0},changed30d:${canvases.changed30d ?? 0},deleted:${deleted}`;
+  } catch {
+    return UNKNOWN;
+  } finally {
+    database?.close();
+  }
+};
+
 // src/analytics/log-build.js
 var isMCPEnabled = (configFile) => configFile.output === "server" && (configFile.mcp?.enabled ?? true);
 var getFeatures = async (configFile) => {
@@ -611,7 +705,9 @@ var getFeatures = async (configFile) => {
     environments: Array.isArray(configFile.environments) && configFile.environments.length > 0,
     output: configFile.output || "static",
     mcp,
-    mcpAuth: mcp && (configFile.mcp?.auth?.enabled ?? false)
+    mcpAuth: mcp && (configFile.mcp?.auth?.enabled ?? false),
+    studio: getStudioMode(configFile),
+    storage: getStorageType(configFile)
   };
 };
 var getDirectoryProvider = (source) => {
@@ -653,50 +749,70 @@ var toCloudResourceCounts = (counts) => ({
   customPages: counts.customPages || 0,
   customApis: counts.customApis || 0
 });
-var reportCloudResourceInventory = async (configFile, resourceCounts) => {
+var getEnabledCloudAnalytics = (configFile) => {
   const analytics = configFile.cloud?.analytics;
-  if (!analytics?.enabled || !analytics.trackingId || !analytics.writeKey) return;
+  if (!analytics?.enabled || !analytics.trackingId || !analytics.writeKey) return null;
+  return analytics;
+};
+var reportCloudResourceInventory = async (configFile, resourceCounts) => {
+  const analytics = getEnabledCloudAnalytics(configFile);
+  if (!analytics) return;
   const endpoint = analytics.endpoint || CLOUD_ANALYTICS_ENDPOINT;
-  await fetch(endpoint, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "X-EventCatalog-Analytics-Key": analytics.writeKey
-    },
-    body: JSON.stringify({
-      trackingId: analytics.trackingId,
-      event: "catalog.resource_inventory_reported",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      counts: toCloudResourceCounts(resourceCounts)
-    })
-  });
+  try {
+    await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-EventCatalog-Analytics-Key": analytics.writeKey
+      },
+      body: JSON.stringify({
+        trackingId: analytics.trackingId,
+        event: "catalog.resource_inventory_reported",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        counts: toCloudResourceCounts(resourceCounts)
+      }),
+      signal: AbortSignal.timeout(TELEMETRY_REQUEST_TIMEOUT_MS)
+    });
+  } catch {
+  }
 };
 var main = async (projectDir, { command = "build", license } = {}) => {
   try {
     await verifyRequiredFieldsAreInCatalogConfigFile(projectDir);
     const configFile = await getEventCatalogConfigFile(projectDir);
+    if (isTelemetryDisabled(configFile, process.env)) {
+      if (getEnabledCloudAnalytics(configFile)) {
+        const resourceCounts2 = await countResources(projectDir);
+        await reportCloudResourceInventory(configFile, resourceCounts2);
+      }
+      return;
+    }
     const { cId, tsd, organizationName, generators = [] } = configFile;
     const generatorNames = generators.length > 0 ? generators.map((generator) => generator[0]) : ["none"];
     const features = await getFeatures(configFile);
     const resourceCounts = await countResources(projectDir);
     const contentHash = await hashCatalogContent(projectDir);
     await reportCloudResourceInventory(configFile, resourceCounts);
-    await raiseEvent({
-      command,
-      org: organizationName,
-      cId,
-      // Trial start date (unix ms) from eventcatalog.config.js
-      tsd,
-      // Commercial license or trial, and when each expires (unix ms)
-      ...getLicenseAnalytics(license, tsd),
-      // CI redeploys and human-run builds are different signals; tag rather than suppress
-      ci: process.env.CI ? "true" : "false",
-      contentHash,
-      generators: generatorNames.toString(),
-      features: Object.keys(features).map((feature) => `${feature}:${features[feature]}`).join(","),
-      directorySources: serializeDirectorySources(configFile),
-      resources: serializeCounts(resourceCounts)
-    });
+    await raiseEvent(
+      {
+        command,
+        org: organizationName,
+        cId,
+        // Trial start date (unix ms) from eventcatalog.config.js
+        tsd,
+        // Commercial license or trial, and when each expires (unix ms)
+        ...getLicenseAnalytics(license, tsd),
+        // CI redeploys and human-run builds are different signals; tag rather than suppress
+        ci: process.env.CI ? "true" : "false",
+        contentHash,
+        generators: generatorNames.toString(),
+        features: Object.keys(features).map((feature) => `${feature}:${features[feature]}`).join(","),
+        directorySources: serializeDirectorySources(configFile),
+        resources: serializeCounts(resourceCounts),
+        studio: serializeStudioUsage(projectDir, configFile)
+      },
+      configFile
+    );
   } catch (error) {
   }
 };
@@ -714,8 +830,8 @@ async function watch(projectDirectory, catalogDirectory, callback = () => {
 }
 
 // src/resolve-catalog-dependencies.js
-var import_node_path6 = __toESM(require("path"), 1);
-var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
+var import_node_fs4 = __toESM(require("fs"), 1);
 var import_gray_matter2 = __toESM(require("gray-matter"), 1);
 var resolve_catalog_dependencies_default = async (catalogDir, core2) => {
   const catalogConfig = await getEventCatalogConfigFile(catalogDir);
@@ -723,11 +839,11 @@ var resolve_catalog_dependencies_default = async (catalogDir, core2) => {
   if (!dependencies) {
     return;
   }
-  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 });
+  const dependenciesDir = import_node_path7.default.join(catalogDir, "dependencies");
+  if (import_node_fs4.default.existsSync(dependenciesDir)) {
+    import_node_fs4.default.rmSync(dependenciesDir, { recursive: true, force: true });
   }
-  import_node_fs3.default.mkdirSync(dependenciesDir, { recursive: true });
+  import_node_fs4.default.mkdirSync(dependenciesDir, { recursive: true });
   const resourceTypes = Object.keys(dependencies);
   for (const resourceType of resourceTypes) {
     for (const dependency of dependencies[resourceType]) {
@@ -747,9 +863,9 @@ var resolve_catalog_dependencies_default = async (catalogDir, core2) => {
         },
         frontmatter
       );
-      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);
+      const resourceFile = import_node_path7.default.join(dependenciesDir, resourceType, dependency.id, `index.md`);
+      import_node_fs4.default.mkdirSync(import_node_path7.default.dirname(resourceFile), { recursive: true });
+      import_node_fs4.default.writeFileSync(resourceFile, markdown);
     }
   }
   return;
@@ -759,8 +875,8 @@ var resolve_catalog_dependencies_default = async (catalogDir, core2) => {
 var import_boxen2 = __toESM(require("boxen"), 1);
 
 // src/features.ts
-var import_node_path7 = require("path");
-var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path8 = require("path");
+var import_node_fs5 = __toESM(require("fs"), 1);
 var getProjectOutDir = async () => {
   const config = await getEventCatalogConfigFile(process.env.PROJECT_DIR || "");
   return config?.outDir || "dist";
@@ -775,7 +891,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_path7.join)(directory, "eventcatalog.auth.js"));
+  const hasAuthConfig = import_node_fs5.default.existsSync((0, import_node_path8.join)(directory, "eventcatalog.auth.js"));
   return hasAuthConfig;
 };
 
@@ -784,11 +900,11 @@ var import_update_notifier = __toESM(require("update-notifier"), 1);
 var import_dotenv = __toESM(require("dotenv"), 1);
 
 // src/migrations/message-channels-to-service-channels.ts
-var import_node_fs5 = __toESM(require("fs"), 1);
+var import_node_fs6 = __toESM(require("fs"), 1);
 var import_glob2 = require("glob");
-var import_node_os2 = __toESM(require("os"), 1);
+var import_node_os = __toESM(require("os"), 1);
 var import_gray_matter3 = __toESM(require("gray-matter"), 1);
-var import_node_path8 = __toESM(require("path"), 1);
+var import_node_path9 = __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());
@@ -797,7 +913,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_path8.default.join(dir2 || process.env.PROJECT_DIR);
+  const PROJECT_DIR = import_node_path9.default.join(dir2 || process.env.PROJECT_DIR);
   const messages = await (0, import_glob2.glob)(
     [
       "**/events/*/index.mdx",
@@ -820,7 +936,7 @@ var message_channels_to_service_channels_default = async (dir2) => {
       cwd: PROJECT_DIR,
       absolute: true,
       nodir: true,
-      windowsPathsNoEscape: import_node_os2.default.platform() == "win32",
+      windowsPathsNoEscape: import_node_os.default.platform() == "win32",
       ignore: ["node_modules/**", "**/dist/**", "**/teams", "**/users", "**/package.json", "**/Dockerfile"]
     }
   );
@@ -836,13 +952,13 @@ var message_channels_to_service_channels_default = async (dir2) => {
       absolute: true
     }
   );
-  const messagesWithChannels = messages.reduce((acc, message) => {
-    const file = import_node_fs5.default.readFileSync(message, "utf8");
+  const messagesWithChannels = messages.reduce((acc, message2) => {
+    const file = import_node_fs6.default.readFileSync(message2, "utf8");
     const { data } = (0, import_gray_matter3.default)(file);
     if (data.channels?.length > 0) {
       acc.push({
         ...data,
-        path: message
+        path: message2
       });
     }
     return acc;
@@ -851,11 +967,11 @@ var message_channels_to_service_channels_default = async (dir2) => {
     return { status: "success", message: "No messages with channels found in the catalog" };
   }
   const servicesWithChannels = services.reduce((acc, service) => {
-    const file = import_node_fs5.default.readFileSync(service, "utf8");
+    const file = import_node_fs6.default.readFileSync(service, "utf8");
     const { data } = (0, import_gray_matter3.default)(file);
-    const isSending = data.sends?.some((send) => messagesWithChannels.some((message) => message.id === send.id));
+    const isSending = data.sends?.some((send) => messagesWithChannels.some((message2) => message2.id === send.id));
     const isReceiving = data.receives?.some(
-      (receive) => messagesWithChannels.some((message) => message.id === receive.id)
+      (receive) => messagesWithChannels.some((message2) => message2.id === receive.id)
     );
     if (isSending || isReceiving) {
       acc.push({
@@ -866,18 +982,18 @@ var message_channels_to_service_channels_default = async (dir2) => {
     return acc;
   }, []);
   for (const service of servicesWithChannels) {
-    const file = import_node_fs5.default.readFileSync(service.path, "utf8");
+    const file = import_node_fs6.default.readFileSync(service.path, "utf8");
     const { data } = (0, import_gray_matter3.default)(file);
-    const messagesTheServiceSendsThatNeedUpdating = data.sends?.filter((send) => messagesWithChannels.some((message) => message.id === send.id)) ?? [];
-    const messagesTheServiceReceivesThatNeedUpdating = data.receives?.filter((receive) => messagesWithChannels.some((message) => message.id === receive.id)) ?? [];
+    const messagesTheServiceSendsThatNeedUpdating = data.sends?.filter((send) => messagesWithChannels.some((message2) => message2.id === send.id)) ?? [];
+    const messagesTheServiceReceivesThatNeedUpdating = data.receives?.filter((receive) => messagesWithChannels.some((message2) => message2.id === receive.id)) ?? [];
     if (messagesTheServiceSendsThatNeedUpdating.length > 0 || messagesTheServiceReceivesThatNeedUpdating.length > 0) {
       const newSends = (data.sends ?? []).map((send) => {
-        const match = messagesWithChannels.find((message) => message.id === send.id);
+        const match = messagesWithChannels.find((message2) => message2.id === send.id);
         if (!match) return send;
         return { ...send, to: (match.channels ?? []).filter((channel) => channel !== null) };
       });
       const newReceives = (data.receives ?? []).map((receive) => {
-        const match = messagesWithChannels.find((message) => message.id === receive.id);
+        const match = messagesWithChannels.find((message2) => message2.id === receive.id);
         if (!match) return receive;
         return { ...receive, from: (match.channels ?? []).filter((channel) => channel !== null) };
       });
@@ -886,14 +1002,14 @@ var message_channels_to_service_channels_default = async (dir2) => {
         ...newSends.length > 0 ? { sends: newSends } : {},
         ...newReceives.length > 0 ? { receives: newReceives } : {}
       };
-      import_node_fs5.default.writeFileSync(service.path, import_gray_matter3.default.stringify(file, newData));
+      import_node_fs6.default.writeFileSync(service.path, import_gray_matter3.default.stringify(file, newData));
     }
   }
-  for (const message of messagesWithChannels) {
-    const file = import_node_fs5.default.readFileSync(message.path, "utf8");
+  for (const message2 of messagesWithChannels) {
+    const file = import_node_fs6.default.readFileSync(message2.path, "utf8");
     const parsed = (0, import_gray_matter3.default)(file);
     const { channels, ...newData } = parsed.data;
-    import_node_fs5.default.writeFileSync(message.path, import_gray_matter3.default.stringify(parsed.content, newData));
+    import_node_fs6.default.writeFileSync(message2.path, import_gray_matter3.default.stringify(parsed.content, newData));
   }
   console.log("\u2714 Channels migrated to new services API");
 };
@@ -903,13 +1019,39 @@ var runMigrations = async (dir2) => {
   await message_channels_to_service_channels_default(dir2);
 };
 
+// src/utils/child-process-signals.ts
+var import_node_os2 = require("os");
+var FORWARDED_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+var isRunning = (child) => child.exitCode === null && child.signalCode === null;
+var stopChildWithParent = (child, parent = process) => {
+  let received;
+  const onSignal = (signal) => {
+    received = signal;
+    if (isRunning(child)) child.kill(signal);
+  };
+  const onExit = () => {
+    if (isRunning(child)) child.kill("SIGTERM");
+  };
+  for (const signal of FORWARDED_SIGNALS) parent.on(signal, onSignal);
+  parent.on("exit", onExit);
+  return {
+    childClosed: () => {
+      for (const signal of FORWARDED_SIGNALS) parent.off(signal, onSignal);
+      parent.off("exit", onExit);
+      if (!received) return false;
+      parent.exit(128 + import_node_os2.constants.signals[received]);
+      return true;
+    }
+  };
+};
+
 // eventcatalog/src/features/fields/field-indexer.ts
-var import_node_path10 = __toESM(require("path"), 1);
-var import_node_fs7 = __toESM(require("fs"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
+var import_node_fs8 = __toESM(require("fs"), 1);
 
 // eventcatalog/src/features/fields/fields-db.ts
 var import_sql = __toESM(require("sql.js"), 1);
-var import_node_fs6 = __toESM(require("fs"), 1);
+var import_node_fs7 = __toESM(require("fs"), 1);
 var SCHEMA_SQL = `
   CREATE TABLE IF NOT EXISTS fields (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -978,13 +1120,13 @@ var FieldsDatabase = class _FieldsDatabase {
     this.dbPath = dbPath;
   }
   static async create(dbPath, options) {
-    if (options?.recreate && import_node_fs6.default.existsSync(dbPath)) {
-      import_node_fs6.default.unlinkSync(dbPath);
+    if (options?.recreate && import_node_fs7.default.existsSync(dbPath)) {
+      import_node_fs7.default.unlinkSync(dbPath);
     }
     const SQL = await (0, import_sql.default)();
     let db;
-    if (!options?.recreate && import_node_fs6.default.existsSync(dbPath)) {
-      const buffer = import_node_fs6.default.readFileSync(dbPath);
+    if (!options?.recreate && import_node_fs7.default.existsSync(dbPath)) {
+      const buffer = import_node_fs7.default.readFileSync(dbPath);
       db = new SQL.Database(buffer);
     } else {
       db = new SQL.Database();
@@ -1045,7 +1187,7 @@ var FieldsDatabase = class _FieldsDatabase {
   save() {
     const data = this.db.export();
     const buffer = Buffer.from(data);
-    import_node_fs6.default.writeFileSync(this.dbPath, buffer);
+    import_node_fs7.default.writeFileSync(this.dbPath, buffer);
   }
   queryFields(params) {
     const {
@@ -1055,7 +1197,7 @@ var FieldsDatabase = class _FieldsDatabase {
       format,
       type,
       messageType,
-      message,
+      message: message2,
       producer,
       consumer,
       required,
@@ -1089,9 +1231,9 @@ var FieldsDatabase = class _FieldsDatabase {
       conditions.push(`f.message_type IN (${types2.map(() => "?").join(", ")})`);
       bindings.push(...types2);
     }
-    if (message) {
+    if (message2) {
       conditions.push(`f.message_id = ?`);
-      bindings.push(message);
+      bindings.push(message2);
     }
     if (required) {
       conditions.push(`f.required = 1`);
@@ -1270,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 path20 = prefix ? `${prefix}.${field.name}` : field.name;
+    const path21 = prefix ? `${prefix}.${field.name}` : field.name;
     const isOptional = Array.isArray(field.type) && field.type.includes("null");
     const typeName = getAvroTypeName(field.type);
     fields.push({
-      path: path20,
+      path: path21,
       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, path20, fields);
+      walkAvroRecord(innerType, path21, 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, `${path20}[]`, fields);
+      walkAvroRecord(arrayType.items, `${path21}[]`, fields);
     }
   }
 }
@@ -1316,32 +1458,32 @@ function walkJsonSchema(node, prefix, requiredList, rootSchema, fields) {
   }
   if (!node.properties) return;
   for (const [name, prop] of Object.entries(node.properties)) {
-    const path20 = prefix ? `${prefix}.${name}` : name;
+    const path21 = 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: path20, type: type2, description: resolved.description || "", required: isRequired });
+        fields.push({ path: path21, type: type2, description: resolved.description || "", required: isRequired });
         if (resolved.properties) {
-          walkJsonSchema(resolved, path20, resolved.required || [], rootSchema, fields);
+          walkJsonSchema(resolved, path21, resolved.required || [], rootSchema, fields);
         }
       } else {
-        fields.push({ path: path20, type: "$ref", description: "", required: isRequired });
+        fields.push({ path: path21, 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: path20, type, description: prop.description || "", required: isRequired });
+    fields.push({ path: path21, type, description: prop.description || "", required: isRequired });
     if (typeList.includes("object") && prop.properties) {
-      walkJsonSchema(prop, path20, prop.required || [], rootSchema, fields);
+      walkJsonSchema(prop, path21, prop.required || [], rootSchema, fields);
     }
     if (typeList.includes("array") && prop.items) {
       if (prop.items.type === "object" && prop.items.properties) {
-        walkJsonSchema(prop.items, `${path20}[]`, prop.items.required || [], rootSchema, fields);
+        walkJsonSchema(prop.items, `${path21}[]`, prop.items.required || [], rootSchema, fields);
       }
     }
   }
@@ -1358,22 +1500,22 @@ function resolveLocalRef(ref, rootSchema) {
 }
 
 // eventcatalog/integrations/runtime-paths.mjs
-var import_node_path9 = __toESM(require("path"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
 function getRuntimePaths(projectDirectory, runtimeDirectory) {
-  const project = import_node_path9.default.resolve(projectDirectory);
-  const cacheDirectory = import_node_path9.default.join(project, ".astro");
-  const runtime = runtimeDirectory ? import_node_path9.default.resolve(runtimeDirectory) : import_node_path9.default.join(cacheDirectory, "eventcatalog");
+  const project = import_node_path10.default.resolve(projectDirectory);
+  const cacheDirectory = import_node_path10.default.join(project, ".astro");
+  const runtime = runtimeDirectory ? import_node_path10.default.resolve(runtimeDirectory) : import_node_path10.default.join(cacheDirectory, "eventcatalog");
   return {
     projectDirectory: project,
     cacheDirectory,
     runtimeDirectory: runtime,
-    fieldsDatabasePath: import_node_path9.default.join(runtime, ".eventcatalog", "fields.db")
+    fieldsDatabasePath: import_node_path10.default.join(runtime, ".eventcatalog", "fields.db")
   };
 }
 
 // eventcatalog/src/features/fields/field-indexer.ts
 function detectFormat(fileName) {
-  const ext = import_node_path10.default.extname(fileName).toLowerCase();
+  const ext = import_node_path11.default.extname(fileName).toLowerCase();
   if (ext === ".proto") return "proto";
   if (ext === ".avro" || ext === ".avsc") return "avro";
   return "json-schema";
@@ -1382,9 +1524,9 @@ async function buildFieldsIndex(catalogDir, outputDir) {
   const sdkModule = await import("@eventcatalog/sdk");
   const sdk = sdkModule.default(catalogDir);
   const { fieldsDatabasePath: dbPath } = getRuntimePaths(catalogDir, outputDir || catalogDir);
-  const dbDir = import_node_path10.default.dirname(dbPath);
-  if (!import_node_fs7.default.existsSync(dbDir)) {
-    import_node_fs7.default.mkdirSync(dbDir, { recursive: true });
+  const dbDir = import_node_path11.default.dirname(dbPath);
+  if (!import_node_fs8.default.existsSync(dbDir)) {
+    import_node_fs8.default.mkdirSync(dbDir, { recursive: true });
   }
   const db = await FieldsDatabase.create(dbPath, { recreate: true });
   const warnings = [];
@@ -1468,7 +1610,7 @@ async function buildFieldsIndex(catalogDir, outputDir) {
 
 // src/search-indexer.ts
 var import_promises4 = __toESM(require("fs/promises"), 1);
-var import_node_path11 = __toESM(require("path"), 1);
+var import_node_path12 = __toESM(require("path"), 1);
 var import_glob3 = require("glob");
 var import_gray_matter4 = __toESM(require("gray-matter"), 1);
 var RESOURCE_COLLECTIONS = {
@@ -1532,9 +1674,9 @@ var markdownToSearchText = (content) => {
 };
 var inferDocIdFromFile = (relativePath, frontmatterId) => {
   if (frontmatterId) return frontmatterId;
-  const fileName = import_node_path11.default.posix.basename(removeExtension(relativePath));
+  const fileName = import_node_path12.default.posix.basename(removeExtension(relativePath));
   if (fileName.toLowerCase() === "index") {
-    return import_node_path11.default.posix.basename(import_node_path11.default.posix.dirname(relativePath));
+    return import_node_path12.default.posix.basename(import_node_path12.default.posix.dirname(relativePath));
   }
   return stripNumericPrefix(fileName);
 };
@@ -1552,7 +1694,7 @@ var findResourceSegment = (segments) => {
   return match;
 };
 var readResourceFrontmatter = async (projectDir, resourcePath) => {
-  const candidates = [import_node_path11.default.join(projectDir, resourcePath, "index.mdx"), import_node_path11.default.join(projectDir, resourcePath, "index.md")];
+  const candidates = [import_node_path12.default.join(projectDir, resourcePath, "index.mdx"), import_node_path12.default.join(projectDir, resourcePath, "index.md")];
   for (const candidate of candidates) {
     try {
       const file = await import_promises4.default.readFile(candidate, "utf8");
@@ -1577,7 +1719,7 @@ var deriveRecordFromPath = async ({
   }
   if (segments[0] === "docs") {
     const customPath = normalizeUrlPath(removeExtension(segments.slice(1).join("/")));
-    const title = data.title || data.label || import_node_path11.default.posix.basename(customPath) || "Custom docs";
+    const title = data.title || data.label || import_node_path12.default.posix.basename(customPath) || "Custom docs";
     return {
       url: buildUrl(`/docs/custom/${customPath}`, config),
       title,
@@ -1695,7 +1837,7 @@ var collectSearchRecords = async ({
     files.map(async (file) => {
       const raw = await import_promises4.default.readFile(file, "utf8");
       const parsed = (0, import_gray_matter4.default)(raw);
-      const relativePath = normalizePath(import_node_path11.default.relative(projectDir, file));
+      const relativePath = normalizePath(import_node_path12.default.relative(projectDir, file));
       const baseRecord = await deriveRecordFromPath({
         projectDir,
         relativePath,
@@ -1743,7 +1885,7 @@ var getSearchOutputPath = ({
   if (searchOutputPath) {
     return searchOutputPath;
   }
-  return import_node_path11.default.join(outDir, isServer ? "client" : "", "pagefind");
+  return import_node_path12.default.join(outDir, isServer ? "client" : "", "pagefind");
 };
 var buildSearchIndex = async ({ projectDir, outDir, config, isServer, searchOutputPath }) => {
   const records = await collectSearchRecords({ projectDir, config });
@@ -1797,74 +1939,74 @@ ${errors.join("\n")}`);
 };
 
 // src/catalog-runtime.ts
-var import_node_fs8 = __toESM(require("fs"), 1);
-var import_node_path12 = __toESM(require("path"), 1);
-var import_node_module = require("module");
-var require2 = (0, import_node_module.createRequire)(importMetaUrl);
+var import_node_fs9 = __toESM(require("fs"), 1);
+var import_node_path13 = __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_fs8.default.existsSync(file) && import_node_fs8.default.readFileSync(file, "utf8") === content) return;
-  import_node_fs8.default.mkdirSync(import_node_path12.default.dirname(file), { recursive: true });
-  import_node_fs8.default.writeFileSync(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);
 };
 var importPath = (file) => file.replace(/\\/g, "/");
-var hasLegacyCatalogRuntime = (projectDirectory) => import_node_fs8.default.existsSync(import_node_path12.default.join(projectDirectory, ".eventcatalog-core"));
+var hasLegacyCatalogRuntime = (projectDirectory) => import_node_fs9.default.existsSync(import_node_path13.default.join(projectDirectory, ".eventcatalog-core"));
 var clearCatalogCache = (projectDirectory) => {
   const { cacheDirectory } = getRuntimePaths(projectDirectory);
-  import_node_fs8.default.rmSync(cacheDirectory, { recursive: true, force: true });
+  import_node_fs9.default.rmSync(cacheDirectory, { recursive: true, force: true });
 };
 var prepareCatalogRuntime = ({ projectDirectory, catalogDirectory, packageDirectory }) => {
-  const runtime = import_node_path12.default.resolve(catalogDirectory);
-  const source = import_node_path12.default.resolve(packageDirectory);
-  const project = import_node_path12.default.resolve(projectDirectory);
+  const runtime = import_node_path13.default.resolve(catalogDirectory);
+  const source = import_node_path13.default.resolve(packageDirectory);
+  const project = import_node_path13.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_fs8.default.mkdirSync(runtime, { recursive: true });
+  import_node_fs9.default.mkdirSync(runtime, { recursive: true });
   writeIfChanged(
-    import_node_path12.default.join(runtime, "content.config.ts"),
-    `export { collections } from ${JSON.stringify(importPath(import_node_path12.default.join(source, "src/content.config.ts")))};
+    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")))};
 `
   );
-  const packageTsconfig = JSON.parse(import_node_fs8.default.readFileSync(import_node_path12.default.join(source, "tsconfig.json"), "utf8"));
+  const packageTsconfig = JSON.parse(import_node_fs9.default.readFileSync(import_node_path13.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_path12.default.resolve(source, target)))
+      targets.map((target) => importPath(import_node_path13.default.resolve(source, target)))
     ])
   );
-  paths["@config"] = [importPath(import_node_path12.default.join(project, "eventcatalog.config.js"))];
-  paths["@catalog/styles"] = [importPath(import_node_path12.default.join(project, "eventcatalog.styles.css"))];
+  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["@catalog/components/*"] = [
-    importPath(import_node_path12.default.join(project, "components/*")),
-    importPath(import_node_path12.default.join(project, "federated/components/*"))
+    importPath(import_node_path13.default.join(project, "components/*")),
+    importPath(import_node_path13.default.join(project, "federated/components/*"))
   ];
-  paths["@catalog/snippets/*"] = [importPath(import_node_path12.default.join(project, "snippets/*"))];
+  paths["@catalog/snippets/*"] = [importPath(import_node_path13.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_path12.default.join(runtime, "tsconfig.json"),
+    import_node_path13.default.join(runtime, "tsconfig.json"),
     JSON.stringify(
       {
-        extends: importPath(import_node_path12.default.join(source, "tsconfig.json")),
+        extends: importPath(import_node_path13.default.join(source, "tsconfig.json")),
         compilerOptions: {
           baseUrl: ".",
           paths,
           typeRoots: [
-            importPath(import_node_path12.default.join(project, "node_modules/@types")),
-            importPath(import_node_path12.default.join(source, "../node_modules/@types")),
-            importPath(import_node_path12.default.join(source, "../node_modules")),
-            importPath(import_node_path12.default.join(project, "node_modules"))
+            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"))
           ]
         },
         include: [
-          importPath(import_node_path12.default.join(project, ".astro/types.d.ts")),
+          importPath(import_node_path13.default.join(project, ".astro/types.d.ts")),
           "content.config.ts",
-          importPath(import_node_path12.default.join(project, "components/**/*")),
-          importPath(import_node_path12.default.join(source, "src/**/*"))
+          importPath(import_node_path13.default.join(project, "components/**/*")),
+          importPath(import_node_path13.default.join(source, "src/**/*"))
         ],
         // Keep legacy generated files out of checks on an existing checkout.
-        exclude: (packageTsconfig.exclude ?? []).map((entry) => importPath(import_node_path12.default.resolve(source, entry)))
+        exclude: (packageTsconfig.exclude ?? []).map((entry) => importPath(import_node_path13.default.resolve(source, entry)))
       },
       null,
       2
@@ -1904,8 +2046,8 @@ var KNOWN_EVENTCATALOG_COLLECTIONS = /* @__PURE__ */ new Set([
 var EMPTY_COLLECTION_MESSAGE = /^The collection ("(?:\\.|[^"\\])*") does not exist or is empty\. Please check your content config file for errors\.$/;
 var ANSI_PATTERN = /\u001B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
 var ASTRO_CONTENT_WARN_PREFIX = /^[^[\]]*\[WARN\]\s+\[content\](?:\s+\[[^\]]+\])*\s*$/;
-function collectionNameFromEmptyWarning(message) {
-  const match = message.match(EMPTY_COLLECTION_MESSAGE);
+function collectionNameFromEmptyWarning(message2) {
+  const match = message2.match(EMPTY_COLLECTION_MESSAGE);
   if (!match) return null;
   try {
     const name = JSON.parse(match[1]);
@@ -1914,8 +2056,8 @@ function collectionNameFromEmptyWarning(message) {
     return null;
   }
 }
-function isIntentionalEmptyCollectionMessage(message) {
-  const name = collectionNameFromEmptyWarning(message);
+function isIntentionalEmptyCollectionMessage(message2) {
+  const name = collectionNameFromEmptyWarning(message2);
   return name !== null && KNOWN_EVENTCATALOG_COLLECTIONS.has(name);
 }
 function isIntentionalEmptyCollectionLine(line) {
@@ -1923,8 +2065,8 @@ function isIntentionalEmptyCollectionLine(line) {
   const marker = 'The collection "';
   const start = plain.indexOf(marker);
   if (start === -1) return false;
-  const message = plain.slice(start).trim();
-  if (!isIntentionalEmptyCollectionMessage(message)) return false;
+  const message2 = plain.slice(start).trim();
+  if (!isIntentionalEmptyCollectionMessage(message2)) return false;
   const before = plain.slice(0, start).trim();
   return before.length === 0 || ASTRO_CONTENT_WARN_PREFIX.test(before);
 }
@@ -1944,8 +2086,8 @@ var createAstroDevLineFilter = () => {
 };
 
 // src/astro-config-path.ts
-var import_node_path13 = __toESM(require("path"), 1);
-var getAstroConfigPath = (projectDirectory, configFile, paths = import_node_path13.default) => {
+var import_node_path14 = __toESM(require("path"), 1);
+var getAstroConfigPath = (projectDirectory, configFile, paths = import_node_path14.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();
@@ -1960,18 +2102,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_path19 = __toESM(require("path"), 1);
+var import_node_path20 = __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_path14 = __toESM(require("path"), 1);
+var import_node_path15 = __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_path14.default.join(projectDirectory, ".eventcatalog-cache", "federation", "content");
-  const getCachePath = (key) => import_node_path14.default.join(cacheDirectory, encodeURIComponent(key));
+  const cacheDirectory = import_node_path15.default.join(projectDirectory, ".eventcatalog-cache", "federation", "content");
+  const getCachePath = (key) => import_node_path15.default.join(cacheDirectory, encodeURIComponent(key));
   return {
     async get(key) {
       if (options.read === false || !isContentHash(key)) return void 0;
@@ -2158,20 +2300,20 @@ var getVisibleFederationDiagnostics = (diagnostics, verbose) => diagnostics.filt
 
 // src/federation/output-transaction.ts
 var import_promises6 = __toESM(require("fs/promises"), 1);
-var import_node_path15 = __toESM(require("path"), 1);
+var import_node_path16 = __toESM(require("path"), 1);
 var getSafePublicPath = (publicDirectory, relativePath) => {
-  const normalizedPath = import_node_path15.default.posix.normalize(relativePath);
-  const unsafe = relativePath.length === 0 || relativePath.includes("\0") || relativePath.includes("\\") || import_node_path15.default.posix.isAbsolute(relativePath) || /^[a-zA-Z]:\//.test(relativePath) || normalizedPath !== relativePath || normalizedPath === ".." || normalizedPath.startsWith("../");
+  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("../");
   if (unsafe) return void 0;
-  const destinationPath = import_node_path15.default.resolve(publicDirectory, relativePath);
-  const relativeDestinationPath = import_node_path15.default.relative(publicDirectory, destinationPath);
-  return relativeDestinationPath !== "" && relativeDestinationPath !== ".." && !relativeDestinationPath.startsWith(`..${import_node_path15.default.sep}`) && !import_node_path15.default.isAbsolute(relativeDestinationPath) ? destinationPath : 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;
 };
 var beginFederationOutputTransaction = async (projectDirectory, outDir, relativePublicPaths) => {
-  const transactionDirectory = await import_promises6.default.mkdtemp(import_node_path15.default.join(projectDirectory, ".eventcatalog-federation-transaction-"));
-  const previousOutDir = import_node_path15.default.join(transactionDirectory, "federated");
-  const publicBackupDirectory = import_node_path15.default.join(transactionDirectory, "public");
-  const publicDirectory = import_node_path15.default.resolve(projectDirectory, "public");
+  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 publicSnapshots = [];
   const missingPublicDirectories = /* @__PURE__ */ new Set();
   let hadPreviousOutDir = false;
@@ -2182,8 +2324,8 @@ var beginFederationOutputTransaction = async (projectDirectory, outDir, relative
       try {
         const stat = await import_promises6.default.lstat(destinationPath);
         if (!stat.isFile()) continue;
-        const backupPath = import_node_path15.default.join(publicBackupDirectory, `${publicSnapshots.length}`);
-        await import_promises6.default.mkdir(import_node_path15.default.dirname(backupPath), { recursive: true });
+        const backupPath = import_node_path16.default.join(publicBackupDirectory, `${publicSnapshots.length}`);
+        await import_promises6.default.mkdir(import_node_path16.default.dirname(backupPath), { recursive: true });
         await import_promises6.default.copyFile(destinationPath, backupPath);
         publicSnapshots.push({ backupPath, destinationPath, state: "file" });
       } catch (error) {
@@ -2191,7 +2333,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_path15.default.dirname(destinationPath);
+        let directory = import_node_path16.default.dirname(destinationPath);
         while (directory !== publicDirectory) {
           try {
             await import_promises6.default.lstat(directory);
@@ -2201,7 +2343,7 @@ var beginFederationOutputTransaction = async (projectDirectory, outDir, relative
             if (directoryCode === "ENOTDIR") break;
             if (directoryCode !== "ENOENT") throw directoryError;
             missingPublicDirectories.add(directory);
-            directory = import_node_path15.default.dirname(directory);
+            directory = import_node_path16.default.dirname(directory);
           }
         }
       }
@@ -2237,7 +2379,7 @@ var beginFederationOutputTransaction = async (projectDirectory, outDir, relative
           continue;
         }
         await attempt(async () => {
-          await import_promises6.default.mkdir(import_node_path15.default.dirname(snapshot.destinationPath), { recursive: true });
+          await import_promises6.default.mkdir(import_node_path16.default.dirname(snapshot.destinationPath), { recursive: true });
           await import_promises6.default.copyFile(snapshot.backupPath, snapshot.destinationPath);
         });
       }
@@ -2274,7 +2416,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_path16 = __toESM(require("path"), 1);
+var import_node_path17 = __toESM(require("path"), 1);
 var getContentHash2 = (content) => `sha256:${(0, import_node_crypto3.createHash)("sha256").update(content).digest("hex")}`;
 var getFileHash = async (filePath) => {
   try {
@@ -2286,13 +2428,13 @@ var getFileHash = async (filePath) => {
   }
 };
 var getSafePath = (directory, 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 resolvedDirectory = import_node_path16.default.resolve(directory);
-  const resolvedPath = import_node_path16.default.resolve(resolvedDirectory, relativePath);
-  const relativeResolvedPath = import_node_path16.default.relative(resolvedDirectory, resolvedPath);
-  if (relativeResolvedPath === "" || relativeResolvedPath === ".." || relativeResolvedPath.startsWith(`..${import_node_path16.default.sep}`) || import_node_path16.default.isAbsolute(relativeResolvedPath)) {
+  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)) {
     return void 0;
   }
   return resolvedPath;
@@ -2300,16 +2442,16 @@ var getSafePath = (directory, relativePath) => {
 var listFiles = async (directory, relativeDirectory = "") => {
   let entries;
   try {
-    entries = await import_promises7.default.readdir(import_node_path16.default.join(directory, relativeDirectory), { withFileTypes: true });
+    entries = await import_promises7.default.readdir(import_node_path17.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_path16.default.join(relativeDirectory, entry.name);
+      const relativePath = import_node_path17.default.join(relativeDirectory, entry.name);
       if (entry.isDirectory()) return listFiles(directory, relativePath);
-      return entry.isFile() ? [relativePath.split(import_node_path16.default.sep).join("/")] : [];
+      return entry.isFile() ? [relativePath.split(import_node_path17.default.sep).join("/")] : [];
     })
   );
   return files.flat().sort();
@@ -2324,19 +2466,19 @@ var pathExists = async (filePath) => {
   }
 };
 var hasBlockingParent = async (publicDirectory, destinationPath) => {
-  let currentPath = import_node_path16.default.dirname(destinationPath);
+  let currentPath = import_node_path17.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_path16.default.dirname(currentPath);
+    currentPath = import_node_path17.default.dirname(currentPath);
   }
   return false;
 };
 var pruneEmptyDirectories = async (publicDirectory, filePath) => {
-  let currentPath = import_node_path16.default.dirname(filePath);
+  let currentPath = import_node_path17.default.dirname(filePath);
   while (currentPath !== publicDirectory) {
     try {
       await import_promises7.default.rmdir(currentPath);
@@ -2344,7 +2486,7 @@ var pruneEmptyDirectories = async (publicDirectory, filePath) => {
       if (!["ENOENT", "ENOTEMPTY"].includes(error.code ?? "")) throw error;
       if (error.code === "ENOTEMPTY") return;
     }
-    currentPath = import_node_path16.default.dirname(currentPath);
+    currentPath = import_node_path17.default.dirname(currentPath);
   }
 };
 var composePublicAssets = async ({
@@ -2354,8 +2496,8 @@ var composePublicAssets = async ({
   previousFiles = {},
   collisionPaths = /* @__PURE__ */ new Set()
 }) => {
-  const publicDirectory = import_node_path16.default.resolve(projectDirectory, "public");
-  const federatedPublicDirectory = import_node_path16.default.resolve(federatedDirectory, "public");
+  const publicDirectory = import_node_path17.default.resolve(projectDirectory, "public");
+  const federatedPublicDirectory = import_node_path17.default.resolve(federatedDirectory, "public");
   const sourceFiles = await listFiles(federatedPublicDirectory);
   const sourceFileSet = new Set(sourceFiles);
   const managedFiles = /* @__PURE__ */ new Set();
@@ -2391,7 +2533,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_path16.default.dirname(destinationPath), { recursive: true });
+    await import_promises7.default.mkdir(import_node_path17.default.dirname(destinationPath), { recursive: true });
     await import_promises7.default.writeFile(destinationPath, content);
     files[relativePath] = { source: asset.resolvedFrom.source, hash: getContentHash2(content) };
     copied += 1;
@@ -2404,17 +2546,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_path17 = __toESM(require("path"), 1);
+var import_node_path18 = __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_path17.default.relative(directory, target);
-  return relativePath === "" || !relativePath.startsWith(`..${import_node_path17.default.sep}`) && relativePath !== ".." && !import_node_path17.default.isAbsolute(relativePath);
+  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);
 };
 var assertPortableRelativePath = (filePath, label, allowRoot = true) => {
   const portablePath = filePath.replaceAll("\\", "/");
-  const normalizedPath = import_node_path17.default.posix.normalize(portablePath);
-  const isUnsafe = filePath.includes("\\") || filePath.includes("\0") || import_node_path17.default.posix.isAbsolute(normalizedPath) || /^[a-zA-Z]:\//.test(normalizedPath) || normalizedPath === ".." || normalizedPath.startsWith("../") || !allowRoot && (normalizedPath === "." || normalizedPath === "");
+  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 === "");
   if (isUnsafe) throw new Error(`${label} "${filePath}" escapes its filesystem source`);
   return normalizedPath;
 };
@@ -2424,13 +2566,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_path17.default.resolve(projectDirectory, locator);
+  return import_node_path18.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_path17.default.resolve(sourceRoot, ...catalogPath.split("/"));
+  const catalogDirectory = import_node_path18.default.resolve(sourceRoot, ...catalogPath.split("/"));
   if (!isWithinDirectory(sourceRoot, catalogDirectory)) {
     throw new Error(`Catalog path "${source.path}" escapes source "${source.id}"`);
   }
@@ -2452,7 +2594,7 @@ var getCatalogDirectory = async (projectDirectory, source) => {
 };
 var getArtifactPath = async (catalogDirectory, source, artifactPath) => {
   const normalizedPath = assertPortableRelativePath(artifactPath, "Federated artifact path", false);
-  const filePath = import_node_path17.default.resolve(catalogDirectory, ...normalizedPath.split("/"));
+  const filePath = import_node_path18.default.resolve(catalogDirectory, ...normalizedPath.split("/"));
   if (!isWithinDirectory(catalogDirectory, filePath)) {
     throw new Error(`Federated artifact path "${artifactPath}" escapes source "${source.id}"`);
   }
@@ -2492,7 +2634,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_path18 = __toESM(require("path"), 1);
+var import_node_path19 = __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);
@@ -2503,8 +2645,8 @@ var parseGitHubSource = (source) => {
 };
 var assertSafeCatalogPath = (source) => {
   const catalogPath = source.path ?? ".";
-  const normalized = import_node_path18.default.posix.normalize(catalogPath.replaceAll("\\", "/"));
-  if (catalogPath.includes("\\") || import_node_path18.default.posix.isAbsolute(normalized) || normalized === ".." || normalized.startsWith("../")) {
+  const normalized = import_node_path19.default.posix.normalize(catalogPath.replaceAll("\\", "/"));
+  if (catalogPath.includes("\\") || import_node_path19.default.posix.isAbsolute(normalized) || normalized === ".." || normalized.startsWith("../")) {
     throw new Error(`Catalog path "${catalogPath}" escapes source "${source.id}"`);
   }
 };
@@ -2547,8 +2689,8 @@ var getGitEnvironment = (token) => {
 };
 var createCheckout = (executeFile, token) => async (source, ref, callback) => {
   const { owner, repository } = parseGitHubSource(source);
-  const catalogPath = import_node_path18.default.posix.normalize(source.path ?? ".");
-  const directory = await import_promises9.default.mkdtemp(import_node_path18.default.join(import_node_os3.default.tmpdir(), "eventcatalog-federation-"));
+  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 env = getGitEnvironment(token);
   try {
     const git = (args) => executeFile("git", args, { cwd: directory, env, encoding: "utf8" });
@@ -2568,16 +2710,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_path18.default.resolve(directory, source.path ?? ".");
-  const relativeCatalogDirectory = import_node_path18.default.relative(directory, catalogDirectory);
-  if (relativeCatalogDirectory.startsWith("..") || import_node_path18.default.isAbsolute(relativeCatalogDirectory)) {
+  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)) {
     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_path18.default.posix.join(source.path ?? ".", "catalog.index.json");
+  const indexPath = import_node_path19.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")));
@@ -2600,7 +2742,7 @@ var createGitHubSourceProvider = (options = {}) => {
     },
     async fetchContent({ source, commit, path: artifactPath }) {
       assertSafeCatalogPath(source);
-      const catalogPath = import_node_path18.default.posix.join(source.path ?? ".", artifactPath);
+      const catalogPath = import_node_path19.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;
@@ -2711,8 +2853,8 @@ var pathExists2 = async (filePath) => {
   }
 };
 var cleanupPreviousFederation = async (projectDirectory, onProgress) => {
-  const outDir = import_node_path19.default.join(projectDirectory, "federated");
-  const lockPath = import_node_path19.default.join(projectDirectory, "eventcatalog.lock");
+  const outDir = import_node_path20.default.join(projectDirectory, "federated");
+  const lockPath = import_node_path20.default.join(projectDirectory, "eventcatalog.lock");
   const previousLock = await readLock(lockPath);
   const hadFederatedOutput = await pathExists2(outDir);
   const hadLock = previousLock !== void 0;
@@ -2768,12 +2910,12 @@ var federateCatalog = async (projectDirectory, options = {}) => {
         generated: resolved.generated
       });
     } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to federate source "${source.id}": ${message}`, { cause: error });
+      const message2 = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to federate source "${source.id}": ${message2}`, { cause: error });
     }
   }
-  const outDir = import_node_path19.default.join(projectDirectory, "federated");
-  const lockPath = import_node_path19.default.join(projectDirectory, "eventcatalog.lock");
+  const outDir = import_node_path20.default.join(projectDirectory, "federated");
+  const lockPath = import_node_path20.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);
@@ -2885,16 +3027,17 @@ Run npm i @eventcatalog/core to update`;
 };
 
 // src/eventcatalog.ts
-var currentDir = import_node_path21.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
-var astroCli = import_node_path21.default.join(import_node_path21.default.dirname((0, import_node_module2.createRequire)(importMetaUrl).resolve("astro/package.json")), "bin/astro.mjs");
+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 ASTRO_IN_FOREGROUND = { ASTRO_DEV_BACKGROUND: "1", ASTRO_PREVIEW_BACKGROUND: "1" };
 var program = new import_commander.Command().version(VERSION);
-var dir = import_node_path21.default.resolve(process.env.PROJECT_DIR || process.cwd());
-var eventCatalogDir = import_node_path21.default.resolve((0, import_node_path20.join)(currentDir, "../eventcatalog/"));
-var astroConfigPath = () => getAstroConfigPath(dir, (0, import_node_path20.join)(eventCatalogDir, "astro.config.mjs"));
+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 { runtimeDirectory: core } = getRuntimePaths(dir);
 var getInstalledEventCatalogVersion = () => {
   try {
-    const pkg = import_fs.default.readFileSync((0, import_node_path20.join)(dir, "package.json"), "utf8");
+    const pkg = import_fs.default.readFileSync((0, import_node_path21.join)(dir, "package.json"), "utf8");
     const json = JSON.parse(pkg);
     return json.dependencies["@eventcatalog/core"];
   } catch (error) {
@@ -2918,7 +3061,7 @@ var resolveDevPort = async ({ projectDir }) => {
 };
 var startDevPrewarm = ({
   port = 3e3,
-  paths = ["/ping", "/"],
+  paths = ["/"],
   retries = 80,
   intervalMs = 250,
   initialDelayMs = 500
@@ -2927,10 +3070,13 @@ var startDevPrewarm = ({
   const hit = (requestPath) => new Promise((resolve2) => {
     const req = import_node_http.default.get(
       {
-        hostname: "127.0.0.1",
+        // Not 127.0.0.1: the dev server can listen on IPv6 only ([::1]), which refused
+        // every prewarm request
+        hostname: "localhost",
         port,
         path: requestPath,
-        timeout: 1200
+        // A refused connection fails at once; once connected, let the first render finish
+        timeout: 3e4
       },
       (res) => {
         res.resume();
@@ -2960,12 +3106,12 @@ var startDevPrewarm = ({
 var buildDevSearchIndex = async ({ config }) => {
   const result = await buildSearchIndex({
     projectDir: dir,
-    outDir: import_node_path21.default.join(core, "public"),
-    searchOutputPath: import_node_path21.default.join(core, "public", "pagefind"),
+    outDir: import_node_path22.default.join(core, "public"),
+    searchOutputPath: import_node_path22.default.join(core, "public", "pagefind"),
     config,
     isServer: false
   });
-  logger.info(`Indexed ${result.records} page(s) into ${import_node_path21.default.relative(core, result.outputPath)}`, "search");
+  logger.info(`Indexed ${result.records} page(s) into ${import_node_path22.default.relative(core, result.outputPath)}`, "search");
 };
 var warnIfIndexedSearchUsesAuth = async () => {
   if (!await isAuthEnabled()) {
@@ -3028,10 +3174,14 @@ var runCommandWithFilteredOutput = async ({
       cwd,
       env: {
         ...process.env,
+        // Astro sends usage data (commands, config, machine details) to Astro by default: turn it off
+        // for everyone using EventCatalog
+        ASTRO_TELEMETRY_DISABLED: "1",
         ...env
       },
       stdio: ["inherit", "pipe", "pipe"]
     });
+    const signals = stopChildWithParent(child);
     let stdoutBuffer = "";
     let stderrBuffer = "";
     const flush = (buffer, writer, isFinal = false) => {
@@ -3059,11 +3209,13 @@ var runCommandWithFilteredOutput = async ({
       stderrBuffer = flush(stderrBuffer, process.stderr);
     });
     child.on("error", (error) => {
+      signals.childClosed();
       reject(error);
     });
     child.on("close", (code) => {
       stdoutBuffer = flush(stdoutBuffer, process.stdout, true);
       stderrBuffer = flush(stderrBuffer, process.stderr, true);
+      if (signals.childClosed()) return;
       if (code === 0) {
         resolve2();
         return;
@@ -3114,10 +3266,10 @@ Upgrade now: npm i @eventcatalog/core@beta`;
   if (!installedVersion) return;
   const pkg = { name: "@eventcatalog/core", version: installedVersion };
   const notifier = (0, import_update_notifier.default)({ pkg, updateCheckInterval: 0 });
-  const message = getEventCatalogUpdateMessage(installedVersion, notifier.update?.latest);
-  if (message) {
+  const message2 = getEventCatalogUpdateMessage(installedVersion, notifier.update?.latest);
+  if (message2) {
     console.log(
-      (0, import_boxen2.default)(message, {
+      (0, import_boxen2.default)(message2, {
         padding: 1,
         margin: 1,
         align: "center",
@@ -3141,8 +3293,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_path21.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path21.default.join(dir, ".env") });
+  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 (options.debug) {
     logger.info("Debug mode enabled", "debug");
@@ -3189,7 +3341,9 @@ program.command("dev").description("Run development server of EventCatalog").opt
       });
       startDevPrewarm({
         port: prewarmPort,
-        paths: ["/ping", "/"]
+        // Renders the homepage before anyone opens it. Requests stop at the first response,
+        // so a probe path like /ping first would leave the homepage cold.
+        paths: ["/"]
       });
     }
     await runCommandWithFilteredOutput({
@@ -3201,7 +3355,8 @@ program.command("dev").description("Run development server of EventCatalog").opt
         CATALOG_DIR: core,
         EVENTCATALOG_DEV_MODE: "true",
         IGNORE_BUILD_ARTIFACTS: "true",
-        NODE_NO_WARNINGS: "1"
+        NODE_NO_WARNINGS: "1",
+        ...ASTRO_IN_FOREGROUND
       },
       shouldFilterLine: createAstroDevLineFilter(),
       transformLine: replaceAstroReadyVersionLine
@@ -3217,8 +3372,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_path21.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path21.default.join(dir, ".env") });
+  if (import_fs.default.existsSync(import_node_path22.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path22.default.join(dir, ".env") });
   }
   await verifyRequiredFieldsAreInCatalogConfigFile(dir);
   const config = await getEventCatalogConfigFile(dir);
@@ -3255,7 +3410,7 @@ program.command("build").description("Run build of EventCatalog").action(async (
   });
   if (await isIndexedSearchEnabled()) {
     await warnIfIndexedSearchUsesAuth();
-    const outDir = import_node_path21.default.resolve(dir, await getProjectOutDir());
+    const outDir = import_node_path22.default.resolve(dir, await getProjectOutDir());
     logger.info("Building indexed search...", "search");
     const result = await buildSearchIndex({
       projectDir: dir,
@@ -3263,7 +3418,7 @@ program.command("build").description("Run build of EventCatalog").action(async (
       config,
       isServer
     });
-    logger.info(`Indexed ${result.records} page(s) into ${import_node_path21.default.relative(dir, result.outputPath)}`, "search");
+    logger.info(`Indexed ${result.records} page(s) into ${import_node_path22.default.relative(dir, result.outputPath)}`, "search");
   }
 });
 var previewCatalog = async ({ command }) => {
@@ -3273,20 +3428,39 @@ var previewCatalog = async ({ command }) => {
     cwd: dir,
     env: {
       PROJECT_DIR: dir,
-      CATALOG_DIR: core
+      CATALOG_DIR: core,
+      ...ASTRO_IN_FOREGROUND
     },
     shouldFilterLine: createAstroLineFilter()
   });
 };
+var SERVER_BOOTSTRAP = `
+const entry = await import(process.argv[1]);
+const { server } = entry.startServer();
+globalThis[Symbol.for('eventcatalog.http-server')] = server.server;
+const start = process.env.EVENTCATALOG_START_PATH;
+if (start) {
+  server.server.once('listening', () => {
+    // Where the server listens (HOST can be one address only); loopback when it listens on every address
+    const { address, port } = server.server.address();
+    const host = ['0.0.0.0', '::'].includes(address) ? '127.0.0.1' : address.includes(':') ? '[' + address + ']' : address;
+    fetch('http://' + host + ':' + port + start).catch((error) => console.error('[eventcatalog] Could not start the server:', error.message));
+  });
+}
+`;
 var startServerCatalog = async () => {
-  const serverEntryPath = import_node_path21.default.join(dir, "dist", "server", "entry.mjs");
+  const serverEntryPath = import_node_path22.default.join(dir, "dist", "server", "entry.mjs");
+  const config = await getEventCatalogConfigFile(dir);
+  const base = (config?.base || "/").replace(/\/$/, "");
   await runCommandWithFilteredOutput({
     command: process.execPath,
-    args: [serverEntryPath],
+    args: ["--input-type=module", "-e", SERVER_BOOTSTRAP, (0, import_node_url2.pathToFileURL)(serverEntryPath).href],
     cwd: dir,
     env: {
       PROJECT_DIR: dir,
-      CATALOG_DIR: core
+      CATALOG_DIR: core,
+      ASTRO_NODE_AUTOSTART: "disabled",
+      EVENTCATALOG_START_PATH: `${base}/_eventcatalog/start`
     },
     shouldFilterLine: createAstroLineFilter()
   });
@@ -3294,20 +3468,21 @@ 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_path21.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path21.default.join(dir, ".env") });
+  if (import_fs.default.existsSync(import_node_path22.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path22.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_path21.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path21.default.join(dir, ".env") });
+  if (import_fs.default.existsSync(import_node_path22.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path22.default.join(dir, ".env") });
   }
   const isServerOutput = await isOutputServer();
   if (isServerOutput) {
-    await getLicenseStatus2(dir);
+    const license = await getLicenseStatus2(dir);
+    void log_build_default(dir, { command: "start", license });
     await startServerCatalog();
   } else {
     await previewCatalog({ command });
@@ -3316,22 +3491,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_path21.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path21.default.join(dir, ".env") });
+  if (import_fs.default.existsSync(import_node_path22.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path22.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_path21.default.join(dir, "exports");
+  const exportsDir = import_node_path22.default.join(dir, "exports");
   ensureDir(exportsDir);
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  const exportFile = import_node_path21.default.join(exportsDir, `catalog-${date}.json`);
+  const exportFile = import_node_path22.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_path21.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path21.default.join(dir, ".env") });
+  if (import_fs.default.existsSync(import_node_path22.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path22.default.join(dir, ".env") });
   }
   await generate(dir);
 });
@@ -3404,7 +3579,7 @@ var reportFederationProgress = (event, verbose = false) => {
       }
       return;
     case "hydrating":
-      logger.info(`Hydrating federated content into ${import_node_path21.default.relative(dir, event.outDir)}/...`, "federation");
+      logger.info(`Hydrating federated content into ${import_node_path22.default.relative(dir, event.outDir)}/...`, "federation");
       return;
     case "hydrate:cache":
       if (event.files === 1 || event.files % 25 === 0) {
@@ -3427,13 +3602,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_path21.default.relative(dir, event.result.lockPath)}`, "federation");
+      logger.info(`Recorded resolved source state in ${import_node_path22.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_path21.default.join(dir, ".env"))) {
-    import_dotenv.default.config({ path: import_node_path21.default.join(dir, ".env") });
+  if (import_fs.default.existsSync(import_node_path22.default.join(dir, ".env"))) {
+    import_dotenv.default.config({ path: import_node_path22.default.join(dir, ".env") });
   }
   logger.info("Starting federation...", "federation");
   let cleanedPreviousOutput = false;
@@ -3454,7 +3629,7 @@ program.addHelpText(
     Example: npx eventcatalog dev --debug -- --env=production --port=3000
   `
 );
-program.parseAsync().then(() => process.exit(0)).catch((err) => {
+program.parseAsync().then(() => process.exit()).catch((err) => {
   if (!(err instanceof FederationConflictError) && !(err instanceof FederationDiagnosticError)) console.error(err);
   process.exit(1);
 });