codarch 0.3.21 → 0.3.23

package/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // apps/cli/src/commands/analyze.ts
-import fs11 from "node:fs";
-import path11 from "node:path";
+import fs12 from "node:fs";
+import path12 from "node:path";
 
 // packages/versions/src/manifest.ts
 var CC_JSON_VERSION = "2.0";
@@ -166,15 +166,15 @@ var ConfigError = class extends Error {
     this.name = "ConfigError";
   }
 };
-function asObject(value, path23) {
+function asObject(value, path24) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new ConfigError(`${path23} debe ser un objeto`);
+    throw new ConfigError(`${path24} debe ser un objeto`);
   }
   return value;
 }
-function asString(value, path23) {
+function asString(value, path24) {
   if (typeof value !== "string" || value.trim() === "") {
-    throw new ConfigError(`${path23} debe ser un texto no vac\xEDo`);
+    throw new ConfigError(`${path24} debe ser un texto no vac\xEDo`);
   }
   return value.trim();
 }
@@ -597,18 +597,18 @@ function parseInlineProfiles(value) {
   });
   return profiles;
 }
-function parseProfileEntry(value, path23) {
-  const entry = asObject(value, path23);
-  const id = asString(entry.id, `${path23}.id`);
-  const title = asString(entry.title, `${path23}.title`);
-  const description = entry.description === void 0 ? "" : asString(entry.description, `${path23}.description`);
-  const when = entry.when === void 0 ? "" : asString(entry.when, `${path23}.when`);
-  const layers = parseLayerList(entry.layers, `${path23}.layers`);
+function parseProfileEntry(value, path24) {
+  const entry = asObject(value, path24);
+  const id = asString(entry.id, `${path24}.id`);
+  const title = asString(entry.title, `${path24}.title`);
+  const description = entry.description === void 0 ? "" : asString(entry.description, `${path24}.description`);
+  const when = entry.when === void 0 ? "" : asString(entry.when, `${path24}.when`);
+  const layers = parseLayerList(entry.layers, `${path24}.layers`);
   if (layers.length === 0) {
-    throw new ConfigError(`${path23} necesita al menos una capa`);
+    throw new ConfigError(`${path24} necesita al menos una capa`);
   }
   const layerNames = new Set(layers.map((layer) => layer.name));
-  const rules = parseRuleList(entry.rules, layerNames, `${path23}.rules`).filter(
+  const rules = parseRuleList(entry.rules, layerNames, `${path24}.rules`).filter(
     (rule) => rule.type === "forbidden"
   );
   return { id, title, description, when, layers, rules };
@@ -715,35 +715,35 @@ function withFile(file, read) {
     throw error;
   }
 }
-function parseLayerList(value, path23 = "config.layers") {
+function parseLayerList(value, path24 = "config.layers") {
   if (value === void 0) return [];
   if (!Array.isArray(value)) {
-    throw new ConfigError(`${path23} debe ser una lista`);
+    throw new ConfigError(`${path24} debe ser una lista`);
   }
   const layers = [];
   const names = /* @__PURE__ */ new Set();
   value.forEach((raw, index) => {
-    const layer = asObject(raw, `${path23}[${index}]`);
-    const name = asString(layer.name, `${path23}[${index}].name`);
+    const layer = asObject(raw, `${path24}[${index}]`);
+    const name = asString(layer.name, `${path24}[${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(
-        `${path23}[${index}] no puede tener patterns y paths a la vez`
+        `${path24}[${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(
-        `${path23}[${index}].patterns debe ser una lista no vac\xEDa`
+        `${path24}[${index}].patterns debe ser una lista no vac\xEDa`
       );
     }
     const patterns = rawPatterns.map((rawPattern, patternIndex) => {
       const pattern = asString(
         rawPattern,
-        `${path23}[${index}].patterns[${patternIndex}]`
+        `${path24}[${index}].patterns[${patternIndex}]`
       ).replaceAll("\\", "/").replace(/^\.\//, "");
       if (pattern.startsWith("/") || /^[A-Za-z]:\//.test(pattern)) {
         throw new ConfigError(
@@ -756,15 +756,15 @@ function parseLayerList(value, path23 = "config.layers") {
   });
   return layers;
 }
-function parseRuleList(value, layerNames, path23 = "config.rules") {
+function parseRuleList(value, layerNames, path24 = "config.rules") {
   if (value === void 0) return [];
   if (!Array.isArray(value)) {
-    throw new ConfigError(`${path23} debe ser una lista`);
+    throw new ConfigError(`${path24} debe ser una lista`);
   }
   const rules = [];
   const names = /* @__PURE__ */ new Set();
   value.forEach((raw, index) => {
-    const at = `${path23}[${index}]`;
+    const at = `${path24}[${index}]`;
     const rule = asObject(raw, at);
     const name = asString(rule.name, `${at}.name`);
     if (names.has(name)) {
@@ -807,17 +807,17 @@ function parseRuleList(value, layerNames, path23 = "config.rules") {
   });
   return rules;
 }
-function parseSeverity(value, path23) {
+function parseSeverity(value, path24) {
   if (value === void 0) return "error";
   if (typeof value !== "string" || !SEVERITIES.has(value)) {
-    throw new ConfigError(`${path23} debe ser info, warn o error`);
+    throw new ConfigError(`${path24} debe ser info, warn o error`);
   }
   return value;
 }
-function optionalNumber(value, path23) {
+function optionalNumber(value, path24) {
   if (value === void 0) return void 0;
   if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw new ConfigError(`${path23} debe ser un n\xFAmero`);
+    throw new ConfigError(`${path24} debe ser un n\xFAmero`);
   }
   return value;
 }
@@ -1508,22 +1508,22 @@ function liveNodes(snapshot) {
     });
   }
   const folderBodies = /* @__PURE__ */ new Map();
-  const visit = (node, path23) => {
+  const visit = (node, path24) => {
     if (node.type === "File") {
       return fileBodies.get(node.id) ?? "";
     }
     const childBodies = [];
     for (const child of node.children ?? []) {
-      childBodies.push(visit(child, path23 ? `${path23}/${child.name}` : child.name));
+      childBodies.push(visit(child, path24 ? `${path24}/${child.name}` : child.name));
     }
     const bodyHash2 = sha256Hex(childBodies.join("|"));
-    if (path23) {
-      folderBodies.set(path23, bodyHash2);
+    if (path24) {
+      folderBodies.set(path24, bodyHash2);
       nodes.push({
         level: "folder",
         kind: "folder",
         name: node.name,
-        path: path23,
+        path: path24,
         bodyHash: bodyHash2,
         complexity: null,
         lines: null,
@@ -1665,15 +1665,15 @@ function verifyChains(chains, snapshot) {
     const prefix = `${root.name}/`;
     walkTree([root], (entry) => {
       if (entry.node.type !== "File") return;
-      const path23 = entry.path.startsWith(prefix) ? entry.path.slice(prefix.length) : entry.path;
+      const path24 = entry.path.startsWith(prefix) ? entry.path.slice(prefix.length) : entry.path;
       const symbols = snapshot.lenses?.symbols?.nodes[entry.node.id] ?? [];
       for (const symbol of symbols) {
         checked++;
-        const chain = byName.get(`${path23}::${symbol.name}`);
+        const chain = byName.get(`${path24}::${symbol.name}`);
         if (!chain) {
           mismatches.push({
             name: symbol.name,
-            path: path23,
+            path: path24,
             reason: "este s\xEDmbolo no tiene cadena"
           });
           continue;
@@ -1682,7 +1682,7 @@ function verifyChains(chains, snapshot) {
         if (!last) {
           mismatches.push({
             name: symbol.name,
-            path: path23,
+            path: path24,
             reason: "la cadena est\xE1 vac\xEDa"
           });
           continue;
@@ -1691,7 +1691,7 @@ function verifyChains(chains, snapshot) {
         if ((symbol.hash ?? "") !== last.bodyHash) {
           mismatches.push({
             name: symbol.name,
-            path: path23,
+            path: path24,
             reason: "el hash del cuerpo no es el de la cadena"
           });
         }
@@ -1838,22 +1838,22 @@ function saveHistory(root, cc, now) {
 // packages/schema/src/errors.ts
 var CcJsonError = class extends Error {
   path;
-  constructor(message, path23) {
-    super(`${message} (en ${path23})`);
+  constructor(message, path24) {
+    super(`${message} (en ${path24})`);
     this.name = "CcJsonError";
-    this.path = path23;
+    this.path = path24;
   }
 };
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function requireRecord(value, path23) {
-  if (!isRecord(value)) throw new CcJsonError("se esperaba un objeto", path23);
+function requireRecord(value, path24) {
+  if (!isRecord(value)) throw new CcJsonError("se esperaba un objeto", path24);
   return value;
 }
-function requireString(value, path23, field5) {
+function requireString(value, path24, field5) {
   if (typeof value !== "string" || value.length === 0) {
-    throw new CcJsonError(`"${field5}" debe ser una cadena no vac\xEDa`, path23);
+    throw new CcJsonError(`"${field5}" debe ser una cadena no vac\xEDa`, path24);
   }
   return value;
 }
@@ -1863,9 +1863,9 @@ var ID_LENGTH = 16;
 function normalizeName(name) {
   return name.normalize("NFC");
 }
-function pathSegments(path23) {
+function pathSegments(path24) {
   const segments = [];
-  for (const raw of path23.replace(/\\/g, "/").split("/")) {
+  for (const raw of path24.replace(/\\/g, "/").split("/")) {
     const segment = normalizeName(raw);
     if (segment === "" || segment === ".") continue;
     if (segment === "..") {
@@ -1879,18 +1879,18 @@ function pathSegments(path23) {
 function canonicalPath(segments) {
   return `/${segments.map(normalizeName).join("/")}`;
 }
-function idFromCanonicalPath(path23, type = "File") {
-  const canonical = path23.startsWith("/") ? path23 : `/${path23}`;
+function idFromCanonicalPath(path24, type = "File") {
+  const canonical = path24.startsWith("/") ? path24 : `/${path24}`;
   return sha256Hex(type + canonical).slice(0, ID_LENGTH);
 }
 function nodeId(type, segments) {
   return idFromCanonicalPath(canonicalPath(segments), type);
 }
-function fileId(path23) {
-  return nodeId("File", pathSegments(path23));
+function fileId(path24) {
+  return nodeId("File", pathSegments(path24));
 }
-function folderId(path23) {
-  return nodeId("Folder", pathSegments(path23));
+function folderId(path24) {
+  return nodeId("Folder", pathSegments(path24));
 }
 
 // packages/schema/src/legacy.ts
@@ -1946,15 +1946,15 @@ function normalizeLegacyCcJson(input) {
   const metrics = {};
   const built = [];
   const ids = /* @__PURE__ */ new Map();
-  const buildNode = (value, parentPath, path23, depth) => {
+  const buildNode = (value, parentPath, path24, depth) => {
     if (depth > MAX_DEPTH) {
-      throw new CcJsonError(`profundidad m\xE1xima ${MAX_DEPTH} superada`, path23);
+      throw new CcJsonError(`profundidad m\xE1xima ${MAX_DEPTH} superada`, path24);
     }
-    const raw = requireRecord(value, path23);
-    const name = readNodeName(raw.name, `${path23}.name`);
+    const raw = requireRecord(value, path24);
+    const name = readNodeName(raw.name, `${path24}.name`);
     const type = raw.type;
     if (type !== "File" && type !== "Folder") {
-      throw new CcJsonError('"type" debe ser "File" o "Folder"', `${path23}.type`);
+      throw new CcJsonError('"type" debe ser "File" o "Folder"', `${path24}.type`);
     }
     const fullPath = [...parentPath, name];
     const id = nodeId(type, fullPath.slice(1));
@@ -1962,13 +1962,13 @@ function normalizeLegacyCcJson(input) {
     if (previous !== void 0) {
       throw new CcJsonError(
         `id duplicado "${id}" para "${previous}" y "${fullPath.join("/")}"`,
-        `${path23}.name`
+        `${path24}.name`
       );
     }
     ids.set(id, fullPath.join("/"));
     built.push({ id, name, fullPath: fullPath.join("/") });
     const node = { id, name, type };
-    const attributes = readMetrics(raw.attributes, `${path23}.attributes`);
+    const attributes = readMetrics(raw.attributes, `${path24}.attributes`);
     if (attributes) metrics[id] = attributes;
     const contentHash = readOptionalString(raw.checksum) ?? readOptionalString(raw.contentHash);
     if (contentHash) node.contentHash = contentHash;
@@ -1976,14 +1976,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', `${path23}.children`);
+        throw new CcJsonError('"children" debe ser un array', `${path24}.children`);
       }
       if (type === "File" && raw.children.length > 0) {
-        throw new CcJsonError("un fichero no puede tener hijos", `${path23}.children`);
+        throw new CcJsonError("un fichero no puede tener hijos", `${path24}.children`);
       }
       if (type === "Folder" && raw.children.length > 0) {
         node.children = raw.children.map(
-          (child, index) => buildNode(child, fullPath, `${path23}.children[${index}]`, depth + 1)
+          (child, index) => buildNode(child, fullPath, `${path24}.children[${index}]`, depth + 1)
         );
       }
     }
@@ -2000,15 +2000,15 @@ function normalizeLegacyCcJson(input) {
       throw new CcJsonError('"edges" debe ser un array', `${base}.edges`);
     }
     edgesRaw.forEach((edge, index) => {
-      const path23 = `${base}.edges[${index}]`;
-      const raw = requireRecord(edge, path23);
-      const fromName = requireString(raw.fromNodeName, `${path23}.fromNodeName`, "fromNodeName");
-      const toName = requireString(raw.toNodeName, `${path23}.toNodeName`, "toNodeName");
+      const path24 = `${base}.edges[${index}]`;
+      const raw = requireRecord(edge, path24);
+      const fromName = requireString(raw.fromNodeName, `${path24}.fromNodeName`, "fromNodeName");
+      const toName = requireString(raw.toNodeName, `${path24}.toNodeName`, "toNodeName");
       const normalized = {
-        fromId: resolveEndpoint(fromName, pathIndex, stripNames, `${path23}.fromNodeName`),
-        toId: resolveEndpoint(toName, pathIndex, stripNames, `${path23}.toNodeName`)
+        fromId: resolveEndpoint(fromName, pathIndex, stripNames, `${path24}.fromNodeName`),
+        toId: resolveEndpoint(toName, pathIndex, stripNames, `${path24}.toNodeName`)
       };
-      const attributes = readMetrics(raw.attributes, `${path23}.attributes`);
+      const attributes = readMetrics(raw.attributes, `${path24}.attributes`);
       if (attributes) normalized.attributes = attributes;
       if (typeof raw.isCyclic === "boolean") normalized.isCyclic = raw.isCyclic;
       if (typeof raw.isPointingUpwards === "boolean") {
@@ -2093,10 +2093,10 @@ function buildPathIndex(built, multipleRoots) {
   }
   return index;
 }
-function resolveEndpoint(endpoint, index, stripNames, path23) {
+function resolveEndpoint(endpoint, index, stripNames, path24) {
   const segments = canonicalSegments(endpoint);
   if (segments.length === 0) {
-    throw new CcJsonError("extremo de arista vac\xEDo", path23);
+    throw new CcJsonError("extremo de arista vac\xEDo", path24);
   }
   const candidates = [segments.join("/")];
   if (segments.length > 1 && stripNames.has(segments[0])) {
@@ -2108,7 +2108,7 @@ function resolveEndpoint(endpoint, index, stripNames, path23) {
   }
   const bare = index.get(segments[segments.length - 1]);
   if (bare) return bare;
-  throw new CcJsonError(`no se pudo resolver el nodo "${endpoint}"`, path23);
+  throw new CcJsonError(`no se pudo resolver el nodo "${endpoint}"`, path24);
 }
 function canonicalSegments(value) {
   const result = [];
@@ -2123,85 +2123,85 @@ function canonicalSegments(value) {
   }
   return result;
 }
-function readNodeName(value, path23) {
-  const name = normalizeName(requireString(value, path23, "name"));
+function readNodeName(value, path24) {
+  const name = normalizeName(requireString(value, path24, "name"));
   if (name === "." || name === "..") {
-    throw new CcJsonError('el nombre no puede ser "." ni ".."', path23);
+    throw new CcJsonError('el nombre no puede ser "." ni ".."', path24);
   }
   if (name.includes("/")) {
-    throw new CcJsonError('el nombre no puede contener "/"', path23);
+    throw new CcJsonError('el nombre no puede contener "/"', path24);
   }
   return name;
 }
 function readOptionalString(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-function readMetrics(value, path23) {
+function readMetrics(value, path24) {
   if (value === void 0) return void 0;
-  const raw = requireRecord(value, path23);
+  const raw = requireRecord(value, path24);
   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`,
-        `${path23}["${metric}"]`
+        `${path24}["${metric}"]`
       );
     }
     out[metric] = metricValue;
   }
   return Object.keys(out).length > 0 ? out : void 0;
 }
-function readAttributeTypes(value, path23) {
+function readAttributeTypes(value, path24) {
   if (value === void 0) return {};
-  const raw = requireRecord(value, path23);
+  const raw = requireRecord(value, path24);
   if ("nodes" in raw || "edges" in raw) {
-    const nodes2 = raw.nodes === void 0 ? void 0 : readTypeMap(raw.nodes, `${path23}.nodes`);
-    const edges = raw.edges === void 0 ? void 0 : readTypeMap(raw.edges, `${path23}.edges`);
+    const nodes2 = raw.nodes === void 0 ? void 0 : readTypeMap(raw.nodes, `${path24}.nodes`);
+    const edges = raw.edges === void 0 ? void 0 : readTypeMap(raw.edges, `${path24}.edges`);
     return {
       ...nodes2 && Object.keys(nodes2).length > 0 ? { nodes: nodes2 } : {},
       ...edges && Object.keys(edges).length > 0 ? { edges } : {}
     };
   }
-  const nodes = readTypeMap(raw, path23);
+  const nodes = readTypeMap(raw, path24);
   return Object.keys(nodes).length > 0 ? { nodes } : {};
 }
-function readTypeMap(value, path23) {
-  const raw = requireRecord(value, path23);
+function readTypeMap(value, path24) {
+  const raw = requireRecord(value, path24);
   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"`,
-        `${path23}["${metric}"]`
+        `${path24}["${metric}"]`
       );
     }
     out[metric] = type;
   }
   return out;
 }
-function readDescriptors(value, path23) {
+function readDescriptors(value, path24) {
   if (value === void 0) return {};
-  const raw = requireRecord(value, path23);
+  const raw = requireRecord(value, path24);
   if ("nodes" in raw || "edges" in raw) {
-    const nodes = raw.nodes === void 0 ? void 0 : readDescriptorMap(raw.nodes, `${path23}.nodes`);
-    const edges = raw.edges === void 0 ? void 0 : readDescriptorMap(raw.edges, `${path23}.edges`);
+    const nodes = raw.nodes === void 0 ? void 0 : readDescriptorMap(raw.nodes, `${path24}.nodes`);
+    const edges = raw.edges === void 0 ? void 0 : readDescriptorMap(raw.edges, `${path24}.edges`);
     return {
       ...nodes && Object.keys(nodes).length > 0 ? { nodes } : {},
       ...edges && Object.keys(edges).length > 0 ? { edges } : {}
     };
   }
-  const flat = readDescriptorMap(raw, path23);
+  const flat = readDescriptorMap(raw, path24);
   return Object.keys(flat).length > 0 ? { flat } : {};
 }
-function readDescriptorMap(value, path23) {
-  const raw = requireRecord(value, path23);
+function readDescriptorMap(value, path24) {
+  const raw = requireRecord(value, path24);
   const out = {};
   for (const [metric, descriptor] of Object.entries(raw)) {
-    const record = requireRecord(descriptor, `${path23}["${metric}"]`);
+    const record = requireRecord(descriptor, `${path24}["${metric}"]`);
     if (record.direction !== void 0 && typeof record.direction !== "number") {
       throw new CcJsonError(
         `"direction" de "${metric}" debe ser un n\xFAmero`,
-        `${path23}["${metric}"].direction`
+        `${path24}["${metric}"].direction`
       );
     }
     out[metric] = record;
@@ -2226,26 +2226,26 @@ function parseCcJson2(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, path23, depth) => {
-    if (depth > MAX_DEPTH2) throw new CcJsonError(`profundidad m\xE1xima ${MAX_DEPTH2} superada`, path23);
-    const raw = requireRecord(value, path23);
-    const id = requireString(raw.id, `${path23}.id`, "id");
-    if (ids.has(id)) throw new CcJsonError(`id duplicado "${id}"`, `${path23}.id`);
+  const validateNode = (value, path24, depth) => {
+    if (depth > MAX_DEPTH2) throw new CcJsonError(`profundidad m\xE1xima ${MAX_DEPTH2} superada`, path24);
+    const raw = requireRecord(value, path24);
+    const id = requireString(raw.id, `${path24}.id`, "id");
+    if (ids.has(id)) throw new CcJsonError(`id duplicado "${id}"`, `${path24}.id`);
     ids.add(id);
-    const name = requireString(raw.name, `${path23}.name`, "name");
+    const name = requireString(raw.name, `${path24}.name`, "name");
     const type = raw.type;
     if (type !== "File" && type !== "Folder") {
-      throw new CcJsonError('"type" debe ser "File" o "Folder"', `${path23}.type`);
+      throw new CcJsonError('"type" debe ser "File" o "Folder"', `${path24}.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', `${path23}.children`);
+        throw new CcJsonError('"children" debe ser un array', `${path24}.children`);
       }
       node.children = raw.children.map(
-        (child, index) => validateNode(child, `${path23}.children[${index}]`, depth + 1)
+        (child, index) => validateNode(child, `${path24}.children[${index}]`, depth + 1)
       );
     }
     return node;
@@ -2276,10 +2276,10 @@ function parseCcJson2(input) {
           throw new CcJsonError('"edges" debe ser un array', "$.lenses.dependency.edges");
         }
         dependency.edges.forEach((edge, index) => {
-          const path23 = `$.lenses.dependency.edges[${index}]`;
-          const raw = requireRecord(edge, path23);
-          requireString(raw.fromId, `${path23}.fromId`, "fromId");
-          requireString(raw.toId, `${path23}.toId`, "toId");
+          const path24 = `$.lenses.dependency.edges[${index}]`;
+          const raw = requireRecord(edge, path24);
+          requireString(raw.fromId, `${path24}.fromId`, "fromId");
+          requireString(raw.toId, `${path24}.toId`, "toId");
         });
       }
     }
@@ -2431,9 +2431,9 @@ function topByMetric(cc, metric, limit = 10) {
   const ranked = [];
   for (const [id, values] of Object.entries(attributes)) {
     const value = values[metric];
-    const path23 = paths.get(id);
-    if (value === void 0 || path23 === void 0) continue;
-    ranked.push({ id, path: path23, value });
+    const path24 = paths.get(id);
+    if (value === void 0 || path24 === void 0) continue;
+    ranked.push({ id, path: path24, value });
   }
   ranked.sort((a, b) => b.value - a.value || a.path.localeCompare(b.path));
   return ranked.slice(0, limit);
@@ -2919,11 +2919,11 @@ function summarize(index) {
 }
 function difference(present, absent) {
   const files = [];
-  for (const [id, path23] of present.paths) {
+  for (const [id, path24] of present.paths) {
     if (absent.paths.has(id)) continue;
     files.push({
       id,
-      path: path23,
+      path: path24,
       metrics: sortedMetrics(present.metrics[id])
     });
   }
@@ -2931,7 +2931,7 @@ function difference(present, absent) {
 }
 function changedFiles(base, head) {
   const changed = [];
-  for (const [id, path23] of head.paths) {
+  for (const [id, path24] of head.paths) {
     if (!base.paths.has(id)) continue;
     const baseValues = base.metrics[id] ?? {};
     const headValues = head.metrics[id] ?? {};
@@ -2951,7 +2951,7 @@ function changedFiles(base, head) {
         delta: baseValue !== null && headValue !== null ? headValue - baseValue : null
       });
     }
-    if (changes.length > 0) changed.push({ id, path: path23, changes });
+    if (changes.length > 0) changed.push({ id, path: path24, changes });
   }
   return changed.sort(compareChangedFiles);
 }
@@ -3184,8 +3184,8 @@ function suggestLayers(cc) {
   const edges = cc.lenses?.dependency?.edges ?? [];
   const groups = /* @__PURE__ */ new Map();
   let ungrouped = 0;
-  const groupOf = (path23) => {
-    const parts = path23.split("/").filter(Boolean);
+  const groupOf = (path24) => {
+    const parts = path24.split("/").filter(Boolean);
     if (parts.length === 0) return null;
     const directory = parts.slice(0, -1);
     if (directory.length === 0) {
@@ -3211,7 +3211,7 @@ function suggestLayers(cc) {
     group.files += 1;
     return group;
   };
-  for (const path23 of paths.values()) groupOf(path23);
+  for (const path24 of paths.values()) groupOf(path24);
   const groupEdges = [];
   for (const edge of edges) {
     const fromPath = paths.get(edge.fromId);
@@ -3816,11 +3816,13 @@ function describeSymbol(name, kind, node, nameNode, complexity) {
     name,
     kind,
     line: node.startPosition.row + 1,
+    // La ficha necesita el cuerpo entero para enseñar el código del símbolo
+    // (ADR 0067): no solo las funciones tienen líneas.
+    lines: node.endPosition.row - node.startPosition.row + 1,
     hash: bodyHash(node, nameNode)
   };
   if (kind === "function") {
     symbol.complexity = complexity ?? functionComplexity(node);
-    symbol.lines = node.endPosition.row - node.startPosition.row + 1;
   }
   return symbol;
 }
@@ -5326,8 +5328,8 @@ function buildSnapshot(input) {
     isCyclic: edge.isCyclic
   }));
   const dependencyNodes = {};
-  for (const [path23, metrics] of input.graph.metrics) {
-    dependencyNodes[fileId(path23)] = { level: metrics.dependencyLevel };
+  for (const [path24, metrics] of input.graph.metrics) {
+    dependencyNodes[fileId(path24)] = { level: metrics.dependencyLevel };
   }
   const migrationLens = input.migration ? migrationLensFrom(input.migration) : void 0;
   const symbolsSummary = {
@@ -5975,8 +5977,8 @@ function parseGitStatus(output) {
       continue;
     }
     if (kind === "2") {
-      const path23 = normalizeGitPath(tail(record, 9));
-      changes.push({ path: path23, kind: "renamed" });
+      const path24 = normalizeGitPath(tail(record, 9));
+      changes.push({ path: path24, kind: "renamed" });
       const from = normalizeGitPath(records[index + 1] ?? "");
       if (from) {
         changes.push({ path: from, kind: "deleted" });
@@ -6351,10 +6353,76 @@ function ensureGitignoreEntry(root, entry) {
   }
 }
 
-// packages/parsers/src/safety.ts
+// packages/parsers/src/source.ts
 import fs8 from "node:fs";
-import os from "node:os";
 import path8 from "node:path";
+var SOURCE_EXTENSIONS2 = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs"
+]);
+var DENIED_SEGMENTS = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  ".codarch",
+  ".codarch-history",
+  "dist",
+  "build",
+  "coverage"
+]);
+var MAX_LINES = 400;
+var MAX_BYTES = 1e6;
+function readSourceSnippet(root, relativePath3, start = 1, end = MAX_LINES) {
+  const normalized = relativePath3.replaceAll("\\", "/").replace(/^\/+/, "");
+  if (!normalized || normalized.includes("\0")) return null;
+  if (normalized.startsWith("../") || normalized.includes("/../")) return null;
+  const segments = normalized.split("/");
+  if (segments.some((segment) => DENIED_SEGMENTS.has(segment))) return null;
+  if (!SOURCE_EXTENSIONS2.has(path8.extname(normalized).toLowerCase())) return null;
+  const rootPath = path8.resolve(root);
+  const file = path8.resolve(rootPath, normalized);
+  const prefix = rootPath.endsWith(path8.sep) ? rootPath : `${rootPath}${path8.sep}`;
+  if (!file.startsWith(prefix)) return null;
+  try {
+    const stats = fs8.statSync(file);
+    if (!stats.isFile() || stats.size > MAX_BYTES) return null;
+    const realRoot = fs8.realpathSync(rootPath);
+    const realFile = fs8.realpathSync(file);
+    const realPrefix = realRoot.endsWith(path8.sep) ? realRoot : `${realRoot}${path8.sep}`;
+    if (!realFile.startsWith(realPrefix)) return null;
+    const text = fs8.readFileSync(file, "utf8");
+    const all = text.split(/\r?\n/);
+    const total = all.length;
+    const first = Math.max(1, Math.trunc(start) || 1);
+    const last = Math.min(
+      total,
+      Math.max(first, Math.trunc(end) || first),
+      first + MAX_LINES - 1
+    );
+    if (first > total) {
+      return { path: normalized, start: first, end: first, total, lines: [] };
+    }
+    return {
+      path: normalized,
+      start: first,
+      end: last,
+      total,
+      lines: all.slice(first - 1, last)
+    };
+  } catch {
+    return null;
+  }
+}
+
+// packages/parsers/src/safety.ts
+import fs9 from "node:fs";
+import os from "node:os";
+import path9 from "node:path";
 var UNIX_PROTECTED = [
   "/bin",
   "/boot",
@@ -6401,7 +6469,7 @@ function protegidas(platform, env) {
   return platform === "darwin" ? MAC_PROTECTED : UNIX_PROTECTED;
 }
 function plataforma(platform) {
-  return platform === "win32" ? path8.win32 : path8.posix;
+  return platform === "win32" ? path9.win32 : path9.posix;
 }
 function comparable(value, platform) {
   const resolved = plataforma(platform).resolve(value);
@@ -6414,7 +6482,7 @@ function dentro(root, base, platform) {
 }
 function real(value) {
   try {
-    return fs8.realpathSync.native(value);
+    return fs9.realpathSync.native(value);
   } catch {
     return value;
   }
@@ -6448,8 +6516,8 @@ function protectedRootReason(root, options = {}) {
 }
 
 // packages/parsers/src/watch.ts
-import fs9 from "node:fs";
-import path9 from "node:path";
+import fs10 from "node:fs";
+import path10 from "node:path";
 
 // packages/parsers/node_modules/chokidar/esm/index.js
 import { stat as statcb } from "fs";
@@ -6527,7 +6595,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path23) => statMethod(path23, { bigint: true });
+      this._stat = (path24) => statMethod(path24, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -6552,8 +6620,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path23, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path23));
+          const { path: path24, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path24));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -6593,20 +6661,20 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path23, depth) {
+  async _exploreDir(path24, depth) {
     let files;
     try {
-      files = await readdir(path23, this._rdOptions);
+      files = await readdir(path24, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path23 };
+    return { files, depth, path: path24 };
   }
-  async _formatEntry(dirent, path23) {
+  async _formatEntry(dirent, path24) {
     let entry;
     const basename5 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path23, basename5));
+      const fullPath = presolve(pjoin(path24, basename5));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename5 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -7006,16 +7074,16 @@ var delFromSet = (main2, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path23, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path24, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path23);
-    emitRaw(rawEvent, evPath, { watchedPath: path23 });
-    if (evPath && path23 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path23, evPath), KEY_LISTENERS, sysPath.join(path23, evPath));
+    listener(path24);
+    emitRaw(rawEvent, evPath, { watchedPath: path24 });
+    if (evPath && path24 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path24, evPath), KEY_LISTENERS, sysPath.join(path24, evPath));
     }
   };
   try {
-    return fs_watch(path23, {
+    return fs_watch(path24, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -7031,12 +7099,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path23, fullPath, options, handlers) => {
+var setFsWatchListener = (path24, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path23, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path24, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -7047,7 +7115,7 @@ var setFsWatchListener = (path23, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path23,
+      path24,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -7062,7 +7130,7 @@ var setFsWatchListener = (path23, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path23, "r");
+          const fd = await open(path24, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -7093,7 +7161,7 @@ var setFsWatchListener = (path23, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path23, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path24, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -7115,7 +7183,7 @@ var setFsWatchFileListener = (path23, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path23, curr));
+          foreach(cont.listeners, (listener2) => listener2(path24, curr));
         }
       })
     };
@@ -7143,13 +7211,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path23, listener) {
+  _watchWithNodeFs(path24, listener) {
     const opts = this.fsw.options;
-    const directory = sysPath.dirname(path23);
-    const basename5 = sysPath.basename(path23);
+    const directory = sysPath.dirname(path24);
+    const basename5 = sysPath.basename(path24);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename5);
-    const absolutePath = sysPath.resolve(path23);
+    const absolutePath = sysPath.resolve(path24);
     const options = {
       persistent: opts.persistent
     };
@@ -7159,12 +7227,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename5) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path23, absolutePath, options, {
+      closer = setFsWatchFileListener(path24, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path23, absolutePath, options, {
+      closer = setFsWatchListener(path24, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -7186,7 +7254,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename5))
       return;
-    const listener = async (path23, newStats) => {
+    const listener = async (path24, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -7200,11 +7268,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path23);
+            this.fsw._closeFile(path24);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path23, closer2);
+              this.fsw._addPathCloser(path24, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -7236,7 +7304,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path23, item) {
+  async _handleSymlink(entry, directory, path24, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -7246,7 +7314,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path23);
+        linkPath = await fsrealpath(path24);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -7256,12 +7324,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path23, entry.stats);
+          this.fsw._emit(EV.CHANGE, path24, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path23, entry.stats);
+        this.fsw._emit(EV.ADD, path24, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -7290,9 +7358,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path23 = sysPath.join(directory, item);
+      let path24 = sysPath.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path23, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path24, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -7301,8 +7369,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path23 = sysPath.join(dir, sysPath.relative(dir, path23));
-        this._addToNodeFs(path23, initialAdd, wh, depth + 1);
+        path24 = sysPath.join(dir, sysPath.relative(dir, path24));
+        this._addToNodeFs(path24, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve4, reject) => {
@@ -7371,13 +7439,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path23, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path24, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path23) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path24) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path23);
+    const wh = this.fsw._getWatchHelpers(path24);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -7393,8 +7461,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path23);
-        const targetPath = follow ? await fsrealpath(path23) : path23;
+        const absPath = sysPath.resolve(path24);
+        const targetPath = follow ? await fsrealpath(path24) : path24;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -7404,29 +7472,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path23) : path23;
+        const targetPath = follow ? await fsrealpath(path24) : path24;
         if (this.fsw.closed)
           return;
         const parent = sysPath.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path23, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path24, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sysPath.resolve(path23), targetPath);
+          this.fsw._symlinkPaths.set(sysPath.resolve(path24), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path23, closer);
+        this.fsw._addPathCloser(path24, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path23;
+        return path24;
       }
     }
   }
@@ -7469,26 +7537,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path23) {
-  if (typeof path23 !== "string")
+function normalizePath(path24) {
+  if (typeof path24 !== "string")
     throw new Error("string expected");
-  path23 = sysPath2.normalize(path23);
-  path23 = path23.replace(/\\/g, "/");
+  path24 = sysPath2.normalize(path24);
+  path24 = path24.replace(/\\/g, "/");
   let prepend = false;
-  if (path23.startsWith("//"))
+  if (path24.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path23.match(DOUBLE_SLASH_RE2))
-    path23 = path23.replace(DOUBLE_SLASH_RE2, "/");
+  while (path24.match(DOUBLE_SLASH_RE2))
+    path24 = path24.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path23 = "/" + path23;
-  return path23;
+    path24 = "/" + path24;
+  return path24;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path23 = normalizePath(testString);
+  const path24 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path23, stats)) {
+    if (pattern(path24, stats)) {
       return true;
     }
   }
@@ -7528,19 +7596,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path23) => toUnix(sysPath2.normalize(toUnix(path23)));
-var normalizeIgnored = (cwd = "") => (path23) => {
-  if (typeof path23 === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path23) ? path23 : sysPath2.join(cwd, path23));
+var normalizePathToUnix = (path24) => toUnix(sysPath2.normalize(toUnix(path24)));
+var normalizeIgnored = (cwd = "") => (path24) => {
+  if (typeof path24 === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path24) ? path24 : sysPath2.join(cwd, path24));
   } else {
-    return path23;
+    return path24;
   }
 };
-var getAbsolutePath = (path23, cwd) => {
-  if (sysPath2.isAbsolute(path23)) {
-    return path23;
+var getAbsolutePath = (path24, cwd) => {
+  if (sysPath2.isAbsolute(path24)) {
+    return path24;
   }
-  return sysPath2.join(cwd, path23);
+  return sysPath2.join(cwd, path24);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -7595,10 +7663,10 @@ var DirEntry = class {
 var STAT_METHOD_F = "stat";
 var STAT_METHOD_L = "lstat";
 var WatchHelper = class {
-  constructor(path23, follow, fsw) {
+  constructor(path24, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path23;
-    this.path = path23 = path23.replace(REPLACER_RE, "");
+    const watchPath = path24;
+    this.path = path24 = path24.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sysPath2.resolve(watchPath);
     this.dirParts = [];
@@ -7720,20 +7788,20 @@ var FSWatcher = class extends EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path23) => {
-        const absPath = getAbsolutePath(path23, cwd);
+      paths = paths.map((path24) => {
+        const absPath = getAbsolutePath(path24, cwd);
         return absPath;
       });
     }
-    paths.forEach((path23) => {
-      this._removeIgnoredPath(path23);
+    paths.forEach((path24) => {
+      this._removeIgnoredPath(path24);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path23) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path23, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path24) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path24, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -7755,17 +7823,17 @@ var FSWatcher = class extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path23) => {
-      if (!sysPath2.isAbsolute(path23) && !this._closers.has(path23)) {
+    paths.forEach((path24) => {
+      if (!sysPath2.isAbsolute(path24) && !this._closers.has(path24)) {
         if (cwd)
-          path23 = sysPath2.join(cwd, path23);
-        path23 = sysPath2.resolve(path23);
+          path24 = sysPath2.join(cwd, path24);
+        path24 = sysPath2.resolve(path24);
       }
-      this._closePath(path23);
-      this._addIgnoredPath(path23);
-      if (this._watched.has(path23)) {
+      this._closePath(path24);
+      this._addIgnoredPath(path24);
+      if (this._watched.has(path24)) {
         this._addIgnoredPath({
-          path: path23,
+          path: path24,
           recursive: true
         });
       }
@@ -7829,38 +7897,38 @@ var FSWatcher = class extends EventEmitter {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path23, stats) {
+  async _emit(event, path24, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path23 = sysPath2.normalize(path23);
+      path24 = sysPath2.normalize(path24);
     if (opts.cwd)
-      path23 = sysPath2.relative(opts.cwd, path23);
-    const args = [path23];
+      path24 = sysPath2.relative(opts.cwd, path24);
+    const args = [path24];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path23))) {
+    if (awf && (pw = this._pendingWrites.get(path24))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path23, [event, ...args]);
+        this._pendingUnlinks.set(path24, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path24) => {
+          this._pendingUnlinks.forEach((entry, path25) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path24);
+            this._pendingUnlinks.delete(path25);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path23)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path24)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path23);
+        this._pendingUnlinks.delete(path24);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -7878,16 +7946,16 @@ var FSWatcher = class extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path23, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path24, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path23, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path24, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path23) : path23;
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path24) : path24;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -7918,23 +7986,23 @@ var FSWatcher = class extends EventEmitter {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path23, timeout) {
+  _throttle(actionType, path24, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path23);
+    const actionPath = action.get(path24);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path23);
+      const item = action.get(path24);
       const count = item ? item.count : 0;
-      action.delete(path23);
+      action.delete(path24);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -7942,7 +8010,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path23, thr);
+    action.set(path24, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -7956,44 +8024,44 @@ var FSWatcher = class extends EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path23, threshold, event, awfEmit) {
+  _awaitWriteFinish(path24, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path23;
-    if (this.options.cwd && !sysPath2.isAbsolute(path23)) {
-      fullPath = sysPath2.join(this.options.cwd, path23);
+    let fullPath = path24;
+    if (this.options.cwd && !sysPath2.isAbsolute(path24)) {
+      fullPath = sysPath2.join(this.options.cwd, path24);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path23)) {
+        if (err || !writes.has(path24)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path23).lastChange = now2;
+          writes.get(path24).lastChange = now2;
         }
-        const pw = writes.get(path23);
+        const pw = writes.get(path24);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path23);
+          writes.delete(path24);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path23)) {
-      writes.set(path23, {
+    if (!writes.has(path24)) {
+      writes.set(path24, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path23);
+          writes.delete(path24);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -8004,8 +8072,8 @@ var FSWatcher = class extends EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path23, stats) {
-    if (this.options.atomic && DOT_RE.test(path23))
+  _isIgnored(path24, stats) {
+    if (this.options.atomic && DOT_RE.test(path24))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -8015,17 +8083,17 @@ var FSWatcher = class extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path23, stats);
+    return this._userIgnored(path24, stats);
   }
-  _isntIgnored(path23, stat4) {
-    return !this._isIgnored(path23, stat4);
+  _isntIgnored(path24, stat4) {
+    return !this._isIgnored(path24, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path23) {
-    return new WatchHelper(path23, this.options.followSymlinks, this);
+  _getWatchHelpers(path24) {
+    return new WatchHelper(path24, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -8057,63 +8125,63 @@ var FSWatcher = class extends EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path23 = sysPath2.join(directory, item);
-    const fullPath = sysPath2.resolve(path23);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path23) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path23, 100))
+    const path24 = sysPath2.join(directory, item);
+    const fullPath = sysPath2.resolve(path24);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path24) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path24, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path23);
+    const wp = this._getWatchedDir(path24);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path23, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path24, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path23;
+    let relPath = path24;
     if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path23);
+      relPath = sysPath2.relative(this.options.cwd, path24);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path23);
+    this._watched.delete(path24);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path23))
-      this._emit(eventName, path23);
-    this._closePath(path23);
+    if (wasTracked && !this._isIgnored(path24))
+      this._emit(eventName, path24);
+    this._closePath(path24);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path23) {
-    this._closeFile(path23);
-    const dir = sysPath2.dirname(path23);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path23));
+  _closePath(path24) {
+    this._closeFile(path24);
+    const dir = sysPath2.dirname(path24);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path24));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path23) {
-    const closers = this._closers.get(path23);
+  _closeFile(path24) {
+    const closers = this._closers.get(path24);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path23);
+    this._closers.delete(path24);
   }
-  _addPathCloser(path23, closer) {
+  _addPathCloser(path24, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path23);
+    let list = this._closers.get(path24);
     if (!list) {
       list = [];
-      this._closers.set(path23, list);
+      this._closers.set(path24, list);
     }
     list.push(closer);
   }
@@ -8175,7 +8243,7 @@ function watchRepository(root, options) {
   let recursive = true;
   try {
     watchers.push(
-      fs9.watch(root, { recursive: true }, (_event, filename) => {
+      fs10.watch(root, { recursive: true }, (_event, filename) => {
         if (filename) note(filename.toString());
       })
     );
@@ -8189,7 +8257,7 @@ function watchRepository(root, options) {
   let git = false;
   try {
     watchers.push(
-      fs9.watch(path9.join(root, ".git"), { recursive: false }, () => {
+      fs10.watch(path10.join(root, ".git"), { recursive: false }, () => {
         gitChanged = true;
         schedule();
       })
@@ -8217,7 +8285,7 @@ function chokidarWatcherFor(root, delayMs, options) {
     // Un editor puede escribir el fichero en dos pasos; esperamos a que acabe.
     awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 },
     ignored: (candidate) => {
-      const relative4 = path9.relative(root, candidate);
+      const relative4 = path10.relative(root, candidate);
       if (relative4 === "") return false;
       return isLiveIgnored(relative4);
     }
@@ -8230,7 +8298,7 @@ function chokidarWatcherFor(root, delayMs, options) {
     options.onChange(paths);
   };
   watcher.on("all", (_event, changed) => {
-    pending.add(path9.relative(root, changed));
+    pending.add(path10.relative(root, changed));
     if (timer) clearTimeout(timer);
     timer = setTimeout(flush, delayMs);
   });
@@ -8330,8 +8398,8 @@ function hashString(value) {
   }
   return hash >>> 0;
 }
-function sectionForPath(path23) {
-  const folders = path23.split("/").filter(Boolean).slice(0, -1);
+function sectionForPath(path24) {
+  const folders = path24.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("/");
@@ -8357,6 +8425,13 @@ function metricTitle(attributes, key) {
   }
   return key;
 }
+function metricDescription(attributes, key) {
+  const descriptor = attributes?.[key];
+  if (isRecord3(descriptor) && typeof descriptor.description === "string" && descriptor.description) {
+    return descriptor.description;
+  }
+  return void 0;
+}
 function metricDirection(attributes, key) {
   const descriptor = attributes?.[key];
   if (isRecord3(descriptor) && typeof descriptor.direction === "number") {
@@ -8401,7 +8476,7 @@ function buildRenderModel(cc, options = {}) {
   const fileIndexById = /* @__PURE__ */ new Map();
   walkFiles(cc.files, (entry) => {
     const fullPath = entry.path;
-    const path23 = prefix && fullPath.startsWith(prefix) ? fullPath.slice(prefix.length) : fullPath;
+    const path24 = prefix && fullPath.startsWith(prefix) ? fullPath.slice(prefix.length) : fullPath;
     const values = attributes[entry.node.id];
     const rawArea = valueOf(values, areaMetric);
     const index = files.length;
@@ -8409,7 +8484,7 @@ function buildRenderModel(cc, options = {}) {
     files.push({
       index,
       nodeId: entry.node.id,
-      path: path23,
+      path: path24,
       name: entry.node.name,
       section: -1,
       area: Math.max(1, rawArea ?? 0),
@@ -8474,6 +8549,7 @@ function buildRenderModel(cc, options = {}) {
     return {
       key,
       title: metricTitle(descriptors, key),
+      description: metricDescription(descriptors, key),
       direction: metricDirection(descriptors, key),
       min,
       max,
@@ -8572,7 +8648,7 @@ function buildRenderModel(cc, options = {}) {
   };
 }
 function buildRoots(cc, singleRoot, fileIndexById, files) {
-  const build = (node, path23) => {
+  const build = (node, path24) => {
     if (node.type === "File") {
       const index = fileIndexById.get(node.id);
       const file = index === void 0 ? void 0 : files[index];
@@ -8580,7 +8656,7 @@ function buildRoots(cc, singleRoot, fileIndexById, files) {
         kind: "file",
         key: `f:${index ?? -1}`,
         name: node.name,
-        path: path23,
+        path: path24,
         value: file?.area ?? 1,
         fileCount: 1,
         section: file?.section ?? 0,
@@ -8588,13 +8664,13 @@ function buildRoots(cc, singleRoot, fileIndexById, files) {
       };
     }
     const children = (node.children ?? []).map(
-      (child) => build(child, path23 ? `${path23}/${child.name}` : child.name)
+      (child) => build(child, path24 ? `${path24}/${child.name}` : child.name)
     );
     const folder = {
       kind: "folder",
-      key: `d:${path23}`,
+      key: `d:${path24}`,
       name: node.name,
-      path: path23,
+      path: path24,
       value: children.reduce((sum, child) => sum + child.value, 0) || 1,
       fileCount: children.reduce((sum, child) => sum + child.fileCount, 0),
       section: -1,
@@ -9238,21 +9314,21 @@ function renderHtml(model) {
 }
 
 // apps/cli/src/config.ts
-import path10 from "node:path";
+import path11 from "node:path";
 function defaultConfigPath(root = ".") {
   return findProjectConfig(root);
 }
 function loadProjectIgnore2(root, options = {}) {
   if (options.noConfig) return [];
-  const file = options.config ? path10.resolve(options.config) : defaultConfigPath(root);
+  const file = options.config ? path11.resolve(options.config) : defaultConfigPath(root);
   return file ? loadIgnoreConfig(file) : [];
 }
 
 // apps/cli/src/io.ts
-import fs10 from "node:fs";
+import fs11 from "node:fs";
 import zlib from "node:zlib";
 function readJsonFile2(file) {
-  const buffer = fs10.readFileSync(file);
+  const buffer = fs11.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");
@@ -9321,18 +9397,18 @@ function runAnalyze(options) {
     }
     throw error;
   }
-  const rootPath = path11.resolve(root);
-  const outDirectory = path11.resolve(
-    options.out ?? path11.join(rootPath, ".codarch")
+  const rootPath = path12.resolve(root);
+  const outDirectory = path12.resolve(
+    options.out ?? path12.join(rootPath, ".codarch")
   );
-  const snapshotPath = path11.join(outDirectory, "snapshot.cc.json");
-  const mapPath = path11.join(outDirectory, "map.html");
+  const snapshotPath = path12.join(outDirectory, "snapshot.cc.json");
+  const mapPath = path12.join(outDirectory, "map.html");
   try {
-    if (outDirectory === path11.join(rootPath, ".codarch") && !fs11.existsSync(outDirectory)) {
+    if (outDirectory === path12.join(rootPath, ".codarch") && !fs12.existsSync(outDirectory)) {
       ensureGitignoreEntry(rootPath, ".codarch/");
     }
-    fs11.mkdirSync(outDirectory, { recursive: true });
-    fs11.writeFileSync(
+    fs12.mkdirSync(outDirectory, { recursive: true });
+    fs12.writeFileSync(
       snapshotPath,
       `${JSON.stringify(cc, null, 2)}
 `,
@@ -9354,7 +9430,7 @@ function runAnalyze(options) {
         title: options.title
       });
       const html = renderHtml(model);
-      fs11.writeFileSync(mapPath, html, "utf8");
+      fs12.writeFileSync(mapPath, html, "utf8");
       mapBytes = Buffer.byteLength(html, "utf8");
     } catch (error) {
       mapError = error instanceof RenderError ? error.message : error.message;
@@ -9363,14 +9439,14 @@ function runAnalyze(options) {
     mapError = "no hay ficheros TypeScript/JavaScript que dibujar";
   }
   const snapshotBytes = Buffer.byteLength(
-    fs11.readFileSync(snapshotPath),
+    fs12.readFileSync(snapshotPath),
     "utf8"
   );
   const lines = [];
   lines.push("");
   lines.push("  CodArch \xB7 an\xE1lisis");
   lines.push("");
-  lines.push(field("ra\xEDz", path11.resolve(root)));
+  lines.push(field("ra\xEDz", path12.resolve(root)));
   lines.push(field("snapshot", `${snapshotPath} (${formatBytes(snapshotBytes)})`));
   if (mapError) {
     lines.push(field("mapa", `omitido (${mapError})`));
@@ -9409,7 +9485,7 @@ function runAnalyze(options) {
   lines.push(field("tiempo", `${num(result.durationMs)} ms`));
   if (options.history) {
     try {
-      const saved = saveHistory(path11.resolve(root), cc, /* @__PURE__ */ new Date());
+      const saved = saveHistory(path12.resolve(root), cc, /* @__PURE__ */ new Date());
       lines.push(
         field(
           "historial",
@@ -9453,7 +9529,7 @@ function runAnalyze(options) {
 }
 
 // apps/cli/src/commands/diff.ts
-import path14 from "node:path";
+import path15 from "node:path";
 
 // packages/addons/src/index.ts
 var AddonError = class extends Error {
@@ -9508,32 +9584,32 @@ function parseAddonManifest(input) {
     }
   };
 }
-function parseAddonView(input, path23) {
-  const view = asObject2(input, path23);
-  rejectUnknown(view, VIEW_KEYS, path23);
-  const state = asObject2(view.state ?? {}, `${path23}.state`);
-  rejectUnknown(state, STATE_KEYS, `${path23}.state`);
-  const tab = optionalString(state.tab, `${path23}.state.tab`);
+function parseAddonView(input, path24) {
+  const view = asObject2(input, path24);
+  rejectUnknown(view, VIEW_KEYS, path24);
+  const state = asObject2(view.state ?? {}, `${path24}.state`);
+  rejectUnknown(state, STATE_KEYS, `${path24}.state`);
+  const tab = optionalString(state.tab, `${path24}.state.tab`);
   const normalizedTab = tab === "lenses" ? "rules" : tab === "pr" ? "changes" : tab;
   if (normalizedTab !== void 0 && normalizedTab !== "file" && normalizedTab !== "rules" && normalizedTab !== "changes") {
     throw new AddonError(
-      `${path23}.state.tab debe ser file, rules o changes`
+      `${path24}.state.tab debe ser file, rules o changes`
     );
   }
   if (state.labels !== void 0 && typeof state.labels !== "boolean") {
-    throw new AddonError(`${path23}.state.labels debe ser true o false`);
+    throw new AddonError(`${path24}.state.labels debe ser true o false`);
   }
   return {
-    id: asString2(view.id, `${path23}.id`),
-    title: asString2(view.title, `${path23}.title`),
-    description: optionalString(view.description, `${path23}.description`),
+    id: asString2(view.id, `${path24}.id`),
+    title: asString2(view.title, `${path24}.title`),
+    description: optionalString(view.description, `${path24}.description`),
     state: {
-      area: optionalString(state.area, `${path23}.state.area`),
-      color: optionalString(state.color, `${path23}.state.color`),
-      focus: optionalString(state.focus, `${path23}.state.focus`),
-      file: optionalString(state.file, `${path23}.state.file`),
+      area: optionalString(state.area, `${path24}.state.area`),
+      color: optionalString(state.color, `${path24}.state.color`),
+      focus: optionalString(state.focus, `${path24}.state.focus`),
+      file: optionalString(state.file, `${path24}.state.file`),
       tab: normalizedTab,
-      symbol: optionalString(state.symbol, `${path23}.state.symbol`),
+      symbol: optionalString(state.symbol, `${path24}.state.symbol`),
       labels: state.labels
     }
   };
@@ -9600,64 +9676,64 @@ function addonError(name, error) {
   }
   return new AddonError(`addons/${name}: ${error.message}`);
 }
-function rejectUnknown(value, known, path23) {
+function rejectUnknown(value, known, path24) {
   const allowed = new Set(known);
   for (const key of Object.keys(value)) {
     if (!allowed.has(key)) {
       throw new AddonError(
-        `${path23}: clave desconocida "${key}" (se admite: ${known.join(", ")})`
+        `${path24}: clave desconocida "${key}" (se admite: ${known.join(", ")})`
       );
     }
   }
 }
-function parsePathList(value, path23) {
+function parsePathList(value, path24) {
   if (value === void 0 || value === null) return [];
   if (!Array.isArray(value)) {
-    throw new AddonError(`${path23} debe ser una lista`);
+    throw new AddonError(`${path24} debe ser una lista`);
   }
   return value.map((raw, index) => {
-    const file = asString2(raw, `${path23}[${index}]`);
+    const file = asString2(raw, `${path24}[${index}]`);
     if (file.startsWith("/") || /^[A-Za-z]:[\\/]/.test(file) || file.startsWith("\\")) {
       throw new AddonError(
-        `${path23}[${index}] debe ser relativo a la carpeta del addon: ${file}`
+        `${path24}[${index}] debe ser relativo a la carpeta del addon: ${file}`
       );
     }
     if (file.split(/[\\/]/).includes("..")) {
       throw new AddonError(
-        `${path23}[${index}] no puede salirse de la carpeta del addon: ${file}`
+        `${path24}[${index}] no puede salirse de la carpeta del addon: ${file}`
       );
     }
     return file.replaceAll("\\", "/");
   });
 }
-function asObject2(value, path23) {
+function asObject2(value, path24) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new AddonError(`${path23} debe ser un objeto`);
+    throw new AddonError(`${path24} debe ser un objeto`);
   }
   return value;
 }
-function asString2(value, path23) {
+function asString2(value, path24) {
   if (typeof value !== "string" || value.trim() === "") {
-    throw new AddonError(`${path23} debe ser un texto no vac\xEDo`);
+    throw new AddonError(`${path24} debe ser un texto no vac\xEDo`);
   }
   return value.trim();
 }
-function optionalString(value, path23) {
+function optionalString(value, path24) {
   if (value === void 0 || value === null) return void 0;
-  return asString2(value, path23);
+  return asString2(value, path24);
 }
 
 // packages/addons/src/node.ts
-import fs12 from "node:fs";
-import path12 from "node:path";
+import fs13 from "node:fs";
+import path13 from "node:path";
 import { parse as parseYaml3 } from "yaml";
 var ADDONS_DIR = "addons";
 var CONFIG_FILES = [".codarch.yml", ".codarch.yaml"];
 function loadAddons(root) {
-  const dir = path12.join(root, ADDONS_DIR);
+  const dir = path13.join(root, ADDONS_DIR);
   let entries;
   try {
-    entries = fs12.readdirSync(dir, { withFileTypes: true });
+    entries = fs13.readdirSync(dir, { withFileTypes: true });
   } catch {
     return { addons: [], errors: [] };
   }
@@ -9666,7 +9742,7 @@ function loadAddons(root) {
   const folders = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
   for (const name of folders) {
     try {
-      const addon = loadAddon(path12.join(dir, name));
+      const addon = loadAddon(path13.join(dir, name));
       if (addon.manifest.name !== name) {
         throw new AddonError(
           `la carpeta se llama "${name}" y el manifiesto "${addon.manifest.name}": deben coincidir`
@@ -9680,9 +9756,9 @@ function loadAddons(root) {
   return { addons, errors };
 }
 function loadAddon(dir) {
-  const label = path12.basename(dir);
+  const label = path13.basename(dir);
   const manifest = parseAddonManifest(
-    readJson(path12.join(dir, "addon.json"), `${label}/addon.json`)
+    readJson(path13.join(dir, "addon.json"), `${label}/addon.json`)
   );
   return parseAddon({
     manifest,
@@ -9712,11 +9788,11 @@ function repoAddons(root) {
 }
 function declaredAddons(root) {
   for (const name of CONFIG_FILES) {
-    const file = path12.join(root, name);
-    if (!fs12.existsSync(file)) continue;
+    const file = path13.join(root, name);
+    if (!fs13.existsSync(file)) continue;
     let text;
     try {
-      text = fs12.readFileSync(file, "utf8");
+      text = fs13.readFileSync(file, "utf8");
     } catch {
       return [];
     }
@@ -9732,10 +9808,10 @@ function declaredAddons(root) {
 function readYamlPieces(dir, files) {
   const pieces = [];
   for (const file of files) {
-    const full = path12.join(dir, file);
+    const full = path13.join(dir, file);
     let text;
     try {
-      text = fs12.readFileSync(full, "utf8");
+      text = fs13.readFileSync(full, "utf8");
     } catch (error) {
       throw new AddonError(`no se pudo leer ${file}: ${error.message}`);
     }
@@ -9753,7 +9829,7 @@ function readYamlPieces(dir, files) {
 function readJson(file, label) {
   let text;
   try {
-    text = fs12.readFileSync(file, "utf8");
+    text = fs13.readFileSync(file, "utf8");
   } catch (error) {
     throw new AddonError(`no se pudo leer ${label}: ${error.message}`);
   }
@@ -9768,8 +9844,8 @@ function stripBom(text) {
 }
 
 // apps/cli/src/commands/compare.ts
-import fs13 from "node:fs";
-import path13 from "node:path";
+import fs14 from "node:fs";
+import path14 from "node:path";
 var numberFormat2 = new Intl.NumberFormat("es-ES");
 function num2(value) {
   return numberFormat2.format(value);
@@ -9793,13 +9869,13 @@ function compareSnapshots(base, head, options) {
     console.error(`no se pudo comparar: ${error.message}`);
     return 1;
   }
-  const outPath = path13.resolve(options.out ?? "report.json");
+  const outPath = path14.resolve(options.out ?? "report.json");
   let reportBytes = 0;
   try {
-    fs13.mkdirSync(path13.dirname(outPath), { recursive: true });
+    fs14.mkdirSync(path14.dirname(outPath), { recursive: true });
     const text = `${JSON.stringify(report, null, 2)}
 `;
-    fs13.writeFileSync(outPath, text, "utf8");
+    fs14.writeFileSync(outPath, text, "utf8");
     reportBytes = Buffer.byteLength(text, "utf8");
   } catch (error) {
     console.error(
@@ -9974,7 +10050,7 @@ function runDiff(options) {
     if (!options.noConfig) {
       configPath = options.config ?? defaultConfigPath();
       if (configPath) {
-        const loaded = loadAddons(path14.dirname(path14.resolve(configPath)));
+        const loaded = loadAddons(path15.dirname(path15.resolve(configPath)));
         for (const error of loaded.errors) {
           console.error(`aviso: ${error.message}`);
         }
@@ -10066,7 +10142,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 displayPath2 = (path23) => rootPrefix && path23.startsWith(rootPrefix) ? path23.slice(rootPrefix.length) : path23;
+  const displayPath2 = (path24) => rootPrefix && path24.startsWith(rootPrefix) ? path24.slice(rootPrefix.length) : path24;
   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;
@@ -10145,8 +10221,8 @@ function runInspect(options) {
 }
 
 // apps/cli/src/commands/render.ts
-import fs14 from "node:fs";
-import path15 from "node:path";
+import fs15 from "node:fs";
+import path16 from "node:path";
 function defaultOutputPath(input) {
   const lower = input.toLowerCase();
   const suffixes = [".cc.json.gz", ".cc.json", ".json.gz", ".json", ".gz"];
@@ -10156,7 +10232,7 @@ function defaultOutputPath(input) {
   return `${input}.html`;
 }
 function defaultProjectName(input) {
-  let name = path15.basename(input.replace(/\\/g, "/"));
+  let name = path16.basename(input.replace(/\\/g, "/"));
   const lower = name.toLowerCase();
   const suffixes = [".cc.json.gz", ".cc.json", ".json.gz", ".json", ".gz"];
   for (const suffix of suffixes) {
@@ -10223,8 +10299,8 @@ function runRender(options) {
   const elapsed = Date.now() - started;
   const out = options.out ?? defaultOutputPath(options.file);
   try {
-    fs14.mkdirSync(path15.dirname(path15.resolve(out)), { recursive: true });
-    fs14.writeFileSync(out, html, "utf8");
+    fs15.mkdirSync(path16.dirname(path16.resolve(out)), { recursive: true });
+    fs15.writeFileSync(out, html, "utf8");
   } catch (error) {
     console.error(`no se pudo escribir ${out}: ${error.message}`);
     return 1;
@@ -10265,13 +10341,13 @@ function runRender(options) {
 }
 
 // apps/cli/src/commands/serve.ts
-import fs15 from "node:fs";
+import fs16 from "node:fs";
 import http from "node:http";
-import path16 from "node:path";
+import path17 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // apps/cli/src/version.ts
-var VERSION = true ? "0.3.21" : "0.0.0";
+var VERSION = true ? "0.3.23" : "0.0.0";
 
 // apps/cli/src/commands/serve.ts
 var MIME = {
@@ -10297,7 +10373,7 @@ var IGNORED_BROWSE = /* @__PURE__ */ new Set([
   "target"
 ]);
 function runServe(options) {
-  const root = path16.resolve(options.root ?? ".");
+  const root = path17.resolve(options.root ?? ".");
   const denied = protectedRootReason(root);
   if (denied) {
     console.error(
@@ -10383,8 +10459,8 @@ function runServe(options) {
     broadcast(clients, "watch", { watch: state.watch });
   };
   const switchRoot = (nextRoot) => {
-    const resolved = path16.resolve(nextRoot);
-    const stat4 = fs15.statSync(resolved);
+    const resolved = path17.resolve(nextRoot);
+    const stat4 = fs16.statSync(resolved);
     if (!stat4.isDirectory()) throw new Error("la ruta no es un directorio");
     const next = analyzeState(resolved, state.watch);
     stopWatcher();
@@ -10407,7 +10483,7 @@ function runServe(options) {
   };
   const meta = () => ({
     version: VERSION === "0.0.0" ? "dev" : VERSION,
-    root: path16.basename(state.root),
+    root: path17.basename(state.root),
     rootPath: state.root,
     watch: state.watch,
     files: state.files,
@@ -10468,6 +10544,22 @@ function runServe(options) {
         }
         return;
       }
+      if (pathname === "/api/source") {
+        const relative4 = url.searchParams.get("path");
+        if (!relative4) {
+          sendError(response, 400, "falta path");
+          return;
+        }
+        const start = Number(url.searchParams.get("start") ?? "1");
+        const end = Number(url.searchParams.get("end") ?? "400");
+        const snippet = readSourceSnippet(state.root, relative4, start, end);
+        if (!snippet) {
+          sendError(response, 404, "no hay c\xF3digo para esa ruta");
+          return;
+        }
+        sendJson(response, snippet);
+        return;
+      }
       if (pathname === "/data/snapshot.cc.json") {
         sendJson(response, state.snapshot);
         return;
@@ -10498,7 +10590,7 @@ function runServe(options) {
         return;
       }
       if (pathname === "/data/chains.json") {
-        if (!fs15.existsSync(path16.join(state.root, ".codarch"))) {
+        if (!fs16.existsSync(path17.join(state.root, ".codarch"))) {
           ensureGitignoreEntry(state.root, ".codarch/");
         }
         const symbol = url.searchParams.get("symbol");
@@ -10507,14 +10599,14 @@ function runServe(options) {
       }
       if (pathname.startsWith("/data/history/")) {
         const name = pathname.slice("/data/history/".length);
-        const file = path16.join(historyLocation(state.root).directory, name);
+        const file = path17.join(historyLocation(state.root).directory, name);
         if (!file.startsWith(historyLocation(state.root).directory)) {
           sendError(response, 403, "ruta fuera del historial");
           return;
         }
         let body;
         try {
-          body = fs15.readFileSync(file);
+          body = fs16.readFileSync(file);
         } catch {
           sendError(response, 404, "no hay esa foto en el historial");
           return;
@@ -10631,15 +10723,15 @@ function stateFrom(root, result, watch2) {
   };
 }
 function browseDirectories(root, requested) {
-  const target = requested?.trim() ? path16.resolve(requested) : root;
-  const stat4 = fs15.statSync(target);
+  const target = requested?.trim() ? path17.resolve(requested) : root;
+  const stat4 = fs16.statSync(target);
   if (!stat4.isDirectory()) throw new Error("la ruta no es un directorio");
-  const entries = fs15.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) => ({
+  const entries = fs16.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: path16.join(target, entry.name),
+    path: path17.join(target, entry.name),
     kind: "directory"
   }));
-  const parent = path16.dirname(target);
+  const parent = path17.dirname(target);
   return {
     path: target,
     parent: parent === target ? null : parent,
@@ -10675,9 +10767,9 @@ function originAllowed(request, options) {
 function findWebRoot() {
   const candidates = [
     fileURLToPath(new URL("./web", import.meta.url)),
-    path16.resolve(process.cwd(), "apps", "web", "dist"),
-    path16.resolve(
-      path16.dirname(fileURLToPath(import.meta.url)),
+    path17.resolve(process.cwd(), "apps", "web", "dist"),
+    path17.resolve(
+      path17.dirname(fileURLToPath(import.meta.url)),
       "..",
       "..",
       "..",
@@ -10686,14 +10778,14 @@ function findWebRoot() {
     )
   ];
   for (const candidate of candidates) {
-    if (fs15.existsSync(path16.join(candidate, "index.html"))) return candidate;
+    if (fs16.existsSync(path17.join(candidate, "index.html"))) return candidate;
   }
   return null;
 }
 function readReport(root) {
-  const file = path16.join(root, ".codarch", "report.json");
+  const file = path17.join(root, ".codarch", "report.json");
   try {
-    return JSON.parse(fs15.readFileSync(file, "utf8"));
+    return JSON.parse(fs16.readFileSync(file, "utf8"));
   } catch (error) {
     if (error.code !== "ENOENT") {
       console.error(`no se pudo leer ${file}: ${error.message}`);
@@ -10711,16 +10803,16 @@ function serveStatic(webRoot, pathname, headOnly, response) {
     return;
   }
   const relative4 = decoded === "/" ? "index.html" : decoded.replace(/^\/+/, "");
-  let file = path16.resolve(webRoot, relative4);
-  if (!isWithin2(webRoot, file) || !fs15.existsSync(file) || !fs15.statSync(file).isFile()) {
-    file = path16.join(webRoot, "index.html");
+  let file = path17.resolve(webRoot, relative4);
+  if (!isWithin2(webRoot, file) || !fs16.existsSync(file) || !fs16.statSync(file).isFile()) {
+    file = path17.join(webRoot, "index.html");
   }
   try {
-    const body = fs15.readFileSync(file);
+    const body = fs16.readFileSync(file);
     response.writeHead(200, {
-      "Content-Type": MIME[path16.extname(file).toLowerCase()] ?? "application/octet-stream",
+      "Content-Type": MIME[path17.extname(file).toLowerCase()] ?? "application/octet-stream",
       "Content-Length": body.length,
-      "Cache-Control": file.includes(`${path16.sep}assets${path16.sep}`) ? "public, max-age=31536000, immutable" : "no-store",
+      "Cache-Control": file.includes(`${path17.sep}assets${path17.sep}`) ? "public, max-age=31536000, immutable" : "no-store",
       "X-Content-Type-Options": "nosniff"
     });
     if (headOnly) response.end();
@@ -10731,8 +10823,8 @@ function serveStatic(webRoot, pathname, headOnly, response) {
   }
 }
 function isWithin2(root, candidate) {
-  const relative4 = path16.relative(root, candidate);
-  return relative4 === "" || !relative4.startsWith("..") && !path16.isAbsolute(relative4);
+  const relative4 = path17.relative(root, candidate);
+  return relative4 === "" || !relative4.startsWith("..") && !path17.isAbsolute(relative4);
 }
 function sendJson(response, value) {
   const body = `${JSON.stringify(value)}
@@ -10827,14 +10919,14 @@ function runProfiles(json) {
 }
 
 // apps/cli/src/commands/history.ts
-import fs16 from "node:fs";
-import path17 from "node:path";
+import fs17 from "node:fs";
+import path18 from "node:path";
 var numberFormat5 = new Intl.NumberFormat("es-ES");
 function num5(value) {
   return numberFormat5.format(value);
 }
 function runHistory(options) {
-  const root = path17.resolve(options.root ?? ".");
+  const root = path18.resolve(options.root ?? ".");
   const index = readHistoryIndex(root);
   if (options.from && options.to) {
     return compareEntries(root, index.entries, options.from, options.to, options);
@@ -10912,10 +11004,10 @@ function compareEntries(root, entries, fromToken, toToken, options) {
   });
 }
 function loadEntry(directory, entry) {
-  const file = path17.join(directory, fileNameFor(entry));
+  const file = path18.join(directory, fileNameFor(entry));
   let raw;
   try {
-    raw = fs16.readFileSync(file, "utf8");
+    raw = fs17.readFileSync(file, "utf8");
   } catch (error) {
     console.error(`no se pudo leer ${file}: ${error.message}`);
     return null;
@@ -10936,9 +11028,9 @@ function fileNameFor(entry) {
 }
 
 // apps/cli/src/commands/chain.ts
-import path18 from "node:path";
+import path19 from "node:path";
 function runChain(options) {
-  const root = path18.resolve(options.root ?? ".");
+  const root = path19.resolve(options.root ?? ".");
   const index = readHistoryIndex(root);
   if (index.entries.length === 0) {
     console.error(
@@ -11023,10 +11115,10 @@ function eventLabel(type) {
 }
 
 // apps/cli/src/commands/verify.ts
-import fs17 from "node:fs";
-import path19 from "node:path";
+import fs18 from "node:fs";
+import path20 from "node:path";
 function runVerify(options) {
-  const root = path19.resolve(options.root ?? ".");
+  const root = path20.resolve(options.root ?? ".");
   const index = readHistoryIndex(root);
   if (index.entries.length === 0) {
     console.error(
@@ -11070,21 +11162,21 @@ function runVerify(options) {
   return 2;
 }
 function readCurrentSnapshot(root, last) {
-  const current = path19.join(root, ".codarch", "snapshot.cc.json");
+  const current = path20.join(root, ".codarch", "snapshot.cc.json");
   try {
     return parseCcJson(
-      JSON.parse(fs17.readFileSync(current, "utf8"))
+      JSON.parse(fs18.readFileSync(current, "utf8"))
     );
   } catch {
   }
   if (!last) return null;
-  const history = path19.join(root, ".codarch-history");
+  const history = path20.join(root, ".codarch-history");
   try {
-    const files = fs17.readdirSync(history).filter((file) => file.endsWith(".cc.json")).sort();
+    const files = fs18.readdirSync(history).filter((file) => file.endsWith(".cc.json")).sort();
     const lastFile = files[files.length - 1];
     if (!lastFile) return null;
     return parseCcJson(
-      JSON.parse(fs17.readFileSync(path19.join(history, lastFile), "utf8"))
+      JSON.parse(fs18.readFileSync(path20.join(history, lastFile), "utf8"))
     );
   } catch {
     return null;
@@ -11197,18 +11289,18 @@ function runSuggest(options) {
 }
 
 // apps/cli/src/commands/addons.ts
-import fs19 from "node:fs";
-import path21 from "node:path";
+import fs20 from "node:fs";
+import path22 from "node:path";
 
 // apps/cli/src/commands/installed.ts
-import fs18 from "node:fs";
-import path20 from "node:path";
+import fs19 from "node:fs";
+import path21 from "node:path";
 import { parseDocument } from "yaml";
 var CONFIG_FILES2 = [".codarch.yml", ".codarch.yaml"];
 function findConfig(root) {
   for (const file of CONFIG_FILES2) {
-    const full = path20.join(root, file);
-    if (fs18.existsSync(full)) return full;
+    const full = path21.join(root, file);
+    if (fs19.existsSync(full)) return full;
   }
   return null;
 }
@@ -11222,8 +11314,8 @@ function declaredIn(root, kind) {
 function declareIn(root, kind, name) {
   const file = findConfig(root);
   if (!file) {
-    fs18.writeFileSync(
-      path20.join(root, ".codarch.yml"),
+    fs19.writeFileSync(
+      path21.join(root, ".codarch.yml"),
       `version: ${CONFIG_VERSION}
 
 ${kind}:
@@ -11242,7 +11334,7 @@ ${kind}:
   if (asRecord(doc.doc.toJS()).version === void 0) {
     doc.doc.set("version", 1);
   }
-  fs18.writeFileSync(file, String(doc.doc), "utf8");
+  fs19.writeFileSync(file, String(doc.doc), "utf8");
   return { ok: true };
 }
 function undeclareIn(root, kind, name) {
@@ -11256,13 +11348,13 @@ function undeclareIn(root, kind, name) {
     kind,
     declared.filter((entry) => entry !== name)
   );
-  fs18.writeFileSync(file, String(doc.doc), "utf8");
+  fs19.writeFileSync(file, String(doc.doc), "utf8");
   return { ok: true };
 }
 function readDocument(file) {
   let text;
   try {
-    text = fs18.readFileSync(file, "utf8");
+    text = fs19.readFileSync(file, "utf8");
   } catch (error) {
     return { ok: false, message: `no se pudo leer ${file}: ${error.message}` };
   }
@@ -11286,13 +11378,13 @@ function stringList(value) {
   return value.filter((entry) => typeof entry === "string");
 }
 function childDirectories(dir) {
-  if (!fs18.existsSync(dir)) return [];
-  return fs18.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => !name.startsWith(".") && name !== "node_modules").sort();
+  if (!fs19.existsSync(dir)) return [];
+  return fs19.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => !name.startsWith(".") && name !== "node_modules").sort();
 }
 
 // apps/cli/src/commands/addons.ts
 function runAddons(options) {
-  const root = path21.resolve(options.root);
+  const root = path22.resolve(options.root);
   if (options.action === "list") return listAddons(root, options.json);
   if (!options.target) {
     console.error(
@@ -11307,7 +11399,7 @@ function listAddons(root, json) {
   const configFile = findConfig(root);
   const declared = declaredIn(root, "addons");
   const missing = declared.filter(
-    (name) => !fs19.existsSync(path21.join(root, ADDONS_DIR, name))
+    (name) => !fs20.existsSync(path22.join(root, ADDONS_DIR, name))
   );
   const groups = [
     ...loaded.addons.map((addon) => ({
@@ -11331,7 +11423,7 @@ function listAddons(root, json) {
       JSON.stringify(
         {
           dir: ADDONS_DIR,
-          config: configFile ? path21.relative(root, configFile) : null,
+          config: configFile ? path22.relative(root, configFile) : null,
           declared,
           addons: groups,
           missing
@@ -11393,7 +11485,7 @@ function listAddons(root, json) {
   return loaded.errors.length > 0 || missing.length > 0 ? 1 : 0;
 }
 function addAddon(root, target) {
-  const source = path21.resolve(root, target);
+  const source = path22.resolve(root, target);
   let addon;
   try {
     addon = loadAddon(source);
@@ -11403,15 +11495,15 @@ function addAddon(root, target) {
     );
     return 1;
   }
-  const dest = path21.join(root, ADDONS_DIR, addon.manifest.name);
-  if (fs19.existsSync(dest)) {
+  const dest = path22.join(root, ADDONS_DIR, addon.manifest.name);
+  if (fs20.existsSync(dest)) {
     console.error(
       `${ADDONS_DIR}/${addon.manifest.name} ya existe. Qu\xEDtalo antes con: codarch addons remove ${addon.manifest.name}`
     );
     return 1;
   }
-  fs19.mkdirSync(path21.dirname(dest), { recursive: true });
-  fs19.cpSync(source, dest, { recursive: true });
+  fs20.mkdirSync(path22.dirname(dest), { recursive: true });
+  fs20.cpSync(source, dest, { recursive: true });
   const declared = declareIn(root, "addons", addon.manifest.name);
   if (!declared.ok) {
     console.error(declared.message);
@@ -11438,12 +11530,12 @@ function removeAddon(root, name) {
     console.error(`no es un nombre de addon: ${name}`);
     return 1;
   }
-  const dir = path21.join(root, ADDONS_DIR, name);
-  if (!fs19.existsSync(dir)) {
+  const dir = path22.join(root, ADDONS_DIR, name);
+  if (!fs20.existsSync(dir)) {
     console.error(`no existe ${ADDONS_DIR}/${name}`);
     return 1;
   }
-  fs19.rmSync(dir, { recursive: true, force: true });
+  fs20.rmSync(dir, { recursive: true, force: true });
   const undeclared = undeclareIn(root, "addons", name);
   if (!undeclared.ok) {
     console.error(undeclared.message);
@@ -11456,12 +11548,12 @@ function removeAddon(root, name) {
 }
 
 // apps/cli/src/commands/plugins.ts
-import fs20 from "node:fs";
-import path22 from "node:path";
+import fs21 from "node:fs";
+import path23 from "node:path";
 var PLUGINS_DIR = "plugins";
 var ENTRY_FILES = ["index.tsx", "index.ts"];
 function runPlugins(options) {
-  const root = path22.resolve(options.root);
+  const root = path23.resolve(options.root);
   if (options.action === "list") return listPlugins(root, options.json);
   if (!options.target) {
     console.error(
@@ -11472,11 +11564,11 @@ function runPlugins(options) {
   return options.action === "add" ? addPlugin(root, options.target) : removePlugin(root, options.target);
 }
 function listPlugins(root, json) {
-  const dir = path22.join(root, PLUGINS_DIR);
+  const dir = path23.join(root, PLUGINS_DIR);
   const configFile = findConfig(root);
   const declared = declaredIn(root, "plugins");
   const entries = childDirectories(dir).map((name) => {
-    const loaded = readManifest(path22.join(dir, name), name);
+    const loaded = readManifest(path23.join(dir, name), name);
     const isDeclared = declared.includes(name);
     if (!loaded.ok) return { name, declared: isDeclared, error: loaded.message };
     if (loaded.manifest.name !== name) {
@@ -11495,7 +11587,7 @@ function listPlugins(root, json) {
       JSON.stringify(
         {
           dir: PLUGINS_DIR,
-          config: configFile ? path22.relative(root, configFile) : null,
+          config: configFile ? path23.relative(root, configFile) : null,
           declared,
           plugins: entries.map(
             (entry) => "error" in entry ? { name: entry.name, error: entry.error, declared: entry.declared } : {
@@ -11558,26 +11650,26 @@ function listPlugins(root, json) {
   return errors.length > 0 || missing.length > 0 ? 1 : 0;
 }
 function addPlugin(root, target) {
-  const source = path22.resolve(root, target);
-  if (!fs20.existsSync(source) || !fs20.statSync(source).isDirectory()) {
+  const source = path23.resolve(root, target);
+  if (!fs21.existsSync(source) || !fs21.statSync(source).isDirectory()) {
     console.error(`no es una carpeta: ${displayPath(root, source)}`);
     return 1;
   }
-  const loaded = readManifest(source, path22.basename(source));
+  const loaded = readManifest(source, path23.basename(source));
   if (!loaded.ok) {
     console.error(`plugin inv\xE1lido: ${loaded.message}`);
     return 1;
   }
   const { manifest } = loaded;
-  const dest = path22.join(root, PLUGINS_DIR, manifest.name);
-  if (fs20.existsSync(dest)) {
+  const dest = path23.join(root, PLUGINS_DIR, manifest.name);
+  if (fs21.existsSync(dest)) {
     console.error(
       `${PLUGINS_DIR}/${manifest.name} ya existe. Qu\xEDtalo antes con: codarch plugins remove ${manifest.name}`
     );
     return 1;
   }
-  fs20.mkdirSync(path22.dirname(dest), { recursive: true });
-  fs20.cpSync(source, dest, { recursive: true });
+  fs21.mkdirSync(path23.dirname(dest), { recursive: true });
+  fs21.cpSync(source, dest, { recursive: true });
   const declared = declareIn(root, "plugins", manifest.name);
   if (!declared.ok) {
     console.error(declared.message);
@@ -11599,12 +11691,12 @@ function removePlugin(root, name) {
     console.error(`no es un nombre de plugin: ${name}`);
     return 1;
   }
-  const dir = path22.join(root, PLUGINS_DIR, name);
-  if (!fs20.existsSync(dir)) {
+  const dir = path23.join(root, PLUGINS_DIR, name);
+  if (!fs21.existsSync(dir)) {
     console.error(`no existe ${PLUGINS_DIR}/${name}`);
     return 1;
   }
-  fs20.rmSync(dir, { recursive: true, force: true });
+  fs21.rmSync(dir, { recursive: true, force: true });
   const undeclared = undeclareIn(root, "plugins", name);
   if (!undeclared.ok) {
     console.error(undeclared.message);
@@ -11617,13 +11709,13 @@ function removePlugin(root, name) {
   return 0;
 }
 function readManifest(dir, fallbackName) {
-  const file = path22.join(dir, "plugin.json");
-  if (!fs20.existsSync(file)) {
+  const file = path23.join(dir, "plugin.json");
+  if (!fs21.existsSync(file)) {
     return { ok: false, message: `falta plugin.json en ${dir}` };
   }
   let raw;
   try {
-    raw = JSON.parse(fs20.readFileSync(file, "utf8").replace(/^\uFEFF/, ""));
+    raw = JSON.parse(fs21.readFileSync(file, "utf8").replace(/^\uFEFF/, ""));
   } catch (error) {
     return { ok: false, message: `plugin.json no es JSON: ${error.message}` };
   }
@@ -11653,7 +11745,7 @@ function readManifest(dir, fallbackName) {
   if (names.length !== views.length) {
     return { ok: false, message: "contributes.views solo admite nombres" };
   }
-  if (!ENTRY_FILES.some((entry) => fs20.existsSync(path22.join(dir, entry)))) {
+  if (!ENTRY_FILES.some((entry) => fs21.existsSync(path23.join(dir, entry)))) {
     return {
       ok: false,
       message: `falta el punto de entrada en ${dir}: ${ENTRY_FILES.join(" o ")}`
@@ -11673,7 +11765,7 @@ function readManifest(dir, fallbackName) {
   };
 }
 function displayPath(root, target) {
-  const relative4 = path22.relative(root, target);
+  const relative4 = path23.relative(root, target);
   return relative4.startsWith("..") ? target : relative4;
 }