@eventcatalog/sdk 2.26.1 → 2.26.3

package/dist/index.mjs

@@ -2431,430 +2431,118 @@ var dumpCatalog = (directory) => async (options) => {
   };
 };
 
-// src/snapshots.ts
-import fs14 from "fs";
-import path7 from "path";
-import { createHash } from "crypto";
-import { execSync } from "child_process";
-import { compare } from "semver";
+// src/graph.ts
+import { maxSatisfying, validRange as validRange4 } from "semver";
 
-// src/snapshot-diff.ts
-var stableStringify = (value) => {
-  if (value === null || value === void 0 || typeof value !== "object") {
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) {
-    return "[" + value.map(stableStringify).join(",") + "]";
-  }
-  const sorted = Object.keys(value).sort().map((key) => JSON.stringify(key) + ":" + stableStringify(value[key]));
-  return "{" + sorted.join(",") + "}";
-};
-var flattenResources = (snapshot) => {
-  const resources = [];
-  const addResources = (items, type) => {
-    for (const item of items) {
-      resources.push({
-        resourceId: item.id,
-        version: item.version,
-        type,
-        data: item
-      });
-    }
-  };
-  addResources(snapshot.resources.domains, "domain");
-  addResources(snapshot.resources.services, "service");
-  addResources(snapshot.resources.agents || [], "agent");
-  addResources(snapshot.resources.messages.events, "event");
-  addResources(snapshot.resources.messages.commands, "command");
-  addResources(snapshot.resources.messages.queries, "query");
-  addResources(snapshot.resources.channels, "channel");
-  return resources;
+// src/adrs.ts
+import fs14 from "fs/promises";
+import { join as join16 } from "path";
+var getAdr = (directory) => async (id, version) => getResource(directory, id, version, { type: "adr" });
+var getAdrs = (directory) => async (options) => getResources(directory, { type: "adrs", latestOnly: options?.latestOnly });
+var writeAdr = (directory) => async (adr, options = {
+  path: "",
+  override: false,
+  format: "mdx"
+}) => writeResource(directory, { ...adr }, { ...options, type: "adr" });
+var rmAdr = (directory) => async (path9) => {
+  await fs14.rm(join16(directory, path9), { recursive: true });
+  invalidateFileCache();
 };
-var EXCLUDED_FIELDS = /* @__PURE__ */ new Set(["markdown", "_eventcatalog"]);
-var getComparableFields = (data) => {
-  const result = {};
-  for (const [key, value] of Object.entries(data)) {
-    if (!EXCLUDED_FIELDS.has(key)) {
-      result[key] = value;
-    }
-  }
-  return result;
+var rmAdrById = (directory) => async (id, version, persistFiles) => {
+  await rmResourceById(directory, id, version, { type: "adr", persistFiles });
 };
-var findChangedFields = (dataA, dataB) => {
-  const fieldsA = getComparableFields(dataA);
-  const fieldsB = getComparableFields(dataB);
-  const allKeys = /* @__PURE__ */ new Set([...Object.keys(fieldsA), ...Object.keys(fieldsB)]);
-  const changed = [];
-  for (const key of allKeys) {
-    if (stableStringify(fieldsA[key] ?? null) !== stableStringify(fieldsB[key] ?? null)) {
-      changed.push(key);
-    }
-  }
-  return changed;
+var versionAdr = (directory) => async (id) => versionResource(directory, id);
+var adrHasVersion = (directory) => async (id, version) => {
+  const file = await findFileById(directory, id, version);
+  return !!file;
 };
-var resourceKey = (r) => `${r.resourceId}@${r.version}`;
-var idTypeKey = (r) => `${r.resourceId}:${r.type}`;
-var computeResourceDiff = (snapshotA, snapshotB) => {
-  const resourcesA = flattenResources(snapshotA);
-  const resourcesB = flattenResources(snapshotB);
-  const mapA = /* @__PURE__ */ new Map();
-  const byIdA = /* @__PURE__ */ new Map();
-  for (const r of resourcesA) {
-    mapA.set(resourceKey(r), r);
-    byIdA.set(idTypeKey(r), r);
-  }
-  const mapB = /* @__PURE__ */ new Map();
-  const byIdB = /* @__PURE__ */ new Map();
-  for (const r of resourcesB) {
-    mapB.set(resourceKey(r), r);
-    byIdB.set(idTypeKey(r), r);
-  }
-  const changes = [];
-  const handledIds = /* @__PURE__ */ new Set();
-  for (const resource of resourcesB) {
-    const key = resourceKey(resource);
-    if (!mapA.has(key)) {
-      const idKey = idTypeKey(resource);
-      const oldResource = byIdA.get(idKey);
-      if (oldResource && oldResource.version !== resource.version && !handledIds.has(idKey)) {
-        const changedFields = findChangedFields(oldResource.data, resource.data);
-        changes.push({
-          resourceId: resource.resourceId,
-          version: resource.version,
-          type: resource.type,
-          changeType: "versioned",
-          previousVersion: oldResource.version,
-          newVersion: resource.version,
-          changedFields: changedFields.length > 0 ? changedFields : void 0
-        });
-        handledIds.add(idKey);
-      } else if (!handledIds.has(idKey)) {
-        changes.push({
-          resourceId: resource.resourceId,
-          version: resource.version,
-          type: resource.type,
-          changeType: "added"
-        });
-      }
-    }
-  }
-  for (const resource of resourcesA) {
-    const key = resourceKey(resource);
-    if (!mapB.has(key)) {
-      const idKey = idTypeKey(resource);
-      if (!handledIds.has(idKey)) {
-        changes.push({
-          resourceId: resource.resourceId,
-          version: resource.version,
-          type: resource.type,
-          changeType: "removed"
-        });
-      }
-    }
-  }
-  for (const resourceB of resourcesB) {
-    const key = resourceKey(resourceB);
-    const resourceA = mapA.get(key);
-    if (resourceA) {
-      const changedFields = findChangedFields(resourceA.data, resourceB.data);
-      if (changedFields.length > 0) {
-        changes.push({
-          resourceId: resourceB.resourceId,
-          version: resourceB.version,
-          type: resourceB.type,
-          changeType: "modified",
-          changedFields
-        });
-      }
-    }
-  }
-  return changes;
+var addFileToAdr = (directory) => async (id, file, version) => addFileToResource(directory, id, file, version, { type: "adr" });
+
+// src/data-products.ts
+import fs15 from "fs/promises";
+import { join as join17 } from "path";
+var getDataProduct = (directory) => async (id, version) => getResource(directory, id, version, { type: "data-product" });
+var getDataProducts = (directory) => async (options) => getResources(directory, { type: "data-products", latestOnly: options?.latestOnly });
+var writeDataProduct = (directory) => async (dataProduct, options = {
+  path: "",
+  override: false,
+  format: "mdx"
+}) => writeResource(directory, { ...dataProduct }, { ...options, type: "data-product" });
+var writeDataProductToDomain = (directory) => async (dataProduct, domain, options = { path: "", format: "mdx", override: false }) => {
+  let pathForDataProduct = domain.version && domain.version !== "latest" ? `/${domain.id}/versioned/${domain.version}/data-products` : `/${domain.id}/data-products`;
+  pathForDataProduct = join17(pathForDataProduct, dataProduct.id);
+  await writeResource(directory, { ...dataProduct }, { ...options, path: pathForDataProduct, type: "data-product" });
 };
-var getRelationshipKey = (serviceId, resourceId, resourceVersion, direction) => {
-  return `${serviceId}:${direction}:${resourceId}@${resourceVersion || "latest"}`;
+var rmDataProduct = (directory) => async (path9) => {
+  await fs15.rm(join17(directory, path9), { recursive: true });
+  invalidateFileCache();
 };
-var extractRelationships = (snapshot) => {
-  const relationships = /* @__PURE__ */ new Map();
-  for (const service of [...snapshot.resources.services, ...snapshot.resources.agents || []]) {
-    for (const direction of ["sends", "receives"]) {
-      const pointers = service[direction] || [];
-      for (const pointer of pointers) {
-        const key = getRelationshipKey(service.id, pointer.id, pointer.version, direction);
-        relationships.set(key, {
-          serviceId: service.id,
-          serviceVersion: service.version,
-          resourceId: pointer.id,
-          resourceVersion: pointer.version,
-          direction
-        });
-      }
-    }
-  }
-  return relationships;
+var rmDataProductById = (directory) => async (id, version, persistFiles) => {
+  await rmResourceById(directory, id, version, { type: "data-product", persistFiles });
 };
-var computeRelationshipDiff = (snapshotA, snapshotB) => {
-  const relsA = extractRelationships(snapshotA);
-  const relsB = extractRelationships(snapshotB);
-  const changes = [];
-  for (const [key, rel] of relsB) {
-    if (!relsA.has(key)) {
-      changes.push({ ...rel, changeType: "added" });
-    }
-  }
-  for (const [key, rel] of relsA) {
-    if (!relsB.has(key)) {
-      changes.push({ ...rel, changeType: "removed" });
-    }
-  }
-  return changes;
+var versionDataProduct = (directory) => async (id) => versionResource(directory, id);
+var dataProductHasVersion = (directory) => async (id, version) => {
+  const file = await findFileById(directory, id, version);
+  return !!file;
 };
+var addFileToDataProduct = (directory) => async (id, file, version) => addFileToResource(directory, id, file, version);
 
-// src/snapshots.ts
-var SNAPSHOT_VERSION = "1.0.0";
-var getEventCatalogVersion2 = (catalogDir) => {
-  try {
-    const packageJson = fs14.readFileSync(path7.join(catalogDir, "package.json"), "utf8");
-    const packageJsonObject = JSON.parse(packageJson);
-    return packageJsonObject["dependencies"]?.["@eventcatalog/core"] ?? "unknown";
-  } catch {
-    return "unknown";
-  }
+// src/containers.ts
+import fs16 from "fs/promises";
+import { join as join18 } from "path";
+var getContainer = (directory) => async (id, version) => getResource(directory, id, version, { type: "container" });
+var getContainers = (directory) => async (options) => getResources(directory, { type: "containers", latestOnly: options?.latestOnly });
+var writeContainer = (directory) => async (data, options = {
+  path: "",
+  override: false,
+  format: "mdx"
+}) => writeResource(directory, { ...data }, { ...options, type: "container" });
+var versionContainer = (directory) => async (id) => versionResource(directory, id);
+var rmContainer = (directory) => async (path9) => {
+  await fs16.rm(join18(directory, path9), { recursive: true });
+  invalidateFileCache();
 };
-var pickCoreFields = (resource) => {
-  const picked = { id: resource.id, version: resource.version, name: resource.name };
-  if (resource.sends) picked.sends = resource.sends;
-  if (resource.receives) picked.receives = resource.receives;
-  if (resource.deprecated) picked.deprecated = resource.deprecated;
-  if (resource.owners) picked.owners = resource.owners;
-  if (resource.schemaPath) picked.schemaPath = resource.schemaPath;
-  if (resource.schemaHash) picked.schemaHash = resource.schemaHash;
-  return picked;
+var rmContainerById = (directory) => async (id, version, persistFiles) => {
+  await rmResourceById(directory, id, version, { type: "container", persistFiles });
 };
-var deduplicateByLatestVersion = (resources) => {
-  const seen = /* @__PURE__ */ new Map();
-  for (const r of resources) {
-    const existing = seen.get(r.id);
-    if (!existing || compare(r.version, existing.version) > 0) {
-      seen.set(r.id, r);
-    }
+var containerHasVersion = (directory) => async (id, version) => {
+  const file = await findFileById(directory, id, version);
+  return !!file;
+};
+var addFileToContainer = (directory) => async (id, file, version) => addFileToResource(directory, id, file, version);
+var writeContainerToService = (directory) => async (container, service, options = { path: "", format: "mdx", override: false }) => {
+  const resourcePath = await getResourcePath(directory, service.id, service.version);
+  if (!resourcePath) {
+    throw new Error("Service not found");
   }
-  return Array.from(seen.values());
+  let pathForContainer = service.version && service.version !== "latest" ? `${resourcePath.directory}/versioned/${service.version}/containers` : `${resourcePath.directory}/containers`;
+  pathForContainer = join18(pathForContainer, container.id);
+  await writeResource(directory, { ...container }, { ...options, path: pathForContainer, type: "container" });
 };
-var stripToCore = (resources) => {
-  if (!resources || resources.length === 0) return [];
-  return deduplicateByLatestVersion(resources).map(pickCoreFields);
-};
-var detectGitInfo = (catalogDir) => {
-  try {
-    const opts = { cwd: catalogDir, encoding: "utf8", stdio: "pipe" };
-    const branch = execSync("git rev-parse --abbrev-ref HEAD", opts).trim();
-    const commit = execSync("git rev-parse --short HEAD", opts).trim();
-    const status = execSync("git status --porcelain", opts).trim();
-    return { branch, commit, dirty: status.length > 0 };
-  } catch {
-    return void 0;
-  }
-};
-var enrichWithSchemaHashes = async (getSchemaForMessage2, resources) => {
-  await Promise.all(
-    resources.map(async (resource) => {
-      if (!resource.schemaPath) return;
-      const schema = await getSchemaForMessage2(resource.id, resource.version);
-      if (!schema) return;
-      resource.schemaHash = createHash("sha256").update(schema.schema).digest("hex");
-    })
-  );
-};
-var createSnapshot = (directory) => {
-  return async (options) => {
-    const { label, outputDir, git } = options || {};
-    const sdk = src_default(directory);
-    const [domains, services, agents, events, commands, queries, channels] = await Promise.all([
-      sdk.getDomains(),
-      sdk.getServices(),
-      sdk.getAgents(),
-      sdk.getEvents(),
-      sdk.getCommands(),
-      sdk.getQueries(),
-      sdk.getChannels()
-    ]);
-    await Promise.all([
-      enrichWithSchemaHashes(sdk.getSchemaForMessage, events || []),
-      enrichWithSchemaHashes(sdk.getSchemaForMessage, commands || []),
-      enrichWithSchemaHashes(sdk.getSchemaForMessage, queries || [])
-    ]);
-    const snapshotDomains = stripToCore(domains);
-    const snapshotServices = stripToCore(services);
-    const snapshotAgents = stripToCore(agents);
-    const snapshotEvents = stripToCore(events);
-    const snapshotCommands = stripToCore(commands);
-    const snapshotQueries = stripToCore(queries);
-    const snapshotChannels = stripToCore(channels);
-    const snapshotLabel = label || (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const gitInfo = git || detectGitInfo(directory);
-    const snapshot = {
-      snapshotVersion: SNAPSHOT_VERSION,
-      catalogVersion: getEventCatalogVersion2(directory),
-      label: snapshotLabel,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      ...gitInfo ? { git: gitInfo } : {},
-      resources: {
-        domains: snapshotDomains,
-        services: snapshotServices,
-        agents: snapshotAgents,
-        messages: {
-          events: snapshotEvents,
-          commands: snapshotCommands,
-          queries: snapshotQueries
-        },
-        channels: snapshotChannels
-      }
-    };
-    const snapshotsDir = outputDir || path7.join(directory, ".snapshots");
-    fs14.mkdirSync(snapshotsDir, { recursive: true });
-    const fileName = `${snapshotLabel}.snapshot.json`;
-    const filePath = path7.join(snapshotsDir, fileName);
-    fs14.writeFileSync(filePath, JSON.stringify(snapshot));
-    return { filePath, snapshot };
-  };
-};
-var diffSnapshots = (directory) => async (snapshotAPath, snapshotBPath) => {
-  const snapshotA = JSON.parse(fs14.readFileSync(snapshotAPath, "utf-8"));
-  const snapshotB = JSON.parse(fs14.readFileSync(snapshotBPath, "utf-8"));
-  const resourceChanges = computeResourceDiff(snapshotA, snapshotB);
-  const relationshipChanges = computeRelationshipDiff(snapshotA, snapshotB);
-  const resourceCounts = { added: 0, removed: 0, modified: 0, versioned: 0 };
-  for (const r of resourceChanges) resourceCounts[r.changeType]++;
-  const relCounts = { added: 0, removed: 0 };
-  for (const r of relationshipChanges) relCounts[r.changeType]++;
-  return {
-    snapshotA: { label: snapshotA.label, createdAt: snapshotA.createdAt },
-    snapshotB: { label: snapshotB.label, createdAt: snapshotB.createdAt },
-    summary: {
-      totalChanges: resourceChanges.length + relationshipChanges.length,
-      resourcesAdded: resourceCounts.added,
-      resourcesRemoved: resourceCounts.removed,
-      resourcesModified: resourceCounts.modified,
-      resourcesVersioned: resourceCounts.versioned,
-      relationshipsAdded: relCounts.added,
-      relationshipsRemoved: relCounts.removed
-    },
-    resources: resourceChanges,
-    relationships: relationshipChanges
-  };
-};
-var listSnapshots = (directory) => async () => {
-  const snapshotsDir = path7.join(directory, ".snapshots");
-  if (!fs14.existsSync(snapshotsDir)) return [];
-  const files = fs14.readdirSync(snapshotsDir).filter((f) => f.endsWith(".snapshot.json"));
-  const snapshots = [];
-  for (const file of files) {
-    try {
-      const filePath = path7.join(snapshotsDir, file);
-      const content = JSON.parse(fs14.readFileSync(filePath, "utf-8"));
-      snapshots.push({
-        label: content.label,
-        createdAt: content.createdAt,
-        filePath,
-        ...content.git ? { git: content.git } : {}
-      });
-    } catch {
-    }
-  }
-  return snapshots.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
-};
-
-// src/changelogs.ts
-import path8, { dirname as dirname6 } from "path";
-import fsSync8 from "fs";
-import fs15 from "fs/promises";
-import matter8 from "gray-matter";
-var writeChangelog = (catalogDir) => async (id, changelog, options = {}) => {
-  const { version, format = "mdx" } = options;
-  const resourceFile = await findFileById(catalogDir, id, version);
-  if (!resourceFile) {
-    throw new Error(`No resource found with id: ${id}${version ? ` and version: ${version}` : ""}`);
-  }
-  const resourceDir = dirname6(resourceFile);
-  const changelogPath = path8.join(resourceDir, `changelog.${format}`);
-  const { markdown, ...frontmatter } = changelog;
-  const fm = { ...frontmatter };
-  if (fm.createdAt instanceof Date) {
-    fm.createdAt = fm.createdAt;
-  }
-  if (!fm.badges || fm.badges.length === 0) {
-    delete fm.badges;
+var writeContainerToSystem = (directory) => async (container, system, options = { path: "", format: "mdx", override: false }) => {
+  const resourcePath = await getResourcePath(directory, system.id, system.version);
+  if (!resourcePath) {
+    throw new Error("System not found");
   }
-  fsSync8.mkdirSync(resourceDir, { recursive: true });
-  const document = matter8.stringify(markdown.trim(), fm);
-  fsSync8.writeFileSync(changelogPath, document);
-  invalidateFileCache();
+  const pathForContainer = join18(resourcePath.directory, "containers", container.id);
+  await writeResource(directory, { ...container }, { ...options, path: pathForContainer, type: "container" });
 };
-var appendChangelog = (catalogDir) => async (id, changelog, options = {}) => {
-  const { version, format = "mdx" } = options;
-  const resourceFile = await findFileById(catalogDir, id, version);
-  if (!resourceFile) {
-    throw new Error(`No resource found with id: ${id}${version ? ` and version: ${version}` : ""}`);
-  }
-  const resourceDir = dirname6(resourceFile);
-  const mdxPath = path8.join(resourceDir, "changelog.mdx");
-  const mdPath = path8.join(resourceDir, "changelog.md");
-  const existingPath = fsSync8.existsSync(mdxPath) ? mdxPath : fsSync8.existsSync(mdPath) ? mdPath : void 0;
-  if (!existingPath) {
-    return writeChangelog(catalogDir)(id, changelog, options);
-  }
-  const existing = matter8.read(existingPath);
-  const existingContent = existing.content.trim();
-  const newEntry = changelog.markdown.trim();
-  const combined = `${newEntry}
-
----
 
-${existingContent}`;
-  const fm = { ...existing.data };
-  fm.createdAt = changelog.createdAt;
-  if (changelog.badges && changelog.badges.length > 0) {
-    fm.badges = changelog.badges;
-  } else {
-    delete fm.badges;
-  }
-  const document = matter8.stringify(combined, fm);
-  fsSync8.writeFileSync(existingPath, document);
-  invalidateFileCache();
-};
-var getChangelog = (catalogDir) => async (id, options = {}) => {
-  const { version } = options;
-  const resourceFile = await findFileById(catalogDir, id, version);
-  if (!resourceFile) return void 0;
-  const resourceDir = dirname6(resourceFile);
-  const mdxPath = path8.join(resourceDir, "changelog.mdx");
-  const mdPath = path8.join(resourceDir, "changelog.md");
-  const changelogPath = fsSync8.existsSync(mdxPath) ? mdxPath : fsSync8.existsSync(mdPath) ? mdPath : void 0;
-  if (!changelogPath) return void 0;
-  const { data, content } = matter8.read(changelogPath);
-  return { ...data, markdown: content.trim() };
-};
-var rmChangelog = (catalogDir) => async (id, options = {}) => {
-  const { version } = options;
-  const resourceFile = await findFileById(catalogDir, id, version);
-  if (!resourceFile) {
-    throw new Error(`No resource found with id: ${id}${version ? ` and version: ${version}` : ""}`);
-  }
-  const resourceDir = dirname6(resourceFile);
-  const mdxPath = path8.join(resourceDir, "changelog.mdx");
-  const mdPath = path8.join(resourceDir, "changelog.md");
-  if (fsSync8.existsSync(mdxPath)) {
-    await fs15.rm(mdxPath);
-  }
-  if (fsSync8.existsSync(mdPath)) {
-    await fs15.rm(mdPath);
-  }
-  invalidateFileCache();
-};
+// src/data-stores.ts
+var getDataStore = getContainer;
+var getDataStores = getContainers;
+var writeDataStore = writeContainer;
+var versionDataStore = versionContainer;
+var rmDataStore = rmContainer;
+var rmDataStoreById = rmContainerById;
+var dataStoreHasVersion = containerHasVersion;
+var addFileToDataStore = addFileToContainer;
+var writeDataStoreToService = writeContainerToService;
+var writeDataStoreToSystem = writeContainerToSystem;
 
 // src/entities.ts
-import fs16 from "fs/promises";
-import { join as join16 } from "path";
+import fs17 from "fs/promises";
+import { join as join19 } from "path";
 var getEntity = (directory) => async (id, version) => getResource(directory, id, version, { type: "entity" });
 var getEntities = (directory) => async (options) => getResources(directory, { type: "entities", latestOnly: options?.latestOnly });
 var writeEntity = (directory) => async (entity, options = {
@@ -2867,11 +2555,11 @@ var writeEntityToSystem = (directory) => async (entity, system, options = { path
   if (!resourcePath) {
     throw new Error("System not found");
   }
-  const pathForEntity = join16(resourcePath.directory, "entities", entity.id);
+  const pathForEntity = join19(resourcePath.directory, "entities", entity.id);
   await writeResource(directory, { ...entity }, { ...options, path: pathForEntity, type: "entity" });
 };
 var rmEntity = (directory) => async (path9) => {
-  await fs16.rm(join16(directory, path9), { recursive: true });
+  await fs17.rm(join19(directory, path9), { recursive: true });
   invalidateFileCache();
 };
 var rmEntityById = (directory) => async (id, version, persistFiles) => {
@@ -2884,8 +2572,8 @@ var entityHasVersion = (directory) => async (id, version) => {
 };
 
 // src/flows.ts
-import fs17 from "fs/promises";
-import { join as join17 } from "path";
+import fs18 from "fs/promises";
+import { join as join20 } from "path";
 
 // src/flow-builder.ts
 var cloneStep = (step) => ({
@@ -3349,144 +3037,815 @@ var FlowBuilder = class _FlowBuilder {
           throw new Error(`Flow step "${step.id}" references missing next step "${nextStepId}"`);
         }
       }
-    }
-  }
-};
-
-// src/flows.ts
-var getFlow = (directory) => async (id, version) => getResource(directory, id, version, { type: "flow" });
-var getFlows = (directory) => async (options) => getResources(directory, { type: "flows", latestOnly: options?.latestOnly });
-var writeFlow = (directory) => async (flow, options = {
-  path: "",
-  override: false,
-  format: "mdx"
-}) => writeResource(directory, { ...flow }, { ...options, type: "flow" });
-var writeVersionedFlow = (directory) => async (flow) => {
-  const path9 = getVersionedDirectory(flow.id, flow.version);
-  return await writeFlow(directory)({ ...flow }, { path: path9 });
-};
-var writeFlowToDomain = (directory) => async (flow, domain, options = { path: "", format: "mdx", override: false }) => {
-  let pathForFlow = domain.version && domain.version !== "latest" ? `/${domain.id}/versioned/${domain.version}/flows` : `/${domain.id}/flows`;
-  pathForFlow = join17(pathForFlow, flow.id);
-  await writeResource(directory, { ...flow }, { ...options, path: pathForFlow, type: "flow" });
+    }
+  }
+};
+
+// src/flows.ts
+var getFlow = (directory) => async (id, version) => getResource(directory, id, version, { type: "flow" });
+var getFlows = (directory) => async (options) => getResources(directory, { type: "flows", latestOnly: options?.latestOnly });
+var writeFlow = (directory) => async (flow, options = {
+  path: "",
+  override: false,
+  format: "mdx"
+}) => writeResource(directory, { ...flow }, { ...options, type: "flow" });
+var writeVersionedFlow = (directory) => async (flow) => {
+  const path9 = getVersionedDirectory(flow.id, flow.version);
+  return await writeFlow(directory)({ ...flow }, { path: path9 });
+};
+var writeFlowToDomain = (directory) => async (flow, domain, options = { path: "", format: "mdx", override: false }) => {
+  let pathForFlow = domain.version && domain.version !== "latest" ? `/${domain.id}/versioned/${domain.version}/flows` : `/${domain.id}/flows`;
+  pathForFlow = join20(pathForFlow, flow.id);
+  await writeResource(directory, { ...flow }, { ...options, path: pathForFlow, type: "flow" });
+};
+var writeFlowToService = (directory) => async (flow, service, options = { path: "", format: "mdx", override: false }) => {
+  let pathForFlow = service.version && service.version !== "latest" ? `/${service.id}/versioned/${service.version}/flows` : `/${service.id}/flows`;
+  pathForFlow = join20(pathForFlow, flow.id);
+  await writeResource(directory, { ...flow }, { ...options, path: pathForFlow, type: "flow" });
+};
+var writeFlowToSystem = (directory) => async (flow, system, options = { path: "", format: "mdx", override: false }) => {
+  const resourcePath = await getResourcePath(directory, system.id, system.version);
+  if (!resourcePath) {
+    throw new Error("System not found");
+  }
+  const pathForFlow = join20(resourcePath.directory, "flows", flow.id);
+  await writeResource(directory, { ...flow }, { ...options, path: pathForFlow, type: "flow" });
+};
+var writeFlowToAgent = (directory) => async (flow, agent, options = { path: "", format: "mdx", override: false }) => {
+  let pathForFlow = agent.version && agent.version !== "latest" ? `/${agent.id}/versioned/${agent.version}/flows` : `/${agent.id}/flows`;
+  pathForFlow = join20(pathForFlow, flow.id);
+  await writeResource(directory, { ...flow }, { ...options, path: pathForFlow, type: "flow" });
+};
+var rmFlow = (directory) => async (path9) => {
+  await fs18.rm(join20(directory, path9), { recursive: true });
+  invalidateFileCache();
+};
+var rmFlowById = (directory) => async (id, version, persistFiles) => {
+  await rmResourceById(directory, id, version, { type: "flow", persistFiles });
+};
+var versionFlow = (directory) => async (id) => versionResource(directory, id);
+var flowHasVersion = (directory) => async (id, version) => {
+  const file = await findFileById(directory, id, version);
+  return !!file;
+};
+var addFileToFlow = (directory) => async (id, file, version) => addFileToResource(directory, id, file, version, { type: "flow" });
+
+// src/graph.ts
+var DEFAULT_DEPTH = Number.POSITIVE_INFINITY;
+var RESOURCE_TYPE_ORDER = [
+  "domain",
+  "system",
+  "service",
+  "agent",
+  "event",
+  "command",
+  "query",
+  "channel",
+  "entity",
+  "container",
+  "data-product",
+  "flow",
+  "adr"
+];
+var typeOrder = new Map(RESOURCE_TYPE_ORDER.map((type, index) => [type, index]));
+var NON_ADR_RESOURCE_TYPES = RESOURCE_TYPE_ORDER.filter((type) => type !== "adr");
+var NESTED_TRAVERSAL_CONCURRENCY = 16;
+var RESOURCE_TYPE_ALIASES = {
+  domains: "domain",
+  systems: "system",
+  services: "service",
+  agents: "agent",
+  events: "event",
+  commands: "command",
+  queries: "query",
+  channels: "channel",
+  entities: "entity",
+  containers: "container",
+  "data-products": "data-product",
+  flows: "flow",
+  adrs: "adr"
+};
+var resourceKey = (resource) => `${resource.type}:${resource.id}:${resource.version}`;
+var toGraphResource = (type, resource) => ({
+  type,
+  id: resource.id,
+  version: resource.version
+});
+var sortResources = (left, right) => {
+  const typeComparison = (typeOrder.get(left.type) || 0) - (typeOrder.get(right.type) || 0);
+  if (typeComparison !== 0) return typeComparison;
+  const idComparison = left.id.localeCompare(right.id);
+  return idComparison !== 0 ? idComparison : left.version.localeCompare(right.version);
+};
+var normalizeResourceType = (type) => {
+  if (!type) return void 0;
+  if (RESOURCE_TYPE_ORDER.includes(type)) return type;
+  return RESOURCE_TYPE_ALIASES[type];
+};
+var indexResources = (resources) => {
+  const byId = /* @__PURE__ */ new Map();
+  const byVersion = /* @__PURE__ */ new Map();
+  for (const resource of resources) {
+    const versions = byId.get(resource.id);
+    if (versions) versions.push(resource);
+    else byId.set(resource.id, [resource]);
+    byVersion.set(`${resource.id}:${resource.version}`, resource);
+  }
+  return { byId, byVersion };
+};
+var pathIncludes = (path9, key) => {
+  let current = path9;
+  while (current) {
+    if (current.key === key) return true;
+    current = current.parent;
+  }
+  return false;
+};
+var mapWithConcurrency = async (items, concurrency, transform) => {
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  const worker = async () => {
+    while (nextIndex < items.length) {
+      const index = nextIndex++;
+      results[index] = await transform(items[index]);
+    }
+  };
+  const workers = Array.from({ length: Math.min(concurrency, items.length) }, worker);
+  await Promise.all(workers);
+  return results;
+};
+var validateDepth = (depth) => {
+  if (!Number.isInteger(depth) || depth < 0) {
+    throw new Error("Graph depth must be a non-negative integer");
+  }
+};
+var getGraph = (directory) => {
+  const graph = async (root, options = {}) => {
+    const depth = options.depth ?? DEFAULT_DEPTH;
+    if (options.depth !== void 0) validateDepth(depth);
+    const collectionLoaders = {
+      domain: getDomains(directory),
+      system: getSystems(directory),
+      service: getServices(directory),
+      agent: getAgents(directory),
+      event: getEvents(directory),
+      command: getCommands(directory),
+      query: getQueries(directory),
+      flow: getFlows(directory),
+      channel: getChannels(directory),
+      entity: getEntities(directory),
+      container: getDataStores(directory),
+      "data-product": getDataProducts(directory),
+      adr: getAdrs(directory)
+    };
+    const latestIndexCache = /* @__PURE__ */ new Map();
+    const allVersionsIndexCache = /* @__PURE__ */ new Map();
+    const adjacencyCache = /* @__PURE__ */ new Map();
+    const loadLatestIndex = (type) => {
+      const cachedIndex = latestIndexCache.get(type);
+      if (cachedIndex) return cachedIndex;
+      const index = collectionLoaders[type]({ latestOnly: true }).then((resources2) => indexResources(resources2 || []));
+      latestIndexCache.set(type, index);
+      return index;
+    };
+    const loadAllVersionsIndex = (type) => {
+      const cachedIndex = allVersionsIndexCache.get(type);
+      if (cachedIndex) return cachedIndex;
+      const latestIndex = latestIndexCache.get(type);
+      const index = Promise.all([collectionLoaders[type](), latestIndex]).then(([resources2, loadedLatestIndex]) => {
+        const allVersionsIndex = indexResources(resources2 || []);
+        for (const [id, latestResources] of loadedLatestIndex?.byId || []) {
+          const latestResource = latestResources[0];
+          if (!latestResource) continue;
+          const key = `${id}:${latestResource.version}`;
+          if (!allVersionsIndex.byVersion.has(key)) continue;
+          allVersionsIndex.byVersion.set(key, latestResource);
+          const versions = allVersionsIndex.byId.get(id);
+          const matchingVersion = versions?.findIndex((resource) => resource.version === latestResource.version) ?? -1;
+          if (versions && matchingVersion !== -1) versions[matchingVersion] = latestResource;
+        }
+        return allVersionsIndex;
+      });
+      allVersionsIndexCache.set(type, index);
+      return index;
+    };
+    const read = async (type, pointer) => {
+      const latestIndex = await loadLatestIndex(type);
+      const latestResource = latestIndex.byId.get(pointer.id)?.[0];
+      if (!pointer.version || pointer.version === "latest") {
+        return latestResource;
+      }
+      if (latestResource?.version === pointer.version) return latestResource;
+      const allVersionsIndex = await loadAllVersionsIndex(type);
+      const exactMatch = allVersionsIndex.byVersion.get(`${pointer.id}:${pointer.version}`);
+      if (exactMatch) return exactMatch;
+      const range = validRange4(pointer.version);
+      if (!range) return void 0;
+      const candidates = allVersionsIndex.byId.get(pointer.id) || [];
+      const version = maxSatisfying(
+        candidates.map((resource) => resource.version),
+        range
+      );
+      return candidates.find((resource) => resource.version === version);
+    };
+    const resolvePointer = async (pointer, candidateTypes) => {
+      const explicitType = normalizeResourceType(pointer.type);
+      if (pointer.type && !explicitType) return [];
+      const types = explicitType ? [explicitType] : candidateTypes;
+      const resolved = await Promise.all(
+        types.map(async (type) => {
+          const resource = await read(type, pointer);
+          return resource && resource.hidden !== true ? { type, resource } : void 0;
+        })
+      );
+      return resolved.filter((resource) => resource !== void 0);
+    };
+    const resolvePointers = async (pointers, candidateTypes) => {
+      const resolved = await Promise.all(pointers.map((pointer) => resolvePointer(pointer, candidateTypes)));
+      return resolved.flat();
+    };
+    let adrTargetIndex;
+    const loadAdrTargetIndex = () => {
+      if (adrTargetIndex) return adrTargetIndex;
+      adrTargetIndex = loadAllVersionsIndex("adr").then((adrIndex) => {
+        const targets = /* @__PURE__ */ new Map();
+        for (const adr of adrIndex.byVersion.values()) {
+          if (adr.hidden === true) continue;
+          for (const pointer of adr.appliesTo || []) {
+            const type = normalizeResourceType(pointer.type);
+            if (!type || type === "adr") continue;
+            const key = `${type}:${pointer.id}`;
+            const entries = targets.get(key);
+            const target = { pointer, resource: adr };
+            if (entries) entries.push(target);
+            else targets.set(key, [target]);
+          }
+        }
+        return targets;
+      });
+      return adrTargetIndex;
+    };
+    const pointerMatchesVersion = (pointer, version) => {
+      if (!pointer.version || pointer.version === "latest") return true;
+      if (pointer.version === version) return true;
+      const range = validRange4(pointer.version);
+      return range ? maxSatisfying([version], range) === version : false;
+    };
+    const getAdrsForResource = async (type, resource) => {
+      if (type === "adr") return [];
+      const targets = (await loadAdrTargetIndex()).get(`${type}:${resource.id}`) || [];
+      return targets.filter(({ pointer }) => pointerMatchesVersion(pointer, resource.version)).map(({ resource: resource2 }) => ({ type: "adr", resource: resource2 }));
+    };
+    const resolveChildren = async (type, resource) => {
+      const children = [];
+      const addPointers = async (pointers, candidateTypes) => {
+        children.push(...await resolvePointers(pointers, candidateTypes));
+      };
+      if (type === "domain") {
+        await addPointers(resource.domains || [], ["domain"]);
+        await addPointers(resource.systems || [], ["system"]);
+        await addPointers(resource.services || [], ["service"]);
+        await addPointers(resource.agents || [], ["agent"]);
+        await addPointers(resource.entities || [], ["entity"]);
+        await addPointers(resource.flows || [], ["flow"]);
+        await addPointers([...resource.dataProducts || [], ...resource["data-products"] || []], ["data-product"]);
+        await addPointers([...resource.sends || [], ...resource.receives || []], ["event", "command", "query"]);
+      } else if (type === "system") {
+        await addPointers(resource.relationships || [], ["system"]);
+        await addPointers(resource.services || [], ["service"]);
+        await addPointers(resource.flows || [], ["flow"]);
+        await addPointers(resource.entities || [], ["entity"]);
+        await addPointers(resource.containers || [], ["container"]);
+      } else if (type === "service" || type === "agent") {
+        await addPointers([...resource.sends || [], ...resource.receives || []], ["event", "command", "query"]);
+        await addPointers(resource.entities || [], ["entity"]);
+        await addPointers(resource.flows || [], ["flow"]);
+        await addPointers([...resource.writesTo || [], ...resource.readsFrom || []], ["container"]);
+      } else if (type === "event" || type === "command" || type === "query") {
+        await addPointers([...resource.channels || [], ...resource.messageChannels || []], ["channel"]);
+      } else if (type === "channel") {
+        await addPointers(resource.routes || [], ["channel"]);
+      } else if (type === "data-product") {
+        await addPointers(
+          [...resource.inputs || [], ...resource.outputs || []],
+          ["event", "command", "query", "channel", "container", "service"]
+        );
+      } else if (type === "flow") {
+        for (const step of resource.steps || []) {
+          if (step.message) await addPointers([step.message], ["event", "command", "query"]);
+          if (step.agent) await addPointers([step.agent], ["agent"]);
+          if (step.service) await addPointers([step.service], ["service"]);
+          if (step.flow) await addPointers([step.flow], ["flow"]);
+          if (step.container) await addPointers([step.container], ["container"]);
+          if (step.dataProduct) await addPointers([step.dataProduct], ["data-product"]);
+        }
+      } else if (type === "adr") {
+        await addPointers(resource.appliesTo || [], NON_ADR_RESOURCE_TYPES);
+        await addPointers(
+          [
+            ...resource.supersedes || [],
+            ...resource.supersededBy || [],
+            ...resource.amends || [],
+            ...resource.amendedBy || [],
+            ...resource.related || []
+          ],
+          ["adr"]
+        );
+      }
+      children.push(...await getAdrsForResource(type, resource));
+      const uniqueChildren = /* @__PURE__ */ new Map();
+      for (const child of children) {
+        const graphResource = toGraphResource(child.type, child.resource);
+        uniqueChildren.set(resourceKey(graphResource), child);
+      }
+      return Array.from(uniqueChildren.values()).sort(
+        (left, right) => sortResources(toGraphResource(left.type, left.resource), toGraphResource(right.type, right.resource))
+      );
+    };
+    const getChildren = (type, resource) => {
+      const key = resourceKey(toGraphResource(type, resource));
+      const cachedChildren = adjacencyCache.get(key);
+      if (cachedChildren) return cachedChildren;
+      const children = resolveChildren(type, resource);
+      adjacencyCache.set(key, children);
+      return children;
+    };
+    const buildNode = async (type, resource, remainingDepth, ancestors) => {
+      const graphResource = toGraphResource(type, resource);
+      const key = resourceKey(graphResource);
+      if (remainingDepth === 0) return { ...graphResource, children: [] };
+      const nextAncestors = { key, parent: ancestors };
+      const resolvedChildren = await getChildren(type, resource);
+      const children = await mapWithConcurrency(
+        resolvedChildren,
+        NESTED_TRAVERSAL_CONCURRENCY,
+        ({ type: childType, resource: childResource }) => {
+          const child = toGraphResource(childType, childResource);
+          if (pathIncludes(nextAncestors, resourceKey(child))) return Promise.resolve({ ...child, children: [] });
+          return buildNode(childType, childResource, remainingDepth - 1, nextAncestors);
+        }
+      );
+      return { ...graphResource, children };
+    };
+    const rootResource = await read(root.type, root);
+    if (!rootResource || rootResource.hidden === true) return void 0;
+    const flatRoot = toGraphResource(root.type, rootResource);
+    if (!options.flat) {
+      const nestedRoot = await buildNode(root.type, rootResource, depth);
+      return { root: nestedRoot };
+    }
+    const flatRootKey = resourceKey(flatRoot);
+    const resources = /* @__PURE__ */ new Map([[flatRootKey, flatRoot]]);
+    const visited = /* @__PURE__ */ new Set([flatRootKey]);
+    const queue = [
+      { type: root.type, resource: rootResource, remainingDepth: depth }
+    ];
+    for (let index = 0; index < queue.length; index++) {
+      const current = queue[index];
+      if (current.remainingDepth === 0) continue;
+      const children = await getChildren(current.type, current.resource);
+      for (const child of children) {
+        const graphResource = toGraphResource(child.type, child.resource);
+        const key = resourceKey(graphResource);
+        if (visited.has(key)) continue;
+        visited.add(key);
+        resources.set(key, graphResource);
+        queue.push({ ...child, remainingDepth: current.remainingDepth - 1 });
+      }
+    }
+    const relatedResources = Array.from(resources.values()).filter((resource) => resourceKey(resource) !== flatRootKey).sort(sortResources);
+    return {
+      root: flatRoot,
+      resources: [flatRoot, ...relatedResources]
+    };
+  };
+  return graph;
+};
+
+// src/snapshots.ts
+import fs19 from "fs";
+import path7 from "path";
+import { createHash } from "crypto";
+import { execSync } from "child_process";
+import { compare } from "semver";
+
+// src/snapshot-diff.ts
+var stableStringify = (value) => {
+  if (value === null || value === void 0 || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return "[" + value.map(stableStringify).join(",") + "]";
+  }
+  const sorted = Object.keys(value).sort().map((key) => JSON.stringify(key) + ":" + stableStringify(value[key]));
+  return "{" + sorted.join(",") + "}";
+};
+var flattenResources = (snapshot) => {
+  const resources = [];
+  const addResources = (items, type) => {
+    for (const item of items) {
+      resources.push({
+        resourceId: item.id,
+        version: item.version,
+        type,
+        data: item
+      });
+    }
+  };
+  addResources(snapshot.resources.domains, "domain");
+  addResources(snapshot.resources.services, "service");
+  addResources(snapshot.resources.agents || [], "agent");
+  addResources(snapshot.resources.messages.events, "event");
+  addResources(snapshot.resources.messages.commands, "command");
+  addResources(snapshot.resources.messages.queries, "query");
+  addResources(snapshot.resources.channels, "channel");
+  return resources;
+};
+var EXCLUDED_FIELDS = /* @__PURE__ */ new Set(["markdown", "_eventcatalog"]);
+var getComparableFields = (data) => {
+  const result = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (!EXCLUDED_FIELDS.has(key)) {
+      result[key] = value;
+    }
+  }
+  return result;
+};
+var findChangedFields = (dataA, dataB) => {
+  const fieldsA = getComparableFields(dataA);
+  const fieldsB = getComparableFields(dataB);
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(fieldsA), ...Object.keys(fieldsB)]);
+  const changed = [];
+  for (const key of allKeys) {
+    if (stableStringify(fieldsA[key] ?? null) !== stableStringify(fieldsB[key] ?? null)) {
+      changed.push(key);
+    }
+  }
+  return changed;
+};
+var resourceKey2 = (r) => `${r.resourceId}@${r.version}`;
+var idTypeKey = (r) => `${r.resourceId}:${r.type}`;
+var computeResourceDiff = (snapshotA, snapshotB) => {
+  const resourcesA = flattenResources(snapshotA);
+  const resourcesB = flattenResources(snapshotB);
+  const mapA = /* @__PURE__ */ new Map();
+  const byIdA = /* @__PURE__ */ new Map();
+  for (const r of resourcesA) {
+    mapA.set(resourceKey2(r), r);
+    byIdA.set(idTypeKey(r), r);
+  }
+  const mapB = /* @__PURE__ */ new Map();
+  const byIdB = /* @__PURE__ */ new Map();
+  for (const r of resourcesB) {
+    mapB.set(resourceKey2(r), r);
+    byIdB.set(idTypeKey(r), r);
+  }
+  const changes = [];
+  const handledIds = /* @__PURE__ */ new Set();
+  for (const resource of resourcesB) {
+    const key = resourceKey2(resource);
+    if (!mapA.has(key)) {
+      const idKey = idTypeKey(resource);
+      const oldResource = byIdA.get(idKey);
+      if (oldResource && oldResource.version !== resource.version && !handledIds.has(idKey)) {
+        const changedFields = findChangedFields(oldResource.data, resource.data);
+        changes.push({
+          resourceId: resource.resourceId,
+          version: resource.version,
+          type: resource.type,
+          changeType: "versioned",
+          previousVersion: oldResource.version,
+          newVersion: resource.version,
+          changedFields: changedFields.length > 0 ? changedFields : void 0
+        });
+        handledIds.add(idKey);
+      } else if (!handledIds.has(idKey)) {
+        changes.push({
+          resourceId: resource.resourceId,
+          version: resource.version,
+          type: resource.type,
+          changeType: "added"
+        });
+      }
+    }
+  }
+  for (const resource of resourcesA) {
+    const key = resourceKey2(resource);
+    if (!mapB.has(key)) {
+      const idKey = idTypeKey(resource);
+      if (!handledIds.has(idKey)) {
+        changes.push({
+          resourceId: resource.resourceId,
+          version: resource.version,
+          type: resource.type,
+          changeType: "removed"
+        });
+      }
+    }
+  }
+  for (const resourceB of resourcesB) {
+    const key = resourceKey2(resourceB);
+    const resourceA = mapA.get(key);
+    if (resourceA) {
+      const changedFields = findChangedFields(resourceA.data, resourceB.data);
+      if (changedFields.length > 0) {
+        changes.push({
+          resourceId: resourceB.resourceId,
+          version: resourceB.version,
+          type: resourceB.type,
+          changeType: "modified",
+          changedFields
+        });
+      }
+    }
+  }
+  return changes;
+};
+var getRelationshipKey = (serviceId, resourceId, resourceVersion, direction) => {
+  return `${serviceId}:${direction}:${resourceId}@${resourceVersion || "latest"}`;
+};
+var extractRelationships = (snapshot) => {
+  const relationships = /* @__PURE__ */ new Map();
+  for (const service of [...snapshot.resources.services, ...snapshot.resources.agents || []]) {
+    for (const direction of ["sends", "receives"]) {
+      const pointers = service[direction] || [];
+      for (const pointer of pointers) {
+        const key = getRelationshipKey(service.id, pointer.id, pointer.version, direction);
+        relationships.set(key, {
+          serviceId: service.id,
+          serviceVersion: service.version,
+          resourceId: pointer.id,
+          resourceVersion: pointer.version,
+          direction
+        });
+      }
+    }
+  }
+  return relationships;
+};
+var computeRelationshipDiff = (snapshotA, snapshotB) => {
+  const relsA = extractRelationships(snapshotA);
+  const relsB = extractRelationships(snapshotB);
+  const changes = [];
+  for (const [key, rel] of relsB) {
+    if (!relsA.has(key)) {
+      changes.push({ ...rel, changeType: "added" });
+    }
+  }
+  for (const [key, rel] of relsA) {
+    if (!relsB.has(key)) {
+      changes.push({ ...rel, changeType: "removed" });
+    }
+  }
+  return changes;
+};
+
+// src/snapshots.ts
+var SNAPSHOT_VERSION = "1.0.0";
+var getEventCatalogVersion2 = (catalogDir) => {
+  try {
+    const packageJson = fs19.readFileSync(path7.join(catalogDir, "package.json"), "utf8");
+    const packageJsonObject = JSON.parse(packageJson);
+    return packageJsonObject["dependencies"]?.["@eventcatalog/core"] ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+};
+var pickCoreFields = (resource) => {
+  const picked = { id: resource.id, version: resource.version, name: resource.name };
+  if (resource.sends) picked.sends = resource.sends;
+  if (resource.receives) picked.receives = resource.receives;
+  if (resource.deprecated) picked.deprecated = resource.deprecated;
+  if (resource.owners) picked.owners = resource.owners;
+  if (resource.schemaPath) picked.schemaPath = resource.schemaPath;
+  if (resource.schemaHash) picked.schemaHash = resource.schemaHash;
+  return picked;
+};
+var deduplicateByLatestVersion = (resources) => {
+  const seen = /* @__PURE__ */ new Map();
+  for (const r of resources) {
+    const existing = seen.get(r.id);
+    if (!existing || compare(r.version, existing.version) > 0) {
+      seen.set(r.id, r);
+    }
+  }
+  return Array.from(seen.values());
+};
+var stripToCore = (resources) => {
+  if (!resources || resources.length === 0) return [];
+  return deduplicateByLatestVersion(resources).map(pickCoreFields);
+};
+var detectGitInfo = (catalogDir) => {
+  try {
+    const opts = { cwd: catalogDir, encoding: "utf8", stdio: "pipe" };
+    const branch = execSync("git rev-parse --abbrev-ref HEAD", opts).trim();
+    const commit = execSync("git rev-parse --short HEAD", opts).trim();
+    const status = execSync("git status --porcelain", opts).trim();
+    return { branch, commit, dirty: status.length > 0 };
+  } catch {
+    return void 0;
+  }
+};
+var enrichWithSchemaHashes = async (getSchemaForMessage2, resources) => {
+  await Promise.all(
+    resources.map(async (resource) => {
+      if (!resource.schemaPath) return;
+      const schema = await getSchemaForMessage2(resource.id, resource.version);
+      if (!schema) return;
+      resource.schemaHash = createHash("sha256").update(schema.schema).digest("hex");
+    })
+  );
+};
+var createSnapshot = (directory) => {
+  return async (options) => {
+    const { label, outputDir, git } = options || {};
+    const sdk = src_default(directory);
+    const [domains, services, agents, events, commands, queries, channels] = await Promise.all([
+      sdk.getDomains(),
+      sdk.getServices(),
+      sdk.getAgents(),
+      sdk.getEvents(),
+      sdk.getCommands(),
+      sdk.getQueries(),
+      sdk.getChannels()
+    ]);
+    await Promise.all([
+      enrichWithSchemaHashes(sdk.getSchemaForMessage, events || []),
+      enrichWithSchemaHashes(sdk.getSchemaForMessage, commands || []),
+      enrichWithSchemaHashes(sdk.getSchemaForMessage, queries || [])
+    ]);
+    const snapshotDomains = stripToCore(domains);
+    const snapshotServices = stripToCore(services);
+    const snapshotAgents = stripToCore(agents);
+    const snapshotEvents = stripToCore(events);
+    const snapshotCommands = stripToCore(commands);
+    const snapshotQueries = stripToCore(queries);
+    const snapshotChannels = stripToCore(channels);
+    const snapshotLabel = label || (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const gitInfo = git || detectGitInfo(directory);
+    const snapshot = {
+      snapshotVersion: SNAPSHOT_VERSION,
+      catalogVersion: getEventCatalogVersion2(directory),
+      label: snapshotLabel,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...gitInfo ? { git: gitInfo } : {},
+      resources: {
+        domains: snapshotDomains,
+        services: snapshotServices,
+        agents: snapshotAgents,
+        messages: {
+          events: snapshotEvents,
+          commands: snapshotCommands,
+          queries: snapshotQueries
+        },
+        channels: snapshotChannels
+      }
+    };
+    const snapshotsDir = outputDir || path7.join(directory, ".snapshots");
+    fs19.mkdirSync(snapshotsDir, { recursive: true });
+    const fileName = `${snapshotLabel}.snapshot.json`;
+    const filePath = path7.join(snapshotsDir, fileName);
+    fs19.writeFileSync(filePath, JSON.stringify(snapshot));
+    return { filePath, snapshot };
+  };
 };
-var writeFlowToService = (directory) => async (flow, service, options = { path: "", format: "mdx", override: false }) => {
-  let pathForFlow = service.version && service.version !== "latest" ? `/${service.id}/versioned/${service.version}/flows` : `/${service.id}/flows`;
-  pathForFlow = join17(pathForFlow, flow.id);
-  await writeResource(directory, { ...flow }, { ...options, path: pathForFlow, type: "flow" });
+var diffSnapshots = (directory) => async (snapshotAPath, snapshotBPath) => {
+  const snapshotA = JSON.parse(fs19.readFileSync(snapshotAPath, "utf-8"));
+  const snapshotB = JSON.parse(fs19.readFileSync(snapshotBPath, "utf-8"));
+  const resourceChanges = computeResourceDiff(snapshotA, snapshotB);
+  const relationshipChanges = computeRelationshipDiff(snapshotA, snapshotB);
+  const resourceCounts = { added: 0, removed: 0, modified: 0, versioned: 0 };
+  for (const r of resourceChanges) resourceCounts[r.changeType]++;
+  const relCounts = { added: 0, removed: 0 };
+  for (const r of relationshipChanges) relCounts[r.changeType]++;
+  return {
+    snapshotA: { label: snapshotA.label, createdAt: snapshotA.createdAt },
+    snapshotB: { label: snapshotB.label, createdAt: snapshotB.createdAt },
+    summary: {
+      totalChanges: resourceChanges.length + relationshipChanges.length,
+      resourcesAdded: resourceCounts.added,
+      resourcesRemoved: resourceCounts.removed,
+      resourcesModified: resourceCounts.modified,
+      resourcesVersioned: resourceCounts.versioned,
+      relationshipsAdded: relCounts.added,
+      relationshipsRemoved: relCounts.removed
+    },
+    resources: resourceChanges,
+    relationships: relationshipChanges
+  };
 };
-var writeFlowToSystem = (directory) => async (flow, system, options = { path: "", format: "mdx", override: false }) => {
-  const resourcePath = await getResourcePath(directory, system.id, system.version);
-  if (!resourcePath) {
-    throw new Error("System not found");
+var listSnapshots = (directory) => async () => {
+  const snapshotsDir = path7.join(directory, ".snapshots");
+  if (!fs19.existsSync(snapshotsDir)) return [];
+  const files = fs19.readdirSync(snapshotsDir).filter((f) => f.endsWith(".snapshot.json"));
+  const snapshots = [];
+  for (const file of files) {
+    try {
+      const filePath = path7.join(snapshotsDir, file);
+      const content = JSON.parse(fs19.readFileSync(filePath, "utf-8"));
+      snapshots.push({
+        label: content.label,
+        createdAt: content.createdAt,
+        filePath,
+        ...content.git ? { git: content.git } : {}
+      });
+    } catch {
+    }
   }
-  const pathForFlow = join17(resourcePath.directory, "flows", flow.id);
-  await writeResource(directory, { ...flow }, { ...options, path: pathForFlow, type: "flow" });
-};
-var writeFlowToAgent = (directory) => async (flow, agent, options = { path: "", format: "mdx", override: false }) => {
-  let pathForFlow = agent.version && agent.version !== "latest" ? `/${agent.id}/versioned/${agent.version}/flows` : `/${agent.id}/flows`;
-  pathForFlow = join17(pathForFlow, flow.id);
-  await writeResource(directory, { ...flow }, { ...options, path: pathForFlow, type: "flow" });
-};
-var rmFlow = (directory) => async (path9) => {
-  await fs17.rm(join17(directory, path9), { recursive: true });
-  invalidateFileCache();
-};
-var rmFlowById = (directory) => async (id, version, persistFiles) => {
-  await rmResourceById(directory, id, version, { type: "flow", persistFiles });
-};
-var versionFlow = (directory) => async (id) => versionResource(directory, id);
-var flowHasVersion = (directory) => async (id, version) => {
-  const file = await findFileById(directory, id, version);
-  return !!file;
+  return snapshots.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
 };
-var addFileToFlow = (directory) => async (id, file, version) => addFileToResource(directory, id, file, version, { type: "flow" });
 
-// src/containers.ts
-import fs18 from "fs/promises";
-import { join as join18 } from "path";
-var getContainer = (directory) => async (id, version) => getResource(directory, id, version, { type: "container" });
-var getContainers = (directory) => async (options) => getResources(directory, { type: "containers", latestOnly: options?.latestOnly });
-var writeContainer = (directory) => async (data, options = {
-  path: "",
-  override: false,
-  format: "mdx"
-}) => writeResource(directory, { ...data }, { ...options, type: "container" });
-var versionContainer = (directory) => async (id) => versionResource(directory, id);
-var rmContainer = (directory) => async (path9) => {
-  await fs18.rm(join18(directory, path9), { recursive: true });
+// src/changelogs.ts
+import path8, { dirname as dirname7 } from "path";
+import fsSync8 from "fs";
+import fs20 from "fs/promises";
+import matter8 from "gray-matter";
+var writeChangelog = (catalogDir) => async (id, changelog, options = {}) => {
+  const { version, format = "mdx" } = options;
+  const resourceFile = await findFileById(catalogDir, id, version);
+  if (!resourceFile) {
+    throw new Error(`No resource found with id: ${id}${version ? ` and version: ${version}` : ""}`);
+  }
+  const resourceDir = dirname7(resourceFile);
+  const changelogPath = path8.join(resourceDir, `changelog.${format}`);
+  const { markdown, ...frontmatter } = changelog;
+  const fm = { ...frontmatter };
+  if (fm.createdAt instanceof Date) {
+    fm.createdAt = fm.createdAt;
+  }
+  if (!fm.badges || fm.badges.length === 0) {
+    delete fm.badges;
+  }
+  fsSync8.mkdirSync(resourceDir, { recursive: true });
+  const document = matter8.stringify(markdown.trim(), fm);
+  fsSync8.writeFileSync(changelogPath, document);
   invalidateFileCache();
 };
-var rmContainerById = (directory) => async (id, version, persistFiles) => {
-  await rmResourceById(directory, id, version, { type: "container", persistFiles });
-};
-var containerHasVersion = (directory) => async (id, version) => {
-  const file = await findFileById(directory, id, version);
-  return !!file;
-};
-var addFileToContainer = (directory) => async (id, file, version) => addFileToResource(directory, id, file, version);
-var writeContainerToService = (directory) => async (container, service, options = { path: "", format: "mdx", override: false }) => {
-  const resourcePath = await getResourcePath(directory, service.id, service.version);
-  if (!resourcePath) {
-    throw new Error("Service not found");
+var appendChangelog = (catalogDir) => async (id, changelog, options = {}) => {
+  const { version, format = "mdx" } = options;
+  const resourceFile = await findFileById(catalogDir, id, version);
+  if (!resourceFile) {
+    throw new Error(`No resource found with id: ${id}${version ? ` and version: ${version}` : ""}`);
   }
-  let pathForContainer = service.version && service.version !== "latest" ? `${resourcePath.directory}/versioned/${service.version}/containers` : `${resourcePath.directory}/containers`;
-  pathForContainer = join18(pathForContainer, container.id);
-  await writeResource(directory, { ...container }, { ...options, path: pathForContainer, type: "container" });
-};
-var writeContainerToSystem = (directory) => async (container, system, options = { path: "", format: "mdx", override: false }) => {
-  const resourcePath = await getResourcePath(directory, system.id, system.version);
-  if (!resourcePath) {
-    throw new Error("System not found");
+  const resourceDir = dirname7(resourceFile);
+  const mdxPath = path8.join(resourceDir, "changelog.mdx");
+  const mdPath = path8.join(resourceDir, "changelog.md");
+  const existingPath = fsSync8.existsSync(mdxPath) ? mdxPath : fsSync8.existsSync(mdPath) ? mdPath : void 0;
+  if (!existingPath) {
+    return writeChangelog(catalogDir)(id, changelog, options);
   }
-  const pathForContainer = join18(resourcePath.directory, "containers", container.id);
-  await writeResource(directory, { ...container }, { ...options, path: pathForContainer, type: "container" });
-};
+  const existing = matter8.read(existingPath);
+  const existingContent = existing.content.trim();
+  const newEntry = changelog.markdown.trim();
+  const combined = `${newEntry}
 
-// src/data-stores.ts
-var getDataStore = getContainer;
-var getDataStores = getContainers;
-var writeDataStore = writeContainer;
-var versionDataStore = versionContainer;
-var rmDataStore = rmContainer;
-var rmDataStoreById = rmContainerById;
-var dataStoreHasVersion = containerHasVersion;
-var addFileToDataStore = addFileToContainer;
-var writeDataStoreToService = writeContainerToService;
-var writeDataStoreToSystem = writeContainerToSystem;
+---
 
-// src/data-products.ts
-import fs19 from "fs/promises";
-import { join as join19 } from "path";
-var getDataProduct = (directory) => async (id, version) => getResource(directory, id, version, { type: "data-product" });
-var getDataProducts = (directory) => async (options) => getResources(directory, { type: "data-products", latestOnly: options?.latestOnly });
-var writeDataProduct = (directory) => async (dataProduct, options = {
-  path: "",
-  override: false,
-  format: "mdx"
-}) => writeResource(directory, { ...dataProduct }, { ...options, type: "data-product" });
-var writeDataProductToDomain = (directory) => async (dataProduct, domain, options = { path: "", format: "mdx", override: false }) => {
-  let pathForDataProduct = domain.version && domain.version !== "latest" ? `/${domain.id}/versioned/${domain.version}/data-products` : `/${domain.id}/data-products`;
-  pathForDataProduct = join19(pathForDataProduct, dataProduct.id);
-  await writeResource(directory, { ...dataProduct }, { ...options, path: pathForDataProduct, type: "data-product" });
-};
-var rmDataProduct = (directory) => async (path9) => {
-  await fs19.rm(join19(directory, path9), { recursive: true });
+${existingContent}`;
+  const fm = { ...existing.data };
+  fm.createdAt = changelog.createdAt;
+  if (changelog.badges && changelog.badges.length > 0) {
+    fm.badges = changelog.badges;
+  } else {
+    delete fm.badges;
+  }
+  const document = matter8.stringify(combined, fm);
+  fsSync8.writeFileSync(existingPath, document);
   invalidateFileCache();
 };
-var rmDataProductById = (directory) => async (id, version, persistFiles) => {
-  await rmResourceById(directory, id, version, { type: "data-product", persistFiles });
+var getChangelog = (catalogDir) => async (id, options = {}) => {
+  const { version } = options;
+  const resourceFile = await findFileById(catalogDir, id, version);
+  if (!resourceFile) return void 0;
+  const resourceDir = dirname7(resourceFile);
+  const mdxPath = path8.join(resourceDir, "changelog.mdx");
+  const mdPath = path8.join(resourceDir, "changelog.md");
+  const changelogPath = fsSync8.existsSync(mdxPath) ? mdxPath : fsSync8.existsSync(mdPath) ? mdPath : void 0;
+  if (!changelogPath) return void 0;
+  const { data, content } = matter8.read(changelogPath);
+  return { ...data, markdown: content.trim() };
 };
-var versionDataProduct = (directory) => async (id) => versionResource(directory, id);
-var dataProductHasVersion = (directory) => async (id, version) => {
-  const file = await findFileById(directory, id, version);
-  return !!file;
+var rmChangelog = (catalogDir) => async (id, options = {}) => {
+  const { version } = options;
+  const resourceFile = await findFileById(catalogDir, id, version);
+  if (!resourceFile) {
+    throw new Error(`No resource found with id: ${id}${version ? ` and version: ${version}` : ""}`);
+  }
+  const resourceDir = dirname7(resourceFile);
+  const mdxPath = path8.join(resourceDir, "changelog.mdx");
+  const mdPath = path8.join(resourceDir, "changelog.md");
+  if (fsSync8.existsSync(mdxPath)) {
+    await fs20.rm(mdxPath);
+  }
+  if (fsSync8.existsSync(mdPath)) {
+    await fs20.rm(mdPath);
+  }
+  invalidateFileCache();
 };
-var addFileToDataProduct = (directory) => async (id, file, version) => addFileToResource(directory, id, file, version);
 
 // src/diagrams.ts
-import fs20 from "fs/promises";
-import { join as join20 } from "path";
+import fs21 from "fs/promises";
+import { join as join21 } from "path";
 var getDiagram = (directory) => async (id, version) => getResource(directory, id, version, { type: "diagram" });
 var getDiagrams = (directory) => async (options) => getResources(directory, { type: "diagrams", latestOnly: options?.latestOnly });
 var writeDiagram = (directory) => async (diagram, options = {
@@ -3495,7 +3854,7 @@ var writeDiagram = (directory) => async (diagram, options = {
   format: "mdx"
 }) => writeResource(directory, { ...diagram }, { ...options, type: "diagram" });
 var rmDiagram = (directory) => async (path9) => {
-  await fs20.rm(join20(directory, path9), { recursive: true });
+  await fs21.rm(join21(directory, path9), { recursive: true });
   invalidateFileCache();
 };
 var rmDiagramById = (directory) => async (id, version, persistFiles) => {
@@ -3508,30 +3867,6 @@ var diagramHasVersion = (directory) => async (id, version) => {
 };
 var addFileToDiagram = (directory) => async (id, file, version) => addFileToResource(directory, id, file, version, { type: "diagram" });
 
-// src/adrs.ts
-import fs21 from "fs/promises";
-import { join as join21 } from "path";
-var getAdr = (directory) => async (id, version) => getResource(directory, id, version, { type: "adr" });
-var getAdrs = (directory) => async (options) => getResources(directory, { type: "adrs", latestOnly: options?.latestOnly });
-var writeAdr = (directory) => async (adr, options = {
-  path: "",
-  override: false,
-  format: "mdx"
-}) => writeResource(directory, { ...adr }, { ...options, type: "adr" });
-var rmAdr = (directory) => async (path9) => {
-  await fs21.rm(join21(directory, path9), { recursive: true });
-  invalidateFileCache();
-};
-var rmAdrById = (directory) => async (id, version, persistFiles) => {
-  await rmResourceById(directory, id, version, { type: "adr", persistFiles });
-};
-var versionAdr = (directory) => async (id) => versionResource(directory, id);
-var adrHasVersion = (directory) => async (id, version) => {
-  const file = await findFileById(directory, id, version);
-  return !!file;
-};
-var addFileToAdr = (directory) => async (id, file, version) => addFileToResource(directory, id, file, version, { type: "adr" });
-
 // src/index.ts
 var src_default = (path9) => {
   return {
@@ -4426,6 +4761,13 @@ var src_default = (path9) => {
      * @returns A JSON file with the catalog
      */
     dumpCatalog: dumpCatalog(join22(path9)),
+    /**
+     * Returns the resources reachable from a catalog resource.
+     * @param root - Resource to use as the root of the graph
+     * @param options - Traversal depth and whether to return a flat resource list
+     * @returns The resolved graph, or undefined when the root does not exist
+     */
+    getGraph: getGraph(join22(path9)),
     /**
      * Returns the event catalog configuration file.
      * The event catalog configuration file is the file that contains the configuration for the event catalog.