codarch 0.1.1 → 0.1.3

package/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // apps/cli/src/commands/analyze.ts
-import fs7 from "node:fs";
+import fs6 from "node:fs";
 import path5 from "node:path";
 
 // packages/parsers/src/ts/parser.ts
@@ -39,7 +39,9 @@ var TypeScriptParser = class {
   }
   parse(source, filePath) {
     const parser = usesTsxGrammar(filePath) ? this.tsxParser : this.tsParser;
-    const root = parser.parse(source).rootNode;
+    const root = parser.parse(source, void 0, {
+      bufferSize: Math.max(64 * 1024, Buffer.byteLength(source, "utf8") + 1)
+    }).rootNode;
     return {
       metrics: measureSource(source, root),
       imports: collectImports(root)
@@ -256,6 +258,34 @@ var MAX_RESOLVE_DEPTH = 8;
 var BUILTINS = new Set(
   builtinModules.flatMap((name) => [name, `node:${name}`])
 );
+var ASSET_EXTENSIONS = [
+  ".css",
+  ".scss",
+  ".sass",
+  ".less",
+  ".svg",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".avif",
+  ".ico",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".mp4",
+  ".webm",
+  ".mp3",
+  ".wav",
+  ".pdf"
+];
+function isAssetSpecifier(specifier) {
+  const clean = specifier.split(/[?#]/, 1)[0]?.toLowerCase() ?? "";
+  return ASSET_EXTENSIONS.some((extension) => clean.endsWith(extension));
+}
 var ImportResolver = class {
   warnings = [];
   root;
@@ -815,7 +845,7 @@ function stronglyConnectedComponents(nodes, adjacency, reverse) {
 }
 function componentLevels(components, edges, componentOf) {
   const condensation = /* @__PURE__ */ new Map();
-  const indegree = new Array(components.length).fill(0);
+  const indegree = Array.from({ length: components.length }).fill(0);
   for (const edge of edges) {
     const from = componentOf.get(edge.from);
     const to = componentOf.get(edge.to);
@@ -827,7 +857,7 @@ function componentLevels(components, edges, componentOf) {
       indegree[to] = (indegree[to] ?? 0) + 1;
     }
   }
-  const levels = new Array(components.length).fill(0);
+  const levels = Array.from({ length: components.length }).fill(0);
   const queue = [];
   for (let index = 0; index < components.length; index++) {
     if (indegree[index] === 0) queue.push(index);
@@ -857,22 +887,22 @@ import path4 from "node:path";
 // packages/schema/src/errors.ts
 var CcJsonError = class extends Error {
   path;
-  constructor(message, path8) {
-    super(`${message} (en ${path8})`);
+  constructor(message, path9) {
+    super(`${message} (en ${path9})`);
     this.name = "CcJsonError";
-    this.path = path8;
+    this.path = path9;
   }
 };
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function requireRecord(value, path8) {
-  if (!isRecord2(value)) throw new CcJsonError("se esperaba un objeto", path8);
+function requireRecord(value, path9) {
+  if (!isRecord2(value)) throw new CcJsonError("se esperaba un objeto", path9);
   return value;
 }
-function requireString(value, path8, field5) {
+function requireString(value, path9, field5) {
   if (typeof value !== "string" || value.length === 0) {
-    throw new CcJsonError(`"${field5}" debe ser una cadena no vac\xEDa`, path8);
+    throw new CcJsonError(`"${field5}" debe ser una cadena no vac\xEDa`, path9);
   }
   return value;
 }
@@ -883,9 +913,9 @@ var ID_LENGTH = 16;
 function normalizeName(name) {
   return name.normalize("NFC");
 }
-function pathSegments(path8) {
+function pathSegments(path9) {
   const segments = [];
-  for (const raw of path8.replace(/\\/g, "/").split("/")) {
+  for (const raw of path9.replace(/\\/g, "/").split("/")) {
     const segment = normalizeName(raw);
     if (segment === "" || segment === ".") continue;
     if (segment === "..") {
@@ -899,18 +929,18 @@ function pathSegments(path8) {
 function canonicalPath(segments) {
   return `/${segments.map(normalizeName).join("/")}`;
 }
-function idFromCanonicalPath(path8, type = "File") {
-  const canonical = path8.startsWith("/") ? path8 : `/${path8}`;
+function idFromCanonicalPath(path9, type = "File") {
+  const canonical = path9.startsWith("/") ? path9 : `/${path9}`;
   return createHash("sha256").update(type + canonical, "utf8").digest("hex").slice(0, ID_LENGTH);
 }
 function nodeId(type, segments) {
   return idFromCanonicalPath(canonicalPath(segments), type);
 }
-function fileId(path8) {
-  return nodeId("File", pathSegments(path8));
+function fileId(path9) {
+  return nodeId("File", pathSegments(path9));
 }
-function folderId(path8) {
-  return nodeId("Folder", pathSegments(path8));
+function folderId(path9) {
+  return nodeId("Folder", pathSegments(path9));
 }
 
 // packages/schema/src/legacy.ts
@@ -966,15 +996,15 @@ function normalizeLegacyCcJson(input) {
   const metrics = {};
   const built = [];
   const ids = /* @__PURE__ */ new Map();
-  const buildNode = (value, parentPath, path8, depth) => {
+  const buildNode = (value, parentPath, path9, depth) => {
     if (depth > MAX_DEPTH) {
-      throw new CcJsonError(`profundidad m\xE1xima ${MAX_DEPTH} superada`, path8);
+      throw new CcJsonError(`profundidad m\xE1xima ${MAX_DEPTH} superada`, path9);
     }
-    const raw = requireRecord(value, path8);
-    const name = readNodeName(raw.name, `${path8}.name`);
+    const raw = requireRecord(value, path9);
+    const name = readNodeName(raw.name, `${path9}.name`);
     const type = raw.type;
     if (type !== "File" && type !== "Folder") {
-      throw new CcJsonError('"type" debe ser "File" o "Folder"', `${path8}.type`);
+      throw new CcJsonError('"type" debe ser "File" o "Folder"', `${path9}.type`);
     }
     const fullPath = [...parentPath, name];
     const id = nodeId(type, fullPath.slice(1));
@@ -982,13 +1012,13 @@ function normalizeLegacyCcJson(input) {
     if (previous !== void 0) {
       throw new CcJsonError(
         `id duplicado "${id}" para "${previous}" y "${fullPath.join("/")}"`,
-        `${path8}.name`
+        `${path9}.name`
       );
     }
     ids.set(id, fullPath.join("/"));
     built.push({ id, name, fullPath: fullPath.join("/") });
     const node = { id, name, type };
-    const attributes = readMetrics(raw.attributes, `${path8}.attributes`);
+    const attributes = readMetrics(raw.attributes, `${path9}.attributes`);
     if (attributes) metrics[id] = attributes;
     const contentHash = readOptionalString(raw.checksum) ?? readOptionalString(raw.contentHash);
     if (contentHash) node.contentHash = contentHash;
@@ -996,14 +1026,14 @@ function normalizeLegacyCcJson(input) {
     if (link) node.link = link;
     if (raw.children !== void 0) {
       if (!Array.isArray(raw.children)) {
-        throw new CcJsonError('"children" debe ser un array', `${path8}.children`);
+        throw new CcJsonError('"children" debe ser un array', `${path9}.children`);
       }
       if (type === "File" && raw.children.length > 0) {
-        throw new CcJsonError("un fichero no puede tener hijos", `${path8}.children`);
+        throw new CcJsonError("un fichero no puede tener hijos", `${path9}.children`);
       }
       if (type === "Folder" && raw.children.length > 0) {
         node.children = raw.children.map(
-          (child, index) => buildNode(child, fullPath, `${path8}.children[${index}]`, depth + 1)
+          (child, index) => buildNode(child, fullPath, `${path9}.children[${index}]`, depth + 1)
         );
       }
     }
@@ -1020,15 +1050,15 @@ function normalizeLegacyCcJson(input) {
       throw new CcJsonError('"edges" debe ser un array', `${base}.edges`);
     }
     edgesRaw.forEach((edge, index) => {
-      const path8 = `${base}.edges[${index}]`;
-      const raw = requireRecord(edge, path8);
-      const fromName = requireString(raw.fromNodeName, `${path8}.fromNodeName`, "fromNodeName");
-      const toName = requireString(raw.toNodeName, `${path8}.toNodeName`, "toNodeName");
+      const path9 = `${base}.edges[${index}]`;
+      const raw = requireRecord(edge, path9);
+      const fromName = requireString(raw.fromNodeName, `${path9}.fromNodeName`, "fromNodeName");
+      const toName = requireString(raw.toNodeName, `${path9}.toNodeName`, "toNodeName");
       const normalized = {
-        fromId: resolveEndpoint(fromName, pathIndex, stripNames, `${path8}.fromNodeName`),
-        toId: resolveEndpoint(toName, pathIndex, stripNames, `${path8}.toNodeName`)
+        fromId: resolveEndpoint(fromName, pathIndex, stripNames, `${path9}.fromNodeName`),
+        toId: resolveEndpoint(toName, pathIndex, stripNames, `${path9}.toNodeName`)
       };
-      const attributes = readMetrics(raw.attributes, `${path8}.attributes`);
+      const attributes = readMetrics(raw.attributes, `${path9}.attributes`);
       if (attributes) normalized.attributes = attributes;
       if (typeof raw.isCyclic === "boolean") normalized.isCyclic = raw.isCyclic;
       if (typeof raw.isPointingUpwards === "boolean") {
@@ -1113,10 +1143,10 @@ function buildPathIndex(built, multipleRoots) {
   }
   return index;
 }
-function resolveEndpoint(endpoint, index, stripNames, path8) {
+function resolveEndpoint(endpoint, index, stripNames, path9) {
   const segments = canonicalSegments(endpoint);
   if (segments.length === 0) {
-    throw new CcJsonError("extremo de arista vac\xEDo", path8);
+    throw new CcJsonError("extremo de arista vac\xEDo", path9);
   }
   const candidates = [segments.join("/")];
   if (segments.length > 1 && stripNames.has(segments[0])) {
@@ -1128,7 +1158,7 @@ function resolveEndpoint(endpoint, index, stripNames, path8) {
   }
   const bare = index.get(segments[segments.length - 1]);
   if (bare) return bare;
-  throw new CcJsonError(`no se pudo resolver el nodo "${endpoint}"`, path8);
+  throw new CcJsonError(`no se pudo resolver el nodo "${endpoint}"`, path9);
 }
 function canonicalSegments(value) {
   const result = [];
@@ -1143,85 +1173,85 @@ function canonicalSegments(value) {
   }
   return result;
 }
-function readNodeName(value, path8) {
-  const name = normalizeName(requireString(value, path8, "name"));
+function readNodeName(value, path9) {
+  const name = normalizeName(requireString(value, path9, "name"));
   if (name === "." || name === "..") {
-    throw new CcJsonError('el nombre no puede ser "." ni ".."', path8);
+    throw new CcJsonError('el nombre no puede ser "." ni ".."', path9);
   }
   if (name.includes("/")) {
-    throw new CcJsonError('el nombre no puede contener "/"', path8);
+    throw new CcJsonError('el nombre no puede contener "/"', path9);
   }
   return name;
 }
 function readOptionalString(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-function readMetrics(value, path8) {
+function readMetrics(value, path9) {
   if (value === void 0) return void 0;
-  const raw = requireRecord(value, path8);
+  const raw = requireRecord(value, path9);
   const out = {};
   for (const [metric, metricValue] of Object.entries(raw)) {
     if (typeof metricValue !== "number" || !Number.isFinite(metricValue)) {
       throw new CcJsonError(
         `la m\xE9trica "${metric}" debe ser un n\xFAmero finito`,
-        `${path8}["${metric}"]`
+        `${path9}["${metric}"]`
       );
     }
     out[metric] = metricValue;
   }
   return Object.keys(out).length > 0 ? out : void 0;
 }
-function readAttributeTypes(value, path8) {
+function readAttributeTypes(value, path9) {
   if (value === void 0) return {};
-  const raw = requireRecord(value, path8);
+  const raw = requireRecord(value, path9);
   if ("nodes" in raw || "edges" in raw) {
-    const nodes2 = raw.nodes === void 0 ? void 0 : readTypeMap(raw.nodes, `${path8}.nodes`);
-    const edges = raw.edges === void 0 ? void 0 : readTypeMap(raw.edges, `${path8}.edges`);
+    const nodes2 = raw.nodes === void 0 ? void 0 : readTypeMap(raw.nodes, `${path9}.nodes`);
+    const edges = raw.edges === void 0 ? void 0 : readTypeMap(raw.edges, `${path9}.edges`);
     return {
       ...nodes2 && Object.keys(nodes2).length > 0 ? { nodes: nodes2 } : {},
       ...edges && Object.keys(edges).length > 0 ? { edges } : {}
     };
   }
-  const nodes = readTypeMap(raw, path8);
+  const nodes = readTypeMap(raw, path9);
   return Object.keys(nodes).length > 0 ? { nodes } : {};
 }
-function readTypeMap(value, path8) {
-  const raw = requireRecord(value, path8);
+function readTypeMap(value, path9) {
+  const raw = requireRecord(value, path9);
   const out = {};
   for (const [metric, type] of Object.entries(raw)) {
     if (type !== "absolute" && type !== "relative") {
       throw new CcJsonError(
         `el tipo de "${metric}" debe ser "absolute" o "relative"`,
-        `${path8}["${metric}"]`
+        `${path9}["${metric}"]`
       );
     }
     out[metric] = type;
   }
   return out;
 }
-function readDescriptors(value, path8) {
+function readDescriptors(value, path9) {
   if (value === void 0) return {};
-  const raw = requireRecord(value, path8);
+  const raw = requireRecord(value, path9);
   if ("nodes" in raw || "edges" in raw) {
-    const nodes = raw.nodes === void 0 ? void 0 : readDescriptorMap(raw.nodes, `${path8}.nodes`);
-    const edges = raw.edges === void 0 ? void 0 : readDescriptorMap(raw.edges, `${path8}.edges`);
+    const nodes = raw.nodes === void 0 ? void 0 : readDescriptorMap(raw.nodes, `${path9}.nodes`);
+    const edges = raw.edges === void 0 ? void 0 : readDescriptorMap(raw.edges, `${path9}.edges`);
     return {
       ...nodes && Object.keys(nodes).length > 0 ? { nodes } : {},
       ...edges && Object.keys(edges).length > 0 ? { edges } : {}
     };
   }
-  const flat = readDescriptorMap(raw, path8);
+  const flat = readDescriptorMap(raw, path9);
   return Object.keys(flat).length > 0 ? { flat } : {};
 }
-function readDescriptorMap(value, path8) {
-  const raw = requireRecord(value, path8);
+function readDescriptorMap(value, path9) {
+  const raw = requireRecord(value, path9);
   const out = {};
   for (const [metric, descriptor] of Object.entries(raw)) {
-    const record = requireRecord(descriptor, `${path8}["${metric}"]`);
+    const record = requireRecord(descriptor, `${path9}["${metric}"]`);
     if (record.direction !== void 0 && typeof record.direction !== "number") {
       throw new CcJsonError(
         `"direction" de "${metric}" debe ser un n\xFAmero`,
-        `${path8}["${metric}"].direction`
+        `${path9}["${metric}"].direction`
       );
     }
     out[metric] = record;
@@ -1229,11 +1259,10 @@ function readDescriptorMap(value, path8) {
   return out;
 }
 
-// packages/schema/src/parse.ts
+// packages/schema/src/parse2.ts
 var MAX_DEPTH2 = 512;
-function parseCcJson(input) {
+function parseCcJson2(input) {
   if (!isRecord2(input)) throw new CcJsonError("se esperaba un objeto", "$");
-  if (isLegacyCcJson(input)) return normalizeLegacyCcJson(input);
   const metaRaw = requireRecord(input.meta, "$.meta");
   const apiVersion = requireString(metaRaw.apiVersion, "$.meta.apiVersion", "apiVersion");
   if (!apiVersion.startsWith("2.")) {
@@ -1247,26 +1276,26 @@ function parseCcJson(input) {
   const roots = Array.isArray(filesRaw) ? filesRaw : [filesRaw];
   if (roots.length === 0) throw new CcJsonError("el \xE1rbol est\xE1 vac\xEDo", "$.files");
   const ids = /* @__PURE__ */ new Set();
-  const validateNode = (value, path8, depth) => {
-    if (depth > MAX_DEPTH2) throw new CcJsonError(`profundidad m\xE1xima ${MAX_DEPTH2} superada`, path8);
-    const raw = requireRecord(value, path8);
-    const id = requireString(raw.id, `${path8}.id`, "id");
-    if (ids.has(id)) throw new CcJsonError(`id duplicado "${id}"`, `${path8}.id`);
+  const validateNode = (value, path9, depth) => {
+    if (depth > MAX_DEPTH2) throw new CcJsonError(`profundidad m\xE1xima ${MAX_DEPTH2} superada`, path9);
+    const raw = requireRecord(value, path9);
+    const id = requireString(raw.id, `${path9}.id`, "id");
+    if (ids.has(id)) throw new CcJsonError(`id duplicado "${id}"`, `${path9}.id`);
     ids.add(id);
-    const name = requireString(raw.name, `${path8}.name`, "name");
+    const name = requireString(raw.name, `${path9}.name`, "name");
     const type = raw.type;
     if (type !== "File" && type !== "Folder") {
-      throw new CcJsonError('"type" debe ser "File" o "Folder"', `${path8}.type`);
+      throw new CcJsonError('"type" debe ser "File" o "Folder"', `${path9}.type`);
     }
     const node = { id, name, type };
     if (typeof raw.contentHash === "string") node.contentHash = raw.contentHash;
     if (typeof raw.link === "string") node.link = raw.link;
     if (raw.children !== void 0) {
       if (!Array.isArray(raw.children)) {
-        throw new CcJsonError('"children" debe ser un array', `${path8}.children`);
+        throw new CcJsonError('"children" debe ser un array', `${path9}.children`);
       }
       node.children = raw.children.map(
-        (child, index) => validateNode(child, `${path8}.children[${index}]`, depth + 1)
+        (child, index) => validateNode(child, `${path9}.children[${index}]`, depth + 1)
       );
     }
     return node;
@@ -1297,10 +1326,10 @@ function parseCcJson(input) {
           throw new CcJsonError('"edges" debe ser un array', "$.lenses.dependency.edges");
         }
         dependency.edges.forEach((edge, index) => {
-          const path8 = `$.lenses.dependency.edges[${index}]`;
-          const raw = requireRecord(edge, path8);
-          requireString(raw.fromId, `${path8}.fromId`, "fromId");
-          requireString(raw.toId, `${path8}.toId`, "toId");
+          const path9 = `$.lenses.dependency.edges[${index}]`;
+          const raw = requireRecord(edge, path9);
+          requireString(raw.fromId, `${path9}.fromId`, "fromId");
+          requireString(raw.toId, `${path9}.toId`, "toId");
         });
       }
     }
@@ -1313,6 +1342,12 @@ function parseCcJson(input) {
   };
 }
 
+// packages/schema/src/parse.ts
+function parseCcJson(input) {
+  if (isLegacyCcJson(input)) return normalizeLegacyCcJson(input);
+  return parseCcJson2(input);
+}
+
 // packages/schema/src/tree.ts
 function walkTree(roots, visit) {
   const stack = roots.map((node) => ({ node, path: node.name, depth: 0 })).reverse();
@@ -1383,9 +1418,9 @@ function topByMetric(cc, metric, limit = 10) {
   const ranked = [];
   for (const [id, values] of Object.entries(attributes)) {
     const value = values[metric];
-    const path8 = paths.get(id);
-    if (value === void 0 || path8 === void 0) continue;
-    ranked.push({ id, path: path8, value });
+    const path9 = paths.get(id);
+    if (value === void 0 || path9 === void 0) continue;
+    ranked.push({ id, path: path9, value });
   }
   ranked.sort((a, b) => b.value - a.value || a.path.localeCompare(b.path));
   return ranked.slice(0, limit);
@@ -1954,8 +1989,8 @@ function buildSnapshot(input) {
     isCyclic: edge.isCyclic
   }));
   const dependencyNodes = {};
-  for (const [path8, metrics] of input.graph.metrics) {
-    dependencyNodes[fileId(path8)] = { level: metrics.dependencyLevel };
+  for (const [path9, metrics] of input.graph.metrics) {
+    dependencyNodes[fileId(path9)] = { level: metrics.dependencyLevel };
   }
   const migrationLens = input.migration ? migrationLensFrom(input.migration) : void 0;
   const lenses = {
@@ -2219,6 +2254,7 @@ function analyzeRepository(rootInput, options = {}) {
     let fileUnresolvedImports = 0;
     for (const imported of parsed.imports) {
       if (imported.typeOnly) fileTypeOnlyImports++;
+      if (isAssetSpecifier(imported.specifier)) continue;
       const result = resolver.resolve(file.absolutePath, imported.specifier);
       if (result.kind === "internal") {
         const targetLanguage = languageForPath(result.file.relativePath);
@@ -2369,1900 +2405,1902 @@ function readProjectName(root) {
   return path4.basename(root) || "Proyecto";
 }
 
-// packages/metrics/src/config.ts
-import fs5 from "node:fs";
-import { parse as parseYaml } from "yaml";
-var ConfigError = class extends Error {
+// packages/metrics/src/risk.ts
+var COMPLEXITY_METRIC_CANDIDATES = [
+  "maxComplexity",
+  "max_complexity_per_function",
+  "complexity",
+  "logic_complexity",
+  "sonar_cognitive_complexity"
+];
+var CHURN_METRIC_CANDIDATES = [
+  "number_of_commits",
+  "number_of_authors",
+  "number_of_renames"
+];
+var RISK_WEIGHTS = {
+  complexity: 0.5,
+  churn: 0.32,
+  size: 0.18
+};
+var RISK_GAMMA = 1.7;
+function riskScores(files) {
+  const complexityP95 = percentile(
+    files.map((file) => file.complexity).filter((value) => value > 0),
+    0.95
+  );
+  const churnP95 = percentile(
+    files.map((file) => file.churn).filter((value) => value > 0),
+    0.95
+  );
+  const sizeP95 = percentile(
+    files.map((file) => file.size).filter((value) => value > 0),
+    0.95
+  );
+  const complexityWeight = complexityP95 > 0 ? RISK_WEIGHTS.complexity : 0;
+  const churnWeight = churnP95 > 0 ? RISK_WEIGHTS.churn : 0;
+  const sizeWeight = sizeP95 > 0 ? RISK_WEIGHTS.size : 0;
+  const totalWeight = complexityWeight + churnWeight + sizeWeight;
+  if (totalWeight === 0) return files.map(() => 0);
+  return files.map((file) => {
+    const raw = (complexityWeight * norm(file.complexity, complexityP95) + churnWeight * norm(file.churn, churnP95) + sizeWeight * norm(file.size, sizeP95)) / totalWeight;
+    return Math.pow(clamp01(raw), RISK_GAMMA);
+  });
+}
+function firstMetric(available, candidates) {
+  const set = available instanceof Set ? available : new Set(available);
+  for (const candidate of candidates) {
+    if (set.has(candidate)) return candidate;
+  }
+  return null;
+}
+function norm(value, p95) {
+  return p95 > 0 ? clamp01(value / p95) : 0;
+}
+function percentile(values, p) {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const index = Math.min(
+    sorted.length - 1,
+    Math.max(0, Math.floor((sorted.length - 1) * p))
+  );
+  return sorted[index] ?? 0;
+}
+function clamp01(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(1, value));
+}
+
+// packages/render/src/model.ts
+var RenderError = class extends Error {
   constructor(message) {
     super(message);
-    this.name = "ConfigError";
+    this.name = "RenderError";
   }
 };
-var SEVERITIES = /* @__PURE__ */ new Set(["info", "warn", "error"]);
-function parseRuleConfig(input) {
-  const root = asObject(input, "config");
-  if (root.version !== 1) {
-    throw new ConfigError("config.version debe ser 1");
-  }
-  const layers = parseLayers(root.layers);
-  const layerNames = new Set(layers.map((layer) => layer.name));
-  const rules = parseRules(root.rules, layerNames);
-  return { version: 1, layers, rules };
+var PALETTE = [
+  "#b9c4d0",
+  "#c9b8a8",
+  "#a9bfae",
+  "#c4b6c9",
+  "#c9c2a6",
+  "#d5d2ca",
+  "#c2c8d0",
+  "#d6c6bd",
+  "#b7c6c2",
+  "#cbbfb0",
+  "#bcc3b9",
+  "#cfc6c9"
+];
+var CURATED_METRICS = [
+  "rloc",
+  "maxComplexity",
+  "max_complexity_per_function",
+  "complexity",
+  "functions",
+  "number_of_functions",
+  "maxFunctionLength",
+  "loc",
+  "imports",
+  "externalImports",
+  "builtinImports",
+  "typeOnlyImports",
+  "unresolvedImports",
+  "fanIn",
+  "fanOut",
+  "inCycle",
+  "cycleSize",
+  "dependencyLevel",
+  "number_of_commits",
+  "number_of_authors",
+  "incoming_dependencies",
+  "outgoing_dependencies"
+];
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function loadRuleConfig(file) {
-  let text;
-  try {
-    text = fs5.readFileSync(file, "utf8");
-  } catch (error) {
-    throw new ConfigError(
-      `no se pudo leer ${file}: ${error.message}`
-    );
+function valueOf(values, key) {
+  if (!key || !values) return void 0;
+  const value = values[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function percentile2(values, p) {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const index = Math.min(
+    sorted.length - 1,
+    Math.max(0, Math.floor((sorted.length - 1) * p))
+  );
+  return sorted[index] ?? 0;
+}
+function hashString(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index++) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
   }
-  let value;
-  try {
-    value = parseYaml(text);
-  } catch (error) {
-    throw new ConfigError(
-      `YAML inv\xE1lido en ${file}: ${error.message}`
-    );
+  return hash >>> 0;
+}
+function sectionForPath(path9) {
+  const folders = path9.split("/").filter(Boolean).slice(0, -1);
+  if (folders.length === 0) return "(ra\xEDz)";
+  if (folders.length === 1) return folders[0];
+  return folders.slice(0, 3).join("/");
+}
+function asEdges(value) {
+  if (!Array.isArray(value)) return [];
+  const edges = [];
+  for (const item of value) {
+    if (!isRecord3(item)) continue;
+    if (typeof item.fromId !== "string" || typeof item.toId !== "string") continue;
+    edges.push({
+      fromId: item.fromId,
+      toId: item.toId,
+      ...item.isCyclic === true ? { isCyclic: true } : {}
+    });
   }
-  try {
-    return parseRuleConfig(value);
-  } catch (error) {
-    if (error instanceof ConfigError) {
-      throw new ConfigError(`${file}: ${error.message}`);
-    }
-    throw error;
+  return edges;
+}
+function metricTitle(attributes, key) {
+  const descriptor = attributes?.[key];
+  if (isRecord3(descriptor) && typeof descriptor.title === "string" && descriptor.title) {
+    return descriptor.title;
   }
+  return key;
 }
-function parseLayers(value) {
-  if (value === void 0) return [];
-  if (!Array.isArray(value)) {
-    throw new ConfigError("config.layers debe ser una lista");
+function metricDirection(attributes, key) {
+  const descriptor = attributes?.[key];
+  if (isRecord3(descriptor) && typeof descriptor.direction === "number") {
+    return descriptor.direction;
   }
-  const layers = [];
-  const names = /* @__PURE__ */ new Set();
-  value.forEach((raw, index) => {
-    const layer = asObject(raw, `config.layers[${index}]`);
-    const name = asString(layer.name, `config.layers[${index}].name`);
-    if (names.has(name)) {
-      throw new ConfigError(`capa duplicada: ${name}`);
-    }
-    names.add(name);
-    if (layer.patterns !== void 0 && layer.paths !== void 0) {
-      throw new ConfigError(
-        `config.layers[${index}] no puede tener patterns y paths a la vez`
-      );
-    }
-    const rawPatterns = layer.patterns ?? layer.paths;
-    if (!Array.isArray(rawPatterns) || rawPatterns.length === 0) {
-      throw new ConfigError(
-        `config.layers[${index}].patterns debe ser una lista no vac\xEDa`
+  return 0;
+}
+function buildRenderModel(cc, options = {}) {
+  const stats = getStats(cc);
+  const coverage = new Set(stats.metricCoverage.map((entry) => entry.name));
+  const attributes = cc.lenses?.metrics?.attributes ?? {};
+  const descriptors = cc.lenses?.metrics?.attributeDescriptors;
+  let areaMetric;
+  if (options.areaMetric) {
+    if (!coverage.has(options.areaMetric)) {
+      throw new RenderError(
+        `la m\xE9trica de \xE1rea "${options.areaMetric}" no existe en este cc.json`
       );
     }
-    const patterns = rawPatterns.map((rawPattern, patternIndex) => {
-      const pattern = asString(
-        rawPattern,
-        `config.layers[${index}].patterns[${patternIndex}]`
-      ).replaceAll("\\", "/").replace(/^\.\//, "");
-      if (pattern.startsWith("/") || /^[A-Za-z]:\//.test(pattern)) {
-        throw new ConfigError(
-          `el patr\xF3n "${pattern}" debe ser relativo al root del proyecto`
-        );
-      }
-      return pattern;
-    });
-    layers.push({ name, patterns });
-  });
-  return layers;
-}
-function parseRules(value, layerNames) {
-  if (value === void 0) return [];
-  if (!Array.isArray(value)) {
-    throw new ConfigError("config.rules debe ser una lista");
+    areaMetric = options.areaMetric;
+  } else {
+    areaMetric = defaultMetric(stats) ?? null;
   }
-  const rules = [];
-  const names = /* @__PURE__ */ new Set();
-  value.forEach((raw, index) => {
-    const rule = asObject(raw, `config.rules[${index}]`);
-    const name = asString(rule.name, `config.rules[${index}].name`);
-    if (names.has(name)) {
-      throw new ConfigError(`regla duplicada: ${name}`);
-    }
-    names.add(name);
-    const type = asString(rule.type, `config.rules[${index}].type`);
-    const severity = parseSeverity(
-      rule.severity,
-      `config.rules[${index}].severity`
-    );
-    const message = rule.message === void 0 ? void 0 : asString(rule.message, `config.rules[${index}].message`);
-    if (type === "forbidden") {
-      const from = asString(rule.from, `config.rules[${index}].from`);
-      const to = asString(rule.to, `config.rules[${index}].to`);
-      if (!layerNames.has(from)) {
-        throw new ConfigError(
-          `config.rules[${index}].from apunta a una capa inexistente: ${from}`
-        );
-      }
-      if (!layerNames.has(to)) {
-        throw new ConfigError(
-          `config.rules[${index}].to apunta a una capa inexistente: ${to}`
-        );
-      }
-      rules.push({ type, name, from, to, severity, message });
-      return;
-    }
-    if (type === "threshold") {
-      const metric = asString(
-        rule.metric,
-        `config.rules[${index}].metric`
+  const complexityKey = firstMetric(coverage, COMPLEXITY_METRIC_CANDIDATES);
+  const churnKey = firstMetric(coverage, CHURN_METRIC_CANDIDATES);
+  const metricKeys = [];
+  const addMetric = (key) => {
+    if (key && coverage.has(key) && !metricKeys.includes(key)) metricKeys.push(key);
+  };
+  for (const key of CURATED_METRICS) addMetric(key);
+  addMetric(areaMetric);
+  addMetric(complexityKey);
+  addMetric(churnKey);
+  if (options.color && options.color !== "risk" && options.color !== "structure") {
+    addMetric(options.color);
+  }
+  const singleRoot = cc.files.length === 1 && cc.files[0]?.type === "Folder" ? cc.files[0] : null;
+  const prefix = singleRoot ? `${singleRoot.name}/` : "";
+  const rootName = singleRoot?.name ?? "";
+  const warnings = [];
+  const files = [];
+  const fileIndexById = /* @__PURE__ */ new Map();
+  walkFiles(cc.files, (entry) => {
+    const fullPath = entry.path;
+    const path9 = prefix && fullPath.startsWith(prefix) ? fullPath.slice(prefix.length) : fullPath;
+    const values = attributes[entry.node.id];
+    const rawArea = valueOf(values, areaMetric);
+    const index = files.length;
+    fileIndexById.set(entry.node.id, index);
+    files.push({
+      index,
+      nodeId: entry.node.id,
+      path: path9,
+      name: entry.node.name,
+      section: -1,
+      area: Math.max(1, rawArea ?? 0),
+      actualArea: rawArea ?? 0,
+      risk: 0,
+      complexity: valueOf(values, complexityKey) ?? 0,
+      churn: valueOf(values, churnKey) ?? 0,
+      values: []
+    });
+  });
+  if (areaMetric && files.length > 0) {
+    const missing = files.filter((file) => file.actualArea === 0).length;
+    if (missing > 0) {
+      warnings.push(
+        `${missing} ficheros sin "${areaMetric}"; se dibujan con \xE1rea m\xEDnima para no desaparecer`
       );
-      const min = optionalNumber(rule.min, `config.rules[${index}].min`);
-      const max = optionalNumber(rule.max, `config.rules[${index}].max`);
-      if (min === void 0 && max === void 0) {
-        throw new ConfigError(
-          `config.rules[${index}] necesita min o max`
-        );
-      }
-      if (min !== void 0 && max !== void 0 && min > max) {
-        throw new ConfigError(
-          `config.rules[${index}]: min no puede ser mayor que max`
-        );
-      }
-      rules.push({ type, name, metric, min, max, severity, message });
-      return;
     }
-    if (type === "cycles") {
-      rules.push({ type, name, severity, message });
-      return;
+    if (!options.areaMetric && areaMetric !== "rloc") {
+      warnings.push(`"rloc" no est\xE1 presente; se usa "${areaMetric}" como \xE1rea`);
     }
-    throw new ConfigError(
-      `config.rules[${index}].type desconocido: ${type}`
-    );
-  });
-  return rules;
-}
-function parseSeverity(value, path8) {
-  if (value === void 0) return "error";
-  if (typeof value !== "string" || !SEVERITIES.has(value)) {
-    throw new ConfigError(`${path8} debe ser info, warn o error`);
-  }
-  return value;
-}
-function optionalNumber(value, path8) {
-  if (value === void 0) return void 0;
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw new ConfigError(`${path8} debe ser un n\xFAmero`);
-  }
-  return value;
-}
-function asObject(value, path8) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new ConfigError(`${path8} debe ser un objeto`);
   }
-  return value;
-}
-function asString(value, path8) {
-  if (typeof value !== "string" || value.trim() === "") {
-    throw new ConfigError(`${path8} debe ser un texto no vac\xEDo`);
-  }
-  return value.trim();
-}
-
-// packages/metrics/src/rules.ts
-import { minimatch } from "minimatch";
-function emptyRuleReport() {
-  return {
-    configured: false,
-    summary: {
-      layers: 0,
-      rules: 0,
-      introduced: 0,
-      existing: 0,
-      resolved: 0,
-      introducedErrors: 0,
-      introducedWarnings: 0
-    },
-    violations: { introduced: [], existing: [], resolved: [] }
-  };
-}
-function evaluateRules(base, head, config) {
-  const baseViolations = evaluateInput(base, config);
-  const headViolations = evaluateInput(head, config);
-  const baseByKey = new Map(
-    baseViolations.map((violation) => [violation.key, violation])
-  );
-  const headByKey = new Map(
-    headViolations.map((violation) => [violation.key, violation])
+  const risks = riskScores(
+    files.map((file) => ({
+      complexity: file.complexity,
+      churn: file.churn,
+      size: file.actualArea
+    }))
   );
-  const introduced = [];
-  const existing = [];
-  const resolved = [];
-  for (const [key, violation] of headByKey) {
-    if (baseByKey.has(key)) existing.push(violation);
-    else introduced.push(violation);
+  for (const [index, file] of files.entries()) {
+    file.risk = risks[index] ?? 0;
   }
-  for (const [key, violation] of baseByKey) {
-    if (!headByKey.has(key)) resolved.push(violation);
+  const sectionAccumulator = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const key = sectionForPath(file.path);
+    const current = sectionAccumulator.get(key) ?? { files: 0, area: 0 };
+    current.files++;
+    current.area += file.actualArea;
+    sectionAccumulator.set(key, current);
   }
-  introduced.sort(compareViolations);
-  existing.sort(compareViolations);
-  resolved.sort(compareViolations);
-  return {
-    configured: true,
-    summary: {
-      layers: config.layers.length,
-      rules: config.rules.length,
-      introduced: introduced.length,
-      existing: existing.length,
-      resolved: resolved.length,
-      introducedErrors: introduced.filter(
-        (violation) => violation.severity === "error"
-      ).length,
-      introducedWarnings: introduced.filter(
-        (violation) => violation.severity === "warn"
-      ).length
-    },
-    violations: { introduced, existing, resolved }
-  };
-}
-function evaluateInput(input, config) {
-  const layers = layerIndex(input.files, config.layers);
-  const violations = [];
-  for (const rule of config.rules) {
-    if (rule.type === "forbidden") {
-      evaluateForbidden(rule, input, layers, violations);
-    } else if (rule.type === "threshold") {
-      evaluateThreshold(rule, input, violations);
-    } else {
-      evaluateCycles(rule, input.cycles, violations);
-    }
+  const sections = [...sectionAccumulator.entries()].map(([key, value]) => ({
+    key,
+    label: key,
+    files: value.files,
+    area: value.area,
+    color: PALETTE[hashString(key) % PALETTE.length]
+  })).sort((a, b) => b.area - a.area || a.key.localeCompare(b.key));
+  const sectionIndex = new Map(sections.map((section, index) => [section.key, index]));
+  for (const file of files) {
+    file.section = sectionIndex.get(sectionForPath(file.path)) ?? 0;
   }
-  const byKey = /* @__PURE__ */ new Map();
-  for (const violation of violations) byKey.set(violation.key, violation);
-  return [...byKey.values()].sort(compareViolations);
-}
-function layerIndex(files, layers) {
-  const index = /* @__PURE__ */ new Map();
+  const metrics = metricKeys.map((key) => {
+    const present = files.map((file) => valueOf(attributes[file.nodeId], key)).filter((value) => value !== void 0);
+    const min = present.length > 0 ? Math.min(...present) : 0;
+    const actualMax = present.length > 0 ? Math.max(...present) : 0;
+    const p95 = percentile2(present, 0.95);
+    const skewed = min >= 0 && p95 > 0 && actualMax > p95 * 4;
+    const max = skewed ? actualMax : p95 > 0 ? p95 : actualMax;
+    return {
+      key,
+      title: metricTitle(descriptors, key),
+      direction: metricDirection(descriptors, key),
+      min,
+      max,
+      actualMax,
+      p95,
+      mode: skewed ? "log" : "linear",
+      coverage: present.length
+    };
+  });
   for (const file of files) {
-    for (const layer of layers) {
-      if (layer.patterns.some(
-        (pattern) => minimatch(file.path, pattern, { dot: true })
-      )) {
-        index.set(file.id, layer.name);
-        break;
-      }
-    }
+    const values = attributes[file.nodeId];
+    file.values = metrics.map((metric) => valueOf(values, metric.key) ?? null);
   }
-  return index;
-}
-function evaluateForbidden(rule, input, layers, violations) {
-  for (const edge of input.edges) {
-    if (layers.get(edge.fromId) !== rule.from) continue;
-    if (layers.get(edge.toId) !== rule.to) continue;
-    violations.push({
-      key: `forbidden:${rule.name}:${edge.fromId}->${edge.toId}`,
-      rule: rule.name,
-      type: "forbidden",
-      severity: rule.severity,
-      message: rule.message ?? `${edge.from} no puede depender de ${edge.to}`,
-      files: [edge.from, edge.to],
-      edge: {
-        fromId: edge.fromId,
-        toId: edge.toId,
-        from: edge.from,
-        to: edge.to
+  const roots = buildRoots(cc, singleRoot, fileIndexById, files);
+  const folderCount = countFolders(roots);
+  const dependency = cc.lenses?.dependency;
+  const leafEdges = asEdges(dependency?.leafEdges);
+  const rawEdges = leafEdges.length > 0 ? leafEdges : asEdges(dependency?.edges);
+  const edgeSet = /* @__PURE__ */ new Set();
+  const edges = [];
+  const n = files.length;
+  for (const edge of rawEdges) {
+    const from = fileIndexById.get(edge.fromId);
+    const to = fileIndexById.get(edge.toId);
+    if (from === void 0 || to === void 0 || from === to) continue;
+    const key = from * n + to;
+    if (edgeSet.has(key)) continue;
+    edgeSet.add(key);
+    edges.push({ from, to });
+    if (edges.length >= 2e4) {
+      warnings.push("se han limitado las dependencias a 20.000 aristas");
+      break;
+    }
+  }
+  edges.sort((a, b) => a.from - b.from || a.to - b.to);
+  const flaggedEdges = /* @__PURE__ */ new Set();
+  for (const edge of rawEdges) {
+    if (edge.isCyclic !== true) continue;
+    const from = fileIndexById.get(edge.fromId);
+    const to = fileIndexById.get(edge.toId);
+    if (from === void 0 || to === void 0) continue;
+    flaggedEdges.add(from * n + to);
+  }
+  const cycleSet = /* @__PURE__ */ new Set();
+  const cycles = [];
+  for (const edge of edges) {
+    const key = edge.from * n + edge.to;
+    const backward = edgeSet.has(edge.to * n + edge.from);
+    if (backward || flaggedEdges.has(key)) {
+      if (!cycleSet.has(key)) {
+        cycleSet.add(key);
+        cycles.push(edge);
       }
-    });
+    }
+  }
+  cycles.sort((a, b) => a.from - b.from || a.to - b.to);
+  if (rawEdges.length === 0) {
+    warnings.push("este cc.json no trae una lente de dependencias utilizable");
+  }
+  const totalArea = files.reduce((sum, file) => sum + file.actualArea, 0);
+  const hotspotCount = files.filter((file) => file.risk >= 0.66).length;
+  let initialLens = "risk";
+  let initialMetric = null;
+  if (options.color === "structure") {
+    initialLens = "structure";
+  } else if (options.color && options.color !== "risk") {
+    if (!coverage.has(options.color)) {
+      throw new RenderError(`la m\xE9trica de color "${options.color}" no existe en este cc.json`);
+    }
+    initialLens = "metric";
+    initialMetric = options.color;
   }
+  const defaultSelection = pickDefaultSelection(files, initialLens, initialMetric, metrics);
+  const project = cc.meta.projectName || options.title || "Proyecto sin nombre";
+  return {
+    meta: {
+      project,
+      title: options.title || project,
+      commit: cc.meta.commitHash || "",
+      checksum: cc.meta.checksum || "",
+      apiVersion: cc.meta.apiVersion,
+      rootName
+    },
+    files,
+    sections,
+    metrics,
+    edges,
+    cycles,
+    roots,
+    areaMetric,
+    areaTitle: areaMetric ? metricTitle(descriptors, areaMetric) : "\xC1rea",
+    totalArea,
+    fileCount: files.length,
+    folderCount,
+    hotspotCount,
+    defaultSelection,
+    initialLens,
+    initialMetric,
+    warnings
+  };
 }
-function evaluateThreshold(rule, input, violations) {
-  for (const file of input.files) {
-    const value = file.metrics[rule.metric];
-    if (typeof value !== "number" || !Number.isFinite(value)) continue;
-    const tooHigh = rule.max !== void 0 && value > rule.max;
-    const tooLow = rule.min !== void 0 && value < rule.min;
-    if (!tooHigh && !tooLow) continue;
-    const limit = tooHigh && rule.max !== void 0 ? `m\xE1ximo ${rule.max}` : `m\xEDnimo ${rule.min}`;
-    violations.push({
-      key: `threshold:${rule.name}:${file.id}`,
-      rule: rule.name,
-      type: "threshold",
-      severity: rule.severity,
-      message: rule.message ?? `${file.path}: ${rule.metric} = ${value} (${limit})`,
-      files: [file.path],
-      metric: {
-        name: rule.metric,
-        value,
-        ...rule.min !== void 0 ? { min: rule.min } : {},
-        ...rule.max !== void 0 ? { max: rule.max } : {}
-      }
-    });
+function buildRoots(cc, singleRoot, fileIndexById, files) {
+  const build = (node, path9) => {
+    if (node.type === "File") {
+      const index = fileIndexById.get(node.id);
+      const file = index === void 0 ? void 0 : files[index];
+      return {
+        kind: "file",
+        key: `f:${index ?? -1}`,
+        name: node.name,
+        path: path9,
+        value: file?.area ?? 1,
+        fileCount: 1,
+        section: file?.section ?? 0,
+        fileIndex: index
+      };
+    }
+    const children = (node.children ?? []).map(
+      (child) => build(child, path9 ? `${path9}/${child.name}` : child.name)
+    );
+    const folder = {
+      kind: "folder",
+      key: `d:${path9}`,
+      name: node.name,
+      path: path9,
+      value: children.reduce((sum, child) => sum + child.value, 0) || 1,
+      fileCount: children.reduce((sum, child) => sum + child.fileCount, 0),
+      section: -1,
+      children
+    };
+    while (folder.children?.length === 1 && folder.children[0]?.kind === "folder") {
+      const only = folder.children[0];
+      folder.name = `${folder.name}/${only.name}`;
+      folder.path = only.path;
+      folder.key = `d:${only.path}`;
+      folder.value = only.value;
+      folder.fileCount = only.fileCount;
+      folder.children = only.children;
+    }
+    return folder;
+  };
+  if (singleRoot) {
+    return (singleRoot.children ?? []).map((child) => build(child, child.name));
+  }
+  return cc.files.map((root) => build(root, root.name));
+}
+function countFolders(nodes) {
+  let count = 0;
+  const stack = [...nodes];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node.kind === "folder") count++;
+    if (node.children) stack.push(...node.children);
   }
+  return count;
 }
-function evaluateCycles(rule, cycles, violations) {
-  for (const cycle of cycles) {
-    const paths = cycle.nodes.map((node) => node.path);
-    violations.push({
-      key: `cycles:${rule.name}:${cycle.nodes.map((node) => node.id).sort().join("|")}`,
-      rule: rule.name,
-      type: "cycles",
-      severity: rule.severity,
-      message: rule.message ?? cycleMessage(paths),
-      files: paths,
-      cycle: {
-        size: cycle.size,
-        nodes: cycle.nodes.map((node) => ({ ...node }))
+function pickDefaultSelection(files, lens, metric, metrics) {
+  if (files.length === 0) return null;
+  if (lens === "metric" && metric) {
+    const index = metrics.findIndex((entry) => entry.key === metric);
+    if (index >= 0) {
+      let best = null;
+      for (const file of files) {
+        const value = file.values[index];
+        if (value === null || value === void 0) continue;
+        if (!best || value > (best.values[index] ?? -Infinity)) best = file;
       }
-    });
+      if (best) return best.index;
+    }
+  }
+  if (lens === "structure") {
+    return files.reduce(
+      (best, file) => file.actualArea > best.actualArea ? file : best
+    ).index;
   }
+  return files.reduce((best, file) => file.risk > best.risk ? file : best).index;
 }
-function cycleMessage(paths) {
-  const visible = paths.slice(0, 6);
-  const suffix = paths.length > visible.length ? " \u2192 \u2026" : "";
-  return `Ciclo de ${paths.length} ficheros: ${visible.join(" \u2192 ")}${suffix}`;
+
+// packages/render/src/html.ts
+import { readFileSync } from "node:fs";
+
+// packages/render/src/color.ts
+var RISK_STOPS = [
+  [0, "#ebe7df"],
+  [0.35, "#e9cd98"],
+  [0.65, "#d68a54"],
+  [1, "#a42e2c"]
+];
+var METRIC_STOPS = [
+  [0, "#ebe7df"],
+  [0.5, "#b9c9cf"],
+  [1, "#355b6b"]
+];
+var RISK_GRADIENT = "linear-gradient(90deg, #ebe7df 0%, #e9cd98 35%, #d68a54 65%, #a42e2c 100%)";
+var METRIC_GRADIENT = "linear-gradient(90deg, #ebe7df 0%, #b9c9cf 50%, #355b6b 100%)";
+function clamp012(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(1, value));
 }
-function compareViolations(left, right) {
-  return compareStrings4(left.key, right.key);
+function hexToRgb(hex) {
+  const value = hex.replace("#", "");
+  return [
+    Number.parseInt(value.slice(0, 2), 16),
+    Number.parseInt(value.slice(2, 4), 16),
+    Number.parseInt(value.slice(4, 6), 16)
+  ];
 }
-function compareStrings4(left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
+function rgbToHex(rgb) {
+  return `#${rgb.map((channel) => channel.toString(16).padStart(2, "0")).join("")}`;
 }
-
-// packages/metrics/src/diff.ts
-function diffSnapshots(base, head, options = {}) {
-  const top = Math.max(1, Math.floor(options.top ?? 10));
-  const baseIndex = indexSnapshot(base);
-  const headIndex = indexSnapshot(head);
-  const added = difference(headIndex, baseIndex);
-  const removed = difference(baseIndex, headIndex);
-  const changed = changedFiles(baseIndex, headIndex);
-  const edgeDiff = diffEdges(baseIndex, headIndex);
-  const baseCycles = cycleGroups(baseIndex);
-  const headCycles = cycleGroups(headIndex);
-  const introducedCycles = cycleDifference(headCycles, baseCycles);
-  const fixedCycles = cycleDifference(baseCycles, headCycles);
-  const hotspotMetric = chooseHotspotMetric(
-    baseIndex,
-    headIndex,
-    options.hotspotMetric
-  );
-  const hotspots = hotspotMetric ? buildHotspots(baseIndex, headIndex, added, changed, hotspotMetric, top) : [];
-  const rules = options.rules ? evaluateRules(
-    ruleInput(baseIndex, [...baseCycles.values()].map((group) => group.component)),
-    ruleInput(headIndex, [...headCycles.values()].map((group) => group.component)),
-    options.rules
-  ) : emptyRuleReport();
-  return {
-    schemaVersion: "1.0",
-    base: summarize(baseIndex),
-    head: summarize(headIndex),
-    summary: {
-      addedFiles: added.length,
-      removedFiles: removed.length,
-      changedFiles: changed.length,
-      addedEdges: edgeDiff.added.length,
-      removedEdges: edgeDiff.removed.length,
-      cyclicEdgesAdded: edgeDiff.cyclicAdded.length,
-      cyclicEdgesRemoved: edgeDiff.cyclicRemoved.length,
-      introducedCycles: introducedCycles.length,
-      fixedCycles: fixedCycles.length,
-      hotspots: hotspots.length
-    },
-    hotspotMetric,
-    rules,
-    files: { added, removed, changed },
-    edges: edgeDiff,
-    cycles: { introduced: introducedCycles, fixed: fixedCycles },
-    hotspots
-  };
+function mix(a, b, t) {
+  const from = hexToRgb(a);
+  const to = hexToRgb(b);
+  return rgbToHex([
+    Math.round(from[0] + (to[0] - from[0]) * t),
+    Math.round(from[1] + (to[1] - from[1]) * t),
+    Math.round(from[2] + (to[2] - from[2]) * t)
+  ]);
 }
-function indexSnapshot(cc) {
-  const paths = /* @__PURE__ */ new Map();
-  for (const root of cc.files) {
-    walkFiles([root], (entry) => {
-      paths.set(entry.node.id, relativePath(root, entry.path, entry.node));
-    });
-  }
-  const nodes = [...paths.keys()].sort(
-    (left, right) => compareStrings5(paths.get(left) ?? left, paths.get(right) ?? right)
-  );
-  const metrics = cc.lenses?.metrics?.attributes ?? {};
-  const edges = /* @__PURE__ */ new Map();
-  for (const edge of cc.lenses?.dependency?.edges ?? []) {
-    const key = edgeKey(edge.fromId, edge.toId);
-    const weight = finiteNumber(edge.attributes?.weight) ?? 1;
-    const typeOnly = finiteNumber(edge.attributes?.typeOnly) ?? 0;
-    const existing = edges.get(key);
-    if (existing) {
-      existing.weight += weight;
-      existing.typeOnly += typeOnly;
-      existing.isCyclic = existing.isCyclic || edge.isCyclic === true;
-    } else {
-      edges.set(key, {
-        fromId: edge.fromId,
-        toId: edge.toId,
-        weight,
-        typeOnly,
-        isCyclic: edge.isCyclic === true
-      });
+function ramp(stops, t) {
+  const value = clamp012(t);
+  for (let index = 0; index < stops.length - 1; index++) {
+    const from = stops[index];
+    const to = stops[index + 1];
+    if (value <= to[0]) {
+      const span2 = to[0] - from[0] || 1;
+      return mix(from[1], to[1], (value - from[0]) / span2);
     }
   }
-  return { cc, paths, nodes, metrics, edges };
-}
-function relativePath(root, fullPath, leaf) {
-  if (fullPath === root.name) return leaf.name;
-  const prefix = `${root.name}/`;
-  return fullPath.startsWith(prefix) ? fullPath.slice(prefix.length) : fullPath;
+  return stops[stops.length - 1][1];
 }
-function summarize(index) {
-  let folders = 0;
-  walkTree(index.cc.files, (entry) => {
-    if (entry.node.type === "Folder" && entry.depth > 0) folders++;
-  });
-  return {
-    projectName: index.cc.meta.projectName ?? "",
-    checksum: index.cc.meta.checksum ?? "",
-    files: index.paths.size,
-    folders,
-    edges: index.edges.size
-  };
+function riskColor(risk) {
+  return ramp(RISK_STOPS, risk);
 }
-function difference(present, absent) {
-  const files = [];
-  for (const [id, path8] of present.paths) {
-    if (absent.paths.has(id)) continue;
-    files.push({
-      id,
-      path: path8,
-      metrics: sortedMetrics(present.metrics[id])
-    });
+function metricColor(value, metric) {
+  if (value === null) return METRIC_STOPS[0][1];
+  let t;
+  if (metric.mode === "log") {
+    const span2 = Math.max(1e-9, metric.max - metric.min);
+    t = Math.log1p(Math.max(0, value - metric.min)) / Math.log1p(span2);
+  } else {
+    const span2 = metric.max - metric.min;
+    t = span2 > 0 ? (value - metric.min) / span2 : 0;
   }
-  return files.sort(compareFiles);
+  return ramp(METRIC_STOPS, t);
 }
-function changedFiles(base, head) {
-  const changed = [];
-  for (const [id, path8] of head.paths) {
-    if (!base.paths.has(id)) continue;
-    const baseValues = base.metrics[id] ?? {};
-    const headValues = head.metrics[id] ?? {};
-    const keys = /* @__PURE__ */ new Set([...Object.keys(baseValues), ...Object.keys(headValues)]);
-    const changes = [];
-    for (const metric of [...keys].sort(compareStrings5)) {
-      const baseValue = finiteNumber(baseValues[metric]);
-      const headValue = finiteNumber(headValues[metric]);
-      if (baseValue === null && headValue === null) continue;
-      if (baseValue !== null && headValue !== null && baseValue === headValue) {
-        continue;
-      }
-      changes.push({
-        metric,
-        base: baseValue,
-        head: headValue,
-        delta: baseValue !== null && headValue !== null ? headValue - baseValue : null
-      });
+function inkFor(color) {
+  const [r, g, b] = hexToRgb(color);
+  const luminance = (0.2126 * r + 0.7152 * g + 0.0722 * b) / 255;
+  return luminance > 0.52 ? "#1a1a1a" : "#f7f5f1";
+}
+function colorForFile(lens, risk, section, value, metric) {
+  if (lens === "structure") return section?.color ?? "#ddd8cf";
+  if (lens === "risk" || !metric) return riskColor(risk);
+  return metricColor(value, metric);
+}
+
+// packages/layouts/src/squarify.ts
+function squarify(items, rect) {
+  if (rect.w <= 0 || rect.h <= 0) return [];
+  const usable = items.filter(
+    (item) => Number.isFinite(item.value) && item.value > 0
+  );
+  const total = usable.reduce((sum, item) => sum + item.value, 0);
+  if (usable.length === 0 || total <= 0) return [];
+  const sorted = usable.map((item, index2) => ({ item, index: index2 })).sort((a, b) => b.item.value - a.item.value || a.index - b.index).map(({ item }) => item);
+  const scale = rect.w * rect.h / total;
+  const placed = [];
+  let x = rect.x;
+  let y = rect.y;
+  let w = rect.w;
+  let h = rect.h;
+  let row = [];
+  const area = (item) => item.value * scale;
+  function worst(candidate, side) {
+    let sum = 0;
+    let max = -Infinity;
+    let min = Infinity;
+    for (const item of candidate) {
+      const value = area(item);
+      sum += value;
+      if (value > max) max = value;
+      if (value < min) min = value;
     }
-    if (changes.length > 0) changed.push({ id, path: path8, changes });
+    if (sum <= 0 || side <= 0) return Infinity;
+    return Math.max(
+      side * side * max / (sum * sum),
+      sum * sum / (side * side * min)
+    );
   }
-  return changed.sort(compareChangedFiles);
-}
-function diffEdges(base, head) {
-  const added = [];
-  const removed = [];
-  for (const [key, edge] of head.edges) {
-    if (!base.edges.has(key)) added.push(edgeChange(head, edge));
+  function place(current, horizontal) {
+    if (current.length === 0) return;
+    const sum = current.reduce((acc, item) => acc + area(item), 0);
+    if (sum <= 0) return;
+    if (horizontal) {
+      if (w <= 0) return;
+      const thickness = sum / w;
+      if (!Number.isFinite(thickness) || thickness <= 0) return;
+      let position = x;
+      for (const item of current) {
+        const length = area(item) / thickness;
+        placed.push({ item, x: position, y, w: length, h: thickness });
+        position += length;
+      }
+      y += thickness;
+      h -= thickness;
+    } else {
+      if (h <= 0) return;
+      const thickness = sum / h;
+      if (!Number.isFinite(thickness) || thickness <= 0) return;
+      let position = y;
+      for (const item of current) {
+        const length = area(item) / thickness;
+        placed.push({ item, x, y: position, w: thickness, h: length });
+        position += length;
+      }
+      x += thickness;
+      w -= thickness;
+    }
   }
-  for (const [key, edge] of base.edges) {
-    if (!head.edges.has(key)) removed.push(edgeChange(base, edge));
+  let index = 0;
+  while (index < sorted.length) {
+    const horizontal = w >= h;
+    const side = horizontal ? w : h;
+    const next = sorted[index];
+    if (row.length === 0) {
+      row.push(next);
+      index++;
+      continue;
+    }
+    if (worst([...row, next], side) <= worst(row, side)) {
+      row.push(next);
+      index++;
+    } else {
+      place(row, horizontal);
+      row = [];
+    }
   }
-  added.sort(compareEdgeChanges);
-  removed.sort(compareEdgeChanges);
-  return {
-    added,
-    removed,
-    cyclicAdded: added.filter((edge) => edge.isCyclic),
-    cyclicRemoved: removed.filter((edge) => edge.isCyclic)
+  if (row.length > 0) place(row, w >= h);
+  return placed;
+}
+
+// packages/render/src/layout.ts
+var VIEW_WIDTH = 1400;
+var VIEW_HEIGHT = 900;
+var VIEW_PADDING = 8;
+var MAX_DEPTH3 = 12;
+function layoutMap(roots, width = VIEW_WIDTH, height = VIEW_HEIGHT) {
+  const rect = {
+    x: VIEW_PADDING,
+    y: VIEW_PADDING,
+    w: Math.max(1, width - VIEW_PADDING * 2),
+    h: Math.max(1, height - VIEW_PADDING * 2)
   };
+  return layoutChildren(roots, rect, 0);
 }
-function edgeChange(index, edge) {
-  return {
-    fromId: edge.fromId,
-    toId: edge.toId,
-    from: index.paths.get(edge.fromId) ?? edge.fromId,
-    to: index.paths.get(edge.toId) ?? edge.toId,
-    weight: edge.weight,
-    typeOnly: edge.typeOnly,
-    isCyclic: edge.isCyclic
-  };
+function layoutChildren(nodes, rect, depth) {
+  if (nodes.length === 0 || rect.w < 2 || rect.h < 2) return [];
+  const items = nodes.map((node) => ({
+    key: node.key,
+    value: Math.max(1, node.value),
+    node
+  }));
+  return squarify(items, rect).map(
+    (placed) => layoutNode(placed.item.node, {
+      x: placed.x,
+      y: placed.y,
+      w: placed.w,
+      h: placed.h
+    }, depth)
+  );
 }
-function cycleGroups(index) {
-  const adjacency = /* @__PURE__ */ new Map();
-  const reverse = /* @__PURE__ */ new Map();
-  for (const node of index.nodes) {
-    adjacency.set(node, []);
-    reverse.set(node, []);
-  }
-  for (const edge of index.edges.values()) {
-    if (!index.paths.has(edge.fromId) || !index.paths.has(edge.toId)) continue;
-    adjacency.get(edge.fromId)?.push(edge.toId);
-    reverse.get(edge.toId)?.push(edge.fromId);
-  }
-  for (const [node, neighbors] of adjacency) {
-    adjacency.set(node, [...new Set(neighbors)].sort(compareStrings5));
-  }
-  for (const [node, neighbors] of reverse) {
-    reverse.set(node, [...new Set(neighbors)].sort(compareStrings5));
-  }
-  const visited = /* @__PURE__ */ new Set();
-  const order = [];
-  for (const start of index.nodes) {
-    if (visited.has(start)) continue;
-    visited.add(start);
-    const stack = [
-      { node: start, neighbors: adjacency.get(start) ?? [], next: 0 }
-    ];
-    while (stack.length > 0) {
-      const frame = stack[stack.length - 1];
-      if (frame.next < frame.neighbors.length) {
-        const next = frame.neighbors[frame.next];
-        frame.next++;
-        if (!visited.has(next)) {
-          visited.add(next);
-          stack.push({
-            node: next,
-            neighbors: adjacency.get(next) ?? [],
-            next: 0
-          });
-        }
-      } else {
-        order.push(frame.node);
-        stack.pop();
-      }
-    }
-  }
-  const assigned = /* @__PURE__ */ new Set();
-  const groups = /* @__PURE__ */ new Map();
-  for (let position = order.length - 1; position >= 0; position--) {
-    const start = order[position];
-    if (assigned.has(start)) continue;
-    assigned.add(start);
-    const component = [];
-    const stack = [start];
-    while (stack.length > 0) {
-      const node = stack.pop();
-      component.push(node);
-      for (const next of reverse.get(node) ?? []) {
-        if (assigned.has(next)) continue;
-        assigned.add(next);
-        stack.push(next);
-      }
-    }
-    const hasSelfLoop = component.some(
-      (node) => (adjacency.get(node) ?? []).includes(node)
-    );
-    if (component.length < 2 && !hasSelfLoop) continue;
-    const nodes = component.map((id) => ({
-      id,
-      path: index.paths.get(id) ?? id
-    })).sort((left, right) => {
-      return compareStrings5(left.path, right.path) || compareStrings5(left.id, right.id);
-    });
-    const key = [...component].sort(compareStrings5).join("\0");
-    groups.set(key, { key, component: { size: nodes.length, nodes } });
+function layoutNode(node, rect, depth) {
+  if (node.kind === "file" || !node.children || node.children.length === 0) {
+    return { node, rect, headerHeight: 0, children: [] };
   }
-  return groups;
-}
-function cycleDifference(present, absent) {
-  const cycles = [];
-  for (const [key, group] of present) {
-    if (!absent.has(key)) cycles.push(group.component);
+  let headerHeight = 0;
+  if (rect.w >= 30 && rect.h >= 32) {
+    headerHeight = rect.h >= 62 ? 17 : 13;
   }
-  return cycles.sort(compareCycles);
+  const inner = {
+    x: rect.x + 1,
+    y: rect.y + headerHeight + 1,
+    w: Math.max(0, rect.w - 2),
+    h: Math.max(0, rect.h - headerHeight - 2)
+  };
+  const children = depth < MAX_DEPTH3 && inner.w >= 1 && inner.h >= 1 ? layoutChildren(node.children, inner, depth + 1) : [];
+  return { node, rect, headerHeight, children };
 }
-function ruleInput(index, cycles) {
-  const files = index.nodes.map((id) => ({
-    id,
-    path: index.paths.get(id) ?? id,
-    metrics: sortedMetrics(index.metrics[id])
-  }));
-  const edges = [];
-  for (const edge of index.edges.values()) {
-    if (!index.paths.has(edge.fromId) || !index.paths.has(edge.toId)) {
-      continue;
-    }
-    edges.push({
-      fromId: edge.fromId,
-      toId: edge.toId,
-      from: index.paths.get(edge.fromId) ?? edge.fromId,
-      to: index.paths.get(edge.toId) ?? edge.toId
-    });
-  }
-  return { files, edges, cycles };
+
+// packages/render/src/svg.ts
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
-function chooseHotspotMetric(base, head, requested) {
-  if (requested) return requested;
-  for (const metric of ["maxComplexity", "rloc"]) {
-    if (hasMetric(base, metric) || hasMetric(head, metric)) return metric;
-  }
-  return null;
+function escapeAttr(value) {
+  return escapeHtml(value);
 }
-function hasMetric(index, metric) {
-  for (const values of Object.values(index.metrics)) {
-    if (finiteNumber(values[metric]) !== null) return true;
-  }
-  return false;
+function formatInt(value) {
+  if (!Number.isFinite(value)) return "\u2014";
+  return Math.round(value).toString().replace(/\B(?=(\d{3})+(?!\d))/g, ".");
 }
-function buildHotspots(base, head, added, changed, metric, top) {
-  const addedIds = new Set(added.map((file) => file.id));
-  const candidates = [...added, ...changed];
-  const hotspots = [];
-  for (const file of candidates) {
-    const baseValue = finiteNumber(base.metrics[file.id]?.[metric]);
-    const headValue = finiteNumber(head.metrics[file.id]?.[metric]);
-    if (headValue === null) continue;
-    const before = baseValue ?? 0;
-    const delta = headValue - before;
-    if (delta <= 0) continue;
-    hotspots.push({
-      id: file.id,
-      path: file.path,
-      metric,
-      base: before,
-      head: headValue,
-      delta,
-      change: addedIds.has(file.id) ? "added" : "changed"
-    });
+function formatCompact(value) {
+  if (!Number.isFinite(value)) return "\u2014";
+  const absolute = Math.abs(value);
+  if (absolute >= 1e6) {
+    return `${(value / 1e6).toFixed(1).replace(".0", "").replace(".", ",")}M`;
   }
-  return hotspots.sort(
-    (left, right) => right.delta - left.delta || right.head - left.head || compareStrings5(left.path, right.path)
-  ).slice(0, top);
-}
-function sortedMetrics(values) {
-  const sorted = {};
-  if (!values) return sorted;
-  for (const key of Object.keys(values).sort(compareStrings5)) {
-    const value = finiteNumber(values[key]);
-    if (value !== null) sorted[key] = value;
+  if (absolute >= 1e3) {
+    return `${(value / 1e3).toFixed(1).replace(".0", "").replace(".", ",")}k`;
   }
-  return sorted;
-}
-function finiteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-function edgeKey(fromId, toId) {
-  return `${fromId}\0${toId}`;
-}
-function compareFiles(left, right) {
-  return compareStrings5(left.path, right.path) || compareStrings5(left.id, right.id);
+  return formatInt(value);
 }
-function compareChangedFiles(left, right) {
-  return compareStrings5(left.path, right.path) || compareStrings5(left.id, right.id);
+function coord(value) {
+  const rounded = Math.round(value);
+  return Object.is(rounded, -0) ? "0" : String(rounded);
 }
-function compareEdgeChanges(left, right) {
-  return compareStrings5(left.from, right.from) || compareStrings5(left.to, right.to) || compareStrings5(left.fromId, right.fromId) || compareStrings5(left.toId, right.toId);
+function span(value) {
+  return String(Math.max(1, Math.round(value)));
 }
-function compareCycles(left, right) {
-  return compareStrings5(
-    left.nodes[0]?.path ?? "",
-    right.nodes[0]?.path ?? ""
-  ) || left.size - right.size;
+function truncate(value, maxWidth, fontSize) {
+  const maxChars = Math.floor(maxWidth / (fontSize * 0.56));
+  if (maxChars <= 0) return "";
+  if (value.length <= maxChars) return value;
+  if (maxChars === 1) return "\u2026";
+  return `${value.slice(0, maxChars - 1)}\u2026`;
 }
-function compareStrings5(left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
+function labelFor(nodeName, rect, out, ink) {
+  if (rect.w < 44 || rect.h < 13) return;
+  const available = rect.w - 8;
+  const dot = nodeName.lastIndexOf(".");
+  const twoLines = rect.h >= 27 && rect.w >= 64 && dot > 0 && dot < nodeName.length - 1;
+  if (twoLines) {
+    const base = truncate(nodeName.slice(0, dot), available, 12.5);
+    const extension = truncate(nodeName.slice(dot), available, 10);
+    if (base) {
+      out.push(
+        `<text class="a" x="${coord(rect.x + 4)}" y="${coord(rect.y + 12)}" fill="${ink}">${escapeHtml(base)}</text>`
+      );
+    }
+    if (extension) {
+      out.push(
+        `<text class="b" x="${coord(rect.x + 4)}" y="${coord(rect.y + 22.5)}" fill="${ink}">${escapeHtml(extension)}</text>`
+      );
+    }
+    return;
+  }
+  const label = truncate(nodeName, available, 12.5);
+  if (!label) return;
+  out.push(
+    `<text class="a" x="${coord(rect.x + 4)}" y="${coord(rect.y + 13)}" fill="${ink}">${escapeHtml(label)}</text>`
+  );
 }
-
-// packages/metrics/src/risk.ts
-var COMPLEXITY_METRIC_CANDIDATES = [
-  "maxComplexity",
-  "max_complexity_per_function",
-  "complexity",
-  "logic_complexity",
-  "sonar_cognitive_complexity"
-];
-var CHURN_METRIC_CANDIDATES = [
-  "number_of_commits",
-  "number_of_authors",
-  "number_of_renames"
-];
-var RISK_WEIGHTS = {
-  complexity: 0.5,
-  churn: 0.32,
-  size: 0.18
-};
-var RISK_GAMMA = 1.7;
-function riskScores(files) {
-  const complexityP95 = percentile(
-    files.map((file) => file.complexity).filter((value) => value > 0),
-    0.95
-  );
-  const churnP95 = percentile(
-    files.map((file) => file.churn).filter((value) => value > 0),
-    0.95
+function renderPlaced(placed, out, model, metricIndex, metric) {
+  const node = placed.node;
+  const rect = placed.rect;
+  if (node.kind === "file") {
+    const index = node.fileIndex;
+    if (index === void 0) return;
+    const file = model.files[index];
+    if (!file) return;
+    const value = metricIndex >= 0 ? file.values[metricIndex] ?? null : null;
+    const fill = colorForFile(
+      model.initialLens,
+      file.risk,
+      model.sections[file.section],
+      value,
+      metric
+    );
+    const ink = inkFor(fill);
+    out.push(
+      `<rect data-i="${index}" x="${coord(rect.x)}" y="${coord(rect.y)}" width="${span(rect.w)}" height="${span(rect.h)}" fill="${fill}"/>`
+    );
+    labelFor(file.name, rect, out, ink);
+    return;
+  }
+  const folder = node;
+  out.push(
+    `<g class="folder" data-nm="${escapeAttr(folder.name)}" data-n="${folder.fileCount}" data-a="${coord(folder.value)}">`
   );
-  const sizeP95 = percentile(
-    files.map((file) => file.size).filter((value) => value > 0),
-    0.95
+  out.push(
+    `<rect class="fr" x="${coord(rect.x)}" y="${coord(rect.y)}" width="${span(rect.w)}" height="${span(rect.h)}"/>`
   );
-  const complexityWeight = complexityP95 > 0 ? RISK_WEIGHTS.complexity : 0;
-  const churnWeight = churnP95 > 0 ? RISK_WEIGHTS.churn : 0;
-  const sizeWeight = sizeP95 > 0 ? RISK_WEIGHTS.size : 0;
-  const totalWeight = complexityWeight + churnWeight + sizeWeight;
-  if (totalWeight === 0) return files.map(() => 0);
-  return files.map((file) => {
-    const raw = (complexityWeight * norm(file.complexity, complexityP95) + churnWeight * norm(file.churn, churnP95) + sizeWeight * norm(file.size, sizeP95)) / totalWeight;
-    return Math.pow(clamp01(raw), RISK_GAMMA);
-  });
-}
-function firstMetric(available, candidates) {
-  const set = available instanceof Set ? available : new Set(available);
-  for (const candidate of candidates) {
-    if (set.has(candidate)) return candidate;
+  if (placed.headerHeight >= 13 && rect.w >= 30) {
+    const headerHeight = placed.headerHeight;
+    out.push(
+      `<rect class="fh" x="${coord(rect.x + 1)}" y="${coord(rect.y + 1)}" width="${span(rect.w - 2)}" height="${span(headerHeight - 1)}"/>`
+    );
+    const count = formatCompact(folder.value);
+    const showCount = rect.w >= 86;
+    const countWidth = showCount ? count.length * 5.8 + 12 : 0;
+    const name = truncate(folder.name, Math.max(8, rect.w - 12 - countWidth), 11.5);
+    if (name) {
+      out.push(
+        `<text class="ft" x="${coord(rect.x + 6)}" y="${coord(rect.y + headerHeight / 2 + 4)}">${escapeHtml(name)}</text>`
+      );
+    }
+    if (showCount) {
+      out.push(
+        `<text class="fn" x="${coord(rect.x + rect.w - 6)}" y="${coord(rect.y + headerHeight / 2 + 3.6)}">${escapeHtml(count)}</text>`
+      );
+    }
   }
-  return null;
-}
-function norm(value, p95) {
-  return p95 > 0 ? clamp01(value / p95) : 0;
-}
-function percentile(values, p) {
-  if (values.length === 0) return 0;
-  const sorted = [...values].sort((a, b) => a - b);
-  const index = Math.min(
-    sorted.length - 1,
-    Math.max(0, Math.floor((sorted.length - 1) * p))
-  );
-  return sorted[index] ?? 0;
-}
-function clamp01(value) {
-  if (!Number.isFinite(value)) return 0;
-  return Math.max(0, Math.min(1, value));
-}
-
-// packages/render/src/model.ts
-var RenderError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "RenderError";
+  for (const child of placed.children) {
+    renderPlaced(child, out, model, metricIndex, metric);
   }
-};
-var PALETTE = [
-  "#b9c4d0",
-  "#c9b8a8",
-  "#a9bfae",
-  "#c4b6c9",
-  "#c9c2a6",
-  "#d5d2ca",
-  "#c2c8d0",
-  "#d6c6bd",
-  "#b7c6c2",
-  "#cbbfb0",
-  "#bcc3b9",
-  "#cfc6c9"
-];
-var CURATED_METRICS = [
-  "rloc",
-  "maxComplexity",
-  "max_complexity_per_function",
-  "complexity",
-  "functions",
-  "number_of_functions",
-  "maxFunctionLength",
-  "loc",
-  "imports",
-  "externalImports",
-  "builtinImports",
-  "typeOnlyImports",
-  "unresolvedImports",
-  "fanIn",
-  "fanOut",
-  "inCycle",
-  "cycleSize",
-  "dependencyLevel",
-  "number_of_commits",
-  "number_of_authors",
-  "incoming_dependencies",
-  "outgoing_dependencies"
-];
-function isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function valueOf(values, key) {
-  if (!key || !values) return void 0;
-  const value = values[key];
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+  out.push("</g>");
 }
-function percentile2(values, p) {
-  if (values.length === 0) return 0;
-  const sorted = [...values].sort((a, b) => a - b);
-  const index = Math.min(
-    sorted.length - 1,
-    Math.max(0, Math.floor((sorted.length - 1) * p))
+function renderSvg(model) {
+  const metricIndex = model.initialMetric ? model.metrics.findIndex((metric2) => metric2.key === model.initialMetric) : -1;
+  const metric = metricIndex >= 0 ? model.metrics[metricIndex] : void 0;
+  const out = [];
+  out.push(
+    `<svg id="map" viewBox="0 0 ${VIEW_WIDTH} ${VIEW_HEIGHT}" preserveAspectRatio="xMidYMid meet" role="img" aria-label="Mapa de arquitectura de ${escapeAttr(model.meta.project)}">`
   );
-  return sorted[index] ?? 0;
-}
-function hashString(value) {
-  let hash = 2166136261;
-  for (let index = 0; index < value.length; index++) {
-    hash ^= value.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return hash >>> 0;
-}
-function sectionForPath(path8) {
-  const folders = path8.split("/").filter(Boolean).slice(0, -1);
-  if (folders.length === 0) return "(ra\xEDz)";
-  if (folders.length === 1) return folders[0];
-  return folders.slice(0, 3).join("/");
-}
-function asEdges(value) {
-  if (!Array.isArray(value)) return [];
-  const edges = [];
-  for (const item of value) {
-    if (!isRecord3(item)) continue;
-    if (typeof item.fromId !== "string" || typeof item.toId !== "string") continue;
-    edges.push({
-      fromId: item.fromId,
-      toId: item.toId,
-      ...item.isCyclic === true ? { isCyclic: true } : {}
-    });
+  out.push(
+    `<rect class="canvas" x="0" y="0" width="${VIEW_WIDTH}" height="${VIEW_HEIGHT}"/>`
+  );
+  out.push(`<g id="cells">`);
+  for (const placed of layoutMap(model.roots)) {
+    renderPlaced(placed, out, model, metricIndex, metric);
   }
-  return edges;
+  out.push(`</g><g id="edges"></g></svg>`);
+  return out.join("");
 }
-function metricTitle(attributes, key) {
-  const descriptor = attributes?.[key];
-  if (isRecord3(descriptor) && typeof descriptor.title === "string" && descriptor.title) {
-    return descriptor.title;
-  }
-  return key;
+
+// packages/render/src/html.ts
+var STYLES = readFileSync(new URL("./styles.css", import.meta.url), "utf8");
+var CLIENT = readFileSync(new URL("./client.js", import.meta.url), "utf8").replace(
+  /<\/script/gi,
+  "<\\/script"
+);
+function round(value, digits = 2) {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
 }
-function metricDirection(attributes, key) {
-  const descriptor = attributes?.[key];
-  if (isRecord3(descriptor) && typeof descriptor.direction === "number") {
-    return descriptor.direction;
-  }
-  return 0;
+function jsonForScript(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
 }
-function buildRenderModel(cc, options = {}) {
-  const stats = getStats(cc);
-  const coverage = new Set(stats.metricCoverage.map((entry) => entry.name));
-  const attributes = cc.lenses?.metrics?.attributes ?? {};
-  const descriptors = cc.lenses?.metrics?.attributeDescriptors;
-  let areaMetric;
-  if (options.areaMetric) {
-    if (!coverage.has(options.areaMetric)) {
-      throw new RenderError(
-        `la m\xE9trica de \xE1rea "${options.areaMetric}" no existe en este cc.json`
-      );
-    }
-    areaMetric = options.areaMetric;
-  } else {
-    areaMetric = defaultMetric(stats) ?? null;
-  }
-  const complexityKey = firstMetric(coverage, COMPLEXITY_METRIC_CANDIDATES);
-  const churnKey = firstMetric(coverage, CHURN_METRIC_CANDIDATES);
-  const metricKeys = [];
-  const addMetric = (key) => {
-    if (key && coverage.has(key) && !metricKeys.includes(key)) metricKeys.push(key);
-  };
-  for (const key of CURATED_METRICS) addMetric(key);
-  addMetric(areaMetric);
-  addMetric(complexityKey);
-  addMetric(churnKey);
-  if (options.color && options.color !== "risk" && options.color !== "structure") {
-    addMetric(options.color);
-  }
-  const singleRoot = cc.files.length === 1 && cc.files[0]?.type === "Folder" ? cc.files[0] : null;
-  const prefix = singleRoot ? `${singleRoot.name}/` : "";
-  const rootName = singleRoot?.name ?? "";
-  const warnings = [];
-  const files = [];
-  const fileIndexById = /* @__PURE__ */ new Map();
-  walkFiles(cc.files, (entry) => {
-    const fullPath = entry.path;
-    const path8 = prefix && fullPath.startsWith(prefix) ? fullPath.slice(prefix.length) : fullPath;
-    const values = attributes[entry.node.id];
-    const rawArea = valueOf(values, areaMetric);
-    const index = files.length;
-    fileIndexById.set(entry.node.id, index);
-    files.push({
-      index,
-      nodeId: entry.node.id,
-      path: path8,
-      name: entry.node.name,
-      section: -1,
-      area: Math.max(1, rawArea ?? 0),
-      actualArea: rawArea ?? 0,
-      risk: 0,
-      complexity: valueOf(values, complexityKey) ?? 0,
-      churn: valueOf(values, churnKey) ?? 0,
-      values: []
-    });
-  });
-  if (areaMetric && files.length > 0) {
-    const missing = files.filter((file) => file.actualArea === 0).length;
-    if (missing > 0) {
-      warnings.push(
-        `${missing} ficheros sin "${areaMetric}"; se dibujan con \xE1rea m\xEDnima para no desaparecer`
-      );
-    }
-    if (!options.areaMetric && areaMetric !== "rloc") {
-      warnings.push(`"rloc" no est\xE1 presente; se usa "${areaMetric}" como \xE1rea`);
-    }
-  }
-  const risks = riskScores(
-    files.map((file) => ({
-      complexity: file.complexity,
-      churn: file.churn,
-      size: file.actualArea
-    }))
-  );
-  for (const [index, file] of files.entries()) {
-    file.risk = risks[index] ?? 0;
-  }
-  const sectionAccumulator = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    const key = sectionForPath(file.path);
-    const current = sectionAccumulator.get(key) ?? { files: 0, area: 0 };
-    current.files++;
-    current.area += file.actualArea;
-    sectionAccumulator.set(key, current);
-  }
-  const sections = [...sectionAccumulator.entries()].map(([key, value]) => ({
-    key,
-    label: key,
-    files: value.files,
-    area: value.area,
-    color: PALETTE[hashString(key) % PALETTE.length]
-  })).sort((a, b) => b.area - a.area || a.key.localeCompare(b.key));
-  const sectionIndex = new Map(sections.map((section, index) => [section.key, index]));
-  for (const file of files) {
-    file.section = sectionIndex.get(sectionForPath(file.path)) ?? 0;
-  }
-  const metrics = metricKeys.map((key) => {
-    const present = files.map((file) => valueOf(attributes[file.nodeId], key)).filter((value) => value !== void 0);
-    const min = present.length > 0 ? Math.min(...present) : 0;
-    const actualMax = present.length > 0 ? Math.max(...present) : 0;
-    const p95 = percentile2(present, 0.95);
-    const skewed = min >= 0 && p95 > 0 && actualMax > p95 * 4;
-    const max = skewed ? actualMax : p95 > 0 ? p95 : actualMax;
-    return {
-      key,
-      title: metricTitle(descriptors, key),
-      direction: metricDirection(descriptors, key),
-      min,
-      max,
-      actualMax,
-      p95,
-      mode: skewed ? "log" : "linear",
-      coverage: present.length
-    };
-  });
-  for (const file of files) {
-    const values = attributes[file.nodeId];
-    file.values = metrics.map((metric) => valueOf(values, metric.key) ?? null);
-  }
-  const roots = buildRoots(cc, singleRoot, fileIndexById, files);
-  const folderCount = countFolders(roots);
-  const dependency = cc.lenses?.dependency;
-  const leafEdges = asEdges(dependency?.leafEdges);
-  const rawEdges = leafEdges.length > 0 ? leafEdges : asEdges(dependency?.edges);
-  const edgeSet = /* @__PURE__ */ new Set();
-  const edges = [];
-  const n = files.length;
-  for (const edge of rawEdges) {
-    const from = fileIndexById.get(edge.fromId);
-    const to = fileIndexById.get(edge.toId);
-    if (from === void 0 || to === void 0 || from === to) continue;
-    const key = from * n + to;
-    if (edgeSet.has(key)) continue;
-    edgeSet.add(key);
-    edges.push({ from, to });
-    if (edges.length >= 2e4) {
-      warnings.push("se han limitado las dependencias a 20.000 aristas");
-      break;
-    }
-  }
-  edges.sort((a, b) => a.from - b.from || a.to - b.to);
-  const flaggedEdges = /* @__PURE__ */ new Set();
-  for (const edge of rawEdges) {
-    if (edge.isCyclic !== true) continue;
-    const from = fileIndexById.get(edge.fromId);
-    const to = fileIndexById.get(edge.toId);
-    if (from === void 0 || to === void 0) continue;
-    flaggedEdges.add(from * n + to);
-  }
-  const cycleSet = /* @__PURE__ */ new Set();
-  const cycles = [];
-  for (const edge of edges) {
-    const key = edge.from * n + edge.to;
-    const backward = edgeSet.has(edge.to * n + edge.from);
-    if (backward || flaggedEdges.has(key)) {
-      if (!cycleSet.has(key)) {
-        cycleSet.add(key);
-        cycles.push(edge);
+function serialise(model) {
+  const directoryIndex = /* @__PURE__ */ new Map();
+  const directories = [];
+  const fileRows = model.files.map((file) => {
+    const slash = file.path.lastIndexOf("/");
+    const directory = slash >= 0 ? file.path.slice(0, slash) : "";
+    let dirIndex = -1;
+    if (directory) {
+      const known = directoryIndex.get(directory);
+      if (known === void 0) {
+        dirIndex = directories.length;
+        directoryIndex.set(directory, dirIndex);
+        directories.push(directory);
+      } else {
+        dirIndex = known;
       }
     }
-  }
-  cycles.sort((a, b) => a.from - b.from || a.to - b.to);
-  if (rawEdges.length === 0) {
-    warnings.push("este cc.json no trae una lente de dependencias utilizable");
-  }
-  const totalArea = files.reduce((sum, file) => sum + file.actualArea, 0);
-  const hotspotCount = files.filter((file) => file.risk >= 0.66).length;
-  let initialLens = "risk";
-  let initialMetric = null;
-  if (options.color === "structure") {
-    initialLens = "structure";
-  } else if (options.color && options.color !== "risk") {
-    if (!coverage.has(options.color)) {
-      throw new RenderError(`la m\xE9trica de color "${options.color}" no existe en este cc.json`);
-    }
-    initialLens = "metric";
-    initialMetric = options.color;
-  }
-  const defaultSelection = pickDefaultSelection(files, initialLens, initialMetric, metrics);
-  const project = cc.meta.projectName || options.title || "Proyecto sin nombre";
+    const name = slash >= 0 ? file.path.slice(slash + 1) : file.path;
+    return [
+      dirIndex,
+      name,
+      file.section,
+      round(file.area, 1),
+      round(file.actualArea, 1),
+      round(file.risk, 4),
+      round(file.complexity, 1),
+      round(file.churn, 1),
+      ...file.values.map((value) => value === null ? null : round(value, 2))
+    ];
+  });
   return {
+    v: 1,
     meta: {
-      project,
-      title: options.title || project,
-      commit: cc.meta.commitHash || "",
-      checksum: cc.meta.checksum || "",
-      apiVersion: cc.meta.apiVersion,
-      rootName
+      project: model.meta.project,
+      commit: model.meta.commit,
+      checksum: model.meta.checksum,
+      api: model.meta.apiVersion,
+      root: model.meta.rootName
     },
-    files,
-    sections,
-    metrics,
-    edges,
-    cycles,
-    roots,
-    areaMetric,
-    areaTitle: areaMetric ? metricTitle(descriptors, areaMetric) : "\xC1rea",
-    totalArea,
-    fileCount: files.length,
-    folderCount,
-    hotspotCount,
-    defaultSelection,
-    initialLens,
-    initialMetric,
-    warnings
-  };
-}
-function buildRoots(cc, singleRoot, fileIndexById, files) {
-  const build = (node, path8) => {
-    if (node.type === "File") {
-      const index = fileIndexById.get(node.id);
-      const file = index === void 0 ? void 0 : files[index];
-      return {
-        kind: "file",
-        key: `f:${index ?? -1}`,
-        name: node.name,
-        path: path8,
-        value: file?.area ?? 1,
-        fileCount: 1,
-        section: file?.section ?? 0,
-        fileIndex: index
-      };
-    }
-    const children = (node.children ?? []).map(
-      (child) => build(child, path8 ? `${path8}/${child.name}` : child.name)
-    );
-    const folder = {
-      kind: "folder",
-      key: `d:${path8}`,
-      name: node.name,
-      path: path8,
-      value: children.reduce((sum, child) => sum + child.value, 0) || 1,
-      fileCount: children.reduce((sum, child) => sum + child.fileCount, 0),
-      section: -1,
-      children
-    };
-    while (folder.children?.length === 1 && folder.children[0]?.kind === "folder") {
-      const only = folder.children[0];
-      folder.name = `${folder.name}/${only.name}`;
-      folder.path = only.path;
-      folder.key = `d:${only.path}`;
-      folder.value = only.value;
-      folder.fileCount = only.fileCount;
-      folder.children = only.children;
-    }
-    return folder;
+    area: {
+      key: model.areaMetric,
+      title: model.areaTitle,
+      total: round(model.totalArea, 1)
+    },
+    lens: model.initialLens,
+    metric: model.initialMetric,
+    metrics: model.metrics.map((metric) => ({
+      key: metric.key,
+      title: metric.title,
+      min: round(metric.min, 2),
+      max: round(metric.max, 2),
+      mode: metric.mode,
+      dir: metric.direction,
+      coverage: metric.coverage
+    })),
+    sections: model.sections.map((section) => ({
+      key: section.key,
+      color: section.color,
+      files: section.files,
+      area: round(section.area, 1)
+    })),
+    dirs: directories,
+    files: fileRows,
+    edges: model.edges.flatMap((edge) => [edge.from, edge.to]),
+    cycles: model.cycles.flatMap((edge) => [edge.from, edge.to]),
+    hot: model.hotspotCount,
+    default: model.defaultSelection,
+    fileCount: model.fileCount,
+    folderCount: model.folderCount,
+    totalArea: round(model.totalArea, 1)
   };
-  if (singleRoot) {
-    return (singleRoot.children ?? []).map((child) => build(child, child.name));
-  }
-  return cc.files.map((root) => build(root, root.name));
 }
-function countFolders(nodes) {
-  let count = 0;
-  const stack = [...nodes];
-  while (stack.length > 0) {
-    const node = stack.pop();
-    if (node.kind === "folder") count++;
-    if (node.children) stack.push(...node.children);
-  }
-  return count;
+function renderLensButtons(model) {
+  const lenses = [
+    { id: "structure", label: "Estructura" },
+    { id: "risk", label: "Riesgo" }
+  ];
+  if (model.metrics.length > 0) lenses.push({ id: "metric", label: "M\xE9trica" });
+  return lenses.map(
+    (lens) => `<button type="button" class="lens" role="tab" data-lens="${lens.id}" aria-selected="${String(
+      model.initialLens === lens.id
+    )}">${lens.label}</button>`
+  ).join("");
 }
-function pickDefaultSelection(files, lens, metric, metrics) {
-  if (files.length === 0) return null;
-  if (lens === "metric" && metric) {
-    const index = metrics.findIndex((entry) => entry.key === metric);
-    if (index >= 0) {
-      let best = null;
-      for (const file of files) {
-        const value = file.values[index];
-        if (value === null || value === void 0) continue;
-        if (!best || value > (best.values[index] ?? -Infinity)) best = file;
-      }
-      if (best) return best.index;
-    }
+function renderFindings(model) {
+  const chips = [];
+  if (model.hotspotCount > 0) {
+    chips.push(
+      `<button type="button" class="finding" data-focus="hotspot"><i class="dot info"></i><b>${formatInt(
+        model.hotspotCount
+      )}</b> hotspots</button>`
+    );
   }
-  if (lens === "structure") {
-    return files.reduce(
-      (best, file) => file.actualArea > best.actualArea ? file : best
-    ).index;
+  if (model.cycles.length > 0) {
+    chips.push(
+      `<button type="button" class="finding" data-focus="cycle"><i class="dot warn"></i><b>${formatInt(
+        model.cycles.length
+      )}</b> aristas c\xEDclicas</button>`
+    );
   }
-  return files.reduce((best, file) => file.risk > best.risk ? file : best).index;
-}
-
-// packages/render/src/html.ts
-import { readFileSync } from "node:fs";
-
-// packages/render/src/color.ts
-var RISK_STOPS = [
-  [0, "#ebe7df"],
-  [0.35, "#e9cd98"],
-  [0.65, "#d68a54"],
-  [1, "#a42e2c"]
-];
-var METRIC_STOPS = [
-  [0, "#ebe7df"],
-  [0.5, "#b9c9cf"],
-  [1, "#355b6b"]
-];
-var RISK_GRADIENT = "linear-gradient(90deg, #ebe7df 0%, #e9cd98 35%, #d68a54 65%, #a42e2c 100%)";
-var METRIC_GRADIENT = "linear-gradient(90deg, #ebe7df 0%, #b9c9cf 50%, #355b6b 100%)";
-function clamp012(value) {
-  if (!Number.isFinite(value)) return 0;
-  return Math.max(0, Math.min(1, value));
-}
-function hexToRgb(hex) {
-  const value = hex.replace("#", "");
-  return [
-    Number.parseInt(value.slice(0, 2), 16),
-    Number.parseInt(value.slice(2, 4), 16),
-    Number.parseInt(value.slice(4, 6), 16)
-  ];
-}
-function rgbToHex(rgb) {
-  return `#${rgb.map((channel) => channel.toString(16).padStart(2, "0")).join("")}`;
+  chips.push(
+    `<span class="finding static"><i class="dot neutral"></i><b>${formatInt(
+      model.fileCount
+    )}</b> ficheros</span>`
+  );
+  chips.push(
+    `<span class="finding static"><i class="dot neutral"></i><b>${formatInt(
+      model.edges.length
+    )}</b> dependencias</span>`
+  );
+  return `${chips.join("")}<span class="spacer"></span><span id="search-status" class="search-status" aria-live="polite"></span><span class="run-meta">${escapeHtml(
+    model.areaTitle
+  )} \xB7 ${formatInt(model.metrics.length)} m\xE9tricas \xB7 cc.json ${escapeHtml(
+    model.meta.apiVersion
+  )}</span>`;
 }
-function mix(a, b, t) {
-  const from = hexToRgb(a);
-  const to = hexToRgb(b);
-  return rgbToHex([
-    Math.round(from[0] + (to[0] - from[0]) * t),
-    Math.round(from[1] + (to[1] - from[1]) * t),
-    Math.round(from[2] + (to[2] - from[2]) * t)
-  ]);
+function metricByKey(model, key) {
+  return key ? model.metrics.find((metric) => metric.key === key) : void 0;
 }
-function ramp(stops, t) {
-  const value = clamp012(t);
-  for (let index = 0; index < stops.length - 1; index++) {
-    const from = stops[index];
-    const to = stops[index + 1];
-    if (value <= to[0]) {
-      const span2 = to[0] - from[0] || 1;
-      return mix(from[1], to[1], (value - from[0]) / span2);
+function renderLegend(model) {
+  if (model.initialLens === "structure") {
+    const items = model.sections.slice(0, 6).map(
+      (section) => `<span><i style="background:${section.color}"></i>${escapeHtml(section.key)}</span>`
+    ).join("");
+    return `<span>Carpeta</span><span class="sws">${items}</span>`;
+  }
+  if (model.initialLens === "metric" && model.initialMetric) {
+    const metric = metricByKey(model, model.initialMetric);
+    if (metric) {
+      const direction = metric.direction === -1 ? " \xB7 menos es mejor" : metric.direction === 1 ? " \xB7 m\xE1s es mejor" : "";
+      return `<span>${escapeHtml(metric.title)}${direction}</span><span class="mono">${escapeHtml(
+        formatCompact(metric.min)
+      )}</span><span class="bar" style="background:${METRIC_GRADIENT}"></span><span class="mono">${escapeHtml(
+        formatCompact(metric.max)
+      )}</span>`;
     }
   }
-  return stops[stops.length - 1][1];
+  return `<span>Riesgo (0\u2013100)</span><span class="mono">0</span><span class="bar" style="background:${RISK_GRADIENT}"></span><span class="mono">100</span>`;
 }
-function riskColor(risk) {
-  return ramp(RISK_STOPS, risk);
+function renderMetricOptions(model) {
+  return model.metrics.map(
+    (metric) => `<option value="${escapeAttr(metric.key)}"${metric.key === model.initialMetric ? " selected" : ""}>${escapeHtml(metric.title)}</option>`
+  ).join("");
 }
-function metricColor(value, metric) {
-  if (value === null) return METRIC_STOPS[0][1];
-  let t;
-  if (metric.mode === "log") {
-    const span2 = Math.max(1e-9, metric.max - metric.min);
-    t = Math.log1p(Math.max(0, value - metric.min)) / Math.log1p(span2);
-  } else {
-    const span2 = metric.max - metric.min;
-    t = span2 > 0 ? (value - metric.min) / span2 : 0;
+function renderInspectorSummary(model) {
+  const hotspots = [...model.files].sort((a, b) => b.risk - a.risk || a.path.localeCompare(b.path)).slice(0, 5);
+  return `<div class="summary">
+  <div class="sub">Proyecto</div>
+  <div class="big">${formatInt(model.fileCount)}</div>
+  <div class="sub">ficheros \xB7 ${formatInt(model.folderCount)} carpetas</div>
+  <p>${formatInt(model.totalArea)} de ${escapeHtml(
+    model.areaTitle.toLowerCase()
+  )} \xB7 ${formatInt(model.metrics.length)} m\xE9tricas \xB7 ${formatInt(
+    model.hotspotCount
+  )} hotspots.</p>
+  <h4>Mayor riesgo</h4>
+  <ul class="deps">${hotspots.map(
+    (file) => `<li data-file="${file.index}"><i class="sw" style="background:${riskColor(
+      file.risk
+    )}"></i><span>${escapeHtml(file.path)}</span><em>${Math.round(
+      file.risk * 100
+    )}</em></li>`
+  ).join("")}</ul>
+  <p>Selecciona un bloque para ver sus m\xE9tricas y sus dependencias. Clic en la cabecera de una carpeta para enfocarla.</p>
+</div>`;
+}
+function renderHtml(model) {
+  const project = escapeHtml(model.meta.project);
+  const title = escapeHtml(model.meta.title);
+  const commit = model.meta.commit ? model.meta.commit.slice(0, 7) : "";
+  const checksum = model.meta.checksum ? model.meta.checksum.slice(0, 8) : "";
+  const badge = commit || checksum || `cc.json ${model.meta.apiVersion}`;
+  const payload = jsonForScript(serialise(model));
+  const metricPicker = model.metrics.length > 0 ? `<label class="metric-pick" id="metric-pick"${model.initialLens === "metric" ? "" : " hidden"}><span>M\xE9trica</span><select id="metric-select">${renderMetricOptions(
+    model
+  )}</select></label>` : "";
+  const crumbs = model.meta.rootName ? `${project} <span class="sep">/</span> ${escapeHtml(model.meta.rootName)}` : project;
+  return `<!doctype html>
+<html lang="es">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="color-scheme" content="light">
+<meta name="generator" content="CodArch">
+<title>CodArch \xB7 ${title}</title>
+<style>${STYLES}</style>
+</head>
+<body>
+<div class="app">
+  <header>
+    <div class="brand">CodArch</div>
+    <div class="repo">
+      <b>${title}</b>
+      ${model.meta.rootName && model.meta.rootName !== model.meta.project ? `<span>${escapeHtml(model.meta.rootName)}</span>` : ""}
+      <span class="commit">${escapeHtml(badge)}</span>
+    </div>
+    <div class="spacer"></div>
+    <nav class="lenses" role="tablist" aria-label="Lentes">${renderLensButtons(model)}</nav>
+    ${metricPicker}
+    <label class="search">
+      <svg width="12" height="12" viewBox="0 0 16 16" fill="none" aria-hidden="true">
+        <circle cx="7" cy="7" r="4.5" stroke="#8d877d" stroke-width="1.4"/>
+        <path d="M10.5 10.5 14 14" stroke="#8d877d" stroke-width="1.4"/>
+      </svg>
+      <input id="q" type="search" placeholder="Buscar fichero\u2026" autocomplete="off" aria-label="Buscar fichero">
+    </label>
+  </header>
+
+  <div class="findings">${renderFindings(model)}</div>
+
+  <main class="map-wrap">
+    <div class="map" id="map">${renderSvg(model)}</div>
+    <div class="tooltip" id="tooltip"></div>
+  </main>
+
+  <aside id="inspector">${renderInspectorSummary(model)}</aside>
+
+  <footer>
+    <span class="crumbs" id="crumbs">${crumbs}</span>
+    <span class="hint">clic para fijar \xB7 esc para limpiar</span>
+    <span class="legend" id="legend">${renderLegend(model)}</span>
+  </footer>
+</div>
+<script id="codarch-data" type="application/json">${payload}</script>
+<script>${CLIENT}</script>
+</body>
+</html>`;
+}
+
+// apps/cli/src/io.ts
+import fs5 from "node:fs";
+import zlib from "node:zlib";
+function readJsonFile2(file) {
+  const buffer = fs5.readFileSync(file);
+  const isGzip = buffer.length > 2 && buffer[0] === 31 && buffer[1] === 139;
+  const raw = isGzip ? zlib.gunzipSync(buffer) : buffer;
+  const text = raw.toString("utf8");
+  try {
+    return { json: JSON.parse(text), bytes: buffer.length };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`no es JSON v\xE1lido: ${message}`);
   }
-  return ramp(METRIC_STOPS, t);
-}
-function inkFor(color) {
-  const [r, g, b] = hexToRgb(color);
-  const luminance = (0.2126 * r + 0.7152 * g + 0.0722 * b) / 255;
-  return luminance > 0.52 ? "#1a1a1a" : "#f7f5f1";
 }
-function colorForFile(lens, risk, section, value, metric) {
-  if (lens === "structure") return section?.color ?? "#ddd8cf";
-  if (lens === "risk" || !metric) return riskColor(risk);
-  return metricColor(value, metric);
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
 
-// packages/layouts/src/squarify.ts
-function squarify(items, rect) {
-  if (rect.w <= 0 || rect.h <= 0) return [];
-  const usable = items.filter(
-    (item) => Number.isFinite(item.value) && item.value > 0
-  );
-  const total = usable.reduce((sum, item) => sum + item.value, 0);
-  if (usable.length === 0 || total <= 0) return [];
-  const sorted = usable.map((item, index2) => ({ item, index: index2 })).sort((a, b) => b.item.value - a.item.value || a.index - b.index).map(({ item }) => item);
-  const scale = rect.w * rect.h / total;
-  const placed = [];
-  let x = rect.x;
-  let y = rect.y;
-  let w = rect.w;
-  let h = rect.h;
-  let row = [];
-  const area = (item) => item.value * scale;
-  function worst(candidate, side) {
-    let sum = 0;
-    let max = -Infinity;
-    let min = Infinity;
-    for (const item of candidate) {
-      const value = area(item);
-      sum += value;
-      if (value > max) max = value;
-      if (value < min) min = value;
+// apps/cli/src/commands/analyze.ts
+var numberFormat = new Intl.NumberFormat("es-ES");
+function num(value) {
+  return numberFormat.format(value);
+}
+function field(label, value) {
+  return `  ${label.padEnd(12)} ${value}`;
+}
+function runAnalyze(options) {
+  const root = options.root ?? ".";
+  let result;
+  try {
+    result = analyzeRepository(root, {
+      ignore: options.ignore,
+      projectName: options.projectName,
+      git: options.git
+    });
+  } catch (error) {
+    console.error(`no se pudo analizar ${root}: ${error.message}`);
+    return 1;
+  }
+  let cc;
+  try {
+    cc = parseCcJson(result.snapshot);
+  } catch (error) {
+    if (error instanceof CcJsonError) {
+      console.error(`el snapshot generado no es cc.json v\xE1lido: ${error.message}`);
+      return 1;
     }
-    if (sum <= 0 || side <= 0) return Infinity;
-    return Math.max(
-      side * side * max / (sum * sum),
-      sum * sum / (side * side * min)
+    throw error;
+  }
+  const outDirectory = path5.resolve(
+    options.out ?? path5.join(path5.resolve(root), ".codarch")
+  );
+  const snapshotPath = path5.join(outDirectory, "snapshot.cc.json");
+  const mapPath = path5.join(outDirectory, "map.html");
+  try {
+    fs6.mkdirSync(outDirectory, { recursive: true });
+    fs6.writeFileSync(
+      snapshotPath,
+      `${JSON.stringify(cc, null, 2)}
+`,
+      "utf8"
     );
+  } catch (error) {
+    console.error(
+      `no se pudo escribir ${snapshotPath}: ${error.message}`
+    );
+    return 1;
   }
-  function place(current, horizontal) {
-    if (current.length === 0) return;
-    const sum = current.reduce((acc, item) => acc + area(item), 0);
-    if (sum <= 0) return;
-    if (horizontal) {
-      if (w <= 0) return;
-      const thickness = sum / w;
-      if (!Number.isFinite(thickness) || thickness <= 0) return;
-      let position = x;
-      for (const item of current) {
-        const length = area(item) / thickness;
-        placed.push({ item, x: position, y, w: length, h: thickness });
-        position += length;
-      }
-      y += thickness;
-      h -= thickness;
-    } else {
-      if (h <= 0) return;
-      const thickness = sum / h;
-      if (!Number.isFinite(thickness) || thickness <= 0) return;
-      let position = y;
-      for (const item of current) {
-        const length = area(item) / thickness;
-        placed.push({ item, x, y: position, w: thickness, h: length });
-        position += length;
-      }
-      x += thickness;
-      w -= thickness;
+  let mapBytes = 0;
+  let mapError = null;
+  if (result.files > 0) {
+    try {
+      const model = buildRenderModel(cc, {
+        areaMetric: "rloc",
+        color: "risk",
+        title: options.title
+      });
+      const html = renderHtml(model);
+      fs6.writeFileSync(mapPath, html, "utf8");
+      mapBytes = Buffer.byteLength(html, "utf8");
+    } catch (error) {
+      mapError = error instanceof RenderError ? error.message : error.message;
     }
+  } else {
+    mapError = "no hay ficheros TypeScript/JavaScript que dibujar";
   }
-  let index = 0;
-  while (index < sorted.length) {
-    const horizontal = w >= h;
-    const side = horizontal ? w : h;
-    const next = sorted[index];
-    if (row.length === 0) {
-      row.push(next);
-      index++;
-      continue;
-    }
-    if (worst([...row, next], side) <= worst(row, side)) {
-      row.push(next);
-      index++;
-    } else {
-      place(row, horizontal);
-      row = [];
-    }
+  const snapshotBytes = Buffer.byteLength(
+    fs6.readFileSync(snapshotPath),
+    "utf8"
+  );
+  const lines = [];
+  lines.push("");
+  lines.push("  CodArch \xB7 an\xE1lisis");
+  lines.push("");
+  lines.push(field("ra\xEDz", path5.resolve(root)));
+  lines.push(field("snapshot", `${snapshotPath} (${formatBytes(snapshotBytes)})`));
+  if (mapError) {
+    lines.push(field("mapa", `omitido (${mapError})`));
+  } else {
+    lines.push(field("mapa", `${mapPath} (${formatBytes(mapBytes)})`));
   }
-  if (row.length > 0) place(row, w >= h);
-  return placed;
-}
-
-// packages/render/src/layout.ts
-var VIEW_WIDTH = 1400;
-var VIEW_HEIGHT = 900;
-var VIEW_PADDING = 8;
-var MAX_DEPTH3 = 12;
-function layoutMap(roots) {
-  const rect = {
-    x: VIEW_PADDING,
-    y: VIEW_PADDING,
-    w: VIEW_WIDTH - VIEW_PADDING * 2,
-    h: VIEW_HEIGHT - VIEW_PADDING * 2
-  };
-  return layoutChildren(roots, rect, 0);
-}
-function layoutChildren(nodes, rect, depth) {
-  if (nodes.length === 0 || rect.w < 2 || rect.h < 2) return [];
-  const items = nodes.map((node) => ({
-    key: node.key,
-    value: Math.max(1, node.value),
-    node
-  }));
-  return squarify(items, rect).map(
-    (placed) => layoutNode(placed.item.node, {
-      x: placed.x,
-      y: placed.y,
-      w: placed.w,
-      h: placed.h
-    }, depth)
+  lines.push(
+    field(
+      "estructura",
+      `${num(result.files)} ficheros \xB7 ${num(result.folders)} carpetas \xB7 ${num(
+        result.edges
+      )} aristas \xB7 ${num(result.cycles.length)} ciclos`
+    )
   );
-}
-function layoutNode(node, rect, depth) {
-  if (node.kind === "file" || !node.children || node.children.length === 0) {
-    return { node, rect, headerHeight: 0, children: [] };
+  lines.push(
+    field(
+      "imports",
+      `${num(result.externalImports)} externos \xB7 ${num(
+        result.builtinImports
+      )} builtins \xB7 ${num(result.typeOnlyImports)} type-only \xB7 ${num(
+        result.unresolvedImports
+      )} sin resolver`
+    )
+  );
+  const migrationLanguages = Object.entries(result.migration.languages).map(([language, stats]) => `${language} ${num(stats?.rloc ?? 0)}`).join(" \xB7 ");
+  lines.push(
+    field(
+      "migraci\xF3n",
+      `${migrationLanguages || "\u2014"} \xB7 ${num(
+        result.migration.bridgeFiles
+      )} puentes \xB7 ${num(result.migration.ffiEdges)} FFI \xB7 deuda ${num(
+        result.migration.migrationDebt
+      )}`
+    )
+  );
+  lines.push(field("tiempo", `${num(result.durationMs)} ms`));
+  lines.push(
+    field(
+      "historial",
+      result.git.enabled ? `${num(result.git.commits)} commits \xB7 ${num(
+        result.git.authors
+      )} autores${result.git.shallow ? " \xB7 shallow" : ""}` : "sin git; se omite churn"
+    )
+  );
+  for (const warning of result.warnings.slice(0, 10)) {
+    lines.push(field("aviso", warning));
   }
-  let headerHeight = 0;
-  if (rect.w >= 30 && rect.h >= 32) {
-    headerHeight = rect.h >= 62 ? 17 : 13;
+  if (result.warnings.length > 10) {
+    lines.push(field("aviso", `y ${num(result.warnings.length - 10)} m\xE1s`));
+  }
+  for (const issue of result.unresolved.slice(0, 5)) {
+    lines.push(
+      field(
+        "sin resolver",
+        `${issue.file}:${issue.line} ${issue.specifier} (${issue.reason})`
+      )
+    );
+  }
+  if (result.unresolved.length > 5) {
+    lines.push(
+      field("sin resolver", `y ${num(result.unresolved.length - 5)} m\xE1s`)
+    );
   }
-  const inner = {
-    x: rect.x + 1,
-    y: rect.y + headerHeight + 1,
-    w: Math.max(0, rect.w - 2),
-    h: Math.max(0, rect.h - headerHeight - 2)
-  };
-  const children = depth < MAX_DEPTH3 && inner.w >= 1 && inner.h >= 1 ? layoutChildren(node.children, inner, depth + 1) : [];
-  return { node, rect, headerHeight, children };
+  lines.push("");
+  console.log(lines.join("\n"));
+  return 0;
 }
 
-// packages/render/src/svg.ts
-function escapeHtml(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
-}
-function escapeAttr(value) {
-  return escapeHtml(value);
-}
-function formatInt(value) {
-  if (!Number.isFinite(value)) return "\u2014";
-  return Math.round(value).toString().replace(/\B(?=(\d{3})+(?!\d))/g, ".");
-}
-function formatCompact(value) {
-  if (!Number.isFinite(value)) return "\u2014";
-  const absolute = Math.abs(value);
-  if (absolute >= 1e6) {
-    return `${(value / 1e6).toFixed(1).replace(".0", "").replace(".", ",")}M`;
+// apps/cli/src/commands/diff.ts
+import fs8 from "node:fs";
+import path6 from "node:path";
+
+// packages/metrics/src/config.ts
+import fs7 from "node:fs";
+import { parse as parseYaml } from "yaml";
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
   }
-  if (absolute >= 1e3) {
-    return `${(value / 1e3).toFixed(1).replace(".0", "").replace(".", ",")}k`;
+};
+var SEVERITIES = /* @__PURE__ */ new Set(["info", "warn", "error"]);
+function parseRuleConfig(input) {
+  const root = asObject(input, "config");
+  if (root.version !== 1) {
+    throw new ConfigError("config.version debe ser 1");
   }
-  return formatInt(value);
-}
-function coord(value) {
-  const rounded = Math.round(value);
-  return Object.is(rounded, -0) ? "0" : String(rounded);
-}
-function span(value) {
-  return String(Math.max(1, Math.round(value)));
+  const layers = parseLayers(root.layers);
+  const layerNames = new Set(layers.map((layer) => layer.name));
+  const rules = parseRules(root.rules, layerNames);
+  return { version: 1, layers, rules };
 }
-function truncate(value, maxWidth, fontSize) {
-  const maxChars = Math.floor(maxWidth / (fontSize * 0.56));
-  if (maxChars <= 0) return "";
-  if (value.length <= maxChars) return value;
-  if (maxChars === 1) return "\u2026";
-  return `${value.slice(0, maxChars - 1)}\u2026`;
+function loadRuleConfig(file) {
+  let text;
+  try {
+    text = fs7.readFileSync(file, "utf8");
+  } catch (error) {
+    throw new ConfigError(
+      `no se pudo leer ${file}: ${error.message}`
+    );
+  }
+  let value;
+  try {
+    value = parseYaml(text);
+  } catch (error) {
+    throw new ConfigError(
+      `YAML inv\xE1lido en ${file}: ${error.message}`
+    );
+  }
+  try {
+    return parseRuleConfig(value);
+  } catch (error) {
+    if (error instanceof ConfigError) {
+      throw new ConfigError(`${file}: ${error.message}`);
+    }
+    throw error;
+  }
 }
-function labelFor(nodeName, rect, out, ink) {
-  if (rect.w < 44 || rect.h < 13) return;
-  const available = rect.w - 8;
-  const dot = nodeName.lastIndexOf(".");
-  const twoLines = rect.h >= 27 && rect.w >= 64 && dot > 0 && dot < nodeName.length - 1;
-  if (twoLines) {
-    const base = truncate(nodeName.slice(0, dot), available, 12.5);
-    const extension = truncate(nodeName.slice(dot), available, 10);
-    if (base) {
-      out.push(
-        `<text class="a" x="${coord(rect.x + 4)}" y="${coord(rect.y + 12)}" fill="${ink}">${escapeHtml(base)}</text>`
+function parseLayers(value) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) {
+    throw new ConfigError("config.layers debe ser una lista");
+  }
+  const layers = [];
+  const names = /* @__PURE__ */ new Set();
+  value.forEach((raw, index) => {
+    const layer = asObject(raw, `config.layers[${index}]`);
+    const name = asString(layer.name, `config.layers[${index}].name`);
+    if (names.has(name)) {
+      throw new ConfigError(`capa duplicada: ${name}`);
+    }
+    names.add(name);
+    if (layer.patterns !== void 0 && layer.paths !== void 0) {
+      throw new ConfigError(
+        `config.layers[${index}] no puede tener patterns y paths a la vez`
       );
     }
-    if (extension) {
-      out.push(
-        `<text class="b" x="${coord(rect.x + 4)}" y="${coord(rect.y + 22.5)}" fill="${ink}">${escapeHtml(extension)}</text>`
+    const rawPatterns = layer.patterns ?? layer.paths;
+    if (!Array.isArray(rawPatterns) || rawPatterns.length === 0) {
+      throw new ConfigError(
+        `config.layers[${index}].patterns debe ser una lista no vac\xEDa`
       );
     }
-    return;
-  }
-  const label = truncate(nodeName, available, 12.5);
-  if (!label) return;
-  out.push(
-    `<text class="a" x="${coord(rect.x + 4)}" y="${coord(rect.y + 13)}" fill="${ink}">${escapeHtml(label)}</text>`
-  );
+    const patterns = rawPatterns.map((rawPattern, patternIndex) => {
+      const pattern = asString(
+        rawPattern,
+        `config.layers[${index}].patterns[${patternIndex}]`
+      ).replaceAll("\\", "/").replace(/^\.\//, "");
+      if (pattern.startsWith("/") || /^[A-Za-z]:\//.test(pattern)) {
+        throw new ConfigError(
+          `el patr\xF3n "${pattern}" debe ser relativo al root del proyecto`
+        );
+      }
+      return pattern;
+    });
+    layers.push({ name, patterns });
+  });
+  return layers;
 }
-function renderPlaced(placed, out, model, metricIndex, metric) {
-  const node = placed.node;
-  const rect = placed.rect;
-  if (node.kind === "file") {
-    const index = node.fileIndex;
-    if (index === void 0) return;
-    const file = model.files[index];
-    if (!file) return;
-    const value = metricIndex >= 0 ? file.values[metricIndex] ?? null : null;
-    const fill = colorForFile(
-      model.initialLens,
-      file.risk,
-      model.sections[file.section],
-      value,
-      metric
+function parseRules(value, layerNames) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) {
+    throw new ConfigError("config.rules debe ser una lista");
+  }
+  const rules = [];
+  const names = /* @__PURE__ */ new Set();
+  value.forEach((raw, index) => {
+    const rule = asObject(raw, `config.rules[${index}]`);
+    const name = asString(rule.name, `config.rules[${index}].name`);
+    if (names.has(name)) {
+      throw new ConfigError(`regla duplicada: ${name}`);
+    }
+    names.add(name);
+    const type = asString(rule.type, `config.rules[${index}].type`);
+    const severity = parseSeverity(
+      rule.severity,
+      `config.rules[${index}].severity`
     );
-    const ink = inkFor(fill);
-    out.push(
-      `<rect data-i="${index}" x="${coord(rect.x)}" y="${coord(rect.y)}" width="${span(rect.w)}" height="${span(rect.h)}" fill="${fill}"/>`
+    const message = rule.message === void 0 ? void 0 : asString(rule.message, `config.rules[${index}].message`);
+    if (type === "forbidden") {
+      const from = asString(rule.from, `config.rules[${index}].from`);
+      const to = asString(rule.to, `config.rules[${index}].to`);
+      if (!layerNames.has(from)) {
+        throw new ConfigError(
+          `config.rules[${index}].from apunta a una capa inexistente: ${from}`
+        );
+      }
+      if (!layerNames.has(to)) {
+        throw new ConfigError(
+          `config.rules[${index}].to apunta a una capa inexistente: ${to}`
+        );
+      }
+      rules.push({ type, name, from, to, severity, message });
+      return;
+    }
+    if (type === "threshold") {
+      const metric = asString(
+        rule.metric,
+        `config.rules[${index}].metric`
+      );
+      const min = optionalNumber(rule.min, `config.rules[${index}].min`);
+      const max = optionalNumber(rule.max, `config.rules[${index}].max`);
+      if (min === void 0 && max === void 0) {
+        throw new ConfigError(
+          `config.rules[${index}] necesita min o max`
+        );
+      }
+      if (min !== void 0 && max !== void 0 && min > max) {
+        throw new ConfigError(
+          `config.rules[${index}]: min no puede ser mayor que max`
+        );
+      }
+      rules.push({ type, name, metric, min, max, severity, message });
+      return;
+    }
+    if (type === "cycles") {
+      rules.push({ type, name, severity, message });
+      return;
+    }
+    throw new ConfigError(
+      `config.rules[${index}].type desconocido: ${type}`
     );
-    labelFor(file.name, rect, out, ink);
-    return;
+  });
+  return rules;
+}
+function parseSeverity(value, path9) {
+  if (value === void 0) return "error";
+  if (typeof value !== "string" || !SEVERITIES.has(value)) {
+    throw new ConfigError(`${path9} debe ser info, warn o error`);
   }
-  const folder = node;
-  out.push(
-    `<g class="folder" data-nm="${escapeAttr(folder.name)}" data-n="${folder.fileCount}" data-a="${coord(folder.value)}">`
+  return value;
+}
+function optionalNumber(value, path9) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new ConfigError(`${path9} debe ser un n\xFAmero`);
+  }
+  return value;
+}
+function asObject(value, path9) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new ConfigError(`${path9} debe ser un objeto`);
+  }
+  return value;
+}
+function asString(value, path9) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new ConfigError(`${path9} debe ser un texto no vac\xEDo`);
+  }
+  return value.trim();
+}
+
+// packages/metrics/src/rules.ts
+import { minimatch } from "minimatch";
+function emptyRuleReport() {
+  return {
+    configured: false,
+    summary: {
+      layers: 0,
+      rules: 0,
+      introduced: 0,
+      existing: 0,
+      resolved: 0,
+      introducedErrors: 0,
+      introducedWarnings: 0
+    },
+    violations: { introduced: [], existing: [], resolved: [] }
+  };
+}
+function evaluateRules(base, head, config) {
+  const baseViolations = evaluateInput(base, config);
+  const headViolations = evaluateInput(head, config);
+  const baseByKey = new Map(
+    baseViolations.map((violation) => [violation.key, violation])
   );
-  out.push(
-    `<rect class="fr" x="${coord(rect.x)}" y="${coord(rect.y)}" width="${span(rect.w)}" height="${span(rect.h)}"/>`
+  const headByKey = new Map(
+    headViolations.map((violation) => [violation.key, violation])
   );
-  if (placed.headerHeight >= 13 && rect.w >= 30) {
-    const headerHeight = placed.headerHeight;
-    out.push(
-      `<rect class="fh" x="${coord(rect.x + 1)}" y="${coord(rect.y + 1)}" width="${span(rect.w - 2)}" height="${span(headerHeight - 1)}"/>`
-    );
-    const count = formatCompact(folder.value);
-    const showCount = rect.w >= 86;
-    const countWidth = showCount ? count.length * 5.8 + 12 : 0;
-    const name = truncate(folder.name, Math.max(8, rect.w - 12 - countWidth), 11.5);
-    if (name) {
-      out.push(
-        `<text class="ft" x="${coord(rect.x + 6)}" y="${coord(rect.y + headerHeight / 2 + 4)}">${escapeHtml(name)}</text>`
-      );
+  const introduced = [];
+  const existing = [];
+  const resolved = [];
+  for (const [key, violation] of headByKey) {
+    if (baseByKey.has(key)) existing.push(violation);
+    else introduced.push(violation);
+  }
+  for (const [key, violation] of baseByKey) {
+    if (!headByKey.has(key)) resolved.push(violation);
+  }
+  introduced.sort(compareViolations);
+  existing.sort(compareViolations);
+  resolved.sort(compareViolations);
+  return {
+    configured: true,
+    summary: {
+      layers: config.layers.length,
+      rules: config.rules.length,
+      introduced: introduced.length,
+      existing: existing.length,
+      resolved: resolved.length,
+      introducedErrors: introduced.filter(
+        (violation) => violation.severity === "error"
+      ).length,
+      introducedWarnings: introduced.filter(
+        (violation) => violation.severity === "warn"
+      ).length
+    },
+    violations: { introduced, existing, resolved }
+  };
+}
+function evaluateInput(input, config) {
+  const layers = layerIndex(input.files, config.layers);
+  const violations = [];
+  for (const rule of config.rules) {
+    if (rule.type === "forbidden") {
+      evaluateForbidden(rule, input, layers, violations);
+    } else if (rule.type === "threshold") {
+      evaluateThreshold(rule, input, violations);
+    } else {
+      evaluateCycles(rule, input.cycles, violations);
     }
-    if (showCount) {
-      out.push(
-        `<text class="fn" x="${coord(rect.x + rect.w - 6)}" y="${coord(rect.y + headerHeight / 2 + 3.6)}">${escapeHtml(count)}</text>`
-      );
+  }
+  const byKey = /* @__PURE__ */ new Map();
+  for (const violation of violations) byKey.set(violation.key, violation);
+  return [...byKey.values()].sort(compareViolations);
+}
+function layerIndex(files, layers) {
+  const index = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    for (const layer of layers) {
+      if (layer.patterns.some(
+        (pattern) => minimatch(file.path, pattern, { dot: true })
+      )) {
+        index.set(file.id, layer.name);
+        break;
+      }
     }
   }
-  for (const child of placed.children) {
-    renderPlaced(child, out, model, metricIndex, metric);
+  return index;
+}
+function evaluateForbidden(rule, input, layers, violations) {
+  for (const edge of input.edges) {
+    if (layers.get(edge.fromId) !== rule.from) continue;
+    if (layers.get(edge.toId) !== rule.to) continue;
+    violations.push({
+      key: `forbidden:${rule.name}:${edge.fromId}->${edge.toId}`,
+      rule: rule.name,
+      type: "forbidden",
+      severity: rule.severity,
+      message: rule.message ?? `${edge.from} no puede depender de ${edge.to}`,
+      files: [edge.from, edge.to],
+      edge: {
+        fromId: edge.fromId,
+        toId: edge.toId,
+        from: edge.from,
+        to: edge.to
+      }
+    });
   }
-  out.push("</g>");
 }
-function renderSvg(model) {
-  const metricIndex = model.initialMetric ? model.metrics.findIndex((metric2) => metric2.key === model.initialMetric) : -1;
-  const metric = metricIndex >= 0 ? model.metrics[metricIndex] : void 0;
-  const out = [];
-  out.push(
-    `<svg id="map" viewBox="0 0 ${VIEW_WIDTH} ${VIEW_HEIGHT}" preserveAspectRatio="xMidYMid meet" role="img" aria-label="Mapa de arquitectura de ${escapeAttr(model.meta.project)}">`
-  );
-  out.push(
-    `<rect class="canvas" x="0" y="0" width="${VIEW_WIDTH}" height="${VIEW_HEIGHT}"/>`
-  );
-  out.push(`<g id="cells">`);
-  for (const placed of layoutMap(model.roots)) {
-    renderPlaced(placed, out, model, metricIndex, metric);
+function evaluateThreshold(rule, input, violations) {
+  for (const file of input.files) {
+    const value = file.metrics[rule.metric];
+    if (typeof value !== "number" || !Number.isFinite(value)) continue;
+    const tooHigh = rule.max !== void 0 && value > rule.max;
+    const tooLow = rule.min !== void 0 && value < rule.min;
+    if (!tooHigh && !tooLow) continue;
+    const limit = tooHigh && rule.max !== void 0 ? `m\xE1ximo ${rule.max}` : `m\xEDnimo ${rule.min}`;
+    violations.push({
+      key: `threshold:${rule.name}:${file.id}`,
+      rule: rule.name,
+      type: "threshold",
+      severity: rule.severity,
+      message: rule.message ?? `${file.path}: ${rule.metric} = ${value} (${limit})`,
+      files: [file.path],
+      metric: {
+        name: rule.metric,
+        value,
+        ...rule.min !== void 0 ? { min: rule.min } : {},
+        ...rule.max !== void 0 ? { max: rule.max } : {}
+      }
+    });
   }
-  out.push(`</g><g id="edges"></g></svg>`);
-  return out.join("");
 }
-
-// packages/render/src/html.ts
-var STYLES = readFileSync(new URL("./styles.css", import.meta.url), "utf8");
-var CLIENT = readFileSync(new URL("./client.js", import.meta.url), "utf8").replace(
-  /<\/script/gi,
-  "<\\/script"
-);
-function round(value, digits = 2) {
-  const factor = 10 ** digits;
-  return Math.round(value * factor) / factor;
+function evaluateCycles(rule, cycles, violations) {
+  for (const cycle of cycles) {
+    const paths = cycle.nodes.map((node) => node.path);
+    violations.push({
+      key: `cycles:${rule.name}:${cycle.nodes.map((node) => node.id).sort().join("|")}`,
+      rule: rule.name,
+      type: "cycles",
+      severity: rule.severity,
+      message: rule.message ?? cycleMessage(paths),
+      files: paths,
+      cycle: {
+        size: cycle.size,
+        nodes: cycle.nodes.map((node) => ({ ...node }))
+      }
+    });
+  }
 }
-function jsonForScript(value) {
-  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+function cycleMessage(paths) {
+  const visible = paths.slice(0, 6);
+  const suffix = paths.length > visible.length ? " \u2192 \u2026" : "";
+  return `Ciclo de ${paths.length} ficheros: ${visible.join(" \u2192 ")}${suffix}`;
 }
-function serialise(model) {
-  const directoryIndex = /* @__PURE__ */ new Map();
-  const directories = [];
-  const fileRows = model.files.map((file) => {
-    const slash = file.path.lastIndexOf("/");
-    const directory = slash >= 0 ? file.path.slice(0, slash) : "";
-    let dirIndex = -1;
-    if (directory) {
-      const known = directoryIndex.get(directory);
-      if (known === void 0) {
-        dirIndex = directories.length;
-        directoryIndex.set(directory, dirIndex);
-        directories.push(directory);
-      } else {
-        dirIndex = known;
-      }
-    }
-    const name = slash >= 0 ? file.path.slice(slash + 1) : file.path;
-    return [
-      dirIndex,
-      name,
-      file.section,
-      round(file.area, 1),
-      round(file.actualArea, 1),
-      round(file.risk, 4),
-      round(file.complexity, 1),
-      round(file.churn, 1),
-      ...file.values.map((value) => value === null ? null : round(value, 2))
-    ];
-  });
-  return {
-    v: 1,
-    meta: {
-      project: model.meta.project,
-      commit: model.meta.commit,
-      checksum: model.meta.checksum,
-      api: model.meta.apiVersion,
-      root: model.meta.rootName
-    },
-    area: {
-      key: model.areaMetric,
-      title: model.areaTitle,
-      total: round(model.totalArea, 1)
-    },
-    lens: model.initialLens,
-    metric: model.initialMetric,
-    metrics: model.metrics.map((metric) => ({
-      key: metric.key,
-      title: metric.title,
-      min: round(metric.min, 2),
-      max: round(metric.max, 2),
-      mode: metric.mode,
-      dir: metric.direction,
-      coverage: metric.coverage
-    })),
-    sections: model.sections.map((section) => ({
-      key: section.key,
-      color: section.color,
-      files: section.files,
-      area: round(section.area, 1)
-    })),
-    dirs: directories,
-    files: fileRows,
-    edges: model.edges.flatMap((edge) => [edge.from, edge.to]),
-    cycles: model.cycles.flatMap((edge) => [edge.from, edge.to]),
-    hot: model.hotspotCount,
-    default: model.defaultSelection,
-    fileCount: model.fileCount,
-    folderCount: model.folderCount,
-    totalArea: round(model.totalArea, 1)
-  };
+function compareViolations(left, right) {
+  return compareStrings4(left.key, right.key);
 }
-function renderLensButtons(model) {
-  const lenses = [
-    { id: "structure", label: "Estructura" },
-    { id: "risk", label: "Riesgo" }
-  ];
-  if (model.metrics.length > 0) lenses.push({ id: "metric", label: "M\xE9trica" });
-  return lenses.map(
-    (lens) => `<button type="button" class="lens" role="tab" data-lens="${lens.id}" aria-selected="${String(
-      model.initialLens === lens.id
-    )}">${lens.label}</button>`
-  ).join("");
+function compareStrings4(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
 }
-function renderFindings(model) {
-  const chips = [];
-  if (model.hotspotCount > 0) {
-    chips.push(
-      `<button type="button" class="finding" data-focus="hotspot"><i class="dot info"></i><b>${formatInt(
-        model.hotspotCount
-      )}</b> hotspots</button>`
-    );
-  }
-  if (model.cycles.length > 0) {
-    chips.push(
-      `<button type="button" class="finding" data-focus="cycle"><i class="dot warn"></i><b>${formatInt(
-        model.cycles.length
-      )}</b> aristas c\xEDclicas</button>`
-    );
-  }
-  chips.push(
-    `<span class="finding static"><i class="dot neutral"></i><b>${formatInt(
-      model.fileCount
-    )}</b> ficheros</span>`
-  );
-  chips.push(
-    `<span class="finding static"><i class="dot neutral"></i><b>${formatInt(
-      model.edges.length
-    )}</b> dependencias</span>`
+
+// packages/metrics/src/diff.ts
+function diffSnapshots(base, head, options = {}) {
+  const top = Math.max(1, Math.floor(options.top ?? 10));
+  const baseIndex = indexSnapshot(base);
+  const headIndex = indexSnapshot(head);
+  const added = difference(headIndex, baseIndex);
+  const removed = difference(baseIndex, headIndex);
+  const changed = changedFiles(baseIndex, headIndex);
+  const edgeDiff = diffEdges(baseIndex, headIndex);
+  const baseCycles = cycleGroups(baseIndex);
+  const headCycles = cycleGroups(headIndex);
+  const introducedCycles = cycleDifference(headCycles, baseCycles);
+  const fixedCycles = cycleDifference(baseCycles, headCycles);
+  const hotspotMetric = chooseHotspotMetric(
+    baseIndex,
+    headIndex,
+    options.hotspotMetric
   );
-  return `${chips.join("")}<span class="spacer"></span><span id="search-status" class="search-status" aria-live="polite"></span><span class="run-meta">${escapeHtml(
-    model.areaTitle
-  )} \xB7 ${formatInt(model.metrics.length)} m\xE9tricas \xB7 cc.json ${escapeHtml(
-    model.meta.apiVersion
-  )}</span>`;
-}
-function metricByKey(model, key) {
-  return key ? model.metrics.find((metric) => metric.key === key) : void 0;
+  const hotspots = hotspotMetric ? buildHotspots(baseIndex, headIndex, added, changed, hotspotMetric, top) : [];
+  const rules = options.rules ? evaluateRules(
+    ruleInput(baseIndex, [...baseCycles.values()].map((group) => group.component)),
+    ruleInput(headIndex, [...headCycles.values()].map((group) => group.component)),
+    options.rules
+  ) : emptyRuleReport();
+  return {
+    schemaVersion: "1.0",
+    base: summarize(baseIndex),
+    head: summarize(headIndex),
+    summary: {
+      addedFiles: added.length,
+      removedFiles: removed.length,
+      changedFiles: changed.length,
+      addedEdges: edgeDiff.added.length,
+      removedEdges: edgeDiff.removed.length,
+      cyclicEdgesAdded: edgeDiff.cyclicAdded.length,
+      cyclicEdgesRemoved: edgeDiff.cyclicRemoved.length,
+      introducedCycles: introducedCycles.length,
+      fixedCycles: fixedCycles.length,
+      hotspots: hotspots.length
+    },
+    hotspotMetric,
+    rules,
+    files: { added, removed, changed },
+    edges: edgeDiff,
+    cycles: { introduced: introducedCycles, fixed: fixedCycles },
+    hotspots
+  };
 }
-function renderLegend(model) {
-  if (model.initialLens === "structure") {
-    const items = model.sections.slice(0, 6).map(
-      (section) => `<span><i style="background:${section.color}"></i>${escapeHtml(section.key)}</span>`
-    ).join("");
-    return `<span>Carpeta</span><span class="sws">${items}</span>`;
+function indexSnapshot(cc) {
+  const paths = /* @__PURE__ */ new Map();
+  for (const root of cc.files) {
+    walkFiles([root], (entry) => {
+      paths.set(entry.node.id, relativePath(root, entry.path, entry.node));
+    });
   }
-  if (model.initialLens === "metric" && model.initialMetric) {
-    const metric = metricByKey(model, model.initialMetric);
-    if (metric) {
-      const direction = metric.direction === -1 ? " \xB7 menos es mejor" : metric.direction === 1 ? " \xB7 m\xE1s es mejor" : "";
-      return `<span>${escapeHtml(metric.title)}${direction}</span><span class="mono">${escapeHtml(
-        formatCompact(metric.min)
-      )}</span><span class="bar" style="background:${METRIC_GRADIENT}"></span><span class="mono">${escapeHtml(
-        formatCompact(metric.max)
-      )}</span>`;
+  const nodes = [...paths.keys()].sort(
+    (left, right) => compareStrings5(paths.get(left) ?? left, paths.get(right) ?? right)
+  );
+  const metrics = cc.lenses?.metrics?.attributes ?? {};
+  const edges = /* @__PURE__ */ new Map();
+  for (const edge of cc.lenses?.dependency?.edges ?? []) {
+    const key = edgeKey(edge.fromId, edge.toId);
+    const weight = finiteNumber(edge.attributes?.weight) ?? 1;
+    const typeOnly = finiteNumber(edge.attributes?.typeOnly) ?? 0;
+    const existing = edges.get(key);
+    if (existing) {
+      existing.weight += weight;
+      existing.typeOnly += typeOnly;
+      existing.isCyclic = existing.isCyclic || edge.isCyclic === true;
+    } else {
+      edges.set(key, {
+        fromId: edge.fromId,
+        toId: edge.toId,
+        weight,
+        typeOnly,
+        isCyclic: edge.isCyclic === true
+      });
     }
   }
-  return `<span>Riesgo (0\u2013100)</span><span class="mono">0</span><span class="bar" style="background:${RISK_GRADIENT}"></span><span class="mono">100</span>`;
-}
-function renderMetricOptions(model) {
-  return model.metrics.map(
-    (metric) => `<option value="${escapeAttr(metric.key)}"${metric.key === model.initialMetric ? " selected" : ""}>${escapeHtml(metric.title)}</option>`
-  ).join("");
-}
-function renderInspectorSummary(model) {
-  const hotspots = [...model.files].sort((a, b) => b.risk - a.risk || a.path.localeCompare(b.path)).slice(0, 5);
-  return `<div class="summary">
-  <div class="sub">Proyecto</div>
-  <div class="big">${formatInt(model.fileCount)}</div>
-  <div class="sub">ficheros \xB7 ${formatInt(model.folderCount)} carpetas</div>
-  <p>${formatInt(model.totalArea)} de ${escapeHtml(
-    model.areaTitle.toLowerCase()
-  )} \xB7 ${formatInt(model.metrics.length)} m\xE9tricas \xB7 ${formatInt(
-    model.hotspotCount
-  )} hotspots.</p>
-  <h4>Mayor riesgo</h4>
-  <ul class="deps">${hotspots.map(
-    (file) => `<li data-file="${file.index}"><i class="sw" style="background:${riskColor(
-      file.risk
-    )}"></i><span>${escapeHtml(file.path)}</span><em>${Math.round(
-      file.risk * 100
-    )}</em></li>`
-  ).join("")}</ul>
-  <p>Selecciona un bloque para ver sus m\xE9tricas y sus dependencias. Clic en la cabecera de una carpeta para enfocarla.</p>
-</div>`;
+  return { cc, paths, nodes, metrics, edges };
 }
-function renderHtml(model) {
-  const project = escapeHtml(model.meta.project);
-  const title = escapeHtml(model.meta.title);
-  const commit = model.meta.commit ? model.meta.commit.slice(0, 7) : "";
-  const checksum = model.meta.checksum ? model.meta.checksum.slice(0, 8) : "";
-  const badge = commit || checksum || `cc.json ${model.meta.apiVersion}`;
-  const payload = jsonForScript(serialise(model));
-  const metricPicker = model.metrics.length > 0 ? `<label class="metric-pick" id="metric-pick"${model.initialLens === "metric" ? "" : " hidden"}><span>M\xE9trica</span><select id="metric-select">${renderMetricOptions(
-    model
-  )}</select></label>` : "";
-  const crumbs = model.meta.rootName ? `${project} <span class="sep">/</span> ${escapeHtml(model.meta.rootName)}` : project;
-  return `<!doctype html>
-<html lang="es">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<meta name="color-scheme" content="light">
-<meta name="generator" content="CodArch">
-<title>CodArch \xB7 ${title}</title>
-<style>${STYLES}</style>
-</head>
-<body>
-<div class="app">
-  <header>
-    <div class="brand">CodArch</div>
-    <div class="repo">
-      <b>${title}</b>
-      ${model.meta.rootName && model.meta.rootName !== model.meta.project ? `<span>${escapeHtml(model.meta.rootName)}</span>` : ""}
-      <span class="commit">${escapeHtml(badge)}</span>
-    </div>
-    <div class="spacer"></div>
-    <nav class="lenses" role="tablist" aria-label="Lentes">${renderLensButtons(model)}</nav>
-    ${metricPicker}
-    <label class="search">
-      <svg width="12" height="12" viewBox="0 0 16 16" fill="none" aria-hidden="true">
-        <circle cx="7" cy="7" r="4.5" stroke="#8d877d" stroke-width="1.4"/>
-        <path d="M10.5 10.5 14 14" stroke="#8d877d" stroke-width="1.4"/>
-      </svg>
-      <input id="q" type="search" placeholder="Buscar fichero\u2026" autocomplete="off" aria-label="Buscar fichero">
-    </label>
-  </header>
-
-  <div class="findings">${renderFindings(model)}</div>
-
-  <main class="map-wrap">
-    <div class="map" id="map">${renderSvg(model)}</div>
-    <div class="tooltip" id="tooltip"></div>
-  </main>
-
-  <aside id="inspector">${renderInspectorSummary(model)}</aside>
-
-  <footer>
-    <span class="crumbs" id="crumbs">${crumbs}</span>
-    <span class="hint">clic para fijar \xB7 esc para limpiar</span>
-    <span class="legend" id="legend">${renderLegend(model)}</span>
-  </footer>
-</div>
-<script id="codarch-data" type="application/json">${payload}</script>
-<script>${CLIENT}</script>
-</body>
-</html>`;
+function relativePath(root, fullPath, leaf) {
+  if (fullPath === root.name) return leaf.name;
+  const prefix = `${root.name}/`;
+  return fullPath.startsWith(prefix) ? fullPath.slice(prefix.length) : fullPath;
 }
-
-// apps/cli/src/io.ts
-import fs6 from "node:fs";
-import zlib from "node:zlib";
-function readJsonFile2(file) {
-  const buffer = fs6.readFileSync(file);
-  const isGzip = buffer.length > 2 && buffer[0] === 31 && buffer[1] === 139;
-  const raw = isGzip ? zlib.gunzipSync(buffer) : buffer;
-  const text = raw.toString("utf8");
-  try {
-    return { json: JSON.parse(text), bytes: buffer.length };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`no es JSON v\xE1lido: ${message}`);
+function summarize(index) {
+  let folders = 0;
+  walkTree(index.cc.files, (entry) => {
+    if (entry.node.type === "Folder" && entry.depth > 0) folders++;
+  });
+  return {
+    projectName: index.cc.meta.projectName ?? "",
+    checksum: index.cc.meta.checksum ?? "",
+    files: index.paths.size,
+    folders,
+    edges: index.edges.size
+  };
+}
+function difference(present, absent) {
+  const files = [];
+  for (const [id, path9] of present.paths) {
+    if (absent.paths.has(id)) continue;
+    files.push({
+      id,
+      path: path9,
+      metrics: sortedMetrics(present.metrics[id])
+    });
   }
+  return files.sort(compareFiles);
 }
-function formatBytes(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+function changedFiles(base, head) {
+  const changed = [];
+  for (const [id, path9] of head.paths) {
+    if (!base.paths.has(id)) continue;
+    const baseValues = base.metrics[id] ?? {};
+    const headValues = head.metrics[id] ?? {};
+    const keys = /* @__PURE__ */ new Set([...Object.keys(baseValues), ...Object.keys(headValues)]);
+    const changes = [];
+    for (const metric of [...keys].sort(compareStrings5)) {
+      const baseValue = finiteNumber(baseValues[metric]);
+      const headValue = finiteNumber(headValues[metric]);
+      if (baseValue === null && headValue === null) continue;
+      if (baseValue !== null && headValue !== null && baseValue === headValue) {
+        continue;
+      }
+      changes.push({
+        metric,
+        base: baseValue,
+        head: headValue,
+        delta: baseValue !== null && headValue !== null ? headValue - baseValue : null
+      });
+    }
+    if (changes.length > 0) changed.push({ id, path: path9, changes });
+  }
+  return changed.sort(compareChangedFiles);
 }
-
-// apps/cli/src/commands/analyze.ts
-var numberFormat = new Intl.NumberFormat("es-ES");
-function num(value) {
-  return numberFormat.format(value);
+function diffEdges(base, head) {
+  const added = [];
+  const removed = [];
+  for (const [key, edge] of head.edges) {
+    if (!base.edges.has(key)) added.push(edgeChange(head, edge));
+  }
+  for (const [key, edge] of base.edges) {
+    if (!head.edges.has(key)) removed.push(edgeChange(base, edge));
+  }
+  added.sort(compareEdgeChanges);
+  removed.sort(compareEdgeChanges);
+  return {
+    added,
+    removed,
+    cyclicAdded: added.filter((edge) => edge.isCyclic),
+    cyclicRemoved: removed.filter((edge) => edge.isCyclic)
+  };
 }
-function field(label, value) {
-  return `  ${label.padEnd(12)} ${value}`;
+function edgeChange(index, edge) {
+  return {
+    fromId: edge.fromId,
+    toId: edge.toId,
+    from: index.paths.get(edge.fromId) ?? edge.fromId,
+    to: index.paths.get(edge.toId) ?? edge.toId,
+    weight: edge.weight,
+    typeOnly: edge.typeOnly,
+    isCyclic: edge.isCyclic
+  };
 }
-function runAnalyze(options) {
-  const root = options.root ?? ".";
-  let result;
-  try {
-    result = analyzeRepository(root, {
-      ignore: options.ignore,
-      projectName: options.projectName,
-      git: options.git
-    });
-  } catch (error) {
-    console.error(`no se pudo analizar ${root}: ${error.message}`);
-    return 1;
+function cycleGroups(index) {
+  const adjacency = /* @__PURE__ */ new Map();
+  const reverse = /* @__PURE__ */ new Map();
+  for (const node of index.nodes) {
+    adjacency.set(node, []);
+    reverse.set(node, []);
   }
-  let cc;
-  try {
-    cc = parseCcJson(result.snapshot);
-  } catch (error) {
-    if (error instanceof CcJsonError) {
-      console.error(`el snapshot generado no es cc.json v\xE1lido: ${error.message}`);
-      return 1;
-    }
-    throw error;
+  for (const edge of index.edges.values()) {
+    if (!index.paths.has(edge.fromId) || !index.paths.has(edge.toId)) continue;
+    adjacency.get(edge.fromId)?.push(edge.toId);
+    reverse.get(edge.toId)?.push(edge.fromId);
   }
-  const outDirectory = path5.resolve(
-    options.out ?? path5.join(path5.resolve(root), ".codarch")
-  );
-  const snapshotPath = path5.join(outDirectory, "snapshot.cc.json");
-  const mapPath = path5.join(outDirectory, "map.html");
-  try {
-    fs7.mkdirSync(outDirectory, { recursive: true });
-    fs7.writeFileSync(
-      snapshotPath,
-      `${JSON.stringify(cc, null, 2)}
-`,
-      "utf8"
-    );
-  } catch (error) {
-    console.error(
-      `no se pudo escribir ${snapshotPath}: ${error.message}`
-    );
-    return 1;
+  for (const [node, neighbors] of adjacency) {
+    adjacency.set(node, [...new Set(neighbors)].sort(compareStrings5));
   }
-  let mapBytes = 0;
-  let mapError = null;
-  if (result.files > 0) {
-    try {
-      const model = buildRenderModel(cc, {
-        areaMetric: "rloc",
-        color: "risk",
-        title: options.title
-      });
-      const html = renderHtml(model);
-      fs7.writeFileSync(mapPath, html, "utf8");
-      mapBytes = Buffer.byteLength(html, "utf8");
-    } catch (error) {
-      mapError = error instanceof RenderError ? error.message : error.message;
+  for (const [node, neighbors] of reverse) {
+    reverse.set(node, [...new Set(neighbors)].sort(compareStrings5));
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const order = [];
+  for (const start of index.nodes) {
+    if (visited.has(start)) continue;
+    visited.add(start);
+    const stack = [
+      { node: start, neighbors: adjacency.get(start) ?? [], next: 0 }
+    ];
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1];
+      if (frame.next < frame.neighbors.length) {
+        const next = frame.neighbors[frame.next];
+        frame.next++;
+        if (!visited.has(next)) {
+          visited.add(next);
+          stack.push({
+            node: next,
+            neighbors: adjacency.get(next) ?? [],
+            next: 0
+          });
+        }
+      } else {
+        order.push(frame.node);
+        stack.pop();
+      }
     }
-  } else {
-    mapError = "no hay ficheros TypeScript/JavaScript que dibujar";
   }
-  const snapshotBytes = Buffer.byteLength(
-    fs7.readFileSync(snapshotPath),
-    "utf8"
-  );
-  const lines = [];
-  lines.push("");
-  lines.push("  CodArch \xB7 an\xE1lisis");
-  lines.push("");
-  lines.push(field("ra\xEDz", path5.resolve(root)));
-  lines.push(field("snapshot", `${snapshotPath} (${formatBytes(snapshotBytes)})`));
-  if (mapError) {
-    lines.push(field("mapa", `omitido (${mapError})`));
-  } else {
-    lines.push(field("mapa", `${mapPath} (${formatBytes(mapBytes)})`));
+  const assigned = /* @__PURE__ */ new Set();
+  const groups = /* @__PURE__ */ new Map();
+  for (let position = order.length - 1; position >= 0; position--) {
+    const start = order[position];
+    if (assigned.has(start)) continue;
+    assigned.add(start);
+    const component = [];
+    const stack = [start];
+    while (stack.length > 0) {
+      const node = stack.pop();
+      component.push(node);
+      for (const next of reverse.get(node) ?? []) {
+        if (assigned.has(next)) continue;
+        assigned.add(next);
+        stack.push(next);
+      }
+    }
+    const hasSelfLoop = component.some(
+      (node) => (adjacency.get(node) ?? []).includes(node)
+    );
+    if (component.length < 2 && !hasSelfLoop) continue;
+    const nodes = component.map((id) => ({
+      id,
+      path: index.paths.get(id) ?? id
+    })).sort((left, right) => {
+      return compareStrings5(left.path, right.path) || compareStrings5(left.id, right.id);
+    });
+    const key = [...component].sort(compareStrings5).join("\0");
+    groups.set(key, { key, component: { size: nodes.length, nodes } });
   }
-  lines.push(
-    field(
-      "estructura",
-      `${num(result.files)} ficheros \xB7 ${num(result.folders)} carpetas \xB7 ${num(
-        result.edges
-      )} aristas \xB7 ${num(result.cycles.length)} ciclos`
-    )
-  );
-  lines.push(
-    field(
-      "imports",
-      `${num(result.externalImports)} externos \xB7 ${num(
-        result.builtinImports
-      )} builtins \xB7 ${num(result.typeOnlyImports)} type-only \xB7 ${num(
-        result.unresolvedImports
-      )} sin resolver`
-    )
-  );
-  const migrationLanguages = Object.entries(result.migration.languages).map(([language, stats]) => `${language} ${num(stats?.rloc ?? 0)}`).join(" \xB7 ");
-  lines.push(
-    field(
-      "migraci\xF3n",
-      `${migrationLanguages || "\u2014"} \xB7 ${num(
-        result.migration.bridgeFiles
-      )} puentes \xB7 ${num(result.migration.ffiEdges)} FFI \xB7 deuda ${num(
-        result.migration.migrationDebt
-      )}`
-    )
-  );
-  lines.push(field("tiempo", `${num(result.durationMs)} ms`));
-  lines.push(
-    field(
-      "historial",
-      result.git.enabled ? `${num(result.git.commits)} commits \xB7 ${num(
-        result.git.authors
-      )} autores${result.git.shallow ? " \xB7 shallow" : ""}` : "sin git; se omite churn"
-    )
-  );
-  for (const warning of result.warnings.slice(0, 10)) {
-    lines.push(field("aviso", warning));
+  return groups;
+}
+function cycleDifference(present, absent) {
+  const cycles = [];
+  for (const [key, group] of present) {
+    if (!absent.has(key)) cycles.push(group.component);
+  }
+  return cycles.sort(compareCycles);
+}
+function ruleInput(index, cycles) {
+  const files = index.nodes.map((id) => ({
+    id,
+    path: index.paths.get(id) ?? id,
+    metrics: sortedMetrics(index.metrics[id])
+  }));
+  const edges = [];
+  for (const edge of index.edges.values()) {
+    if (!index.paths.has(edge.fromId) || !index.paths.has(edge.toId)) {
+      continue;
+    }
+    edges.push({
+      fromId: edge.fromId,
+      toId: edge.toId,
+      from: index.paths.get(edge.fromId) ?? edge.fromId,
+      to: index.paths.get(edge.toId) ?? edge.toId
+    });
   }
-  if (result.warnings.length > 10) {
-    lines.push(field("aviso", `y ${num(result.warnings.length - 10)} m\xE1s`));
+  return { files, edges, cycles };
+}
+function chooseHotspotMetric(base, head, requested) {
+  if (requested) return requested;
+  for (const metric of ["maxComplexity", "rloc"]) {
+    if (hasMetric(base, metric) || hasMetric(head, metric)) return metric;
   }
-  for (const issue of result.unresolved.slice(0, 5)) {
-    lines.push(
-      field(
-        "sin resolver",
-        `${issue.file}:${issue.line} ${issue.specifier} (${issue.reason})`
-      )
-    );
+  return null;
+}
+function hasMetric(index, metric) {
+  for (const values of Object.values(index.metrics)) {
+    if (finiteNumber(values[metric]) !== null) return true;
   }
-  if (result.unresolved.length > 5) {
-    lines.push(
-      field("sin resolver", `y ${num(result.unresolved.length - 5)} m\xE1s`)
-    );
+  return false;
+}
+function buildHotspots(base, head, added, changed, metric, top) {
+  const addedIds = new Set(added.map((file) => file.id));
+  const candidates = [...added, ...changed];
+  const hotspots = [];
+  for (const file of candidates) {
+    const baseValue = finiteNumber(base.metrics[file.id]?.[metric]);
+    const headValue = finiteNumber(head.metrics[file.id]?.[metric]);
+    if (headValue === null) continue;
+    const before = baseValue ?? 0;
+    const delta = headValue - before;
+    if (delta <= 0) continue;
+    hotspots.push({
+      id: file.id,
+      path: file.path,
+      metric,
+      base: before,
+      head: headValue,
+      delta,
+      change: addedIds.has(file.id) ? "added" : "changed"
+    });
   }
-  lines.push("");
-  console.log(lines.join("\n"));
-  return 0;
+  return hotspots.sort(
+    (left, right) => right.delta - left.delta || right.head - left.head || compareStrings5(left.path, right.path)
+  ).slice(0, top);
+}
+function sortedMetrics(values) {
+  const sorted = {};
+  if (!values) return sorted;
+  for (const key of Object.keys(values).sort(compareStrings5)) {
+    const value = finiteNumber(values[key]);
+    if (value !== null) sorted[key] = value;
+  }
+  return sorted;
+}
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function edgeKey(fromId, toId) {
+  return `${fromId}\0${toId}`;
+}
+function compareFiles(left, right) {
+  return compareStrings5(left.path, right.path) || compareStrings5(left.id, right.id);
+}
+function compareChangedFiles(left, right) {
+  return compareStrings5(left.path, right.path) || compareStrings5(left.id, right.id);
+}
+function compareEdgeChanges(left, right) {
+  return compareStrings5(left.from, right.from) || compareStrings5(left.to, right.to) || compareStrings5(left.fromId, right.fromId) || compareStrings5(left.toId, right.toId);
+}
+function compareCycles(left, right) {
+  return compareStrings5(
+    left.nodes[0]?.path ?? "",
+    right.nodes[0]?.path ?? ""
+  ) || left.size - right.size;
+}
+function compareStrings5(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
 }
 
 // apps/cli/src/commands/diff.ts
-import fs8 from "node:fs";
-import path6 from "node:path";
 var numberFormat2 = new Intl.NumberFormat("es-ES");
 function num2(value) {
   return numberFormat2.format(value);
@@ -4504,7 +4542,7 @@ function runInspect(options) {
   const metric = options.metric ?? defaultMetric(stats);
   const top = metric ? topByMetric(cc, metric, options.top) : [];
   const rootPrefix = cc.files.length === 1 ? `${cc.files[0]?.name}/` : "";
-  const displayPath = (path8) => rootPrefix && path8.startsWith(rootPrefix) ? path8.slice(rootPrefix.length) : path8;
+  const displayPath = (path9) => rootPrefix && path9.startsWith(rootPrefix) ? path9.slice(rootPrefix.length) : path9;
   if (options.metric && !stats.metricCoverage.some((entry) => entry.name === options.metric)) {
     console.error(`la m\xE9trica "${options.metric}" no existe en este fichero`);
     return 1;
@@ -4702,8 +4740,440 @@ function runRender(options) {
   return 0;
 }
 
+// apps/cli/src/commands/serve.ts
+import fs10 from "node:fs";
+import http from "node:http";
+import path8 from "node:path";
+import { fileURLToPath } from "node:url";
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".wasm": "application/wasm"
+};
+var IGNORED_WATCH = /(^|\/)(node_modules|\.git|\.codarch|dist|coverage|\.next|out|target)(\/|$)/;
+var IGNORED_BROWSE = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  ".codarch",
+  "dist",
+  "coverage",
+  ".next",
+  "out",
+  "target"
+]);
+function runServe(options) {
+  const root = path8.resolve(options.root ?? ".");
+  const webRoot = options.web === false ? null : findWebRoot();
+  if (options.web !== false && !webRoot) {
+    console.error(
+      "no se encontr\xF3 el build web. Ejecuta `npm run web:build` o usa el paquete publicado."
+    );
+    return 1;
+  }
+  let state = analyzeState(root, options.watch);
+  let watcher = null;
+  let timer;
+  const clients = /* @__PURE__ */ new Set();
+  const startWatcher = () => {
+    if (watcher) return null;
+    try {
+      watcher = fs10.watch(state.root, { recursive: true }, (_event, filename) => {
+        if (!filename) return;
+        const relative = filename.toString().replace(/\\/g, "/");
+        if (IGNORED_WATCH.test(relative)) return;
+        scheduleRefresh();
+      });
+      return null;
+    } catch (error) {
+      watcher = null;
+      return error.message;
+    }
+  };
+  const stopWatcher = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+    watcher?.close();
+    watcher = null;
+  };
+  const closeClients = () => {
+    for (const client of clients) client.end();
+    clients.clear();
+  };
+  const refresh = () => {
+    if (!state.watch) return;
+    try {
+      const next = analyzeState(state.root, state.watch);
+      state = next;
+      broadcast(clients, "update", {
+        checksum: state.checksum,
+        files: state.files
+      });
+      console.log(
+        `  \u21BB ${state.files} ficheros \xB7 checksum ${state.checksum.slice(0, 8)}`
+      );
+    } catch (error) {
+      const message = error.message;
+      console.error(`  no se pudo reanalizar: ${message}`);
+      broadcast(clients, "error", { message });
+    }
+  };
+  const scheduleRefresh = () => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = void 0;
+      refresh();
+    }, 350);
+  };
+  const setWatch = (enabled) => {
+    if (enabled === state.watch) return;
+    if (enabled) {
+      const error = startWatcher();
+      if (error) throw new Error(`watch no disponible: ${error}`);
+      state = { ...state, watch: true };
+    } else {
+      stopWatcher();
+      closeClients();
+      state = { ...state, watch: false };
+    }
+    broadcast(clients, "watch", { watch: state.watch });
+  };
+  const switchRoot = (nextRoot) => {
+    const resolved = path8.resolve(nextRoot);
+    const stat = fs10.statSync(resolved);
+    if (!stat.isDirectory()) throw new Error("la ruta no es un directorio");
+    const next = analyzeState(resolved, state.watch);
+    stopWatcher();
+    state = next;
+    if (state.watch) {
+      const error = startWatcher();
+      if (error) {
+        state = { ...state, watch: false };
+        console.error(`watch no disponible en ${resolved}: ${error}`);
+      }
+    }
+    broadcast(clients, "update", {
+      checksum: state.checksum,
+      files: state.files
+    });
+    console.log(
+      `  \u2192 ${state.root} \xB7 ${state.files} ficheros \xB7 ${state.watch ? "live" : "servido"}`
+    );
+    return state;
+  };
+  const meta = () => ({
+    root: path8.basename(state.root),
+    rootPath: state.root,
+    watch: state.watch,
+    files: state.files,
+    checksum: state.checksum,
+    warnings: state.warnings,
+    updatedAt: state.updatedAt
+  });
+  const server = http.createServer(async (request, response) => {
+    try {
+      const host = request.headers.host ?? `${options.host}:${options.port}`;
+      const url = new URL(request.url ?? "/", `http://${host}`);
+      const pathname = url.pathname;
+      if (request.method === "POST") {
+        if (!originAllowed(request, options)) {
+          sendError(response, 403, "origen no permitido");
+          return;
+        }
+        if (pathname === "/api/root") {
+          const body = await readBody(request);
+          const nextRoot = typeof body === "object" && body !== null && typeof body.path === "string" ? body.path : "";
+          if (!nextRoot.trim()) {
+            sendError(response, 400, "falta la ruta de la carpeta");
+            return;
+          }
+          const next = switchRoot(nextRoot);
+          sendJson(response, {
+            ...meta(),
+            rootPath: next.root,
+            watch: next.watch
+          });
+          return;
+        }
+        if (pathname === "/api/watch") {
+          const body = await readBody(request);
+          const enabled = typeof body === "object" && body !== null && body.enabled === true;
+          try {
+            setWatch(enabled);
+          } catch (error) {
+            sendError(response, 400, error.message);
+            return;
+          }
+          sendJson(response, meta());
+          return;
+        }
+        sendError(response, 404, "endpoint desconocido");
+        return;
+      }
+      if (request.method !== "GET" && request.method !== "HEAD") {
+        response.writeHead(405, { Allow: "GET, HEAD, POST" });
+        response.end();
+        return;
+      }
+      if (pathname === "/api/browse") {
+        try {
+          sendJson(response, browseDirectories(state.root, url.searchParams.get("path")));
+        } catch (error) {
+          sendError(response, 400, error.message);
+        }
+        return;
+      }
+      if (pathname === "/data/snapshot.cc.json") {
+        sendJson(response, state.snapshot);
+        return;
+      }
+      if (pathname === "/data/meta.json") {
+        sendJson(response, meta());
+        return;
+      }
+      if (pathname === "/data/report.json") {
+        const report = readReport(state.root);
+        if (report === null) {
+          sendError(response, 404, "no hay .codarch/report.json");
+          return;
+        }
+        sendJson(response, report);
+        return;
+      }
+      if (pathname === "/events") {
+        if (!state.watch) {
+          response.writeHead(204);
+          response.end();
+          return;
+        }
+        response.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-store",
+          Connection: "keep-alive",
+          "X-Accel-Buffering": "no"
+        });
+        response.write(
+          `event: ready
+data: ${JSON.stringify({
+            checksum: state.checksum,
+            files: state.files
+          })}
+
+`
+        );
+        clients.add(response);
+        request.on("close", () => clients.delete(response));
+        return;
+      }
+      if (!webRoot) {
+        sendError(response, 404, "servidor en modo API: la web la sirve otro proceso");
+        return;
+      }
+      serveStatic(webRoot, pathname, request.method === "HEAD", response);
+    } catch (error) {
+      if (!response.headersSent) {
+        sendError(response, 500, error.message);
+      } else {
+        response.end();
+      }
+    }
+  });
+  if (state.watch) {
+    const error = startWatcher();
+    if (error) {
+      state = { ...state, watch: false };
+      console.error(`watch no disponible; se sirve el an\xE1lisis inicial: ${error}`);
+    }
+  }
+  server.on("error", (error) => {
+    console.error(`no se pudo escuchar en ${options.host}:${options.port}: ${error.message}`);
+    process.exitCode = 1;
+  });
+  server.listen(options.port, options.host, () => {
+    const url = `http://${options.host}:${options.port}`;
+    const lines = [
+      "",
+      "  CodArch \xB7 serve",
+      "",
+      `  ra\xEDz         ${state.root}`,
+      `  web          ${webRoot ?? "modo API (la sirve Vite)"}`,
+      `  URL          ${url}`,
+      `  snapshot     ${state.files} ficheros \xB7 checksum ${state.checksum.slice(0, 8)}`,
+      `  modo         ${state.watch ? "watch activo (SSE)" : "solo an\xE1lisis inicial"}`,
+      ""
+    ];
+    console.log(lines.join("\n"));
+  });
+  const shutdown = () => {
+    stopWatcher();
+    closeClients();
+    server.close(() => process.exit(0));
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  return 0;
+}
+function analyzeState(root, watch) {
+  const result = analyzeRepository(root, { git: true });
+  return {
+    root,
+    snapshot: result.snapshot,
+    files: result.files,
+    checksum: result.snapshot.meta.checksum ?? "",
+    warnings: result.warnings.slice(0, 5),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    watch
+  };
+}
+function browseDirectories(root, requested) {
+  const target = requested?.trim() ? path8.resolve(requested) : root;
+  const stat = fs10.statSync(target);
+  if (!stat.isDirectory()) throw new Error("la ruta no es un directorio");
+  const entries = fs10.readdirSync(target, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !IGNORED_BROWSE.has(entry.name)).sort((left, right) => left.name.localeCompare(right.name)).slice(0, 500).map((entry) => ({
+    name: entry.name,
+    path: path8.join(target, entry.name),
+    kind: "directory"
+  }));
+  const parent = path8.dirname(target);
+  return {
+    path: target,
+    parent: parent === target ? null : parent,
+    entries
+  };
+}
+async function readBody(request) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of request) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    size += buffer.length;
+    if (size > 64 * 1024) throw new Error("cuerpo demasiado grande");
+    chunks.push(buffer);
+  }
+  const text = Buffer.concat(chunks).toString("utf8");
+  return text ? JSON.parse(text) : {};
+}
+function originAllowed(request, options) {
+  const origin = request.headers.origin;
+  if (!origin) return true;
+  try {
+    const parsed = new URL(origin);
+    if (parsed.protocol !== "http:") return false;
+    if (parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1") {
+      return true;
+    }
+    return origin === `http://${options.host}:${options.port}`;
+  } catch {
+    return false;
+  }
+}
+function findWebRoot() {
+  const candidates = [
+    fileURLToPath(new URL("./web", import.meta.url)),
+    path8.resolve(process.cwd(), "apps", "web", "dist"),
+    path8.resolve(
+      path8.dirname(fileURLToPath(import.meta.url)),
+      "..",
+      "..",
+      "..",
+      "web",
+      "dist"
+    )
+  ];
+  for (const candidate of candidates) {
+    if (fs10.existsSync(path8.join(candidate, "index.html"))) return candidate;
+  }
+  return null;
+}
+function readReport(root) {
+  const file = path8.join(root, ".codarch", "report.json");
+  try {
+    return JSON.parse(fs10.readFileSync(file, "utf8"));
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      console.error(`no se pudo leer ${file}: ${error.message}`);
+    }
+    return null;
+  }
+}
+function serveStatic(webRoot, pathname, headOnly, response) {
+  let decoded;
+  try {
+    decoded = decodeURIComponent(pathname);
+  } catch {
+    response.writeHead(400);
+    response.end();
+    return;
+  }
+  const relative = decoded === "/" ? "index.html" : decoded.replace(/^\/+/, "");
+  let file = path8.resolve(webRoot, relative);
+  if (!isWithin2(webRoot, file) || !fs10.existsSync(file) || !fs10.statSync(file).isFile()) {
+    file = path8.join(webRoot, "index.html");
+  }
+  try {
+    const body = fs10.readFileSync(file);
+    response.writeHead(200, {
+      "Content-Type": MIME[path8.extname(file).toLowerCase()] ?? "application/octet-stream",
+      "Content-Length": body.length,
+      "Cache-Control": file.includes(`${path8.sep}assets${path8.sep}`) ? "public, max-age=31536000, immutable" : "no-store",
+      "X-Content-Type-Options": "nosniff"
+    });
+    if (headOnly) response.end();
+    else response.end(body);
+  } catch (error) {
+    response.writeHead(500);
+    response.end(error.message);
+  }
+}
+function isWithin2(root, candidate) {
+  const relative = path8.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path8.isAbsolute(relative);
+}
+function sendJson(response, value) {
+  const body = `${JSON.stringify(value)}
+`;
+  response.writeHead(200, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Content-Length": Buffer.byteLength(body),
+    "Cache-Control": "no-store",
+    "X-Content-Type-Options": "nosniff"
+  });
+  response.end(body);
+}
+function sendError(response, status, message) {
+  const body = `${JSON.stringify({ error: message })}
+`;
+  response.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Content-Length": Buffer.byteLength(body),
+    "Cache-Control": "no-store"
+  });
+  response.end(body);
+}
+function broadcast(clients, event, data) {
+  const payload = `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+  for (const client of clients) {
+    try {
+      client.write(payload);
+    } catch {
+      clients.delete(client);
+    }
+  }
+}
+
 // apps/cli/src/index.ts
-var VERSION = true ? "0.1.1" : "0.0.0";
+var VERSION = true ? "0.1.3" : "0.0.0";
 var USAGE = `
 CodArch \xB7 mapa vivo de la arquitectura de tu software
 
@@ -4712,6 +5182,7 @@ Uso:
   codarch inspect <fichero.cc.json[.gz]> [opciones]
   codarch render  <fichero.cc.json[.gz]> [opciones]
   codarch diff    <base.cc.json[.gz]> <head.cc.json[.gz]> [opciones]
+  codarch serve   [ruta] [opciones]
 
 Opciones de analyze:
   -o, --out <dir>    directorio de salida (por defecto <ruta>/.codarch)
@@ -4745,6 +5216,14 @@ Opciones de diff:
   --fail-on <modo>  none | cycles | violations | hotspots | any (por defecto none)
   -h, --help        esta ayuda
 
+Opciones de serve:
+  -p, --port <n>    puerto local (por defecto 4173)
+  --host <host>     interfaz (por defecto 127.0.0.1)
+  --watch           reanaliza al cambiar ficheros y refresca por SSE (por defecto)
+  --no-watch        solo analiza al arrancar
+  --no-web          modo API sin servir la app (para Vite u otro frontend)
+  -h, --help        esta ayuda
+
 Ejemplos:
   codarch analyze .
   codarch analyze . -o .codarch --title "Mi proyecto"
@@ -4752,6 +5231,8 @@ Ejemplos:
   codarch render samples/codecharta_visualization.cc.json.gz
   codarch render mapa.cc.json -o mapa.html --area rloc --color maxComplexity
   codarch diff base.cc.json head.cc.json -o report.json --fail-on cycles
+  codarch serve .
+  codarch serve . --no-watch
 `;
 function parseAnalyze(args) {
   const options = { help: false, ignore: [] };
@@ -5015,6 +5496,63 @@ function parseDiff(args) {
 function isFailOn(value) {
   return value === "none" || value === "cycles" || value === "violations" || value === "hotspots" || value === "any";
 }
+function parseServe(args) {
+  const options = {
+    port: 4173,
+    host: "127.0.0.1",
+    watch: true,
+    web: true,
+    help: false
+  };
+  const positional = [];
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--port" || arg === "-p") {
+      const value = args[++index];
+      const port = Number(value);
+      if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        console.error("--port necesita un n\xFAmero entre 1 y 65535");
+        return 1;
+      }
+      options.port = port;
+    } else if (arg.startsWith("--port=")) {
+      const port = Number(arg.slice("--port=".length));
+      if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        console.error("--port necesita un n\xFAmero entre 1 y 65535");
+        return 1;
+      }
+      options.port = port;
+    } else if (arg === "--host") {
+      const value = args[++index];
+      if (!value) {
+        console.error("--host necesita un valor");
+        return 1;
+      }
+      options.host = value;
+    } else if (arg.startsWith("--host=")) {
+      options.host = arg.slice("--host=".length);
+    } else if (arg === "--watch") {
+      options.watch = true;
+    } else if (arg === "--no-watch") {
+      options.watch = false;
+    } else if (arg === "--no-web") {
+      options.web = false;
+    } else if (arg === "--help" || arg === "-h") {
+      options.help = true;
+    } else if (arg.startsWith("-")) {
+      console.error(`opci\xF3n desconocida en serve: ${arg}`);
+      return 1;
+    } else {
+      positional.push(arg);
+    }
+  }
+  if (positional.length > 1) {
+    console.error("serve acepta como m\xE1ximo una ruta");
+    return 1;
+  }
+  options.root = positional[0];
+  return options;
+}
 function main(argv) {
   const [command, ...rest] = argv;
   if (!command || command === "--help" || command === "-h") {
@@ -5045,6 +5583,15 @@ function main(argv) {
     if (typeof parsed === "number") return parsed;
     return runDiff(parsed);
   }
+  if (command === "serve") {
+    const parsed = parseServe(rest);
+    if (typeof parsed === "number") return parsed;
+    if (parsed.help) {
+      console.log(USAGE);
+      return 0;
+    }
+    return runServe(parsed);
+  }
   console.error(`comando desconocido: ${command}
 ${USAGE}`);
   return 1;