hexwright 0.1.0

package/dist/cli.js

@@ -0,0 +1,2223 @@
+#!/usr/bin/env node
+import "./chunk-ZXMDA7VB.js";
+
+// src/cli.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { createRequire } from "module";
+import { dirname as dirname2, join as join6, resolve } from "path";
+import { parseArgs } from "util";
+
+// src/mcp.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+var ok = (text) => ({ content: [{ type: "text", text }] });
+var brief = (n) => `${n.name} [${n.component}] ${n.domain} \u2014 ${n.file}:${n.line}`;
+var edgeLine = (e, other, dir) => `  ${dir} ${other?.name ?? "?"} [${other?.component}] ${other?.domain}${e.rel === "DEPENDS_ON" ? "" : ` (${e.rel})`}${e.identifierOnly ? " \xB7id" : ""}${e.violation ? `  !! ${e.violation}` : ""}${e.contracts.length ? `
+      uses: ${e.contracts.join(", ")}` : ""}`;
+function buildServer(getQuery, _project) {
+  const server = new McpServer({ name: "hexwright", version: "0.1.0" });
+  const resolveOr = (q, name) => {
+    const r = q.resolve(name);
+    if (r.node) return { node: r.node, err: null };
+    const list = r.candidates.map(brief).join("\n");
+    return {
+      node: null,
+      err: ok(
+        r.candidates.length ? `'${name}' is ambiguous or not exact. Candidates:
+${list}` : `not found: ${name}`
+      )
+    };
+  };
+  server.registerTool(
+    "check_violations",
+    {
+      title: "Boundary violations",
+      description: "Whether the code breaks its own architecture: cross-domain Entity access, an Entity leaked into a contract, an inbound adapter touching an Entity, an application or domain type referencing an adapter. Run this after finishing a change and before opening a PR \u2014 these are verdicts over the whole graph, so reading files will not surface them. scope 'delta' reports only what this branch introduced, including a relation that already existed but became a violation because a type moved.",
+      inputSchema: { scope: z.enum(["all", "delta"]).optional() }
+    },
+    async ({ scope = "all" }) => {
+      const q = getQuery();
+      if (scope === "delta" && !q.hasBase) {
+        return ok("no base ref \u2014 restart the server with --base <ref> to scope to this branch");
+      }
+      const vs = q.violations(scope);
+      if (!vs.length) return ok(scope === "delta" ? "no new violations" : "no violations");
+      return ok(
+        [
+          `${vs.length} violation(s):`,
+          ...vs.map((e) => {
+            const s = q.node(e.src);
+            const d = q.node(e.dst);
+            return `  ${s?.name} \u2192 ${d?.domain}.${d?.name}
+      ${e.violation}
+      ${s?.file}`;
+          })
+        ].join("\n")
+      );
+    }
+  );
+  server.registerTool(
+    "get_delta",
+    {
+      title: "Branch delta",
+      description: "What this branch changed structurally against the base: types added, types whose public contract or relations changed \u2014 and for each, exactly what was added or removed. Use it before opening a PR to confirm the change matches what was agreed, and to describe it from facts rather than memory. Needs the server started with --base."
+    },
+    async () => {
+      const q = getQuery();
+      const d = q.delta();
+      if (!d.added.length && !d.modified.length) {
+        return ok(
+          q.hasBase ? "no structural change on this branch" : "no base ref \u2014 restart with --base"
+        );
+      }
+      const out = [
+        `added ${d.added.length} types \xB7 ${d.addedEdges.length} edges \xB7 modified ${d.modified.length} types`
+      ];
+      if (d.added.length) out.push("", "added:", ...d.added.map((n) => `  + ${brief(n)}`));
+      if (d.modified.length) {
+        out.push("", "modified:");
+        for (const n of d.modified) {
+          out.push(`  ~ ${brief(n)}`);
+          const c = n.change;
+          if (!c) continue;
+          const nameOf = (id) => q.node(id)?.name ?? id;
+          for (const s of c.apiRemoved) out.push(`      - contract  ${s}`);
+          for (const s of c.apiAdded) out.push(`      + contract  ${s}`);
+          for (const s of c.propsRemoved) out.push(`      - property  ${s}`);
+          for (const s of c.propsAdded) out.push(`      + property  ${s}`);
+          for (const id of c.depsRemoved) out.push(`      - depends   ${nameOf(id)}`);
+          for (const id of c.depsAdded) out.push(`      + depends   ${nameOf(id)}`);
+        }
+      }
+      const newViol = q.violations("delta");
+      out.push("", newViol.length ? `NEW violations (${newViol.length}):` : "no new violations");
+      for (const e of newViol) {
+        out.push(`  ${q.node(e.src)?.name} \u2192 ${q.node(e.dst)?.name}  ${e.violation}`);
+      }
+      return ok(out.join("\n"));
+    }
+  );
+  server.registerTool(
+    "dependencies",
+    {
+      title: "Dependencies",
+      description: "How a type is wired, in either direction. 'out' = what it depends on and which methods it actually calls on each \u2014 including references held only in a local variable, whose type name never appears in the source, so grep cannot find them. 'in' = what depends on it, which of its methods each consumer uses, and which it declares that nobody calls. Use 'in' before adding a method to an existing port or use case: if the consumers already use disjoint subsets, the interface wants splitting rather than growing. Raise hops to see what a change would reach beyond the direct callers.",
+      inputSchema: {
+        name: z.string().describe("exact type name or FQCN"),
+        direction: z.enum(["in", "out", "both"]).optional(),
+        hops: z.number().int().min(1).max(4).optional().describe("in-direction only. default 1"),
+        includeIdentifiers: z.boolean().optional().describe("include identifier-only references (FamilyId etc). default false")
+      }
+    },
+    async ({ name, direction = "both", hops = 1, includeIdentifiers = false }) => {
+      const q = getQuery();
+      const { node: n, err } = resolveOr(q, name);
+      if (!n) return err;
+      const keep = (e) => includeIdentifiers || !e.identifierOnly;
+      const out = [`${n.name} [${n.component}] ${n.domain} \u2014 ${n.file}:${n.line}`];
+      if (direction !== "in") {
+        const es = q.outgoing(n.id).filter(keep);
+        out.push("", `depends on (${es.length}):`);
+        for (const e of es) out.push(edgeLine(e, q.node(e.dst), "\u2192"));
+      }
+      if (direction !== "out") {
+        const es = q.incoming(n.id).filter(keep);
+        out.push("", `depended on by (${es.length}):`);
+        for (const e of es) out.push(edgeLine(e, q.node(e.src), "\u2190"));
+        const u = q.contractUsage(n.id);
+        if (u.declared.length && u.unusedByAll.length) {
+          out.push("", `declares ${u.declared.length}, never called (${u.unusedByAll.length}):`);
+          for (const s of u.unusedByAll) out.push(`  ${s}`);
+        }
+        if (hops > 1) {
+          const reach = q.impact(n.id, hops).filter((r) => r.hop > 1);
+          out.push("", `reaches ${reach.length} more type(s) beyond the direct callers:`);
+          for (const r of reach) out.push(`  hop ${r.hop}  ${brief(r.node)}`);
+        }
+      }
+      return ok(out.join("\n"));
+    }
+  );
+  return server;
+}
+async function serveStdio(getQuery, project) {
+  const server = buildServer(getQuery, project);
+  await server.connect(new StdioServerTransport());
+}
+
+// src/output/tsv.ts
+function toTsv(g) {
+  const prefix = commonPrefix(g.nodes.map((n) => n.id));
+  const s = (id) => prefix && id.startsWith(prefix) ? id.slice(prefix.length) : id;
+  const out = [
+    `# hexwright	project=${g.project}	ref=${g.ref}	prefix=${prefix}`,
+    `# nodes=${g.nodes.length}	edges=${g.edges.length}`
+  ];
+  for (const n of g.nodes) {
+    out.push(["N", s(n.id), n.domain, n.component, `${n.file}:${n.line}`].join("	"));
+  }
+  for (const e of g.edges) {
+    const flags = (e.crossDomain ? "x" : "") + (e.identifierOnly ? "i" : "") + (e.violation ? "!" : "");
+    out.push(["E", e.rel, s(e.src), s(e.dst), flags].join("	"));
+  }
+  return `${out.join("\n")}
+`;
+}
+function commonPrefix(ids) {
+  if (!ids.length) return "";
+  const parts = ids.map((i) => i.split("."));
+  const first = parts[0];
+  const common = [];
+  for (let i = 0; i < first.length - 1; i++) {
+    const seg = first[i];
+    if (parts.every((p) => p[i] === seg)) common.push(seg);
+    else break;
+  }
+  return common.length ? `${common.join(".")}.` : "";
+}
+function deltaSummary(d, g) {
+  const byId = new Map(g.nodes.map((n) => [n.id, n]));
+  const label = (id) => {
+    const n = byId.get(id);
+    return n ? `${n.name} [${n.component}] ${n.domain}` : id;
+  };
+  const lines = [
+    `added   ${d.addedNodes.length} nodes \xB7 ${d.addedEdges.length} edges`,
+    `modified ${d.modifiedNodes.length} nodes`,
+    `removed ${d.removedNodes.length} nodes \xB7 ${d.removedEdges.length} edges`
+  ];
+  for (const id of d.addedNodes) lines.push(`  + ${label(id)}`);
+  for (const id of d.modifiedNodes) lines.push(`  ~ ${label(id)}`);
+  for (const id of d.removedNodes) lines.push(`  - ${id}`);
+  return lines.join("\n");
+}
+
+// src/profile.ts
+import { readFileSync } from "fs";
+import { parse } from "yaml";
+function loadProfile(path, overrides = {}) {
+  const p = parse(readFileSync(path, "utf8"));
+  p.domain = { ...p.domain, ...overrides };
+  return p;
+}
+function layerOf(p, path) {
+  for (const [layer, frag] of Object.entries(p.layers)) {
+    if (path.includes(frag)) return layer;
+  }
+  return "other";
+}
+function sublayerOf(p, path) {
+  for (const [sub, frag] of Object.entries(p.sublayers)) {
+    if (path.includes(frag)) return sub;
+  }
+  return "";
+}
+function adapterKindOf(p, path) {
+  for (const [kind, frag] of Object.entries(p.adapterKinds)) {
+    if (path.includes(frag)) return kind;
+  }
+  return path.includes("/adapter/") ? "in" : "";
+}
+function isExcluded(p, path) {
+  return p.exclude.some((frag) => path.includes(frag));
+}
+function componentOf(p, ctx) {
+  for (const r of p.components) {
+    if (r.layer && r.layer !== ctx.layer) continue;
+    if (r.sublayer && r.sublayer !== ctx.sublayer) continue;
+    if (r.kinds && !r.kinds.includes(ctx.kind)) continue;
+    if (r.structs && !r.structs.some((x) => x.toLowerCase() === ctx.struct.toLowerCase())) continue;
+    if (r.nameEnds && !ctx.name.endsWith(r.nameEnds)) continue;
+    return r.as;
+  }
+  return "DTO";
+}
+
+// src/project.ts
+import { existsSync, readFileSync as readFileSync2, readdirSync, statSync } from "fs";
+import { join, relative } from "path";
+var GRADLE = ["build.gradle.kts", "build.gradle"];
+var SETTINGS = ["settings.gradle.kts", "settings.gradle"];
+var SKIP = /* @__PURE__ */ new Set(["node_modules", "build", ".git", ".gradle", "dist", "out"]);
+function findGradleModules(root, maxDepth) {
+  const found = [];
+  const walk2 = (dir, depth) => {
+    if (GRADLE.some((f) => existsSync(join(dir, f)))) found.push(dir);
+    if (depth >= maxDepth) return;
+    for (const e of readdirSync(dir)) {
+      if (SKIP.has(e) || e.startsWith(".")) continue;
+      const p = join(dir, e);
+      if (statSync(p).isDirectory()) walk2(p, depth + 1);
+    }
+  };
+  walk2(root, 0);
+  return found;
+}
+function countSubprojects(dir) {
+  for (const f of SETTINGS) {
+    const p = join(dir, f);
+    if (!existsSync(p)) continue;
+    const text = readFileSync2(p, "utf8").replace(/\/\/[^\n]*/g, "");
+    return (text.match(/\binclude\s*[("']/g) ?? []).length;
+  }
+  return 0;
+}
+function detectSource(repo, override) {
+  if (override) {
+    const asModule = join(repo, override, "src", "main", "kotlin");
+    if (existsSync(asModule)) {
+      return {
+        srcAbs: asModule,
+        srcRel: join(override, "src/main/kotlin"),
+        module: override,
+        subprojects: countSubprojects(join(repo, override)) || countSubprojects(repo),
+        how: "gradle"
+      };
+    }
+    const abs = join(repo, override);
+    if (!existsSync(abs)) throw new Error(`source root not found: ${abs}`);
+    return { srcAbs: abs, srcRel: override, module: ".", subprojects: 0, how: "explicit" };
+  }
+  const modules = findGradleModules(repo, 2).filter(
+    (m) => existsSync(join(m, "src", "main", "kotlin"))
+  );
+  if (modules.length === 1) {
+    const mod = modules[0];
+    const abs = join(mod, "src", "main", "kotlin");
+    return {
+      srcAbs: abs,
+      srcRel: relative(repo, abs) || ".",
+      module: relative(repo, mod) || ".",
+      subprojects: countSubprojects(mod) || countSubprojects(repo),
+      how: "gradle"
+    };
+  }
+  if (modules.length > 1) {
+    const names = modules.map((m) => relative(repo, m) || ".").join(", ");
+    throw new Error(
+      `found ${modules.length} Gradle modules with Kotlin sources (${names}).
+hexwright assumes a single module \u2014 pass --src to pick one.`
+    );
+  }
+  const fallback = join(repo, "src", "main", "kotlin");
+  if (existsSync(fallback)) {
+    return {
+      srcAbs: fallback,
+      srcRel: "src/main/kotlin",
+      module: ".",
+      subprojects: 0,
+      how: "convention"
+    };
+  }
+  throw new Error(
+    "no Kotlin source root found. Looked for build.gradle(.kts) with src/main/kotlin up to two levels deep, then ./src/main/kotlin. Pass --src to specify it."
+  );
+}
+
+// src/view/layout.ts
+var LEVEL = {
+  Entity: 0,
+  Service: 1,
+  Event: 1,
+  UseCase: 2,
+  Port: 3,
+  DTO: 4,
+  VO: 4,
+  Error: 4,
+  Shared: 4,
+  Adapter: 5
+};
+var SATURATION = {
+  Entity: 95,
+  Service: 72,
+  Event: 60,
+  UseCase: 48,
+  Port: 30,
+  DTO: 0,
+  VO: 0,
+  Error: 0,
+  Shared: 22,
+  Adapter: 18
+};
+var SHAPE = {
+  Entity: "barrel",
+  Service: "rectangle",
+  UseCase: "round-rectangle",
+  Port: "cut-rectangle",
+  Event: "rhomboid",
+  DTO: "round-rectangle",
+  VO: "round-rectangle",
+  Error: "round-rectangle",
+  Shared: "round-rectangle",
+  Adapter: "round-rectangle"
+};
+var CORE = ["Entity", "Service", "UseCase", "Port", "Event"];
+var OUTLINE = ["DTO", "VO", "Error"];
+var HUE_FLOOR = 42;
+var HUE_CEIL = 338;
+var HUE_SEP = 15;
+function rawHue(domain) {
+  let h = 0;
+  for (let i = 0; i < domain.length; i++) h = h * 31 + domain.charCodeAt(i) | 0;
+  const frac = Math.abs(h * 0.6180339887 % 1);
+  return Math.round(HUE_FLOOR + frac * (HUE_CEIL - HUE_FLOOR));
+}
+var circDist = (a, b) => {
+  const d = Math.abs(a - b) % 360;
+  return Math.min(d, 360 - d);
+};
+function hueMap(domains) {
+  const names = [...new Set(domains)].filter((d) => !isCommon(d)).sort();
+  const taken = [];
+  const out = /* @__PURE__ */ new Map();
+  const span = HUE_CEIL - HUE_FLOOR;
+  for (const d of names) {
+    const start = rawHue(d);
+    let hue = start;
+    for (let step = 0; step < span; step++) {
+      const cand = HUE_FLOOR + (start - HUE_FLOOR + step) % span;
+      if (taken.every((t) => circDist(t, cand) >= HUE_SEP)) {
+        hue = cand;
+        break;
+      }
+    }
+    taken.push(hue);
+    out.set(d, hue);
+  }
+  return (d) => isCommon(d) ? 0 : out.get(d) ?? rawHue(d);
+}
+var isCommon = (domain) => domain === "common" || domain === "shared";
+var NODE_W = 190;
+var NODE_H = 40;
+var RING_GAP = 230;
+var ARC = 268;
+var DOMAIN_GAP = 130;
+var BOX_PAD = 34;
+var LABEL_H = 30;
+function concentric(nodes) {
+  const rings = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    const lv = LEVEL[n.component];
+    rings.set(lv, [...rings.get(lv) ?? [], n]);
+  }
+  const pos = /* @__PURE__ */ new Map();
+  let prev = 0;
+  for (const lv of [...rings.keys()].sort((a, b) => a - b)) {
+    const ring = rings.get(lv);
+    const need = ring.length * ARC / (2 * Math.PI);
+    const r = lv === 0 && ring.length === 1 ? 0 : Math.max(prev + RING_GAP, need, 170);
+    ring.forEach((n, i) => {
+      if (r === 0) pos.set(n.id, [0, 0]);
+      else {
+        const a = 2 * Math.PI * i / ring.length - Math.PI / 2;
+        pos.set(n.id, [r * Math.cos(a), r * Math.sin(a)]);
+      }
+    });
+    prev = r;
+  }
+  let hw = 0;
+  let hh = 0;
+  for (const [x, y] of pos.values()) {
+    hw = Math.max(hw, Math.abs(x));
+    hh = Math.max(hh, Math.abs(y));
+  }
+  return { pos, hw: hw + NODE_W / 2 + BOX_PAD, hh: hh + NODE_H / 2 + BOX_PAD + LABEL_H / 2 };
+}
+function placeDomains(g, box, gap = DOMAIN_GAP) {
+  const byId = new Map(g.nodes.map((n) => [n.id, n]));
+  const link = /* @__PURE__ */ new Map();
+  for (const e of g.edges) {
+    const a = byId.get(e.src)?.domain;
+    const b = byId.get(e.dst)?.domain;
+    if (!a || !b || a === b) continue;
+    const k = a < b ? `${a}|${b}` : `${b}|${a}`;
+    link.set(k, (link.get(k) ?? 0) + 1);
+  }
+  const size = (d) => box.get(d) ?? { hw: 0, hh: 0 };
+  const area = (d) => size(d).hw * size(d).hh;
+  const doms = [...box.keys()].sort((a, b) => area(b) - area(a));
+  const P = /* @__PURE__ */ new Map();
+  let r = 0;
+  let ang = 0;
+  doms.forEach((d, i) => {
+    if (i === 0) {
+      P.set(d, [0, 0]);
+      return;
+    }
+    r += Math.hypot(size(d).hw, size(d).hh) * 0.95;
+    ang += 2.399963;
+    P.set(d, [r * Math.cos(ang), r * Math.sin(ang)]);
+  });
+  const separate = (step) => {
+    let worst = 0;
+    for (let i = 0; i < doms.length; i++) {
+      const a = doms[i];
+      for (let j = i + 1; j < doms.length; j++) {
+        const b = doms[j];
+        const pa = P.get(a);
+        const pb = P.get(b);
+        const dx = pb[0] - pa[0];
+        const dy = pb[1] - pa[1];
+        const ox = size(a).hw + size(b).hw + gap - Math.abs(dx);
+        const oy = size(a).hh + size(b).hh + gap - Math.abs(dy);
+        if (ox <= 0 || oy <= 0) continue;
+        worst = Math.max(worst, Math.min(ox, oy));
+        const shift = Math.min(ox, oy) * step;
+        if (ox < oy) {
+          const s = dx >= 0 ? 1 : -1;
+          pa[0] -= s * shift;
+          pb[0] += s * shift;
+        } else {
+          const s = dy >= 0 ? 1 : -1;
+          pa[1] -= s * shift;
+          pb[1] += s * shift;
+        }
+      }
+    }
+    return worst;
+  };
+  for (let iter = 0; iter < 400; iter++) {
+    for (let i = 0; i < doms.length; i++) {
+      const a = doms[i];
+      for (let j = i + 1; j < doms.length; j++) {
+        const b = doms[j];
+        const w = link.get(a < b ? `${a}|${b}` : `${b}|${a}`) ?? 0;
+        const pa = P.get(a);
+        const pb = P.get(b);
+        const dx = pb[0] - pa[0];
+        const dy = pb[1] - pa[1];
+        const dist = Math.hypot(dx, dy) || 1;
+        const ox = size(a).hw + size(b).hw + gap - Math.abs(dx);
+        const oy = size(a).hh + size(b).hh + gap - Math.abs(dy);
+        if (ox > 0 && oy > 0) continue;
+        const slack = -Math.min(ox, oy);
+        const pull = Math.min(slack * (w ? 0.06 * Math.log1p(w) : 6e-3), 90);
+        P.set(a, [pa[0] + dx / dist * pull, pa[1] + dy / dist * pull]);
+        P.set(b, [pb[0] - dx / dist * pull, pb[1] - dy / dist * pull]);
+      }
+    }
+    separate(0.5);
+    for (const d of doms) {
+      const p = P.get(d);
+      p[0] -= p[0] * 4e-3;
+      p[1] -= p[1] * 4e-3;
+    }
+  }
+  for (let iter = 0; iter < 600 && separate(0.5) > 0.5; iter++) ;
+  return P;
+}
+function hexLayout(g) {
+  const byDomain = /* @__PURE__ */ new Map();
+  for (const n of g.nodes) byDomain.set(n.domain, [...byDomain.get(n.domain) ?? [], n]);
+  const local = /* @__PURE__ */ new Map();
+  const box = /* @__PURE__ */ new Map();
+  for (const [d, ns] of byDomain) {
+    const c = concentric(ns);
+    local.set(d, c.pos);
+    box.set(d, { hw: c.hw, hh: c.hh });
+  }
+  const centers = placeDomains(g, box);
+  const out = [];
+  for (const [d, pos] of local) {
+    const [cx, cy] = centers.get(d) ?? [0, 0];
+    for (const [id, [x, y]] of pos) out.push({ id, x: Math.round(cx + x), y: Math.round(cy + y) });
+  }
+  return out;
+}
+var COL_W = NODE_W + 54;
+var ROW_H = 74;
+function blockOf(d, ns) {
+  const items = [...ns].sort(
+    (a, b) => LEVEL[a.component] - LEVEL[b.component] || a.name.localeCompare(b.name)
+  );
+  const cols = Math.max(1, Math.min(5, Math.ceil(Math.sqrt(items.length / 2.2))));
+  const rows = Math.ceil(items.length / cols);
+  return { d, items, cols, w: cols * COL_W + 80, h: rows * ROW_H + 92 };
+}
+function organicLayout(g) {
+  const byDomain = /* @__PURE__ */ new Map();
+  for (const n of g.nodes) byDomain.set(n.domain, [...byDomain.get(n.domain) ?? [], n]);
+  const blocks = [...byDomain].map(([d, ns]) => blockOf(d, ns));
+  const box = new Map(blocks.map((b) => [b.d, { hw: b.w / 2, hh: b.h / 2 }]));
+  const centers = placeDomains(g, box, 70);
+  const out = [];
+  for (const b of blocks) {
+    const [cx, cy] = centers.get(b.d) ?? [0, 0];
+    b.items.forEach((n, i) => {
+      out.push({
+        id: n.id,
+        x: Math.round(cx - b.w / 2 + 40 + i % b.cols * COL_W + NODE_W / 2),
+        y: Math.round(cy - b.h / 2 + 52 + Math.floor(i / b.cols) * ROW_H)
+      });
+    });
+  }
+  return out;
+}
+function gridLayout(g, maxWidth = 3e3) {
+  const byDomain = /* @__PURE__ */ new Map();
+  for (const n of g.nodes) byDomain.set(n.domain, [...byDomain.get(n.domain) ?? [], n]);
+  const blocks = [...byDomain.entries()].map(([d, ns]) => blockOf(d, ns)).sort((a, b) => b.items.length - a.items.length);
+  const MAXW = maxWidth;
+  const out = [];
+  let y = 0;
+  let x = 0;
+  let rowH = 0;
+  for (const b of blocks) {
+    if (x + b.w > MAXW && x > 0) {
+      y += rowH + 90;
+      x = 0;
+      rowH = 0;
+    }
+    b.items.forEach((n, i) => {
+      out.push({
+        id: n.id,
+        x: Math.round(x + 40 + i % b.cols * (NODE_W + 54) + NODE_W / 2),
+        y: Math.round(y + 52 + Math.floor(i / b.cols) * 74)
+      });
+    });
+    x += b.w + 70;
+    rowH = Math.max(rowH, b.h);
+  }
+  return out;
+}
+
+// src/render/select.ts
+function select(g, view, showIdentifiers = false) {
+  const byId = new Map(g.nodes.map((n) => [n.id, n]));
+  const real = g.edges.filter((e) => showIdentifiers || !e.identifierOnly);
+  const withNeighbours = (seed) => {
+    const out = new Set(seed);
+    for (const e of real) {
+      if (seed.has(e.src) && byId.has(e.dst)) out.add(e.dst);
+      if (seed.has(e.dst) && byId.has(e.src)) out.add(e.src);
+    }
+    return out;
+  };
+  const changedSet = () => {
+    const seed = new Set(
+      g.nodes.filter((n) => n.status === "added" || n.status === "modified").map((n) => n.id)
+    );
+    if (!seed.size) throw new Error("no structural change on this branch \u2014 nothing to render");
+    for (const e of real) {
+      if (e.status !== "added") continue;
+      if (seed.has(e.src) && byId.has(e.dst)) seed.add(e.dst);
+      if (seed.has(e.dst) && byId.has(e.src)) seed.add(e.src);
+    }
+    return seed;
+  };
+  const dependents = (seed) => {
+    const out = new Set(seed);
+    for (const e of real) if (seed.has(e.dst) && byId.has(e.src)) out.add(e.src);
+    return out;
+  };
+  let keep;
+  let label;
+  if (view === "all") {
+    keep = new Set(g.nodes.map((n) => n.id));
+    label = "all types";
+  } else if (view === "core") {
+    keep = new Set(g.nodes.filter((n) => CORE.includes(n.component)).map((n) => n.id));
+    label = "core \u2014 Entity \xB7 Service \xB7 UseCase \xB7 Port \xB7 Event";
+  } else if (view.startsWith("domain:")) {
+    const d = view.slice(7);
+    const seed = new Set(g.nodes.filter((n) => n.domain === d).map((n) => n.id));
+    if (!seed.size) throw new Error(`no such domain: ${d}`);
+    keep = withNeighbours(seed);
+    label = `domain ${d} and what it touches`;
+  } else if (view === "impact") {
+    keep = dependents(changedSet());
+    label = "what this branch changed, and everything that depends on it";
+  } else {
+    keep = changedSet();
+    const linked = real.filter((e) => keep.has(e.src) && keep.has(e.dst)).length;
+    if (linked) {
+      label = "what this branch added and changed";
+    } else {
+      keep = dependents(keep);
+      label = "what this branch changed (no new relations \u2014 showing dependents)";
+    }
+  }
+  const nodes = g.nodes.filter((n) => keep.has(n.id));
+  const edges = real.filter((e) => keep.has(e.src) && keep.has(e.dst));
+  return { graph: { ...g, nodes, edges }, label };
+}
+
+// src/render/svg.ts
+var BG = "#0e1116";
+var FG = "#e6edf3";
+var MUTED = "#8b949e";
+var DIM = "#6e7681";
+var RULE = "#30363d";
+var ADDED = "#f0883e";
+var MODIFIED = "#a371f7";
+var VIOLATION = "#f85149";
+var FONT = "-apple-system, BlinkMacSystemFont, 'Helvetica Neue', Arial, 'DejaVu Sans', 'Liberation Sans', 'Noto Sans', sans-serif";
+var hsl = (h, s, l) => `hsl(${h},${s}%,${l}%)`;
+var esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+function fit(text, maxPx, fontPx) {
+  const w = (s) => [...s].reduce(
+    (a, c) => a + (c.charCodeAt(0) > 11904 ? 1 : /[A-Z]/.test(c) ? 0.62 : 0.5),
+    0
+  ) * fontPx;
+  if (w(text) <= maxPx) return text;
+  let out = text;
+  while (out.length > 1 && w(`${out}\u2026`) > maxPx) out = out.slice(0, -1);
+  return `${out}\u2026`;
+}
+var sizeOf = (n) => n.component === "Entity" ? { w: 190, h: 36 } : { w: 182, h: 32 };
+function shapePath(p) {
+  const { x, y, w, h } = p;
+  const l = x - w / 2;
+  const t = y - h / 2;
+  switch (SHAPE[p.n.component]) {
+    case "barrel":
+      return `<rect x="${l}" y="${t}" width="${w}" height="${h}" rx="${h / 2}" ry="${h / 2}"/>`;
+    case "rectangle":
+      return `<rect x="${l}" y="${t}" width="${w}" height="${h}"/>`;
+    case "cut-rectangle": {
+      const c = 8;
+      const pts = [
+        [l + c, t],
+        [l + w - c, t],
+        [l + w, t + c],
+        [l + w, t + h - c],
+        [l + w - c, t + h],
+        [l + c, t + h],
+        [l, t + h - c],
+        [l, t + c]
+      ];
+      return `<polygon points="${pts.map(([a, b]) => `${a},${b}`).join(" ")}"/>`;
+    }
+    case "rhomboid": {
+      const s = 9;
+      return `<polygon points="${l + s},${t} ${l + w},${t} ${l + w - s},${t + h} ${l},${t + h}"/>`;
+    }
+    default:
+      return `<rect x="${l}" y="${t}" width="${w}" height="${h}" rx="5" ry="5"/>`;
+  }
+}
+var qbez = (a, c, b, t) => ({
+  x: (1 - t) ** 2 * a.x + 2 * (1 - t) * t * c.x + t ** 2 * b.x,
+  y: (1 - t) ** 2 * a.y + 2 * (1 - t) * t * c.y + t ** 2 * b.y
+});
+var inside = (p, b, pad = 0) => Math.abs(p.x - b.x) <= b.w / 2 + pad && Math.abs(p.y - b.y) <= b.h / 2 + pad;
+function trim(a, c, b, ab, bb) {
+  const N = 120;
+  let t0 = 0;
+  let t1 = 1;
+  for (let i = 0; i <= N; i++) {
+    const t = i / N;
+    if (!inside(qbez(a, c, b, t), ab, 1)) {
+      t0 = t;
+      break;
+    }
+  }
+  for (let i = 0; i <= N; i++) {
+    const t = 1 - i / N;
+    if (!inside(qbez(a, c, b, t), bb, 3)) {
+      t1 = t;
+      break;
+    }
+  }
+  return t1 - t0 < 0.02 ? void 0 : { t0, t1 };
+}
+var EDGE = {
+  DEPENDS_ON: { width: 1.9, dash: "", bow: 0, arrow: "vee", scale: 0.95 },
+  IMPLEMENTS: { width: 2.2, dash: "9 5", bow: 42, arrow: "triangle", scale: 1.35 },
+  EXTENDS: { width: 3.4, dash: "3 3", bow: 58, arrow: "triangle", scale: 1.6 }
+};
+function arrowHead(tip, dir, st, color) {
+  const len = 11 * st.scale;
+  const half = 4.6 * st.scale;
+  const nx = -dir.y;
+  const ny = dir.x;
+  const bx = tip.x - dir.x * len;
+  const by = tip.y - dir.y * len;
+  const p1 = `${bx + nx * half},${by + ny * half}`;
+  const p2 = `${bx - nx * half},${by - ny * half}`;
+  if (st.arrow === "vee") {
+    return `<path d="M${p1} L${tip.x},${tip.y} L${p2}" fill="none" stroke="${color}" stroke-width="${st.width * 1.3}" stroke-linecap="round"/>`;
+  }
+  return `<polygon points="${tip.x},${tip.y} ${p1} ${p2}" fill="${BG}" stroke="${color}" stroke-width="${st.width}"/>`;
+}
+function gridWidthFor(g) {
+  const TARGET = 4 / 3;
+  let best = 3e3;
+  let bestErr = Number.POSITIVE_INFINITY;
+  for (const w of [900, 1200, 1500, 1900, 2400, 3e3, 3800]) {
+    const pos = gridLayout(g, w);
+    if (!pos.length) continue;
+    const xs = pos.map((p) => p.x);
+    const ys = pos.map((p) => p.y);
+    const gw = Math.max(...xs) - Math.min(...xs) + 300;
+    const gh = Math.max(...ys) - Math.min(...ys) + 200;
+    const err = Math.abs(gw / gh - TARGET);
+    if (err < bestErr) {
+      bestErr = err;
+      best = w;
+    }
+  }
+  return best;
+}
+function renderSvg(g, opt = {}) {
+  const layout = opt.layout ?? "hex";
+  const hueOf = hueMap(g.nodes.map((n) => n.domain));
+  const place = layout === "hex" ? hexLayout(g) : layout === "organic" ? organicLayout(g) : gridLayout(g, gridWidthFor(g));
+  const coords = new Map(place.map((p) => [p.id, p]));
+  const placed = g.nodes.map((n) => {
+    const c = coords.get(n.id) ?? { x: 0, y: 0 };
+    return { n, x: c.x, y: c.y, ...sizeOf(n) };
+  });
+  const at = new Map(placed.map((p) => [p.n.id, p]));
+  const domains = /* @__PURE__ */ new Map();
+  for (const p of placed) {
+    const b = domains.get(p.n.domain);
+    const x1 = Math.min(b ? b.x : Number.POSITIVE_INFINITY, p.x - p.w / 2);
+    const y1 = Math.min(b ? b.y : Number.POSITIVE_INFINITY, p.y - p.h / 2);
+    const x2 = Math.max(b ? b.w : Number.NEGATIVE_INFINITY, p.x + p.w / 2);
+    const y2 = Math.max(b ? b.h : Number.NEGATIVE_INFINITY, p.y + p.h / 2);
+    domains.set(p.n.domain, { x: x1, y: y1, w: x2, h: y2 });
+  }
+  const PAD = 26;
+  const LABEL = 26;
+  const boxes = [...domains].map(([d, b]) => ({
+    d,
+    x: b.x - PAD,
+    y: b.y - PAD - LABEL,
+    w: b.w - b.x + PAD * 2,
+    h: b.h - b.y + PAD * 2 + LABEL
+  }));
+  const parts = [];
+  for (const b of boxes) {
+    const hue = hueOf(b.d);
+    const sat = isCommon(b.d) ? 0 : 26;
+    parts.push(
+      `<rect x="${b.x}" y="${b.y}" width="${b.w}" height="${b.h}" rx="10" fill="${hsl(hue, sat, 13)}" fill-opacity="0.5" stroke="${hsl(hue, sat + 19, 42)}" stroke-width="1.5"/>`,
+      `<text x="${b.x + 14}" y="${b.y + 20}" font-size="19" font-weight="bold" fill="${hsl(hue, sat + 29, 62)}">${esc(b.d)}</text>`
+    );
+  }
+  const hasDelta = g.nodes.some((n) => n.status === "added" || n.status === "modified");
+  const order = (e) => e.violation ? 2 : e.status === "added" ? 1 : 0;
+  for (const e of [...g.edges].sort((a, b) => order(a) - order(b))) {
+    const s = at.get(e.src);
+    const d = at.get(e.dst);
+    if (!s || !d) continue;
+    const st = EDGE[e.rel] ?? EDGE.DEPENDS_ON;
+    const a = { x: s.x, y: s.y };
+    const b = { x: d.x, y: d.y };
+    const mid = { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
+    const len = Math.hypot(b.x - a.x, b.y - a.y) || 1;
+    const c = st.bow === 0 ? mid : {
+      x: mid.x + -(b.y - a.y) / len * st.bow * 2,
+      y: mid.y + (b.x - a.x) / len * st.bow * 2
+    };
+    const cut = trim(a, c, b, s, d);
+    if (!cut) continue;
+    const hue = hueOf(s.n.domain);
+    let color = hsl(hue, e.crossDomain ? 62 : 22, e.crossDomain ? 58 : 46);
+    let op = e.crossDomain ? 0.8 : 0.62;
+    if (hasDelta && e.status === "existing") op *= 0.45;
+    let width = st.width;
+    let dash = st.dash;
+    if (e.identifierOnly) {
+      dash = "1 4";
+      op = 0.4;
+    }
+    if (e.status === "added") {
+      color = ADDED;
+      op = 1;
+    }
+    if (e.violation) {
+      color = VIOLATION;
+      op = 1;
+      width = 3.4;
+    }
+    const N = 26;
+    const pts = [];
+    for (let i = 0; i <= N; i++) pts.push(qbez(a, c, b, cut.t0 + (cut.t1 - cut.t0) * i / N));
+    const path = pts.map((p, i) => `${i ? "L" : "M"}${p.x.toFixed(1)},${p.y.toFixed(1)}`).join(" ");
+    parts.push(
+      `<path d="${path}" fill="none" stroke="${color}" stroke-width="${width}"` + (dash ? ` stroke-dasharray="${dash}"` : "") + ` opacity="${op}"/>`
+    );
+    const tip = pts[N];
+    const prev = pts[N - 2];
+    const dl = Math.hypot(tip.x - prev.x, tip.y - prev.y) || 1;
+    parts.push(
+      `<g opacity="${op}">${arrowHead(tip, { x: (tip.x - prev.x) / dl, y: (tip.y - prev.y) / dl }, { ...st, width }, color)}</g>`
+    );
+    if (e.violation) {
+      const m = qbez(a, c, b, (cut.t0 + cut.t1) / 2);
+      const tw = e.violation.length * 5.2 + 8;
+      parts.push(
+        `<rect x="${m.x - tw / 2}" y="${m.y - 8}" width="${tw}" height="15" rx="3" fill="${BG}" fill-opacity="0.85"/>`,
+        `<text x="${m.x}" y="${m.y + 3.5}" font-size="10" fill="${VIOLATION}" text-anchor="middle">${esc(e.violation)}</text>`
+      );
+    }
+  }
+  for (const p of placed) {
+    const n = p.n;
+    const hue = hueOf(n.domain);
+    const sat = isCommon(n.domain) ? 0 : SATURATION[n.component];
+    const outline = OUTLINE.includes(n.component);
+    const body = shapePath(p);
+    const fill = outline ? "none" : hsl(hue, sat, 46 - sat * 0.07);
+    let stroke = hsl(hue, outline ? 48 : sat, outline ? 52 : 70);
+    let sw = outline ? 1.4 : n.component === "Entity" ? 2.6 : n.component === "Service" ? 1.8 : 1;
+    if (n.status === "added") {
+      stroke = ADDED;
+      sw = 3;
+    } else if (n.status === "modified") {
+      stroke = MODIFIED;
+      sw = 2.6;
+    }
+    const dashed = n.status === "modified" ? "7 4" : outline ? "4 3" : "";
+    const attrs = ` fill="${fill}" stroke="${stroke}" stroke-width="${sw}"` + (dashed ? ` stroke-dasharray="${dashed}"` : "");
+    parts.push(body.replace("/>", `${attrs}/>`));
+    const bold = n.component === "Entity";
+    const fs = bold ? 12 : 11;
+    parts.push(
+      `<text x="${p.x}" y="${p.y + fs * 0.36}" font-size="${fs}" text-anchor="middle"` + (bold ? ` font-weight="bold"` : "") + ` fill="${outline ? hsl(hue, hue ? 52 : 0, 72) : "#fff"}">${esc(fit(n.name, p.w - 20, fs))}</text>`
+    );
+  }
+  const xs = boxes.flatMap((b) => [b.x, b.x + b.w]);
+  const ys = boxes.flatMap((b) => [b.y, b.y + b.h]);
+  const M = 40;
+  const minX = Math.min(...xs) - M;
+  const minY = Math.min(...ys) - M;
+  const gw = Math.max(...xs) - minX + M;
+  const gh = Math.max(...ys) - minY + M;
+  const head = header(g, opt.viewLabel ?? "", gw);
+  const legend = legendBlock(g, gw, head.h + gh, hueOf);
+  const total = head.h + gh + legend.h;
+  return [
+    `<svg xmlns="http://www.w3.org/2000/svg" width="${Math.round(gw)}" height="${Math.round(total)}"`,
+    ` viewBox="0 0 ${Math.round(gw)} ${Math.round(total)}" font-family="${FONT}">`,
+    `<rect width="100%" height="100%" fill="${BG}"/>`,
+    head.svg,
+    `<g transform="translate(${-minX},${head.h - minY})">`,
+    ...parts,
+    "</g>",
+    legend.svg,
+    "</svg>",
+    ""
+  ].join("\n");
+}
+function header(g, viewLabel, w) {
+  const add = g.nodes.filter((n) => n.status === "added").length;
+  const mod = g.nodes.filter((n) => n.status === "modified").length;
+  const viol = g.edges.filter((e) => e.violation).length;
+  const bits = [`${g.nodes.length} types`, `${g.edges.length} relations`];
+  if (add || mod) bits.push(`${add} added \xB7 ${mod} modified`);
+  bits.push(viol ? `${viol} violation${viol > 1 ? "s" : ""}` : "no violations");
+  return {
+    h: 78,
+    svg: [
+      `<text x="26" y="30" font-size="17" font-weight="bold" fill="${FG}">${esc(g.project)}</text>`,
+      `<text x="${esc(String(26 + g.project.length * 10 + 12))}" y="30" font-size="12" fill="${DIM}">${esc(g.ref)}</text>`,
+      `<text x="26" y="52" font-size="12" fill="${MUTED}">${esc(viewLabel)}</text>`,
+      `<text x="${w - 26}" y="30" font-size="12" text-anchor="end" fill="${viol ? VIOLATION : MUTED}">${esc(bits.join("  \xB7  "))}</text>`,
+      `<line x1="0" y1="66" x2="${w}" y2="66" stroke="${RULE}"/>`
+    ].join("\n")
+  };
+}
+function legendBlock(g, w, top, hueOf) {
+  const comps = [...new Set(g.nodes.map((n) => n.component))].sort((a, b) => LEVEL[a] - LEVEL[b]);
+  const rels = [...new Set(g.edges.map((e) => e.rel))];
+  const doms = [...new Set(g.nodes.map((n) => n.domain))].sort();
+  const rows = [`<line x1="0" y1="${top}" x2="${w}" y2="${top}" stroke="${RULE}"/>`];
+  let y = top + 26;
+  let x = 26;
+  rows.push(`<text x="${x}" y="${y + 4}" font-size="11" fill="${DIM}">shape</text>`);
+  x += 48;
+  for (const c of comps) {
+    const p = {
+      n: { component: c, domain: "", name: "" },
+      x: x + 16,
+      y,
+      w: 30,
+      h: 15
+    };
+    const outline = OUTLINE.includes(c);
+    rows.push(
+      shapePath(p).replace(
+        "/>",
+        ` fill="${outline ? "none" : MUTED}" stroke="${MUTED}" stroke-width="1.2"${outline ? ' stroke-dasharray="3 2"' : ""}/>`
+      ),
+      `<text x="${x + 38}" y="${y + 4}" font-size="11" fill="${MUTED}">${c}</text>`
+    );
+    x += 46 + c.length * 6.6;
+  }
+  y += 26;
+  x = 26;
+  rows.push(`<text x="${x}" y="${y + 4}" font-size="11" fill="${DIM}">edge</text>`);
+  x += 48;
+  for (const r of rels) {
+    const st = EDGE[r];
+    rows.push(
+      `<path d="M${x},${y} L${x + 34},${y}" stroke="${MUTED}" stroke-width="${st.width}"${st.dash ? ` stroke-dasharray="${st.dash}"` : ""} fill="none"/>`,
+      arrowHead({ x: x + 40, y }, { x: 1, y: 0 }, st, MUTED),
+      `<text x="${x + 48}" y="${y + 4}" font-size="11" fill="${MUTED}">${r}</text>`
+    );
+    x += 60 + r.length * 6.6;
+  }
+  rows.push(
+    `<path d="M${x},${y} L${x + 34},${y}" stroke="${VIOLATION}" stroke-width="3.4" fill="none"/>`,
+    `<text x="${x + 40}" y="${y + 4}" font-size="11" fill="${VIOLATION}">boundary violation</text>`
+  );
+  x += 150;
+  rows.push(
+    `<rect x="${x}" y="${y - 7}" width="14" height="14" rx="3" fill="none" stroke="${ADDED}" stroke-width="3"/>`,
+    `<text x="${x + 20}" y="${y + 4}" font-size="11" fill="${ADDED}">added</text>`,
+    `<rect x="${x + 66}" y="${y - 7}" width="14" height="14" rx="3" fill="none" stroke="${MODIFIED}" stroke-width="2.6" stroke-dasharray="7 4"/>`,
+    `<text x="${x + 86}" y="${y + 4}" font-size="11" fill="${MODIFIED}">modified</text>`
+  );
+  y += 26;
+  x = 26;
+  rows.push(`<text x="${x}" y="${y + 4}" font-size="11" fill="${DIM}">domain</text>`);
+  x += 48;
+  for (const d of doms) {
+    if (x > w - 160) {
+      y += 20;
+      x = 74;
+    }
+    rows.push(
+      `<rect x="${x}" y="${y - 6}" width="11" height="11" rx="2" fill="${hsl(hueOf(d), isCommon(d) ? 0 : 60, 50)}"/>`,
+      `<text x="${x + 16}" y="${y + 4}" font-size="11" fill="${MUTED}">${esc(d)}</text>`
+    );
+    x += 24 + d.length * 6.6;
+  }
+  y += 24;
+  rows.push(
+    `<text x="26" y="${y + 4}" font-size="10" fill="${DIM}">colour = domain \xB7 saturation = position in the hexagon (Entity darkest \u2192 outward lighter) \xB7 coordinates are deterministic, so two branches line up</text>`
+  );
+  return { svg: rows.join("\n"), h: y + 22 - top };
+}
+
+// src/source.ts
+import { readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import { join as join4 } from "path";
+
+// src/model.ts
+var nodeIndex = (g) => new Map(g.nodes.map((n) => [n.id, n]));
+var edgeKey = (e) => `${e.src}\0${e.dst}\0${e.rel}`;
+
+// src/delta.ts
+function diff(base, head) {
+  const b = nodeIndex(base);
+  const h = nodeIndex(head);
+  const addedNodes = [...h.keys()].filter((id) => !b.has(id)).sort();
+  const removedNodes = [...b.keys()].filter((id) => !h.has(id)).sort();
+  const be = new Map(base.edges.map((e) => [edgeKey(e), e]));
+  const he = new Map(head.edges.map((e) => [edgeKey(e), e]));
+  const addedEdges = [...he].filter(([k]) => !be.has(k)).map(([, e]) => e);
+  const removedEdges = [...be].filter(([k]) => !he.has(k)).map(([, e]) => e);
+  const contractChanged = /* @__PURE__ */ new Set();
+  for (const [id, n] of h) {
+    const o = b.get(id);
+    if (!o) continue;
+    if (o.api.join("\n") !== n.api.join("\n") || o.props.join("\n") !== n.props.join("\n")) {
+      contractChanged.add(id);
+    }
+  }
+  const touched = /* @__PURE__ */ new Set();
+  for (const e of [...addedEdges, ...removedEdges]) {
+    touched.add(e.src);
+    touched.add(e.dst);
+  }
+  const added = new Set(addedNodes);
+  const modifiedNodes = [.../* @__PURE__ */ new Set([...contractChanged, ...touched])].filter((id) => h.has(id) && !added.has(id)).sort();
+  const gone = (from, to) => {
+    const s = new Set(to);
+    return from.filter((x) => !s.has(x));
+  };
+  const changes = /* @__PURE__ */ new Map();
+  for (const id of modifiedNodes) {
+    const o = b.get(id);
+    const n = h.get(id);
+    changes.set(id, {
+      apiAdded: gone(n.api, o.api),
+      apiRemoved: gone(o.api, n.api),
+      propsAdded: gone(n.props, o.props),
+      propsRemoved: gone(o.props, n.props),
+      depsAdded: addedEdges.filter((e) => e.src === id).map((e) => e.dst),
+      depsRemoved: removedEdges.filter((e) => e.src === id).map((e) => e.dst)
+    });
+  }
+  const baseViol = new Set(base.edges.filter((e) => e.violation).map(edgeKey));
+  const newViolations = new Set(
+    head.edges.filter((e) => e.violation && !baseViol.has(edgeKey(e))).map(edgeKey)
+  );
+  return {
+    addedNodes,
+    removedNodes,
+    modifiedNodes,
+    addedEdges,
+    removedEdges,
+    changes,
+    newViolations
+  };
+}
+function applyStatus(head, d) {
+  const added = new Set(d.addedNodes);
+  const modified = new Set(d.modifiedNodes);
+  const addedE = new Set(d.addedEdges.map(edgeKey));
+  return {
+    ...head,
+    nodes: head.nodes.map((n) => ({
+      ...n,
+      status: added.has(n.id) ? "added" : modified.has(n.id) ? "modified" : "existing",
+      ...d.changes.get(n.id) ? { change: d.changes.get(n.id) } : {}
+    })),
+    edges: head.edges.map((e) => ({
+      ...e,
+      status: addedE.has(edgeKey(e)) ? "added" : "existing",
+      ...d.newViolations.has(edgeKey(e)) ? { newViolation: true } : {}
+    }))
+  };
+}
+
+// src/extract/kotlin.ts
+import { readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join2, relative as relative2 } from "path";
+
+// src/extract/kotlin-syntax.ts
+var PACKAGE = /^package\s+([\w.]+)/;
+var IMPORT = /^import\s+([\w.]+)(?:\s+as\s+(\w+))?/;
+var MODS = "(?:public |internal |private |protected |open |abstract |sealed |data |value |inner |annotation |enum |final |external |expect |actual |fun )*";
+var DECL = new RegExp(
+  `^(?<mods>${MODS})(?<kw>class|interface|object)\\s+(?<name>[A-Za-z_]\\w*)`
+);
+var FUN_MODS = "(?:override |open |abstract |suspend |operator |private |internal |protected |inline |final )*";
+var SIG = new RegExp(
+  `^\\s+(?:@\\w+(?:\\([^)]*\\))?\\s*)*(?<mods>${FUN_MODS})fun\\s+(?<name>\\w+)\\s*\\(`
+);
+var FUN_LINE = new RegExp(
+  `^\\s+(?:@\\w+(?:\\([^)]*\\))?\\s+)*${FUN_MODS.replace("| final ", "|final ")}fun\\s`
+);
+var PROP = /^ {4}(?!private|internal|protected)(?:override |open |const |lateinit )*va[lr]\s+(\w+)\s*:\s*([^=\n]+?)\s*(?:=|$)/;
+var FIELD = /va[lr]\s+(\w+)\s*:\s*([A-Za-z_]\w*)/g;
+var LOCAL_CALL = /va[lr]\s+(\w+)\s*=\s*([A-Za-z_]\w*)[.!?]*\.(\w+)\s*\(/g;
+var LOCAL_CTOR = /va[lr]\s+(\w+)\s*=\s*([A-Z]\w*)\s*\(/g;
+var CALL = /\b(\w+)[!?]*\.(\w+)\s*\(/g;
+var TYPENAME = /\b([A-Z]\w*)\b/g;
+function kindOf(mods, kw) {
+  const m = mods.split(/\s+/);
+  for (const k of ["value", "data", "enum", "sealed", "annotation", "abstract", "fun"]) {
+    if (m.includes(k)) return `${k} ${kw}`;
+  }
+  return kw;
+}
+function structOf(kind) {
+  if (kind.includes("interface")) return "Interface";
+  if (kind === "object") return "Object";
+  return "Class";
+}
+function stripComments(text) {
+  const out = [];
+  let inBlock = false;
+  let inLine = false;
+  let inStr = false;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (inLine) {
+      if (c === "\n") {
+        inLine = false;
+        out.push("\n");
+      } else out.push(" ");
+      continue;
+    }
+    if (inBlock) {
+      if (c === "*" && text[i + 1] === "/") {
+        out.push("  ");
+        i++;
+        inBlock = false;
+        continue;
+      }
+      out.push(c === "\n" ? "\n" : " ");
+      continue;
+    }
+    if (!inStr && c === "/" && text[i + 1] === "*") {
+      inBlock = true;
+      out.push("  ");
+      i++;
+      continue;
+    }
+    if (!inStr && c === "/" && text[i + 1] === "/") {
+      inLine = true;
+      out.push("  ");
+      i++;
+      continue;
+    }
+    if (c === '"') inStr = !inStr;
+    else if (c === "\n") inStr = false;
+    out.push(c);
+  }
+  return out.join("");
+}
+function cleanSig(name, params, ret) {
+  const r = (ret.split("{")[0] ?? "").split("=")[0]?.trimEnd() ?? "";
+  return `${name}${params}${r}`.replace(/\s+/g, " ").replace(/\( /g, "(").replace(/ \)/g, ")").replace(/ ,/g, ",").trim();
+}
+function collectSigs(body) {
+  const out = /* @__PURE__ */ new Map();
+  for (let i = 0; i < body.length; i++) {
+    const m = SIG.exec(body[i]);
+    if (!m?.groups) continue;
+    const name = m.groups.name;
+    const isPublic = !/private|internal|protected/.test(m.groups.mods ?? "");
+    const buf = [];
+    let depth = 0;
+    let started = false;
+    for (let j = i; j < Math.min(i + 30, body.length); j++) {
+      let line = body[j];
+      if (j === i) line = line.slice(line.indexOf("(", line.indexOf("fun")));
+      for (const ch of line) {
+        if (ch === "(") {
+          depth++;
+          started = true;
+        } else if (ch === ")") depth--;
+        buf.push(ch);
+        if (started && depth === 0) break;
+      }
+      if (started && depth === 0) {
+        const parts = body[j].split(")");
+        out.set(name, { params: buf.join(""), ret: parts[parts.length - 1], isPublic });
+        break;
+      }
+      buf.push(" ");
+    }
+  }
+  return out;
+}
+function ctorParams(header2) {
+  const i = header2.indexOf("(");
+  if (i < 0) return [];
+  let depth = 0;
+  const buf = [];
+  for (const ch of header2.slice(i)) {
+    if (ch === "(" || ch === "<") depth++;
+    else if (ch === ")" || ch === ">") {
+      depth--;
+      if (depth === 0) break;
+    }
+    buf.push(ch);
+  }
+  const inner = buf.join("").slice(1);
+  const parts = [];
+  let cur = [];
+  depth = 0;
+  for (const ch of inner) {
+    if ("(<[".includes(ch)) depth++;
+    else if (")>]".includes(ch)) depth--;
+    if (ch === "," && depth === 0) {
+      parts.push(cur.join(""));
+      cur = [];
+    } else cur.push(ch);
+  }
+  parts.push(cur.join(""));
+  const res = [];
+  for (let p of parts) {
+    p = (p.split("=")[0] ?? "").replace(/\s+/g, " ").trim();
+    p = p.replace(/^(?:@\w+(?:\([^)]*\))?\s*)*/, "").replace(/^(?:private |internal |protected |override |val |var )*/, "").trim();
+    if (p.includes(":")) res.push(p);
+  }
+  return res;
+}
+function enumEntries(body) {
+  const i = body.indexOf("{");
+  if (i < 0) return [];
+  let depth = 0;
+  const out = [];
+  let cur = [];
+  for (const ch of body.slice(i + 1)) {
+    if (ch === "(" || ch === "[") depth++;
+    else if (ch === ")" || ch === "]") depth--;
+    else if (ch === "{") depth++;
+    else if (ch === "}") {
+      if (depth === 0) break;
+      depth--;
+    }
+    if ((ch === "," || ch === ";") && depth === 0) {
+      out.push(cur.join(""));
+      cur = [];
+      if (ch === ";") break;
+    } else cur.push(ch);
+  }
+  out.push(cur.join(""));
+  const res = [];
+  for (const e of out) {
+    const m = /^\s*([A-Z][A-Za-z0-9_]*)/.exec(e);
+    if (m) res.push(m[1]);
+  }
+  return res;
+}
+function parseSupertypes(lines, start) {
+  const buf = [];
+  let depth = 0;
+  let seenColon = false;
+  for (let li = start; li < Math.min(start + 80, lines.length); li++) {
+    let line = lines[li];
+    const cpos = line.indexOf("//");
+    if (cpos >= 0) line = line.slice(0, cpos);
+    for (const ch of line) {
+      if ("(<[".includes(ch)) depth++;
+      else if (")>]".includes(ch)) depth = Math.max(0, depth - 1);
+      else if (ch === "{" && depth === 0) return supertypeNames(buf.join(""), seenColon);
+      else if (ch === ":" && depth === 0) seenColon = true;
+      buf.push(ch);
+    }
+    const stripped = buf.join("").trimEnd();
+    if (depth === 0 && stripped) {
+      const last = stripped[stripped.length - 1];
+      if (seenColon) {
+        if (last !== "," && last !== ":") return supertypeNames(buf.join(""), seenColon);
+      } else if (li > start || !stripped.includes("(") || stripped.endsWith(")")) {
+        if (!stripped.endsWith(",")) return [];
+      }
+    }
+    buf.push("\n");
+  }
+  return supertypeNames(buf.join(""), seenColon);
+}
+function supertypeNames(text, seenColon) {
+  if (!seenColon) return [];
+  let depth = 0;
+  let idx = -1;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if ("(<[".includes(ch)) depth++;
+    else if (")>]".includes(ch)) depth = Math.max(0, depth - 1);
+    else if (ch === ":" && depth === 0) {
+      idx = i;
+      break;
+    }
+  }
+  if (idx < 0) return [];
+  const parts = [];
+  let cur = [];
+  depth = 0;
+  for (const ch of text.slice(idx + 1)) {
+    if ("(<[".includes(ch)) depth++;
+    else if (")>]".includes(ch)) depth--;
+    if (ch === "," && depth === 0) {
+      parts.push(cur.join(""));
+      cur = [];
+    } else cur.push(ch);
+  }
+  parts.push(cur.join(""));
+  const names = [];
+  for (const p of parts) {
+    const head = (p.split(/\bby\b/)[0] ?? "").trim();
+    const m = /^([A-Za-z_][\w.]*)/.exec(head);
+    if (m) names.push(m[1].split(".").pop());
+  }
+  return names;
+}
+
+// src/extract/kotlin.ts
+function walk(dir, out = []) {
+  for (const e of readdirSync2(dir)) {
+    const p = join2(dir, e);
+    if (statSync2(p).isDirectory()) walk(p, out);
+    else if (e.endsWith(".kt")) out.push(p);
+  }
+  return out;
+}
+function inferBasePackage(pkgs) {
+  if (!pkgs.length) return "";
+  const split = pkgs.map((p) => p.split("."));
+  const first = split[0];
+  const common = [];
+  for (let i = 0; i < first.length; i++) {
+    const seg = first[i];
+    if (split.every((s) => s[i] === seg)) common.push(seg);
+    else break;
+  }
+  return common.join(".");
+}
+function extractKotlin(srcRoot, profile, project, ref) {
+  const files = walk(srcRoot).sort();
+  const infos = [];
+  const rawPkgs = [];
+  for (const abs of files) {
+    const rel = relative2(srcRoot, abs);
+    if (isExcluded(profile, `/${rel}`)) continue;
+    const lines = stripComments(readFileSync3(abs, "utf8")).split("\n");
+    let pkg = "";
+    const imports = /* @__PURE__ */ new Map();
+    const decls = [];
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const pm = PACKAGE.exec(line);
+      if (pm) {
+        pkg = pm[1];
+        continue;
+      }
+      const im = IMPORT.exec(line);
+      if (im) {
+        const fq = im[1];
+        imports.set(im[2] ?? fq.split(".").pop(), fq);
+        continue;
+      }
+      const dm = DECL.exec(line);
+      if (dm?.groups) {
+        decls.push({
+          name: dm.groups.name,
+          line: i,
+          kind: kindOf(dm.groups.mods ?? "", dm.groups.kw)
+        });
+      }
+    }
+    rawPkgs.push(pkg);
+    infos.push({ rel, pkg, imports, decls, lines, layer: layerOf(profile, `/${rel}`) });
+  }
+  const base = profile.domain.base || inferBasePackage(rawPkgs);
+  const domainOf = (pkg) => {
+    const rest = pkg.startsWith(`${base}.`) ? pkg.slice(base.length + 1) : pkg;
+    return rest.split(".")[profile.domain.at] ?? "root";
+  };
+  const types = /* @__PURE__ */ new Map();
+  const byPkg = /* @__PURE__ */ new Map();
+  for (const fi of infos) {
+    if (fi.layer === "other") continue;
+    const path = `/${fi.rel}`;
+    const layer = fi.layer;
+    const sublayer = sublayerOf(profile, path);
+    const adapterKind = layer === "adapter" ? adapterKindOf(profile, path) : "";
+    const domain = domainOf(fi.pkg);
+    for (let di = 0; di < fi.decls.length; di++) {
+      const d = fi.decls[di];
+      const end = di + 1 < fi.decls.length ? fi.decls[di + 1].line : fi.lines.length;
+      const body = fi.lines.slice(d.line, end);
+      const struct = structOf(d.kind);
+      const sigs = collectSigs(body);
+      const api = [];
+      for (const [nm, s] of sigs) if (s.isPublic) api.push(cleanSig(nm, s.params, s.ret));
+      const headerFull = body.slice(0, 40).join("\n");
+      const braceAt = headerFull.indexOf("{");
+      const header2 = braceAt >= 0 ? headerFull.slice(0, braceAt) : headerFull;
+      const props = ctorParams(header2);
+      if (braceAt >= 0) {
+        const rest = body.slice(header2.split("\n").length - 1);
+        const first = rest[0];
+        if (first !== void 0) rest[0] = first.slice(first.indexOf("{") + 1);
+        for (const ln of rest) {
+          const pm = PROP.exec(ln);
+          if (pm) props.push(`${pm[1]}: ${pm[2].trim().replace(/,$/, "")}`);
+        }
+      }
+      if (d.kind.includes("enum")) props.push(...enumEntries(body.join("\n")));
+      const id = `${fi.pkg}.${d.name}`;
+      types.set(id, {
+        id,
+        name: d.name,
+        domain,
+        component: componentOf(profile, { layer, sublayer, kind: d.kind, struct, name: d.name }),
+        layer,
+        sublayer,
+        kind: d.kind,
+        adapterKind,
+        api,
+        props,
+        file: fi.rel,
+        line: d.line + 1,
+        struct,
+        sigs
+      });
+      byPkg.set(fi.pkg, [...byPkg.get(fi.pkg) ?? [], id]);
+    }
+  }
+  const visibleOf = (fi) => {
+    const v = /* @__PURE__ */ new Map();
+    for (const [simple, fq] of fi.imports) if (types.has(fq)) v.set(simple, fq);
+    for (const id of byPkg.get(fi.pkg) ?? []) {
+      const t = types.get(id);
+      if (!v.has(t.name)) v.set(t.name, id);
+    }
+    return v;
+  };
+  const analyzed = new Set(Object.keys(profile.layers));
+  const dep = /* @__PURE__ */ new Map();
+  const supers = [];
+  const layerViol = /* @__PURE__ */ new Set();
+  const key = (s, d) => `${s}\0${d}`;
+  for (const fi of infos) {
+    if (!analyzed.has(fi.layer)) continue;
+    const visible = visibleOf(fi);
+    for (let di = 0; di < fi.decls.length; di++) {
+      const d = fi.decls[di];
+      const id = `${fi.pkg}.${d.name}`;
+      const end = di + 1 < fi.decls.length ? fi.decls[di + 1].line : fi.lines.length;
+      const body = fi.lines.slice(d.line, end).join("\n");
+      for (const sup of parseSupertypes(fi.lines, d.line)) {
+        const tgt = visible.get(sup);
+        if (tgt) supers.push([id, tgt]);
+      }
+      for (const [simple, tgt] of visible) {
+        if (tgt === id) continue;
+        const t = types.get(tgt);
+        const cnt = body.split(new RegExp(`\\b${simple}\\b`, "g")).length - 1;
+        if (!cnt) continue;
+        if (t.layer === "adapter" && (fi.layer === "application" || fi.layer === "domain")) {
+          layerViol.add(key(id, tgt));
+        }
+        dep.set(key(id, tgt), (dep.get(key(id, tgt)) ?? 0) + cnt);
+      }
+    }
+  }
+  const sigTypes = /* @__PURE__ */ new Map();
+  const visCache = /* @__PURE__ */ new Map();
+  for (const fi of infos) visCache.set(fi.rel, visibleOf(fi));
+  for (const [id, t] of types) {
+    const v = visCache.get(t.file) ?? /* @__PURE__ */ new Map();
+    const m = /* @__PURE__ */ new Map();
+    for (const [nm, s] of t.sigs) {
+      const pick = (txt) => {
+        const out = /* @__PURE__ */ new Set();
+        for (const mm of txt.matchAll(TYPENAME)) {
+          const tgt = v.get(mm[1]);
+          if (tgt) out.add(tgt);
+        }
+        return out;
+      };
+      m.set(nm, [pick(s.params), pick(s.ret)]);
+    }
+    sigTypes.set(id, m);
+  }
+  const viaSig = /* @__PURE__ */ new Set();
+  const usedContracts = /* @__PURE__ */ new Map();
+  for (const fi of infos) {
+    if (!analyzed.has(fi.layer)) continue;
+    const visible = visCache.get(fi.rel);
+    for (let di = 0; di < fi.decls.length; di++) {
+      const d = fi.decls[di];
+      const id = `${fi.pkg}.${d.name}`;
+      const end = di + 1 < fi.decls.length ? fi.decls[di + 1].line : fi.lines.length;
+      const body = fi.lines.slice(d.line, end).join("\n");
+      const bind = /* @__PURE__ */ new Map();
+      for (const m of body.matchAll(FIELD)) {
+        const tgt = visible.get(m[2]);
+        if (tgt) bind.set(m[1], tgt);
+      }
+      for (let pass = 0; pass < 3; pass++) {
+        for (const m of body.matchAll(LOCAL_CTOR)) {
+          const tgt = visible.get(m[2]);
+          if (tgt && !bind.has(m[1])) bind.set(m[1], tgt);
+        }
+        for (const m of body.matchAll(LOCAL_CALL)) {
+          const owner = bind.get(m[2]);
+          if (!owner) continue;
+          const rets = sigTypes.get(owner)?.get(m[3])?.[1];
+          if (rets?.size === 1 && !bind.has(m[1])) {
+            bind.set(m[1], [...rets][0]);
+          }
+        }
+      }
+      for (const m of body.matchAll(CALL)) {
+        const owner = bind.get(m[1]);
+        if (!owner) continue;
+        const sg = sigTypes.get(owner)?.get(m[2]);
+        if (!sg) continue;
+        const ck = key(id, owner);
+        usedContracts.set(ck, (usedContracts.get(ck) ?? /* @__PURE__ */ new Set()).add(m[2]));
+        for (const tgt of /* @__PURE__ */ new Set([...sg[0], ...sg[1]])) {
+          if (tgt === id) continue;
+          const k = key(id, tgt);
+          if (!dep.has(k)) {
+            dep.set(k, 1);
+            viaSig.add(k);
+          }
+        }
+      }
+    }
+  }
+  const supSet = new Set(supers.map(([c, p]) => key(c, p)));
+  const edges = [];
+  const push2 = (src, dst, rel, weight) => {
+    const s = types.get(src);
+    const d = types.get(dst);
+    const k = key(src, dst);
+    const sigs = d.sigs;
+    const contracts = [...usedContracts.get(k) ?? []].sort().map((m) => {
+      const sg = sigs.get(m);
+      return sg ? cleanSig(m, sg.params, sg.ret) : m;
+    });
+    edges.push({
+      src,
+      dst,
+      rel,
+      weight,
+      crossDomain: s.domain !== d.domain,
+      identifierOnly: d.component === "VO" && d.sublayer === "model",
+      viaSignature: viaSig.has(k),
+      contracts: rel === "DEPENDS_ON" ? contracts : [],
+      violation: violationOf(profile, s, d, layerViol.has(k))
+    });
+  };
+  for (const [c, p] of supSet.size ? [...supSet].map((k) => k.split("\0")) : []) {
+    const parent = types.get(p);
+    push2(c, p, parent.struct === "Interface" ? "IMPLEMENTS" : "EXTENDS", 1);
+  }
+  for (const [k, w] of dep) {
+    if (supSet.has(k)) continue;
+    const [s, d] = k.split("\0");
+    push2(s, d, "DEPENDS_ON", w);
+  }
+  const nodes = [...types.values()].map(({ struct: _s, sigs: _g, ...n }) => n);
+  nodes.sort((a, b) => a.id.localeCompare(b.id));
+  edges.sort(
+    (a, b) => a.src.localeCompare(b.src) || a.dst.localeCompare(b.dst) || a.rel.localeCompare(b.rel)
+  );
+  return { project, ref, nodes, edges };
+}
+function violationOf(p, s, d, layerBack) {
+  if (layerBack) {
+    const rule = p.rules.layering.find((r) => r.from.includes(s.layer) && r.to.includes(d.layer));
+    if (rule) return rule.message;
+  }
+  if (d.component !== "Entity") return "";
+  const ea = p.rules.entityAccess;
+  if (s.domain !== d.domain) {
+    return ea.crossDomain === "deny" ? "cross-domain Entity access" : "";
+  }
+  if (s.layer === "adapter") {
+    return ea.allowAdapterKinds.includes(s.adapterKind) ? "" : "inbound adapter touches Entity";
+  }
+  return ea.allow.includes(s.component) ? "" : `${s.component} exposes Entity`;
+}
+
+// src/git.ts
+import { execFileSync } from "child_process";
+import { mkdtempSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join as join3 } from "path";
+function exportRef(repo, ref, subPath = "") {
+  const dir = mkdtempSync(join3(tmpdir(), "hexwright-"));
+  const args = ["-C", repo, "archive", "--format=tar", ref];
+  if (subPath) args.push("--", subPath);
+  let tar;
+  try {
+    tar = execFileSync("git", args, { maxBuffer: 1 << 30, stdio: ["ignore", "pipe", "ignore"] });
+  } catch {
+    rmSync(dir, { recursive: true, force: true });
+    const remote = /^([^/]+)\/(.+)$/.exec(ref);
+    const [name, dest] = remote ? [remote[2], `refs/remotes/${remote[1]}/${remote[2]}`] : [ref, `refs/heads/${ref}`];
+    throw new Error(
+      `cannot read '${ref}' from ${repo} \u2014 the ref is not in this clone.
+  CI checkouts are shallow by default. Either fetch it:
+    git fetch --no-tags --depth=1 origin ${name}:${dest}
+  or check out with full history (actions/checkout: fetch-depth: 0).`
+    );
+  }
+  execFileSync("tar", ["-x", "-C", dir], { input: tar });
+  return { dir, cleanup: () => rmSync(dir, { recursive: true, force: true }) };
+}
+var gitOut = (repo, args) => execFileSync("git", ["-C", repo, ...args], {
+  encoding: "utf8",
+  stdio: ["ignore", "pipe", "ignore"]
+}).trim();
+function resolveRef(repo, ref) {
+  return gitOut(repo, ["rev-parse", "--short", ref]);
+}
+function currentBranch(repo) {
+  return gitOut(repo, ["rev-parse", "--abbrev-ref", "HEAD"]);
+}
+
+// src/query.ts
+var GraphQuery = class {
+  graph;
+  byId;
+  out;
+  inc;
+  constructor(graph) {
+    this.graph = graph;
+    this.byId = new Map(graph.nodes.map((n) => [n.id, n]));
+    this.out = /* @__PURE__ */ new Map();
+    this.inc = /* @__PURE__ */ new Map();
+    for (const e of graph.edges) {
+      push(this.out, e.src, e);
+      push(this.inc, e.dst, e);
+    }
+  }
+  /** Find nodes by partial name or FQCN, or filter by component and domain. */
+  find(q) {
+    const needle = q.query?.toLowerCase();
+    const hits = this.graph.nodes.filter((n) => {
+      if (q.domain && n.domain !== q.domain) return false;
+      if (q.component && n.component !== q.component) return false;
+      if (!needle) return true;
+      return n.name.toLowerCase().includes(needle) || n.id.toLowerCase().includes(needle);
+    });
+    hits.sort((a, b) => {
+      const ea = a.name.toLowerCase() === needle ? 0 : 1;
+      const eb = b.name.toLowerCase() === needle ? 0 : 1;
+      return ea - eb || a.name.length - b.name.length;
+    });
+    return hits.slice(0, q.limit ?? 40);
+  }
+  /** Resolve one node from an exact name or FQCN. Ambiguity returns candidates. */
+  resolve(name) {
+    const exact = this.byId.get(name);
+    if (exact) return { node: exact, candidates: [] };
+    const byName = this.graph.nodes.filter((n) => n.name === name);
+    if (byName.length === 1) return { node: byName[0], candidates: [] };
+    if (byName.length > 1) return { candidates: byName };
+    return { candidates: this.find({ query: name, limit: 8 }) };
+  }
+  node(id) {
+    return this.byId.get(id);
+  }
+  outgoing(id) {
+    return this.out.get(id) ?? [];
+  }
+  incoming(id) {
+    return this.inc.get(id) ?? [];
+  }
+  /** What a change to this node reaches — reverse dependencies, N hops out. */
+  impact(id, hops = 2) {
+    const seen = /* @__PURE__ */ new Set([id]);
+    const out = [];
+    let frontier = [id];
+    for (let h = 1; h <= hops; h++) {
+      const next = [];
+      for (const cur of frontier) {
+        for (const e of this.incoming(cur)) {
+          if (seen.has(e.src)) continue;
+          seen.add(e.src);
+          next.push(e.src);
+          const n = this.byId.get(e.src);
+          if (n) out.push({ hop: h, node: n });
+        }
+      }
+      frontier = next;
+      if (!frontier.length) break;
+    }
+    return out;
+  }
+  /** Whether this graph can be compared against a base (built with --base). */
+  get hasBase() {
+    return this.graph.nodes.some((n) => n.status !== void 0);
+  }
+  violations(scope = "all") {
+    return this.graph.edges.filter(
+      (e) => e.violation && (scope === "all" || e.newViolation === true)
+    );
+  }
+  /** Which declared methods each consumer actually calls — the ISP signal. */
+  contractUsage(id) {
+    const target = this.byId.get(id);
+    const declared = target?.api ?? [];
+    const consumers = this.incoming(id).filter((e) => e.contracts.length).map((e) => ({ name: this.byId.get(e.src)?.name ?? e.src, used: e.contracts }));
+    const usedNames = new Set(consumers.flatMap((c) => c.used.map(methodName)));
+    return {
+      declared,
+      consumers,
+      unusedByAll: declared.filter((d) => !usedNames.has(methodName(d)))
+    };
+  }
+  delta() {
+    return {
+      added: this.graph.nodes.filter((n) => n.status === "added"),
+      modified: this.graph.nodes.filter((n) => n.status === "modified"),
+      addedEdges: this.graph.edges.filter((e) => e.status === "added")
+    };
+  }
+};
+function push(m, k, v) {
+  const arr = m.get(k);
+  if (arr) arr.push(v);
+  else m.set(k, [v]);
+}
+var methodName = (sig) => {
+  const i = sig.indexOf("(");
+  return i > 0 ? sig.slice(0, i) : sig;
+};
+
+// src/source.ts
+function stamp(srcAbs, profilePath) {
+  let newest = 0;
+  let count = 0;
+  const walk2 = (dir) => {
+    for (const e of readdirSync3(dir, { withFileTypes: true })) {
+      const p = join4(dir, e.name);
+      if (e.isDirectory()) walk2(p);
+      else if (e.name.endsWith(".kt")) {
+        count++;
+        const m = statSync3(p).mtimeMs;
+        if (m > newest) newest = m;
+      }
+    }
+  };
+  try {
+    walk2(srcAbs);
+  } catch {
+    return "unreadable";
+  }
+  let profileM = 0;
+  try {
+    profileM = statSync3(profilePath).mtimeMs;
+  } catch {
+  }
+  return `${count}:${newest}:${profileM}`;
+}
+var GraphSource = class {
+  cfg;
+  /** The base is a git ref and therefore immutable — extracted once per process. */
+  baseGraph;
+  last;
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  /** The current graph. Returns the cache when the source has not moved. */
+  graph() {
+    const s = stamp(this.cfg.srcAbs, this.cfg.profilePath);
+    if (this.last && this.last.stamp === s) return this.last.graph;
+    const { profile, project, srcAbs } = this.cfg;
+    const ref = safe(() => `${currentBranch(this.cfg.repo)}@${resolveRef(this.cfg.repo, "HEAD")}`) ?? "working-tree";
+    const head = extractKotlin(srcAbs, profile, project, ref);
+    let graph = head;
+    let delta;
+    if (this.cfg.base) {
+      delta = diff(this.base(), head);
+      graph = applyStatus(head, delta);
+    }
+    this.last = { stamp: s, graph, query: new GraphQuery(graph), ...delta ? { delta } : {} };
+    return graph;
+  }
+  /** A query object over the current graph. */
+  query() {
+    this.graph();
+    return this.last.query;
+  }
+  /** The delta against the base, or undefined when no base was given. */
+  delta() {
+    this.graph();
+    return this.last?.delta;
+  }
+  base() {
+    if (this.baseGraph) return this.baseGraph;
+    const { repo, srcRel, profile, project, base } = this.cfg;
+    const { dir, cleanup } = exportRef(repo, base, srcRel);
+    try {
+      this.baseGraph = extractKotlin(join4(dir, srcRel), profile, project, base);
+    } finally {
+      cleanup();
+    }
+    return this.baseGraph;
+  }
+};
+var safe = (f) => {
+  try {
+    return f();
+  } catch {
+    return void 0;
+  }
+};
+
+// src/view/server.ts
+import { createServer } from "http";
+import { dirname, join as join5 } from "path";
+
+// src/view/html.ts
+var shell = () => `<!doctype html>
+<meta charset="utf-8"><title>hexwright</title>
+<style>
+ *{box-sizing:border-box} body{margin:0;font:13px -apple-system,Helvetica,sans-serif;
+   background:#0e1116;color:#e6edf3;display:flex;height:100vh;overflow:hidden}
+ #side{width:340px;flex:none;background:#161b22;border-right:1px solid #30363d;
+   padding:16px 18px;overflow-y:auto}
+ #cy{flex:1;background:#0e1116}
+ h1{font-size:15px;margin:0 0 4px} #ref{color:#6e7681;font-size:10.5px;word-break:break-all}
+ .sub{color:#8b949e;font-size:11px;margin-bottom:14px;line-height:1.5}
+ .sub .d{padding-left:11px;margin:1px 0 6px;color:#7d8590;line-height:1.55;
+   border-left:1px solid #30363d} .sub b{color:#adbac7;font-weight:600}
+ h2{font-size:11px;text-transform:uppercase;letter-spacing:.06em;color:#8b949e;
+   margin:16px 0 7px;border-top:1px solid #30363d;padding-top:12px}
+ label{display:flex;align-items:center;gap:7px;padding:3px 0;cursor:pointer;font-size:12px}
+ label:hover{color:#fff} input[type=checkbox]{accent-color:#58a6ff;margin:0}
+ label i{display:inline-block;width:14px;border-top:2px solid #8b949e;vertical-align:4px;
+   margin:0 3px 0 1px;flex:none} label i.d{border-top-style:dashed}
+ .sw{width:11px;height:11px;flex:none} .n{margin-left:auto;color:#6e7681;font-size:10px}
+ button{background:#21262d;color:#c9d1d9;border:1px solid #30363d;border-radius:5px;
+   padding:5px 9px;font-size:11px;cursor:pointer;margin:2px 3px 2px 0}
+ button:hover{background:#30363d} button.on{background:#1f6feb;border-color:#1f6feb;color:#fff}
+ #stat{margin:0 0 10px;padding:7px 9px;background:#1c2128;border-radius:5px;
+   color:#8b949e;font-size:11px}
+ #deltaBox{background:#1c2128;border:1px solid #30363d;border-radius:6px;padding:9px;
+   margin:9px 0;font-size:11px;line-height:1.7;display:none}
+ .k{display:inline-block;width:9px;height:9px;border:2px solid #f0883e;border-radius:2px;
+   vertical-align:-1px;margin-right:4px}
+ .k2{display:inline-block;width:11px;border-top:2px dashed #a371f7;vertical-align:4px;
+   margin-right:4px}
+ .lg{font-size:10.5px;color:#8b949e;line-height:1.9;margin-top:4px}
+ #info{position:fixed;right:14px;top:14px;background:#161b22ee;border:1px solid #30363d;
+   border-radius:7px;padding:11px 13px;max-width:360px;font-size:12px;display:none;line-height:1.6}
+ #info table{border-collapse:collapse;width:100%;margin-top:7px}
+ #info td{padding:3px 0;vertical-align:top;font-size:11.5px}
+ #info td:first-child{color:#8b949e;width:88px;white-space:nowrap}
+ #info .ih{font-size:13px;font-weight:600;color:#58a6ff;border-bottom:1px solid #30363d;
+   padding-bottom:6px}
+ #info .mut{color:#6e7681;font-size:10.5px}
+ #info .x{float:right;cursor:pointer;color:#8b949e;font-size:16px;line-height:1;padding:0 2px}
+ #info .x:hover{color:#fff}
+ #info .hint{color:#6e7681;font-size:10px;margin-top:8px;border-top:1px solid #30363d;padding-top:6px}
+ .dirbar{display:flex;gap:4px;margin:9px 0 6px;border-top:1px solid #30363d;padding-top:9px}
+ .dirb{flex:1;margin:0;font-size:10.5px;padding:4px 2px}
+ .lks{max-height:250px;overflow-y:auto;margin:0 -3px}
+ .lk{display:flex;align-items:center;gap:4px;padding:3px 5px;border-radius:4px;
+   cursor:pointer;font-size:11.5px;white-space:nowrap;overflow:hidden}
+ .lk:hover{background:#21262d} .lk .ar{color:#58a6ff;flex:none;width:11px}
+ .lk .rel{margin-left:auto;color:#6e7681;font-size:9.5px;flex:none;padding-left:6px}
+ .lk .sig{white-space:normal;font-family:ui-monospace,Menlo,monospace;font-size:10.5px;
+   line-height:1.5;color:#8b949e} .lk .sig b{color:#79c0ff;font-weight:600}
+</style>
+<div id="side">
+ <h1 id="title">\u2026</h1>
+ <div id="ref"></div>
+ <div class="sub" style="margin-top:6px">Color = domain \xB7 Saturation = hexagonal position</div>
+ <div id="deltaBox"><div id="delta"></div></div>
+ <div id="stat"></div>
+
+ <h2>View</h2>
+ <button id="pcore">Core only</button><button id="pall">All</button>
+ <label style="margin-top:9px"><input type=checkbox id="deltaOnly">
+  <b style="color:#f0883e">Branch delta only</b></label>
+ <div class="sub" style="margin:4px 0 0"><div class="d">independent of the component filter \u2014
+  combine it with <b>Core only</b></div></div>
+
+ <h2>Layout</h2>
+ <button id="bhex">Hexagonal</button><button id="bgrid">Grid</button>
+ <div class="sub" style="margin:8px 0 0">
+  <b>Hexagonal</b><div class="d">concentric rings per domain \u2014
+   Entity \u2192 Service \u2192 UseCase \u2192 Port \u2192 DTO\xB7VO</div>
+  <b>Grid</b><div class="d">list-like. both are fixed coordinates, so branches stay comparable.</div></div>
+ <div style="margin-top:10px;border-top:1px solid #30363d;padding-top:10px">
+  <button id="borg" style="width:100%;margin:0">\u26A1 Organic re-layout</button></div>
+ <div class="sub" style="margin:6px 0 0"><div class="d">re-packs on every filter change.
+  On <b>Hexagonal</b> it moves the <b>domain boxes</b> \u2014 the concentric rings inside each
+  domain stay intact. On <b>Grid</b> it is a free-form force layout over the nodes.
+  Off = keep the fixed coordinates above.</div></div>
+
+ <h2>Edges</h2>
+ <label><input type=checkbox id="showId">Show identifier edges</label>
+ <label><input type=checkbox id="crossOnly">Cross-domain edges only</label>
+ <div class="sub" style="margin:6px 0 0"><b>Identifier edges</b><div class="d">references like
+  FamilyId\xB7UserId \u2014 a shared coordinate system, not coupling. Hidden by default.</div></div>
+
+ <h2>Edge types</h2>
+ <label><input type=checkbox class=rf value="DEPENDS_ON" checked>
+  <i></i>DEPENDS_ON <span class="mut">straight \xB7 open V</span><span class="n" id="cDEPENDS_ON"></span></label>
+ <label><input type=checkbox class=rf value="IMPLEMENTS" checked>
+  <i class="d"></i>IMPLEMENTS <span class="mut">curved \xB7 long dash</span><span class="n" id="cIMPLEMENTS"></span></label>
+ <label><input type=checkbox class=rf value="EXTENDS" checked>
+  <i class="d"></i>EXTENDS <span class="mut">curved \xB7 short dash</span><span class="n" id="cEXTENDS"></span></label>
+ <div style="margin-top:10px;border-top:1px solid #30363d;padding-top:10px">
+  <button id="bviol" style="width:100%;margin:0">\u26A0 Violations only</button></div>
+ <div class="sub" style="margin:6px 0 0"><div class="d">combines with the filters above \u2014
+  keeps only the nodes and edges a violation runs through. Turns on <b>Organic</b>
+  while active; switching it off restores exactly what you had.</div></div>
+ <div class="lg">
+  <b style="color:#f85149">Design violation</b> \u2014 thick red<span class="n" id="cviol"></span><br>
+  \xB7 cross-domain Entity access<br>\xB7 Entity leaked into a contract<br>
+  \xB7 inbound adapter touching an Entity<br>\xB7 application \u2192 adapter back-reference<br>
+  <span style="color:#f0883e">\u25A0</span> added &nbsp;<span style="color:#a371f7">\u25A0</span> modified
+ </div>
+
+ <h2>Components</h2><div id="comps"></div>
+ <h2>Domains</h2>
+ <button id="allDomOn">All</button><button id="allDomOff">None</button>
+ <div id="doms"></div>
+</div>
+<div id="cy"></div><div id="info"></div>
+<script src="/client.js"></script>
+`;
+
+// src/view/server.ts
+var HERE = dirname(new URL(import.meta.url).pathname);
+async function clientBundle() {
+  const prebuilt = join5(HERE, "client.js");
+  const { existsSync: existsSync2, readFileSync: readFileSync4 } = await import("fs");
+  if (existsSync2(prebuilt)) return readFileSync4(prebuilt, "utf8");
+  const esbuild = await import("./main-CUYP5EVX.js");
+  const r = await esbuild.build({
+    entryPoints: [join5(HERE, "client.ts")],
+    bundle: true,
+    format: "iife",
+    target: "es2022",
+    minify: true,
+    write: false,
+    logLevel: "silent"
+  });
+  return r.outputFiles?.[0]?.text ?? "";
+}
+async function serveHttp(opt) {
+  const client = await clientBundle();
+  const server = createServer((req, res) => {
+    const url = req.url ?? "/";
+    if (url === "/" || url.startsWith("/?")) {
+      res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+      res.end(shell());
+      return;
+    }
+    if (url === "/client.js") {
+      res.writeHead(200, { "content-type": "text/javascript; charset=utf-8" });
+      res.end(client);
+      return;
+    }
+    if (url === "/api/graph") {
+      const g = opt.graph();
+      res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
+      res.end(JSON.stringify(g));
+      return;
+    }
+    res.writeHead(404).end("not found");
+  });
+  await new Promise((ok2) => server.listen(opt.port, ok2));
+  return `http://localhost:${opt.port}`;
+}
+
+// src/cli.ts
+var HERE2 = dirname2(new URL(import.meta.url).pathname);
+var USAGE = `hexwright \u2014 design graph for hexagonal codebases
+
+  hexwright extract --repo <path> [options]     print graph summary
+  hexwright check   --repo <path> [options]     exit 1 on violations
+  hexwright mcp     --repo <path> [options]     serve MCP over stdio
+  hexwright serve   --repo <path> [options]     web UI (and MCP with --mcp)
+  hexwright render  --repo <path> [options]     write an SVG (and PNG) for a PR
+
+Options
+  --repo <path>        target repository (required)
+  --src <path>         source root, relative to repo   [auto: Gradle module]
+  --base <ref>         branch/commit to diff against   [none]
+  --project <name>     name shown in outputs           [repo dir name]
+  --base-package <pkg> package prefix before the domain segment [auto]
+  --profile <file>     architecture profile            [hexagonal-kotlin.yml]
+  --out <dir>          write graph.json / graph.tsv here
+  --json               print graph as JSON to stdout
+  --port <n>           web UI port                     [7800]
+  --mcp                also serve MCP over stdio (with serve)
+
+check only
+  --scope <s>          all | delta   [all]
+                       delta = fail only on violations this branch introduced;
+                       requires --base. Lets you gate a repository that already
+                       has violations without fixing them all first.
+
+render only
+  --view <v>           delta | impact | core | all | domain:<name>   [delta]
+  --layout <l>         organic | grid | hex
+                       [organic for delta\xB7domain, hex for core\xB7all]
+  --image <file>       output path; .svg, or .png to rasterize  [graph.svg]
+  --identifiers        include identifier-only references (FamilyId\xB7UserId)
+`;
+function main() {
+  const { values: v, positionals } = parseArgs({
+    allowPositionals: true,
+    options: {
+      repo: { type: "string" },
+      src: { type: "string" },
+      base: { type: "string" },
+      project: { type: "string" },
+      "base-package": { type: "string" },
+      profile: { type: "string" },
+      out: { type: "string" },
+      json: { type: "boolean", default: false },
+      port: { type: "string", default: "7800" },
+      mcp: { type: "boolean", default: false },
+      scope: { type: "string", default: "all" },
+      view: { type: "string", default: "delta" },
+      layout: { type: "string" },
+      // no default — chosen to suit the view
+      image: { type: "string" },
+      identifiers: { type: "boolean", default: false },
+      help: { type: "boolean", short: "h", default: false }
+    }
+  });
+  const cmd = positionals[0] ?? "extract";
+  if (v.help || !v.repo || !["extract", "check", "mcp", "serve", "render"].includes(cmd)) {
+    process.stdout.write(USAGE);
+    return v.help ? 0 : 1;
+  }
+  const repo = resolve(v.repo);
+  const project = v.project ?? repo.split("/").filter(Boolean).pop() ?? "project";
+  const profilePath = v.profile ?? join6(HERE2, "..", "profiles", "hexagonal-kotlin.yml");
+  const profile = loadProfile(profilePath, v["base-package"] ? { base: v["base-package"] } : {});
+  let det;
+  try {
+    det = detectSource(repo, v.src);
+  } catch (e) {
+    process.stderr.write(`${e.message}
+`);
+    return 1;
+  }
+  if (det.subprojects > 0) {
+    process.stderr.write(
+      `warning: settings.gradle declares ${det.subprojects} subproject(s). hexwright assumes a single module and analyzes only ${det.srcRel}
+`
+    );
+  }
+  const source = new GraphSource({
+    repo,
+    srcAbs: det.srcAbs,
+    srcRel: det.srcRel,
+    profile,
+    profilePath,
+    project,
+    ...v.base ? { base: v.base } : {}
+  });
+  let graph;
+  try {
+    graph = source.graph();
+  } catch (e) {
+    process.stderr.write(`${e.message}
+`);
+    return 1;
+  }
+  const d = source.delta();
+  const summary = d ? deltaSummary(d, graph) : "";
+  const violations = graph.edges.filter((e) => e.violation);
+  const deltaScope = v.scope === "delta";
+  if (deltaScope && !v.base) {
+    process.stderr.write("--scope delta needs --base <ref> to know what is new\n");
+    return 1;
+  }
+  const gated = deltaScope ? violations.filter((e) => e.newViolation) : violations;
+  if (cmd === "serve") {
+    void serveHttp({ port: Number(v.port), graph: () => source.graph() }).then((url) => {
+      process.stderr.write(
+        `hexwright \u2014 ${project} @ ${graph.ref}
+  ${graph.nodes.length} nodes \xB7 ${graph.edges.length} edges \xB7 ${violations.length} violations${v.base ? ` \xB7 delta vs ${v.base}` : ""}
+  web ${url}
+`
+      );
+      if (v.mcp) void serveStdio(() => source.query(), project);
+    });
+    return -1;
+  }
+  if (cmd === "render") {
+    const out = v.image ?? "graph.svg";
+    let sel;
+    try {
+      sel = select(graph, v.view, v.identifiers);
+    } catch (e) {
+      process.stderr.write(`${e.message}
+`);
+      return 1;
+    }
+    const layout = v.layout === "hex" || v.layout === "grid" || v.layout === "organic" ? v.layout : v.view === "core" || v.view === "all" ? "hex" : "organic";
+    const svg = renderSvg(sel.graph, {
+      layout,
+      viewLabel: sel.label,
+      showIdentifiers: v.identifiers
+    });
+    const dir = dirname2(resolve(out));
+    mkdirSync(dir, { recursive: true });
+    const svgPath = out.endsWith(".png") ? `${out.slice(0, -4)}.svg` : out;
+    writeFileSync(svgPath, svg);
+    process.stdout.write(
+      `${project} @ ${graph.ref}
+  view    ${sel.label}
+  drew    ${sel.graph.nodes.length} types \xB7 ${sel.graph.edges.length} relations \xB7 ${sel.graph.edges.filter((e) => e.violation).length} violations
+  wrote   ${svgPath}  (${Math.round(svg.length / 1024)} KB)
+`
+    );
+    if (out.endsWith(".png")) {
+      const px = toPng(svg, out);
+      process.stdout.write(
+        px ? `  wrote   ${out}  (${px})
+` : `  note    PNG skipped \u2014 install @resvg/resvg-js for rasterizing
+`
+      );
+    }
+    return 0;
+  }
+  if (cmd === "mcp") {
+    process.stderr.write(
+      `hexwright mcp \u2014 ${project} @ ${graph.ref}
+  ${graph.nodes.length} nodes \xB7 ${graph.edges.length} edges \xB7 ${violations.length} violations${v.base ? ` \xB7 delta vs ${v.base}` : ""}
+`
+    );
+    void serveStdio(() => source.query(), project);
+    return -1;
+  }
+  if (v.json) {
+    process.stdout.write(`${JSON.stringify(graph, null, 1)}
+`);
+  } else {
+    const byComp = /* @__PURE__ */ new Map();
+    for (const n of graph.nodes) byComp.set(n.component, (byComp.get(n.component) ?? 0) + 1);
+    const byRel = /* @__PURE__ */ new Map();
+    for (const e of graph.edges) byRel.set(e.rel, (byRel.get(e.rel) ?? 0) + 1);
+    process.stdout.write(`${project} @ ${graph.ref}
+`);
+    process.stdout.write(
+      `  nodes ${graph.nodes.length}  ${[...byComp].sort((a, b) => b[1] - a[1]).map(([k, n]) => `${k} ${n}`).join(" \xB7 ")}
+`
+    );
+    process.stdout.write(
+      `  edges ${graph.edges.length}  ${[...byRel].map(([k, n]) => `${k} ${n}`).join(" \xB7 ")}
+`
+    );
+    process.stdout.write(`  domains ${new Set(graph.nodes.map((n) => n.domain)).size}
+`);
+    process.stdout.write(`  source  ${det.srcRel}  (${det.how})
+`);
+    if (summary) process.stdout.write(`
+delta vs ${v.base}
+${indent(summary)}
+`);
+    const shown = cmd === "check" ? gated : violations;
+    if (shown.length) {
+      const carried = violations.length - gated.length;
+      process.stdout.write(
+        `
+violations ${shown.length}` + (deltaScope ? ` new  (${carried} pre-existing, not gated)
+` : "\n")
+      );
+      const byId = new Map(graph.nodes.map((n) => [n.id, n]));
+      for (const e of shown) {
+        const s = byId.get(e.src);
+        const d2 = byId.get(e.dst);
+        process.stdout.write(
+          `  ${s?.name} \u2192 ${d2?.domain}.${d2?.name}  ${e.violation}
+      ${s?.file}
+`
+        );
+      }
+    } else if (deltaScope) {
+      process.stdout.write(`
+violations 0 new  (${violations.length} pre-existing, not gated)
+`);
+    } else {
+      process.stdout.write("\nviolations 0\n");
+    }
+  }
+  if (v.out) {
+    mkdirSync(v.out, { recursive: true });
+    writeFileSync(join6(v.out, "graph.json"), `${JSON.stringify(graph, null, 1)}
+`);
+    writeFileSync(join6(v.out, "graph.tsv"), toTsv(graph));
+    process.stderr.write(`
+wrote ${join6(v.out, "graph.json")} \xB7 graph.tsv
+`);
+  }
+  return cmd === "check" && gated.length ? 1 : 0;
+}
+function toPng(svg, out) {
+  try {
+    const req = createRequire(import.meta.url);
+    const { Resvg } = req("@resvg/resvg-js");
+    const img = new Resvg(svg, {
+      font: { loadSystemFonts: true, defaultFontFamily: "DejaVu Sans" }
+    }).render();
+    writeFileSync(out, img.asPng());
+    return `${img.width}\xD7${img.height}`;
+  } catch {
+    return void 0;
+  }
+}
+var indent = (s) => s.split("\n").map((l) => `  ${l}`).join("\n");
+var code = main();
+if (code >= 0) process.exitCode = code;