@fraczak/k 6.0.0 → 6.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraczak/k",
-    "version": "6.0.0",
+    "version": "6.0.2",
     "description": "k — a language for composing first-order partial functions over algebraic data types (products and tagged unions); includes runtime, type derivation, REPL, and codec toolchain",
     "main": "index.mjs",
     "scripts": {
@@ -10,22 +10,19 @@
     },
     "repository": {
         "type": "git",
-        "url": "git+https://github.com/fraczak/k.git"
-    },
-    "publishConfig": {
-        "access": "public"
+        "url": "https://github.com/fraczak/k.git"
     },
     "author": "Wojciech Fraczak",
     "license": "ISC",
     "bin": {
-        "k": "k.mjs",
-        "k-compile-object": "objects/compile.mjs",
-        "k-decompile-object": "objects/decompile.mjs",
-        "k-parse": "codecs/k-parse.mjs",
-        "k-pattern": "codecs/k-pattern.mjs",
-        "k-print": "codecs/k-print.mjs",
-        "k-repl": "repl2.mjs",
-        "k-repl2": "repl2.mjs"
+        "k": "./k.mjs",
+        "k-compile-object": "./objects/compile.mjs",
+        "k-decompile-object": "./objects/decompile.mjs",
+        "k-parse": "./codecs/k-parse.mjs",
+        "k-pattern": "./patterns/from-k.mjs",
+        "k-print": "./codecs/k-print.mjs",
+        "k-repl": "./repl2.mjs",
+        "k-repl2": "./repl2.mjs"
     },
     "devDependencies": {
         "jiwson": "^0.1.2"

package/{codecs/k-pattern.mjs → patterns/from-k.mjs}

@@ -3,14 +3,14 @@
 import fs from "node:fs";
 import { argv, exit, stdin, stdout } from "node:process";
 import k from "../index.mjs";
-import { exportPatternGraph } from "./runtime/codec.mjs";
-import { patternToPropertyList } from "./runtime/pattern-json.mjs";
+import { exportPatternGraph } from "../codecs/runtime/codec.mjs";
+import { patternToPropertyList } from "../codecs/runtime/pattern-json.mjs";
 
 function usage(prog) {
   console.error(`Usage: ${prog} [script-or-file]`);
   console.error("  Read a k script from a file argument or stdin.");
   console.error("  The main expression must be a filter or a type name.");
-  console.error("  Output is the canonical JSON pattern array.");
+  console.error("  Output is the canonical property-list pattern array.");
   console.error("  Example:");
   console.error(`    cat pattern.k | ${prog}`);
   console.error(`    ${prog} '$ bits = < {} _, bits 0, bits 1 >; ?< {} nil, { $bits car, X cdr } cons > = X'`);

package/repl2.mjs

@@ -28,10 +28,10 @@ const TYPE_DEF_RE = /^\s*\$\s*([a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*)\s*=/;
 const REL_DEF_RE = /^\s*([a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*)\s*=/;
 const COMMAND_NAMES = [
   "help", "type", "code", "rel", "def", "run", "eval", "t", "d", "C",
-  "codes", "rels", "val", "reset", "save", "klib", "ko", "export", "load",
+  "codes", "rels", "val", "reset", "klib", "ko", "load",
   "quit", "exit"
 ];
-const PATH_COMMANDS = new Set(["save", "klib", "ko", "export", "load"]);
+const PATH_COMMANDS = new Set(["klib", "ko", "load"]);
 const initialCodes = codes.dump();
 
 function cloneJSON(value) {
@@ -88,12 +88,49 @@ function aliasPreamble(state, omitName = null) {
   return lines.filter(Boolean).join("\n");
 }
 
+function preambleLineCount(preamble) {
+  if (!preamble) return 0;
+  return preamble.split("\n").length;
+}
+
+function remapLineNumber(line, offset) {
+  return Math.max(1, line - offset);
+}
+
+function remapDiagnosticMessage(message, lineOffset) {
+  if (!lineOffset) return message;
+
+  let rewritten = message.replace(
+    /\(lines (\d+):(\d+)\.\.\.(\d+):(\d+)\)/g,
+    (_, startLine, startCol, endLine, endCol) =>
+      `(lines ${remapLineNumber(Number(startLine), lineOffset)}:${startCol}...${remapLineNumber(Number(endLine), lineOffset)}:${endCol})`
+  );
+
+  rewritten = rewritten.replace(
+    /Parse error on line (\d+):/g,
+    (_, line) => `Parse error on line ${remapLineNumber(Number(line), lineOffset)}:`
+  );
+
+  return rewritten;
+}
+
+function remapError(error, lineOffset) {
+  if (!lineOffset || !error?.message) return error;
+  const remapped = new Error(remapDiagnosticMessage(error.message, lineOffset));
+  remapped.name = error.name;
+  if (error.stack) {
+    remapped.stack = error.stack.replace(error.message, remapped.message);
+  }
+  if ("cause" in error) remapped.cause = error.cause;
+  return remapped;
+}
+
 function compileWithOptionalIdentity(source, options) {
   try {
     return hydrateObject(compileLibrary(source, options));
   } catch (error) {
     if (!/got 'EOF'|Expecting/.test(error.message)) throw error;
-    return hydrateObject(compileLibrary(`${source}\n()`, options));
+    return hydrateObject(compileLibrary(`${ensureSemicolon(source)}\n()`, options));
   }
 }
 
@@ -102,7 +139,7 @@ function annotateWithOptionalIdentity(source, options) {
     return annotate(source, options);
   } catch (error) {
     if (!/got 'EOF'|Expecting/.test(error.message)) throw error;
-    return annotate(`${source}\n()`, options);
+    return annotate(`${ensureSemicolon(source)}\n()`, options);
   }
 }
 
@@ -183,15 +220,18 @@ function savedLibrary(state) {
 function executableObject(state, mainExpression) {
   const main = (mainExpression || state.lastMain || "").trim();
   if (!main) {
-    throw new Error(":ko requires a main expression unless one has already been evaluated or defined");
+    throw new Error(":ko file expr requires a main expression unless one has already been evaluated or defined");
   }
 
   restoreCodes(state);
+  const preamble = aliasPreamble(state);
   try {
-    return compileObject([aliasPreamble(state), main].filter(Boolean).join("\n"), {
+    return compileObject([preamble, main].filter(Boolean).join("\n"), {
       source: "<repl>",
       libraries: [stateLibrary(state)]
     });
+  } catch (error) {
+    throw remapError(error, preambleLineCount(preamble));
   } finally {
     restoreCodes(state);
   }
@@ -272,6 +312,13 @@ function canonicalNames(state) {
   ])].filter((name) => name.startsWith("@")).sort();
 }
 
+function aliasNames(state) {
+  return [...new Set([
+    ...Object.keys(state.typeAliases),
+    ...Object.keys(state.relAliases)
+  ])].sort();
+}
+
 function expandHome(input) {
   if (input === "~") return os.homedir();
   if (input.startsWith("~/")) return path.join(os.homedir(), input.slice(2));
@@ -303,6 +350,19 @@ function completeCanonical(line, state) {
   return [matches, line];
 }
 
+function completeIdentifier(line, state) {
+  const match = line.match(/^(.*?)(\$?[A-Za-z0-9_+-][A-Za-z0-9_?!+-]*)$/);
+  if (!match) return [[], line];
+  const [, prefix, partial] = match;
+  const isTypeToken = partial.startsWith("$");
+  const barePartial = isTypeToken ? partial.slice(1) : partial;
+  const names = isTypeToken ? Object.keys(state.typeAliases).sort() : aliasNames(state);
+  const matches = names
+    .filter((name) => name.startsWith(barePartial))
+    .map((name) => `${prefix}${isTypeToken ? "$" : ""}${name}`);
+  return [matches, line];
+}
+
 function completePath(line, tokenStart) {
   const token = line.slice(tokenStart);
   const quote = token[0] === "\"" || token[0] === "'" ? token[0] : "";
@@ -359,6 +419,10 @@ function completeCommandArgument(line, state) {
     return completeCanonical(line, state);
   }
 
+  if (/\$?[A-Za-z0-9_+-][A-Za-z0-9_?!+-]*$/.test(line)) {
+    return completeIdentifier(line, state);
+  }
+
   return [[], line];
 }
 
@@ -369,6 +433,9 @@ function completeInput(line, state) {
   if (/@[A-Za-z0-9_?!+-]*$/.test(line)) {
     return completeCanonical(line, state);
   }
+  if (/\$?[A-Za-z0-9_+-][A-Za-z0-9_?!+-]*$/.test(line)) {
+    return completeIdentifier(line, state);
+  }
   return [[], line];
 }
 
@@ -376,10 +443,89 @@ function createCompleter(state) {
   return (line) => completeInput(line, state);
 }
 
+function isMainEntrypoint(entryArg = argv[1]) {
+  if (!entryArg) return false;
+  try {
+    return fs.realpathSync(entryArg) === fs.realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+}
+
 function ensureSemicolon(source) {
   return source.trim().endsWith(";") ? source : `${source};`;
 }
 
+function isEofParseError(error) {
+  return /got 'EOF'|Unexpected end of input/.test(error.message || "");
+}
+
+function lineForContinuation(line) {
+  return line.replace(/\\\s*$/, "");
+}
+
+function lineHasExplicitContinuation(line) {
+  return /\\\s*$/.test(line);
+}
+
+function lineTerminatesSnippet(line) {
+  return /;\s*$/.test(line);
+}
+
+function explicitSnippetTerminated(source) {
+  const lines = source.split("\n");
+  const lastLine = lines[lines.length - 1] || "";
+  return lineTerminatesSnippet(lastLine);
+}
+
+function analyzeRawSnippet(source) {
+  try {
+    const parsed = parse(source);
+    return { kind: "withMain", parsed };
+  } catch (error) {
+    if (!isEofParseError(error)) throw error;
+  }
+
+  return { kind: "incomplete", parsed: null };
+}
+
+function analyzeAcceptedSnippet(source, explicitTerminated = explicitSnippetTerminated(source)) {
+  try {
+    const parsed = parse(source);
+    return { kind: "withMain", parsed };
+  } catch (error) {
+    if (!explicitTerminated) {
+      if (isEofParseError(error)) return { kind: "incomplete", parsed: null };
+      throw error;
+    }
+  }
+
+  const parsed = parse(`${source}\n()`);
+  return { kind: "definitionsOnly", parsed };
+}
+
+function compileSnippetArtifacts(source, state, sourceName = "<repl>") {
+  restoreCodes(state);
+  const preamble = aliasPreamble(state);
+  const fullSource = [preamble, source].filter(Boolean).join("\n");
+  const options = {
+    source: sourceName,
+    libraries: [stateLibrary(state)]
+  };
+  try {
+    const lib = compileWithOptionalIdentity(fullSource, options);
+    const { relAlias, meta } = libraryOriginsFromSource(source, fullSource, lib, options);
+    const annotated = annotateWithOptionalIdentity(fullSource, options);
+    return {
+      annotated,
+      lib: { ...lib, relAlias, meta },
+      lineOffset: preambleLineCount(preamble)
+    };
+  } catch (error) {
+    throw remapError(error, preambleLineCount(preamble));
+  }
+}
+
 async function defineType(input, state) {
   const typeMatch = input.match(TYPE_DEF_RE);
   if (!typeMatch) {
@@ -388,8 +534,14 @@ async function defineType(input, state) {
 
   const name = typeMatch[1];
   restoreCodes(state);
-  const source = [aliasPreamble(state, name), ensureSemicolon(input), "()"].filter(Boolean).join("\n");
-  const annotated = annotate(source, { libraries: [stateLibrary(state)] });
+  const preamble = aliasPreamble(state, name);
+  const source = [preamble, ensureSemicolon(input), "()"].filter(Boolean).join("\n");
+  let annotated;
+  try {
+    annotated = annotate(source, { libraries: [stateLibrary(state)] });
+  } catch (error) {
+    throw remapError(error, preambleLineCount(preamble));
+  }
   const hash = annotated.representatives[name];
   if (!hash) throw new Error(`Type definition did not produce an alias for '${name}'`);
   state.codes = codes.dump();
@@ -406,8 +558,14 @@ async function defineRelation(input, state) {
 
   const name = relMatch[1];
   restoreCodes(state);
-  const source = [aliasPreamble(state, name), ensureSemicolon(input), name].filter(Boolean).join("\n");
-  const lib = hydrateObject(compileLibrary(source, { source: "<repl>", libraries: [stateLibrary(state)] }));
+  const preamble = aliasPreamble(state, name);
+  const source = [preamble, ensureSemicolon(input), name].filter(Boolean).join("\n");
+  let lib;
+  try {
+    lib = hydrateObject(compileLibrary(source, { source: "<repl>", libraries: [stateLibrary(state)] }));
+  } catch (error) {
+    throw remapError(error, preambleLineCount(preamble));
+  }
   const hash = lib.relAlias?.[name];
   if (!hash || !lib.rels?.[hash]) throw new Error(`Relation definition did not produce an alias for '${name}'`);
   state.codes = codes.dump();
@@ -424,16 +582,52 @@ async function runExpression(input, state) {
   if (!expression) throw new Error(":run requires an expression");
 
   restoreCodes(state);
-  const source = [aliasPreamble(state), expression].filter(Boolean).join("\n");
-  const annotated = annotate(source, { libraries: [stateLibrary(state)] });
+  const preamble = aliasPreamble(state);
+  const source = [preamble, expression].filter(Boolean).join("\n");
+  let annotated;
+  try {
+    annotated = annotate(source, { libraries: [stateLibrary(state)] });
+  } catch (error) {
+    throw remapError(error, preambleLineCount(preamble));
+  }
   const mainRel = annotated.rels.__main__;
   run.defs = annotated;
-  state.value = run(codes.find, mainRel.def, state.value, mainRel.typePatternGraph);
+  try {
+    state.value = run(codes.find, mainRel.def, state.value, mainRel.typePatternGraph);
+  } catch (error) {
+    throw remapError(error, preambleLineCount(preamble));
+  }
   state.lastMain = expression;
   restoreCodes(state);
   return [printValue(state.value)];
 }
 
+async function runSnippet(input, state, options = {}) {
+  const snippet = input.trim();
+  if (!snippet) return [];
+
+  const explicitTerminated = options.explicitTerminated ?? explicitSnippetTerminated(input);
+  const analysis = analyzeAcceptedSnippet(snippet, explicitTerminated);
+  const { annotated, lib, lineOffset } = compileSnippetArtifacts(snippet, state);
+  mergeLibrary(state, lib, "<repl>");
+
+  if (analysis.kind === "definitionsOnly") {
+    restoreCodes(state);
+    return [];
+  }
+
+  const mainRel = annotated.rels.__main__;
+  run.defs = annotated;
+  try {
+    state.value = run(codes.find, mainRel.def, state.value, mainRel.typePatternGraph);
+  } catch (error) {
+    throw remapError(error, lineOffset);
+  }
+  state.lastMain = snippet;
+  restoreCodes(state);
+  return [printValue(state.value)];
+}
+
 async function evaluateInput(input, state) {
   const line = input.trim();
   if (line === "" || line.startsWith("#") || line.startsWith("//") || line.startsWith("--")) return [];
@@ -442,9 +636,7 @@ async function evaluateInput(input, state) {
     return evaluateCommand(line, state);
   }
 
-  if (input.match(TYPE_DEF_RE)) return defineType(input, state);
-  if (input.match(REL_DEF_RE)) return defineRelation(input, state);
-  return runExpression(input, state);
+  return runSnippet(input, state);
 }
 
 function parseCommand(line) {
@@ -494,37 +686,20 @@ async function evaluateCommand(line, state) {
       Object.assign(state, fresh);
       return ["reset"];
     }
-    case "save": {
-      if (!arg) throw new Error(`${usagePrefix}save requires a file path`);
-      fs.writeFileSync(arg, encodeLibrary(savedLibrary(state)));
-      return [`saved ${arg}`];
-    }
     case "klib": {
       if (!arg) throw new Error(`${usagePrefix}klib requires a file path`);
       fs.writeFileSync(arg, encodeLibrary(savedLibrary(state)));
       return [`saved ${arg}`];
     }
     case "ko": {
-      if (!arg) throw new Error(`${usagePrefix}ko requires a file path`);
-      const [path, ...mainParts] = arg.split(/\s+/);
-      const object = executableObject(state, mainParts.join(" "));
-      fs.writeFileSync(path, encodeObject(object));
-      const main = (mainParts.join(" ") || state.lastMain).trim();
-      return [`saved ${path} (${main})`];
-    }
-    case "export": {
-      if (!arg) throw new Error(`${usagePrefix}export requires a file path`);
+      if (!arg) throw new Error(`${usagePrefix}ko requires a file path and main expression`);
       const [path, ...mainParts] = arg.split(/\s+/);
-      if (path.endsWith(".klib")) {
-        fs.writeFileSync(path, encodeLibrary(savedLibrary(state)));
-        return [`saved ${path}`];
-      }
-      if (!path.endsWith(".ko")) {
-        throw new Error(":export writes .klib or .ko files; use :klib or :ko for explicit export");
+      if (mainParts.length === 0) {
+        throw new Error(":ko file expr requires a main expression");
       }
       const object = executableObject(state, mainParts.join(" "));
       fs.writeFileSync(path, encodeObject(object));
-      const main = (mainParts.join(" ") || state.lastMain).trim();
+      const main = mainParts.join(" ").trim();
       return [`saved ${path} (${main})`];
     }
     case "load": {
@@ -535,14 +710,19 @@ async function evaluateCommand(line, state) {
       } else {
         restoreCodes(state);
         const source = fs.readFileSync(arg, "utf8");
-        const fullSource = [aliasPreamble(state), source].filter(Boolean).join("\n");
+        const preamble = aliasPreamble(state);
+        const fullSource = [preamble, source].filter(Boolean).join("\n");
         const options = {
           source: arg,
           libraries: [stateLibrary(state)]
         };
-        const lib = compileWithOptionalIdentity(fullSource, options);
-        const { relAlias, meta } = libraryOriginsFromSource(source, fullSource, lib, options);
-        mergeLibrary(state, { ...lib, relAlias, meta }, arg);
+        try {
+          const lib = compileWithOptionalIdentity(fullSource, options);
+          const { relAlias, meta } = libraryOriginsFromSource(source, fullSource, lib, options);
+          mergeLibrary(state, { ...lib, relAlias, meta }, arg);
+        } catch (error) {
+          throw remapError(error, preambleLineCount(preamble));
+        }
       }
       return [`loaded ${arg}`];
     }
@@ -580,14 +760,15 @@ function helpText() {
     ":codes               list type aliases",
     ":rels                list relation aliases",
     ":load file           load .k source or .klib",
-    ":klib file           export state as .klib",
-    ":ko file [expr]      export executable .ko",
-    ":export file [expr]  export by extension: .klib or .ko",
+    ":klib file           export state as a library",
+    ":ko file expr        export executable .ko using expr as main",
     ":val                 print current value",
     ":reset               clear state",
     ":help                show this help",
     "",
-    "Raw k definitions and expressions are still accepted as shorthand."
+    "Raw k input is compiled as a snippet on top of the current state.",
+    "A line ending with ';' plus only spaces closes the snippet.",
+    "Use '\\' to force continuation."
   ].join("\n");
 }
 
@@ -606,19 +787,50 @@ function startRepl() {
   console.log("k interpreter (.klib-backed). Type :help for commands.");
   rl.prompt();
   async function handleLine(line) {
-    if (line.trim().endsWith("\\")) {
-      buffer.push(line.replace(/\\\s*$/, ""));
+    if (lineHasExplicitContinuation(line)) {
+      buffer.push(lineForContinuation(line));
       rl.setPrompt("  ");
       if (!closed) rl.prompt();
       return;
     }
 
-    const input = [...buffer, line].join("\n");
+    if (buffer.length === 0 && line.trim().startsWith(":")) {
+      rl.setPrompt("> ");
+      try {
+        for (const output of await evaluateInput(line, state)) {
+          console.log(output);
+        }
+      } catch (error) {
+        console.error(error.message || String(error));
+      }
+      if (!closed) rl.prompt();
+      return;
+    }
+
+    buffer.push(line);
+    const input = buffer.join("\n");
+    const explicitTerminated = lineTerminatesSnippet(line);
+    if (!explicitTerminated) {
+      try {
+        const analysis = analyzeRawSnippet(input);
+        if (analysis.kind !== "withMain") {
+          rl.setPrompt("  ");
+          if (!closed) rl.prompt();
+          return;
+        }
+      } catch (error) {
+        buffer.length = 0;
+        rl.setPrompt("> ");
+        console.error(error.message || String(error));
+        if (!closed) rl.prompt();
+        return;
+      }
+    }
+
     buffer.length = 0;
     rl.setPrompt("> ");
-
     try {
-      for (const output of await evaluateInput(input, state)) {
+      for (const output of await runSnippet(input, state, { explicitTerminated })) {
         console.log(output);
       }
     } catch (error) {
@@ -635,17 +847,24 @@ function startRepl() {
   });
 }
 
-if (argv[1] && fileURLToPath(import.meta.url) === argv[1]) {
+if (isMainEntrypoint()) {
   startRepl();
 }
 
 export {
+  aliasNames,
+  analyzeAcceptedSnippet,
+  analyzeRawSnippet,
   canonicalNames,
   completeInput,
   createCompleter,
   createState,
   evaluateInput,
+  explicitSnippetTerminated,
   helpText,
+  isMainEntrypoint,
+  lineHasExplicitContinuation,
+  lineTerminatesSnippet,
   printValue,
   propertyListToFilter,
   valueToK

package/scripts/generate-dependency-graph.mjs

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const root = path.resolve(__dirname, "..");
+const outPath = path.join(root, "DOCS", "dependency-graph.md");
+
+function getTrackedMjsFiles() {
+  const raw = execSync("git ls-files '*.mjs'", {
+    cwd: root,
+    encoding: "utf8"
+  });
+
+  const all = raw
+    .split("\n")
+    .map((s) => s.trim())
+    .filter(Boolean);
+
+  return all.filter((relPath) => {
+    if (relPath.startsWith("codecs/")) return true;
+    if (relPath.includes("/")) return false;
+    if (relPath.startsWith("test")) return false;
+    if (relPath.includes("-test")) return false;
+    return true;
+  });
+}
+
+function parseLocalImports(absPath) {
+  const source = fs.readFileSync(absPath, "utf8");
+  const regex = /^\s*import\s+[^;]*?from\s+["']([^"']+)["'];?\s*$/gm;
+  const imports = [];
+  let match;
+  while ((match = regex.exec(source)) !== null) {
+    const specifier = match[1];
+    if (specifier.startsWith("./") || specifier.startsWith("../")) {
+      imports.push(specifier);
+    }
+  }
+  return imports;
+}
+
+function toNodeId(relPath) {
+  return relPath.replace(/[^a-zA-Z0-9]/g, "_");
+}
+
+function makeBar(sizeKb) {
+  const units = Math.max(1, Math.min(20, Math.round(sizeKb)));
+  return "█".repeat(units);
+}
+
+function renderGraph(files, sizesKb, edges) {
+  const lines = [];
+  lines.push("# Project Dependency Graph");
+  lines.push("");
+  lines.push("_Auto-generated by scripts/generate-dependency-graph.mjs._");
+  lines.push("");
+  lines.push("```mermaid");
+  lines.push("graph TD");
+  lines.push("    classDef default fill:#fff,stroke:#333,stroke-width:2px,color:#000;");
+  lines.push("");
+
+  for (const relPath of files) {
+    const id = toNodeId(relPath);
+    const sizeKb = sizesKb[relPath];
+    const bar = makeBar(sizeKb);
+    lines.push(`    ${id}[\"${relPath} (${sizeKb.toFixed(1)} KB)<br/>${bar}\"]`);
+  }
+
+  if (edges.length > 0) {
+    lines.push("");
+  }
+
+  for (const { src, dst } of edges) {
+    lines.push(`    ${toNodeId(src)} --> ${toNodeId(dst)}`);
+  }
+
+  lines.push("```");
+  lines.push("");
+  return lines.join("\n");
+}
+
+function main() {
+  const files = getTrackedMjsFiles().sort();
+  const fileSet = new Set(files);
+
+  const sizesKb = {};
+  for (const relPath of files) {
+    const absPath = path.join(root, relPath);
+    const bytes = fs.statSync(absPath).size;
+    sizesKb[relPath] = bytes / 1024;
+  }
+
+  const edgeKeys = new Set();
+  const edges = [];
+  for (const relPath of files) {
+    const absPath = path.join(root, relPath);
+    const imports = parseLocalImports(absPath);
+
+    for (const specifier of imports) {
+      const resolved = path.normalize(path.join(path.dirname(relPath), specifier));
+      if (!resolved.endsWith(".mjs")) continue;
+      if (!fileSet.has(resolved)) continue;
+      const key = `${relPath}->${resolved}`;
+      if (edgeKeys.has(key)) continue;
+      edgeKeys.add(key);
+      edges.push({ src: relPath, dst: resolved });
+    }
+  }
+
+  const graph = renderGraph(files, sizesKb, edges);
+  fs.writeFileSync(outPath, graph, "utf8");
+  console.log(`Wrote ${path.relative(root, outPath)}`);
+  console.log(`Nodes: ${files.length}, Edges: ${edges.length}`);
+}
+
+main();