@eventcatalog/core 4.11.2 → 4.12.0-beta.1

package/eventcatalog/integrations/eventcatalog-runtime.mjs

@@ -0,0 +1,252 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { searchForWorkspaceRoot } from 'vite';
+
+export const packageDirectory = fileURLToPath(new URL('../', import.meta.url));
+
+export function getDevServerFileSystem({ projectDirectory, coreDirectory = packageDirectory }) {
+  // A linked Core can belong to a different workspace than the catalog. pnpm
+  // resolves its dependencies into that workspace's node_modules, outside Core
+  // itself. Preserve Vite's workspace boundary for both roots, including their
+  // real paths, instead of assuming dependencies are relative to process.cwd().
+  const allow = [projectDirectory, coreDirectory].flatMap((directory) => {
+    const absolute = path.resolve(directory);
+    const real = fs.realpathSync(absolute);
+    return [absolute, real, searchForWorkspaceRoot(real)];
+  });
+  return { strict: true, allow: [...new Set(allow)] };
+}
+
+// Match Astro's file-based routing conventions, including endpoint suffixes
+// (e.g. llms.txt.ts) and underscore-prefixed helpers beside page entrypoints.
+export function getPackageRoutes(pagesDirectory = path.join(packageDirectory, 'src/pages')) {
+  const routes = [];
+  const visit = (directory, segments = []) => {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      if (entry.name.startsWith('_') || (entry.name.startsWith('.') && !(entry.isDirectory() && entry.name === '.well-known')))
+        continue;
+      const entrypoint = path.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        visit(entrypoint, [...segments, entry.name]);
+        continue;
+      }
+      if (!entry.isFile() || !/\.(astro|md|mdx|js|ts)$/.test(entry.name)) continue;
+      if (/\.(test|spec|d)\.ts$/.test(entry.name)) continue;
+      const name = entry.name.replace(/\.(astro|md|mdx|js|ts)$/, '');
+      const parts = name === 'index' ? segments : [...segments, name];
+      routes.push({ pattern: `/${parts.join('/')}`, entrypoint });
+    }
+  };
+  visit(pagesDirectory);
+  return routes;
+}
+
+export function getRuntimeAliases({ projectDirectory, runtimeDirectory, coreDirectory = packageDirectory }) {
+  // Keep package aliases aligned with ../tsconfig.json, ../../vitest.config.js
+  // and ../../../../examples/default/tsconfig.json. src/catalog-runtime.ts derives
+  // type-check paths from that tsconfig and overrides catalog-owned entries.
+  const source = (relative) => path.join(coreDirectory, 'src', relative);
+  return [
+    { find: /^@config$/, replacement: path.join(projectDirectory, 'eventcatalog.config.js') },
+    { find: /^@eventcatalog$/, replacement: source('utils/eventcatalog-config/catalog.ts') },
+    { find: '@icons', replacement: source('icons') },
+    { find: '@components', replacement: source('components') },
+    { find: '@catalog/layouts', replacement: source('toolkit/layouts') },
+    { find: /^@catalog\/utils$/, replacement: source('toolkit/utils/index.ts') },
+    { find: '@catalog/utils', replacement: source('toolkit/utils') },
+    { find: '@catalog/snippets', replacement: path.join(projectDirectory, 'snippets') },
+    { find: /^@types$/, replacement: source('types/index.ts') },
+    { find: '@utils', replacement: source('utils') },
+    { find: '@layouts', replacement: source('layouts') },
+    { find: '@enterprise', replacement: source('enterprise') },
+    { find: /^auth:config$/, replacement: path.join(coreDirectory, 'auth.config.ts') },
+    { find: '@stores', replacement: source('stores') },
+  ];
+}
+
+export function packageDependenciesPlugin(coreDirectory = packageDirectory) {
+  const packageFile = path.join(coreDirectory, '../package.json');
+  const { dependencies = {} } = JSON.parse(fs.readFileSync(packageFile, 'utf-8'));
+  return {
+    name: 'eventcatalog:package-dependencies',
+    enforce: 'post',
+    async resolveId(source, importer, options) {
+      const dependency = source.startsWith('@') ? source.split('/').slice(0, 2).join('/') : source.split('/')[0];
+      if (!(dependency in dependencies)) return;
+      // pnpm does not hoist Core's dependencies into the catalog's node_modules.
+      // Resolve through Vite to preserve package exports and browser conditions.
+      return this.resolve(source, packageFile, { ...options, skipSelf: true });
+    },
+  };
+}
+
+export function userConfigPlugin(projectDirectory, coreDirectory = packageDirectory) {
+  const sourceModule = path.join(coreDirectory, 'src/utils/eventcatalog-config/source.ts');
+  return {
+    name: 'eventcatalog:user-config',
+    enforce: 'pre',
+    load(id) {
+      if (path.normalize(id.split('?')[0]) !== path.normalize(sourceModule)) return;
+      // Bundle the user's configuration into the application. The config-time
+      // loader uses a dynamic import, which must not survive into deployed SSR.
+      return `export { default } from ${JSON.stringify(path.join(projectDirectory, 'eventcatalog.config.js'))};`;
+    },
+  };
+}
+
+export function catalogStylesPlugin(projectDirectory, runtimeDirectory, coreDirectory = packageDirectory) {
+  const stylesheet = path.join(coreDirectory, 'src/styles/tailwind.css');
+  return {
+    name: 'eventcatalog:catalog-styles',
+    enforce: 'pre',
+    load(id) {
+      if (path.normalize(id.split('?')[0]) !== path.normalize(stylesheet)) return;
+      // Tailwind skips ignored folders and node_modules by default. Explicitly
+      // include user components and Markdown/MDX classes at their source.
+      const sources = [projectDirectory];
+      return `${fs.readFileSync(stylesheet, 'utf-8')}\n${sources
+        .map((source) => `@source ${JSON.stringify(source.replace(/\\/g, '/'))};`)
+        .join('\n')}\n`;
+    },
+  };
+}
+
+const isWithin = (file, directory) => file === directory || file.startsWith(`${directory}${path.sep}`);
+const toModuleId = (file) => file.replace(/\\/g, '/');
+
+export function customSourcesPlugin(projectDirectory) {
+  const localDirectory = path.join(projectDirectory, 'components');
+  const federatedDirectory = path.join(projectDirectory, 'federated/components');
+  const stylePath = path.join(projectDirectory, 'eventcatalog.styles.css');
+  const emptyStyles = '\0eventcatalog:empty-styles.css';
+  const homepageModule = '\0virtual:eventcatalog/homepage';
+  const homepage = path.join(projectDirectory, 'pages/homepage.astro');
+  const resolveFile = (file) => {
+    const candidates = [
+      file,
+      ...['.astro', '.tsx', '.ts', '.jsx', '.js', '.mjs', '.mdx', '.md'].map((extension) => file + extension),
+    ];
+    for (const candidate of candidates) {
+      if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return candidate;
+    }
+    if (fs.existsSync(file) && fs.statSync(file).isDirectory()) {
+      return resolveFile(path.join(file, 'index'));
+    }
+  };
+  return {
+    name: 'eventcatalog:custom-sources',
+    enforce: 'pre',
+    configureServer(server) {
+      const componentDirectories = [localDirectory, federatedDirectory];
+      const knownFiles = new Set();
+      const scan = (directory) => {
+        if (!fs.existsSync(directory) || !fs.statSync(directory).isDirectory()) return;
+        for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+          const file = path.join(directory, entry.name);
+          if (entry.isDirectory()) scan(file);
+          else knownFiles.add(file);
+        }
+      };
+      for (const directory of componentDirectories) scan(directory);
+
+      let restartTimer;
+      const scheduleRestart = () => {
+        clearTimeout(restartTimer);
+        // A newly added local override changes the resolution of an existing
+        // federated import. Restart Vite after coalescing filesystem events so
+        // its module graph is rebuilt against the current overlay.
+        restartTimer = setTimeout(() => {
+          server.restart().catch((error) => server.config.logger.error(`[EventCatalog] ${error.message}`));
+        }, 50);
+      };
+      const onAdd = (file) => {
+        file = path.resolve(file);
+        if (!componentDirectories.some((directory) => isWithin(file, directory)) || knownFiles.has(file)) return;
+        knownFiles.add(file);
+        scheduleRestart();
+      };
+      const onUnlink = (file) => {
+        if (!knownFiles.delete(path.resolve(file))) return;
+        scheduleRestart();
+      };
+      const cleanup = () => {
+        clearTimeout(restartTimer);
+        server.watcher.off('add', onAdd);
+        server.watcher.off('unlink', onUnlink);
+        server.watcher.off('close', cleanup);
+        server.httpServer?.off('close', cleanup);
+      };
+      server.watcher.on('add', onAdd);
+      server.watcher.on('unlink', onUnlink);
+      server.watcher.once('close', cleanup);
+      server.httpServer?.once('close', cleanup);
+      server.watcher.add(componentDirectories);
+    },
+    resolveId(id, importer) {
+      if (id === 'virtual:eventcatalog/homepage') return homepageModule;
+      if (id === '@catalog/styles') return fs.existsSync(stylePath) ? toModuleId(stylePath) : emptyStyles;
+      // Astro can turn an import from an original user component into a
+      // root-relative URL (e.g. /components/Card.astro?astro&type=style). Vite's
+      // root is Core, so retry those URL paths against the catalog. This is not
+      // a filesystem-drive-path rewrite; URL paths use '/' on Windows too.
+      if (id.startsWith('/') && !id.startsWith('/@') && !fs.existsSync(id.split('?')[0])) {
+        const [source, query] = id.split('?');
+        const projectFile = path.resolve(projectDirectory, `.${source}`);
+        if (fs.existsSync(projectFile) && fs.statSync(projectFile).isFile()) {
+          // Astro normalizes compiler filenames to forward slashes. Keep Vite's
+          // module IDs identical so its client-script manifest uses the same keys.
+          return toModuleId(projectFile) + (query === undefined ? '' : `?${query}`);
+        }
+      }
+      const [source, query] = id.split('?');
+      let relative;
+      if (source.startsWith('@catalog/components/')) {
+        relative = source.slice('@catalog/components/'.length);
+      } else if (source.startsWith('.') && importer) {
+        const parent = path.normalize(importer.split('?')[0]);
+        const directory = [localDirectory, federatedDirectory].find((directory) => isWithin(parent, directory));
+        if (directory) relative = path.relative(directory, path.resolve(path.dirname(parent), source));
+      }
+      if (relative === undefined) return;
+      const local = path.resolve(localDirectory, relative);
+      const federated = path.resolve(federatedDirectory, relative);
+      if (!isWithin(local, localDirectory) || !isWithin(federated, federatedDirectory)) return;
+      const resolved = resolveFile(local) || resolveFile(federated);
+      return resolved ? toModuleId(resolved) + (query === undefined ? '' : `?${query}`) : undefined;
+    },
+    load(id) {
+      if (id === emptyStyles) return '';
+      if (id === homepageModule) {
+        return fs.existsSync(homepage)
+          ? `export { default } from ${JSON.stringify(toModuleId(homepage))};`
+          : 'export default null;';
+      }
+    },
+  };
+}
+
+export default function eventCatalogRuntime({ projectDirectory, runtimeDirectory }) {
+  return {
+    name: 'eventcatalog:runtime',
+    hooks: {
+      'astro:config:setup': ({ injectRoute, updateConfig, addWatchFile }) => {
+        for (const route of getPackageRoutes()) injectRoute(route);
+        addWatchFile(path.join(projectDirectory, 'eventcatalog.config.js'));
+        addWatchFile(path.join(projectDirectory, 'eventcatalog.styles.css'));
+        addWatchFile(path.join(projectDirectory, 'pages/homepage.astro'));
+        updateConfig({
+          vite: {
+            resolve: { alias: getRuntimeAliases({ projectDirectory, runtimeDirectory }) },
+            plugins: [
+              userConfigPlugin(projectDirectory),
+              catalogStylesPlugin(projectDirectory, runtimeDirectory),
+              customSourcesPlugin(projectDirectory),
+              packageDependenciesPlugin(),
+            ],
+          },
+        });
+      },
+    },
+  };
+}

package/eventcatalog/integrations/expressive-code-config.mjs

@@ -0,0 +1,6 @@
+import { mergeEcConfigOptions } from 'astro-expressive-code';
+import defaults from '../ec.config.mjs';
+
+export default function preprocessConfig({ ecConfig }) {
+  return mergeEcConfigOptions(defaults, ecConfig);
+}

package/eventcatalog/integrations/runtime-dependencies.mjs

@@ -0,0 +1,49 @@
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+const dependenciesDirectory = new URL('../../dist/runtime-dependencies/', import.meta.url);
+
+export function getRuntimeDependencyPath(specifier, environment, manifest, directory = dependenciesDirectory) {
+  if (!Object.hasOwn(manifest, specifier)) return specifier;
+  if ((specifier === 'astro' || specifier.startsWith('astro/')) && specifier !== 'astro/assets/services/sharp') return specifier;
+  if (/^@astrojs\/(react|node|internal-helpers)(?:\/|$)/.test(specifier)) return specifier;
+  const filename = manifest[specifier];
+  // Prerender imports need file URLs so Windows drive paths remain valid ESM.
+  // Prerender artifacts are temporary. Deployed SSR uses public package
+  // specifiers that survive moving/reinstalling the app.
+  return environment === 'prerender'
+    ? new URL(filename, directory).href
+    : `@eventcatalog/core/dist/runtime-dependencies/${filename}`;
+}
+
+export default function runtimeDependencies() {
+  const manifest = JSON.parse(fs.readFileSync(new URL('manifest.json', dependenciesDirectory), 'utf-8'));
+  return {
+    name: 'eventcatalog:runtime-dependencies',
+    apply: 'build',
+    enforce: 'pre',
+    async resolveId(source, importer, options) {
+      if (this.environment.name !== 'prerender' || options.kind !== 'require-call') return;
+      const dependencyUrl = getRuntimeDependencyPath(source, 'prerender', manifest);
+      if (dependencyUrl === source) return;
+      const resolved = await this.resolve(source, importer, { ...options, skipSelf: true });
+      if (!resolved?.external) return;
+      // Node's require() needs a filesystem path, while ESM imports below need
+      // file URLs. Keep this ID distinct so output.paths leaves it untouched.
+      return { id: fileURLToPath(dependencyUrl), external: 'absolute' };
+    },
+    configEnvironment(name) {
+      if (name !== 'ssr' && name !== 'prerender') return;
+      return {
+        build: {
+          rolldownOptions: {
+            output: {
+              paths(specifier) {
+                return getRuntimeDependencyPath(specifier, name, manifest);
+              },
+            },
+          },
+        },
+      };
+    },
+  };
+}

package/eventcatalog/integrations/runtime-dependency-manifest.mjs

@@ -0,0 +1,15 @@
+export function createRuntimeDependencyManifest(specifiers) {
+  const manifest = Object.create(null);
+  const filenames = new Map();
+  for (const specifier of [...new Set(specifiers)].sort()) {
+    // These characters have filesystem/URL meaning even without slash encoding.
+    if (/[\\%?#:]/.test(specifier)) throw new Error(`Unsupported runtime dependency specifier: ${specifier}`);
+    const filename = `${specifier.replaceAll('/', '__')}.mjs`;
+    const key = filename.toLowerCase();
+    const existing = filenames.get(key);
+    if (existing) throw new Error(`Runtime dependency filename collision: ${existing} and ${specifier} both map to ${filename}`);
+    filenames.set(key, specifier);
+    manifest[specifier] = filename;
+  }
+  return manifest;
+}

package/eventcatalog/integrations/runtime-paths.mjs

@@ -0,0 +1,16 @@
+import path from 'node:path';
+
+// Shared by the CLI, Astro integrations, development scripts and runtime readers.
+// Callers pass CATALOG_DIR explicitly when consuming the CLI's selected runtime;
+// the CLI itself always selects the cache under its user's project.
+export function getRuntimePaths(projectDirectory, runtimeDirectory) {
+  const project = path.resolve(projectDirectory);
+  const cacheDirectory = path.join(project, '.astro');
+  const runtime = runtimeDirectory ? path.resolve(runtimeDirectory) : path.join(cacheDirectory, 'eventcatalog');
+  return {
+    projectDirectory: project,
+    cacheDirectory,
+    runtimeDirectory: runtime,
+    fieldsDatabasePath: path.join(runtime, '.eventcatalog', 'fields.db'),
+  };
+}

package/eventcatalog/src/content.config.ts

@@ -15,30 +15,15 @@ import { withExtensionProperties } from './utils/collections/extension-propertie
 // Enterprise Collections
 import { customPagesSchema, resourceDocsSchema, resourceDocCategoriesSchema } from './enterprise/collections';
 
-export const projectDirBase = (() => {
-  const projectDir = process.env.PROJECT_DIR;
-  const catalogDir = process.env.CATALOG_DIR;
-
-  // If CATALOG_DIR is set (monorepo mode), compute relative path from catalog to project
-  // Otherwise fall back to absolute path (standalone mode)
-  if (catalogDir && projectDir) {
-    const relativePath = path.relative(catalogDir, projectDir);
-    // Ensure forward slashes for consistency
-    return relativePath.replace(/\\/g, '/');
-  }
-
-  // Fallback to absolute path
-  if (process.platform === 'win32' && projectDir) {
-    const projectDirPath = projectDir.replace(/\\/g, '/');
-    return projectDirPath.startsWith('/') ? projectDirPath : `/${projectDirPath}`;
-  }
-  return projectDir;
-})();
+// Astro's root is the user's catalog. Keep loader paths relative to that root,
+// independently of where generated metadata or the installed package lives.
+export const catalogRoot = '.';
+const projectDirectory = path.resolve(process.env.PROJECT_DIR || process.cwd());
 
 const pages = defineCollection({
   loader: globWithSafeWatcher({
     pattern: withIgnoredBuildArtifacts(['**/pages/*.(md|mdx)']),
-    base: projectDirBase,
+    base: catalogRoot,
   }),
   schema: z
     .object({
@@ -125,7 +110,7 @@ const directoryEntrySource = z.object({
 const changelogs = defineCollection({
   loader: globWithSafeWatcher({
     pattern: withIgnoredBuildArtifacts(['**/changelog.(md|mdx)']),
-    base: projectDirBase,
+    base: catalogRoot,
   }),
   schema: z.object({
     createdAt: z.date().optional(),
@@ -266,7 +251,7 @@ const flowStep = z
 const flows = defineCollection({
   loader: globWithSafeWatcher({
     pattern: withIgnoredBuildArtifacts(['**/flows/**/index.(md|mdx)', '**/flows/**/versioned/*/index.(md|mdx)']),
-    base: projectDirBase,
+    base: catalogRoot,
     generateId: ({ data }) => {
       return `${data.id}-${data.version}`;
     },
@@ -378,7 +363,7 @@ const messageDetailsPanelPropertySchema = z.object({
 const events = defineCollection({
   loader: globWithSafeWatcher({
     pattern: withIgnoredBuildArtifacts(['**/events/*/index.(md|mdx)', '**/events/*/versioned/*/index.(md|mdx)']),
-    base: projectDirBase,
+    base: catalogRoot,
     generateId: ({ data, ...rest }) => {
       return `${data.id}-${data.version}`;
     },
@@ -403,7 +388,7 @@ const events = defineCollection({
 const commands = defineCollection({
   loader: globWithSafeWatcher({
     pattern: withIgnoredBuildArtifacts(['**/commands/*/index.(md|mdx)', '**/commands/*/versioned/*/index.(md|mdx)']),
-    base: projectDirBase,
+    base: catalogRoot,
     generateId: ({ data }) => {
       return `${data.id}-${data.version}`;
     },
@@ -428,7 +413,7 @@ const commands = defineCollection({
 const queries = defineCollection({
   loader: globWithSafeWatcher({
     pattern: withIgnoredBuildArtifacts(['**/queries/*/index.(md|mdx)', '**/queries/*/versioned/*/index.(md|mdx)']),
-    base: projectDirBase,
+    base: catalogRoot,
     generateId: ({ data }) => {
       return `${data.id}-${data.version}`;
     },
@@ -465,7 +450,7 @@ const dataProductOutputPointer = z.object({
 const dataProducts = defineCollection({
   loader: globWithSafeWatcher({
     pattern: withIgnoredBuildArtifacts(['**/data-products/*/index.(md|mdx)', '**/data-products/*/versioned/*/index.(md|mdx)']),
-    base: projectDirBase,
+    base: catalogRoot,
     generateId: ({ data }) => {
       return `${data.id}-${data.version}`;
     },
@@ -514,7 +499,7 @@ const services = defineCollection({
         'services/*/versioned/*/index.(md|mdx)', // ✅ Capture versioned files inside services
       ])
     ),
-    base: projectDirBase,
+    base: catalogRoot,
     generateId: ({ data, ...rest }) => {
       return `${data.id}-${data.version}`;
     },
@@ -564,7 +549,7 @@ const agentModel = z.object({
 const agents = defineCollection({
   loader: globWithSafeWatcher({
     pattern: withIgnoredBuildArtifacts(['**/agents/*/index.(md|mdx)', '**/agents/*/versioned/*/index.(md|mdx)']),
-    base: projectDirBase,
+    base: catalogRoot,
     generateId: ({ data }) => {
       return `${data.id}-${data.version}`;
     },
@@ -628,7 +613,7 @@ const adrResourcePointer = adrPointer.extend({
 const adrs = defineCollection({
   loader: globWithSafeWatcher({
     pattern: withIgnoredBuildArtifacts(['**/adrs/*/index.(md|mdx)', '**/adrs/*/versioned/*/index.(md|mdx)']),
-    base: projectDirBase,
+    base: catalogRoot,
     generateId: ({ data }) => `${data.id}-${data.version}`,
   }),
   schema: withExtensionProperties(
@@ -680,7 +665,7 @@ const dataClassificationEnum = z.enum(['public', 'internal', 'confidential', 're
 const containers = defineCollection({
   loader: globWithSafeWatcher({
     pattern: withIgnoredBuildArtifacts(['**/containers/**/index.(md|mdx)', '**/containers/**/versioned/*/index.(md|mdx)']),
-    base: projectDirBase,
+    base: catalogRoot,
     generateId: ({ data }) => {
       return `${data.id}-${data.version}`;
     },
@@ -723,7 +708,7 @@ const customPages = defineCollection({
   loader: globWithSafeWatcher({
     // any number of child folders
     pattern: withIgnoredBuildArtifacts(['docs/*.(md|mdx)', 'docs/**/*.@(md|mdx)']),
-    base: projectDirBase,
+    base: catalogRoot,
   }),
   schema: customPagesSchema,
 });
@@ -742,7 +727,7 @@ const resourceDocs = defineCollection({
         'domains/**/docs/*.@(md|mdx)',
       ])
     ),
-    base: projectDirBase,
+    base: catalogRoot,
   }),
   schema: resourceDocsSchema,
 });
@@ -761,7 +746,7 @@ const resourceDocCategories = defineCollection({
         'domains/**/docs/_category_.json',
       ])
     ),
-    base: projectDirBase,
+    base: catalogRoot,
   }),
   schema: resourceDocCategoriesSchema,
 });
@@ -779,7 +764,7 @@ const domains = defineCollection({
         'domains/*/subdomains/*/versioned/*/index.(md|mdx)',
       ])
     ),
-    base: projectDirBase,
+    base: catalogRoot,
     generateId: ({ data, ...rest }) => {
       return `${data.id}-${data.version}`;
     },
@@ -860,7 +845,7 @@ const systems = defineCollection({
       '!**/systems/**/adrs/**',
       '!**/systems/**/docs/**',
     ]),
-    base: projectDirBase,
+    base: catalogRoot,
     generateId: ({ data }) => {
       return `${data.id}-${data.version}`;
     },
@@ -900,7 +885,7 @@ const systems = defineCollection({
 const channels = defineCollection({
   loader: globWithSafeWatcher({
     pattern: withIgnoredBuildArtifacts(['**/channels/**/index.(md|mdx)', '**/channels/**/versioned/*/index.(md|mdx)']),
-    base: projectDirBase,
+    base: catalogRoot,
     generateId: ({ data }) => {
       return `${data.id}-${data.version}`;
     },
@@ -949,7 +934,7 @@ const ubiquitousLanguages = defineCollection({
     pattern: withIgnoredBuildArtifacts(
       withFederatedContent(['domains/*/ubiquitous-language.(md|mdx)', 'domains/*/subdomains/*/ubiquitous-language.(md|mdx)'])
     ),
-    base: projectDirBase,
+    base: catalogRoot,
     generateId: ({ data }) => {
       // File has no id, so we need to generate one
       return uuidv4();
@@ -1013,7 +998,7 @@ const entityPropertySchema: z.ZodType<EntityPropertySchema> = z.lazy(() =>
 const entities = defineCollection({
   loader: globWithSafeWatcher({
     pattern: withIgnoredBuildArtifacts(['**/entities/*/index.(md|mdx)', '**/entities/*/versioned/*/index.(md|mdx)']),
-    base: projectDirBase,
+    base: catalogRoot,
     generateId: ({ data, ...rest }) => {
       return `${data.id}-${data.version}`;
     },
@@ -1045,11 +1030,12 @@ const entities = defineCollection({
 const users = defineCollection({
   loader: userTeamDirectoryLoader({
     collection: 'users',
+    storePath: path.join(projectDirectory, '.eventcatalog/store/directory.json'),
     sources: config.directory?.sources,
     conflictStrategy: config.directory?.conflictStrategy,
     local: {
       pattern: withIgnoredBuildArtifacts(withFederatedContent('users/*.(md|mdx)')),
-      base: projectDirBase,
+      base: catalogRoot,
       generateId: ({ data }) => data.id as string,
     },
   }),
@@ -1077,11 +1063,12 @@ const users = defineCollection({
 const teams = defineCollection({
   loader: userTeamDirectoryLoader({
     collection: 'teams',
+    storePath: path.join(projectDirectory, '.eventcatalog/store/directory.json'),
     sources: config.directory?.sources,
     conflictStrategy: config.directory?.conflictStrategy,
     local: {
       pattern: withIgnoredBuildArtifacts(withFederatedContent('teams/*.(md|mdx)')),
-      base: projectDirBase,
+      base: catalogRoot,
       generateId: ({ data }) => data.id as string,
     },
   }),
@@ -1107,12 +1094,12 @@ const teams = defineCollection({
 
 const designs = defineCollection({
   loader: async () => {
-    const data = await globPackage('**/**/*.ecstudio', { cwd: projectDirBase, ignore: ['dist/**', '**/node_modules/**'] });
+    const data = await globPackage('**/**/*.ecstudio', { cwd: projectDirectory, ignore: ['dist/**', '**/node_modules/**'] });
     // File all the files in the designs folder
     // Limit 3 designs community edition?
     const files = data.reduce<{ id: string; name: string }[]>((acc, filePath) => {
       try {
-        const data = fs.readFileSync(path.join(projectDirBase!, filePath), 'utf-8');
+        const data = fs.readFileSync(path.join(projectDirectory, filePath), 'utf-8');
         const json = JSON.parse(data);
         return [...acc, { ...json }];
       } catch (error) {
@@ -1137,7 +1124,7 @@ const designs = defineCollection({
 const diagrams = defineCollection({
   loader: globWithSafeWatcher({
     pattern: withIgnoredBuildArtifacts(['**/diagrams/**/index.(md|mdx)', '**/diagrams/**/versioned/*/index.(md|mdx)']),
-    base: projectDirBase,
+    base: catalogRoot,
     generateId: ({ data }) => `${data.id}-${data.version}`,
   }),
   schema: withExtensionProperties(
@@ -1163,7 +1150,7 @@ const schemas = defineCollection({
         '**/queries/*/index.{md,mdx}',
         '**/queries/*/versioned/*/index.{md,mdx}',
       ]) as string[],
-      base: projectDirBase,
+      base: projectDirectory,
     },
     sources: config.schemas?.sources ?? [],
   }),
@@ -1265,7 +1252,7 @@ const sidebars = defineCollection({
         'domains/**/sidebar.json',
       ])
     ),
-    base: projectDirBase,
+    base: catalogRoot,
   }),
   schema: sidebarSchema,
 });
@@ -1284,7 +1271,7 @@ const examples = defineCollection({
       '**/queries/*/examples/**/*.(md|mdx)',
       '**/queries/*/versioned/*/examples/**/*.(md|mdx)',
     ]),
-    base: projectDirBase,
+    base: catalogRoot,
     generateId: ({ entry }) => entry,
   }),
   schema: z.object({

package/eventcatalog/src/enterprise/custom-pages/routes.ts

@@ -17,8 +17,9 @@ export interface CustomPageRoute {
 export const DEFAULT_CUSTOM_PAGES_PREFIX = 'custom';
 
 /**
- * Tracks the routable files during dev so route injection re-runs when files
- * are added or removed. Never a route itself.
+ * Older Core versions wrote this file beside copied custom pages. Retain the
+ * exclusion so a leftover manifest can never become a JSON endpoint. The current
+ * manifest lives in .astro/eventcatalog, outside the user's pages directory.
  */
 export const CUSTOM_PAGES_MANIFEST_FILENAME = '.routes-manifest.json';
 

package/eventcatalog/src/enterprise/feature.ts

@@ -11,7 +11,8 @@
 
 import fs from 'fs';
 import { join } from 'path';
-import config from '../../eventcatalog.config.js';
+// Feature checks also run during Astro config evaluation, before @config exists.
+import config from '../utils/eventcatalog-config/source';
 
 // Inline isSSR to avoid circular dependency with ../utils/feature (which re-exports from this file)
 const isSSR = () => config?.output === 'server';

package/eventcatalog/src/enterprise/fields/field-indexer.ts

@@ -7,6 +7,7 @@ import path from 'node:path';
 import fs from 'node:fs';
 import { FieldsDatabase } from './fields-db';
 import { extractSchemaFieldsDeep } from './field-extractor';
+import { getRuntimePaths } from '../../../integrations/runtime-paths.mjs';
 
 function detectFormat(fileName: string): string {
   const ext = path.extname(fileName).toLowerCase();
@@ -33,8 +34,10 @@ export async function buildFieldsIndex(catalogDir: string, outputDir?: string):
   const sdkModule = await import('@eventcatalog/sdk');
   const sdk = sdkModule.default(catalogDir);
 
-  const dbDir = path.join(outputDir || catalogDir, '.eventcatalog');
-  const dbPath = path.join(dbDir, 'fields.db');
+  // Preserve the public indexer's default output directory; CLI callers pass
+  // the generated runtime directory explicitly.
+  const { fieldsDatabasePath: dbPath } = getRuntimePaths(catalogDir, outputDir || catalogDir);
+  const dbDir = path.dirname(dbPath);
 
   if (!fs.existsSync(dbDir)) {
     fs.mkdirSync(dbDir, { recursive: true });