codarch 0.1.3 → 0.1.4

package/index.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 
 // apps/cli/src/commands/analyze.ts
-import fs6 from "node:fs";
-import path5 from "node:path";
+import fs4 from "node:fs";
+import path3 from "node:path";
 
 // packages/parsers/src/ts/parser.ts
 import Parser from "tree-sitter";
 import TypeScript from "tree-sitter-typescript";
-var EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+
+// packages/parsers/src/ts/measure.ts
 var FUNCTION_TYPES = /* @__PURE__ */ new Set([
   "function_declaration",
   "function_expression",
@@ -28,30 +29,13 @@ var DECISION_TYPES = /* @__PURE__ */ new Set([
   "conditional_expression"
 ]);
 var LOGICAL_OPERATORS = /* @__PURE__ */ new Set(["&&", "||", "??"]);
-var TypeScriptParser = class {
-  name = "typescript";
-  extensions = EXTENSIONS;
-  tsParser = new Parser();
-  tsxParser = new Parser();
-  constructor() {
-    this.tsParser.setLanguage(TypeScript.typescript);
-    this.tsxParser.setLanguage(TypeScript.tsx);
-  }
-  parse(source, filePath) {
-    const parser = usesTsxGrammar(filePath) ? this.tsxParser : this.tsParser;
-    const root = parser.parse(source, void 0, {
-      bufferSize: Math.max(64 * 1024, Buffer.byteLength(source, "utf8") + 1)
-    }).rootNode;
-    return {
-      metrics: measureSource(source, root),
-      imports: collectImports(root)
-    };
-  }
-};
 function usesTsxGrammar(filePath) {
   const lower = filePath.toLowerCase();
   return lower.endsWith(".tsx") || lower.endsWith(".jsx") || lower.endsWith(".js") || lower.endsWith(".mjs") || lower.endsWith(".cjs");
 }
+function isComment(text) {
+  return text.startsWith("//") || text.startsWith("/*") || text.startsWith("#!");
+}
 function measureSource(source, root) {
   const codeLines = /* @__PURE__ */ new Set();
   const stack = [root];
@@ -60,8 +44,8 @@ function measureSource(source, root) {
   let maxFunctionLength = 0;
   while (stack.length > 0) {
     const node = stack.pop();
-    if (node.type === "comment" || node.type === "hash_bang_line") continue;
     if (node.childCount === 0) {
+      if (isComment(node.text)) continue;
       if (node.text.trim() !== "") {
         for (let row = node.startPosition.row; row <= node.endPosition.row; row++) {
           codeLines.add(row);
@@ -225,11 +209,175 @@ function decodeStringBody(body) {
   );
 }
 
+// packages/parsers/src/ts/parser.ts
+var EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+var TypeScriptParser = class {
+  name = "typescript";
+  extensions = EXTENSIONS;
+  tsParser = new Parser();
+  tsxParser = new Parser();
+  constructor() {
+    this.tsParser.setLanguage(TypeScript.typescript);
+    this.tsxParser.setLanguage(TypeScript.tsx);
+  }
+  parse(source, filePath) {
+    const parser = usesTsxGrammar(filePath) ? this.tsxParser : this.tsParser;
+    const root = parser.parse(source, void 0, {
+      bufferSize: Math.max(64 * 1024, Buffer.byteLength(source, "utf8") + 1)
+    }).rootNode;
+    const node = root;
+    return {
+      metrics: measureSource(source, node),
+      imports: collectImports(node)
+    };
+  }
+};
+
 // packages/parsers/src/resolve.ts
-import fs from "node:fs";
-import path from "node:path";
-import { builtinModules } from "node:module";
 import ts from "typescript";
+
+// packages/parsers/src/builtins.ts
+var NODE_BUILTINS = [
+  "_http_agent",
+  "_http_client",
+  "_http_common",
+  "_http_incoming",
+  "_http_outgoing",
+  "_http_server",
+  "_stream_duplex",
+  "_stream_passthrough",
+  "_stream_readable",
+  "_stream_transform",
+  "_stream_wrap",
+  "_stream_writable",
+  "_tls_common",
+  "_tls_wrap",
+  "assert",
+  "assert/strict",
+  "async_hooks",
+  "buffer",
+  "child_process",
+  "cluster",
+  "console",
+  "constants",
+  "crypto",
+  "dgram",
+  "diagnostics_channel",
+  "dns",
+  "dns/promises",
+  "domain",
+  "events",
+  "fs",
+  "fs/promises",
+  "http",
+  "http2",
+  "https",
+  "inspector",
+  "inspector/promises",
+  "module",
+  "net",
+  "os",
+  "path",
+  "path/posix",
+  "path/win32",
+  "perf_hooks",
+  "process",
+  "punycode",
+  "querystring",
+  "readline",
+  "readline/promises",
+  "repl",
+  "stream",
+  "stream/consumers",
+  "stream/promises",
+  "stream/web",
+  "string_decoder",
+  "sys",
+  "timers",
+  "timers/promises",
+  "tls",
+  "trace_events",
+  "tty",
+  "url",
+  "util",
+  "util/types",
+  "v8",
+  "vm",
+  "wasi",
+  "worker_threads",
+  "zlib",
+  "node:sea",
+  "node:sqlite",
+  "node:test",
+  "node:test/reporters"
+];
+function isNodeBuiltin(specifier) {
+  if (specifier.startsWith("node:")) return true;
+  return NODE_BUILTINS.includes(specifier);
+}
+
+// packages/parsers/src/path.ts
+function join(...segments) {
+  const parts = [];
+  for (const segment of segments) {
+    if (!segment) continue;
+    for (const piece of segment.split("/")) {
+      if (piece === "" || piece === ".") continue;
+      if (piece === "..") {
+        parts.pop();
+        continue;
+      }
+      parts.push(piece);
+    }
+  }
+  return `/${parts.join("/")}`;
+}
+function resolve(...segments) {
+  let resolved = "";
+  let absolute = false;
+  for (let index = segments.length - 1; index >= 0 && !absolute; index -= 1) {
+    const segment = segments[index];
+    if (!segment) continue;
+    resolved = resolved === "" ? segment : `${segment}/${resolved}`;
+    absolute = segment.startsWith("/");
+  }
+  if (!absolute) resolved = `/${resolved}`;
+  return join(resolved);
+}
+function dirname(target) {
+  const normalized = target.replace(/\/+$/, "");
+  const index = normalized.lastIndexOf("/");
+  if (index <= 0) return "/";
+  return normalized.slice(0, index);
+}
+function basename(target) {
+  const normalized = target.replace(/\/+$/, "");
+  const index = normalized.lastIndexOf("/");
+  return index === -1 ? normalized : normalized.slice(index + 1);
+}
+function extname(target) {
+  const name = basename(target);
+  const index = name.lastIndexOf(".");
+  if (index <= 0) return "";
+  return name.slice(index);
+}
+function relative(from, target) {
+  const fromParts = from.split("/").filter(Boolean);
+  const targetParts = target.split("/").filter(Boolean);
+  let common = 0;
+  while (common < fromParts.length && common < targetParts.length && fromParts[common] === targetParts[common]) {
+    common += 1;
+  }
+  const up = fromParts.length - common;
+  const down = targetParts.slice(common);
+  const parts = [...Array.from({ length: up }, () => ".."), ...down];
+  return parts.join("/");
+}
+function isAbsolute(target) {
+  return target.startsWith("/");
+}
+
+// packages/parsers/src/resolve.ts
 var SOURCE_EXTENSIONS = [
   ".ts",
   ".tsx",
@@ -255,9 +403,6 @@ var WORKSPACE_SKIP_DIRS = /* @__PURE__ */ new Set([
 ]);
 var MAX_WORKSPACE_DEPTH = 8;
 var MAX_RESOLVE_DEPTH = 8;
-var BUILTINS = new Set(
-  builtinModules.flatMap((name) => [name, `node:${name}`])
-);
 var ASSET_EXTENSIONS = [
   ".css",
   ".scss",
@@ -283,31 +428,33 @@ var ASSET_EXTENSIONS = [
   ".pdf"
 ];
 function isAssetSpecifier(specifier) {
-  const clean = specifier.split(/[?#]/, 1)[0]?.toLowerCase() ?? "";
-  return ASSET_EXTENSIONS.some((extension) => clean.endsWith(extension));
+  const clean2 = specifier.split(/[?#]/, 1)[0]?.toLowerCase() ?? "";
+  return ASSET_EXTENSIONS.some((extension) => clean2.endsWith(extension));
 }
 var ImportResolver = class {
   warnings = [];
   root;
+  fileSystem;
   byPath = /* @__PURE__ */ new Map();
   packageJsonCache = /* @__PURE__ */ new Map();
   configCache = /* @__PURE__ */ new Map();
   workspaces;
-  constructor(rootInput, files) {
-    this.root = path.resolve(rootInput);
-    for (const file of files) this.byPath.set(pathKey(file.absolutePath), file);
-    this.workspaces = discoverWorkspaces(this.root, this.warnings);
+  constructor(rootInput, files, fileSystem) {
+    this.root = resolve(rootInput);
+    this.fileSystem = fileSystem;
+    for (const file of files) this.byPath.set(this.pathKey(file.absolutePath), file);
+    this.workspaces = discoverWorkspaces(this.root, this.fileSystem, this.warnings);
   }
   resolve(importerPath, specifier) {
-    if (BUILTINS.has(specifier) || specifier.startsWith("node:")) {
+    if (isNodeBuiltin(specifier)) {
       return { kind: "external", specifier, builtin: true };
     }
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      const base = specifier.startsWith("/") ? path.resolve(this.root, `.${specifier}`) : path.resolve(path.dirname(path.resolve(importerPath)), specifier);
+      const base = specifier.startsWith("/") ? resolve(this.root, `.${specifier}`) : resolve(dirname(resolve(importerPath)), specifier);
       const file = this.resolveAsFileOrDirectory(base);
       return file ? { kind: "internal", file } : { kind: "unresolved", specifier, reason: "no se encontr\xF3 el fichero" };
     }
-    const config = this.configFor(path.dirname(path.resolve(importerPath)));
+    const config = this.configFor(dirname(resolve(importerPath)));
     if (config) {
       const alias = matchAlias(config.aliases, specifier);
       if (alias) {
@@ -345,7 +492,7 @@ var ImportResolver = class {
     const subpath = specifier === workspace.name ? "." : `./${specifier.slice(workspace.name.length + 1)}`;
     for (const target of packageExportTargets(workspace.json.exports, subpath)) {
       const file = this.resolveAsFileOrDirectory(
-        path.resolve(workspace.dir, target)
+        resolve(workspace.dir, target)
       );
       if (file) return file;
     }
@@ -354,7 +501,7 @@ var ImportResolver = class {
         const value = workspace.json[field5];
         if (typeof value !== "string") continue;
         const file = this.resolveAsFileOrDirectory(
-          path.resolve(workspace.dir, value)
+          resolve(workspace.dir, value)
         );
         if (file) return file;
       }
@@ -365,13 +512,13 @@ var ImportResolver = class {
         "index.tsx"
       ]) {
         const file = this.resolveAsFileOrDirectory(
-          path.resolve(workspace.dir, fallback)
+          resolve(workspace.dir, fallback)
         );
         if (file) return file;
       }
     } else {
       const file = this.resolveAsFileOrDirectory(
-        path.resolve(workspace.dir, subpath.slice(2))
+        resolve(workspace.dir, subpath.slice(2))
       );
       if (file) return file;
     }
@@ -380,7 +527,7 @@ var ImportResolver = class {
   resolveAsFileOrDirectory(base, depth = 0) {
     if (depth > MAX_RESOLVE_DEPTH) return null;
     for (const candidate of fileCandidates(base)) {
-      const file = this.byPath.get(pathKey(candidate));
+      const file = this.byPath.get(this.pathKey(candidate));
       if (file) return file;
     }
     const pkg = this.readPackageJson(base);
@@ -389,67 +536,77 @@ var ImportResolver = class {
         const value = pkg[field5];
         if (typeof value !== "string") continue;
         const file = this.resolveAsFileOrDirectory(
-          path.resolve(base, value),
+          resolve(base, value),
           depth + 1
         );
         if (file) return file;
       }
       for (const target of packageExportTargets(pkg.exports, ".")) {
         const file = this.resolveAsFileOrDirectory(
-          path.resolve(base, target),
+          resolve(base, target),
           depth + 1
         );
         if (file) return file;
       }
     }
     for (const candidate of indexCandidates(base)) {
-      const file = this.byPath.get(pathKey(candidate));
+      const file = this.byPath.get(this.pathKey(candidate));
       if (file) return file;
     }
     return null;
   }
   readPackageJson(directory) {
-    const key = pathKey(directory);
+    const key = this.pathKey(directory);
     if (this.packageJsonCache.has(key)) {
       return this.packageJsonCache.get(key) ?? null;
     }
-    const json = readJsonFile(path.join(directory, "package.json"), this.warnings);
+    const json = readJsonFile(
+      this.fileSystem,
+      join(directory, "package.json"),
+      this.warnings
+    );
     this.packageJsonCache.set(key, json);
     return json;
   }
   configFor(startDirectory) {
     const visited = [];
-    let directory = path.resolve(startDirectory);
+    let directory = resolve(startDirectory);
     while (true) {
-      const key = pathKey(directory);
+      const key = this.pathKey(directory);
       const cached = this.configCache.get(key);
       if (cached !== void 0) {
         for (const visitedKey of visited) this.configCache.set(visitedKey, cached);
         return cached;
       }
       visited.push(key);
-      const configPath = findTsConfig(directory);
+      const configPath = findTsConfig(this.fileSystem, directory);
       if (configPath) {
-        const loaded = loadTsConfig(configPath, this.warnings);
+        const loaded = loadTsConfig(this.fileSystem, configPath, this.warnings);
         for (const visitedKey of visited) this.configCache.set(visitedKey, loaded);
         return loaded;
       }
-      if (key === pathKey(this.root)) break;
-      const parent = path.dirname(directory);
+      if (key === this.pathKey(this.root)) break;
+      const parent = dirname(directory);
       if (parent === directory || !isWithin(this.root, parent)) break;
       directory = parent;
     }
     for (const visitedKey of visited) this.configCache.set(visitedKey, null);
     return null;
   }
+  /**
+   * Clave de una ruta para las tablas internas.
+   *
+   * En sistemas que no distinguen mayúsculas, la clave se normaliza para que
+   * `./Foo` encuentre `foo.ts`.
+   */
+  pathKey(value) {
+    const resolved = resolve(value);
+    return this.fileSystem.caseSensitive ? resolved : resolved.toLowerCase();
+  }
 };
-function pathKey(value) {
-  const resolved = path.resolve(value);
-  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
-}
 function isWithin(root, candidate) {
-  const relative = path.relative(root, candidate);
-  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+  const relative2 = relative(root, candidate);
+  return relative2 === "" || !relative2.startsWith("..") && !isAbsolute(relative2);
 }
 function fileCandidates(base) {
   const lower = base.toLowerCase();
@@ -467,7 +624,7 @@ function fileCandidates(base) {
   if (lower.endsWith(".cjs")) {
     return [`${base.slice(0, -4)}.cts`, base];
   }
-  if (path.extname(base) !== "") return [base];
+  if (extname(base) !== "") return [base];
   return [
     base,
     ...SOURCE_EXTENSIONS.map((extension) => `${base}${extension}`)
@@ -475,18 +632,29 @@ function fileCandidates(base) {
 }
 function indexCandidates(directory) {
   return SOURCE_EXTENSIONS.map(
-    (extension) => path.join(directory, `index${extension}`)
+    (extension) => join(directory, `index${extension}`)
   );
 }
-function findTsConfig(directory) {
+function findTsConfig(fileSystem, directory) {
   for (const name of ["tsconfig.json", "jsconfig.json"]) {
-    const candidate = path.join(directory, name);
-    if (fs.existsSync(candidate)) return candidate;
+    const candidate = join(directory, name);
+    if (fileSystem.exists(candidate)) return candidate;
   }
   return null;
 }
-function loadTsConfig(configPath, warnings) {
-  const read = ts.readConfigFile(configPath, ts.sys.readFile);
+function loadTsConfig(fileSystem, configPath, warnings) {
+  const host = {
+    useCaseSensitiveFileNames: fileSystem.caseSensitive,
+    readDirectory: () => [],
+    fileExists: (candidate) => fileSystem.exists(candidate),
+    readFile: (candidate) => fileSystem.tryReadFile(candidate) ?? void 0,
+    getCurrentDirectory: () => "/",
+    onUnRecoverableConfigFileDiagnostic: () => void 0
+  };
+  const read = ts.readConfigFile(
+    configPath,
+    (candidate) => fileSystem.tryReadFile(candidate) ?? void 0
+  );
   if (read.error || read.config === void 0) {
     warnings.push(
       `no se pudo leer ${configPath}: ${read.error?.messageText ?? "configuraci\xF3n vac\xEDa"}`
@@ -495,13 +663,13 @@ function loadTsConfig(configPath, warnings) {
   }
   const parsed = ts.parseJsonConfigFileContent(
     read.config,
-    ts.sys,
-    path.dirname(configPath),
+    host,
+    dirname(configPath),
     void 0,
     configPath
   );
-  const configDirectory = path.dirname(configPath);
-  const baseUrl = path.resolve(configDirectory, parsed.options.baseUrl ?? ".");
+  const configDirectory = dirname(configPath);
+  const baseUrl = resolve(configDirectory, parsed.options.baseUrl ?? ".");
   const paths = parsed.options.paths ?? {};
   const aliases = [];
   for (const [pattern, targets] of Object.entries(paths)) {
@@ -509,7 +677,7 @@ function loadTsConfig(configPath, warnings) {
     const star = pattern.indexOf("*");
     const prefix = star === -1 ? pattern : pattern.slice(0, star);
     const suffix = star === -1 ? "" : pattern.slice(star + 1);
-    const resolvedTargets = targets.filter((target) => typeof target === "string").map((target) => path.resolve(baseUrl, target));
+    const resolvedTargets = targets.filter((target) => typeof target === "string").map((target) => resolve(baseUrl, target));
     if (resolvedTargets.length > 0) {
       aliases.push({
         prefix,
@@ -602,8 +770,12 @@ function matchWildcardKey(pattern, subpath) {
   }
   return subpath.slice(prefix.length, subpath.length - suffix.length);
 }
-function discoverWorkspaces(root, warnings) {
-  const rootJson = readJsonFile(path.join(root, "package.json"), warnings);
+function discoverWorkspaces(root, fileSystem, warnings) {
+  const rootJson = readJsonFile(
+    fileSystem,
+    join(root, "package.json"),
+    warnings
+  );
   if (!rootJson) return [];
   const patterns = workspacePatterns(rootJson.workspaces);
   if (patterns.length === 0) return [];
@@ -615,14 +787,15 @@ function discoverWorkspaces(root, warnings) {
     const current = stack.pop();
     if (current.relative !== "" && patterns.some((pattern) => pattern.test(current.relative))) {
       const json = readJsonFile(
-        path.join(current.directory, "package.json"),
+        fileSystem,
+        join(current.directory, "package.json"),
         warnings
       );
       if (json && typeof json.name === "string") {
         const existing = byName.get(json.name);
         if (existing) {
           warnings.push(
-            `workspace duplicado "${json.name}": ${path.relative(root, existing.dir)} y ${path.relative(root, current.directory)}`
+            `workspace duplicado "${json.name}": ${relative(root, existing.dir)} y ${relative(root, current.directory)}`
           );
         } else {
           byName.set(json.name, {
@@ -636,7 +809,7 @@ function discoverWorkspaces(root, warnings) {
     if (current.depth >= MAX_WORKSPACE_DEPTH) continue;
     let entries;
     try {
-      entries = fs.readdirSync(current.directory, { withFileTypes: true });
+      entries = fileSystem.readDirectory(current.directory);
     } catch (error) {
       warnings.push(
         `no se pudo leer ${current.relative || "."}: ${error.message}`
@@ -644,10 +817,10 @@ function discoverWorkspaces(root, warnings) {
       continue;
     }
     for (const entry of entries) {
-      if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
+      if (!entry.isDirectory) continue;
       if (WORKSPACE_SKIP_DIRS.has(entry.name)) continue;
       stack.push({
-        directory: path.join(current.directory, entry.name),
+        directory: join(current.directory, entry.name),
         relative: current.relative ? `${current.relative}/${entry.name}` : entry.name,
         depth: current.depth + 1
       });
@@ -693,16 +866,15 @@ function globToRegExp(glob) {
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function readJsonFile(file, warnings) {
+function readJsonFile(fileSystem, file, warnings) {
   let text;
   try {
-    text = fs.readFileSync(file, "utf8");
+    text = fileSystem.tryReadFile(file);
   } catch (error) {
-    if (error.code !== "ENOENT") {
-      warnings.push(`no se pudo leer ${file}: ${error.message}`);
-    }
+    warnings.push(`no se pudo leer ${file}: ${error.message}`);
     return null;
   }
+  if (text === null) return null;
   try {
     const parsed = JSON.parse(text.replace(/^\uFEFF/, ""));
     return isRecord(parsed) ? parsed : null;
@@ -881,41 +1053,516 @@ function compareStrings(left, right) {
 }
 
 // packages/parsers/src/analyze.ts
-import fs4 from "node:fs";
-import path4 from "node:path";
+import { basename as basename2 } from "node:path";
 
 // packages/schema/src/errors.ts
 var CcJsonError = class extends Error {
   path;
-  constructor(message, path9) {
-    super(`${message} (en ${path9})`);
+  constructor(message, path7) {
+    super(`${message} (en ${path7})`);
     this.name = "CcJsonError";
-    this.path = path9;
+    this.path = path7;
   }
 };
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function requireRecord(value, path9) {
-  if (!isRecord2(value)) throw new CcJsonError("se esperaba un objeto", path9);
+function requireRecord(value, path7) {
+  if (!isRecord2(value)) throw new CcJsonError("se esperaba un objeto", path7);
   return value;
 }
-function requireString(value, path9, field5) {
+function requireString(value, path7, field5) {
   if (typeof value !== "string" || value.length === 0) {
-    throw new CcJsonError(`"${field5}" debe ser una cadena no vac\xEDa`, path9);
+    throw new CcJsonError(`"${field5}" debe ser una cadena no vac\xEDa`, path7);
   }
   return value;
 }
 
+// node_modules/@noble/hashes/_u64.js
+var fromNumH = (n) => n / 2 ** 32 | 0;
+var fromNumL = (n) => n >>> 0;
+function setU64FromNum(view, byteOffset, n, isLE) {
+  const h = fromNumH(n);
+  const l = fromNumL(n);
+  view.setUint32(byteOffset, isLE ? l : h, isLE);
+  view.setUint32(byteOffset + 4, isLE ? h : l, isLE);
+}
+
+// node_modules/@noble/hashes/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
+}
+var atitle = (title) => title ? `"${title}" ` : "";
+function anumber(n, title = "") {
+  if (typeof n !== "number")
+    throw new TypeError(atitle(title) + "expected number, got " + typeof n);
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new RangeError(atitle(title) + "expected integer >= 0, got " + n);
+  return n;
+}
+function abytes(value, length, title = "") {
+  if (isBytes(value) && (length === void 0 || value.length === length))
+    return value;
+  if (length !== void 0)
+    anumber(length, "length");
+  const bytes = isBytes(value);
+  const ofLen = length !== void 0 ? ` of length ${length}` : "";
+  const got = bytes ? `length=${value.length}` : `type=${typeof value}`;
+  const message = atitle(title) + "expected Uint8Array" + ofLen + ", got " + got;
+  if (!bytes)
+    throw new TypeError(message);
+  throw new RangeError(message);
+}
+var aobject = (value, label) => {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    throw new TypeError((label === "object" ? "" : `"${label}" `) + "expected object, got type=" + typeof value);
+};
+var aopts = (value, label) => {
+  aobject(value, label);
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null)
+    throw new TypeError(`"${label}" expected plain object`);
+  if (Object.hasOwn(value, "__proto__"))
+    throw new TypeError(`"${label}.__proto__" is not allowed`);
+};
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("hash was destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("digest() was already called");
+}
+function aoutput(out, instance) {
+  abytes(out, void 0, "output");
+  const min = instance.outputLen;
+  if (!(out.length >= min)) {
+    throw new RangeError('"output" expected length >= ' + min);
+  }
+}
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
+}
+function rotl(word, shift) {
+  return word << shift | word >>> 32 - shift >>> 0;
+}
+function checkOpts(defaults, opts, title = "opts") {
+  aopts(defaults, "defaults");
+  if (opts !== void 0)
+    aopts(opts, title);
+  const merged = Object.assign(/* @__PURE__ */ Object.create(null), defaults, opts);
+  return merged;
+}
+function createHasher(hashCons, info = {}) {
+  if (typeof hashCons !== "function")
+    throw new TypeError('"hashCons" expected function, got type=' + typeof hashCons);
+  info = checkOpts({}, info, "info");
+  const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+  const tmp = hashCons(void 0);
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.canXOF = tmp.canXOF;
+  hashC.create = (opts) => hashCons(opts);
+  Object.assign(hashC, info);
+  return Object.freeze(hashC);
+}
+var oidNist = (suffix) => ({
+  // Current NIST hashAlgs suffixes used here fit in one DER subidentifier octet.
+  // Larger suffix values would need base-128 OID encoding and a different length byte.
+  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix])
+});
+
+// node_modules/@noble/hashes/_md.js
+function Chi(a, b, c) {
+  return a & b ^ ~a & c;
+}
+function Maj(a, b, c) {
+  return a & b ^ a & c ^ b & c;
+}
+var HashMD = class {
+  blockLen;
+  outputLen;
+  canXOF = false;
+  padOffset;
+  isLE;
+  // For partial updates less than block size
+  buffer;
+  view;
+  finished = false;
+  length = 0;
+  pos = 0;
+  destroyed = false;
+  constructor(blockLen, outputLen, padOffset, isLE) {
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  update(data) {
+    aexists(this);
+    abytes(data);
+    const { view, buffer, blockLen } = this;
+    const len = data.length;
+    let processed = false;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        processed = true;
+        continue;
+      }
+      buffer.set(pos === 0 && take === len ? data : data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+        processed = true;
+      }
+    }
+    this.length += data.length;
+    if (processed)
+      this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    buffer.fill(0, pos);
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      buffer.fill(0);
+    }
+    setU64FromNum(view, blockLen - 8, this.length * 8, isLE);
+    this.process(view, 0);
+    this.roundClean();
+    const oview = out === buffer ? view : createView(out);
+    const len = this.outputLen;
+    const outLen = len / 4;
+    const state = this.get();
+    if (len % 4 || outLen > state.length)
+      throw new Error("invalid outputLen");
+    for (let i = 0; i < outLen; i++)
+      oview.setUint32(4 * i, state[i], isLE);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneIntoMeta(to) {
+    const { buffer, length, finished, destroyed, pos } = this;
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    if (pos)
+      to.buffer.set(buffer);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+};
+var SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+
+// node_modules/@noble/hashes/legacy.js
+var SHA1_IV = /* @__PURE__ */ Uint32Array.from([
+  1732584193,
+  4023233417,
+  2562383102,
+  271733878,
+  3285377520
+]);
+var p32 = /* @__PURE__ */ Math.pow(2, 32);
+var K = /* @__PURE__ */ Array.from({ length: 64 }, (_, i) => Math.floor(p32 * Math.abs(Math.sin(i + 1))));
+var MD5_IV = /* @__PURE__ */ SHA1_IV.slice(0, 4);
+var MD5_W = /* @__PURE__ */ new Uint32Array(16);
+var MD5_SHIFTS = /* @__PURE__ */ (() => {
+  const S = [
+    [7, 12, 17, 22],
+    [5, 9, 14, 20],
+    [4, 11, 16, 23],
+    [6, 10, 15, 21]
+  ];
+  return Uint8Array.from({ length: 64 }, (_, i) => S[Math.floor(i / 16)][i % 4]);
+})();
+var _MD5 = class extends HashMD {
+  A = MD5_IV[0] | 0;
+  B = MD5_IV[1] | 0;
+  C = MD5_IV[2] | 0;
+  D = MD5_IV[3] | 0;
+  constructor() {
+    super(64, 16, 8, true);
+  }
+  get() {
+    const { A, B, C, D } = this;
+    return [A, B, C, D];
+  }
+  set(A, B, C, D) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+  }
+  _cloneInto(to) {
+    (to ||= new this.constructor()).set(...this.get());
+    return this._cloneIntoMeta(to);
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4)
+      MD5_W[i] = view.getUint32(offset, true);
+    let { A, B, C, D } = this;
+    for (let i = 0; i < 64; i++) {
+      let F, g;
+      if (i < 16) {
+        F = Chi(B, C, D);
+        g = i;
+      } else if (i < 32) {
+        F = Chi(D, B, C);
+        g = (5 * i + 1) % 16;
+      } else if (i < 48) {
+        F = B ^ C ^ D;
+        g = (3 * i + 5) % 16;
+      } else {
+        F = C ^ (B | ~D);
+        g = 7 * i % 16;
+      }
+      F = F + A + K[i] + MD5_W[g];
+      A = D;
+      D = C;
+      C = B;
+      B = B + rotl(F, MD5_SHIFTS[i]);
+    }
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C = C + this.C | 0;
+    D = D + this.D | 0;
+    this.set(A, B, C, D);
+  }
+  roundClean() {
+    clean(MD5_W);
+  }
+  destroy() {
+    this.destroyed = true;
+    this.set(0, 0, 0, 0);
+    clean(this.buffer);
+  }
+};
+var md5 = /* @__PURE__ */ createHasher(() => new _MD5());
+
+// node_modules/@noble/hashes/sha2.js
+var SHA256_K = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+var SHA2_32B = class extends HashMD {
+  // We cannot use array here since array allows indexing by variable
+  // which means optimizer/compiler cannot use registers.
+  // Numeric initializers matter: starting the fields as `undefined` changes
+  // V8's field representation and makes sha256 3x slower (measured).
+  A = 0;
+  B = 0;
+  C = 0;
+  D = 0;
+  E = 0;
+  F = 0;
+  G = 0;
+  H = 0;
+  constructor(outputLen, IV) {
+    super(64, outputLen, 8, false);
+    this.A = IV[0] | 0;
+    this.B = IV[1] | 0;
+    this.C = IV[2] | 0;
+    this.D = IV[3] | 0;
+    this.E = IV[4] | 0;
+    this.F = IV[5] | 0;
+    this.G = IV[6] | 0;
+    this.H = IV[7] | 0;
+  }
+  get() {
+    const { A, B, C, D, E, F, G, H } = this;
+    return [A, B, C, D, E, F, G, H];
+  }
+  // prettier-ignore
+  set(A, B, C, D, E, F, G, H) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+    this.F = F | 0;
+    this.G = G | 0;
+    this.H = H | 0;
+  }
+  _cloneInto(to) {
+    (to ||= new this.constructor()).set(...this.get());
+    return this._cloneIntoMeta(to);
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4)
+      SHA256_W[i] = view.getUint32(offset, false);
+    for (let i = 16; i < 64; i++) {
+      const W15 = SHA256_W[i - 15];
+      const W2 = SHA256_W[i - 2];
+      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+    }
+    let { A, B, C, D, E, F, G, H } = this;
+    for (let i = 0; i < 64; i++) {
+      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+      const T2 = sigma0 + Maj(A, B, C) | 0;
+      H = G;
+      G = F;
+      F = E;
+      E = D + T1 | 0;
+      D = C;
+      C = B;
+      B = A;
+      A = T1 + T2 | 0;
+    }
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C = C + this.C | 0;
+    D = D + this.D | 0;
+    E = E + this.E | 0;
+    F = F + this.F | 0;
+    G = G + this.G | 0;
+    H = H + this.H | 0;
+    this.set(A, B, C, D, E, F, G, H);
+  }
+  roundClean() {
+    clean(SHA256_W);
+  }
+  destroy() {
+    this.destroyed = true;
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    clean(this.buffer);
+  }
+};
+var _SHA256 = class extends SHA2_32B {
+  constructor() {
+    super(32, SHA256_IV);
+  }
+};
+var sha256 = /* @__PURE__ */ createHasher(
+  () => new _SHA256(),
+  /* @__PURE__ */ oidNist(1)
+);
+
+// packages/schema/src/hash.ts
+var encoder = new TextEncoder();
+function sha256Hex(input) {
+  return toHex(sha256(encoder.encode(input)));
+}
+function md5Hex(input) {
+  return toHex(md5(encoder.encode(input)));
+}
+function toHex(bytes) {
+  let hex = "";
+  for (const byte of bytes) hex += byte.toString(16).padStart(2, "0");
+  return hex;
+}
+
 // packages/schema/src/identity.ts
-import { createHash } from "node:crypto";
 var ID_LENGTH = 16;
 function normalizeName(name) {
   return name.normalize("NFC");
 }
-function pathSegments(path9) {
+function pathSegments(path7) {
   const segments = [];
-  for (const raw of path9.replace(/\\/g, "/").split("/")) {
+  for (const raw of path7.replace(/\\/g, "/").split("/")) {
     const segment = normalizeName(raw);
     if (segment === "" || segment === ".") continue;
     if (segment === "..") {
@@ -929,18 +1576,18 @@ function pathSegments(path9) {
 function canonicalPath(segments) {
   return `/${segments.map(normalizeName).join("/")}`;
 }
-function idFromCanonicalPath(path9, type = "File") {
-  const canonical = path9.startsWith("/") ? path9 : `/${path9}`;
-  return createHash("sha256").update(type + canonical, "utf8").digest("hex").slice(0, ID_LENGTH);
+function idFromCanonicalPath(path7, type = "File") {
+  const canonical = path7.startsWith("/") ? path7 : `/${path7}`;
+  return sha256Hex(type + canonical).slice(0, ID_LENGTH);
 }
 function nodeId(type, segments) {
   return idFromCanonicalPath(canonicalPath(segments), type);
 }
-function fileId(path9) {
-  return nodeId("File", pathSegments(path9));
+function fileId(path7) {
+  return nodeId("File", pathSegments(path7));
 }
-function folderId(path9) {
-  return nodeId("Folder", pathSegments(path9));
+function folderId(path7) {
+  return nodeId("Folder", pathSegments(path7));
 }
 
 // packages/schema/src/legacy.ts
@@ -996,15 +1643,15 @@ function normalizeLegacyCcJson(input) {
   const metrics = {};
   const built = [];
   const ids = /* @__PURE__ */ new Map();
-  const buildNode = (value, parentPath, path9, depth) => {
+  const buildNode = (value, parentPath, path7, depth) => {
     if (depth > MAX_DEPTH) {
-      throw new CcJsonError(`profundidad m\xE1xima ${MAX_DEPTH} superada`, path9);
+      throw new CcJsonError(`profundidad m\xE1xima ${MAX_DEPTH} superada`, path7);
     }
-    const raw = requireRecord(value, path9);
-    const name = readNodeName(raw.name, `${path9}.name`);
+    const raw = requireRecord(value, path7);
+    const name = readNodeName(raw.name, `${path7}.name`);
     const type = raw.type;
     if (type !== "File" && type !== "Folder") {
-      throw new CcJsonError('"type" debe ser "File" o "Folder"', `${path9}.type`);
+      throw new CcJsonError('"type" debe ser "File" o "Folder"', `${path7}.type`);
     }
     const fullPath = [...parentPath, name];
     const id = nodeId(type, fullPath.slice(1));
@@ -1012,13 +1659,13 @@ function normalizeLegacyCcJson(input) {
     if (previous !== void 0) {
       throw new CcJsonError(
         `id duplicado "${id}" para "${previous}" y "${fullPath.join("/")}"`,
-        `${path9}.name`
+        `${path7}.name`
       );
     }
     ids.set(id, fullPath.join("/"));
     built.push({ id, name, fullPath: fullPath.join("/") });
     const node = { id, name, type };
-    const attributes = readMetrics(raw.attributes, `${path9}.attributes`);
+    const attributes = readMetrics(raw.attributes, `${path7}.attributes`);
     if (attributes) metrics[id] = attributes;
     const contentHash = readOptionalString(raw.checksum) ?? readOptionalString(raw.contentHash);
     if (contentHash) node.contentHash = contentHash;
@@ -1026,14 +1673,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', `${path9}.children`);
+        throw new CcJsonError('"children" debe ser un array', `${path7}.children`);
       }
       if (type === "File" && raw.children.length > 0) {
-        throw new CcJsonError("un fichero no puede tener hijos", `${path9}.children`);
+        throw new CcJsonError("un fichero no puede tener hijos", `${path7}.children`);
       }
       if (type === "Folder" && raw.children.length > 0) {
         node.children = raw.children.map(
-          (child, index) => buildNode(child, fullPath, `${path9}.children[${index}]`, depth + 1)
+          (child, index) => buildNode(child, fullPath, `${path7}.children[${index}]`, depth + 1)
         );
       }
     }
@@ -1050,15 +1697,15 @@ function normalizeLegacyCcJson(input) {
       throw new CcJsonError('"edges" debe ser un array', `${base}.edges`);
     }
     edgesRaw.forEach((edge, index) => {
-      const path9 = `${base}.edges[${index}]`;
-      const raw = requireRecord(edge, path9);
-      const fromName = requireString(raw.fromNodeName, `${path9}.fromNodeName`, "fromNodeName");
-      const toName = requireString(raw.toNodeName, `${path9}.toNodeName`, "toNodeName");
+      const path7 = `${base}.edges[${index}]`;
+      const raw = requireRecord(edge, path7);
+      const fromName = requireString(raw.fromNodeName, `${path7}.fromNodeName`, "fromNodeName");
+      const toName = requireString(raw.toNodeName, `${path7}.toNodeName`, "toNodeName");
       const normalized = {
-        fromId: resolveEndpoint(fromName, pathIndex, stripNames, `${path9}.fromNodeName`),
-        toId: resolveEndpoint(toName, pathIndex, stripNames, `${path9}.toNodeName`)
+        fromId: resolveEndpoint(fromName, pathIndex, stripNames, `${path7}.fromNodeName`),
+        toId: resolveEndpoint(toName, pathIndex, stripNames, `${path7}.toNodeName`)
       };
-      const attributes = readMetrics(raw.attributes, `${path9}.attributes`);
+      const attributes = readMetrics(raw.attributes, `${path7}.attributes`);
       if (attributes) normalized.attributes = attributes;
       if (typeof raw.isCyclic === "boolean") normalized.isCyclic = raw.isCyclic;
       if (typeof raw.isPointingUpwards === "boolean") {
@@ -1128,10 +1775,10 @@ function buildPathIndex(built, multipleRoots) {
   for (const node of built) {
     const segments = node.fullPath.split("/");
     if (segments.length > 1) add(segments.slice(1).join("/"), node.id);
-    const relative = segments.slice(multipleRoots ? 2 : 1).join("/");
-    if (relative !== "") {
-      add(relative, node.id);
-      add(`root/${relative}`, node.id);
+    const relative2 = segments.slice(multipleRoots ? 2 : 1).join("/");
+    if (relative2 !== "") {
+      add(relative2, node.id);
+      add(`root/${relative2}`, node.id);
     } else if (segments.length === 1) {
       add("root", node.id);
     }
@@ -1143,10 +1790,10 @@ function buildPathIndex(built, multipleRoots) {
   }
   return index;
 }
-function resolveEndpoint(endpoint, index, stripNames, path9) {
+function resolveEndpoint(endpoint, index, stripNames, path7) {
   const segments = canonicalSegments(endpoint);
   if (segments.length === 0) {
-    throw new CcJsonError("extremo de arista vac\xEDo", path9);
+    throw new CcJsonError("extremo de arista vac\xEDo", path7);
   }
   const candidates = [segments.join("/")];
   if (segments.length > 1 && stripNames.has(segments[0])) {
@@ -1158,7 +1805,7 @@ function resolveEndpoint(endpoint, index, stripNames, path9) {
   }
   const bare = index.get(segments[segments.length - 1]);
   if (bare) return bare;
-  throw new CcJsonError(`no se pudo resolver el nodo "${endpoint}"`, path9);
+  throw new CcJsonError(`no se pudo resolver el nodo "${endpoint}"`, path7);
 }
 function canonicalSegments(value) {
   const result = [];
@@ -1173,85 +1820,85 @@ function canonicalSegments(value) {
   }
   return result;
 }
-function readNodeName(value, path9) {
-  const name = normalizeName(requireString(value, path9, "name"));
+function readNodeName(value, path7) {
+  const name = normalizeName(requireString(value, path7, "name"));
   if (name === "." || name === "..") {
-    throw new CcJsonError('el nombre no puede ser "." ni ".."', path9);
+    throw new CcJsonError('el nombre no puede ser "." ni ".."', path7);
   }
   if (name.includes("/")) {
-    throw new CcJsonError('el nombre no puede contener "/"', path9);
+    throw new CcJsonError('el nombre no puede contener "/"', path7);
   }
   return name;
 }
 function readOptionalString(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-function readMetrics(value, path9) {
+function readMetrics(value, path7) {
   if (value === void 0) return void 0;
-  const raw = requireRecord(value, path9);
+  const raw = requireRecord(value, path7);
   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`,
-        `${path9}["${metric}"]`
+        `${path7}["${metric}"]`
       );
     }
     out[metric] = metricValue;
   }
   return Object.keys(out).length > 0 ? out : void 0;
 }
-function readAttributeTypes(value, path9) {
+function readAttributeTypes(value, path7) {
   if (value === void 0) return {};
-  const raw = requireRecord(value, path9);
+  const raw = requireRecord(value, path7);
   if ("nodes" in raw || "edges" in raw) {
-    const nodes2 = raw.nodes === void 0 ? void 0 : readTypeMap(raw.nodes, `${path9}.nodes`);
-    const edges = raw.edges === void 0 ? void 0 : readTypeMap(raw.edges, `${path9}.edges`);
+    const nodes2 = raw.nodes === void 0 ? void 0 : readTypeMap(raw.nodes, `${path7}.nodes`);
+    const edges = raw.edges === void 0 ? void 0 : readTypeMap(raw.edges, `${path7}.edges`);
     return {
       ...nodes2 && Object.keys(nodes2).length > 0 ? { nodes: nodes2 } : {},
       ...edges && Object.keys(edges).length > 0 ? { edges } : {}
     };
   }
-  const nodes = readTypeMap(raw, path9);
+  const nodes = readTypeMap(raw, path7);
   return Object.keys(nodes).length > 0 ? { nodes } : {};
 }
-function readTypeMap(value, path9) {
-  const raw = requireRecord(value, path9);
+function readTypeMap(value, path7) {
+  const raw = requireRecord(value, path7);
   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"`,
-        `${path9}["${metric}"]`
+        `${path7}["${metric}"]`
       );
     }
     out[metric] = type;
   }
   return out;
 }
-function readDescriptors(value, path9) {
+function readDescriptors(value, path7) {
   if (value === void 0) return {};
-  const raw = requireRecord(value, path9);
+  const raw = requireRecord(value, path7);
   if ("nodes" in raw || "edges" in raw) {
-    const nodes = raw.nodes === void 0 ? void 0 : readDescriptorMap(raw.nodes, `${path9}.nodes`);
-    const edges = raw.edges === void 0 ? void 0 : readDescriptorMap(raw.edges, `${path9}.edges`);
+    const nodes = raw.nodes === void 0 ? void 0 : readDescriptorMap(raw.nodes, `${path7}.nodes`);
+    const edges = raw.edges === void 0 ? void 0 : readDescriptorMap(raw.edges, `${path7}.edges`);
     return {
       ...nodes && Object.keys(nodes).length > 0 ? { nodes } : {},
       ...edges && Object.keys(edges).length > 0 ? { edges } : {}
     };
   }
-  const flat = readDescriptorMap(raw, path9);
+  const flat = readDescriptorMap(raw, path7);
   return Object.keys(flat).length > 0 ? { flat } : {};
 }
-function readDescriptorMap(value, path9) {
-  const raw = requireRecord(value, path9);
+function readDescriptorMap(value, path7) {
+  const raw = requireRecord(value, path7);
   const out = {};
   for (const [metric, descriptor] of Object.entries(raw)) {
-    const record = requireRecord(descriptor, `${path9}["${metric}"]`);
+    const record = requireRecord(descriptor, `${path7}["${metric}"]`);
     if (record.direction !== void 0 && typeof record.direction !== "number") {
       throw new CcJsonError(
         `"direction" de "${metric}" debe ser un n\xFAmero`,
-        `${path9}["${metric}"].direction`
+        `${path7}["${metric}"].direction`
       );
     }
     out[metric] = record;
@@ -1276,26 +1923,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, path9, depth) => {
-    if (depth > MAX_DEPTH2) throw new CcJsonError(`profundidad m\xE1xima ${MAX_DEPTH2} superada`, path9);
-    const raw = requireRecord(value, path9);
-    const id = requireString(raw.id, `${path9}.id`, "id");
-    if (ids.has(id)) throw new CcJsonError(`id duplicado "${id}"`, `${path9}.id`);
+  const validateNode = (value, path7, depth) => {
+    if (depth > MAX_DEPTH2) throw new CcJsonError(`profundidad m\xE1xima ${MAX_DEPTH2} superada`, path7);
+    const raw = requireRecord(value, path7);
+    const id = requireString(raw.id, `${path7}.id`, "id");
+    if (ids.has(id)) throw new CcJsonError(`id duplicado "${id}"`, `${path7}.id`);
     ids.add(id);
-    const name = requireString(raw.name, `${path9}.name`, "name");
+    const name = requireString(raw.name, `${path7}.name`, "name");
     const type = raw.type;
     if (type !== "File" && type !== "Folder") {
-      throw new CcJsonError('"type" debe ser "File" o "Folder"', `${path9}.type`);
+      throw new CcJsonError('"type" debe ser "File" o "Folder"', `${path7}.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', `${path9}.children`);
+        throw new CcJsonError('"children" debe ser un array', `${path7}.children`);
       }
       node.children = raw.children.map(
-        (child, index) => validateNode(child, `${path9}.children[${index}]`, depth + 1)
+        (child, index) => validateNode(child, `${path7}.children[${index}]`, depth + 1)
       );
     }
     return node;
@@ -1326,10 +1973,10 @@ function parseCcJson2(input) {
           throw new CcJsonError('"edges" debe ser un array', "$.lenses.dependency.edges");
         }
         dependency.edges.forEach((edge, index) => {
-          const path9 = `$.lenses.dependency.edges[${index}]`;
-          const raw = requireRecord(edge, path9);
-          requireString(raw.fromId, `${path9}.fromId`, "fromId");
-          requireString(raw.toId, `${path9}.toId`, "toId");
+          const path7 = `$.lenses.dependency.edges[${index}]`;
+          const raw = requireRecord(edge, path7);
+          requireString(raw.fromId, `${path7}.fromId`, "fromId");
+          requireString(raw.toId, `${path7}.toId`, "toId");
         });
       }
     }
@@ -1418,9 +2065,9 @@ function topByMetric(cc, metric, limit = 10) {
   const ranked = [];
   for (const [id, values] of Object.entries(attributes)) {
     const value = values[metric];
-    const path9 = paths.get(id);
-    if (value === void 0 || path9 === void 0) continue;
-    ranked.push({ id, path: path9, value });
+    const path7 = paths.get(id);
+    if (value === void 0 || path7 === void 0) continue;
+    ranked.push({ id, path: path7, value });
   }
   ranked.sort((a, b) => b.value - a.value || a.path.localeCompare(b.path));
   return ranked.slice(0, limit);
@@ -1430,155 +2077,6 @@ function defaultMetric(stats) {
   return stats.metricCoverage[0]?.name;
 }
 
-// packages/parsers/src/git.ts
-import { spawnSync } from "node:child_process";
-import fs2 from "node:fs";
-import path2 from "node:path";
-var COMMIT_PREFIX = "__CODARCH_COMMIT__";
-var DEFAULT_MAX_BUFFER = 128 * 1024 * 1024;
-var EMPTY = {
-  metrics: /* @__PURE__ */ new Map(),
-  commits: 0,
-  authors: 0,
-  shallow: false,
-  enabled: false,
-  warnings: []
-};
-function collectGitChurn(rootInput, files, options = {}) {
-  if (options.enabled === false || files.length === 0) {
-    return { ...EMPTY, metrics: /* @__PURE__ */ new Map() };
-  }
-  const root = realPath(rootInput);
-  const maxBuffer = options.maxBuffer ?? DEFAULT_MAX_BUFFER;
-  const warnings = [];
-  const topLevel = runGit(root, ["rev-parse", "--show-toplevel"], maxBuffer);
-  if (!topLevel.ok) {
-    return {
-      ...EMPTY,
-      metrics: /* @__PURE__ */ new Map(),
-      warnings: [`no hay historial git utilizable: ${topLevel.error}`]
-    };
-  }
-  const repoRoot = realPath(topLevel.stdout.trim());
-  const shallowResult = runGit(
-    repoRoot,
-    ["rev-parse", "--is-shallow-repository"],
-    maxBuffer
-  );
-  const shallow = shallowResult.ok && shallowResult.stdout.trim().toLowerCase() === "true";
-  if (shallow) {
-    warnings.push(
-      "el repositorio es shallow: el churn puede estar incompleto"
-    );
-  }
-  const log = runGit(
-    repoRoot,
-    [
-      "-c",
-      "core.quotePath=false",
-      "log",
-      "--no-merges",
-      "--numstat",
-      `--format=${COMMIT_PREFIX}%H%x09%ae`
-    ],
-    maxBuffer
-  );
-  if (!log.ok) {
-    return {
-      ...EMPTY,
-      shallow,
-      warnings: [...warnings, `no se pudo leer git log: ${log.error}`]
-    };
-  }
-  const wanted = new Set(files);
-  const commitsByFile = /* @__PURE__ */ new Map();
-  const authorsByFile = /* @__PURE__ */ new Map();
-  const authors = /* @__PURE__ */ new Set();
-  let commits = 0;
-  let currentAuthor = "";
-  let touched = /* @__PURE__ */ new Set();
-  const flushCommit = () => {
-    if (!currentAuthor || touched.size === 0) return;
-    commits++;
-    authors.add(currentAuthor);
-    for (const file of touched) {
-      commitsByFile.set(file, (commitsByFile.get(file) ?? 0) + 1);
-      let fileAuthors = authorsByFile.get(file);
-      if (!fileAuthors) {
-        fileAuthors = /* @__PURE__ */ new Set();
-        authorsByFile.set(file, fileAuthors);
-      }
-      fileAuthors.add(currentAuthor);
-    }
-    touched = /* @__PURE__ */ new Set();
-    currentAuthor = "";
-  };
-  for (const rawLine of log.stdout.split(/\r?\n/)) {
-    if (rawLine.startsWith(COMMIT_PREFIX)) {
-      flushCommit();
-      const fields2 = rawLine.slice(COMMIT_PREFIX.length).split("	");
-      const author = fields2[1]?.trim() ?? "";
-      currentAuthor = author || "(sin autor)";
-      continue;
-    }
-    if (!currentAuthor || rawLine === "") continue;
-    const fields = rawLine.split("	");
-    if (fields.length < 3) continue;
-    const gitPath = fields.slice(2).join("	");
-    if (!gitPath) continue;
-    const relative = path2.relative(root, path2.resolve(repoRoot, gitPath));
-    if (relative === "" || relative === ".." || relative.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative)) {
-      continue;
-    }
-    const normalized = relative.split(path2.sep).join("/");
-    if (!wanted.has(normalized)) continue;
-    touched.add(normalized);
-  }
-  flushCommit();
-  const metrics = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    metrics.set(file, {
-      commits: commitsByFile.get(file) ?? 0,
-      authors: authorsByFile.get(file)?.size ?? 0
-    });
-  }
-  return {
-    metrics,
-    commits,
-    authors: authors.size,
-    shallow,
-    enabled: true,
-    warnings
-  };
-}
-function realPath(input) {
-  const resolved = path2.resolve(input);
-  try {
-    return fs2.realpathSync.native(resolved);
-  } catch {
-    return resolved;
-  }
-}
-function runGit(cwd, args, maxBuffer) {
-  const result = spawnSync("git", args, {
-    cwd,
-    encoding: "utf8",
-    maxBuffer,
-    windowsHide: true
-  });
-  if (result.error) {
-    return { ok: false, stdout: "", error: result.error.message };
-  }
-  if (result.status !== 0) {
-    return {
-      ok: false,
-      stdout: result.stdout ?? "",
-      error: (result.stderr ?? "").trim() || `git exited with ${result.status}`
-    };
-  }
-  return { ok: true, stdout: result.stdout ?? "", error: "" };
-}
-
 // packages/parsers/src/migration.ts
 var EXTENSION_LANGUAGE = {
   ".ts": "ts",
@@ -1722,9 +2220,9 @@ function jsIsBridge(source, specifiers) {
   return specifiers.some((specifier) => ffiKindForSpecifier(specifier) !== null) || JS_FFI.test(source);
 }
 function ffiKindForSpecifier(specifier) {
-  const clean = specifier.split(/[?#]/, 1)[0]?.toLowerCase() ?? "";
-  if (clean.endsWith(".wasm")) return "wasm";
-  if (clean.endsWith(".node")) return "native";
+  const clean2 = specifier.split(/[?#]/, 1)[0]?.toLowerCase() ?? "";
+  if (clean2.endsWith(".wasm")) return "wasm";
+  if (clean2.endsWith(".node")) return "native";
   return null;
 }
 function buildMigration(files, links) {
@@ -1814,7 +2312,6 @@ function compareStrings2(left, right) {
 }
 
 // packages/parsers/src/snapshot.ts
-import { createHash as createHash2 } from "node:crypto";
 var METRIC_DESCRIPTORS = {
   loc: {
     title: "L\xEDneas",
@@ -1989,8 +2486,8 @@ function buildSnapshot(input) {
     isCyclic: edge.isCyclic
   }));
   const dependencyNodes = {};
-  for (const [path9, metrics] of input.graph.metrics) {
-    dependencyNodes[fileId(path9)] = { level: metrics.dependencyLevel };
+  for (const [path7, metrics] of input.graph.metrics) {
+    dependencyNodes[fileId(path7)] = { level: metrics.dependencyLevel };
   }
   const migrationLens = input.migration ? migrationLensFrom(input.migration) : void 0;
   const lenses = {
@@ -2039,7 +2536,7 @@ function migrationLensFrom(migration) {
   };
 }
 function checksumFor(files, lenses) {
-  return createHash2("md5").update(stableStringify({ files, lenses }), "utf8").digest("hex");
+  return md5Hex(stableStringify({ files, lenses }));
 }
 function stableStringify(value) {
   if (value === null || value === void 0) return "null";
@@ -2076,9 +2573,9 @@ function compareStrings3(left, right) {
 }
 
 // packages/parsers/src/walk.ts
-import fs3 from "node:fs";
-import path3 from "node:path";
 import ignore from "ignore";
+
+// packages/parsers/src/extensions.ts
 var DEFAULT_EXTENSIONS = [
   ".ts",
   ".tsx",
@@ -2089,29 +2586,26 @@ var DEFAULT_EXTENSIONS = [
   ".mjs",
   ".cjs"
 ];
+
+// packages/parsers/src/walk.ts
 var ALWAYS_IGNORED = [".git", "node_modules", ".codarch"];
-function walkSourceFiles(rootInput, options = {}) {
-  const root = path3.resolve(rootInput);
-  const stat = fs3.statSync(root);
-  if (!stat.isDirectory()) {
-    throw new Error(`no es un directorio: ${rootInput}`);
-  }
+function walkSourceFiles(fileSystem, options = {}) {
   const extensions = options.extensions ?? DEFAULT_EXTENSIONS;
   const warnings = [];
   const files = [];
   const rootMatcher = ignore().add(ALWAYS_IGNORED);
   for (const pattern of options.ignore ?? []) rootMatcher.add(pattern);
-  const rootGitignore = readGitignore(root, "", warnings);
+  const rootGitignore = readGitignore(fileSystem, "/", "", warnings);
   if (rootGitignore) rootMatcher.add(rootGitignore);
   const initialLayers = [{ base: "", matcher: rootMatcher }];
   const stack = [
-    { absolutePath: root, relativePath: "", layers: initialLayers }
+    { absolutePath: "/", relativePath: "", layers: initialLayers }
   ];
   while (stack.length > 0) {
     const directory = stack.pop();
     let entries;
     try {
-      entries = fs3.readdirSync(directory.absolutePath, { withFileTypes: true });
+      entries = fileSystem.readDirectory(directory.absolutePath);
     } catch (error) {
       warnings.push(
         `no se pudo leer ${directory.relativePath || "."}: ${error.message}`
@@ -2122,15 +2616,14 @@ function walkSourceFiles(rootInput, options = {}) {
       (left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0
     );
     for (const entry of entries) {
-      if (entry.isSymbolicLink()) continue;
       const relativePath2 = directory.relativePath ? `${directory.relativePath}/${entry.name}` : entry.name;
-      const absolutePath = path3.join(directory.absolutePath, entry.name);
-      if (entry.isDirectory()) {
+      const absolutePath = directory.absolutePath === "/" ? `/${entry.name}` : `${directory.absolutePath}/${entry.name}`;
+      if (entry.isDirectory) {
         if (isIgnored(directory.layers, relativePath2, true)) continue;
-        const nested = readGitignore(absolutePath, relativePath2, warnings);
+        const nested = readGitignore(fileSystem, absolutePath, relativePath2, warnings);
         const layers = nested ? [...directory.layers, { base: relativePath2, matcher: ignore().add(nested) }] : directory.layers;
         stack.push({ absolutePath, relativePath: relativePath2, layers });
-      } else if (entry.isFile()) {
+      } else if (entry.isFile) {
         if (isIgnored(directory.layers, relativePath2, false)) continue;
         if (!matchesExtension(entry.name, extensions)) continue;
         files.push({ absolutePath, relativePath: relativePath2 });
@@ -2143,16 +2636,14 @@ function walkSourceFiles(rootInput, options = {}) {
   warnings.sort();
   return { files, warnings };
 }
-function readGitignore(directory, relativeBase, warnings) {
-  const file = path3.join(directory, ".gitignore");
+function readGitignore(fileSystem, absoluteDirectory, relativeBase, warnings) {
+  const file = absoluteDirectory === "/" ? "/.gitignore" : `${absoluteDirectory}/.gitignore`;
   try {
-    return fs3.readFileSync(file, "utf8");
+    return fileSystem.tryReadFile(file);
   } catch (error) {
-    if (error.code !== "ENOENT") {
-      warnings.push(
-        `no se pudo leer ${relativeBase ? `${relativeBase}/` : ""}.gitignore: ${error.message}`
-      );
-    }
+    warnings.push(
+      `no se pudo leer ${relativeBase ? `${relativeBase}/` : ""}.gitignore: ${error.message}`
+    );
     return null;
   }
 }
@@ -2173,19 +2664,20 @@ function matchesExtension(name, extensions) {
   return extensions.some((extension) => lower.endsWith(extension));
 }
 
-// packages/parsers/src/analyze.ts
-function analyzeRepository(rootInput, options = {}) {
+// packages/parsers/src/analyze-core.ts
+function analyzeFiles(options) {
   const started = Date.now();
-  const root = path4.resolve(rootInput);
-  const projectName = options.projectName ?? readProjectName(root);
-  const walked = walkSourceFiles(root, {
+  const fileSystem = options.fileSystem;
+  const root = options.root ?? "/";
+  const projectName = options.projectName ?? readProjectName(fileSystem, root, options.fallbackName);
+  const walked = walkSourceFiles(fileSystem, {
     ignore: options.ignore,
     extensions: options.extensions ?? MIGRATION_EXTENSIONS
   });
   const warnings = [...walked.warnings];
-  const resolver = new ImportResolver(root, walked.files);
+  const resolver = new ImportResolver(root, walked.files, fileSystem);
   warnings.push(...resolver.warnings);
-  const parser = new TypeScriptParser();
+  const parser = options.parser;
   const parsedFiles = [];
   const migrationFiles = [];
   const migrationLinks = [];
@@ -2215,7 +2707,7 @@ function analyzeRepository(rootInput, options = {}) {
     }
     let source;
     try {
-      source = fs4.readFileSync(file.absolutePath, "utf8");
+      source = fileSystem.readFile(file.absolutePath);
     } catch (error) {
       warnings.push(
         `no se pudo leer ${file.relativePath}: ${error.message}`
@@ -2311,18 +2803,15 @@ function analyzeRepository(rootInput, options = {}) {
       )
     });
   }
-  const git = collectGitChurn(
-    root,
-    parsedFiles.map((file) => file.relativePath),
-    { enabled: options.git !== false }
-  );
-  warnings.push(...git.warnings);
-  if (git.enabled) {
+  let churnResult = null;
+  if (options.churn) {
+    churnResult = options.churn(parsedFiles.map((file) => file.relativePath));
+    warnings.push(...churnResult.warnings);
     for (const file of parsedFiles) {
-      const churn = git.metrics.get(file.relativePath);
-      if (!churn) continue;
-      file.metrics.number_of_commits = churn.commits;
-      file.metrics.number_of_authors = churn.authors;
+      const metrics = churnResult.metrics.get(file.relativePath);
+      if (!metrics) continue;
+      file.metrics.number_of_commits = metrics.commits;
+      file.metrics.number_of_authors = metrics.authors;
     }
   }
   const graph = buildGraph(
@@ -2382,19 +2871,14 @@ function analyzeRepository(rootInput, options = {}) {
     builtinImports,
     typeOnlyImports,
     unresolvedImports: unresolved.length,
-    git: {
-      enabled: git.enabled,
-      commits: git.commits,
-      authors: git.authors,
-      shallow: git.shallow
-    },
     migration: migration.summary,
+    churn: churnResult,
     durationMs: Date.now() - started
   };
 }
-function readProjectName(root) {
+function readProjectName(fileSystem, root, fallbackName) {
   try {
-    const text = fs4.readFileSync(path4.join(root, "package.json"), "utf8");
+    const text = fileSystem.readFile(join(root, "package.json"));
     const parsed = JSON.parse(text.replace(/^\uFEFF/, ""));
     if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && typeof parsed.name === "string") {
       const name = parsed.name.trim();
@@ -2402,7 +2886,232 @@ function readProjectName(root) {
     }
   } catch {
   }
-  return path4.basename(root) || "Proyecto";
+  return fallbackName ?? basename(root) ?? "Proyecto";
+}
+
+// packages/parsers/src/git.ts
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+var COMMIT_PREFIX = "__CODARCH_COMMIT__";
+var DEFAULT_MAX_BUFFER = 128 * 1024 * 1024;
+var EMPTY = {
+  metrics: /* @__PURE__ */ new Map(),
+  commits: 0,
+  authors: 0,
+  shallow: false,
+  enabled: false,
+  warnings: []
+};
+function collectGitChurn(rootInput, files, options = {}) {
+  if (options.enabled === false || files.length === 0) {
+    return { ...EMPTY, metrics: /* @__PURE__ */ new Map() };
+  }
+  const root = realPath(rootInput);
+  const maxBuffer = options.maxBuffer ?? DEFAULT_MAX_BUFFER;
+  const warnings = [];
+  const topLevel = runGit(root, ["rev-parse", "--show-toplevel"], maxBuffer);
+  if (!topLevel.ok) {
+    return {
+      ...EMPTY,
+      metrics: /* @__PURE__ */ new Map(),
+      warnings: [`no hay historial git utilizable: ${topLevel.error}`]
+    };
+  }
+  const repoRoot = realPath(topLevel.stdout.trim());
+  const shallowResult = runGit(
+    repoRoot,
+    ["rev-parse", "--is-shallow-repository"],
+    maxBuffer
+  );
+  const shallow = shallowResult.ok && shallowResult.stdout.trim().toLowerCase() === "true";
+  if (shallow) {
+    warnings.push(
+      "el repositorio es shallow: el churn puede estar incompleto"
+    );
+  }
+  const log = runGit(
+    repoRoot,
+    [
+      "-c",
+      "core.quotePath=false",
+      "log",
+      "--no-merges",
+      "--numstat",
+      `--format=${COMMIT_PREFIX}%H%x09%ae`
+    ],
+    maxBuffer
+  );
+  if (!log.ok) {
+    return {
+      ...EMPTY,
+      shallow,
+      warnings: [...warnings, `no se pudo leer git log: ${log.error}`]
+    };
+  }
+  const wanted = new Set(files);
+  const commitsByFile = /* @__PURE__ */ new Map();
+  const authorsByFile = /* @__PURE__ */ new Map();
+  const authors = /* @__PURE__ */ new Set();
+  let commits = 0;
+  let currentAuthor = "";
+  let touched = /* @__PURE__ */ new Set();
+  const flushCommit = () => {
+    if (!currentAuthor || touched.size === 0) return;
+    commits++;
+    authors.add(currentAuthor);
+    for (const file of touched) {
+      commitsByFile.set(file, (commitsByFile.get(file) ?? 0) + 1);
+      let fileAuthors = authorsByFile.get(file);
+      if (!fileAuthors) {
+        fileAuthors = /* @__PURE__ */ new Set();
+        authorsByFile.set(file, fileAuthors);
+      }
+      fileAuthors.add(currentAuthor);
+    }
+    touched = /* @__PURE__ */ new Set();
+    currentAuthor = "";
+  };
+  for (const rawLine of log.stdout.split(/\r?\n/)) {
+    if (rawLine.startsWith(COMMIT_PREFIX)) {
+      flushCommit();
+      const fields2 = rawLine.slice(COMMIT_PREFIX.length).split("	");
+      const author = fields2[1]?.trim() ?? "";
+      currentAuthor = author || "(sin autor)";
+      continue;
+    }
+    if (!currentAuthor || rawLine === "") continue;
+    const fields = rawLine.split("	");
+    if (fields.length < 3) continue;
+    const gitPath = fields.slice(2).join("	");
+    if (!gitPath) continue;
+    const relative2 = path.relative(root, path.resolve(repoRoot, gitPath));
+    if (relative2 === "" || relative2 === ".." || relative2.startsWith(`..${path.sep}`) || path.isAbsolute(relative2)) {
+      continue;
+    }
+    const normalized = relative2.split(path.sep).join("/");
+    if (!wanted.has(normalized)) continue;
+    touched.add(normalized);
+  }
+  flushCommit();
+  const metrics = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    metrics.set(file, {
+      commits: commitsByFile.get(file) ?? 0,
+      authors: authorsByFile.get(file)?.size ?? 0
+    });
+  }
+  return {
+    metrics,
+    commits,
+    authors: authors.size,
+    shallow,
+    enabled: true,
+    warnings
+  };
+}
+function realPath(input) {
+  const resolved = path.resolve(input);
+  try {
+    return fs.realpathSync.native(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function runGit(cwd, args, maxBuffer) {
+  const result = spawnSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    maxBuffer,
+    windowsHide: true
+  });
+  if (result.error) {
+    return { ok: false, stdout: "", error: result.error.message };
+  }
+  if (result.status !== 0) {
+    return {
+      ok: false,
+      stdout: result.stdout ?? "",
+      error: (result.stderr ?? "").trim() || `git exited with ${result.status}`
+    };
+  }
+  return { ok: true, stdout: result.stdout ?? "", error: "" };
+}
+
+// packages/parsers/src/node-fs.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+var NodeFileSystem = class {
+  caseSensitive = process.platform !== "win32";
+  root;
+  constructor(root) {
+    this.root = path2.resolve(root);
+  }
+  readFile(target) {
+    return fs2.readFileSync(this.native(target), "utf8");
+  }
+  tryReadFile(target) {
+    try {
+      return fs2.readFileSync(this.native(target), "utf8");
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+      return null;
+    }
+  }
+  readDirectory(target) {
+    const entries = fs2.readdirSync(this.native(target), { withFileTypes: true });
+    return entries.map((entry) => ({
+      name: entry.name,
+      isDirectory: entry.isDirectory(),
+      isFile: entry.isFile()
+    }));
+  }
+  exists(target) {
+    return fs2.existsSync(this.native(target));
+  }
+  /** Ruta real en disco de una ruta virtual. */
+  native(target) {
+    const relative2 = target.replace(/^\/+/, "");
+    return relative2 === "" ? this.root : path2.join(this.root, relative2);
+  }
+};
+
+// packages/parsers/src/analyze.ts
+function analyzeRepository(rootInput, options = {}) {
+  const fileSystem = options.fileSystem ?? new NodeFileSystem(rootInput);
+  const useGit = options.git !== false;
+  const result = analyzeFiles({
+    fileSystem,
+    root: options.root ?? "/",
+    projectName: options.projectName,
+    fallbackName: basename2(rootInput),
+    ignore: options.ignore,
+    extensions: options.extensions,
+    parser: new TypeScriptParser(),
+    churn: (relativePaths) => {
+      const git = collectGitChurn(rootInput, relativePaths, { enabled: useGit });
+      return {
+        metrics: git.metrics,
+        warnings: git.warnings,
+        enabled: git.enabled,
+        commits: git.commits,
+        authors: git.authors,
+        shallow: git.shallow
+      };
+    }
+  });
+  const churn = result.churn;
+  return {
+    ...result,
+    git: {
+      enabled: churn?.enabled ?? false,
+      commits: churn?.commits ?? 0,
+      authors: churn?.authors ?? 0,
+      shallow: churn?.shallow ?? false
+    }
+  };
 }
 
 // packages/metrics/src/risk.ts
@@ -2541,8 +3250,8 @@ function hashString(value) {
   }
   return hash >>> 0;
 }
-function sectionForPath(path9) {
-  const folders = path9.split("/").filter(Boolean).slice(0, -1);
+function sectionForPath(path7) {
+  const folders = path7.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("/");
@@ -2612,7 +3321,7 @@ function buildRenderModel(cc, options = {}) {
   const fileIndexById = /* @__PURE__ */ new Map();
   walkFiles(cc.files, (entry) => {
     const fullPath = entry.path;
-    const path9 = prefix && fullPath.startsWith(prefix) ? fullPath.slice(prefix.length) : fullPath;
+    const path7 = prefix && fullPath.startsWith(prefix) ? fullPath.slice(prefix.length) : fullPath;
     const values = attributes[entry.node.id];
     const rawArea = valueOf(values, areaMetric);
     const index = files.length;
@@ -2620,7 +3329,7 @@ function buildRenderModel(cc, options = {}) {
     files.push({
       index,
       nodeId: entry.node.id,
-      path: path9,
+      path: path7,
       name: entry.node.name,
       section: -1,
       area: Math.max(1, rawArea ?? 0),
@@ -2783,7 +3492,7 @@ function buildRenderModel(cc, options = {}) {
   };
 }
 function buildRoots(cc, singleRoot, fileIndexById, files) {
-  const build = (node, path9) => {
+  const build = (node, path7) => {
     if (node.type === "File") {
       const index = fileIndexById.get(node.id);
       const file = index === void 0 ? void 0 : files[index];
@@ -2791,7 +3500,7 @@ function buildRoots(cc, singleRoot, fileIndexById, files) {
         kind: "file",
         key: `f:${index ?? -1}`,
         name: node.name,
-        path: path9,
+        path: path7,
         value: file?.area ?? 1,
         fileCount: 1,
         section: file?.section ?? 0,
@@ -2799,13 +3508,13 @@ function buildRoots(cc, singleRoot, fileIndexById, files) {
       };
     }
     const children = (node.children ?? []).map(
-      (child) => build(child, path9 ? `${path9}/${child.name}` : child.name)
+      (child) => build(child, path7 ? `${path7}/${child.name}` : child.name)
     );
     const folder = {
       kind: "folder",
-      key: `d:${path9}`,
+      key: `d:${path7}`,
       name: node.name,
-      path: path9,
+      path: path7,
       value: children.reduce((sum, child) => sum + child.value, 0) || 1,
       fileCount: children.reduce((sum, child) => sum + child.fileCount, 0),
       section: -1,
@@ -3449,10 +4158,10 @@ function renderHtml(model) {
 }
 
 // apps/cli/src/io.ts
-import fs5 from "node:fs";
+import fs3 from "node:fs";
 import zlib from "node:zlib";
 function readJsonFile2(file) {
-  const buffer = fs5.readFileSync(file);
+  const buffer = fs3.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");
@@ -3500,14 +4209,14 @@ function runAnalyze(options) {
     }
     throw error;
   }
-  const outDirectory = path5.resolve(
-    options.out ?? path5.join(path5.resolve(root), ".codarch")
+  const outDirectory = path3.resolve(
+    options.out ?? path3.join(path3.resolve(root), ".codarch")
   );
-  const snapshotPath = path5.join(outDirectory, "snapshot.cc.json");
-  const mapPath = path5.join(outDirectory, "map.html");
+  const snapshotPath = path3.join(outDirectory, "snapshot.cc.json");
+  const mapPath = path3.join(outDirectory, "map.html");
   try {
-    fs6.mkdirSync(outDirectory, { recursive: true });
-    fs6.writeFileSync(
+    fs4.mkdirSync(outDirectory, { recursive: true });
+    fs4.writeFileSync(
       snapshotPath,
       `${JSON.stringify(cc, null, 2)}
 `,
@@ -3529,7 +4238,7 @@ function runAnalyze(options) {
         title: options.title
       });
       const html = renderHtml(model);
-      fs6.writeFileSync(mapPath, html, "utf8");
+      fs4.writeFileSync(mapPath, html, "utf8");
       mapBytes = Buffer.byteLength(html, "utf8");
     } catch (error) {
       mapError = error instanceof RenderError ? error.message : error.message;
@@ -3538,14 +4247,14 @@ function runAnalyze(options) {
     mapError = "no hay ficheros TypeScript/JavaScript que dibujar";
   }
   const snapshotBytes = Buffer.byteLength(
-    fs6.readFileSync(snapshotPath),
+    fs4.readFileSync(snapshotPath),
     "utf8"
   );
   const lines = [];
   lines.push("");
   lines.push("  CodArch \xB7 an\xE1lisis");
   lines.push("");
-  lines.push(field("ra\xEDz", path5.resolve(root)));
+  lines.push(field("ra\xEDz", path3.resolve(root)));
   lines.push(field("snapshot", `${snapshotPath} (${formatBytes(snapshotBytes)})`));
   if (mapError) {
     lines.push(field("mapa", `omitido (${mapError})`));
@@ -3615,11 +4324,11 @@ function runAnalyze(options) {
 }
 
 // apps/cli/src/commands/diff.ts
-import fs8 from "node:fs";
-import path6 from "node:path";
+import fs6 from "node:fs";
+import path4 from "node:path";
 
 // packages/metrics/src/config.ts
-import fs7 from "node:fs";
+import fs5 from "node:fs";
 import { parse as parseYaml } from "yaml";
 var ConfigError = class extends Error {
   constructor(message) {
@@ -3641,7 +4350,7 @@ function parseRuleConfig(input) {
 function loadRuleConfig(file) {
   let text;
   try {
-    text = fs7.readFileSync(file, "utf8");
+    text = fs5.readFileSync(file, "utf8");
   } catch (error) {
     throw new ConfigError(
       `no se pudo leer ${file}: ${error.message}`
@@ -3771,29 +4480,29 @@ function parseRules(value, layerNames) {
   });
   return rules;
 }
-function parseSeverity(value, path9) {
+function parseSeverity(value, path7) {
   if (value === void 0) return "error";
   if (typeof value !== "string" || !SEVERITIES.has(value)) {
-    throw new ConfigError(`${path9} debe ser info, warn o error`);
+    throw new ConfigError(`${path7} debe ser info, warn o error`);
   }
   return value;
 }
-function optionalNumber(value, path9) {
+function optionalNumber(value, path7) {
   if (value === void 0) return void 0;
   if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw new ConfigError(`${path9} debe ser un n\xFAmero`);
+    throw new ConfigError(`${path7} debe ser un n\xFAmero`);
   }
   return value;
 }
-function asObject(value, path9) {
+function asObject(value, path7) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new ConfigError(`${path9} debe ser un objeto`);
+    throw new ConfigError(`${path7} debe ser un objeto`);
   }
   return value;
 }
-function asString(value, path9) {
+function asString(value, path7) {
   if (typeof value !== "string" || value.trim() === "") {
-    throw new ConfigError(`${path9} debe ser un texto no vac\xEDo`);
+    throw new ConfigError(`${path7} debe ser un texto no vac\xEDo`);
   }
   return value.trim();
 }
@@ -4059,11 +4768,11 @@ function summarize(index) {
 }
 function difference(present, absent) {
   const files = [];
-  for (const [id, path9] of present.paths) {
+  for (const [id, path7] of present.paths) {
     if (absent.paths.has(id)) continue;
     files.push({
       id,
-      path: path9,
+      path: path7,
       metrics: sortedMetrics(present.metrics[id])
     });
   }
@@ -4071,7 +4780,7 @@ function difference(present, absent) {
 }
 function changedFiles(base, head) {
   const changed = [];
-  for (const [id, path9] of head.paths) {
+  for (const [id, path7] of head.paths) {
     if (!base.paths.has(id)) continue;
     const baseValues = base.metrics[id] ?? {};
     const headValues = head.metrics[id] ?? {};
@@ -4091,7 +4800,7 @@ function changedFiles(base, head) {
         delta: baseValue !== null && headValue !== null ? headValue - baseValue : null
       });
     }
-    if (changes.length > 0) changed.push({ id, path: path9, changes });
+    if (changes.length > 0) changed.push({ id, path: path7, changes });
   }
   return changed.sort(compareChangedFiles);
 }
@@ -4348,13 +5057,13 @@ function runDiff(options) {
     console.error(`no se pudo comparar: ${error.message}`);
     return 1;
   }
-  const outPath = path6.resolve(options.out ?? "report.json");
+  const outPath = path4.resolve(options.out ?? "report.json");
   let reportBytes = 0;
   try {
-    fs8.mkdirSync(path6.dirname(outPath), { recursive: true });
+    fs6.mkdirSync(path4.dirname(outPath), { recursive: true });
     const text = `${JSON.stringify(report, null, 2)}
 `;
-    fs8.writeFileSync(outPath, text, "utf8");
+    fs6.writeFileSync(outPath, text, "utf8");
     reportBytes = Buffer.byteLength(text, "utf8");
   } catch (error) {
     console.error(
@@ -4490,7 +5199,7 @@ function loadSnapshot(file) {
 }
 function defaultConfigPath() {
   for (const file of [".codarch.yml", ".codarch.yaml"]) {
-    if (fs8.existsSync(file)) return file;
+    if (fs6.existsSync(file)) return file;
   }
   return void 0;
 }
@@ -4542,7 +5251,7 @@ function runInspect(options) {
   const metric = options.metric ?? defaultMetric(stats);
   const top = metric ? topByMetric(cc, metric, options.top) : [];
   const rootPrefix = cc.files.length === 1 ? `${cc.files[0]?.name}/` : "";
-  const displayPath = (path9) => rootPrefix && path9.startsWith(rootPrefix) ? path9.slice(rootPrefix.length) : path9;
+  const displayPath = (path7) => rootPrefix && path7.startsWith(rootPrefix) ? path7.slice(rootPrefix.length) : path7;
   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;
@@ -4621,8 +5330,8 @@ function runInspect(options) {
 }
 
 // apps/cli/src/commands/render.ts
-import fs9 from "node:fs";
-import path7 from "node:path";
+import fs7 from "node:fs";
+import path5 from "node:path";
 function defaultOutputPath(input) {
   const lower = input.toLowerCase();
   const suffixes = [".cc.json.gz", ".cc.json", ".json.gz", ".json", ".gz"];
@@ -4632,7 +5341,7 @@ function defaultOutputPath(input) {
   return `${input}.html`;
 }
 function defaultProjectName(input) {
-  let name = path7.basename(input.replace(/\\/g, "/"));
+  let name = path5.basename(input.replace(/\\/g, "/"));
   const lower = name.toLowerCase();
   const suffixes = [".cc.json.gz", ".cc.json", ".json.gz", ".json", ".gz"];
   for (const suffix of suffixes) {
@@ -4699,8 +5408,8 @@ function runRender(options) {
   const elapsed = Date.now() - started;
   const out = options.out ?? defaultOutputPath(options.file);
   try {
-    fs9.mkdirSync(path7.dirname(path7.resolve(out)), { recursive: true });
-    fs9.writeFileSync(out, html, "utf8");
+    fs7.mkdirSync(path5.dirname(path5.resolve(out)), { recursive: true });
+    fs7.writeFileSync(out, html, "utf8");
   } catch (error) {
     console.error(`no se pudo escribir ${out}: ${error.message}`);
     return 1;
@@ -4741,9 +5450,9 @@ function runRender(options) {
 }
 
 // apps/cli/src/commands/serve.ts
-import fs10 from "node:fs";
+import fs8 from "node:fs";
 import http from "node:http";
-import path8 from "node:path";
+import path6 from "node:path";
 import { fileURLToPath } from "node:url";
 var MIME = {
   ".html": "text/html; charset=utf-8",
@@ -4769,7 +5478,7 @@ var IGNORED_BROWSE = /* @__PURE__ */ new Set([
   "target"
 ]);
 function runServe(options) {
-  const root = path8.resolve(options.root ?? ".");
+  const root = path6.resolve(options.root ?? ".");
   const webRoot = options.web === false ? null : findWebRoot();
   if (options.web !== false && !webRoot) {
     console.error(
@@ -4784,10 +5493,10 @@ function runServe(options) {
   const startWatcher = () => {
     if (watcher) return null;
     try {
-      watcher = fs10.watch(state.root, { recursive: true }, (_event, filename) => {
+      watcher = fs8.watch(state.root, { recursive: true }, (_event, filename) => {
         if (!filename) return;
-        const relative = filename.toString().replace(/\\/g, "/");
-        if (IGNORED_WATCH.test(relative)) return;
+        const relative2 = filename.toString().replace(/\\/g, "/");
+        if (IGNORED_WATCH.test(relative2)) return;
         scheduleRefresh();
       });
       return null;
@@ -4847,8 +5556,8 @@ function runServe(options) {
     broadcast(clients, "watch", { watch: state.watch });
   };
   const switchRoot = (nextRoot) => {
-    const resolved = path8.resolve(nextRoot);
-    const stat = fs10.statSync(resolved);
+    const resolved = path6.resolve(nextRoot);
+    const stat = fs8.statSync(resolved);
     if (!stat.isDirectory()) throw new Error("la ruta no es un directorio");
     const next = analyzeState(resolved, state.watch);
     stopWatcher();
@@ -4870,7 +5579,7 @@ function runServe(options) {
     return state;
   };
   const meta = () => ({
-    root: path8.basename(state.root),
+    root: path6.basename(state.root),
     rootPath: state.root,
     watch: state.watch,
     files: state.files,
@@ -5034,15 +5743,15 @@ function analyzeState(root, watch) {
   };
 }
 function browseDirectories(root, requested) {
-  const target = requested?.trim() ? path8.resolve(requested) : root;
-  const stat = fs10.statSync(target);
+  const target = requested?.trim() ? path6.resolve(requested) : root;
+  const stat = fs8.statSync(target);
   if (!stat.isDirectory()) throw new Error("la ruta no es un directorio");
-  const entries = fs10.readdirSync(target, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !IGNORED_BROWSE.has(entry.name)).sort((left, right) => left.name.localeCompare(right.name)).slice(0, 500).map((entry) => ({
+  const entries = fs8.readdirSync(target, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !IGNORED_BROWSE.has(entry.name)).sort((left, right) => left.name.localeCompare(right.name)).slice(0, 500).map((entry) => ({
     name: entry.name,
-    path: path8.join(target, entry.name),
+    path: path6.join(target, entry.name),
     kind: "directory"
   }));
-  const parent = path8.dirname(target);
+  const parent = path6.dirname(target);
   return {
     path: target,
     parent: parent === target ? null : parent,
@@ -5078,9 +5787,9 @@ function originAllowed(request, options) {
 function findWebRoot() {
   const candidates = [
     fileURLToPath(new URL("./web", import.meta.url)),
-    path8.resolve(process.cwd(), "apps", "web", "dist"),
-    path8.resolve(
-      path8.dirname(fileURLToPath(import.meta.url)),
+    path6.resolve(process.cwd(), "apps", "web", "dist"),
+    path6.resolve(
+      path6.dirname(fileURLToPath(import.meta.url)),
       "..",
       "..",
       "..",
@@ -5089,14 +5798,14 @@ function findWebRoot() {
     )
   ];
   for (const candidate of candidates) {
-    if (fs10.existsSync(path8.join(candidate, "index.html"))) return candidate;
+    if (fs8.existsSync(path6.join(candidate, "index.html"))) return candidate;
   }
   return null;
 }
 function readReport(root) {
-  const file = path8.join(root, ".codarch", "report.json");
+  const file = path6.join(root, ".codarch", "report.json");
   try {
-    return JSON.parse(fs10.readFileSync(file, "utf8"));
+    return JSON.parse(fs8.readFileSync(file, "utf8"));
   } catch (error) {
     if (error.code !== "ENOENT") {
       console.error(`no se pudo leer ${file}: ${error.message}`);
@@ -5113,17 +5822,17 @@ function serveStatic(webRoot, pathname, headOnly, response) {
     response.end();
     return;
   }
-  const relative = decoded === "/" ? "index.html" : decoded.replace(/^\/+/, "");
-  let file = path8.resolve(webRoot, relative);
-  if (!isWithin2(webRoot, file) || !fs10.existsSync(file) || !fs10.statSync(file).isFile()) {
-    file = path8.join(webRoot, "index.html");
+  const relative2 = decoded === "/" ? "index.html" : decoded.replace(/^\/+/, "");
+  let file = path6.resolve(webRoot, relative2);
+  if (!isWithin2(webRoot, file) || !fs8.existsSync(file) || !fs8.statSync(file).isFile()) {
+    file = path6.join(webRoot, "index.html");
   }
   try {
-    const body = fs10.readFileSync(file);
+    const body = fs8.readFileSync(file);
     response.writeHead(200, {
-      "Content-Type": MIME[path8.extname(file).toLowerCase()] ?? "application/octet-stream",
+      "Content-Type": MIME[path6.extname(file).toLowerCase()] ?? "application/octet-stream",
       "Content-Length": body.length,
-      "Cache-Control": file.includes(`${path8.sep}assets${path8.sep}`) ? "public, max-age=31536000, immutable" : "no-store",
+      "Cache-Control": file.includes(`${path6.sep}assets${path6.sep}`) ? "public, max-age=31536000, immutable" : "no-store",
       "X-Content-Type-Options": "nosniff"
     });
     if (headOnly) response.end();
@@ -5134,8 +5843,8 @@ function serveStatic(webRoot, pathname, headOnly, response) {
   }
 }
 function isWithin2(root, candidate) {
-  const relative = path8.relative(root, candidate);
-  return relative === "" || !relative.startsWith("..") && !path8.isAbsolute(relative);
+  const relative2 = path6.relative(root, candidate);
+  return relative2 === "" || !relative2.startsWith("..") && !path6.isAbsolute(relative2);
 }
 function sendJson(response, value) {
   const body = `${JSON.stringify(value)}
@@ -5173,7 +5882,7 @@ data: ${JSON.stringify(data)}
 }
 
 // apps/cli/src/index.ts
-var VERSION = true ? "0.1.3" : "0.0.0";
+var VERSION = true ? "0.1.4" : "0.0.0";
 var USAGE = `
 CodArch \xB7 mapa vivo de la arquitectura de tu software