aem-eds-kit 0.4.7 → 0.4.9

package/dist/bin/eds.js

@@ -1424,15 +1424,451 @@ var init_init = __esm({
   }
 });
 
+// src/lib/migrate/clientlib.ts
+import { existsSync as existsSync5 } from "fs";
+import { readFile as readFile3, readdir } from "fs/promises";
+import path7 from "path";
+async function listFiles(dir) {
+  const out = [];
+  const walk3 = async (d) => {
+    for (const e of await readdir(d, { withFileTypes: true })) {
+      const p = path7.join(d, e.name);
+      if (e.isDirectory()) await walk3(p);
+      else out.push(p);
+    }
+  };
+  if (existsSync5(dir)) await walk3(dir);
+  return out;
+}
+async function findClientlibDir(componentDir) {
+  if (!existsSync5(componentDir)) return null;
+  const entries = await readdir(componentDir, { withFileTypes: true });
+  const match = entries.find((e) => e.isDirectory() && /clientlib/i.test(e.name));
+  if (match) return path7.join(componentDir, match.name);
+  const hasCss = entries.some((e) => e.isFile() && e.name.endsWith(".css"));
+  return hasCss ? componentDir : null;
+}
+async function readClientlibCss(clientlibDir) {
+  const all = await listFiles(clientlibDir);
+  const preprocessed = all.filter((f) => /\.(less|scss|sass)$/i.test(f)).map((f) => path7.relative(clientlibDir, f));
+  let cssFiles;
+  const cssTxt = path7.join(clientlibDir, "css.txt");
+  if (existsSync5(cssTxt)) {
+    const lines = (await readFile3(cssTxt, "utf-8")).split("\n").map((l) => l.trim());
+    let base = clientlibDir;
+    const listed = [];
+    for (const l of lines) {
+      if (!l) continue;
+      const baseMatch = l.match(/^#base\s*=\s*(.+)$/);
+      if (baseMatch) base = path7.join(clientlibDir, baseMatch[1].trim());
+      else if (!l.startsWith("#")) listed.push(l);
+    }
+    cssFiles = listed.map((rel) => path7.join(base, rel)).filter((f) => existsSync5(f) && f.endsWith(".css"));
+  } else {
+    cssFiles = all.filter((f) => f.endsWith(".css"));
+  }
+  const parts = [];
+  for (const f of cssFiles) parts.push(await readFile3(f, "utf-8"));
+  return {
+    css: parts.join("\n\n"),
+    files: cssFiles.map((f) => path7.relative(clientlibDir, f)),
+    preprocessed
+  };
+}
+var init_clientlib = __esm({
+  "src/lib/migrate/clientlib.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/lib/migrate/dialog.ts
+import { XMLParser } from "fast-xml-parser";
+function tagOf(n) {
+  return Object.keys(n).find((k) => k !== ":@") ?? "";
+}
+function childrenOf(n) {
+  const t = tagOf(n);
+  const v = n[t];
+  return Array.isArray(v) ? v : [];
+}
+function attrsOf(n) {
+  return n[":@"] ?? {};
+}
+function stripType(v) {
+  return typeof v === "string" ? v.replace(/^\{[^}]+\}/, "") : v;
+}
+function attr(n, name) {
+  return stripType(attrsOf(n)[`@_${name}`]);
+}
+function leafComponent(rt, n) {
+  const multiple = attr(n, "multiple") === "true" || attr(n, "multiple") === "{Boolean}true";
+  if (rt.endsWith("/form/textfield")) return "text";
+  if (rt.endsWith("/form/textarea")) return "textarea";
+  if (rt.includes("/richtext")) return "richtext";
+  if (rt.endsWith("/form/numberfield")) return "number";
+  if (rt.endsWith("/form/checkbox")) return "boolean";
+  if (rt.endsWith("/form/radiogroup")) return "radio-group";
+  if (rt.endsWith("/form/select")) return multiple ? "multiselect" : "select";
+  if (rt.endsWith("/form/datepicker")) return "date-time";
+  if (rt.endsWith("/form/pathfield") || rt.endsWith("/form/pathbrowser")) return "aem-content";
+  if (rt.includes("/fileupload") || rt.endsWith("/form/fileupload")) return "reference";
+  if (rt.includes("tagfield") || rt.includes("tagpicker") || rt.includes("tagbrowser"))
+    return "aem-tag";
+  if (rt.includes("contentfragment")) return "aem-content-fragment";
+  if (rt.includes("experiencefragment")) return "aem-experience-fragment";
+  return null;
+}
+function isWrapper(rt) {
+  return rt.includes("/foundation/container") || rt.includes("/foundation/fixedcolumns") || rt.includes("/foundation/well") || rt.includes("/foundation/tabs") || rt.includes("/foundation/form/fieldset") || rt.includes("/foundation/accordion");
+}
+function valueTypeFor(c) {
+  switch (c) {
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date-time":
+      return "date";
+    case "checkbox-group":
+      return "string[]";
+    case "aem-content":
+    case "aem-content-fragment":
+    case "aem-experience-fragment":
+      return void 0;
+    default:
+      return "string";
+  }
+}
+function cleanName(raw, fallback) {
+  const n = (raw ?? "").replace(/^\.\//, "").trim();
+  return n || fallback;
+}
+function readOptions(fieldNode) {
+  const items = childrenOf(fieldNode).find((c) => tagOf(c) === "items");
+  if (!items) return [];
+  return childrenOf(items).map((opt) => {
+    const value = attr(opt, "value") ?? "";
+    const name = attr(opt, "text") ?? attr(opt, "jcr:title") ?? value;
+    return { name, value };
+  });
+}
+function walk(nodes, out, unmapped, counter) {
+  for (const node of nodes) {
+    const rt = attr(node, "sling:resourceType") ?? "";
+    if (rt.endsWith("/foundation/tabs")) {
+      const items = childrenOf(node).find((c) => tagOf(c) === "items");
+      for (const tab of items ? childrenOf(items) : []) {
+        const label = attr(tab, "jcr:title");
+        out.push({ component: "tab", name: cleanName(void 0, tagOf(tab)), label });
+        walk(childrenOf(tab), out, unmapped, counter);
+      }
+      continue;
+    }
+    if (rt.endsWith("/form/multifield")) {
+      const sub = [];
+      walk(childrenOf(node), sub, unmapped, counter);
+      const name = cleanName(attr(node, "name"), `items${counter.i++}`);
+      out.push({
+        component: "container",
+        name,
+        label: attr(node, "fieldLabel") ?? "Items",
+        multi: true,
+        collapsible: true,
+        fields: sub
+      });
+      continue;
+    }
+    const comp = rt ? leafComponent(rt, node) : null;
+    if (comp) {
+      const name = cleanName(attr(node, "name"), `field${counter.i++}`);
+      const field = { component: comp, name };
+      const vt = valueTypeFor(comp);
+      if (vt) field.valueType = vt;
+      const label = attr(node, "fieldLabel") ?? attr(node, "text");
+      if (label) field.label = label;
+      if (comp === "select" || comp === "radio-group" || comp === "multiselect") {
+        const options = readOptions(node);
+        if (options.length) field.options = options;
+      }
+      const def = attr(node, "value") ?? (comp === "boolean" ? attr(node, "checked") : void 0);
+      if (def !== void 0 && def !== "") field.value = comp === "boolean" ? def === "true" : def;
+      out.push(field);
+      continue;
+    }
+    if (rt && attr(node, "name") && !isWrapper(rt)) unmapped.add(rt);
+    walk(childrenOf(node), out, unmapped, counter);
+  }
+}
+function parseDialog(xml) {
+  const parser = new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    preserveOrder: true,
+    removeNSPrefix: false,
+    trimValues: true
+  });
+  const tree = parser.parse(xml);
+  const root = tree.find((n) => tagOf(n) === "jcr:root");
+  const fields = [];
+  const unmapped = /* @__PURE__ */ new Set();
+  if (root) walk(childrenOf(root), fields, unmapped, { i: 1 });
+  return { fields, unmapped: [...unmapped] };
+}
+var init_dialog = __esm({
+  "src/lib/migrate/dialog.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/lib/migrate/component.ts
+import { existsSync as existsSync6 } from "fs";
+import { readFile as readFile4 } from "fs/promises";
+import path8 from "path";
+import { XMLParser as XMLParser2 } from "fast-xml-parser";
+function findDialogFile(componentDir) {
+  const candidates = [
+    path8.join(componentDir, "_cq_dialog", ".content.xml"),
+    path8.join(componentDir, "_cq_dialog.xml"),
+    path8.join(componentDir, "cq:dialog", ".content.xml")
+  ];
+  return candidates.find((c) => existsSync6(c)) ?? null;
+}
+async function readComponentTitle(componentDir) {
+  const file = path8.join(componentDir, ".content.xml");
+  if (!existsSync6(file)) return void 0;
+  try {
+    const parser = new XMLParser2({ ignoreAttributes: false, attributeNamePrefix: "@_" });
+    const parsed = parser.parse(await readFile4(file, "utf-8"));
+    const root = parsed["jcr:root"] ?? {};
+    const title = root["@_jcr:title"];
+    return typeof title === "string" ? title.replace(/^\{[^}]+\}/, "") : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function readDialogFields(componentDir) {
+  const dialog = findDialogFile(componentDir);
+  if (!dialog) return null;
+  return parseDialog(await readFile4(dialog, "utf-8"));
+}
+function migratedModelFile(blockName, title, fields) {
+  const model = {
+    definitions: [
+      {
+        title,
+        id: blockName,
+        plugins: {
+          xwalk: {
+            page: {
+              resourceType: "core/franklin/components/block/v1/block",
+              template: { name: title, model: blockName }
+            }
+          }
+        }
+      }
+    ],
+    models: [{ id: blockName, fields }],
+    filters: []
+  };
+  return `${JSON.stringify(model, null, 2)}
+`;
+}
+function migratedBlockJs(blockName, fields) {
+  const hasContainer = fields.some((f) => f.component === "container" && f.multi);
+  const body = hasContainer ? `  // This block was migrated from a classic AEM component with a multifield.
+  // Each child row is one repeated item - enhance them here.
+  [...block.children].forEach((row) => {
+    row.classList.add('${blockName}-item');
+  });` : `  // Migrated from a classic AEM component. The authored fields arrive as
+  // rows; read and enhance them here (port the old HTL logic as needed).`;
+  return `// Block: ${blockName}
+// Migrated from a classic AEM component by \`eds migrate component\`.
+// TODO: port the component's HTL/JS behaviour into this decorator.
+export default function decorate(block) {
+  block.classList.add('${blockName}');
+${body}
+}
+`;
+}
+function migratedBlockCss(blockName) {
+  return `/* Block: ${blockName} */
+/* Migrated from a classic AEM component. Bring the component's styles here */
+/* (from its clientlib or the rendered page) and keep them scoped to the block. */
+.${blockName} {
+}
+`;
+}
+var init_component = __esm({
+  "src/lib/migrate/component.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_dialog();
+  }
+});
+
+// src/commands/migrate.ts
+var migrate_exports = {};
+__export(migrate_exports, {
+  migrateComponent: () => migrateComponent
+});
+import { existsSync as existsSync7 } from "fs";
+import { mkdir as mkdir3, writeFile as writeFile5 } from "fs/promises";
+import path9 from "path";
+function clientlibBlockCss(blockName, css, files) {
+  return `/* Block: ${blockName} */
+/* Migrated from the component clientlib: ${files.join(", ")}. */
+/* TODO: review selectors and scope them under .${blockName} (and port any LESS/SCSS). */
+
+${css.trim()}
+`;
+}
+function previewFields(fields, depth = 0) {
+  const lines = [];
+  for (const f of fields) {
+    const indent = "  ".repeat(depth);
+    if (f.component === "tab") {
+      lines.push(`${indent}${brand.blue("\u25B8")} ${f.label ?? f.name}`);
+    } else {
+      const opts = f.options?.length ? ` (${f.options.length} options)` : "";
+      const multi = f.multi ? " \xB7multi" : "";
+      const label = f.label ? `- ${f.label}` : "";
+      lines.push(`${indent}${brand.accent(f.component)}${multi}  ${f.name}${opts}  ${label}`);
+      if (f.fields?.length) lines.push(...previewFields(f.fields, depth + 1));
+    }
+  }
+  return lines;
+}
+function countLeaves(fields) {
+  let n = 0;
+  for (const f of fields) {
+    if (f.component === "tab") continue;
+    n += 1;
+    if (f.fields) n += countLeaves(f.fields);
+  }
+  return n;
+}
+async function migrateComponent(dirArg, options = {}) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    logger.error("Not inside an EDS project (no EDS project markers found).");
+    process.exitCode = 1;
+    return;
+  }
+  await logger.logoOnceAnimated("Migrate component");
+  const { input, confirm } = await import("@inquirer/prompts");
+  const interactive = !options.yes;
+  let componentDir = dirArg;
+  if (!componentDir && interactive) {
+    componentDir = await input({
+      message: "Path to the classic component folder",
+      validate: (v) => existsSync7(v.trim()) || "Folder not found"
+    });
+  }
+  if (!componentDir) {
+    logger.error("Provide the path to the classic component folder.");
+    process.exitCode = 1;
+    return;
+  }
+  componentDir = path9.resolve(componentDir.trim());
+  if (!findDialogFile(componentDir)) {
+    logger.error(`No Touch UI dialog (_cq_dialog/.content.xml) found in ${componentDir}.`);
+    process.exitCode = 1;
+    return;
+  }
+  const parsed = await readDialogFields(componentDir);
+  if (!parsed || parsed.fields.length === 0) {
+    logger.warn("Dialog found but no mappable fields were detected.");
+    if (parsed?.unmapped.length)
+      logger.info(`Unmapped resourceTypes: ${parsed.unmapped.join(", ")}`);
+    process.exitCode = 1;
+    return;
+  }
+  const title = await readComponentTitle(componentDir) ?? path9.basename(componentDir);
+  const blockName = options.name && slug2(options.name) || (interactive ? slug2(await input({ message: "Block name", default: slug2(title) })) : slug2(title));
+  logger.info(heading("Mapped fields", `${countLeaves(parsed.fields)} from dialog`));
+  for (const line of previewFields(parsed.fields)) logger.info(`  ${line}`);
+  if (parsed.unmapped.length) {
+    logger.info("");
+    logger.warn(`Skipped (unrecognised): ${parsed.unmapped.join(", ")}`);
+  }
+  logger.info("");
+  if (interactive) {
+    const go = await confirm({ message: `Generate block "${blockName}"?`, default: true });
+    if (!go) {
+      logger.info("Cancelled.");
+      return;
+    }
+  }
+  const blockDir = path9.join(projectRoot, "blocks", blockName);
+  if (existsSync7(blockDir)) {
+    logger.error(
+      `Block "${blockName}" already exists at blocks/${blockName}. Use --name to pick another.`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const clibDir = options.clientlib ? path9.resolve(options.clientlib.trim()) : await findClientlibDir(componentDir);
+  let cssContent = migratedBlockCss(blockName);
+  let cssMessage = "empty - add styles from clientlib / rendered CSS";
+  let preprocessedNote = [];
+  if (clibDir && existsSync7(clibDir)) {
+    const lib = await readClientlibCss(clibDir);
+    if (lib.css.trim()) {
+      cssContent = clientlibBlockCss(blockName, lib.css, lib.files);
+      cssMessage = `from clientlib (${lib.files.length} file(s)) - review & scope`;
+    }
+    preprocessedNote = lib.preprocessed;
+  }
+  await mkdir3(blockDir, { recursive: true });
+  await writeFile5(
+    path9.join(blockDir, `${blockName}.js`),
+    migratedBlockJs(blockName, parsed.fields)
+  );
+  await writeFile5(path9.join(blockDir, `${blockName}.css`), cssContent);
+  await writeFile5(
+    path9.join(blockDir, `_${blockName}.json`),
+    migratedModelFile(blockName, title, parsed.fields)
+  );
+  logger.info(heading("Created"));
+  const files = [`${blockName}.js`, `${blockName}.css`, `_${blockName}.json`];
+  const w = columnWidth(files);
+  logger.info(accentLine(`${blockName}.js`, "decorator stub (port HTL logic)", w));
+  logger.info(accentLine(`${blockName}.css`, cssMessage, w));
+  logger.info(accentLine(`_${blockName}.json`, "Universal Editor model", w));
+  if (preprocessedNote.length) {
+    logger.info("");
+    logger.warn(`LESS/SCSS found (needs a build, not copied): ${preprocessedNote.join(", ")}`);
+  }
+  logger.info("");
+  logger.info(
+    box([`"${blockName}" migrated. Next: add CSS, then \`eds block preview ${blockName}\``])
+  );
+}
+var slug2;
+var init_migrate = __esm({
+  "src/commands/migrate.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_clientlib();
+    init_component();
+    init_project();
+    init_ui();
+    slug2 = (s) => s.trim().toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
+  }
+});
+
 // src/commands/block/create.ts
 var create_exports = {};
 __export(create_exports, {
   createBlock: () => createBlock,
   ueModelFor: () => ueModelFor
 });
-import { existsSync as existsSync5 } from "fs";
-import { mkdir as mkdir3, writeFile as writeFile5 } from "fs/promises";
-import path7 from "path";
+import { existsSync as existsSync8 } from "fs";
+import { mkdir as mkdir4, writeFile as writeFile6 } from "fs/promises";
+import path10 from "path";
 import chalk4 from "chalk";
 function titleCase(name) {
   return name.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
@@ -1511,13 +1947,13 @@ async function createBlock(name, options = {}) {
     process.exitCode = 1;
     return;
   }
-  const blocksDir = path7.join(projectRoot, "blocks", name);
-  if (existsSync5(blocksDir)) {
+  const blocksDir = path10.join(projectRoot, "blocks", name);
+  if (existsSync8(blocksDir)) {
     logger.error(`Block "${name}" already exists at ${blocksDir}`);
     process.exitCode = 1;
     return;
   }
-  await mkdir3(blocksDir, { recursive: true });
+  await mkdir4(blocksDir, { recursive: true });
   const jsContent = `export default function decorate(block) {
   // TODO: implement ${name} block
 }
@@ -1526,14 +1962,14 @@ async function createBlock(name, options = {}) {
   /* TODO: style ${name} block */
 }
 `;
-  await writeFile5(path7.join(blocksDir, `${name}.js`), jsContent);
-  await writeFile5(path7.join(blocksDir, `${name}.css`), cssContent);
+  await writeFile6(path10.join(blocksDir, `${name}.js`), jsContent);
+  await writeFile6(path10.join(blocksDir, `${name}.css`), cssContent);
   const withUe = options.ueModel !== false;
   if (withUe) {
-    await writeFile5(path7.join(blocksDir, `_${name}.json`), ueModelFor(name));
+    await writeFile6(path10.join(blocksDir, `_${name}.json`), ueModelFor(name));
   }
   logger.success(
-    `Block "${name}" created at ${chalk4.cyan(path7.relative(projectRoot, blocksDir))}${withUe ? chalk4.dim(" (+ Universal Editor model)") : ""}`
+    `Block "${name}" created at ${chalk4.cyan(path10.relative(projectRoot, blocksDir))}${withUe ? chalk4.dim(" (+ Universal Editor model)") : ""}`
   );
 }
 var init_create = __esm({
@@ -1547,10 +1983,10 @@ var init_create = __esm({
 });
 
 // src/lib/agents/detect.ts
-import { existsSync as existsSync6 } from "fs";
-import { readFile as readFile3 } from "fs/promises";
+import { existsSync as existsSync9 } from "fs";
+import { readFile as readFile5 } from "fs/promises";
 import { homedir } from "os";
-import path8 from "path";
+import path11 from "path";
 async function whichBinary(name) {
   const { execaCommand } = await import("execa");
   try {
@@ -1578,8 +2014,8 @@ function findFigmaServerKey(node) {
 async function findFigmaMcpServer(configPaths) {
   for (const configPath of configPaths) {
     try {
-      if (!existsSync6(configPath)) continue;
-      const content = await readFile3(configPath, "utf-8");
+      if (!existsSync9(configPath)) continue;
+      const content = await readFile5(configPath, "utf-8");
       try {
         const key = findFigmaServerKey(JSON.parse(content));
         if (key) return key;
@@ -1601,7 +2037,7 @@ async function detectAgent(preferred) {
         return {
           type: def.type,
           path: binPath,
-          configDir: existsSync6(def.configDir) ? def.configDir : void 0,
+          configDir: existsSync9(def.configDir) ? def.configDir : void 0,
           hasFigmaMcp: !!figmaMcpServerName,
           figmaMcpServerName
         };
@@ -1616,7 +2052,7 @@ async function detectAgent(preferred) {
       return {
         type: def.type,
         path: binPath,
-        configDir: existsSync6(def.configDir) ? def.configDir : void 0,
+        configDir: existsSync9(def.configDir) ? def.configDir : void 0,
         hasFigmaMcp: !!figmaMcpServerName,
         figmaMcpServerName
       };
@@ -1633,7 +2069,7 @@ async function detectAllAgents() {
       agents.push({
         type: def.type,
         path: binPath,
-        configDir: existsSync6(def.configDir) ? def.configDir : void 0,
+        configDir: existsSync9(def.configDir) ? def.configDir : void 0,
         hasFigmaMcp: !!figmaMcpServerName,
         figmaMcpServerName
       });
@@ -1651,22 +2087,22 @@ var init_detect = __esm({
       {
         type: "claude",
         binary: "claude",
-        configDir: path8.join(homedir(), ".claude"),
+        configDir: path11.join(homedir(), ".claude"),
         mcpConfigPaths: [
-          path8.join(homedir(), ".claude", "plugins.json"),
-          path8.join(homedir(), ".claude.json")
+          path11.join(homedir(), ".claude", "plugins.json"),
+          path11.join(homedir(), ".claude.json")
         ]
       },
       {
         type: "cursor",
         binary: "cursor",
-        configDir: path8.join(homedir(), ".cursor"),
-        mcpConfigPaths: [path8.join(homedir(), ".cursor", "mcp.json")]
+        configDir: path11.join(homedir(), ".cursor"),
+        mcpConfigPaths: [path11.join(homedir(), ".cursor", "mcp.json")]
       },
       {
         type: "codex",
         binary: "codex",
-        configDir: path8.join(homedir(), ".codex"),
+        configDir: path11.join(homedir(), ".codex"),
         mcpConfigPaths: []
       }
     ];
@@ -1674,23 +2110,23 @@ var init_detect = __esm({
 });
 
 // src/lib/agents/invoke.ts
-import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile6 } from "fs/promises";
+import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile7 } from "fs/promises";
 import { tmpdir } from "os";
-import path9 from "path";
+import path12 from "path";
 import readline from "readline";
 import chalk5 from "chalk";
 async function savePromptToFile(prompt, projectRoot) {
-  const base = projectRoot ? path9.join(projectRoot, "tmp") : tmpdir();
-  const dir = path9.join(base, "eds-cli");
-  await mkdir4(dir, { recursive: true });
+  const base = projectRoot ? path12.join(projectRoot, "tmp") : tmpdir();
+  const dir = path12.join(base, "eds-cli");
+  await mkdir5(dir, { recursive: true });
   const filename = `from-design-${Date.now()}.md`;
-  const filePath = path9.join(dir, filename);
-  await writeFile6(filePath, prompt, "utf-8");
+  const filePath = path12.join(dir, filename);
+  await writeFile7(filePath, prompt, "utf-8");
   return filePath;
 }
 async function invokeAgent(agent, promptFile, cwd) {
   const { execa } = await import("execa");
-  const prompt = await readFile4(promptFile, "utf-8");
+  const prompt = await readFile6(promptFile, "utf-8");
   try {
     switch (agent.type) {
       case "claude": {
@@ -1830,7 +2266,7 @@ function toolLabel(name, input, cwd) {
   const rel = (key) => {
     const p = input?.[key];
     if (typeof p !== "string") return "";
-    return p.startsWith(cwd) ? path9.relative(cwd, p) : path9.basename(p);
+    return p.startsWith(cwd) ? path12.relative(cwd, p) : path12.basename(p);
   };
   if (name.includes("figma")) {
     const short = name.split("__").pop() ?? name;
@@ -1861,13 +2297,13 @@ var init_invoke = __esm({
 });
 
 // src/lib/config.ts
-import { existsSync as existsSync7 } from "fs";
-import { readFile as readFile5 } from "fs/promises";
+import { existsSync as existsSync10 } from "fs";
+import { readFile as readFile7 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import path10 from "path";
+import path13 from "path";
 async function loadJsonFile(filePath) {
   try {
-    const content = await readFile5(filePath, "utf-8");
+    const content = await readFile7(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return void 0;
@@ -1875,7 +2311,7 @@ async function loadJsonFile(filePath) {
 }
 async function loadConfig(projectRoot) {
   const globalRaw = await loadJsonFile(GLOBAL_CONFIG_PATH);
-  const projectRaw = projectRoot ? await loadJsonFile(path10.join(projectRoot, PROJECT_CONFIG_NAME)) : void 0;
+  const projectRaw = projectRoot ? await loadJsonFile(path13.join(projectRoot, PROJECT_CONFIG_NAME)) : void 0;
   const merged = {
     ...typeof globalRaw === "object" && globalRaw !== null ? globalRaw : {},
     ...typeof projectRaw === "object" && projectRaw !== null ? projectRaw : {}
@@ -1894,7 +2330,7 @@ function globalConfigPath() {
   return GLOBAL_CONFIG_PATH;
 }
 function globalConfigExists() {
-  return existsSync7(GLOBAL_CONFIG_PATH);
+  return existsSync10(GLOBAL_CONFIG_PATH);
 }
 var GLOBAL_CONFIG_DIR, GLOBAL_CONFIG_PATH, PROJECT_CONFIG_NAME;
 var init_config = __esm({
@@ -1903,8 +2339,8 @@ var init_config = __esm({
     init_esm_shims();
     init_logger();
     init_schemas();
-    GLOBAL_CONFIG_DIR = path10.join(homedir2(), ".eds");
-    GLOBAL_CONFIG_PATH = path10.join(GLOBAL_CONFIG_DIR, "config.json");
+    GLOBAL_CONFIG_DIR = path13.join(homedir2(), ".eds");
+    GLOBAL_CONFIG_PATH = path13.join(GLOBAL_CONFIG_DIR, "config.json");
     PROJECT_CONFIG_NAME = ".edsrc.json";
   }
 });
@@ -1954,9 +2390,9 @@ var init_node_id = __esm({
 });
 
 // src/lib/figma/prompt-builder.ts
-import { existsSync as existsSync8 } from "fs";
-import { readFile as readFile6 } from "fs/promises";
-import path11 from "path";
+import { existsSync as existsSync11 } from "fs";
+import { readFile as readFile8 } from "fs/promises";
+import path14 from "path";
 function contentSourceGuidance(source, cfHint, blockName) {
   if (!source || source === "document" || source === "ue") return "";
   const q = cfHint ? ` (model / persisted query: \`${cfHint}\`)` : "";
@@ -2168,10 +2604,10 @@ ${tokensHint}
 `;
 }
 async function getTokensHint(projectRoot) {
-  const stylesPath = path11.join(projectRoot, "styles", "styles.css");
-  if (!existsSync8(stylesPath)) return "";
+  const stylesPath = path14.join(projectRoot, "styles", "styles.css");
+  if (!existsSync11(stylesPath)) return "";
   try {
-    const css = await readFile6(stylesPath, "utf-8");
+    const css = await readFile8(stylesPath, "utf-8");
     const rootMatch = css.match(/:root\s*\{([^}]+)\}/);
     if (!rootMatch) return "";
     const props = rootMatch[1].split("\n").filter((line) => line.trim().startsWith("--")).map((line) => line.trim()).join("\n  ");
@@ -2311,11 +2747,11 @@ var init_harness = __esm({
 });
 
 // src/lib/preview/server.ts
-import { createReadStream, existsSync as existsSync9, statSync } from "fs";
+import { createReadStream, existsSync as existsSync12, statSync } from "fs";
 import http from "http";
-import path12 from "path";
+import path15 from "path";
 function startServer(root, routes, port, host = "127.0.0.1") {
-  const resolvedRoot = path12.resolve(root);
+  const resolvedRoot = path15.resolve(root);
   const clients = /* @__PURE__ */ new Set();
   const server = http.createServer((req, res) => {
     const urlPath = decodeURIComponent((req.url ?? "/").split("?")[0]);
@@ -2341,19 +2777,19 @@ function startServer(root, routes, port, host = "127.0.0.1") {
       res.end(route.body);
       return;
     }
-    const filePath = path12.join(resolvedRoot, urlPath);
+    const filePath = path15.join(resolvedRoot, urlPath);
     if (!filePath.startsWith(resolvedRoot)) {
       res.writeHead(403);
       res.end("Forbidden");
       return;
     }
-    if (!existsSync9(filePath) || !statSync(filePath).isFile()) {
+    if (!existsSync12(filePath) || !statSync(filePath).isFile()) {
       res.writeHead(404, { "content-type": "text/plain" });
       res.end(`Not found: ${urlPath}`);
       return;
     }
     res.writeHead(200, {
-      "content-type": MIME[path12.extname(filePath).toLowerCase()] ?? "application/octet-stream"
+      "content-type": MIME[path15.extname(filePath).toLowerCase()] ?? "application/octet-stream"
     });
     createReadStream(filePath).pipe(res);
   });
@@ -2417,9 +2853,9 @@ var preview_exports = {};
 __export(preview_exports, {
   previewBlock: () => previewBlock
 });
-import { existsSync as existsSync10, watch } from "fs";
-import { readFile as readFile7 } from "fs/promises";
-import path13 from "path";
+import { existsSync as existsSync13, watch } from "fs";
+import { readFile as readFile9 } from "fs/promises";
+import path16 from "path";
 import chalk6 from "chalk";
 function labelFor(width) {
   if (width <= 480) return `${width} mobile`;
@@ -2472,30 +2908,30 @@ async function previewBlock(name, options = {}) {
     process.exitCode = 1;
     return;
   }
-  const blockDir = path13.join(projectRoot, "blocks", name);
-  if (!existsSync10(blockDir)) {
+  const blockDir = path16.join(projectRoot, "blocks", name);
+  if (!existsSync13(blockDir)) {
     logger.error(`Block "${name}" not found at blocks/${name}/.`);
     process.exitCode = 1;
     return;
   }
-  if (!existsSync10(path13.join(blockDir, `${name}.css`)) && !existsSync10(path13.join(blockDir, `${name}.js`))) {
+  if (!existsSync13(path16.join(blockDir, `${name}.css`)) && !existsSync13(path16.join(blockDir, `${name}.js`))) {
     logger.error(`Block "${name}" has no ${name}.css / ${name}.js to preview.`);
     process.exitCode = 1;
     return;
   }
   let meta = null;
-  const metaPath = path13.join(blockDir, ".eds-meta.json");
-  if (existsSync10(metaPath)) {
+  const metaPath = path16.join(blockDir, ".eds-meta.json");
+  if (existsSync13(metaPath)) {
     try {
-      meta = JSON.parse(await readFile7(metaPath, "utf-8"));
+      meta = JSON.parse(await readFile9(metaPath, "utf-8"));
     } catch {
     }
   }
-  const samplePath = path13.join(blockDir, `_${name}.preview.html`);
+  const samplePath = path16.join(blockDir, `_${name}.preview.html`);
   let sampleContent;
   let placeholder = false;
-  if (existsSync10(samplePath)) {
-    sampleContent = await readFile7(samplePath, "utf-8");
+  if (existsSync13(samplePath)) {
+    sampleContent = await readFile9(samplePath, "utf-8");
   } else {
     sampleContent = defaultSample(name);
     placeholder = true;
@@ -2576,9 +3012,9 @@ var from_design_exports = {};
 __export(from_design_exports, {
   blockFromDesign: () => blockFromDesign
 });
-import { existsSync as existsSync11 } from "fs";
-import { readFile as readFile8, writeFile as writeFile7 } from "fs/promises";
-import path14 from "path";
+import { existsSync as existsSync14 } from "fs";
+import { readFile as readFile10, writeFile as writeFile8 } from "fs/promises";
+import path17 from "path";
 import chalk7 from "chalk";
 import ora from "ora";
 async function previewRunning(port = 8777) {
@@ -2759,7 +3195,7 @@ async function blockFromDesign(figmaUrlArg, optionsArg) {
     screenshot: options.screenshot !== false
   });
   const promptFile = await savePromptToFile(prompt, projectRoot);
-  const hasTokens = existsSync11(path14.join(projectRoot, "styles", "styles.css"));
+  const hasTokens = existsSync14(path17.join(projectRoot, "styles", "styles.css"));
   promptSpinner.succeed(
     hasTokens ? `Loaded design tokens  ${chalk7.dim("styles/styles.css")}` : `Built prompt  ${chalk7.dim("no project tokens found")}`
   );
@@ -2819,9 +3255,9 @@ async function blockFromDesign(figmaUrlArg, optionsArg) {
     process.exitCode = 1;
     return;
   }
-  const blockDir = path14.join(projectRoot, "blocks", blockName);
+  const blockDir = path17.join(projectRoot, "blocks", blockName);
   const ok = await verifyGeneratedBlock(blockDir, blockName, options.ueModel !== false);
-  if (existsSync11(blockDir)) {
+  if (existsSync14(blockDir)) {
     const meta = {
       provider,
       designRef,
@@ -2831,7 +3267,7 @@ async function blockFromDesign(figmaUrlArg, optionsArg) {
       promptVersion: PROMPT_VERSION,
       agentUsed: agent.type
     };
-    await writeFile7(path14.join(blockDir, ".eds-meta.json"), `${JSON.stringify(meta, null, 2)}
+    await writeFile8(path17.join(blockDir, ".eds-meta.json"), `${JSON.stringify(meta, null, 2)}
 `);
   }
   if (!ok) {
@@ -2860,10 +3296,10 @@ async function blockFromDesign(figmaUrlArg, optionsArg) {
 }
 async function verifyGeneratedBlock(blockDir, blockName, withUeModel) {
   const checks = [];
-  const jsPath = path14.join(blockDir, `${blockName}.js`);
-  const cssPath = path14.join(blockDir, `${blockName}.css`);
-  const hasJs = existsSync11(jsPath);
-  const hasCss = existsSync11(cssPath);
+  const jsPath = path17.join(blockDir, `${blockName}.js`);
+  const cssPath = path17.join(blockDir, `${blockName}.css`);
+  const hasJs = existsSync14(jsPath);
+  const hasCss = existsSync14(cssPath);
   checks.push({
     status: hasJs ? "pass" : "fail",
     name: `${blockName}.js`,
@@ -2875,7 +3311,7 @@ async function verifyGeneratedBlock(blockDir, blockName, withUeModel) {
     message: hasCss ? "created" : "missing \u2014 agent did not write the CSS file"
   });
   if (hasJs) {
-    const js = await readFile8(jsPath, "utf-8");
+    const js = await readFile10(jsPath, "utf-8");
     checks.push({
       status: /export\s+default/.test(js) ? "pass" : "fail",
       name: "decorate export",
@@ -2890,7 +3326,7 @@ async function verifyGeneratedBlock(blockDir, blockName, withUeModel) {
     }
   }
   if (hasCss) {
-    const css = await readFile8(cssPath, "utf-8");
+    const css = await readFile10(cssPath, "utf-8");
     checks.push({
       status: css.includes(`.${blockName}`) ? "pass" : "warn",
       name: "scoped CSS",
@@ -2898,12 +3334,12 @@ async function verifyGeneratedBlock(blockDir, blockName, withUeModel) {
     });
   }
   if (withUeModel) {
-    const hasPerBlock = existsSync11(path14.join(blockDir, `_${blockName}.json`));
-    const modelsFile = path14.join(blockDir, "..", "..", "component-models.json");
+    const hasPerBlock = existsSync14(path17.join(blockDir, `_${blockName}.json`));
+    const modelsFile = path17.join(blockDir, "..", "..", "component-models.json");
     let hasAggregated = false;
-    if (!hasPerBlock && existsSync11(modelsFile)) {
+    if (!hasPerBlock && existsSync14(modelsFile)) {
       try {
-        hasAggregated = (await readFile8(modelsFile, "utf-8")).includes(`"${blockName}"`);
+        hasAggregated = (await readFile10(modelsFile, "utf-8")).includes(`"${blockName}"`);
       } catch {
       }
     }
@@ -2915,8 +3351,8 @@ async function verifyGeneratedBlock(blockDir, blockName, withUeModel) {
     });
     if (hasPerBlock && hasJs) {
       try {
-        const modelRaw = await readFile8(path14.join(blockDir, `_${blockName}.json`), "utf-8");
-        const js = await readFile8(jsPath, "utf-8");
+        const modelRaw = await readFile10(path17.join(blockDir, `_${blockName}.json`), "utf-8");
+        const js = await readFile10(jsPath, "utf-8");
         const isRepeatable = /"resourceType"\s*:\s*"[^"]*\/item"/.test(modelRaw) || /"filter"\s*:/.test(modelRaw) || /"multi"\s*:\s*true/.test(modelRaw);
         const iterates = /\.children/.test(js) || /\bfor\s*\(/.test(js) || /\.forEach\s*\(/.test(js);
         if (isRepeatable) {
@@ -2959,9 +3395,9 @@ var list_exports = {};
 __export(list_exports, {
   listBlocks: () => listBlocks
 });
-import { existsSync as existsSync12 } from "fs";
-import { readFile as readFile9, readdir } from "fs/promises";
-import path15 from "path";
+import { existsSync as existsSync15 } from "fs";
+import { readFile as readFile11, readdir as readdir2 } from "fs/promises";
+import path18 from "path";
 import chalk8 from "chalk";
 async function listBlocks(options = {}) {
   const projectRoot = findProjectRoot();
@@ -2970,27 +3406,27 @@ async function listBlocks(options = {}) {
     process.exitCode = 1;
     return;
   }
-  const blocksDir = path15.join(projectRoot, "blocks");
-  if (!existsSync12(blocksDir)) {
+  const blocksDir = path18.join(projectRoot, "blocks");
+  if (!existsSync15(blocksDir)) {
     logger.info("No blocks/ directory found.");
     return;
   }
-  const entries = await readdir(blocksDir, { withFileTypes: true });
+  const entries = await readdir2(blocksDir, { withFileTypes: true });
   const blocks = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     const name = entry.name;
-    const blockDir = path15.join(blocksDir, name);
+    const blockDir = path18.join(blocksDir, name);
     const info = {
       name,
-      hasJs: existsSync12(path15.join(blockDir, `${name}.js`)),
-      hasCss: existsSync12(path15.join(blockDir, `${name}.css`)),
-      hasUeModel: existsSync12(path15.join(blockDir, `_${name}.json`))
+      hasJs: existsSync15(path18.join(blockDir, `${name}.js`)),
+      hasCss: existsSync15(path18.join(blockDir, `${name}.css`)),
+      hasUeModel: existsSync15(path18.join(blockDir, `_${name}.json`))
     };
-    const metaFile = path15.join(blockDir, ".eds-meta.json");
-    if (existsSync12(metaFile)) {
+    const metaFile = path18.join(blockDir, ".eds-meta.json");
+    if (existsSync15(metaFile)) {
       try {
-        const meta = JSON.parse(await readFile9(metaFile, "utf-8"));
+        const meta = JSON.parse(await readFile11(metaFile, "utf-8"));
         info.figmaSource = {
           fileKey: meta.figmaFileKey,
           nodeId: meta.figmaNodeId,
@@ -3140,9 +3576,9 @@ var integrate_exports = {};
 __export(integrate_exports, {
   integrate: () => integrate
 });
-import { existsSync as existsSync13 } from "fs";
-import { mkdir as mkdir5, readFile as readFile10, writeFile as writeFile8 } from "fs/promises";
-import path16 from "path";
+import { existsSync as existsSync16 } from "fs";
+import { mkdir as mkdir6, readFile as readFile12, writeFile as writeFile9 } from "fs/promises";
+import path19 from "path";
 import chalk9 from "chalk";
 async function integrate(type) {
   const projectRoot = findProjectRoot();
@@ -3171,10 +3607,10 @@ async function integrate(type) {
     values[f.name] = answer.trim();
   }
   const block2 = wrapBlock(integration.name, integration.code(values));
-  const delayedPath = path16.join(projectRoot, "scripts", "delayed.js");
-  await mkdir5(path16.dirname(delayedPath), { recursive: true });
-  const existing = existsSync13(delayedPath) ? await readFile10(delayedPath, "utf-8") : DELAYED_HEADER;
-  await writeFile8(delayedPath, `${existing.replace(/\s*$/, "")}
+  const delayedPath = path19.join(projectRoot, "scripts", "delayed.js");
+  await mkdir6(path19.dirname(delayedPath), { recursive: true });
+  const existing = existsSync16(delayedPath) ? await readFile12(delayedPath, "utf-8") : DELAYED_HEADER;
+  await writeFile9(delayedPath, `${existing.replace(/\s*$/, "")}
 ${block2}`);
   logger.info(heading("Added"));
   logger.info(accentLine(integration.name, "\u2192 scripts/delayed.js"));
@@ -3215,8 +3651,8 @@ var setup_exports = {};
 __export(setup_exports, {
   figmaSetup: () => figmaSetup
 });
-import { existsSync as existsSync14 } from "fs";
-import { mkdir as mkdir6, writeFile as writeFile9 } from "fs/promises";
+import { existsSync as existsSync17 } from "fs";
+import { mkdir as mkdir7, writeFile as writeFile10 } from "fs/promises";
 import chalk10 from "chalk";
 async function figmaSetup() {
   const { select, confirm } = await import("@inquirer/prompts");
@@ -3296,14 +3732,14 @@ async function figmaSetup() {
   });
   if (shouldSave) {
     const configDir = globalConfigDir();
-    if (!existsSync14(configDir)) {
-      await mkdir6(configDir, { recursive: true });
+    if (!existsSync17(configDir)) {
+      await mkdir7(configDir, { recursive: true });
     }
     const config = {};
     if (selectedAgent !== "none") {
       config.agent = selectedAgent;
     }
-    await writeFile9(globalConfigPath(), `${JSON.stringify(config, null, 2)}
+    await writeFile10(globalConfigPath(), `${JSON.stringify(config, null, 2)}
 `, {
       mode: 384
     });
@@ -3330,9 +3766,9 @@ var doctor_exports = {};
 __export(doctor_exports, {
   doctor: () => doctor
 });
-import { existsSync as existsSync15 } from "fs";
-import { readFile as readFile11, readdir as readdir2 } from "fs/promises";
-import path17 from "path";
+import { existsSync as existsSync18 } from "fs";
+import { readFile as readFile13, readdir as readdir3 } from "fs/promises";
+import path20 from "path";
 import { parse as parseYaml } from "yaml";
 async function doctor(options = {}) {
   const projectRoot = findProjectRoot();
@@ -3354,7 +3790,7 @@ async function doctor(options = {}) {
   });
   if (project.hasFstab) {
     try {
-      const content = await readFile11(path17.join(projectRoot, "fstab.yaml"), "utf-8");
+      const content = await readFile13(path20.join(projectRoot, "fstab.yaml"), "utf-8");
       parseYaml(content);
       results.push({ name: "fstab.yaml valid YAML", status: "pass", message: "Valid" });
     } catch {
@@ -3376,28 +3812,28 @@ async function doctor(options = {}) {
     message: project.hasBlocks ? "Found" : "Missing - no blocks yet"
   });
   if (project.hasBlocks) {
-    const blocksDir = path17.join(projectRoot, "blocks");
-    const entries = await readdir2(blocksDir, { withFileTypes: true });
+    const blocksDir = path20.join(projectRoot, "blocks");
+    const entries = await readdir3(blocksDir, { withFileTypes: true });
     let aggregatedModels = "";
-    const aggregatedPath = path17.join(projectRoot, "component-models.json");
-    if (existsSync15(aggregatedPath)) {
+    const aggregatedPath = path20.join(projectRoot, "component-models.json");
+    if (existsSync18(aggregatedPath)) {
       try {
-        aggregatedModels = await readFile11(aggregatedPath, "utf-8");
+        aggregatedModels = await readFile13(aggregatedPath, "utf-8");
       } catch {
       }
     }
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const blockName = entry.name;
-      const jsFile = path17.join(blocksDir, blockName, `${blockName}.js`);
-      const hasJs = existsSync15(jsFile);
+      const jsFile = path20.join(blocksDir, blockName, `${blockName}.js`);
+      const hasJs = existsSync18(jsFile);
       results.push({
         name: `blocks/${blockName} has JS`,
         status: hasJs ? "pass" : "warn",
         message: hasJs ? "Found" : `Missing ${blockName}.js`
       });
       if (hasJs) {
-        const jsContent = await readFile11(jsFile, "utf-8");
+        const jsContent = await readFile13(jsFile, "utf-8");
         if (jsContent.includes("console.log")) {
           results.push({
             name: `blocks/${blockName} no console.log`,
@@ -3406,17 +3842,17 @@ async function doctor(options = {}) {
           });
         }
       }
-      const hasPerBlockModel = existsSync15(path17.join(blocksDir, blockName, `_${blockName}.json`));
+      const hasPerBlockModel = existsSync18(path20.join(blocksDir, blockName, `_${blockName}.json`));
       const hasAggregatedModel = aggregatedModels.includes(`"${blockName}"`);
       results.push({
         name: `blocks/${blockName} UE model`,
         status: hasPerBlockModel || hasAggregatedModel ? "pass" : "warn",
         message: hasPerBlockModel || hasAggregatedModel ? hasPerBlockModel ? `_${blockName}.json` : "in component-models.json" : "no Universal Editor model - authors can't edit this block in UE"
       });
-      const metaFile = path17.join(blocksDir, blockName, ".eds-meta.json");
-      if (existsSync15(metaFile)) {
+      const metaFile = path20.join(blocksDir, blockName, ".eds-meta.json");
+      if (existsSync18(metaFile)) {
         try {
-          const meta = JSON.parse(await readFile11(metaFile, "utf-8"));
+          const meta = JSON.parse(await readFile13(metaFile, "utf-8"));
           const syncDate = new Date(meta.lastSyncedAt);
           const daysSinceSync = Math.floor(
             (Date.now() - syncDate.getTime()) / (1e3 * 60 * 60 * 24)
@@ -3436,10 +3872,10 @@ async function doctor(options = {}) {
       }
     }
   }
-  const queryFile = path17.join(projectRoot, "helix-query.yaml");
-  if (existsSync15(queryFile)) {
+  const queryFile = path20.join(projectRoot, "helix-query.yaml");
+  if (existsSync18(queryFile)) {
     try {
-      const content = await readFile11(queryFile, "utf-8");
+      const content = await readFile13(queryFile, "utf-8");
       parseYaml(content);
       results.push({ name: "helix-query.yaml valid", status: "pass", message: "Valid YAML" });
     } catch {
@@ -3496,9 +3932,9 @@ var audit_loading_exports = {};
 __export(audit_loading_exports, {
   auditLoading: () => auditLoading
 });
-import { existsSync as existsSync16 } from "fs";
-import { readFile as readFile12, readdir as readdir3, stat as stat3 } from "fs/promises";
-import path18 from "path";
+import { existsSync as existsSync19 } from "fs";
+import { readFile as readFile14, readdir as readdir4, stat as stat3 } from "fs/promises";
+import path21 from "path";
 import chalk11 from "chalk";
 async function auditLoading(options = {}) {
   const projectRoot = findProjectRoot();
@@ -3532,8 +3968,8 @@ async function auditLoading(options = {}) {
   printResults(results);
 }
 async function checkHeadHtml(root, results) {
-  const filePath = path18.join(root, "head.html");
-  if (!existsSync16(filePath)) {
+  const filePath = path21.join(root, "head.html");
+  if (!existsSync19(filePath)) {
     results.push({
       rule: "head.html exists",
       status: "warn",
@@ -3541,7 +3977,7 @@ async function checkHeadHtml(root, results) {
     });
     return;
   }
-  const content = await readFile12(filePath, "utf-8");
+  const content = await readFile14(filePath, "utf-8");
   const lines = content.split("\n");
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
@@ -3613,8 +4049,8 @@ async function checkHeadHtml(root, results) {
   }
 }
 async function checkScriptsJs(root, results) {
-  const filePath = path18.join(root, "scripts", "scripts.js");
-  if (!existsSync16(filePath)) {
+  const filePath = path21.join(root, "scripts", "scripts.js");
+  if (!existsSync19(filePath)) {
     results.push({
       rule: "scripts/scripts.js exists",
       status: "warn",
@@ -3622,7 +4058,7 @@ async function checkScriptsJs(root, results) {
     });
     return;
   }
-  const content = await readFile12(filePath, "utf-8");
+  const content = await readFile14(filePath, "utf-8");
   const lines = content.split("\n");
   const hasLoadEager = /function\s+loadEager|loadEager\s*=/i.test(content);
   const hasLoadLazy = /function\s+loadLazy|loadLazy\s*=/i.test(content);
@@ -3700,8 +4136,8 @@ async function checkScriptsJs(root, results) {
   }
 }
 async function checkStylesCss(root, results) {
-  const filePath = path18.join(root, "styles", "styles.css");
-  if (!existsSync16(filePath)) return;
+  const filePath = path21.join(root, "styles", "styles.css");
+  if (!existsSync19(filePath)) return;
   const stats = await stat3(filePath);
   const sizeKb = stats.size / 1024;
   results.push({
@@ -3710,7 +4146,7 @@ async function checkStylesCss(root, results) {
     message: `${sizeKb.toFixed(1)} KB${sizeKb > 40 ? " \u2014 large CSS competes with 100KB LCP budget" : ""}`,
     file: "styles/styles.css"
   });
-  const content = await readFile12(filePath, "utf-8");
+  const content = await readFile14(filePath, "utf-8");
   if (/@import\s/.test(content)) {
     results.push({
       rule: "No @import in styles.css",
@@ -3721,8 +4157,8 @@ async function checkStylesCss(root, results) {
   }
 }
 async function checkDelayedJs(root, results) {
-  const filePath = path18.join(root, "scripts", "delayed.js");
-  if (!existsSync16(filePath)) {
+  const filePath = path21.join(root, "scripts", "delayed.js");
+  if (!existsSync19(filePath)) {
     results.push({
       rule: "scripts/delayed.js exists",
       status: "info",
@@ -3730,7 +4166,7 @@ async function checkDelayedJs(root, results) {
     });
     return;
   }
-  const content = await readFile12(filePath, "utf-8");
+  const content = await readFile14(filePath, "utf-8");
   const stripped = content.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").trim();
   if (!stripped) {
     results.push({
@@ -3742,15 +4178,15 @@ async function checkDelayedJs(root, results) {
   }
 }
 async function checkBlocks(root, results) {
-  const blocksDir = path18.join(root, "blocks");
-  if (!existsSync16(blocksDir)) return;
-  const entries = await readdir3(blocksDir, { withFileTypes: true });
+  const blocksDir = path21.join(root, "blocks");
+  if (!existsSync19(blocksDir)) return;
+  const entries = await readdir4(blocksDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     const blockName = entry.name;
-    const jsFile = path18.join(blocksDir, blockName, `${blockName}.js`);
-    if (!existsSync16(jsFile)) continue;
-    const content = await readFile12(jsFile, "utf-8");
+    const jsFile = path21.join(blocksDir, blockName, `${blockName}.js`);
+    if (!existsSync19(jsFile)) continue;
+    const content = await readFile14(jsFile, "utf-8");
     const lines = content.split("\n");
     const heavyLibs = [
       "jquery",
@@ -3800,9 +4236,9 @@ async function checkBlocks(root, results) {
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     const blockName = entry.name;
-    const cssFile = path18.join(blocksDir, blockName, `${blockName}.css`);
-    if (!existsSync16(cssFile)) continue;
-    const content = await readFile12(cssFile, "utf-8");
+    const cssFile = path21.join(blocksDir, blockName, `${blockName}.css`);
+    if (!existsSync19(cssFile)) continue;
+    const content = await readFile14(cssFile, "utf-8");
     const selectorPattern = /^([a-z][a-z0-9-]*)\s*\{/gm;
     for (const selectorMatch of content.matchAll(selectorPattern)) {
       const selector = selectorMatch[1];
@@ -3818,8 +4254,8 @@ async function checkBlocks(root, results) {
   }
 }
 async function checkAemJs(root, results) {
-  const filePath = path18.join(root, "scripts", "aem.js");
-  if (!existsSync16(filePath)) {
+  const filePath = path21.join(root, "scripts", "aem.js");
+  if (!existsSync19(filePath)) {
     results.push({
       rule: "scripts/aem.js exists",
       status: "warn",
@@ -3891,17 +4327,17 @@ var audit_security_exports = {};
 __export(audit_security_exports, {
   auditSecurity: () => auditSecurity
 });
-import { existsSync as existsSync17 } from "fs";
-import { readFile as readFile13, readdir as readdir4 } from "fs/promises";
-import path19 from "path";
+import { existsSync as existsSync20 } from "fs";
+import { readFile as readFile15, readdir as readdir5 } from "fs/promises";
+import path22 from "path";
 import chalk12 from "chalk";
-async function* walk(dir) {
-  const entries = await readdir4(dir, { withFileTypes: true });
+async function* walk2(dir) {
+  const entries = await readdir5(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const full = path19.join(dir, entry.name);
+    const full = path22.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (IGNORE_DIRS.has(entry.name)) continue;
-      yield* walk(full);
+      yield* walk2(full);
     } else if (entry.isFile()) {
       yield full;
     }
@@ -3932,11 +4368,11 @@ function scanContent(content, relFile, ext) {
   return findings;
 }
 async function auditDependencies(root) {
-  if (!existsSync17(path19.join(root, "package.json"))) {
+  if (!existsSync20(path22.join(root, "package.json"))) {
     return { status: "skipped", note: "no package.json" };
   }
-  const hasLock = existsSync17(path19.join(root, "package-lock.json")) || existsSync17(path19.join(root, "npm-shrinkwrap.json"));
-  if (!hasLock && !existsSync17(path19.join(root, "node_modules"))) {
+  const hasLock = existsSync20(path22.join(root, "package-lock.json")) || existsSync20(path22.join(root, "npm-shrinkwrap.json"));
+  if (!hasLock && !existsSync20(path22.join(root, "node_modules"))) {
     return { status: "skipped", note: "no package-lock.json / node_modules \u2014 run npm install" };
   }
   try {
@@ -3967,12 +4403,12 @@ async function auditSecurity(options = {}) {
     return;
   }
   const findings = [];
-  for await (const file of walk(projectRoot)) {
-    const ext = path19.extname(file).slice(1).toLowerCase();
+  for await (const file of walk2(projectRoot)) {
+    const ext = path22.extname(file).slice(1).toLowerCase();
     if (!SCAN_EXT.has(ext)) continue;
-    const rel = path19.relative(projectRoot, file);
+    const rel = path22.relative(projectRoot, file);
     if (rel.endsWith("aem.js") || rel.endsWith("lib-franklin.js")) continue;
-    const content = await readFile13(file, "utf-8");
+    const content = await readFile15(file, "utf-8");
     findings.push(...scanContent(content, rel, ext));
   }
   const deps = await auditDependencies(projectRoot);
@@ -4390,13 +4826,13 @@ var menu_exports = {};
 __export(menu_exports, {
   mainMenu: () => mainMenu
 });
-import { existsSync as existsSync18 } from "fs";
-import { readdir as readdir5 } from "fs/promises";
-import path20 from "path";
+import { existsSync as existsSync21 } from "fs";
+import { readdir as readdir6 } from "fs/promises";
+import path23 from "path";
 async function listBlockNames(projectRoot) {
-  const dir = path20.join(projectRoot, "blocks");
-  if (!existsSync18(dir)) return [];
-  const entries = await readdir5(dir, { withFileTypes: true });
+  const dir = path23.join(projectRoot, "blocks");
+  if (!existsSync21(dir)) return [];
+  const entries = await readdir6(dir, { withFileTypes: true });
   return entries.filter((e) => e.isDirectory()).map((e) => e.name);
 }
 async function mainMenu() {
@@ -4407,6 +4843,7 @@ async function mainMenu() {
     choices: [
       { name: "Set up this project (authoring model, CI, naming)", value: "init" },
       { name: "Generate a block from a design (Figma/Stitch/Canva/Sketch)", value: "from-design" },
+      { name: "Migrate a classic AEM component to EDS", value: "migrate" },
       { name: "Scaffold Universal Editor components", value: "scaffold" },
       { name: "Create an empty block", value: "create" },
       { name: "Add a third-party integration (GTM, chat, consent\u2026)", value: "integrate" },
@@ -4427,6 +4864,11 @@ async function mainMenu() {
       await blockFromDesign2(void 0, {});
       return;
     }
+    case "migrate": {
+      const { migrateComponent: migrateComponent2 } = await Promise.resolve().then(() => (init_migrate(), migrate_exports));
+      await migrateComponent2(void 0, {});
+      return;
+    }
     case "scaffold": {
       const { scaffoldInteractive: scaffoldInteractive2 } = await Promise.resolve().then(() => (init_scaffold(), scaffold_exports));
       await scaffoldInteractive2();
@@ -4516,7 +4958,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "aem-eds-kit",
-  version: "0.4.7",
+  version: "0.4.9",
   description: "CLI for AEM Edge Delivery Services with Figma MCP integration",
   type: "module",
   engines: {
@@ -4566,6 +5008,7 @@ var package_default = {
     chalk: "^5.4.0",
     commander: "^13.0.0",
     execa: "^9.5.0",
+    "fast-xml-parser": "^5.11.2",
     ora: "^8.1.0",
     yaml: "^2.6.0",
     zod: "^3.24.0"
@@ -4598,6 +5041,11 @@ program.command("init").description("Set up a freshly cloned EDS boilerplate for
   const { initProject: initProject2 } = await Promise.resolve().then(() => (init_init(), init_exports));
   await initProject2(options);
 });
+var migrate = program.command("migrate").description("Migrate from classic AEM to EDS");
+migrate.command("component [dir]").description("Migrate a classic AEM component's dialog into an EDS block + UE model").option("--name <name>", "Block name (otherwise inferred from the component)").option("--clientlib <dir>", "Path to the component's clientlib (otherwise auto-detected)").option("--yes", "Skip confirmation prompts").action(async (dir, options) => {
+  const { migrateComponent: migrateComponent2 } = await Promise.resolve().then(() => (init_migrate(), migrate_exports));
+  await migrateComponent2(dir, options);
+});
 var block = program.command("block").description("Manage EDS blocks");
 block.command("create <name>").description("Scaffold a new EDS block (with Universal Editor model by default)").option("--no-ue-model", "Skip the Universal Editor model (generated by default)").action(async (name, options) => {
   const { createBlock: createBlock2 } = await Promise.resolve().then(() => (init_create(), create_exports));