@eventcatalog/core 4.7.3 → 4.7.5

package/dist/analytics/analytics.cjs

@@ -36,7 +36,7 @@ module.exports = __toCommonJS(analytics_exports);
 var import_os = __toESM(require("os"), 1);
 
 // package.json
-var version = "4.7.3";
+var version = "4.7.5";
 
 // src/constants.ts
 var VERSION = version;

package/dist/analytics/analytics.js

@@ -1,7 +1,7 @@
 import {
   raiseEvent
-} from "../chunk-SMDTRRED.js";
-import "../chunk-V4FAVGI7.js";
+} from "../chunk-2BYTIH4L.js";
+import "../chunk-ZBPMCEXS.js";
 export {
   raiseEvent
 };

package/dist/analytics/log-build.cjs

@@ -140,7 +140,7 @@ var verifyRequiredFieldsAreInCatalogConfigFile = async (projectDirectory) => {
 var import_os = __toESM(require("os"), 1);
 
 // package.json
-var version = "4.7.3";
+var version = "4.7.5";
 
 // src/constants.ts
 var VERSION = version;

package/dist/analytics/log-build.js

@@ -1,9 +1,9 @@
 import {
   log_build_default
-} from "../chunk-GINIJSFI.js";
-import "../chunk-SMDTRRED.js";
+} from "../chunk-QJRY6Q7S.js";
+import "../chunk-2BYTIH4L.js";
 import "../chunk-K2XIENVT.js";
-import "../chunk-V4FAVGI7.js";
+import "../chunk-ZBPMCEXS.js";
 import "../chunk-6QENHZZP.js";
 export {
   log_build_default as default

package/dist/{chunk-SMDTRRED.js → chunk-2BYTIH4L.js}

@@ -1,6 +1,6 @@
 import {
   VERSION
-} from "./chunk-V4FAVGI7.js";
+} from "./chunk-ZBPMCEXS.js";
 
 // src/analytics/analytics.js
 import os from "os";

package/dist/chunk-A2RZR3U4.js

@@ -0,0 +1,29 @@
+import {
+  createFileSystemSourceProvider
+} from "./chunk-SDZQJTJW.js";
+import {
+  createGitHubSourceProvider
+} from "./chunk-352FGP6W.js";
+
+// src/federation/source-provider.ts
+var createFederationSourceProvider = (projectDirectory, providers = {}) => {
+  const github = providers.github ?? createGitHubSourceProvider();
+  const filesystem = providers.filesystem ?? createFileSystemSourceProvider(projectDirectory);
+  const getProvider = (source) => {
+    if (source.source.startsWith("github:")) return github;
+    if (source.source.startsWith("file:")) return filesystem;
+    throw new Error(`Unsupported federation source "${source.source}" for "${source.id}". Supported protocols: github:, file:.`);
+  };
+  return {
+    async resolve(source) {
+      return getProvider(source).resolve(source);
+    },
+    async fetchContent(request) {
+      return getProvider(request.source).fetchContent(request);
+    }
+  };
+};
+
+export {
+  createFederationSourceProvider
+};

package/dist/{chunk-XXJX3WWF.js → chunk-EUZT4RKY.js}

@@ -1,6 +1,6 @@
 import {
   logger
-} from "./chunk-IALEXWSE.js";
+} from "./chunk-QQPH6RCB.js";
 import {
   cleanup,
   getEventCatalogConfigFile

package/dist/chunk-GYYYAUJD.js

@@ -0,0 +1,276 @@
+import {
+  withFederationOutputTransaction
+} from "./chunk-WRNH5C3U.js";
+import {
+  composePublicAssets
+} from "./chunk-5EPNFDT5.js";
+import {
+  createFederationSourceProvider
+} from "./chunk-A2RZR3U4.js";
+import {
+  createFederationContentCache
+} from "./chunk-R7Z5ALYI.js";
+import {
+  getFederationDiagnostics,
+  resolveFederationRules
+} from "./chunk-JJPB6EOZ.js";
+import {
+  getEventCatalogConfigFile
+} from "./chunk-6QENHZZP.js";
+
+// src/federation/federate.ts
+import { createHash } from "crypto";
+import fs from "fs/promises";
+import path from "path";
+import createSDK, { hydrate, resolve } from "@eventcatalog/sdk";
+var FederationConflictError = class extends Error {
+  conflicts;
+  constructor(conflicts) {
+    const details = conflicts.map((conflict) => `${conflict.id}: ${conflict.sources.join(", ")}`).join("\n");
+    super(`Federation conflicts prevent hydration:
+${details}`);
+    this.name = "FederationConflictError";
+    this.conflicts = conflicts;
+  }
+};
+var FederationDiagnosticError = class extends Error {
+  diagnostics;
+  constructor(diagnostics) {
+    const details = diagnostics.map((diagnostic) => `${diagnostic.rule}: ${diagnostic.message}`).join("\n");
+    super(`Federation diagnostics prevent hydration:
+${details}`);
+    this.name = "FederationDiagnosticError";
+    this.diagnostics = diagnostics;
+  }
+};
+var validateSources = (sources) => {
+  const ids = /* @__PURE__ */ new Set();
+  for (const source of sources) {
+    if (!source.id?.trim()) throw new Error("Every federation source requires a stable id.");
+    if (ids.has(source.id)) throw new Error(`Federation source id "${source.id}" is configured more than once.`);
+    ids.add(source.id);
+  }
+};
+var createDiagnosticGraph = (graph, ownershipGraph, remoteSourceIds, localSourceId) => {
+  const edges = ownershipGraph.edges.filter((edge) => remoteSourceIds.has(edge.fromResolvedFrom.source));
+  const externalsByPointer = /* @__PURE__ */ new Map();
+  for (const edge of edges.filter((edge2) => edge2.status === "external")) {
+    const version = edge.pointer ?? void 0;
+    const key = `${edge.to}@${version ?? ""}`;
+    const external = externalsByPointer.get(key) ?? {
+      id: edge.to,
+      ...version === void 0 ? {} : { version },
+      referencedBy: []
+    };
+    if (!external.referencedBy.includes(edge.from)) external.referencedBy.push(edge.from);
+    externalsByPointer.set(key, external);
+  }
+  return {
+    ...graph,
+    entities: [
+      ...graph.entities,
+      ...ownershipGraph.entities.filter(
+        (entity) => entity.resolvedFrom.source === localSourceId && entity.resolvedFrom.commit === "local"
+      )
+    ],
+    edges,
+    conflicts: ownershipGraph.conflicts,
+    externals: [...externalsByPointer.values()]
+  };
+};
+var writeLock = async (lockPath, lock) => {
+  const temporaryPath = `${lockPath}.tmp-${process.pid}`;
+  try {
+    await fs.writeFile(temporaryPath, `${JSON.stringify(lock, null, 2)}
+`, "utf8");
+    await fs.rename(temporaryPath, lockPath);
+  } finally {
+    await fs.rm(temporaryPath, { force: true });
+  }
+};
+var readLock = async (lockPath) => {
+  try {
+    return JSON.parse(await fs.readFile(lockPath, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw new Error(`Cannot read federation lock at "${lockPath}"`, { cause: error });
+  }
+};
+var pathExists = async (filePath) => {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+};
+var cleanupPreviousFederation = async (projectDirectory, onProgress) => {
+  const outDir = path.join(projectDirectory, "federated");
+  const lockPath = path.join(projectDirectory, "eventcatalog.lock");
+  const previousLock = await readLock(lockPath);
+  const hadFederatedOutput = await pathExists(outDir);
+  const hadLock = previousLock !== void 0;
+  if (!hadFederatedOutput && !hadLock) return;
+  const publicResult = await withFederationOutputTransaction(
+    projectDirectory,
+    outDir,
+    Object.keys(previousLock?.publicFiles ?? {}),
+    async () => {
+      const result = await composePublicAssets({
+        projectDirectory,
+        federatedDirectory: outDir,
+        assets: [],
+        previousFiles: previousLock?.publicFiles
+      });
+      await fs.rm(lockPath, { force: true });
+      return result;
+    }
+  );
+  onProgress?.({
+    type: "cleanup:complete",
+    federated: hadFederatedOutput,
+    publicFiles: publicResult.removed,
+    lock: hadLock
+  });
+};
+var federateCatalog = async (projectDirectory, options = {}) => {
+  const config = await getEventCatalogConfigFile(projectDirectory);
+  const sources = config.federation?.sources ?? [];
+  options.onProgress?.({ type: "configured", sources: sources.length });
+  if (sources.length === 0) {
+    await cleanupPreviousFederation(projectDirectory, options.onProgress);
+    return null;
+  }
+  if (options.isFederationEnabled && !await options.isFederationEnabled()) {
+    throw new Error(
+      "Cannot federate catalogs: EventCatalog federation is an Enterprise feature. Visit https://www.eventcatalog.dev/pricing to enable federation."
+    );
+  }
+  validateSources(sources);
+  const rules = resolveFederationRules(config.federation?.rules);
+  if (options.useCache === false) options.onProgress?.({ type: "cache:disabled" });
+  const provider = options.provider ?? createFederationSourceProvider(projectDirectory);
+  const resolvedSources = [];
+  for (const [index, source] of sources.entries()) {
+    const current = index + 1;
+    options.onProgress?.({ type: "source:start", source, current, total: sources.length });
+    try {
+      const resolved = await provider.resolve(source);
+      resolvedSources.push({ config: source, resolved });
+      options.onProgress?.({
+        type: "source:complete",
+        source,
+        current,
+        total: sources.length,
+        commit: resolved.commit,
+        resources: resolved.index.resources.length,
+        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 outDir = path.join(projectDirectory, "federated");
+  const lockPath = path.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);
+  options.onProgress?.({ type: "local:start" });
+  const localIndex = await createSDK(projectDirectory).buildIndex({
+    source: config.cId,
+    commit: "local",
+    hashContent: false,
+    includeFederated: false
+  });
+  options.onProgress?.({ type: "local:complete", resources: localIndex.resources.length });
+  options.onProgress?.({ type: "resolving", resources, localResources: localIndex.resources.length });
+  const ownershipGraph = resolve([localIndex, ...remoteIndexes]);
+  const graph = resolve(remoteIndexes);
+  const diagnosticGraph = createDiagnosticGraph(
+    graph,
+    ownershipGraph,
+    new Set(remoteIndexes.map((index) => index.source)),
+    localIndex.source
+  );
+  const diagnostics = getFederationDiagnostics(diagnosticGraph, rules);
+  options.onProgress?.({ type: "resolved", graph, diagnostics });
+  const blockingConflicts = ownershipGraph.conflicts.filter((conflict) => rules[`federation/${conflict.kind}`] === "error");
+  if (blockingConflicts.length > 0) throw new FederationConflictError(blockingConflicts);
+  const blockingDiagnostics = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+  if (blockingDiagnostics.length > 0) throw new FederationDiagnosticError(blockingDiagnostics);
+  const publicPaths = [
+    ...Object.keys(previousLock?.publicFiles ?? {}),
+    ...graph.assets.filter((asset) => asset.path.startsWith("public/")).map((asset) => asset.path.slice("public/".length))
+  ];
+  const { hydrateResult, publicResult } = await withFederationOutputTransaction(
+    projectDirectory,
+    outDir,
+    publicPaths,
+    async () => {
+      const sourcesById = new Map(sources.map((source) => [source.id, source]));
+      options.onProgress?.({ type: "hydrating", outDir });
+      let hydratedFiles = 0;
+      let cachedFiles = 0;
+      const hydrateResult2 = await hydrate(graph, {
+        outDir,
+        cache: createFederationContentCache(projectDirectory, {
+          read: options.useCache !== false,
+          onHit: () => {
+            cachedFiles += 1;
+            options.onProgress?.({ type: "hydrate:cache", files: cachedFiles });
+          }
+        }),
+        fetch: async ({ source: sourceId, commit, path: artifactPath }) => {
+          const source = sourcesById.get(sourceId);
+          if (!source) throw new Error(`Cannot fetch content for unconfigured source "${sourceId}"`);
+          const content = await provider.fetchContent({ source, commit, path: artifactPath });
+          hydratedFiles += 1;
+          options.onProgress?.({ type: "hydrate:file", files: hydratedFiles, source: sourceId, path: artifactPath });
+          return content;
+        }
+      });
+      const publicResult2 = await composePublicAssets({
+        projectDirectory,
+        federatedDirectory: outDir,
+        assets: graph.assets,
+        previousFiles: previousLock?.publicFiles,
+        collisionPaths: new Set(
+          graph.warnings.filter((warning) => warning.kind === "asset-collision").map((warning) => warning.path)
+        )
+      });
+      options.onProgress?.({ type: "public:complete", result: publicResult2 });
+      const resolvedAt = (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+      await writeLock(lockPath, {
+        lockVersion: 1,
+        sources: resolvedSources.map(({ config: source, resolved }) => ({
+          id: source.id,
+          digest: `sha256:${createHash("sha256").update(resolved.bytes).digest("hex")}`,
+          commit: resolved.commit,
+          resolvedAt
+        })).sort((left, right) => left.id.localeCompare(right.id)),
+        publicFiles: publicResult2.files
+      });
+      return { hydrateResult: hydrateResult2, publicResult: publicResult2 };
+    }
+  );
+  const result = {
+    sources: sources.length,
+    resources,
+    graph,
+    diagnostics,
+    hydrate: hydrateResult,
+    public: publicResult,
+    outDir,
+    lockPath
+  };
+  options.onProgress?.({ type: "complete", result });
+  return result;
+};
+
+export {
+  FederationConflictError,
+  FederationDiagnosticError,
+  federateCatalog
+};

package/dist/chunk-JJPB6EOZ.js

@@ -0,0 +1,159 @@
+// src/federation/diagnostics.ts
+var federationRuleDefaults = {
+  "federation/duplicate-source": "error",
+  "federation/type-collision": "error",
+  "federation/pointer-type-mismatch": "error",
+  "federation/facet-disagreement": "error",
+  "federation/asset-collision": "warn",
+  "federation/missing-resource": "warn",
+  "federation/unresolved-version": "warn"
+};
+var resolveFederationRules = (rules = {}) => {
+  for (const [rule, level] of Object.entries(rules)) {
+    if (!Object.hasOwn(federationRuleDefaults, rule)) throw new Error(`Unknown federation rule "${rule}".`);
+    if (level !== "off" && level !== "warn" && level !== "error") {
+      throw new Error(`Invalid level "${String(level)}" for federation rule "${rule}". Expected off, warn, or error.`);
+    }
+  }
+  return { ...federationRuleDefaults, ...rules };
+};
+var getExternalResource = (external) => `${external.id}${external.version === void 0 ? "" : `@${external.version}`}`;
+var getVersionedResource = (id, version) => `${id}${version == null ? "" : `@${version}`}`;
+var getDocumentedResourceType = (type) => {
+  const usesAn = type === "adr" || type === "agent" || type === "entity" || type === "event";
+  return `documented as ${usesAn ? "an" : "a"} ${type}`;
+};
+var getConflictDiagnostic = (conflict, graph) => {
+  const catalogs = { label: "catalogs", value: conflict.sources.join(", ") };
+  switch (conflict.kind) {
+    case "duplicate-source":
+      return {
+        severity: "error",
+        message: "Resource has multiple owners",
+        rule: "federation/duplicate-source",
+        attributes: [
+          { label: "resource", value: conflict.id },
+          catalogs,
+          { label: "resolution", value: "assign a single owning catalog" }
+        ]
+      };
+    case "type-collision": {
+      const types = [
+        ...new Map(
+          graph.entities.filter((entity) => entity.id === conflict.id).map(
+            (entity) => [
+              `${entity.resolvedFrom.source}:${entity.type}`,
+              { label: entity.resolvedFrom.source, value: getDocumentedResourceType(entity.type) }
+            ]
+          )
+        ).values()
+      ];
+      return {
+        severity: "error",
+        message: "Resource ID has conflicting types",
+        rule: "federation/type-collision",
+        attributes: [{ label: "resource", value: conflict.id }, ...types.length > 0 ? types : [catalogs]]
+      };
+    }
+    case "pointer-type-mismatch": {
+      const typeMismatch = /^Expected (.+) but found (.+)$/.exec(conflict.detail ?? "");
+      return {
+        severity: "error",
+        message: "Reference type does not match resource",
+        rule: "federation/pointer-type-mismatch",
+        attributes: [
+          { label: "resource", value: conflict.id },
+          ...typeMismatch ? [
+            { label: "expected type", value: typeMismatch[1] },
+            { label: "actual type", value: typeMismatch[2] }
+          ] : conflict.detail ? [{ label: "detail", value: conflict.detail }] : [],
+          catalogs
+        ]
+      };
+    }
+    case "facet-disagreement":
+      return {
+        severity: "error",
+        message: "Catalogs disagree about this resource",
+        rule: "federation/facet-disagreement",
+        attributes: [
+          { label: "resource", value: conflict.id },
+          ...conflict.detail ? [{ label: "detail", value: conflict.detail }] : [],
+          catalogs
+        ]
+      };
+  }
+};
+var getFederationDiagnostics = (graph, rules = {}) => {
+  const resolvedRules = resolveFederationRules(rules);
+  const diagnostics = graph.conflicts.map((conflict) => getConflictDiagnostic(conflict, graph));
+  for (const external of graph.externals) {
+    const resource = getExternalResource(external);
+    for (const referencedBy of external.referencedBy) {
+      const referrer = graph.entities.find((entity) => entity.id === referencedBy);
+      diagnostics.push({
+        severity: "warning",
+        message: "Referenced EventCatalog resource does not exist",
+        rule: "federation/missing-resource",
+        attributes: [
+          { label: "source catalog", value: referrer?.resolvedFrom.source ?? "unknown" },
+          { label: "referenced by", value: referencedBy },
+          { label: "missing resource", value: resource }
+        ]
+      });
+    }
+  }
+  for (const edge of graph.edges.filter((edge2) => edge2.status === "unresolved")) {
+    const availableVersions = [
+      ...new Set(graph.entities.filter((entity) => entity.id === edge.to).map((entity) => entity.version ?? "unversioned"))
+    ].sort((left, right) => left.localeCompare(right, void 0, { numeric: true }));
+    diagnostics.push({
+      severity: "warning",
+      message: "Referenced EventCatalog resource version does not exist",
+      rule: "federation/unresolved-version",
+      attributes: [
+        { label: "source catalog", value: edge.fromResolvedFrom.source },
+        { label: "referenced by", value: getVersionedResource(edge.from, edge.fromVersion) },
+        { label: "resource", value: edge.to },
+        { label: "requested version", value: edge.pointer ?? "unspecified" },
+        { label: "available versions", value: availableVersions.join(", ") }
+      ]
+    });
+  }
+  for (const warning of graph.warnings) {
+    diagnostics.push({
+      severity: "warning",
+      message: "Asset collision",
+      rule: "federation/asset-collision",
+      attributes: [
+        { label: "asset", value: warning.path },
+        { label: "sources", value: warning.sources.join(", ") },
+        { label: "winner", value: warning.winner },
+        { label: "resolution", value: "last configured source wins" }
+      ]
+    });
+  }
+  return diagnostics.flatMap((diagnostic) => {
+    const level = resolvedRules[diagnostic.rule];
+    if (level === "off") return [];
+    return [{ ...diagnostic, severity: level === "error" ? "error" : "warning" }];
+  }).sort(
+    (left, right) => (left.severity === right.severity ? 0 : left.severity === "error" ? -1 : 1) || left.rule.localeCompare(right.rule) || (left.attributes[0]?.value ?? "").localeCompare(right.attributes[0]?.value ?? "")
+  );
+};
+var getFederationDiagnosticCounts = (diagnostics) => diagnostics.reduce(
+  (counts, diagnostic) => ({
+    errors: counts.errors + (diagnostic.severity === "error" ? 1 : 0),
+    warnings: counts.warnings + (diagnostic.severity === "warning" ? 1 : 0)
+  }),
+  { errors: 0, warnings: 0 }
+);
+var getVisibleFederationDiagnostics = (diagnostics, verbose) => diagnostics.filter((diagnostic) => verbose || diagnostic.severity === "error");
+
+export {
+  federationRuleDefaults,
+  resolveFederationRules,
+  getFederationDiagnostics,
+  getFederationDiagnosticCounts,
+  getVisibleFederationDiagnostics
+};

package/dist/{chunk-GINIJSFI.js → chunk-QJRY6Q7S.js}

@@ -1,6 +1,6 @@
 import {
   raiseEvent
-} from "./chunk-SMDTRRED.js";
+} from "./chunk-2BYTIH4L.js";
 import {
   countResources,
   serializeCounts

package/dist/{chunk-IALEXWSE.js → chunk-QQPH6RCB.js}

@@ -1,6 +1,6 @@
 import {
   VERSION
-} from "./chunk-V4FAVGI7.js";
+} from "./chunk-ZBPMCEXS.js";
 
 // src/utils/cli-logger.ts
 import pc from "picocolors";
@@ -37,6 +37,29 @@ var logger = {
   warning: (message, tag = "warn") => {
     console.log(formatMessage(tag, message, pc.yellow));
   },
+  line: (message = "") => {
+    console.log(message);
+  },
+  diagnostic: (severity, message, rule, attributes = []) => {
+    const isError = severity === "error";
+    const color = isError ? pc.red : pc.yellow;
+    const icon = isError ? "\u2716" : "\u26A0";
+    const label = `${icon} ${severity.padEnd(7)} ${message}`;
+    const ruleSpacing = " ".repeat(Math.max(2, 72 - label.length));
+    console.log(`  ${color(icon)} ${color(severity.padEnd(7))} ${message}${ruleSpacing}${pc.gray(rule)}`);
+    for (const attribute of attributes) {
+      console.log(`             - ${pc.dim(`${attribute.label}:`)} ${attribute.value}`);
+    }
+  },
+  diagnosticSummary: (errors, warnings) => {
+    const total = errors + warnings;
+    const color = errors > 0 ? pc.red : pc.yellow;
+    const icon = errors > 0 ? "\u2716" : "\u26A0";
+    const problems = `${total} problem${total === 1 ? "" : "s"}`;
+    const errorCount = `${errors} error${errors === 1 ? "" : "s"}`;
+    const warningCount = `${warnings} warning${warnings === 1 ? "" : "s"}`;
+    console.log(color(`${icon} ${problems} (${errorCount}, ${warningCount})`));
+  },
   dim: (message) => {
     console.log(pc.dim(message));
   }

package/dist/chunk-SDZQJTJW.js

@@ -0,0 +1,90 @@
+// src/federation/filesystem-source-provider.ts
+import { createHash } from "crypto";
+import fs from "fs/promises";
+import path from "path";
+import createSDK from "@eventcatalog/sdk";
+var FILESYSTEM_SOURCE_PREFIX = "file:";
+var isWithinDirectory = (directory, target) => {
+  const relativePath = path.relative(directory, target);
+  return relativePath === "" || !relativePath.startsWith(`..${path.sep}`) && relativePath !== ".." && !path.isAbsolute(relativePath);
+};
+var assertPortableRelativePath = (filePath, label, allowRoot = true) => {
+  const portablePath = filePath.replaceAll("\\", "/");
+  const normalizedPath = path.posix.normalize(portablePath);
+  const isUnsafe = filePath.includes("\\") || filePath.includes("\0") || path.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;
+};
+var getSourceRoot = (projectDirectory, source) => {
+  if (!source.source.startsWith(FILESYSTEM_SOURCE_PREFIX)) {
+    throw new Error(`Unsupported federation source "${source.source}". Expected file:path/to/catalog.`);
+  }
+  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 path.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 = path.resolve(sourceRoot, ...catalogPath.split("/"));
+  if (!isWithinDirectory(sourceRoot, catalogDirectory)) {
+    throw new Error(`Catalog path "${source.path}" escapes source "${source.id}"`);
+  }
+  try {
+    const [realSourceRoot, realCatalogDirectory] = await Promise.all([fs.realpath(sourceRoot), fs.realpath(catalogDirectory)]);
+    if (!isWithinDirectory(realSourceRoot, realCatalogDirectory)) {
+      throw new Error(`Catalog path "${source.path}" escapes source "${source.id}"`);
+    }
+    if (!(await fs.stat(realCatalogDirectory)).isDirectory()) {
+      throw new Error(`Filesystem federation source "${source.id}" is not a directory: ${catalogDirectory}`);
+    }
+    return realCatalogDirectory;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Filesystem federation source "${source.id}" does not exist: ${catalogDirectory}`, { cause: error });
+    }
+    throw error;
+  }
+};
+var getArtifactPath = async (catalogDirectory, source, artifactPath) => {
+  const normalizedPath = assertPortableRelativePath(artifactPath, "Federated artifact path", false);
+  const filePath = path.resolve(catalogDirectory, ...normalizedPath.split("/"));
+  if (!isWithinDirectory(catalogDirectory, filePath)) {
+    throw new Error(`Federated artifact path "${artifactPath}" escapes source "${source.id}"`);
+  }
+  try {
+    const realFilePath = await fs.realpath(filePath);
+    if (!isWithinDirectory(catalogDirectory, realFilePath)) {
+      throw new Error(`Federated artifact path "${artifactPath}" escapes source "${source.id}"`);
+    }
+    return realFilePath;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Federated artifact not found for "${source.id}": ${artifactPath}`, { cause: error });
+    }
+    throw error;
+  }
+};
+var createFileSystemSourceProvider = (projectDirectory) => ({
+  async resolve(source) {
+    const catalogDirectory = await getCatalogDirectory(projectDirectory, source);
+    const localIndex = await createSDK(catalogDirectory).buildIndex({
+      source: source.id,
+      commit: "local",
+      includeFederated: false
+    });
+    const snapshot = createHash("sha256").update(JSON.stringify(localIndex)).digest("hex").slice(0, 12);
+    const index = { ...localIndex, commit: `local:${snapshot}` };
+    const bytes = Buffer.from(JSON.stringify(index));
+    return { bytes, index, commit: index.commit, generated: true };
+  },
+  async fetchContent({ source, path: artifactPath }) {
+    const catalogDirectory = await getCatalogDirectory(projectDirectory, source);
+    return fs.readFile(await getArtifactPath(catalogDirectory, source, artifactPath));
+  }
+});
+
+export {
+  createFileSystemSourceProvider
+};