@anarchitects/governance-core 0.0.1

package/dist/index.js

@@ -0,0 +1,1587 @@
+function mn(e, n = { projectOverrides: {} }) {
+  const t = ae(e), o = se(e);
+  return {
+    id: e.workspaceId ?? e.workspace?.id ?? "workspace",
+    name: e.workspaceName ?? e.workspace?.name ?? "workspace",
+    root: e.workspaceRoot ?? e.workspace?.root ?? "",
+    projects: t.map((r) => {
+      const i = ce(r), a = r.tags ?? [], c = r.metadata ?? {}, s = n.projectOverrides[i] ?? {}, l = s.domain ?? r.domain ?? R(a, "domain") ?? R(a, "scope"), u = s.layer ?? r.layer ?? R(a, "layer"), y = de(c);
+      return {
+        id: r.id,
+        name: i,
+        root: r.root ?? "",
+        type: le(r.type),
+        tags: a,
+        domain: l,
+        layer: u,
+        ownership: pe(
+          y,
+          s.ownershipTeam,
+          r.ownership
+        ),
+        metadata: {
+          ...c,
+          ...s.documentation !== void 0 ? { documentation: s.documentation } : {}
+        }
+      };
+    }),
+    dependencies: o.map((r) => ({
+      source: r.sourceProjectId,
+      target: r.targetProjectId,
+      type: ue(r.type),
+      sourceFile: r.sourceFile
+    }))
+  };
+}
+function ae(e) {
+  return e.projects ? e.projects : e.workspace ? e.workspace.projects.map((n) => ({
+    id: n.id,
+    name: n.name,
+    root: n.root,
+    type: n.type,
+    domain: n.domain,
+    layer: n.layer,
+    tags: n.tags,
+    ownership: n.ownership,
+    metadata: n.metadata
+  })) : [];
+}
+function se(e) {
+  return e.dependencies ? e.dependencies : e.workspace ? e.workspace.dependencies.map((n) => ({
+    sourceProjectId: n.source,
+    targetProjectId: n.target,
+    type: n.type,
+    sourceFile: n.sourceFile
+  })) : [];
+}
+function ce(e) {
+  return e.name ?? e.id;
+}
+function R(e, n) {
+  return e.find((o) => o.startsWith(`${n}:`))?.split(":").slice(1).join(":");
+}
+function le(e) {
+  return e === "application" || e === "app" ? "application" : e === "library" || e === "lib" ? "library" : e === "tool" ? "tool" : "unknown";
+}
+function ue(e) {
+  return e === "static" || e === "dynamic" || e === "implicit" ? e : "unknown";
+}
+function de(e) {
+  const n = e.ownership;
+  if (typeof n == "string" && n)
+    return n;
+  if (n && typeof n == "object") {
+    const t = n.team;
+    if (typeof t == "string" && t)
+      return t;
+  }
+}
+function pe(e, n, t) {
+  const o = t?.contacts ?? [], r = n ?? e ?? t?.team;
+  return r && o.length ? {
+    team: r,
+    contacts: o,
+    source: "merged"
+  } : r ? {
+    team: r,
+    contacts: [],
+    source: fe(t?.source)
+  } : o.length ? {
+    contacts: o,
+    source: "codeowners"
+  } : {
+    source: "none"
+  };
+}
+function fe(e) {
+  return e === "merged" || e === "project-metadata" ? e : e === "codeowners" ? "codeowners" : "project-metadata";
+}
+const M = [
+  "graph",
+  "conformance",
+  "policy",
+  "extension"
+], me = [
+  "info",
+  "warning",
+  "error"
+], ye = [
+  "structural-dependency",
+  "cross-domain-dependency",
+  "missing-domain-context",
+  "circular-dependency",
+  "conformance-violation",
+  "domain-boundary-violation",
+  "layer-boundary-violation",
+  "ownership-gap"
+], ge = [
+  "architecture",
+  "boundaries",
+  "ownership",
+  "documentation"
+], A = {
+  graph: 0,
+  conformance: 1,
+  policy: 2,
+  extension: 3
+}, b = {
+  "structural-dependency": 0,
+  "cross-domain-dependency": 1,
+  "missing-domain-context": 2,
+  "circular-dependency": 3,
+  "conformance-violation": 4,
+  "domain-boundary-violation": 5,
+  "layer-boundary-violation": 6,
+  "ownership-gap": 7
+}, q = {
+  error: 0,
+  warning: 1,
+  info: 2
+};
+function yn(e) {
+  const n = he(
+    e.violations,
+    e.reportType
+  ), t = we(
+    e.signals,
+    e.reportType
+  ), o = ve(
+    e.measurements,
+    e.reportType
+  );
+  return {
+    workspace: e.workspace,
+    profile: e.profile,
+    warnings: [...e.warnings ?? []],
+    exceptions: e.exceptions,
+    violations: n,
+    measurements: o,
+    signalBreakdown: Ie(t),
+    metricBreakdown: Pe(o),
+    topIssues: Se(t),
+    health: e.health,
+    recommendations: [...e.recommendations ?? []]
+  };
+}
+function he(e, n) {
+  return n === "boundaries" ? e.filter((t) => t.category === "boundary") : n === "ownership" ? e.filter((t) => t.category === "ownership") : n === "architecture" ? e.filter((t) => t.category !== "ownership") : e;
+}
+function ve(e, n) {
+  return n === "boundaries" ? e.filter(
+    (t) => t.family === "boundaries"
+  ) : n === "ownership" ? e.filter(
+    (t) => t.family === "ownership"
+  ) : n === "architecture" ? e.filter(
+    (t) => t.family !== "ownership" && t.family !== "documentation"
+  ) : e;
+}
+function we(e, n) {
+  return n === "boundaries" ? e.filter((t) => t.category === "boundary") : n === "ownership" ? e.filter((t) => t.category === "ownership") : n === "architecture" ? e.filter((t) => t.category !== "ownership") : e;
+}
+function Ie(e) {
+  const n = /* @__PURE__ */ new Map(), t = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map();
+  for (const r of e)
+    n.set(r.source, (n.get(r.source) ?? 0) + 1), t.set(r.type, (t.get(r.type) ?? 0) + 1), o.set(
+      r.severity,
+      (o.get(r.severity) ?? 0) + 1
+    );
+  return {
+    total: e.length,
+    bySource: [
+      ...M.map((r) => ({
+        source: r,
+        count: n.get(r) ?? 0
+      })),
+      ...B(
+        [...n.keys()],
+        M
+      ).filter((r) => !M.includes(r)).map((r) => ({
+        source: r,
+        count: n.get(r) ?? 0
+      }))
+    ],
+    byType: B(
+      [...t.keys()],
+      ye
+    ).flatMap((r) => {
+      const i = t.get(r) ?? 0;
+      return i > 0 ? [{ type: r, count: i }] : [];
+    }),
+    bySeverity: me.map((r) => ({
+      severity: r,
+      count: o.get(r) ?? 0
+    }))
+  };
+}
+function Pe(e) {
+  const n = /* @__PURE__ */ new Map();
+  for (const o of e) {
+    const r = n.get(o.family) ?? [];
+    r.push(o), n.set(o.family, r);
+  }
+  return {
+    families: B(
+      [...n.keys()],
+      ge
+    ).flatMap((o) => {
+      const r = (n.get(o) ?? []).slice().sort((a, c) => a.id.localeCompare(c.id)).map((a) => ({
+        id: a.id,
+        name: a.name,
+        score: a.score
+      }));
+      if (r.length === 0)
+        return [];
+      const i = r.reduce(
+        (a, c) => a + c.score,
+        0
+      ) / r.length;
+      return [
+        {
+          family: o,
+          score: Math.round(i),
+          measurements: r
+        }
+      ];
+    })
+  };
+}
+function Se(e) {
+  const n = /* @__PURE__ */ new Map();
+  for (const t of e) {
+    const o = be(t), r = n.get(o);
+    if (r) {
+      r.issue.count += 1, r.issue.projects = De(r.issue.projects, t), r.issue.ruleId || (r.issue.ruleId = V(t)), r.issue.sourcePluginId || (r.issue.sourcePluginId = t.sourcePluginId);
+      continue;
+    }
+    n.set(o, {
+      issue: {
+        type: t.type,
+        source: t.source,
+        severity: t.severity,
+        count: 1,
+        projects: J(t),
+        ruleId: V(t),
+        message: t.message,
+        sourcePluginId: t.sourcePluginId
+      }
+    });
+  }
+  return [...n.values()].map((t) => t.issue).sort(je);
+}
+function be(e) {
+  return [
+    e.type,
+    e.source,
+    e.severity,
+    e.sourceProjectId ?? "",
+    e.targetProjectId ?? "",
+    e.relatedProjectIds.join(",")
+  ].join("|");
+}
+function J(e) {
+  return [
+    ...new Set(
+      [
+        e.sourceProjectId,
+        e.targetProjectId,
+        ...e.relatedProjectIds
+      ].filter((n) => !!n)
+    )
+  ].sort((n, t) => n.localeCompare(t));
+}
+function De(e, n) {
+  return [
+    .../* @__PURE__ */ new Set([...e, ...J(n)])
+  ].sort((t, o) => t.localeCompare(o));
+}
+function V(e) {
+  const n = e.metadata?.ruleId;
+  return typeof n == "string" && n.length > 0 ? n : void 0;
+}
+function je(e, n) {
+  const t = q[e.severity] - q[n.severity];
+  if (t !== 0)
+    return t;
+  const o = n.count - e.count;
+  if (o !== 0)
+    return o;
+  const r = b[e.type], i = b[n.type], a = r - i;
+  if (r !== void 0 && i !== void 0 && a !== 0)
+    return a;
+  if (!(e.type in b) || !(n.type in b)) {
+    const l = e.type.localeCompare(n.type);
+    if (l !== 0)
+      return l;
+  }
+  const c = A[e.source] - A[n.source];
+  if (c !== 0)
+    return c;
+  const s = e.projects.join(",").localeCompare(n.projects.join(","));
+  return s !== 0 ? s : e.message.localeCompare(n.message);
+}
+function B(e, n) {
+  const t = new Set(e), o = n.filter((i) => t.has(i)), r = e.filter((i) => !n.includes(i)).sort((i, a) => i.localeCompare(a));
+  return [...o, ...r];
+}
+function S(e, n) {
+  return {
+    useCase: e,
+    request: n.request,
+    analysis: n.analysis,
+    ...n.payloadScope ? { payloadScope: n.payloadScope } : {},
+    ...n.metadata ? { metadata: n.metadata } : {}
+  };
+}
+function gn(e) {
+  return S("root-cause", e);
+}
+function hn(e) {
+  return S("pr-impact", e);
+}
+function vn(e) {
+  return S("drift", e);
+}
+function wn(e) {
+  return S("scorecard", e);
+}
+function In(e) {
+  return S("management-insights", e);
+}
+const Pn = {
+  goodMinScore: 85,
+  warningMinScore: 70
+};
+function z(e) {
+  return Object.fromEntries(
+    e.map((n, t) => [n, e.slice(t)])
+  );
+}
+function m(e, n = {}) {
+  const t = e.allowedLayerDependencies ?? z(e.layers), o = {
+    "domain-boundary": {
+      enabled: !0,
+      severity: "error",
+      options: {
+        allowedDependencies: e.allowedDomainDependencies
+      }
+    },
+    "layer-boundary": {
+      enabled: !0,
+      severity: "warning",
+      options: {
+        allowedDependencies: t,
+        layers: [...e.layers],
+        usesExplicitDependencies: e.allowedLayerDependencies !== void 0
+      }
+    },
+    "ownership-presence": {
+      enabled: !0,
+      severity: "warning",
+      options: {
+        required: e.ownership.required,
+        metadataField: e.ownership.metadataField
+      }
+    }
+  }, r = Object.fromEntries(
+    Object.entries(e.rules ?? {}).map(([i, a]) => [
+      i,
+      {
+        ...o[i] ?? {},
+        ...a,
+        ...a.options !== void 0 ? { options: a.options } : o[i]?.options !== void 0 ? { options: o[i]?.options } : {}
+      }
+    ])
+  );
+  return {
+    name: e.name,
+    description: e.description,
+    rules: {
+      ...o,
+      ...r
+    },
+    scoring: {
+      statusThresholds: e.health.statusThresholds,
+      metricWeights: e.metrics
+    },
+    exceptions: n.exceptions ?? [],
+    projectOverrides: n.projectOverrides ?? {},
+    compatibility: {
+      boundaryPolicySource: e.boundaryPolicySource
+    }
+  };
+}
+const w = {
+  id: "domain-boundary",
+  name: "Domain Boundary",
+  description: "Enforces allowed dependencies between projects in different domains.",
+  category: "boundary",
+  defaultSeverity: "error",
+  evaluate({ workspace: e, profile: n }) {
+    if (!n)
+      return {};
+    const o = m(n).rules[w.id];
+    if (o?.enabled === !1)
+      return {};
+    const r = o?.options, i = o?.severity ?? w.defaultSeverity, a = L(e.projects);
+    return { violations: e.dependencies.flatMap((s) => {
+      const l = a.get(s.source), u = a.get(s.target);
+      return Q(
+        l,
+        u,
+        s,
+        r ?? {
+          allowedDependencies: n.allowedDomainDependencies
+        },
+        i
+      );
+    }) };
+  }
+}, I = {
+  id: "layer-boundary",
+  name: "Layer Boundary",
+  description: "Enforces allowed dependencies between declared architectural layers.",
+  category: "boundary",
+  defaultSeverity: "warning",
+  evaluate({ workspace: e, profile: n }) {
+    if (!n)
+      return {};
+    const o = m(n).rules[I.id];
+    if (o?.enabled === !1)
+      return {};
+    const i = o?.options ?? {
+      allowedDependencies: n.allowedLayerDependencies ?? z(n.layers),
+      layers: [...n.layers],
+      usesExplicitDependencies: n.allowedLayerDependencies !== void 0
+    }, a = o?.severity ?? I.defaultSeverity, c = L(e.projects), s = new Set(i.layers);
+    return { violations: e.dependencies.flatMap((u) => {
+      const y = c.get(u.source), g = c.get(u.target);
+      return X(
+        y,
+        g,
+        u,
+        s,
+        i,
+        a
+      );
+    }) };
+  }
+}, P = {
+  id: "ownership-presence",
+  name: "Ownership Presence",
+  description: "Requires ownership metadata or CODEOWNERS coverage when profiles demand it.",
+  category: "ownership",
+  defaultSeverity: "warning",
+  evaluate({ workspace: e, profile: n }) {
+    if (!n)
+      return {};
+    const o = m(n).rules[P.id];
+    if (o?.enabled === !1)
+      return {};
+    const i = o?.options ?? {
+      required: n.ownership.required,
+      metadataField: n.ownership.metadataField
+    }, a = o?.severity ?? P.defaultSeverity;
+    return i.required ? { violations: e.projects.flatMap(
+      (s) => Z(s, a)
+    ) } : {};
+  }
+}, j = {
+  id: "project-name-convention",
+  name: "Project Name Convention",
+  description: "Validates project names against an explicitly configured regular expression.",
+  category: "convention",
+  defaultSeverity: "warning",
+  evaluate({ workspace: e, profile: n }) {
+    if (!n)
+      return {};
+    const o = m(n).rules[j.id], r = o?.options;
+    if (!o?.enabled || !r?.pattern)
+      return {};
+    const i = new RegExp(r.pattern), a = o.severity ?? j.defaultSeverity;
+    return {
+      violations: e.projects.flatMap(
+        (c) => ke(c, r, i, a)
+      )
+    };
+  }
+}, E = {
+  id: "tag-convention",
+  name: "Tag Convention",
+  description: "Validates required and allowed generic tag prefixes and tag value patterns.",
+  category: "metadata",
+  defaultSeverity: "warning",
+  evaluate({ workspace: e, profile: n }) {
+    if (!n)
+      return {};
+    const o = m(n).rules[E.id], r = o?.options;
+    if (!o?.enabled || !r || !Be(r))
+      return {};
+    const i = o.severity ?? E.defaultSeverity, a = r.valuePattern ? new RegExp(r.valuePattern) : void 0;
+    return {
+      violations: e.projects.flatMap(
+        (c) => xe(c, r, a, i)
+      )
+    };
+  }
+}, k = {
+  id: "missing-domain",
+  name: "Missing Domain",
+  description: "Requires a domain on projects when explicitly configured.",
+  category: "metadata",
+  defaultSeverity: "warning",
+  evaluate({ workspace: e, profile: n }) {
+    if (!n)
+      return {};
+    const o = m(n).rules[k.id], r = o?.options;
+    if (!o?.enabled || !r?.required)
+      return {};
+    const i = o.severity ?? k.defaultSeverity;
+    return {
+      violations: e.projects.flatMap(
+        (a) => Re(a, i)
+      )
+    };
+  }
+}, x = {
+  id: "missing-layer",
+  name: "Missing Layer",
+  description: "Requires a layer on projects when explicitly configured.",
+  category: "metadata",
+  defaultSeverity: "warning",
+  evaluate({ workspace: e, profile: n }) {
+    if (!n)
+      return {};
+    const o = m(n).rules[x.id], r = o?.options;
+    if (!o?.enabled || !r?.required)
+      return {};
+    const i = o.severity ?? x.defaultSeverity;
+    return {
+      violations: e.projects.flatMap(
+        (a) => Me(a, i)
+      )
+    };
+  }
+}, Ee = [
+  w,
+  I,
+  P,
+  j,
+  E,
+  k,
+  x
+];
+function Sn(e) {
+  if (!e.profile)
+    return [];
+  const { workspace: n, profile: t } = e, o = m(t), r = o.rules[w.id], i = r?.enabled !== !1, a = r?.options ?? {
+    allowedDependencies: t.allowedDomainDependencies
+  }, c = r?.severity ?? w.defaultSeverity, s = o.rules[I.id], l = s?.enabled !== !1, u = s?.options ?? {
+    allowedDependencies: t.allowedLayerDependencies ?? z(t.layers),
+    layers: [...t.layers],
+    usesExplicitDependencies: t.allowedLayerDependencies !== void 0
+  }, y = s?.severity ?? I.defaultSeverity, g = o.rules[P.id], te = g?.enabled !== !1, re = g?.options ?? {
+    required: t.ownership.required,
+    metadataField: t.ownership.metadataField
+  }, oe = g?.severity ?? P.defaultSeverity, G = L(n.projects), ie = new Set(u.layers), h = [];
+  for (const f of n.dependencies) {
+    const F = G.get(f.source), _ = G.get(f.target);
+    i && h.push(
+      ...Q(
+        F,
+        _,
+        f,
+        a,
+        c
+      )
+    ), l && h.push(
+      ...X(
+        F,
+        _,
+        f,
+        ie,
+        u,
+        y
+      )
+    );
+  }
+  if (te && re.required)
+    for (const f of n.projects)
+      h.push(...Z(f, oe));
+  for (const f of [
+    j,
+    E,
+    k,
+    x
+  ])
+    h.push(...Ce(f, e));
+  return h;
+}
+function Q(e, n, t, o, r) {
+  return !e || !n ? [] : !e.domain || !n.domain || e.domain === n.domain || $e(
+    o.allowedDependencies,
+    e.domain,
+    n.domain
+  ) ? [] : [
+    {
+      id: `${e.name}-${n.name}-domain`,
+      ruleId: "domain-boundary",
+      project: e.name,
+      severity: r,
+      category: "boundary",
+      message: `Project ${e.name} in domain ${e.domain} depends on ${n.name} in domain ${n.domain}.`,
+      details: {
+        targetProject: n.name,
+        sourceDomain: e.domain,
+        targetDomain: n.domain,
+        dependencyType: t.type
+      },
+      recommendation: "Move the dependency behind an API or adjust domain boundaries in the governance profile."
+    }
+  ];
+}
+function X(e, n, t, o, r, i) {
+  return !e || !n ? [] : !e.layer || !n.layer || !o.has(e.layer) || !o.has(n.layer) || Oe(
+    r.allowedDependencies,
+    e.layer,
+    n.layer
+  ) ? [] : [
+    {
+      id: `${e.name}-${n.name}-layer`,
+      ruleId: "layer-boundary",
+      project: e.name,
+      severity: i,
+      category: "boundary",
+      message: `Layer violation: ${e.name} (${e.layer}) depends on ${n.name} (${n.layer}).`,
+      details: {
+        targetProject: n.name,
+        sourceLayer: e.layer,
+        targetLayer: n.layer,
+        ...r.usesExplicitDependencies ? {
+          allowedTargets: r.allowedDependencies[e.layer] ?? []
+        } : {
+          order: r.layers
+        }
+      },
+      recommendation: r.usesExplicitDependencies ? "Refactor the dependency or update allowedLayerDependencies in the governance profile when the dependency is intentional." : "Refactor dependency direction so higher-level layers depend on same or lower-level layers only."
+    }
+  ];
+}
+function Z(e, n) {
+  return e.ownership?.team || (e.ownership?.contacts?.length ?? 0) > 0 ? [] : [
+    {
+      id: `${e.name}-ownership`,
+      ruleId: "ownership-presence",
+      project: e.name,
+      severity: n,
+      category: "ownership",
+      message: `Project ${e.name} has no ownership metadata or CODEOWNERS mapping.`,
+      recommendation: "Add ownership metadata in project configuration or ensure CODEOWNERS covers the project root."
+    }
+  ];
+}
+function ke(e, n, t, o) {
+  return t.test(e.name) ? [] : [
+    {
+      id: `${e.name}-project-name-convention`,
+      ruleId: "project-name-convention",
+      project: e.name,
+      severity: o,
+      category: "convention",
+      message: n.message ?? `Project ${e.name} does not match the configured naming convention.`,
+      details: {
+        projectName: e.name,
+        pattern: n.pattern
+      },
+      recommendation: "Rename the project or update the configured name pattern when the convention is intentional."
+    }
+  ];
+}
+function xe(e, n, t, o) {
+  const r = [], i = n.prefixSeparator ?? ":";
+  for (const a of n.requiredPrefixes ?? [])
+    e.tags.some(
+      (c) => c.startsWith(`${a}${i}`)
+    ) || r.push({
+      id: `${e.name}-tag-convention-required-${a}`,
+      ruleId: "tag-convention",
+      project: e.name,
+      severity: o,
+      category: "metadata",
+      message: `Project ${e.name} is missing a tag with required prefix ${a}.`,
+      details: {
+        requiredPrefix: a,
+        tags: e.tags
+      },
+      recommendation: "Add a tag with the required prefix or relax the configured requiredPrefixes list."
+    });
+  for (const a of e.tags) {
+    const { prefix: c, value: s } = Te(a, i);
+    n.allowedPrefixes && n.allowedPrefixes.length > 0 && !n.allowedPrefixes.includes(c) && r.push({
+      id: `${e.name}-tag-convention-allowed-${a}`,
+      ruleId: "tag-convention",
+      project: e.name,
+      severity: o,
+      category: "metadata",
+      message: `Project ${e.name} uses tag ${a} with disallowed prefix ${c}.`,
+      details: {
+        tag: a,
+        prefix: c,
+        allowedPrefixes: n.allowedPrefixes
+      },
+      recommendation: "Rename the tag to use an allowed prefix or expand the allowedPrefixes rule configuration."
+    }), t && !t.test(s) && r.push({
+      id: `${e.name}-tag-convention-value-${a}`,
+      ruleId: "tag-convention",
+      project: e.name,
+      severity: o,
+      category: "metadata",
+      message: `Project ${e.name} has tag ${a} with a value that does not match the configured pattern.`,
+      details: {
+        tag: a,
+        value: s,
+        valuePattern: n.valuePattern
+      },
+      recommendation: "Normalize the tag value or update the configured valuePattern when the convention is intentional."
+    });
+  }
+  return r;
+}
+function Re(e, n) {
+  return e.domain ? [] : [
+    {
+      id: `${e.name}-missing-domain`,
+      ruleId: "missing-domain",
+      project: e.name,
+      severity: n,
+      category: "metadata",
+      message: `Project ${e.name} is missing domain metadata.`,
+      recommendation: "Populate the project domain through adapter normalization, metadata, or project overrides."
+    }
+  ];
+}
+function Me(e, n) {
+  return e.layer ? [] : [
+    {
+      id: `${e.name}-missing-layer`,
+      ruleId: "missing-layer",
+      project: e.name,
+      severity: n,
+      category: "metadata",
+      message: `Project ${e.name} is missing layer metadata.`,
+      recommendation: "Populate the project layer through adapter normalization, metadata, or project overrides."
+    }
+  ];
+}
+function Ce(e, n) {
+  return e.evaluate(n).violations ?? [];
+}
+function L(e) {
+  return new Map(e.map((n) => [n.name, n]));
+}
+function $e(e, n, t) {
+  const o = e[n];
+  if (o && (o.includes(t) || o.includes("*")))
+    return !0;
+  const r = e["*"];
+  return !!(r && (r.includes(t) || r.includes("*")));
+}
+function Oe(e, n, t) {
+  return (e[n] ?? []).includes(t);
+}
+function Be(e) {
+  return (e.requiredPrefixes?.length ?? 0) > 0 || (e.allowedPrefixes?.length ?? 0) > 0 || typeof e.valuePattern == "string";
+}
+function Te(e, n) {
+  const t = e.indexOf(n);
+  return t === -1 ? {
+    prefix: e,
+    value: e
+  } : {
+    prefix: e.slice(0, t),
+    value: e.slice(t + n.length)
+  };
+}
+const ze = "core", Le = {
+  id: ze,
+  name: "Governance Core Built-in Rules",
+  rules: Ee
+}, bn = [Le], Ge = [
+  "graph",
+  "conformance",
+  "policy"
+], Fe = ["info", "warning", "error"], _e = [
+  "structural-dependency",
+  "cross-domain-dependency",
+  "missing-domain-context",
+  "circular-dependency",
+  "conformance-violation",
+  "domain-boundary-violation",
+  "layer-boundary-violation",
+  "ownership-gap"
+], Ae = [
+  "architecture",
+  "boundaries",
+  "ownership",
+  "documentation"
+];
+function Dn(e, n) {
+  return {
+    baseline: e,
+    current: n,
+    metricDeltas: N(e.metrics, n.metrics),
+    scoreDeltas: N(e.scores, n.scores),
+    newViolations: n.violations.filter(
+      (t) => !K(e.violations, t)
+    ),
+    resolvedViolations: e.violations.filter(
+      (t) => !K(n.violations, t)
+    ),
+    healthDelta: qe(e, n),
+    signalDeltas: Ve(e, n),
+    metricFamilyDeltas: Ne(e, n),
+    topIssueDeltas: He(e, n),
+    deliveryImpactIndexDeltas: Ue(e, n)
+  };
+}
+function jn(e, n = 0.02) {
+  const t = [], o = e.scoreDeltas.find(
+    (r) => r.id === "workspaceHealth"
+  );
+  o && t.push(
+    C(
+      "workspaceHealth",
+      "workspace-health",
+      "Workspace Health",
+      o,
+      n,
+      e.healthDelta ? {
+        baselineStatus: e.healthDelta.baselineStatus,
+        currentStatus: e.healthDelta.currentStatus,
+        baselineGrade: e.healthDelta.baselineGrade,
+        currentGrade: e.healthDelta.currentGrade
+      } : void 0
+    )
+  );
+  for (const r of e.scoreDeltas)
+    r.id !== "workspaceHealth" && t.push(
+      C(
+        r.id,
+        "metric-score",
+        Xe(r.id),
+        r,
+        n
+      )
+    );
+  for (const r of e.metricFamilyDeltas ?? [])
+    t.push(
+      C(
+        `metric-family:${r.family}`,
+        "metric-family",
+        `Metric Family: ${Ze(r.family)}`,
+        r,
+        n
+      )
+    );
+  for (const r of e.signalDeltas?.bySource ?? [])
+    t.push(
+      D(
+        `signal-source:${r.source}`,
+        "signal-source",
+        `Signal Source: ${r.source}`,
+        r
+      )
+    );
+  for (const r of e.signalDeltas?.byType ?? [])
+    t.push(
+      D(
+        `signal-type:${r.type}`,
+        "signal-type",
+        `Signal Type: ${en(r.type)}`,
+        r
+      )
+    );
+  for (const r of e.signalDeltas?.bySeverity ?? [])
+    t.push(
+      D(
+        `signal-severity:${r.severity}`,
+        "signal-severity",
+        `Signal Severity: ${r.severity}`,
+        r
+      )
+    );
+  for (const r of e.topIssueDeltas ?? [])
+    t.push(
+      D(
+        Ke(r),
+        "top-issue",
+        `Top Issue: ${r.message}`,
+        {
+          baseline: r.baselineCount,
+          current: r.currentCount,
+          delta: r.delta
+        },
+        {
+          type: r.type,
+          source: r.source,
+          severity: r.severity,
+          ruleId: r.ruleId,
+          projects: r.projects
+        }
+      )
+    );
+  return t.push({
+    id: "violation-footprint",
+    kind: "violation-footprint",
+    label: "Violation Footprint",
+    status: ee(
+      e.newViolations.length - e.resolvedViolations.length
+    ),
+    magnitude: Math.abs(
+      e.newViolations.length - e.resolvedViolations.length
+    ),
+    baseline: e.baseline.violations.length,
+    current: e.current.violations.length,
+    delta: p(
+      e.current.violations.length - e.baseline.violations.length
+    ),
+    details: {
+      newViolations: e.newViolations.length,
+      resolvedViolations: e.resolvedViolations.length
+    }
+  }), t.sort(Je);
+}
+function En(e) {
+  const n = e.filter((r) => r.status === "worsening").sort(Y), t = e.filter((r) => r.status === "improving").sort(Y), o = e.filter(
+    (r) => r.status === "stable"
+  ).length;
+  return {
+    overallTrend: n.length > t.length ? "worsening" : t.length > n.length ? "improving" : "stable",
+    worseningCount: n.length,
+    improvingCount: t.length,
+    stableCount: o,
+    topWorsening: n.slice(0, 5),
+    topImproving: t.slice(0, 5)
+  };
+}
+function N(e, n) {
+  return [.../* @__PURE__ */ new Set([...Object.keys(e), ...Object.keys(n)])].sort((o, r) => o.localeCompare(r)).map((o) => {
+    const r = e[o] ?? 0, i = n[o] ?? 0;
+    return {
+      id: o,
+      baseline: r,
+      current: i,
+      delta: p(i - r)
+    };
+  });
+}
+function qe(e, n) {
+  if (!(!e.health || !n.health))
+    return {
+      baselineScore: e.health.score,
+      currentScore: n.health.score,
+      scoreDelta: p(n.health.score - e.health.score),
+      baselineStatus: e.health.status,
+      currentStatus: n.health.status,
+      baselineGrade: e.health.grade,
+      currentGrade: n.health.grade
+    };
+}
+function Ve(e, n) {
+  if (!(!e.signalBreakdown || !n.signalBreakdown))
+    return {
+      bySource: Ge.map(
+        (t) => We(
+          t,
+          H(e, t),
+          H(n, t)
+        )
+      ),
+      byType: _e.flatMap((t) => {
+        const o = U(e, t), r = U(n, t);
+        return o === 0 && r === 0 ? [] : [
+          {
+            type: t,
+            baseline: o,
+            current: r,
+            delta: p(r - o)
+          }
+        ];
+      }),
+      bySeverity: Fe.map(
+        (t) => Ye(
+          t,
+          W(e, t),
+          W(n, t)
+        )
+      )
+    };
+}
+function Ne(e, n) {
+  if (!e.metricBreakdown || !n.metricBreakdown)
+    return;
+  const t = new Map(
+    e.metricBreakdown.families.map((r) => [
+      r.family,
+      r.score
+    ])
+  ), o = new Map(
+    n.metricBreakdown.families.map((r) => [
+      r.family,
+      r.score
+    ])
+  );
+  return Ae.flatMap((r) => {
+    const i = t.get(r), a = o.get(r);
+    return i === void 0 || a === void 0 ? [] : [
+      {
+        family: r,
+        baseline: i,
+        current: a,
+        delta: p(a - i)
+      }
+    ];
+  });
+}
+function He(e, n) {
+  if (!e.topIssues || !n.topIssues)
+    return;
+  const t = new Map(
+    e.topIssues.map((i) => [T(i), i])
+  ), o = new Map(
+    n.topIssues.map((i) => [T(i), i])
+  );
+  return [.../* @__PURE__ */ new Set([...t.keys(), ...o.keys()])].sort((i, a) => i.localeCompare(a)).map((i) => {
+    const a = t.get(i), c = o.get(i), s = c ?? a;
+    if (!s)
+      throw new Error(`Unable to resolve top issue delta for key "${i}".`);
+    const l = [
+      .../* @__PURE__ */ new Set([...a?.projects ?? [], ...c?.projects ?? []])
+    ].sort((u, y) => u.localeCompare(y));
+    return {
+      type: s.type,
+      source: s.source,
+      severity: s.severity,
+      ruleId: s.ruleId,
+      message: s.message,
+      baselineCount: a?.count ?? 0,
+      currentCount: c?.count ?? 0,
+      delta: p((c?.count ?? 0) - (a?.count ?? 0)),
+      projects: l
+    };
+  });
+}
+function Ue(e, n) {
+  const t = new Map(
+    (e.deliveryImpact?.indices ?? []).map((i) => [i.id, i])
+  ), o = new Map(
+    (n.deliveryImpact?.indices ?? []).map((i) => [i.id, i])
+  ), r = [...t.keys()].filter((i) => o.has(i)).sort((i, a) => i.localeCompare(a));
+  if (r.length !== 0)
+    return r.map((i) => {
+      const a = t.get(i), c = o.get(i);
+      return {
+        id: i,
+        baselineScore: a.score,
+        currentScore: c.score,
+        scoreDelta: p(c.score - a.score),
+        baselineRisk: a.risk,
+        currentRisk: c.risk
+      };
+    });
+}
+function C(e, n, t, o, r, i) {
+  return {
+    id: e,
+    kind: n,
+    label: t,
+    status: Qe(o.delta, r),
+    magnitude: Math.abs(o.delta),
+    baseline: o.baseline,
+    current: o.current,
+    delta: o.delta,
+    details: i
+  };
+}
+function D(e, n, t, o, r) {
+  return {
+    id: e,
+    kind: n,
+    label: t,
+    status: ee(o.delta),
+    magnitude: Math.abs(o.delta),
+    baseline: o.baseline,
+    current: o.current,
+    delta: o.delta,
+    details: r
+  };
+}
+function We(e, n, t) {
+  return {
+    source: e,
+    baseline: n,
+    current: t,
+    delta: p(t - n)
+  };
+}
+function Ye(e, n, t) {
+  return {
+    severity: e,
+    baseline: n,
+    current: t,
+    delta: p(t - n)
+  };
+}
+function H(e, n) {
+  return e.signalBreakdown?.bySource.find((t) => t.source === n)?.count ?? 0;
+}
+function U(e, n) {
+  return e.signalBreakdown?.byType.find((t) => t.type === n)?.count ?? 0;
+}
+function W(e, n) {
+  return e.signalBreakdown?.bySeverity.find(
+    (t) => t.severity === n
+  )?.count ?? 0;
+}
+function T(e) {
+  return [
+    e.type,
+    e.source,
+    e.severity,
+    e.ruleId ?? "",
+    e.message
+  ].join("|");
+}
+function Ke(e) {
+  return `top-issue:${T(e)}`;
+}
+function Je(e, n) {
+  return e.id.localeCompare(n.id);
+}
+function Y(e, n) {
+  return n.magnitude - e.magnitude || e.id.localeCompare(n.id);
+}
+function Qe(e, n) {
+  return Math.abs(e) < n ? "stable" : e > 0 ? "improving" : "worsening";
+}
+function ee(e) {
+  return e === 0 ? "stable" : e < 0 ? "improving" : "worsening";
+}
+function Xe(e) {
+  return e.split("-").map((n) => n[0]?.toUpperCase() + n.slice(1)).join(" ");
+}
+function Ze(e) {
+  return e[0].toUpperCase() + e.slice(1);
+}
+function en(e) {
+  return e.split("-").map((n) => n[0]?.toUpperCase() + n.slice(1)).join(" ");
+}
+function p(e) {
+  return Math.round(e * 1e3) / 1e3;
+}
+function K(e, n) {
+  return e.some(
+    (t) => t.type === n.type && t.source === n.source && t.target === n.target
+  );
+}
+function kn(e) {
+  const n = v(e.id, "Exception id"), t = rn(e.source), o = v(e.reason, "Exception reason"), r = v(e.owner, "Exception owner"), i = tn(e.review), a = ne(e.scope);
+  if (a.source !== t)
+    throw new Error(
+      `Exception "${n}" has source "${t}" but scope source "${a.source}".`
+    );
+  return {
+    id: n,
+    source: t,
+    scope: a,
+    reason: o,
+    owner: r,
+    review: i
+  };
+}
+function xn(e) {
+  const n = ne(e);
+  return nn(n) ? [
+    n.source,
+    n.ruleId,
+    n.projectId,
+    n.targetProjectId ?? ""
+  ].join("|") : [
+    n.source,
+    n.ruleId ?? "",
+    n.category ?? "",
+    n.projectId ?? "",
+    (n.relatedProjectIds ?? []).join(",")
+  ].join("|");
+}
+function nn(e) {
+  return e.source === "policy";
+}
+function Rn(e) {
+  return e.source === "conformance";
+}
+function tn(e) {
+  const n = d(e.createdAt), t = d(e.reviewBy), o = d(e.expiresAt);
+  if (!t && !o)
+    throw new Error(
+      "Governance exception review must define reviewBy or expiresAt."
+    );
+  return {
+    ...n ? { createdAt: n } : {},
+    ...t ? { reviewBy: t } : {},
+    ...o ? { expiresAt: o } : {}
+  };
+}
+function ne(e) {
+  if (e.source === "policy")
+    return {
+      source: "policy",
+      ruleId: v(e.ruleId, "Policy exception ruleId"),
+      projectId: v(
+        e.projectId,
+        "Policy exception projectId"
+      ),
+      ...d(e.targetProjectId) ? { targetProjectId: d(e.targetProjectId) } : {}
+    };
+  const n = d(e.ruleId), t = an(e.category), o = d(e.projectId), r = on(e.relatedProjectIds);
+  if (!n && !t && !o && r.length === 0)
+    throw new Error(
+      "Conformance exception scope must define ruleId, category, projectId, or relatedProjectIds."
+    );
+  return {
+    source: "conformance",
+    ...n ? { ruleId: n } : {},
+    ...t ? { category: t } : {},
+    ...o ? { projectId: o } : {},
+    ...r.length > 0 ? { relatedProjectIds: r } : {}
+  };
+}
+function rn(e) {
+  if (e === "policy" || e === "conformance")
+    return e;
+  throw new Error(`Unsupported governance exception source "${e}".`);
+}
+function v(e, n) {
+  const t = d(e);
+  if (!t)
+    throw new Error(`${n} is required.`);
+  return t;
+}
+function d(e) {
+  if (typeof e != "string")
+    return;
+  const n = e.trim();
+  return n.length > 0 ? n : void 0;
+}
+function on(e) {
+  return Array.isArray(e) ? [
+    ...new Set(
+      e.map(d).filter((n) => !!n)
+    )
+  ].sort((n, t) => n.localeCompare(t)) : [];
+}
+function an(e) {
+  return d(e);
+}
+async function sn(e, n) {
+  const t = cn();
+  for (const o of e) {
+    const r = await o.evaluate(n);
+    t.violations.push(...r.violations ?? []), t.signals.push(...r.signals ?? []), t.measurements.push(...r.measurements ?? []);
+  }
+  return t;
+}
+async function Mn(e, n) {
+  return sn(e.rules, n);
+}
+function cn() {
+  return {
+    violations: [],
+    signals: [],
+    measurements: []
+  };
+}
+function Cn(e, n) {
+  const t = Object.fromEntries(
+    e.measurements.map((i) => [
+      i.id,
+      i.value
+    ])
+  ), o = {
+    workspaceHealth: e.health.score,
+    ...Object.fromEntries(
+      e.measurements.map((i) => [
+        i.id,
+        i.score
+      ])
+    )
+  }, r = e.violations.map(
+    (i) => ({
+      type: i.ruleId,
+      source: i.project,
+      target: ln(i.details?.target),
+      ruleId: i.ruleId,
+      severity: i.severity,
+      message: i.message
+    })
+  );
+  return {
+    ...n,
+    metrics: t,
+    scores: o,
+    violations: r,
+    health: {
+      score: e.health.score,
+      status: e.health.status,
+      grade: e.health.grade
+    },
+    signalBreakdown: e.signalBreakdown,
+    metricBreakdown: e.metricBreakdown,
+    topIssues: e.topIssues,
+    deliveryImpact: n.deliveryImpact
+  };
+}
+function ln(e) {
+  return typeof e == "string" ? e : void 0;
+}
+class $n {
+  capabilitiesById = /* @__PURE__ */ new Map();
+  capabilities;
+  constructor(n) {
+    const t = n.map(
+      (o) => Object.freeze({ ...o })
+    );
+    for (const o of t) {
+      if (this.capabilitiesById.has(o.id))
+        throw new Error(
+          `Duplicate governance capability id "${o.id}" is not allowed.`
+        );
+      this.capabilitiesById.set(o.id, o);
+    }
+    this.capabilities = Object.freeze([...t]);
+  }
+  has(n) {
+    return this.capabilitiesById.has(n);
+  }
+  get(n) {
+    return this.capabilitiesById.get(n);
+  }
+  list() {
+    return [...this.capabilities];
+  }
+}
+class $ extends Error {
+  diagnostics;
+  constructor(n, t) {
+    super(n), this.name = "GovernanceExtensionRegistrationError", this.diagnostics = t;
+  }
+}
+class un {
+  context;
+  registry = {
+    metricProviders: [],
+    signalProviders: [],
+    rulePacks: [],
+    enrichers: []
+  };
+  pluginId;
+  constructor(n, t) {
+    this.context = Object.freeze({
+      ...n,
+      options: Object.freeze({ ...n.options })
+    }), this.pluginId = t;
+  }
+  registerMetricProvider(n) {
+    this.registry.metricProviders.push({
+      pluginId: this.pluginId,
+      contribution: n
+    });
+  }
+  registerSignalProvider(n) {
+    this.registry.signalProviders.push({
+      pluginId: this.pluginId,
+      contribution: n
+    });
+  }
+  registerRulePack(n) {
+    this.registry.rulePacks.push({
+      pluginId: this.pluginId,
+      contribution: n
+    });
+  }
+  registerEnricher(n) {
+    this.registry.enrichers.push({
+      pluginId: this.pluginId,
+      contribution: n
+    });
+  }
+  toRegistry() {
+    return {
+      metricProviders: [...this.registry.metricProviders],
+      signalProviders: [...this.registry.signalProviders],
+      rulePacks: [...this.registry.rulePacks],
+      enrichers: [...this.registry.enrichers]
+    };
+  }
+}
+async function On(e, n) {
+  return (await dn(
+    e,
+    n
+  )).registry;
+}
+async function dn(e, n, t = {}) {
+  const o = {
+    metricProviders: [],
+    signalProviders: [],
+    rulePacks: [],
+    enrichers: []
+  }, r = [...t.diagnostics ?? []], i = /* @__PURE__ */ new Map();
+  for (const a of n) {
+    try {
+      fn(a);
+    } catch (s) {
+      throw r.push({
+        code: "governance.extension.invalid_definition",
+        severity: "error",
+        message: O(s),
+        packageName: a.sourceSpecifier,
+        moduleSpecifier: a.moduleSpecifier,
+        legacy: a.legacy
+      }), new $(
+        O(s),
+        r
+      );
+    }
+    const c = i.get(a.definition.id);
+    if (c) {
+      const s = `Duplicate governance extension id "${a.definition.id}" was found in "${c}" and "${a.moduleSpecifier}".`;
+      throw r.push({
+        code: "governance.extension.duplicate_id",
+        severity: "error",
+        message: s,
+        packageName: a.sourceSpecifier,
+        moduleSpecifier: a.moduleSpecifier,
+        extensionId: a.definition.id,
+        legacy: a.legacy
+      }), new $(s, r);
+    }
+    i.set(a.definition.id, a.moduleSpecifier);
+    try {
+      const s = new un(
+        e,
+        a.definition.id
+      );
+      await a.definition.register(s), pn(o, s.toRegistry());
+    } catch (s) {
+      const l = `Governance extension "${a.definition.id}" from "${a.moduleSpecifier}" failed during registration: ${O(s)}`;
+      throw r.push({
+        code: "governance.extension.registration_failed",
+        severity: "error",
+        message: l,
+        packageName: a.sourceSpecifier,
+        moduleSpecifier: a.moduleSpecifier,
+        extensionId: a.definition.id,
+        legacy: a.legacy
+      }), new $(l, r);
+    }
+  }
+  return {
+    registry: o,
+    diagnostics: r
+  };
+}
+async function Bn(e, n) {
+  let t = n.workspace;
+  for (const o of e.enrichers)
+    t = await o.contribution.enrichWorkspace({
+      ...n,
+      workspace: t
+    });
+  return t;
+}
+async function Tn(e, n) {
+  return (await Promise.all(
+    e.rulePacks.map(async (o) => (await o.contribution.evaluate(n)).map((i) => ({
+      ...i,
+      sourcePluginId: i.sourcePluginId ?? o.pluginId
+    })))
+  )).flat();
+}
+async function zn(e, n) {
+  return (await Promise.all(
+    e.signalProviders.map(async (o) => (await o.contribution.provideSignals(n)).map((i) => ({
+      ...i,
+      source: "extension",
+      sourcePluginId: i.sourcePluginId ?? o.pluginId
+    })))
+  )).flat();
+}
+async function Ln(e, n) {
+  return (await Promise.all(
+    e.metricProviders.map(async (o) => (await o.contribution.provideMetrics(n)).map((i) => ({
+      ...i,
+      sourcePluginId: i.sourcePluginId ?? o.pluginId
+    })))
+  )).flat();
+}
+function pn(e, n) {
+  e.metricProviders.push(...n.metricProviders), e.signalProviders.push(...n.signalProviders), e.rulePacks.push(...n.rulePacks), e.enrichers.push(...n.enrichers);
+}
+function fn(e) {
+  if (typeof e.definition.id != "string" || e.definition.id.trim().length === 0)
+    throw new Error(
+      `Governance extension module "${e.moduleSpecifier}" must declare a non-empty "id".`
+    );
+}
+function O(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+export {
+  ze as CORE_BUILT_IN_RULE_PACK_ID,
+  Pn as DEFAULT_HEALTH_STATUS_THRESHOLDS,
+  $n as DefaultGovernanceCapabilityRegistry,
+  $ as GovernanceExtensionRegistrationError,
+  Bn as applyGovernanceEnrichers,
+  vn as buildAiDriftHandoffPayload,
+  S as buildAiHandoffPayload,
+  In as buildAiManagementInsightsHandoffPayload,
+  hn as buildAiPrImpactHandoffPayload,
+  gn as buildAiRootCauseHandoffPayload,
+  wn as buildAiScorecardHandoffPayload,
+  En as buildDriftSummary,
+  yn as buildGovernanceAssessment,
+  xn as buildGovernanceExceptionScopeKey,
+  mn as buildGovernanceWorkspace,
+  Pe as buildMetricBreakdown,
+  Cn as buildMetricSnapshot,
+  Ie as buildSignalBreakdown,
+  Se as buildTopIssues,
+  Ln as collectGovernanceMeasurements,
+  zn as collectGovernanceSignals,
+  Dn as compareSnapshots,
+  Ee as coreBuiltInPolicyRules,
+  Le as coreBuiltInRulePack,
+  bn as coreBuiltInRulePacks,
+  z as deriveAllowedLayerDependenciesFromLayerOrder,
+  w as domainBoundaryRule,
+  Sn as evaluateCoreBuiltInPolicyViolations,
+  Tn as evaluateGovernanceRulePacks,
+  Mn as evaluateRulePack,
+  sn as evaluateRules,
+  ve as filterMeasurementsForReportType,
+  we as filterSignalsForReportType,
+  he as filterViolationsForReportType,
+  Rn as isConformanceExceptionScope,
+  nn as isPolicyExceptionScope,
+  I as layerBoundaryRule,
+  k as missingDomainRule,
+  x as missingLayerRule,
+  kn as normalizeGovernanceException,
+  m as normalizeGovernanceProfile,
+  P as ownershipPresenceRule,
+  j as projectNameConventionRule,
+  On as registerLoadedGovernanceExtensions,
+  dn as registerLoadedGovernanceExtensionsWithDiagnostics,
+  jn as summarizeDrift,
+  E as tagConventionRule
+};