@eventcatalog/core 4.11.2 → 4.12.0-beta.1

package/dist/eventcatalog.cjs

@@ -31,21 +31,26 @@ var import_commander = require("commander");
 var import_node_child_process2 = require("child_process");
 var import_node_path19 = require("path");
 var import_node_http = __toESM(require("http"), 1);
-var import_fs3 = __toESM(require("fs"), 1);
+var import_fs = __toESM(require("fs"), 1);
 var import_node_path20 = __toESM(require("path"), 1);
-var import_node_url = require("url");
+var import_node_url2 = require("url");
+var import_node_module2 = require("module");
 
 // src/generate.js
-var import_node_path2 = __toESM(require("path"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
 
 // src/eventcatalog-config-file-utils.js
+var import_promises2 = require("fs/promises");
+var import_node_path2 = __toESM(require("path"), 1);
+var import_uuid = require("uuid");
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+
+// eventcatalog/integrations/config-loader.mjs
 var import_promises = require("fs/promises");
 var import_node_fs = require("fs");
 var import_node_path = __toESM(require("path"), 1);
-var import_uuid = require("uuid");
-var import_url = require("url");
+var import_node_url = require("url");
 var import_node_os = require("os");
-var import_gray_matter = __toESM(require("gray-matter"), 1);
 async function cleanup(projectDirectory) {
   const filePath = import_node_path.default.join(projectDirectory, "eventcatalog.config.mjs");
   if ((0, import_node_fs.existsSync)(filePath)) {
@@ -93,7 +98,7 @@ var getEventCatalogConfigFile = async (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_url.pathToFileURL)(configFilePath).href}?t=${Date.now()}`;
+    const configFileURL = `${(0, import_node_url.pathToFileURL)(configFilePath).href}?t=${Date.now()}`;
     const config = await import(
       /* @vite-ignore */
       configFileURL
@@ -106,10 +111,12 @@ var getEventCatalogConfigFile = async (projectDirectory) => {
     }
   }
 };
+
+// src/eventcatalog-config-file-utils.js
 var writeEventCatalogConfigFile = async (projectDirectory, newConfig) => {
   try {
-    const configFilePath = import_node_path.default.join(projectDirectory, "eventcatalog.config.js");
-    let content = await (0, import_promises.readFile)(configFilePath, "utf8");
+    const configFilePath = import_node_path2.default.join(projectDirectory, "eventcatalog.config.js");
+    let content = await (0, import_promises2.readFile)(configFilePath, "utf8");
     const startIndex = content.indexOf("export default {");
     if (startIndex === -1) {
       return;
@@ -125,7 +132,7 @@ var writeEventCatalogConfigFile = async (projectDirectory, newConfig) => {
   ${key}: ${valueString},` + content.slice(insertPosition);
       }
     });
-    await (0, import_promises.writeFile)(configFilePath, content);
+    await (0, import_promises2.writeFile)(configFilePath, content);
   } finally {
     await cleanup(projectDirectory);
   }
@@ -144,7 +151,7 @@ var verifyRequiredFieldsAreInCatalogConfigFile = async (projectDirectory) => {
 var import_picocolors = __toESM(require("picocolors"), 1);
 
 // package.json
-var version = "4.11.2";
+var version = "4.12.0-beta.1";
 
 // src/constants.ts
 var VERSION = version;
@@ -237,7 +244,7 @@ var generate = async (PROJECT_DIRECTORY) => {
       let plugin = generator[0];
       const pluginConfig = generator[1];
       if (plugin.startsWith("./")) {
-        plugin = import_node_path2.default.join(PROJECT_DIRECTORY, plugin);
+        plugin = import_node_path3.default.join(PROJECT_DIRECTORY, plugin);
       }
       if (plugin.includes("<rootDir>")) {
         plugin = plugin.replace("<rootDir>", PROJECT_DIRECTORY);
@@ -300,8 +307,8 @@ async function raiseEvent(eventData) {
 // src/analytics/count-resources.js
 var import_glob = require("glob");
 var import_node_crypto = require("crypto");
-var import_promises2 = require("fs/promises");
-var import_node_path3 = __toESM(require("path"), 1);
+var import_promises3 = require("fs/promises");
+var import_node_path4 = __toESM(require("path"), 1);
 var RESOURCE_PATTERNS = {
   adrs: ["**/adrs/*/index.@(md|mdx)"],
   agents: ["**/agents/*/index.@(md|mdx)"],
@@ -353,7 +360,7 @@ async function hashCatalogContent(projectDir) {
   for (const file of [...files].sort()) {
     try {
       hash.update(file);
-      hash.update(await (0, import_promises2.readFile)(import_node_path3.default.join(projectDir, file)));
+      hash.update(await (0, import_promises3.readFile)(import_node_path4.default.join(projectDir, file)));
     } catch {
     }
   }
@@ -473,340 +480,18 @@ var log_build_default = main;
 
 // src/watcher.js
 var import_watcher = __toESM(require("@parcel/watcher"), 1);
-var import_node_fs2 = __toESM(require("fs"), 1);
-
-// src/map-catalog-to-astro.js
-var import_node_path4 = __toESM(require("path"), 1);
-var CUSTOM_PAGE_EXTENSIONS = [".astro", ".ts", ".js", ".mjs"];
-var COLLECTION_KEYS = [
-  "agents",
-  "events",
-  "commands",
-  "services",
-  "domains",
-  "flows",
-  "pages",
-  "changelogs",
-  "queries",
-  "channels",
-  "ubiquitousLanguages",
-  "dependencies"
-];
-function mapCatalogToAstro({ filePath, astroDir, projectDir }) {
-  const relativeFilePath = removeBasePath(filePath, projectDir);
-  if (isLikeC4Source(relativeFilePath)) {
-    return [];
-  }
-  if (!isCatalogRelated(relativeFilePath)) {
-    return [];
-  }
-  const customPageTargetPaths = getCustomPageTargetPaths(relativeFilePath, astroDir);
-  if (customPageTargetPaths) {
-    return customPageTargetPaths;
-  }
-  const baseTargetPaths = getBaseTargetPaths(relativeFilePath);
-  const relativeTargetPath = getRelativeTargetPath(relativeFilePath);
-  return baseTargetPaths.map((base) => import_node_path4.default.join(astroDir, base, relativeTargetPath));
-}
-function removeBasePath(fullPath, basePath) {
-  const relativePath = import_node_path4.default.relative(basePath, fullPath);
-  return relativePath.startsWith("..") ? fullPath : relativePath;
-}
-function isCollectionKey(key) {
-  return COLLECTION_KEYS.includes(key);
-}
-function isLikeC4Source(filePath) {
-  return filePath.endsWith(".c4") || filePath.endsWith(".likec4");
-}
-var hasExtension = (str) => /\.[a-zA-Z0-9]{2,}$/.test(str);
-function getCustomPageTargetPaths(filePath, astroDir) {
-  const filePathArr = filePath.split(import_node_path4.default.sep).filter(Boolean);
-  if (filePathArr[0] !== "pages") {
-    return null;
-  }
-  const customPagePath = import_node_path4.default.join(astroDir, "src", "custom-pages", ...filePathArr.slice(1));
-  if (CUSTOM_PAGE_EXTENSIONS.includes(import_node_path4.default.extname(filePath).toLowerCase())) {
-    return [customPagePath];
-  }
-  if (!hasExtension(filePath)) {
-    return [customPagePath, import_node_path4.default.join(astroDir, "public", "generated", ...filePathArr)];
-  }
-  return [import_node_path4.default.join(astroDir, "public", "generated", ...filePathArr)];
-}
-function isCatalogRelated(filePath) {
-  const filePathArr = filePath.split(import_node_path4.default.sep).filter(Boolean);
-  if ([
-    "eventcatalog.config.js",
-    // config file at root
-    "eventcatalog.styles.css",
-    // custom styles file at root
-    "components",
-    // custom components
-    "snippets",
-    // custom snippets
-    "public",
-    // public assets
-    ".env",
-    // env file
-    ...COLLECTION_KEYS
-  ].includes(filePathArr[0])) {
-    return true;
-  }
-  return false;
-}
-function getBaseTargetPaths(filePath) {
-  const filePathArr = filePath.split(import_node_path4.default.sep).filter(Boolean);
-  if (isCollectionKey(filePathArr[0])) {
-    if (hasExtension(filePath)) {
-      return [import_node_path4.default.join("public", "generated")];
-    }
-    return [import_node_path4.default.join("public", "generated")];
-  }
-  if (filePathArr[0] == "components") {
-    return [import_node_path4.default.join("src", "custom-defined-components")];
-  }
-  if (filePathArr[0] == "snippets") {
-    return [import_node_path4.default.join("src")];
-  }
-  if (filePathArr[0] == "public") {
-    return [import_node_path4.default.join("public")];
-  }
-  return [import_node_path4.default.join("/")];
-}
-function getRelativeTargetPath(filePath) {
-  const filePathArr = filePath.split(import_node_path4.default.sep).filter(Boolean);
-  if (filePathArr[0] == "public" || filePathArr[0] == "components") {
-    filePathArr.shift();
-  }
-  if (filePathArr[0] == "snippets") {
-    return import_node_path4.default.join("snippets", ...filePathArr.slice(1));
-  }
-  const relativePath = [];
-  for (let i = filePathArr.length - 1; i >= 0; i--) {
-    relativePath.unshift(filePathArr[i]);
-    if (isCollectionKey(filePathArr[i]) && filePathArr[i] != "snippets") break;
-  }
-  return import_node_path4.default.join(...relativePath);
-}
-
-// src/watcher.js
-var import_rimraf = require("rimraf");
 var toPosixPath = (p) => p.replace(/\\/g, "/");
-async function watch(projectDirectory, catalogDirectory, callback = void 0) {
-  const subscription = await import_watcher.default.subscribe(
-    projectDirectory,
-    compose(
-      /**
-       * @param {Error|null} err
-       * @param {Event[]} events
-       * @returns {unknown}
-       */
-      (err, events) => {
-        if (err) {
-          return;
-        }
-        for (let event of events) {
-          const { path: filePath, type } = event;
-          if (filePath.endsWith(".lock")) {
-            continue;
-          }
-          if ((filePath.endsWith(".mdx") || filePath.endsWith(".md")) && !filePath.includes("snippets")) {
-            continue;
-          }
-          const astroPaths = mapCatalogToAstro({
-            filePath,
-            astroDir: catalogDirectory,
-            projectDir: projectDirectory
-          });
-          for (const astroPath of astroPaths) {
-            switch (type) {
-              case "create":
-              case "update": {
-                let stat;
-                try {
-                  stat = import_node_fs2.default.statSync(filePath);
-                } catch (err2) {
-                  if (err2.code === "ENOENT") break;
-                  throw err2;
-                }
-                if (stat.isDirectory()) {
-                  import_node_fs2.default.mkdirSync(astroPath, { recursive: true });
-                } else {
-                  retryEPERM(import_node_fs2.default.cpSync)(filePath, astroPath);
-                }
-                break;
-              }
-              case "delete":
-                retryEPERM(import_rimraf.rimrafSync)(astroPath);
-                break;
-            }
-          }
-        }
-      },
-      callback
-    ),
-    {
-      ignore: [`**/${toPosixPath(catalogDirectory)}/!(${toPosixPath(projectDirectory)})**`]
-    }
-  );
+async function watch(projectDirectory, catalogDirectory, callback = () => {
+}) {
+  const subscription = await import_watcher.default.subscribe(projectDirectory, callback, {
+    ignore: [`**/${toPosixPath(catalogDirectory)}/!(${toPosixPath(projectDirectory)})**`]
+  });
   return () => subscription.unsubscribe();
 }
-function compose(...fns) {
-  return function(err, events) {
-    fns.filter(Boolean).forEach((fn, i) => {
-      try {
-        fn(err, events);
-      } catch (error) {
-        console.error({ error });
-        throw error;
-      }
-    });
-  };
-}
-var MAX_RETRIES = 5;
-var DELAY_MS = 100;
-function retryEPERM(fn) {
-  return (...args) => {
-    let retries = 0;
-    while (retries < MAX_RETRIES) {
-      try {
-        return fn(...args);
-      } catch (err) {
-        if (err.code !== "EPERM") throw err;
-        setTimeout(() => {
-        }, DELAY_MS);
-        retries += 1;
-      }
-    }
-  };
-}
-
-// src/catalog-to-astro-content-directory.js
-var import_glob2 = require("glob");
-var path6 = __toESM(require("path"), 1);
-var import_fs = __toESM(require("fs"), 1);
-var import_url2 = require("url");
-var import_node_os2 = __toESM(require("os"), 1);
-
-// src/custom-components.js
-var import_promises3 = __toESM(require("fs/promises"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
-var isCustomComponentPath = (projectDirectory, filePath) => {
-  const [rootDirectory, childDirectory] = import_node_path5.default.relative(projectDirectory, filePath).split(import_node_path5.default.sep);
-  return rootDirectory === "components" || rootDirectory === "federated" && childDirectory === "components";
-};
-var readDirectory = async (directory) => {
-  try {
-    return await import_promises3.default.readdir(directory, { withFileTypes: true });
-  } catch (error) {
-    if (error.code === "ENOENT") return [];
-    throw error;
-  }
-};
-var mergeDirectory = async (sourceDirectory, destinationDirectory) => {
-  for (const entry of await readDirectory(sourceDirectory)) {
-    const sourcePath = import_node_path5.default.join(sourceDirectory, entry.name);
-    const destinationPath = import_node_path5.default.join(destinationDirectory, entry.name);
-    if (entry.isDirectory()) {
-      const destinationEntry = await import_promises3.default.stat(destinationPath).catch((error) => {
-        if (error.code === "ENOENT") return void 0;
-        throw error;
-      });
-      if (destinationEntry && !destinationEntry.isDirectory()) {
-        await import_promises3.default.rm(destinationPath, { recursive: true, force: true });
-      }
-      await import_promises3.default.mkdir(destinationPath, { recursive: true });
-      await mergeDirectory(sourcePath, destinationPath);
-      continue;
-    }
-    await import_promises3.default.rm(destinationPath, { recursive: true, force: true });
-    await import_promises3.default.copyFile(sourcePath, destinationPath);
-  }
-};
-var syncCustomComponents = async (projectDirectory, catalogDirectory) => {
-  const destinationDirectory = import_node_path5.default.join(catalogDirectory, "src", "custom-defined-components");
-  const destinationParent = import_node_path5.default.dirname(destinationDirectory);
-  await import_promises3.default.mkdir(destinationParent, { recursive: true });
-  const stagingDirectory = await import_promises3.default.mkdtemp(import_node_path5.default.join(destinationParent, ".custom-defined-components.staging-"));
-  try {
-    await mergeDirectory(import_node_path5.default.join(projectDirectory, "federated", "components"), stagingDirectory);
-    await mergeDirectory(import_node_path5.default.join(projectDirectory, "components"), stagingDirectory);
-    await import_promises3.default.rm(destinationDirectory, { recursive: true, force: true });
-    await import_promises3.default.rename(stagingDirectory, destinationDirectory);
-  } finally {
-    await import_promises3.default.rm(stagingDirectory, { recursive: true, force: true });
-  }
-};
-
-// src/catalog-to-astro-content-directory.js
-var __filename2 = (0, import_url2.fileURLToPath)(importMetaUrl);
-var rootPkg = path6.resolve(path6.dirname(__filename2), "../");
-var copyFiles = async (source, target) => {
-  const files = await (0, import_glob2.glob)(path6.join(source, "**"), {
-    nodir: true,
-    windowsPathsNoEscape: import_node_os2.default.platform() == "win32",
-    ignore: ["node_modules/**", "**/dist/**", "**/teams", "**/users", "**/*.mdx", "**/*.md", "**/package.json", "**/Dockerfile"]
-  });
-  const snippets = await (0, import_glob2.glob)(path6.join(source, "snippets/**/*.mdx"), {
-    nodir: true,
-    windowsPathsNoEscape: import_node_os2.default.platform() == "win32"
-  });
-  if (snippets.length > 0) {
-    files.push(...snippets);
-  }
-  if (import_fs.default.existsSync(path6.join(source, ".env"))) {
-    files.push(path6.join(source, ".env"));
-  }
-  for (const file of files) {
-    if (isCustomComponentPath(source, file)) continue;
-    mapCatalogToAstro({
-      filePath: file,
-      astroDir: target,
-      projectDir: source
-    }).map((astroPath) => {
-      import_fs.default.cpSync(file, astroPath);
-      return { oldPath: file, newPath: astroPath };
-    });
-  }
-};
-var clearCustomPages = async (target) => {
-  const customPagesDir = path6.join(target, "src", "custom-pages");
-  if (import_fs.default.existsSync(customPagesDir)) import_fs.default.rmSync(customPagesDir, { recursive: true });
-  const staleCodeFiles = await (0, import_glob2.glob)(path6.join(target, "public", "generated", "pages", "**/*.{astro,ts,js,mjs}"), {
-    nodir: true,
-    windowsPathsNoEscape: import_node_os2.default.platform() == "win32"
-  });
-  for (const file of staleCodeFiles) {
-    import_fs.default.rmSync(file);
-  }
-};
-var removeGeneratedLikeC4Sources = async (target) => {
-  const generatedDir = path6.join(target, "public", "generated");
-  const files = await (0, import_glob2.glob)(path6.join(generatedDir, "**/*.{c4,likec4}"), {
-    nodir: true,
-    windowsPathsNoEscape: import_node_os2.default.platform() == "win32"
-  });
-  for (const file of files) {
-    import_fs.default.rmSync(file);
-  }
-};
-var catalogToAstro = async (source, astroDir) => {
-  const astroContentDir = path6.join(astroDir, "src/content/");
-  if (import_fs.default.existsSync(astroContentDir)) import_fs.default.rmSync(astroContentDir, { recursive: true });
-  import_fs.default.mkdirSync(astroContentDir);
-  await verifyRequiredFieldsAreInCatalogConfigFile(source);
-  if (!import_fs.default.existsSync(path6.join(source, "eventcatalog.styles.css"))) {
-    import_fs.default.writeFileSync(path6.join(source, "eventcatalog.styles.css"), "");
-  }
-  await clearCustomPages(astroDir);
-  await removeGeneratedLikeC4Sources(astroDir);
-  await syncCustomComponents(source, astroDir);
-  await copyFiles(source, astroDir);
-};
 
 // src/resolve-catalog-dependencies.js
-var import_node_path6 = __toESM(require("path"), 1);
-var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+var import_node_fs2 = __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);
@@ -814,11 +499,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_path5.default.join(catalogDir, "dependencies");
+  if (import_node_fs2.default.existsSync(dependenciesDir)) {
+    import_node_fs2.default.rmSync(dependenciesDir, { recursive: true, force: true });
   }
-  import_node_fs3.default.mkdirSync(dependenciesDir, { recursive: true });
+  import_node_fs2.default.mkdirSync(dependenciesDir, { recursive: true });
   const resourceTypes = Object.keys(dependencies);
   for (const resourceType of resourceTypes) {
     for (const dependency of dependencies[resourceType]) {
@@ -838,9 +523,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_path5.default.join(dependenciesDir, resourceType, dependency.id, `index.md`);
+      import_node_fs2.default.mkdirSync(import_node_path5.default.dirname(resourceFile), { recursive: true });
+      import_node_fs2.default.writeFileSync(resourceFile, markdown);
     }
   }
   return;
@@ -850,8 +535,8 @@ var resolve_catalog_dependencies_default = async (catalogDir, core2) => {
 var import_boxen = __toESM(require("boxen"), 1);
 
 // src/features.ts
-var import_node_path7 = require("path");
-var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path6 = require("path");
+var import_node_fs3 = __toESM(require("fs"), 1);
 var getProjectOutDir = async () => {
   const config = await getEventCatalogConfigFile(process.env.PROJECT_DIR || "");
   return config?.outDir || "dist";
@@ -866,7 +551,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_fs3.default.existsSync((0, import_node_path6.join)(directory, "eventcatalog.auth.js"));
   return hasAuthConfig;
 };
 
@@ -875,11 +560,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_glob3 = require("glob");
-var import_node_os3 = __toESM(require("os"), 1);
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_glob2 = require("glob");
+var import_node_os2 = __toESM(require("os"), 1);
 var import_gray_matter3 = __toESM(require("gray-matter"), 1);
-var import_node_path8 = __toESM(require("path"), 1);
+var import_node_path7 = __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());
@@ -888,8 +573,8 @@ 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 messages = await (0, import_glob3.glob)(
+  const PROJECT_DIR = import_node_path7.default.join(dir2 || process.env.PROJECT_DIR);
+  const messages = await (0, import_glob2.glob)(
     [
       "**/events/*/index.mdx",
       "**/events/*/index.md",
@@ -911,11 +596,11 @@ var message_channels_to_service_channels_default = async (dir2) => {
       cwd: PROJECT_DIR,
       absolute: true,
       nodir: true,
-      windowsPathsNoEscape: import_node_os3.default.platform() == "win32",
+      windowsPathsNoEscape: import_node_os2.default.platform() == "win32",
       ignore: ["node_modules/**", "**/dist/**", "**/teams", "**/users", "**/package.json", "**/Dockerfile"]
     }
   );
-  const services = await (0, import_glob3.glob)(
+  const services = await (0, import_glob2.glob)(
     [
       "**/services/*/index.mdx",
       "**/services/*/index.md",
@@ -928,7 +613,7 @@ var message_channels_to_service_channels_default = async (dir2) => {
     }
   );
   const messagesWithChannels = messages.reduce((acc, message) => {
-    const file = import_node_fs5.default.readFileSync(message, "utf8");
+    const file = import_node_fs4.default.readFileSync(message, "utf8");
     const { data } = (0, import_gray_matter3.default)(file);
     if (data.channels?.length > 0) {
       acc.push({
@@ -942,7 +627,7 @@ 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_fs4.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 isReceiving = data.receives?.some(
@@ -957,7 +642,7 @@ 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_fs4.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)) ?? [];
@@ -977,14 +662,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_fs4.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");
+    const file = import_node_fs4.default.readFileSync(message.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_fs4.default.writeFileSync(message.path, import_gray_matter3.default.stringify(parsed.content, newData));
   }
   console.log("\u2714 Channels migrated to new services API");
 };
@@ -996,11 +681,11 @@ var runMigrations = async (dir2) => {
 
 // eventcatalog/src/enterprise/fields/field-indexer.ts
 var import_node_path9 = __toESM(require("path"), 1);
-var import_node_fs7 = __toESM(require("fs"), 1);
+var import_node_fs6 = __toESM(require("fs"), 1);
 
 // eventcatalog/src/enterprise/fields/fields-db.ts
 var import_sql = __toESM(require("sql.js"), 1);
-var import_node_fs6 = __toESM(require("fs"), 1);
+var import_node_fs5 = __toESM(require("fs"), 1);
 var SCHEMA_SQL = `
   CREATE TABLE IF NOT EXISTS fields (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -1069,13 +754,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_fs5.default.existsSync(dbPath)) {
+      import_node_fs5.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_fs5.default.existsSync(dbPath)) {
+      const buffer = import_node_fs5.default.readFileSync(dbPath);
       db = new SQL.Database(buffer);
     } else {
       db = new SQL.Database();
@@ -1136,7 +821,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_fs5.default.writeFileSync(this.dbPath, buffer);
   }
   queryFields(params) {
     const {
@@ -1361,22 +1046,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 path19 = prefix ? `${prefix}.${field.name}` : field.name;
     const isOptional = Array.isArray(field.type) && field.type.includes("null");
     const typeName = getAvroTypeName(field.type);
     fields.push({
-      path: path20,
+      path: path19,
       type: typeName,
       description: field.doc || "",
       required: !isOptional
     });
     const innerType = Array.isArray(field.type) ? field.type.find((t) => typeof t === "object" && t.type === "record") : typeof field.type === "object" && field.type.type === "record" ? field.type : null;
     if (innerType) {
-      walkAvroRecord(innerType, path20, fields);
+      walkAvroRecord(innerType, path19, fields);
     }
     const arrayType = Array.isArray(field.type) ? field.type.find((t) => typeof t === "object" && t.type === "array") : typeof field.type === "object" && field.type.type === "array" ? field.type : null;
     if (arrayType && typeof arrayType.items === "object" && arrayType.items.type === "record") {
-      walkAvroRecord(arrayType.items, `${path20}[]`, fields);
+      walkAvroRecord(arrayType.items, `${path19}[]`, fields);
     }
   }
 }
@@ -1407,32 +1092,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 path19 = prefix ? `${prefix}.${name}` : name;
     const isRequired = requiredList.includes(name);
     if (prop.$ref) {
       const resolved = resolveLocalRef(prop.$ref, rootSchema);
       if (resolved) {
         const rawRefType = resolved.type || "object";
         const type2 = Array.isArray(rawRefType) ? [...rawRefType].sort().join(" | ") : rawRefType;
-        fields.push({ path: path20, type: type2, description: resolved.description || "", required: isRequired });
+        fields.push({ path: path19, type: type2, description: resolved.description || "", required: isRequired });
         if (resolved.properties) {
-          walkJsonSchema(resolved, path20, resolved.required || [], rootSchema, fields);
+          walkJsonSchema(resolved, path19, resolved.required || [], rootSchema, fields);
         }
       } else {
-        fields.push({ path: path20, type: "$ref", description: "", required: isRequired });
+        fields.push({ path: path19, type: "$ref", description: "", required: isRequired });
       }
       continue;
     }
     const rawType = prop.type || (prop.enum ? "enum" : prop.$ref ? "$ref" : "object");
     const typeList = Array.isArray(rawType) ? rawType : [rawType];
     const type = Array.isArray(rawType) ? [...rawType].sort().join(" | ") : rawType;
-    fields.push({ path: path20, type, description: prop.description || "", required: isRequired });
+    fields.push({ path: path19, type, description: prop.description || "", required: isRequired });
     if (typeList.includes("object") && prop.properties) {
-      walkJsonSchema(prop, path20, prop.required || [], rootSchema, fields);
+      walkJsonSchema(prop, path19, prop.required || [], rootSchema, fields);
     }
     if (typeList.includes("array") && prop.items) {
       if (prop.items.type === "object" && prop.items.properties) {
-        walkJsonSchema(prop.items, `${path20}[]`, prop.items.required || [], rootSchema, fields);
+        walkJsonSchema(prop.items, `${path19}[]`, prop.items.required || [], rootSchema, fields);
       }
     }
   }
@@ -1448,6 +1133,20 @@ function resolveLocalRef(ref, rootSchema) {
   return current;
 }
 
+// eventcatalog/integrations/runtime-paths.mjs
+var import_node_path8 = __toESM(require("path"), 1);
+function getRuntimePaths(projectDirectory, runtimeDirectory) {
+  const project = import_node_path8.default.resolve(projectDirectory);
+  const cacheDirectory = import_node_path8.default.join(project, ".astro");
+  const runtime = runtimeDirectory ? import_node_path8.default.resolve(runtimeDirectory) : import_node_path8.default.join(cacheDirectory, "eventcatalog");
+  return {
+    projectDirectory: project,
+    cacheDirectory,
+    runtimeDirectory: runtime,
+    fieldsDatabasePath: import_node_path8.default.join(runtime, ".eventcatalog", "fields.db")
+  };
+}
+
 // eventcatalog/src/enterprise/fields/field-indexer.ts
 function detectFormat(fileName) {
   const ext = import_node_path9.default.extname(fileName).toLowerCase();
@@ -1458,10 +1157,10 @@ function detectFormat(fileName) {
 async function buildFieldsIndex(catalogDir, outputDir) {
   const sdkModule = await import("@eventcatalog/sdk");
   const sdk = sdkModule.default(catalogDir);
-  const dbDir = import_node_path9.default.join(outputDir || catalogDir, ".eventcatalog");
-  const dbPath = import_node_path9.default.join(dbDir, "fields.db");
-  if (!import_node_fs7.default.existsSync(dbDir)) {
-    import_node_fs7.default.mkdirSync(dbDir, { recursive: true });
+  const { fieldsDatabasePath: dbPath } = getRuntimePaths(catalogDir, outputDir || catalogDir);
+  const dbDir = import_node_path9.default.dirname(dbPath);
+  if (!import_node_fs6.default.existsSync(dbDir)) {
+    import_node_fs6.default.mkdirSync(dbDir, { recursive: true });
   }
   const db = await FieldsDatabase.create(dbPath, { recreate: true });
   const warnings = [];
@@ -1546,7 +1245,7 @@ async function buildFieldsIndex(catalogDir, outputDir) {
 // src/search-indexer.ts
 var import_promises4 = __toESM(require("fs/promises"), 1);
 var import_node_path10 = __toESM(require("path"), 1);
-var import_glob4 = require("glob");
+var import_glob3 = require("glob");
 var import_gray_matter4 = __toESM(require("gray-matter"), 1);
 var RESOURCE_COLLECTIONS = {
   adrs: { docsPath: "adrs", type: "Architecture Decision" },
@@ -1566,6 +1265,7 @@ var RESOURCE_COLLECTIONS = {
 var IGNORED_GLOBS = [
   "**/.git/**",
   "**/.eventcatalog-core/**",
+  "**/.astro/**",
   "**/dist/**",
   "**/node_modules/**",
   "**/public/**",
@@ -1760,7 +1460,7 @@ var collectSearchRecords = async ({
   projectDir,
   config
 }) => {
-  const files = await (0, import_glob4.glob)("**/*.{md,mdx}", {
+  const files = await (0, import_glob3.glob)("**/*.{md,mdx}", {
     cwd: projectDir,
     absolute: true,
     nodir: true,
@@ -1872,122 +1572,79 @@ ${errors.join("\n")}`);
   };
 };
 
-// src/core-node-modules.ts
-var import_fs2 = __toESM(require("fs"), 1);
+// src/catalog-runtime.ts
+var import_node_fs7 = __toESM(require("fs"), 1);
 var import_node_path11 = __toESM(require("path"), 1);
-var isDirectory = (directory) => {
-  try {
-    return import_fs2.default.statSync(directory).isDirectory();
-  } catch (error) {
-    return false;
-  }
-};
-var hasAstroDependency = (nodeModulesDirectory) => {
-  const astroBin = process.platform === "win32" ? "astro.cmd" : "astro";
-  return import_fs2.default.existsSync(import_node_path11.default.join(nodeModulesDirectory, "astro", "package.json")) || import_fs2.default.existsSync(import_node_path11.default.join(nodeModulesDirectory, ".bin", astroBin));
-};
-var isSymbolicLink = (targetPath) => {
-  try {
-    return import_fs2.default.lstatSync(targetPath).isSymbolicLink();
-  } catch (error) {
-    return false;
-  }
-};
-var isSameDirectory = (a, b) => {
-  try {
-    return import_fs2.default.realpathSync.native(a) === import_fs2.default.realpathSync.native(b);
-  } catch (error) {
-    return false;
-  }
-};
-var resolveInstalledCoreNodeModules = (currentDir2) => {
-  const candidates = [];
-  const seen = /* @__PURE__ */ new Set();
-  const addCandidate = (candidate) => {
-    const resolvedCandidate = import_node_path11.default.resolve(candidate);
-    if (!seen.has(resolvedCandidate)) {
-      candidates.push(resolvedCandidate);
-      seen.add(resolvedCandidate);
-    }
-  };
-  addCandidate(import_node_path11.default.resolve(currentDir2, "..", "node_modules"));
-  let directory = import_node_path11.default.resolve(currentDir2);
-  while (true) {
-    if (import_node_path11.default.basename(directory) === "node_modules") {
-      addCandidate(directory);
-    }
-    addCandidate(import_node_path11.default.join(directory, "node_modules"));
-    const parentDirectory = import_node_path11.default.dirname(directory);
-    if (parentDirectory === directory) {
-      break;
-    }
-    directory = parentDirectory;
-  }
-  return candidates.find((candidate) => isDirectory(candidate) && hasAstroDependency(candidate)) ?? candidates.find(isDirectory);
-};
-var linkCoreNodeModules = ({
-  coreNodeModules,
-  installedCoreNodeModules
-}) => {
-  if (!installedCoreNodeModules) return;
-  if (isSymbolicLink(coreNodeModules)) {
-    if (isSameDirectory(coreNodeModules, installedCoreNodeModules)) {
-      return;
-    }
-    import_fs2.default.unlinkSync(coreNodeModules);
-  } else if (import_fs2.default.existsSync(coreNodeModules)) {
-    return;
+var import_node_module = require("module");
+var require2 = (0, import_node_module.createRequire)(importMetaUrl);
+var writeIfChanged = (file, content) => {
+  if (import_node_fs7.default.existsSync(file) && import_node_fs7.default.readFileSync(file, "utf8") === content) return;
+  import_node_fs7.default.mkdirSync(import_node_path11.default.dirname(file), { recursive: true });
+  import_node_fs7.default.writeFileSync(file, content);
+};
+var importPath = (file) => file.replace(/\\/g, "/");
+var clearCatalogCache = (projectDirectory) => {
+  const { cacheDirectory } = getRuntimePaths(projectDirectory);
+  import_node_fs7.default.rmSync(cacheDirectory, { recursive: true, force: true });
+};
+var prepareCatalogRuntime = ({ projectDirectory, catalogDirectory, packageDirectory }) => {
+  const runtime = import_node_path11.default.resolve(catalogDirectory);
+  const source = import_node_path11.default.resolve(packageDirectory);
+  const project = import_node_path11.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_fs7.default.mkdirSync(runtime, { recursive: true });
+  writeIfChanged(
+    import_node_path11.default.join(runtime, "content.config.ts"),
+    `export { collections } from ${JSON.stringify(importPath(import_node_path11.default.join(source, "src/content.config.ts")))};
+`
+  );
+  const packageTsconfig = JSON.parse(import_node_fs7.default.readFileSync(import_node_path11.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_path11.default.resolve(source, target)))
+    ])
+  );
+  paths["@config"] = [importPath(import_node_path11.default.join(project, "eventcatalog.config.js"))];
+  paths["@catalog/styles"] = [importPath(import_node_path11.default.join(project, "eventcatalog.styles.css"))];
+  paths["@catalog/components/*"] = [
+    importPath(import_node_path11.default.join(project, "components/*")),
+    importPath(import_node_path11.default.join(project, "federated/components/*"))
+  ];
+  paths["@catalog/snippets/*"] = [importPath(import_node_path11.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"))];
   }
-  import_fs2.default.symlinkSync(installedCoreNodeModules, coreNodeModules, process.platform === "win32" ? "junction" : "dir");
-};
-
-// src/copy-core.ts
-var import_node_fs8 = __toESM(require("fs"), 1);
-var import_node_path12 = __toESM(require("path"), 1);
-var IGNORED_CORE_DIRECTORIES = /* @__PURE__ */ new Set([".astro", "dist", "node_modules", "__tests__"]);
-var COLOCATED_TEST_SUFFIXES = [
-  ".spec.js",
-  ".spec.jsx",
-  ".spec.cjs",
-  ".spec.mjs",
-  ".spec.ts",
-  ".spec.tsx",
-  ".spec.cts",
-  ".spec.mts",
-  ".test.js",
-  ".test.jsx",
-  ".test.cjs",
-  ".test.mjs",
-  ".test.ts",
-  ".test.tsx",
-  ".test.cts",
-  ".test.mts"
-];
-var isColocatedTestFile = (fileName) => COLOCATED_TEST_SUFFIXES.some((suffix) => fileName.endsWith(suffix));
-var shouldCopyCoreEntry = (sourceRoot, sourcePath) => {
-  const relativePath = import_node_path12.default.relative(sourceRoot, sourcePath);
-  if (relativePath === "") return true;
-  const pathParts = relativePath.split(import_node_path12.default.sep);
-  if (pathParts.some((part) => IGNORED_CORE_DIRECTORIES.has(part))) return false;
-  const fileName = pathParts[pathParts.length - 1] ?? "";
-  return !isColocatedTestFile(fileName);
-};
-var PRUNE_SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([".astro", "dist", "node_modules"]);
-var pruneExcludedCoreEntries = (coreDir) => {
-  if (!import_node_fs8.default.existsSync(coreDir)) return;
-  const visit = (directory) => {
-    for (const entry of import_node_fs8.default.readdirSync(directory, { withFileTypes: true })) {
-      const entryPath = import_node_path12.default.join(directory, entry.name);
-      if (entry.name === "__tests__" || isColocatedTestFile(entry.name)) {
-        import_node_fs8.default.rmSync(entryPath, { recursive: true, force: true });
-        continue;
-      }
-      if (entry.isDirectory() && !PRUNE_SKIPPED_DIRECTORIES.has(entry.name)) {
-        visit(entryPath);
-      }
-    }
-  };
-  visit(coreDir);
+  writeIfChanged(
+    import_node_path11.default.join(runtime, "tsconfig.json"),
+    JSON.stringify(
+      {
+        extends: importPath(import_node_path11.default.join(source, "tsconfig.json")),
+        compilerOptions: {
+          baseUrl: ".",
+          paths,
+          typeRoots: [
+            importPath(import_node_path11.default.join(project, "node_modules/@types")),
+            importPath(import_node_path11.default.join(source, "../node_modules/@types")),
+            importPath(import_node_path11.default.join(source, "../node_modules")),
+            importPath(import_node_path11.default.join(project, "node_modules"))
+          ]
+        },
+        include: [
+          importPath(import_node_path11.default.join(project, ".astro/types.d.ts")),
+          "content.config.ts",
+          importPath(import_node_path11.default.join(project, "components/**/*")),
+          importPath(import_node_path11.default.join(source, "src/**/*"))
+        ],
+        // Keep legacy generated files out of checks on an existing checkout.
+        exclude: (packageTsconfig.exclude ?? []).map((entry) => importPath(import_node_path11.default.resolve(source, entry)))
+      },
+      null,
+      2
+    ) + "\n"
+  );
 };
 
 // eventcatalog/src/plugins/empty-collection-warning.mjs
@@ -2061,6 +1718,20 @@ var createAstroDevLineFilter = () => {
   };
 };
 
+// src/astro-config-path.ts
+var import_node_path12 = __toESM(require("path"), 1);
+var getAstroConfigPath = (projectDirectory, configFile, paths = import_node_path12.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();
+  if (projectRoot !== configRoot || paths.isAbsolute(relative)) {
+    throw new Error(
+      "EventCatalog cannot load its Astro configuration across filesystem drives. Install or link @eventcatalog/core on the same drive as the catalog."
+    );
+  }
+  return relative.replace(/\\/g, "/");
+};
+
 // src/federation/federate.ts
 var import_node_crypto5 = require("crypto");
 var import_promises10 = __toESM(require("fs/promises"), 1);
@@ -2599,7 +2270,7 @@ var createFileSystemSourceProvider = (projectDirectory) => ({
 // src/federation/github-source-provider.ts
 var import_node_child_process = require("child_process");
 var import_promises9 = __toESM(require("fs/promises"), 1);
-var import_node_os4 = __toESM(require("os"), 1);
+var import_node_os3 = __toESM(require("os"), 1);
 var import_node_path17 = __toESM(require("path"), 1);
 var import_node_util = require("util");
 var import_sdk2 = __toESM(require("@eventcatalog/sdk"), 1);
@@ -2656,7 +2327,7 @@ var getGitEnvironment = (token) => {
 var createCheckout = (executeFile, token) => async (source, ref, callback) => {
   const { owner, repository } = parseGitHubSource(source);
   const catalogPath = import_node_path17.default.posix.normalize(source.path ?? ".");
-  const directory = await import_promises9.default.mkdtemp(import_node_path17.default.join(import_node_os4.default.tmpdir(), "eventcatalog-federation-"));
+  const directory = await import_promises9.default.mkdtemp(import_node_path17.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" });
@@ -2999,14 +2670,16 @@ Run npm i @eventcatalog/core to update`;
 
 // src/eventcatalog.ts
 var import_license2 = require("@eventcatalog/license");
-var currentDir = import_node_path20.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
+var currentDir = import_node_path20.default.dirname((0, import_node_url2.fileURLToPath)(importMetaUrl));
+var astroCli = import_node_path20.default.join(import_node_path20.default.dirname((0, import_node_module2.createRequire)(importMetaUrl).resolve("astro/package.json")), "bin/astro.mjs");
 var program = new import_commander.Command().version(VERSION);
 var dir = import_node_path20.default.resolve(process.env.PROJECT_DIR || process.cwd());
-var core = import_node_path20.default.resolve(process.env.CATALOG_DIR || (0, import_node_path19.join)(dir, ".eventcatalog-core"));
 var eventCatalogDir = import_node_path20.default.resolve((0, import_node_path19.join)(currentDir, "../eventcatalog/"));
+var astroConfigPath = () => getAstroConfigPath(dir, (0, import_node_path19.join)(eventCatalogDir, "astro.config.mjs"));
+var { runtimeDirectory: core } = getRuntimePaths(dir);
 var getInstalledEventCatalogVersion = () => {
   try {
-    const pkg = import_fs3.default.readFileSync((0, import_node_path19.join)(dir, "package.json"), "utf8");
+    const pkg = import_fs.default.readFileSync((0, import_node_path19.join)(dir, "package.json"), "utf8");
     const json = JSON.parse(pkg);
     return json.dependencies["@eventcatalog/core"];
   } catch (error) {
@@ -3015,8 +2688,8 @@ var getInstalledEventCatalogVersion = () => {
 };
 program.name("eventcatalog").description("Documentation tool for event-driven architectures");
 var ensureDir = (dir2) => {
-  if (!import_fs3.default.existsSync(dir2)) {
-    import_fs3.default.mkdirSync(dir2);
+  if (!import_fs.default.existsSync(dir2)) {
+    import_fs.default.mkdirSync(dir2);
   }
 };
 var resolveDevPort = async ({ projectDir }) => {
@@ -3036,7 +2709,7 @@ var startDevPrewarm = ({
   initialDelayMs = 500
 }) => {
   let attempt = 0;
-  const hit = (requestPath) => new Promise((resolve3) => {
+  const hit = (requestPath) => new Promise((resolve2) => {
     const req = import_node_http.default.get(
       {
         hostname: "127.0.0.1",
@@ -3046,13 +2719,13 @@ var startDevPrewarm = ({
       },
       (res) => {
         res.resume();
-        resolve3(true);
+        resolve2(true);
       }
     );
-    req.on("error", () => resolve3(false));
+    req.on("error", () => resolve2(false));
     req.on("timeout", () => {
       req.destroy();
-      resolve3(false);
+      resolve2(false);
     });
   });
   const tick = async () => {
@@ -3129,19 +2802,19 @@ var replaceAstroReadyVersionLine = (line) => {
 };
 var runCommandWithFilteredOutput = async ({
   command,
+  args = [],
   cwd,
   env,
   shouldFilterLine,
   transformLine = (line) => line
 }) => {
-  await new Promise((resolve3, reject) => {
-    const child = (0, import_node_child_process2.spawn)(command, {
+  await new Promise((resolve2, reject) => {
+    const child = (0, import_node_child_process2.spawn)(command, args, {
       cwd,
       env: {
         ...process.env,
         ...env
       },
-      shell: true,
       stdio: ["inherit", "pipe", "pipe"]
     });
     let stdoutBuffer = "";
@@ -3177,29 +2850,20 @@ var runCommandWithFilteredOutput = async ({
       stdoutBuffer = flush(stdoutBuffer, process.stdout, true);
       stderrBuffer = flush(stderrBuffer, process.stderr, true);
       if (code === 0) {
-        resolve3();
+        resolve2();
         return;
       }
-      reject(new Error(`Command failed with exit code ${code}: ${command}`));
+      reject(new Error(`Command failed with exit code ${code}: ${command} ${args.join(" ")}`));
     });
   });
 };
-var copyCore = () => {
-  ensureDir(core);
-  if (eventCatalogDir === core) {
-    return;
-  }
-  import_fs3.default.cpSync(eventCatalogDir, core, {
-    recursive: true,
-    filter: (src) => shouldCopyCoreEntry(eventCatalogDir, src)
-  });
-  pruneExcludedCoreEntries(core);
-  const coreNodeModules = import_node_path20.default.join(core, "node_modules");
-  const installedCoreNodeModules = resolveInstalledCoreNodeModules(currentDir);
-  linkCoreNodeModules({ coreNodeModules, installedCoreNodeModules });
-};
+var prepareCore = () => prepareCatalogRuntime({
+  projectDirectory: dir,
+  catalogDirectory: core,
+  packageDirectory: eventCatalogDir
+});
 var clearCore = () => {
-  if (import_fs3.default.existsSync(core)) import_fs3.default.rmSync(core, { recursive: true });
+  clearCatalogCache(dir);
 };
 var checkForUpdate = () => {
   const declaredVersion = getInstalledEventCatalogVersion();
@@ -3249,12 +2913,12 @@ Upgrade now: npm i @eventcatalog/core@beta`;
     );
   }
 };
-program.command("dev").description("Run development server of EventCatalog").option("-d, --debug", "Output EventCatalog application information into your terminal").option("--force-recreate", "Recreate the eventcatalog-core directory", false).option("--no-prewarm", "Disable automatic dev prewarm request").action(async (options, command) => {
+program.command("dev").description("Run development server of EventCatalog").option("-d, --debug", "Output EventCatalog application information into your terminal").option("--force-recreate", "Clear and regenerate the entire .astro cache, including content and metadata", false).option("--no-prewarm", "Disable automatic dev prewarm request").action(async (options, command) => {
   logger.welcome();
   logger.info("Setting up EventCatalog...", "eventcatalog");
   const isServer = await isOutputServer();
   logger.info(isServer ? "EventCatalog is running in Server Mode" : "EventCatalog is running in Static Mode", "config");
-  if (import_fs3.default.existsSync(import_node_path20.default.join(dir, ".env"))) {
+  if (import_fs.default.existsSync(import_node_path20.default.join(dir, ".env"))) {
     import_dotenv.default.config({ path: import_node_path20.default.join(dir, ".env") });
   }
   if (options.debug) {
@@ -3264,10 +2928,9 @@ program.command("dev").description("Run development server of EventCatalog").opt
   }
   if (options.forceRecreate) clearCore();
   await verifyRequiredFieldsAreInCatalogConfigFile(dir);
-  copyCore();
+  prepareCore();
   await resolve_catalog_dependencies_default(dir, core);
   await runMigrations(dir);
-  await catalogToAstro(dir, core);
   const config = await getEventCatalogConfigFile(dir);
   const canEmbedPages = await (0, import_license2.isFeatureEnabled)(
     "@eventcatalog/backstage-plugin-eventcatalog",
@@ -3303,8 +2966,9 @@ program.command("dev").description("Run development server of EventCatalog").opt
   checkForUpdate();
   let watchUnsub;
   try {
-    watchUnsub = await watch(dir, core, shouldBuildIndexedSearch ? createDevSearchIndexWatcher({ config }) : void 0);
-    const args = command.args.join(" ").trim();
+    if (shouldBuildIndexedSearch) {
+      watchUnsub = await watch(dir, core, createDevSearchIndexWatcher({ config }));
+    }
     if (options.prewarm) {
       const prewarmPort = await resolveDevPort({
         projectDir: dir
@@ -3315,8 +2979,9 @@ program.command("dev").description("Run development server of EventCatalog").opt
       });
     }
     await runCommandWithFilteredOutput({
-      command: `npx astro dev ${args}`,
-      cwd: core,
+      command: process.execPath,
+      args: [astroCli, "dev", "--config", astroConfigPath(), ...command.args],
+      cwd: dir,
       env: {
         PROJECT_DIR: dir,
         CATALOG_DIR: core,
@@ -3341,11 +3006,11 @@ program.command("build").description("Run build of EventCatalog").action(async (
   logger.info("Building EventCatalog...", "build");
   const isServer = await isOutputServer();
   logger.info(isServer ? "EventCatalog is running in Server Mode" : "EventCatalog is running in Static Mode", "config");
-  if (import_fs3.default.existsSync(import_node_path20.default.join(dir, ".env"))) {
+  if (import_fs.default.existsSync(import_node_path20.default.join(dir, ".env"))) {
     import_dotenv.default.config({ path: import_node_path20.default.join(dir, ".env") });
   }
   await verifyRequiredFieldsAreInCatalogConfigFile(dir);
-  copyCore();
+  prepareCore();
   const isBackstagePluginEnabled = await (0, import_license2.isFeatureEnabled)(
     "@eventcatalog/backstage-plugin-eventcatalog",
     process.env.EVENTCATALOG_LICENSE_KEY_BACKSTAGE
@@ -3361,7 +3026,6 @@ program.command("build").description("Run build of EventCatalog").action(async (
   });
   await resolve_catalog_dependencies_default(dir, core);
   await runMigrations(dir);
-  await catalogToAstro(dir, core);
   if (isServer) {
     try {
       logger.info("Building fields index...", "fields");
@@ -3376,10 +3040,10 @@ program.command("build").description("Run build of EventCatalog").action(async (
     }
   }
   checkForUpdate();
-  const args = command.args.join(" ").trim();
   await runCommandWithFilteredOutput({
-    command: `npx astro build ${args}`,
-    cwd: core,
+    command: process.execPath,
+    args: [astroCli, "build", "--config", astroConfigPath(), ...command.args],
+    cwd: dir,
     env: {
       PROJECT_DIR: dir,
       CATALOG_DIR: core,
@@ -3411,8 +3075,9 @@ var previewCatalog = async ({
   isEventCatalogScale = false
 }) => {
   await runCommandWithFilteredOutput({
-    command: `npx astro preview ${command.args.join(" ").trim()}`,
-    cwd: core,
+    command: process.execPath,
+    args: [astroCli, "preview", "--config", astroConfigPath(), ...command.args],
+    cwd: dir,
     env: {
       PROJECT_DIR: dir,
       CATALOG_DIR: core,
@@ -3430,8 +3095,9 @@ var startServerCatalog = async ({
 }) => {
   const serverEntryPath = import_node_path20.default.join(dir, "dist", "server", "entry.mjs");
   await runCommandWithFilteredOutput({
-    command: `node "${serverEntryPath}"`,
-    cwd: core,
+    command: process.execPath,
+    args: [serverEntryPath],
+    cwd: dir,
     env: {
       PROJECT_DIR: dir,
       CATALOG_DIR: core,
@@ -3445,7 +3111,7 @@ var startServerCatalog = async ({
 program.command("preview").description("Serves the contents of your eventcatalog build directory").action(async (options, command) => {
   logger.welcome();
   logger.info("Starting preview of your build...", "preview");
-  if (import_fs3.default.existsSync(import_node_path20.default.join(dir, ".env"))) {
+  if (import_fs.default.existsSync(import_node_path20.default.join(dir, ".env"))) {
     import_dotenv.default.config({ path: import_node_path20.default.join(dir, ".env") });
   }
   const canEmbedPages = await (0, import_license2.isFeatureEnabled)(
@@ -3464,7 +3130,7 @@ program.command("preview").description("Serves the contents of your eventcatalog
 program.command("start").description("Serves the contents of your eventcatalog build directory").action(async (options, command) => {
   logger.welcome();
   logger.info("Starting preview of your build...", "preview");
-  if (import_fs3.default.existsSync(import_node_path20.default.join(dir, ".env"))) {
+  if (import_fs.default.existsSync(import_node_path20.default.join(dir, ".env"))) {
     import_dotenv.default.config({ path: import_node_path20.default.join(dir, ".env") });
   }
   const canEmbedPages = await (0, import_license2.isFeatureEnabled)(
@@ -3492,7 +3158,7 @@ program.command("start").description("Serves the contents of your eventcatalog b
 program.command("export").description("Export your EventCatalog using the SDK dumpCatalog function").option("--include-markdown", "Include markdown content in the export", false).action(async (options) => {
   logger.welcome();
   logger.info("Exporting EventCatalog...", "export");
-  if (import_fs3.default.existsSync(import_node_path20.default.join(dir, ".env"))) {
+  if (import_fs.default.existsSync(import_node_path20.default.join(dir, ".env"))) {
     import_dotenv.default.config({ path: import_node_path20.default.join(dir, ".env") });
   }
   const { default: initSDK } = await import("@eventcatalog/sdk");
@@ -3502,11 +3168,11 @@ program.command("export").description("Export your EventCatalog using the SDK du
   ensureDir(exportsDir);
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const exportFile = import_node_path20.default.join(exportsDir, `catalog-${date}.json`);
-  import_fs3.default.writeFileSync(exportFile, JSON.stringify(catalog, null, 2), "utf-8");
+  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_fs3.default.existsSync(import_node_path20.default.join(dir, ".env"))) {
+  if (import_fs.default.existsSync(import_node_path20.default.join(dir, ".env"))) {
     import_dotenv.default.config({ path: import_node_path20.default.join(dir, ".env") });
   }
   await generate(dir);
@@ -3608,7 +3274,7 @@ var reportFederationProgress = (event, verbose = false) => {
 };
 program.command("federate").description("Fetch, resolve, and hydrate the catalogs configured in federation.sources.").option("--no-cache", "Download all federation content and refresh the cache.").option("-v, --verbose", "Show detailed federation diagnostics.").action(async (commandOptions) => {
   logger.welcome();
-  if (import_fs3.default.existsSync(import_node_path20.default.join(dir, ".env"))) {
+  if (import_fs.default.existsSync(import_node_path20.default.join(dir, ".env"))) {
     import_dotenv.default.config({ path: import_node_path20.default.join(dir, ".env") });
   }
   logger.info("Starting federation...", "federation");