aact 1.0.0 → 2.0.1

package/dist/shared/aact.Dqryafrg.mjs

@@ -0,0 +1,744 @@
+import * as v from 'valibot';
+import YAML from 'yaml';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { Comment, Stdlib_C4_Dynamic_Rel, Relationship, parse, Stdlib_C4_Container_Component, Stdlib_C4_Context, Stdlib_C4_Boundary } from 'plantuml-parser';
+
+const apiTechnologies = ["http", "grpc", "tcp"];
+const allRelations = (model) => model.allContainers.flatMap(
+  (container) => container.relations.map((relation) => ({ from: container, relation }))
+);
+const boundaryContainsName = (boundary, name) => boundary.containers.some((c) => c.name === name);
+const classifyRelation = (boundary, parentBoundary, from, relation, result, parentResult) => {
+  if (!boundaryContainsName(boundary, from.name)) return;
+  if (boundaryContainsName(boundary, relation.to.name)) {
+    result.cohesion++;
+    return;
+  }
+  const isInParentSibling = parentBoundary?.boundaries.some(
+    (b) => b.containers.some((c) => c.name === relation.to.name)
+  ) ?? false;
+  if (!parentBoundary || isInParentSibling) {
+    result.coupling++;
+    result.couplingRelations.push({ from: from.name, to: relation.to.name });
+    if (parentResult) parentResult.cohesion++;
+  } else if (parentResult) {
+    parentResult.coupling++;
+    parentResult.couplingRelations.push({
+      from: from.name,
+      to: relation.to.name
+    });
+  }
+};
+const analyzeModel = (model) => {
+  const relations = allRelations(model);
+  const asyncApiCalls = relations.filter(
+    (it) => it.relation.tags?.includes("async")
+  );
+  const syncApiCalls = relations.filter((it) => {
+    const isExternalApi = it.relation.to.type === "System_Ext";
+    const isApiTechnology = apiTechnologies.some(
+      (apiTechn) => (it.relation.technology ?? "").toLowerCase().includes(apiTechn)
+    );
+    return !it.relation.tags?.includes("async") && (isExternalApi || isApiTechnology);
+  });
+  const boundaryResults = /* @__PURE__ */ new Map();
+  for (const boundary of model.boundaries) {
+    boundaryResults.set(boundary.name, {
+      name: boundary.name,
+      label: boundary.label,
+      cohesion: 0,
+      coupling: 0,
+      couplingRelations: []
+    });
+  }
+  for (const boundary of model.boundaries) {
+    const parentBoundary = model.boundaries.find(
+      (b) => b.boundaries.some((child) => child.name === boundary.name)
+    );
+    const result = boundaryResults.get(boundary.name);
+    const parentResult = parentBoundary ? boundaryResults.get(parentBoundary.name) : void 0;
+    for (const { from, relation } of relations) {
+      classifyRelation(
+        boundary,
+        parentBoundary,
+        from,
+        relation,
+        result,
+        parentResult
+      );
+    }
+  }
+  return {
+    elementsCount: model.allContainers.length,
+    syncApiCalls: syncApiCalls.length,
+    asyncApiCalls: asyncApiCalls.length,
+    databases: analyzeDatabases(model),
+    boundaries: [...boundaryResults.values()]
+  };
+};
+const analyzeDatabases = (model) => {
+  const dbContainers = model.allContainers.filter(
+    (it) => it.type === "ContainerDb"
+  );
+  const dbRelations = model.allContainers.flatMap(
+    (container) => container.relations.filter(
+      (r) => dbContainers.some((db) => db.name === r.to.name)
+    )
+  );
+  return {
+    count: dbContainers.length,
+    consumes: dbRelations.length
+  };
+};
+const analyzeArchitecture = (model) => {
+  return {
+    model,
+    report: analyzeModel(model)
+  };
+};
+
+const ruleOption = (entries) => v.optional(v.union([v.boolean(), v.strictObject(entries)]));
+const AactConfigSchema = v.strictObject({
+  source: v.strictObject({
+    type: v.picklist(["plantuml", "structurizr"]),
+    path: v.string()
+  }),
+  rules: v.optional(
+    v.strictObject({
+      acl: ruleOption({
+        tag: v.optional(v.string()),
+        externalType: v.optional(v.string())
+      }),
+      acyclic: v.optional(v.boolean()),
+      apiGateway: ruleOption({
+        aclTag: v.optional(v.string()),
+        externalType: v.optional(v.string()),
+        gatewayPattern: v.optional(v.instance(RegExp))
+      }),
+      crud: ruleOption({
+        repoTags: v.optional(v.array(v.string())),
+        dbType: v.optional(v.string())
+      }),
+      dbPerService: ruleOption({
+        dbType: v.optional(v.string())
+      }),
+      cohesion: ruleOption({
+        externalType: v.optional(v.string()),
+        internalType: v.optional(v.string())
+      }),
+      stableDependencies: ruleOption({
+        externalType: v.optional(v.string())
+      })
+    })
+  ),
+  generate: v.optional(
+    v.strictObject({
+      kubernetes: v.optional(
+        v.strictObject({
+          path: v.optional(v.string()),
+          exclude: v.optional(v.array(v.string()))
+        })
+      ),
+      boundaryLabel: v.optional(v.string())
+    })
+  )
+});
+const defineConfig = (config) => config;
+
+const toKebab = (name) => name.replaceAll("_", "-");
+const toEnvKey = (name) => name.replaceAll("-", "_").toUpperCase();
+const buildEnvVar = (relation, sourceKebab, options) => {
+  const targetType = relation.to.type;
+  const targetKebab = toKebab(relation.to.name);
+  const targetUpper = toEnvKey(targetKebab);
+  if (targetType === "ContainerDb") {
+    const value = options.dbConnectionTemplate.replaceAll(
+      "{name}",
+      sourceKebab
+    );
+    return { key: "PG_CONNECTION_STRING", value };
+  }
+  if (relation.tags?.includes("async")) {
+    const value = relation.technology ?? targetKebab;
+    return { key: `KAFKA_${targetUpper}_TOPIC`, value };
+  }
+  if (targetType === "System_Ext") {
+    const value = relation.technology ?? `https://${targetKebab}`;
+    return { key: `${targetUpper}_BASE_URL`, value };
+  }
+  if (targetType === "Container") {
+    const value = relation.technology ?? `http://${targetKebab}:${options.defaultPort}`;
+    return { key: `${targetUpper}_BASE_URL`, value };
+  }
+  return void 0;
+};
+const generateKubernetes = (model, options) => {
+  const defaultPort = options?.defaultPort ?? 8080;
+  const dbConnectionTemplate = options?.dbConnectionTemplate ?? "postgresql://{name}:pass-{name}@postgresql:5432/{name}";
+  const resolvedOptions = { defaultPort, dbConnectionTemplate };
+  const containers = model.allContainers.filter(
+    (c) => c.type !== "ContainerDb" && c.type !== "System_Ext"
+  );
+  return containers.map((container) => {
+    const kebabName = toKebab(container.name);
+    const envEntries = [];
+    for (const relation of container.relations) {
+      const entry = buildEnvVar(relation, kebabName, resolvedOptions);
+      if (entry) {
+        envEntries.push(entry);
+      }
+    }
+    envEntries.sort((a, b) => a.key.localeCompare(b.key));
+    const doc = { name: kebabName };
+    if (envEntries.length > 0) {
+      const environment = {};
+      for (const { key, value } of envEntries) {
+        environment[key] = { default: value };
+      }
+      doc.environment = environment;
+    }
+    return {
+      fileName: `${kebabName}.yml`,
+      content: YAML.stringify(doc)
+    };
+  });
+};
+
+const containerTypeMap = {
+  Container: "Container",
+  ContainerDb: "ContainerDb",
+  System_Ext: "System_Ext",
+  Person: "Person"
+};
+const renderContainer = (container) => {
+  const type = containerTypeMap[container.type ?? "Container"] ?? "Container";
+  const tags = container.tags && container.tags.length > 0 ? `, $tags="${container.tags.join("+")}"` : "";
+  const desc = container.description ? `, "${container.description}"` : "";
+  return `${type}(${container.name}, "${container.label}"${desc}${tags})`;
+};
+const renderBoundary = (boundary, indent) => {
+  const inner = indent + "  ";
+  const children = [
+    ...boundary.boundaries.map((child) => renderBoundary(child, inner)),
+    ...boundary.containers.map(
+      (container) => `${inner}${renderContainer(container)}`
+    )
+  ];
+  return [
+    `${indent}Boundary(${boundary.name}, "${boundary.label}") {`,
+    ...children,
+    `${indent}}`
+  ].join("\n");
+};
+const renderRelation = (container, relation) => {
+  const tech = relation.technology ? `, "${relation.technology}"` : "";
+  const tags = relation.tags && relation.tags.length > 0 ? `, $tags="${relation.tags.join("+")}"` : "";
+  return `Rel(${container.name}, ${relation.to.name}, ""${tech}${tags})`;
+};
+const collectBoundaryContainerNames = (boundaries) => {
+  const names = /* @__PURE__ */ new Set();
+  const collect = (boundary) => {
+    for (const c of boundary.containers) names.add(c.name);
+    for (const b of boundary.boundaries) collect(b);
+  };
+  for (const boundary of boundaries) collect(boundary);
+  return names;
+};
+const renderBody = (model, standaloneContainers, boundaryLabel) => {
+  if (boundaryLabel) {
+    return [
+      `Boundary(project, "${boundaryLabel}") {`,
+      ...model.boundaries.map((b) => renderBoundary(b, "  ")),
+      ...standaloneContainers.map((c) => `  ${renderContainer(c)}`),
+      `}`
+    ];
+  }
+  return [
+    ...model.boundaries.map((b) => renderBoundary(b, "")),
+    ...standaloneContainers.map((c) => renderContainer(c))
+  ];
+};
+const generatePlantumlFromModel = (model, options) => {
+  const boundaryNames = collectBoundaryContainerNames(model.boundaries);
+  const standaloneContainers = model.allContainers.filter(
+    (c) => !boundaryNames.has(c.name)
+  );
+  const relations = model.allContainers.flatMap(
+    (container) => container.relations.map((rel) => renderRelation(container, rel))
+  );
+  return [
+    `@startuml`,
+    `!include https://raw.githubusercontent.com/plantuml-stdlib/C4-PlantUML/master/C4_Container.puml`,
+    `LAYOUT_WITH_LEGEND()`,
+    `AddRelTag("async", $lineStyle = DottedLine())`,
+    "",
+    ...renderBody(model, standaloneContainers, options?.boundaryLabel),
+    "",
+    ...relations,
+    "@enduml"
+  ].join("\n");
+};
+
+const filterElements = (elements) => {
+  const result = [];
+  for (const element of elements) {
+    if (element instanceof Comment) continue;
+    if (element.type_.name === "Container" || element.type_.name === "ContainerDb" || element.type_.name === "Component" || element.type_.name === "System_Ext" || element.type_.name === "System" || element.type_.name === "Person" || element instanceof Stdlib_C4_Dynamic_Rel || element instanceof Relationship) {
+      result.push(element);
+    }
+    const elementAsBoundary = element;
+    if (["System_Boundary", "Container_Boundary", "Boundary"].includes(
+      elementAsBoundary.type_.name
+    )) {
+      result.push(elementAsBoundary);
+      const resultFromBoundary = filterElements(elementAsBoundary.elements);
+      result.push(...resultFromBoundary);
+    }
+    if (Array.isArray(element)) {
+      const resultFromArray = filterElements(element);
+      result.push(...resultFromArray);
+    }
+  }
+  return result;
+};
+
+const loadPlantumlElements = async (filePath) => {
+  const filepath = path.resolve(filePath);
+  let data = await fs.readFile(filepath, "utf8");
+  data = data.replaceAll(/, \$tags=(".+?")/g, ", $1").replaceAll('""', '" "');
+  const [{ elements }] = parse(data);
+  for (const element of elements) {
+    if (element instanceof Comment) continue;
+    const relation = element;
+    if (relation.type_.name.startsWith("Rel_Back")) {
+      const from = relation.from;
+      relation.from = relation.to;
+      relation.to = from;
+    }
+  }
+  return filterElements(elements);
+};
+
+const addDependency = (containers, relation) => {
+  const containerFrom = containers.find((x) => x.name === relation.from);
+  if (!containerFrom) return;
+  const containerTo = containers.find((x) => x.name === relation.to);
+  if (!containerTo) return;
+  containerFrom.relations.push({
+    to: containerTo,
+    technology: relation.techn,
+    tags: relation.descr?.split(",").map((t) => t.trim())
+  });
+};
+const mapContainersFromPlantumlElements = (elements) => {
+  const containers = elements.filter(
+    (element) => element instanceof Stdlib_C4_Container_Component || element instanceof Stdlib_C4_Context
+  ).map((element) => {
+    const component = element;
+    return {
+      name: component.alias,
+      label: component.label,
+      type: component.type_.name,
+      relations: [],
+      tags: component.sprite ? [component.sprite] : void 0,
+      description: component.descr
+    };
+  });
+  for (const element of elements) {
+    if (element instanceof Stdlib_C4_Container_Component) {
+      continue;
+    }
+    if (element instanceof Stdlib_C4_Dynamic_Rel) {
+      addDependency(containers, element);
+    }
+  }
+  const boundaries = elements.filter((element) => element instanceof Stdlib_C4_Boundary).map((element) => {
+    const component = element;
+    return {
+      name: component.alias,
+      label: component.label,
+      type: component.type_.name,
+      boundaries: [],
+      containers: containers.filter(
+        (container) => component.elements.filter(
+          (element2) => element2 instanceof Stdlib_C4_Container_Component
+        ).some((e) => e.alias == container.name)
+      )
+    };
+  });
+  for (const boundary of boundaries) {
+    const component = elements.find(
+      (element) => element instanceof Stdlib_C4_Boundary && element.alias == boundary.name
+    );
+    boundary.boundaries = boundaries.filter(
+      (b) => component.elements.filter((element) => element instanceof Stdlib_C4_Boundary).some((e) => e.alias == b.name)
+    );
+  }
+  return {
+    allContainers: containers.toSorted((a, b) => a.name.localeCompare(b.name)),
+    boundaries
+  };
+};
+
+const DATABASE_TECHNOLOGIES = [
+  "postgresql",
+  "postgres",
+  "mysql",
+  "mariadb",
+  "mongodb",
+  "mongo",
+  "redis",
+  "elasticsearch",
+  "dynamodb",
+  "cassandra",
+  "sqlite",
+  "oracle",
+  "sqlserver",
+  "mssql",
+  "database",
+  "db"
+];
+const isDatabase = (technology, name) => {
+  const techLower = technology?.toLowerCase() ?? "";
+  const nameLower = name?.toLowerCase() ?? "";
+  if (DATABASE_TECHNOLOGIES.some((db) => techLower.includes(db))) {
+    return true;
+  }
+  if (nameLower.endsWith(" db") || nameLower.endsWith("_db") || nameLower.endsWith("database")) {
+    return true;
+  }
+  return false;
+};
+const enrichTags = (existingTags, name) => {
+  const tags = existingTags?.split(",").map((t) => t.trim()).filter(Boolean) ?? [];
+  const nameLower = name?.toLowerCase() ?? "";
+  if (nameLower.includes("crud") && !tags.includes("repo")) {
+    tags.push("repo");
+  }
+  if (nameLower.includes("acl") && !tags.includes("acl")) {
+    tags.push("acl");
+  }
+  return tags;
+};
+const loadStructurizrWorkspace = async (filePath) => {
+  const filepath = path.resolve(filePath);
+  const data = await fs.readFile(filepath, "utf8");
+  return JSON.parse(data);
+};
+const processExternalSystem = (system, registry) => {
+  const container = {
+    name: system.id,
+    label: system.name,
+    type: "System_Ext",
+    tags: system.tags?.split(",").map((t) => t.trim()).filter(Boolean),
+    description: system.description ?? "",
+    relations: []
+  };
+  registry.containers.push(container);
+  registry.allElements.set(system.id, container);
+};
+const processInternalSystem = (system, registry) => {
+  const systemContainers = [];
+  for (const cont of system.containers ?? []) {
+    const container = {
+      name: cont.id,
+      label: cont.name,
+      type: isDatabase(cont.technology, cont.name) ? "ContainerDb" : "Container",
+      tags: enrichTags(cont.tags, cont.name),
+      description: cont.description ?? "",
+      relations: []
+    };
+    systemContainers.push(container);
+    registry.containers.push(container);
+    registry.allElements.set(cont.id, container);
+  }
+  registry.boundaries.push({
+    name: system.id,
+    label: system.name,
+    type: "Boundary",
+    boundaries: [],
+    containers: systemContainers
+  });
+};
+const addRelations = (allElements, sourceId, relationships) => {
+  const sourceContainer = allElements.get(sourceId);
+  if (!sourceContainer || !relationships) return;
+  for (const rel of relationships) {
+    const targetContainer = allElements.get(rel.destinationId);
+    if (!targetContainer) continue;
+    let tags = rel.tags?.split(",").map((t) => t.trim());
+    if (rel.interactionStyle === "Asynchronous") {
+      tags = [...tags ?? [], "async"];
+    }
+    const relation = {
+      to: targetContainer,
+      technology: rel.technology,
+      tags
+    };
+    sourceContainer.relations.push(relation);
+  }
+};
+const mapContainersFromStructurizr = (workspace) => {
+  const registry = {
+    allElements: /* @__PURE__ */ new Map(),
+    containers: [],
+    boundaries: []
+  };
+  for (const system of workspace.model.softwareSystems ?? []) {
+    if (system.location === "External") {
+      processExternalSystem(system, registry);
+    } else {
+      processInternalSystem(system, registry);
+    }
+  }
+  for (const person of workspace.model.people ?? []) {
+    const container = {
+      name: person.id,
+      label: person.name,
+      type: "Person",
+      tags: person.tags?.split(",").map((t) => t.trim()).filter(Boolean),
+      description: person.description ?? "",
+      relations: []
+    };
+    registry.containers.push(container);
+    registry.allElements.set(person.id, container);
+  }
+  for (const system of workspace.model.softwareSystems ?? []) {
+    addRelations(registry.allElements, system.id, system.relationships);
+    for (const cont of system.containers ?? []) {
+      addRelations(registry.allElements, cont.id, cont.relationships);
+      for (const comp of cont.components ?? []) {
+        addRelations(registry.allElements, comp.id, comp.relationships);
+      }
+    }
+  }
+  for (const person of workspace.model.people ?? []) {
+    addRelations(registry.allElements, person.id, person.relationships);
+  }
+  return {
+    allContainers: registry.containers.toSorted(
+      (a, b) => a.name.localeCompare(b.name)
+    ),
+    boundaries: registry.boundaries
+  };
+};
+const loadStructurizrElements = async (filePath) => {
+  const workspace = await loadStructurizrWorkspace(filePath);
+  return mapContainersFromStructurizr(workspace);
+};
+
+const checkAcl = (containers, options) => {
+  const tag = options?.tag ?? "acl";
+  const externalType = options?.externalType ?? "System_Ext";
+  const violations = [];
+  for (const container of containers) {
+    const externalRelations = container.relations.filter(
+      (r) => r.to.type === externalType
+    );
+    if (!container.tags?.includes(tag) && externalRelations.length > 0) {
+      violations.push({
+        container: container.name,
+        message: `depends on external systems: ${externalRelations.map((r) => r.to.name).join(", ")}`
+      });
+    }
+  }
+  return violations;
+};
+
+const checkAcyclic = (containers) => {
+  const violations = [];
+  const findCycle = (relations, sourceContainerName, visited = /* @__PURE__ */ new Set()) => {
+    for (const rel of relations) {
+      if (rel.to.name === sourceContainerName) {
+        return true;
+      }
+      if (visited.has(rel.to.name)) continue;
+      visited.add(rel.to.name);
+      if (findCycle(rel.to.relations, sourceContainerName, visited)) {
+        return true;
+      }
+    }
+    return false;
+  };
+  for (const container of containers) {
+    if (findCycle(container.relations, container.name)) {
+      violations.push({
+        container: container.name,
+        message: "participates in a dependency cycle"
+      });
+    }
+  }
+  return violations;
+};
+
+const checkApiGateway = (containers, options) => {
+  const aclTag = options?.aclTag ?? "acl";
+  const externalType = options?.externalType ?? "System_Ext";
+  const gatewayPattern = options?.gatewayPattern ?? /gateway/i;
+  const violations = [];
+  for (const container of containers) {
+    if (!container.tags?.includes(aclTag)) continue;
+    for (const rel of container.relations) {
+      if (rel.to.type !== externalType) continue;
+      const techs = rel.technology?.split(", ") ?? [];
+      if (!techs.some((t) => gatewayPattern.test(t))) {
+        violations.push({
+          container: container.name,
+          message: `external relation to ${rel.to.name} does not go through API Gateway`
+        });
+      }
+    }
+  }
+  return violations;
+};
+
+const getBoundaryCohesion = (boundary) => {
+  let result = 0;
+  for (const container of boundary.containers) {
+    result += container.relations.filter(
+      (r) => boundary.containers.some((c) => c.name === r.to.name)
+    ).length;
+  }
+  for (const innerBoundary of boundary.boundaries) {
+    result += getBoundaryCoupling(innerBoundary);
+  }
+  return result;
+};
+const getBoundaryCoupling = (boundary, externalType = "System_Ext", internalType = "Container") => {
+  let result = 0;
+  for (const container of boundary.containers) {
+    result += container.relations.filter(
+      (r) => r.to.type === internalType && !boundary.containers.some((c) => c.name === r.to.name)
+    ).length;
+  }
+  for (const innerBoundary of boundary.boundaries) {
+    for (const container of innerBoundary.containers) {
+      result += container.relations.filter(
+        (r) => r.to.type === externalType
+      ).length;
+    }
+  }
+  return result;
+};
+const checkCohesion = (model, options) => {
+  const externalType = options?.externalType ?? "System_Ext";
+  const internalType = options?.internalType ?? "Container";
+  const violations = [];
+  for (const boundary of model.boundaries) {
+    const cohesion = getBoundaryCohesion(boundary);
+    const coupling = getBoundaryCoupling(boundary, externalType, internalType);
+    if (cohesion <= coupling) {
+      violations.push({
+        container: boundary.name,
+        message: `cohesion (${cohesion}) is not greater than coupling (${coupling})`
+      });
+    }
+    if (boundary.boundaries.length > 0) {
+      const innerCohesionSum = boundary.boundaries.reduce(
+        (sum, current) => sum + getBoundaryCohesion(current),
+        0
+      );
+      if (cohesion >= innerCohesionSum) {
+        violations.push({
+          container: boundary.name,
+          message: `cohesion (${cohesion}) is not less than sum of inner boundary cohesions (${innerCohesionSum})`
+        });
+      }
+    }
+  }
+  return violations;
+};
+
+const checkCrud = (containers, options) => {
+  const repoTags = options?.repoTags ?? ["repo", "relay"];
+  const dbType = options?.dbType ?? "ContainerDb";
+  const violations = [];
+  for (const container of containers) {
+    const dbRelations = container.relations.filter((r) => r.to.type === dbType);
+    const isRepo = repoTags.some((tag) => container.tags?.includes(tag));
+    if (!isRepo && dbRelations.length > 0) {
+      violations.push({
+        container: container.name,
+        message: `accesses database without repo/relay tag: ${dbRelations.map((r) => r.to.name).join(", ")}`
+      });
+    }
+    if (container.tags?.includes("repo") && container.relations.some((r) => r.to.type !== dbType)) {
+      violations.push({
+        container: container.name,
+        message: `repo has non-database dependencies: ${container.relations.filter((r) => r.to.type !== dbType).map((r) => r.to.name).join(", ")}`
+      });
+    }
+  }
+  return violations;
+};
+
+const checkDbPerService = (containers, options) => {
+  const dbType = options?.dbType ?? "ContainerDb";
+  const violations = [];
+  const dbAccessMap = /* @__PURE__ */ new Map();
+  for (const container of containers) {
+    for (const rel of container.relations) {
+      if (rel.to.type === dbType) {
+        const accessors = dbAccessMap.get(rel.to.name) ?? [];
+        accessors.push(container.name);
+        dbAccessMap.set(rel.to.name, accessors);
+      }
+    }
+  }
+  for (const [db, accessors] of dbAccessMap) {
+    if (accessors.length > 1) {
+      violations.push({
+        container: db,
+        message: `accessed by multiple services: ${accessors.join(", ")}`
+      });
+    }
+  }
+  return violations;
+};
+
+const computeCoupling = (internal, internalNames) => {
+  const ca = /* @__PURE__ */ new Map();
+  const ce = /* @__PURE__ */ new Map();
+  for (const c of internal) {
+    ca.set(c.name, 0);
+    ce.set(c.name, 0);
+  }
+  for (const c of internal) {
+    for (const rel of c.relations) {
+      if (!internalNames.has(rel.to.name)) continue;
+      ce.set(c.name, ce.get(c.name) + 1);
+      ca.set(rel.to.name, ca.get(rel.to.name) + 1);
+    }
+  }
+  return { ca, ce };
+};
+const checkStableDependencies = (containers, options) => {
+  const externalType = options?.externalType ?? "System_Ext";
+  const violations = [];
+  const internal = containers.filter((c) => c.type !== externalType);
+  const internalNames = new Set(internal.map((c) => c.name));
+  const { ca, ce } = computeCoupling(internal, internalNames);
+  const instability = (name) => {
+    const afferent = ca.get(name);
+    const efferent = ce.get(name);
+    if (afferent + efferent === 0) return 1;
+    return efferent / (afferent + efferent);
+  };
+  for (const c of internal) {
+    for (const rel of c.relations) {
+      if (!internalNames.has(rel.to.name)) continue;
+      const iSource = instability(c.name);
+      const iTarget = instability(rel.to.name);
+      if (iSource < iTarget) {
+        violations.push({
+          container: c.name,
+          message: `depends on less stable ${rel.to.name} (I=${iSource.toFixed(2)} \u2192 I=${iTarget.toFixed(2)})`
+        });
+      }
+    }
+  }
+  return violations;
+};
+
+export { AactConfigSchema as A, analyzeArchitecture as a, checkAcyclic as b, checkAcl as c, checkApiGateway as d, checkCohesion as e, checkCrud as f, checkDbPerService as g, checkStableDependencies as h, defineConfig as i, generateKubernetes as j, generatePlantumlFromModel as k, loadPlantumlElements as l, loadStructurizrElements as m, loadStructurizrWorkspace as n, mapContainersFromPlantumlElements as o, mapContainersFromStructurizr as p };