@eventcatalog/core 4.7.4 → 4.7.6

package/LICENSE

@@ -0,0 +1,95 @@
+EventCatalog Core is distributed under a mixed-license model.
+
+The EventCatalog Commercial License below applies to these source paths:
+
+- `eventcatalog/src/enterprise/**`
+- `src/federation/**`
+
+The EventCatalog Commercial License also applies to any portion of a compiled,
+bundled, copied, minified, or otherwise generated artifact derived from those
+paths, regardless of its output location, including artifacts under `dist/**`
+and `bin/**`.
+
+The MIT License below applies to all remaining portions of this package.
+
+MIT License
+
+Copyright (c) 2022-2026 boyney123
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+The EventCatalog Commercial License (the "Commercial License")
+Copyright (c) 2022-2026 EventCatalog Ltd
+
+With regard to the EventCatalog Software:
+
+This software and associated documentation files (the "Software") may only be
+used in production, if you (and any entity that you represent) have agreed to,
+and are in compliance with, the EventCatalog Terms of Service available
+at https://www.eventcatalog.dev/terms, or other agreements governing the use of
+the Software, as mutually agreed by you and EventCatalog Ltd ("EventCatalog"),
+and otherwise have a valid EventCatalog Starter, Scale, or Enterprise
+subscription ("Commercial Subscription").
+
+Subject to the foregoing sentence, you are free to modify this Software and
+publish patches to the Software. You agree that EventCatalog and/or its
+licensors (as applicable) retain all right, title and interest in and to all
+such modifications and/or patches, and all such modifications and/or patches
+may only be used, copied, modified, displayed, distributed, or otherwise
+exploited with a valid Commercial Subscription.
+
+A 14-day free trial of premium features is available at
+https://eventcatalog.cloud/ to help you evaluate the Software before purchasing
+a Commercial Subscription.
+
+Notwithstanding the foregoing, you may copy and modify the Software for
+development and testing purposes, without requiring a subscription. You agree
+that EventCatalog and/or its licensors (as applicable) retain all right, title
+and interest in and to all such modifications. You are not granted any other
+rights beyond what is expressly stated herein. Subject to the foregoing, it is
+forbidden to copy, merge, publish, distribute, sublicense, and/or sell the
+Software.
+
+You may not move, change, disable, or circumvent the license key functionality
+in the Software, and you may not remove or obscure any functionality in the
+Software that is protected by the license key.
+
+This Software is source-available for the purposes of transparency and
+auditability. Source availability does not constitute a grant of rights to use
+the Software in production without a valid Commercial Subscription.
+
+This Commercial License applies only to the part of this Software that is not
+distributed under the MIT license. Any part of this Software distributed under
+the MIT license is copyrighted under the MIT license. The full text of this
+Commercial License shall be included in all copies or substantial portions of
+the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+For all third party components incorporated into the EventCatalog Software,
+those components are licensed under the original license provided by the owner
+of the applicable component.

package/README.md

@@ -35,7 +35,7 @@
 <div align="center">
 
 [![main](https://github.com/event-catalog/eventcatalog/actions/workflows/verify-build.yml/badge.svg)](https://github.com/event-catalog/eventcatalog/actions/workflows/verify-build.yml)
-[![License](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/event-catalog/eventcatalog/blob/main/LICENSE)
+[![License](https://img.shields.io/badge/License-MIT%20%2B%20Commercial-blue.svg)](./LICENSE)
 [![npm version](https://badge.fury.io/js/@eventcatalog%2Fcore.svg)](https://badge.fury.io/js/@eventcatalog/core)
 
 </div>
@@ -205,4 +205,5 @@ This project follows the [all-contributors](https://github.com/all-contributors/
 
 # License
 
-MIT.
+EventCatalog Core uses a mixed-license model. Most files are licensed under MIT; the Enterprise and Federation paths
+identified in [LICENSE](./LICENSE) use the EventCatalog Commercial License.

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.4";
+var version = "4.7.6";
 
 // src/constants.ts
 var VERSION = version;

package/dist/analytics/analytics.js

@@ -1,7 +1,7 @@
 import {
   raiseEvent
-} from "../chunk-FDXJIZ74.js";
-import "../chunk-TLWM7WRZ.js";
+} from "../chunk-YXANZO6Y.js";
+import "../chunk-Q534DWPZ.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.4";
+var version = "4.7.6";
 
 // src/constants.ts
 var VERSION = version;

package/dist/analytics/log-build.js

@@ -1,9 +1,9 @@
 import {
   log_build_default
-} from "../chunk-ZIABX6SP.js";
-import "../chunk-FDXJIZ74.js";
+} from "../chunk-RZAJNR7O.js";
+import "../chunk-YXANZO6Y.js";
 import "../chunk-K2XIENVT.js";
-import "../chunk-TLWM7WRZ.js";
+import "../chunk-Q534DWPZ.js";
 import "../chunk-6QENHZZP.js";
 export {
   log_build_default as default

package/dist/{chunk-7QTCSRAC.js → chunk-6BBLQLGL.js}

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

package/dist/chunk-DDALKGTF.js

@@ -0,0 +1,7 @@
+// src/federation/entitlement.ts
+import { isEventCatalogScaleEnabled } from "@eventcatalog/license";
+var isFederationEnabled = () => isEventCatalogScaleEnabled();
+
+export {
+  isFederationEnabled
+};

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-MLIR3NL4.js

@@ -0,0 +1,279 @@
+import {
+  withFederationOutputTransaction
+} from "./chunk-WRNH5C3U.js";
+import {
+  composePublicAssets
+} from "./chunk-5EPNFDT5.js";
+import {
+  createFederationSourceProvider
+} from "./chunk-6K7XZAYI.js";
+import {
+  createFederationContentCache
+} from "./chunk-R7Z5ALYI.js";
+import {
+  getFederationDiagnostics,
+  resolveFederationRules
+} from "./chunk-JJPB6EOZ.js";
+import {
+  isFederationEnabled
+} from "./chunk-DDALKGTF.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 (!await 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-ZXVQXBTT.js → chunk-MNAPKH63.js}

@@ -1,6 +1,6 @@
 import {
   VERSION
-} from "./chunk-TLWM7WRZ.js";
+} from "./chunk-Q534DWPZ.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-TLWM7WRZ.js → chunk-Q534DWPZ.js}

@@ -1,5 +1,5 @@
 // package.json
-var version = "4.7.4";
+var version = "4.7.6";
 
 // src/constants.ts
 var VERSION = version;

package/dist/{chunk-ZIABX6SP.js → chunk-RZAJNR7O.js}

@@ -1,6 +1,6 @@
 import {
   raiseEvent
-} from "./chunk-FDXJIZ74.js";
+} from "./chunk-YXANZO6Y.js";
 import {
   countResources,
   serializeCounts