aem-eds-kit 0.0.0-stage → 0.4.0

package/dist/bin/eds.js

@@ -0,0 +1,4214 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/lib/logger.ts
+import chalk from "chalk";
+function getLevel() {
+  const env = process.env.EDS_LOG_LEVEL?.toLowerCase();
+  if (env && env in LEVEL_ORDER) return env;
+  return "info";
+}
+function shouldLog(level) {
+  if (quiet) return level === "error";
+  return LEVEL_ORDER[level] >= LEVEL_ORDER[currentLevel];
+}
+var LEVEL_ORDER, currentLevel, quiet, logoShown, logger;
+var init_logger = __esm({
+  "src/lib/logger.ts"() {
+    "use strict";
+    init_esm_shims();
+    LEVEL_ORDER = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3,
+      silent: 4
+    };
+    currentLevel = getLevel();
+    quiet = false;
+    logoShown = false;
+    logger = {
+      setLevel(level) {
+        currentLevel = level;
+      },
+      setQuiet(q) {
+        quiet = q;
+      },
+      debug(...args) {
+        if (shouldLog("debug")) console.error(chalk.gray("[debug]"), ...args);
+      },
+      info(...args) {
+        if (shouldLog("info")) console.error(...args);
+      },
+      /**
+       * Print the brand logo at most once per process. The interactive menu and
+       * every command call this, so running a command directly shows the logo,
+       * while picking it from the menu (which already showed it) doesn't repeat it.
+       */
+      logoOnce(art) {
+        if (logoShown) return;
+        logoShown = true;
+        if (shouldLog("info")) console.error(art);
+      },
+      success(...args) {
+        if (shouldLog("info")) console.error(chalk.green("\u2713"), ...args);
+      },
+      warn(...args) {
+        if (shouldLog("warn")) console.error(chalk.yellow("\u26A0"), ...args);
+      },
+      error(...args) {
+        if (shouldLog("error")) console.error(chalk.red("\u2717"), ...args);
+      }
+    };
+  }
+});
+
+// src/lib/ui.ts
+import chalk2 from "chalk";
+function statusIcon(status) {
+  return icon[status];
+}
+function visibleLength(s) {
+  return s.replace(ANSI, "").length;
+}
+function padEndVisible(s, width) {
+  const pad = width - visibleLength(s);
+  return pad > 0 ? s + " ".repeat(pad) : s;
+}
+function mark() {
+  return chalk2.bgHex("#ff5a36").hex("#0d0d0c").bold(" >_ ");
+}
+function lockup() {
+  return `${mark()} ${chalk2.bold("aem-eds-kit")} ${chalk2.dim("by Piotr Godycki")}`;
+}
+function hexToRgb(hex) {
+  const h = hex.replace("#", "");
+  return [
+    Number.parseInt(h.slice(0, 2), 16),
+    Number.parseInt(h.slice(2, 4), 16),
+    Number.parseInt(h.slice(4, 6), 16)
+  ];
+}
+function mix(a, b, t) {
+  const [ar, ag, ab] = hexToRgb(a);
+  const [br, bg, bb] = hexToRgb(b);
+  const r = Math.round(ar + (br - ar) * t);
+  const g = Math.round(ag + (bg - ag) * t);
+  const bl = Math.round(ab + (bb - ab) * t);
+  return `#${[r, g, bl].map((n) => n.toString(16).padStart(2, "0")).join("")}`;
+}
+function gradientLine(line, stops, width) {
+  const chars = [...line];
+  const span = Math.max(width - 1, 1);
+  return chars.map((ch, i) => {
+    if (ch === " ") return ch;
+    const seg = i / span * (stops.length - 1);
+    const idx = Math.min(Math.floor(seg), stops.length - 2);
+    return chalk2.hex(mix(stops[idx], stops[idx + 1], seg - idx))(ch);
+  }).join("");
+}
+function logo(tagline = "AEM Edge Delivery \xD7 Figma") {
+  const width = columnWidth(LOGO_ART);
+  const art = LOGO_ART.map((row) => `  ${gradientLine(row, LOGO_STOPS, width)}`).join("\n");
+  const dots = Array.from({ length: 5 }, () => brand.accent("\u25CF")).join(" ");
+  return `
+${art}
+
+  ${lockup()}   ${dots}  ${chalk2.dim(tagline)}
+`;
+}
+function heading(title, subtitle) {
+  const bar = brand.red("\u258A");
+  const sub = subtitle ? ` ${chalk2.dim(subtitle)}` : "";
+  return `
+${bar} ${chalk2.bold(title)}${sub}
+`;
+}
+function statusLine(status, name, message, nameWidth = 0) {
+  const padded = nameWidth ? padEndVisible(name, nameWidth) : name;
+  const msg = message ? `  ${chalk2.dim(message)}` : "";
+  return `  ${icon[status]} ${padded}${msg}`;
+}
+function accentLine(name, message, nameWidth = 0) {
+  const padded = nameWidth ? padEndVisible(name, nameWidth) : name;
+  const msg = message ? `  ${chalk2.dim(message)}` : "";
+  return `  ${brand.accent("\u2714")} ${padded}${msg}`;
+}
+function columnWidth(items) {
+  return items.reduce((max, s) => Math.max(max, visibleLength(s)), 0);
+}
+function box(lines, accent = brand.red) {
+  const inner = columnWidth(lines);
+  const top = accent(`\u256D${"\u2500".repeat(inner + 2)}\u256E`);
+  const bot = accent(`\u2570${"\u2500".repeat(inner + 2)}\u256F`);
+  const body = lines.map((l) => `${accent("\u2502")} ${padEndVisible(l, inner)} ${accent("\u2502")}`).join("\n");
+  return `${top}
+${body}
+${bot}`;
+}
+function summary(counts) {
+  const parts = [];
+  if (counts.pass) parts.push(`${icon.pass} ${counts.pass} passed`);
+  if (counts.warn) parts.push(`${icon.warn} ${counts.warn} ${plural(counts.warn, "warning")}`);
+  if (counts.fail) parts.push(`${icon.fail} ${counts.fail} failed`);
+  if (counts.info) parts.push(`${icon.info} ${counts.info} info`);
+  return parts.join(chalk2.dim("   "));
+}
+function plural(n, word) {
+  return n === 1 ? word : `${word}s`;
+}
+var brand, icon, ANSI, LOGO_ART, LOGO_STOPS;
+var init_ui = __esm({
+  "src/lib/ui.ts"() {
+    "use strict";
+    init_esm_shims();
+    brand = {
+      // Warm sweep for the logo wordmark (red → ember → orange)
+      red: chalk2.hex("#FA0F00"),
+      ember: chalk2.hex("#FF4B1F"),
+      orange: chalk2.hex("#FF7B00"),
+      // Accent
+      blue: chalk2.hex("#2680EB"),
+      // Signature accent (matches the landing's `#FF5A36`)
+      accent: chalk2.hex("#ff5a36"),
+      // Five-colour dot mark (the CLI signature)
+      dotOrange: chalk2.hex("#F24E1E"),
+      dotPurple: chalk2.hex("#A259FF"),
+      dotBlue: chalk2.hex("#1ABCFE"),
+      dotGreen: chalk2.hex("#0ACF83"),
+      dotPink: chalk2.hex("#FF7262"),
+      // Semantic roles
+      ok: chalk2.hex("#2D9D78"),
+      warn: chalk2.hex("#E68619"),
+      err: chalk2.hex("#D7373F"),
+      info: chalk2.hex("#2680EB")
+    };
+    icon = {
+      pass: brand.ok("\u2713"),
+      warn: brand.warn("\u26A0"),
+      fail: brand.err("\u2717"),
+      info: brand.info("\u2139"),
+      bullet: chalk2.dim("\u2022"),
+      arrow: chalk2.dim("\u21B3"),
+      figma: brand.dotPurple("\u25C6")
+    };
+    ANSI = /\[[0-9;]*m/g;
+    LOGO_ART = [
+      "\u2588\u2588\u2588\u2588\u2588 \u2588\u2588\u2588\u2588  \u2588\u2588\u2588\u2588\u2588",
+      "\u2588     \u2588   \u2588 \u2588    ",
+      "\u2588\u2588\u2588\u2588  \u2588   \u2588 \u2588\u2588\u2588\u2588\u2588",
+      "\u2588     \u2588   \u2588     \u2588",
+      "\u2588\u2588\u2588\u2588\u2588 \u2588\u2588\u2588\u2588  \u2588\u2588\u2588\u2588\u2588"
+    ];
+    LOGO_STOPS = ["#ff3b1e", "#ff5a36", "#ff7d52"];
+  }
+});
+
+// src/lib/schemas.ts
+import { z } from "zod";
+var figmaUrlSchema, edsConfigSchema, edsProjectSchema, edsMetaSchema, kebabCaseRegex;
+var init_schemas = __esm({
+  "src/lib/schemas.ts"() {
+    "use strict";
+    init_esm_shims();
+    figmaUrlSchema = z.object({
+      fileKey: z.string().min(1),
+      nodeId: z.string().optional(),
+      fileName: z.string().optional()
+    });
+    edsConfigSchema = z.object({
+      agent: z.enum(["claude", "cursor", "codex"]).optional(),
+      figma: z.object({
+        mcpEndpoint: z.string().url().optional(),
+        token: z.string().optional()
+      }).optional(),
+      admin: z.object({
+        org: z.string().optional(),
+        site: z.string().optional(),
+        ref: z.string().default("main")
+      }).optional()
+    });
+    edsProjectSchema = z.object({
+      root: z.string(),
+      hasFstab: z.boolean(),
+      hasBlocks: z.boolean(),
+      hasHeadHtml: z.boolean()
+    });
+    edsMetaSchema = z.object({
+      figmaFileKey: z.string(),
+      figmaNodeId: z.string().optional(),
+      lastSyncedAt: z.string().datetime(),
+      promptVersion: z.string(),
+      agentUsed: z.string().optional()
+    });
+    kebabCaseRegex = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+  }
+});
+
+// src/lib/project.ts
+import { existsSync } from "fs";
+import path2 from "path";
+function findProjectRoot(startDir = process.cwd()) {
+  let dir = path2.resolve(startDir);
+  const { root } = path2.parse(dir);
+  while (dir !== root) {
+    if (existsSync(path2.join(dir, "fstab.yaml"))) {
+      return dir;
+    }
+    dir = path2.dirname(dir);
+  }
+  return void 0;
+}
+function detectProject(rootDir) {
+  return edsProjectSchema.parse({
+    root: rootDir,
+    hasFstab: existsSync(path2.join(rootDir, "fstab.yaml")),
+    hasBlocks: existsSync(path2.join(rootDir, "blocks")),
+    hasHeadHtml: existsSync(path2.join(rootDir, "head.html"))
+  });
+}
+var init_project = __esm({
+  "src/lib/project.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_schemas();
+  }
+});
+
+// src/commands/block/create.ts
+var create_exports = {};
+__export(create_exports, {
+  createBlock: () => createBlock,
+  ueModelFor: () => ueModelFor
+});
+import { existsSync as existsSync2 } from "fs";
+import { mkdir, writeFile } from "fs/promises";
+import path3 from "path";
+import chalk3 from "chalk";
+function titleCase(name) {
+  return name.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function ueModelFor(name) {
+  const title = titleCase(name);
+  const model = {
+    definitions: [
+      {
+        title,
+        id: name,
+        plugins: {
+          xwalk: {
+            page: {
+              resourceType: "core/franklin/components/block/v1/block",
+              template: { name: title, model: name }
+            }
+          }
+        }
+      }
+    ],
+    models: [
+      {
+        id: name,
+        // Starter fields showcasing good patterns (title+titleType collapse
+        // into a heading; richtext for body). Extend from the full catalog —
+        // see docs/universal-editor-fields.md.
+        fields: [
+          {
+            component: "text",
+            name: "title",
+            label: "Title",
+            valueType: "string"
+          },
+          {
+            component: "select",
+            name: "titleType",
+            label: "Title Type",
+            valueType: "string",
+            value: "h2",
+            options: [
+              { name: "H1", value: "h1" },
+              { name: "H2", value: "h2" },
+              { name: "H3", value: "h3" },
+              { name: "H4", value: "h4" }
+            ]
+          },
+          {
+            component: "richtext",
+            name: "text",
+            value: "",
+            label: "Text",
+            valueType: "string"
+          }
+        ]
+      }
+    ],
+    filters: []
+  };
+  return `${JSON.stringify(model, null, 2)}
+`;
+}
+async function createBlock(name, options = {}) {
+  if (!kebabCaseRegex.test(name)) {
+    logger.error(
+      `Invalid block name "${name}". Use kebab-case (e.g., "hero-banner", "card-list").`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    logger.error(
+      "Not inside an EDS project (no fstab.yaml found). Run this from your project root."
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const blocksDir = path3.join(projectRoot, "blocks", name);
+  if (existsSync2(blocksDir)) {
+    logger.error(`Block "${name}" already exists at ${blocksDir}`);
+    process.exitCode = 1;
+    return;
+  }
+  await mkdir(blocksDir, { recursive: true });
+  const jsContent = `export default function decorate(block) {
+  // TODO: implement ${name} block
+}
+`;
+  const cssContent = `.${name} {
+  /* TODO: style ${name} block */
+}
+`;
+  await writeFile(path3.join(blocksDir, `${name}.js`), jsContent);
+  await writeFile(path3.join(blocksDir, `${name}.css`), cssContent);
+  const withUe = options.ueModel !== false;
+  if (withUe) {
+    await writeFile(path3.join(blocksDir, `_${name}.json`), ueModelFor(name));
+  }
+  logger.success(
+    `Block "${name}" created at ${chalk3.cyan(path3.relative(projectRoot, blocksDir))}${withUe ? chalk3.dim(" (+ Universal Editor model)") : ""}`
+  );
+}
+var init_create = __esm({
+  "src/commands/block/create.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_project();
+    init_schemas();
+  }
+});
+
+// src/lib/agents/detect.ts
+import { existsSync as existsSync3 } from "fs";
+import { readFile } from "fs/promises";
+import { homedir } from "os";
+import path4 from "path";
+async function whichBinary(name) {
+  const { execaCommand } = await import("execa");
+  try {
+    const result = await execaCommand(`which ${name}`);
+    return result.stdout.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function findFigmaServerKey(node) {
+  if (!node || typeof node !== "object") return void 0;
+  const obj = node;
+  const servers = obj.mcpServers;
+  if (servers && typeof servers === "object") {
+    for (const key of Object.keys(servers)) {
+      if (key.toLowerCase().includes("figma")) return key;
+    }
+  }
+  for (const value of Object.values(obj)) {
+    const found = findFigmaServerKey(value);
+    if (found) return found;
+  }
+  return void 0;
+}
+async function findFigmaMcpServer(configPaths) {
+  for (const configPath of configPaths) {
+    try {
+      if (!existsSync3(configPath)) continue;
+      const content = await readFile(configPath, "utf-8");
+      try {
+        const key = findFigmaServerKey(JSON.parse(content));
+        if (key) return key;
+      } catch {
+      }
+      if (content.toLowerCase().includes("figma")) return "figma";
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function detectAgent(preferred) {
+  if (preferred) {
+    const def = AGENT_DEFS.find((d) => d.type === preferred);
+    if (def) {
+      const binPath = await whichBinary(def.binary);
+      if (binPath) {
+        const figmaMcpServerName = await findFigmaMcpServer(def.mcpConfigPaths);
+        return {
+          type: def.type,
+          path: binPath,
+          configDir: existsSync3(def.configDir) ? def.configDir : void 0,
+          hasFigmaMcp: !!figmaMcpServerName,
+          figmaMcpServerName
+        };
+      }
+      logger.warn(`Preferred agent "${preferred}" not found in PATH`);
+    }
+  }
+  for (const def of AGENT_DEFS) {
+    const binPath = await whichBinary(def.binary);
+    if (binPath) {
+      const figmaMcpServerName = await findFigmaMcpServer(def.mcpConfigPaths);
+      return {
+        type: def.type,
+        path: binPath,
+        configDir: existsSync3(def.configDir) ? def.configDir : void 0,
+        hasFigmaMcp: !!figmaMcpServerName,
+        figmaMcpServerName
+      };
+    }
+  }
+  return void 0;
+}
+async function detectAllAgents() {
+  const agents = [];
+  for (const def of AGENT_DEFS) {
+    const binPath = await whichBinary(def.binary);
+    if (binPath) {
+      const figmaMcpServerName = await findFigmaMcpServer(def.mcpConfigPaths);
+      agents.push({
+        type: def.type,
+        path: binPath,
+        configDir: existsSync3(def.configDir) ? def.configDir : void 0,
+        hasFigmaMcp: !!figmaMcpServerName,
+        figmaMcpServerName
+      });
+    }
+  }
+  return agents;
+}
+var AGENT_DEFS;
+var init_detect = __esm({
+  "src/lib/agents/detect.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    AGENT_DEFS = [
+      {
+        type: "claude",
+        binary: "claude",
+        configDir: path4.join(homedir(), ".claude"),
+        mcpConfigPaths: [
+          path4.join(homedir(), ".claude", "plugins.json"),
+          path4.join(homedir(), ".claude.json")
+        ]
+      },
+      {
+        type: "cursor",
+        binary: "cursor",
+        configDir: path4.join(homedir(), ".cursor"),
+        mcpConfigPaths: [path4.join(homedir(), ".cursor", "mcp.json")]
+      },
+      {
+        type: "codex",
+        binary: "codex",
+        configDir: path4.join(homedir(), ".codex"),
+        mcpConfigPaths: []
+      }
+    ];
+  }
+});
+
+// src/lib/agents/invoke.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir } from "os";
+import path5 from "path";
+import readline from "readline";
+import chalk4 from "chalk";
+async function savePromptToFile(prompt, projectRoot) {
+  const base = projectRoot ? path5.join(projectRoot, "tmp") : tmpdir();
+  const dir = path5.join(base, "eds-cli");
+  await mkdir2(dir, { recursive: true });
+  const filename = `from-design-${Date.now()}.md`;
+  const filePath = path5.join(dir, filename);
+  await writeFile2(filePath, prompt, "utf-8");
+  return filePath;
+}
+async function invokeAgent(agent, promptFile, cwd) {
+  const { execa } = await import("execa");
+  const prompt = await readFile2(promptFile, "utf-8");
+  try {
+    switch (agent.type) {
+      case "claude": {
+        logger.info(`Running Claude Code ${chalk4.dim("- live log:")}`);
+        const figmaServers = [
+          ...agent.figmaMcpServerName ? [agent.figmaMcpServerName] : [],
+          "figma-sse",
+          "figma-desktop",
+          "figma",
+          "Figma",
+          "plugin_figma_figma"
+          // Claude Code plugin: plugin:figma:figma
+        ];
+        const allowedTools = [
+          ...new Set(figmaServers.map((s) => `mcp__${s}`)),
+          "Edit",
+          "Write",
+          "Read"
+        ].join(",");
+        const sub = execa(
+          "claude",
+          [
+            "-p",
+            prompt,
+            "--output-format",
+            "stream-json",
+            "--verbose",
+            "--allowedTools",
+            allowedTools
+          ],
+          { cwd, buffer: false, stdio: ["ignore", "pipe", "inherit"] }
+        );
+        await renderClaudeStream(sub, cwd);
+        break;
+      }
+      case "cursor": {
+        logger.info("Running Cursor agent...");
+        await execa("cursor", ["--prompt", prompt], {
+          cwd,
+          stdio: "inherit"
+        });
+        break;
+      }
+      case "codex": {
+        logger.info("Running Codex...");
+        await execa("codex", [prompt], {
+          cwd,
+          stdio: "inherit"
+        });
+        break;
+      }
+    }
+    return true;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.error(`Agent ${agent.type} failed: ${msg}`);
+    return false;
+  }
+}
+function shortName(name) {
+  return name.includes("figma") ? name.split("__").pop() ?? name : name.toLowerCase();
+}
+async function renderClaudeStream(sub, cwd) {
+  const ora4 = (await import("ora")).default;
+  const start = Date.now();
+  const elapsed = () => `${Math.round((Date.now() - start) / 1e3)}s`;
+  const spinner = ora4({ text: `thinking  ${chalk4.dim(elapsed())}`, color: "yellow" }).start();
+  let activity = "thinking";
+  const timer = setInterval(() => {
+    spinner.text = `${activity}  ${chalk4.dim(elapsed())}`;
+  }, 300);
+  const pending = /* @__PURE__ */ new Map();
+  const emit = (line) => {
+    spinner.stop();
+    logger.info(`   ${line}`);
+    spinner.start();
+  };
+  let result;
+  try {
+    if (sub.stdout) {
+      const rl = readline.createInterface({ input: sub.stdout });
+      for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        let evt;
+        try {
+          evt = JSON.parse(trimmed);
+        } catch {
+          continue;
+        }
+        const content = Array.isArray(evt.message?.content) ? evt.message.content : [];
+        if (evt.type === "assistant") {
+          for (const block2 of content) {
+            if (block2.type === "text" && "text" in block2) {
+              const first = block2.text.trim().split("\n")[0].slice(0, 100);
+              if (first) emit(chalk4.dim(first));
+            } else if (block2.type === "tool_use" && "name" in block2) {
+              const id = "id" in block2 && block2.id ? block2.id : `${Math.random()}`;
+              pending.set(id, {
+                label: toolLabel(block2.name, block2.input, cwd),
+                start: Date.now()
+              });
+              activity = shortName(block2.name);
+            }
+          }
+        } else if (evt.type === "user") {
+          for (const block2 of content) {
+            if (block2.type === "tool_result" && "tool_use_id" in block2 && block2.tool_use_id) {
+              const p = pending.get(block2.tool_use_id);
+              if (p) {
+                const dur = `${((Date.now() - p.start) / 1e3).toFixed(1)}s`;
+                const failed = "is_error" in block2 && block2.is_error ? ` ${chalk4.red("failed")}` : "";
+                emit(`${p.label}  ${chalk4.dim(dur)}${failed}`);
+                pending.delete(block2.tool_use_id);
+              }
+            }
+          }
+        } else if (evt.type === "result") {
+          const dur = typeof evt.duration_ms === "number" ? `${(evt.duration_ms / 1e3).toFixed(1)}s` : "";
+          const cost = typeof evt.total_cost_usd === "number" ? `$${evt.total_cost_usd.toFixed(3)}` : "";
+          result = [dur, cost].filter(Boolean).join(" \xB7 ") || "done";
+        }
+      }
+    }
+    for (const p of pending.values()) emit(`${p.label}  ${chalk4.dim("\u2026")}`);
+    clearInterval(timer);
+    if (result) spinner.succeed(`${brand.accent("agent finished")}  ${chalk4.dim(result)}`);
+    else spinner.stop();
+  } catch (err) {
+    clearInterval(timer);
+    spinner.stop();
+    throw err;
+  }
+  await sub;
+}
+function toolLabel(name, input, cwd) {
+  const rel = (key) => {
+    const p = input?.[key];
+    if (typeof p !== "string") return "";
+    return p.startsWith(cwd) ? path5.relative(cwd, p) : path5.basename(p);
+  };
+  if (name.includes("figma")) {
+    const short = name.split("__").pop() ?? name;
+    return `${icon.figma} ${chalk4.bold(short)}  ${chalk4.dim("Figma MCP")}`;
+  }
+  switch (name) {
+    case "Write":
+    case "Edit":
+    case "NotebookEdit":
+      return `${brand.accent("\u270E")} ${chalk4.cyan(rel("file_path"))}`;
+    case "Read":
+      return chalk4.dim(`\xB7 read ${rel("file_path")}`);
+    case "Bash": {
+      const cmd = typeof input?.command === "string" ? input.command.split("\n")[0].slice(0, 70) : "";
+      return chalk4.dim(`$ ${cmd}`);
+    }
+    default:
+      return `${brand.blue("\u2192")} ${name}`;
+  }
+}
+var init_invoke = __esm({
+  "src/lib/agents/invoke.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_ui();
+  }
+});
+
+// src/lib/config.ts
+import { existsSync as existsSync4 } from "fs";
+import { readFile as readFile3 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import path6 from "path";
+async function loadJsonFile(filePath) {
+  try {
+    const content = await readFile3(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return void 0;
+  }
+}
+async function loadConfig(projectRoot) {
+  const globalRaw = await loadJsonFile(GLOBAL_CONFIG_PATH);
+  const projectRaw = projectRoot ? await loadJsonFile(path6.join(projectRoot, PROJECT_CONFIG_NAME)) : void 0;
+  const merged = {
+    ...typeof globalRaw === "object" && globalRaw !== null ? globalRaw : {},
+    ...typeof projectRaw === "object" && projectRaw !== null ? projectRaw : {}
+  };
+  const result = edsConfigSchema.safeParse(merged);
+  if (!result.success) {
+    logger.debug("Config validation issues:", result.error.flatten());
+    return edsConfigSchema.parse({});
+  }
+  return result.data;
+}
+function globalConfigDir() {
+  return GLOBAL_CONFIG_DIR;
+}
+function globalConfigPath() {
+  return GLOBAL_CONFIG_PATH;
+}
+function globalConfigExists() {
+  return existsSync4(GLOBAL_CONFIG_PATH);
+}
+var GLOBAL_CONFIG_DIR, GLOBAL_CONFIG_PATH, PROJECT_CONFIG_NAME;
+var init_config = __esm({
+  "src/lib/config.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_schemas();
+    GLOBAL_CONFIG_DIR = path6.join(homedir2(), ".eds");
+    GLOBAL_CONFIG_PATH = path6.join(GLOBAL_CONFIG_DIR, "config.json");
+    PROJECT_CONFIG_NAME = ".edsrc.json";
+  }
+});
+
+// src/lib/figma/node-id.ts
+function parseFigmaUrl(input) {
+  if (/^\d+[-:]\d+$/.test(input.trim())) {
+    throw new Error(
+      `Input "${input}" looks like a node-id but not a full URL. Provide a Figma URL or use --file-key.`
+    );
+  }
+  let url;
+  try {
+    url = new URL(input.trim());
+  } catch {
+    throw new Error(`Invalid Figma URL: "${input}"`);
+  }
+  if (!url.hostname.endsWith("figma.com")) {
+    throw new Error(`Not a Figma URL: "${input}"`);
+  }
+  const segments = url.pathname.split("/").filter(Boolean);
+  if (segments.length < 2) {
+    throw new Error(`Cannot extract fileKey from URL: "${input}"`);
+  }
+  const type = segments[0];
+  let fileKey;
+  let fileName;
+  if (segments[2] === "branch" && segments[3]) {
+    fileKey = segments[3];
+    fileName = segments[4] ? decodeURIComponent(segments[4]) : void 0;
+  } else {
+    fileKey = segments[1];
+    fileName = segments[2] ? decodeURIComponent(segments[2]) : void 0;
+  }
+  const rawNodeId = url.searchParams.get("node-id");
+  const nodeId = rawNodeId ? normalizeNodeId(rawNodeId) : void 0;
+  return { fileKey, nodeId, fileName };
+}
+function normalizeNodeId(nodeId) {
+  return decodeURIComponent(nodeId).replace(/-/g, ":");
+}
+var init_node_id = __esm({
+  "src/lib/figma/node-id.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/lib/figma/prompt-builder.ts
+import { existsSync as existsSync5 } from "fs";
+import { readFile as readFile4 } from "fs/promises";
+import path7 from "path";
+function contentSourceGuidance(source, cfHint, blockName) {
+  if (!source || source === "document" || source === "ue") return "";
+  const q = cfHint ? ` (model / persisted query: \`${cfHint}\`)` : "";
+  const gql = "`${window.location.origin}/graphql/execute.json/<project>/<query>;path=<cfPath>`";
+  if (source === "cf") {
+    return `
+## Content source: Content Fragment
+This block renders an AEM **Content Fragment**${q} - not inline-authored copy.
+- UE model: use an \`aem-content-fragment\` field (e.g. \`name: "fragment"\`) for the CF reference.
+- \`decorate(block)\` must be **async**: read the CF reference from the authored DOM (a link to \`/content/dam/...\`), fetch its fields through an AEM GraphQL **persisted query** (${gql}), then build the DOM from the returned fields.
+- Handle loading / empty / error states. Do not hardcode copy that the CF owns.
+- \`.${blockName}\` styling still follows the EDS conventions below.
+`;
+  }
+  return `
+## Content source: Mixed (Universal Editor + Content Fragment)
+This block mixes **two sources in one model and one \`decorate(block)\`**:
+- **Inline (UE-authored)** parts \u2192 normal fields (text / richtext / image / select) read straight from the authored DOM cells, with semantic collapsing.
+- **Content Fragment** part${q} \u2192 an \`aem-content-fragment\` field; \`decorate()\` is **async** and also fetches that CF via a GraphQL persisted query (${gql}) and renders its fields.
+- Field order in the model = cell order in the authored DOM. Read the inline cells by position; detect the CF reference by its \`/content/dam/\` link. Merge both into the final markup, and handle the CF loading/empty/error states.
+`;
+}
+async function buildPrompt(ctx) {
+  const tokensHint = await getTokensHint(ctx.projectRoot);
+  const contentSourceSection = contentSourceGuidance(ctx.contentSource, ctx.cfHint, ctx.blockName);
+  const withScreenshot = ctx.screenshot !== false;
+  const verifyStep = withScreenshot ? `## Step 5 \u2014 Pixel-Perfect Self-Verification (do not skip)
+After writing the files, **verify against the screenshot from Step 1**:
+1. Re-open the \`get_screenshot\` image and compare it to your implementation region by region.
+2. Check each axis: spacing, font sizes/weights/line-heights, colors, border-radius, shadows, alignment, and overall proportions.
+3. For every mismatch, adjust the CSS and re-check. Repeat until the rendered block is indistinguishable from the screenshot.
+4. Briefly state what you verified and any value you had to infer.` : `## Step 5 \u2014 Structural Self-Verification (do not skip)
+No screenshot was fetched (token-lean mode). Verify against the **exact values from \`get_design_context\`**:
+1. Re-check every extracted value (spacing, fonts, colors, radius, shadows, alignment) against your CSS.
+2. Fix any mismatch.
+3. Briefly state what you verified and any value you had to infer.`;
+  const provider = ctx.provider ?? "figma";
+  const providerName = PROVIDER_NAMES[provider];
+  const fetchSection = provider === "figma" ? `## Step 1 \u2014 Fetch the Design
+Call the Figma MCP tools for this selection:
+- \`get_design_context\` \u2014 structure, layout, measurements, text content
+- \`get_variable_defs\` \u2014 design tokens (variables) to map to CSS custom properties
+${withScreenshot ? "- `get_screenshot` \u2014 the ground-truth visual reference for Step 5. Request it at `maxDimension: 1024` (enough to verify; do not request larger)." : "- (screenshot skipped to save tokens \u2014 pass `excludeScreenshot: true` to `get_design_context`)"}
+
+**Token efficiency:** call each tool **once** for the target node only \u2014 don't re-fetch and don't walk sibling/parent nodes you don't need.${withScreenshot ? "" : " You will verify structurally against the `get_design_context` measurements, not a picture."}
+
+Target:
+- fileKey: \`${ctx.figma?.fileKey}\`
+${ctx.figma?.nodeId ? `- node: \`${ctx.figma.nodeId}\`` : "- (no node selected \u2014 use the full page)"}
+
+${ctx.figma?.nodeId ? `Use node ID \`${ctx.figma.nodeId}\` in file \`${ctx.figma.fileKey}\`.` : `Use file key \`${ctx.figma?.fileKey}\` (no specific node selected \u2014 analyze the full page or ask the user to select a frame).`}` : `## Step 1 \u2014 Fetch the Design
+Read the design from **${providerName}** through your ${providerName} MCP connection (use its design-context / inspect / screenshot tools). Design reference: \`${ctx.designRef ?? "(the selected design)"}\`.
+Extract the **exact** structure, layout, colours, typography, spacing, radius and effects \u2014 do not approximate.${withScreenshot ? " Capture a screenshot for the Step 5 pixel check." : " No screenshot (token-lean) \u2014 verify structurally against the extracted values."}
+
+**Token efficiency:** fetch once for the target only.`;
+  const ueModelSection = ctx.withUeModel ? `
+## Step 4b \u2014 Universal Editor Authoring (REQUIRED, not optional)
+Authors must be able to drop and edit this block in the Universal Editor, so generate its UE configuration **in the same pass** as the code.
+
+Create \`blocks/${ctx.blockName}/_${ctx.blockName}.json\` using the EDS block-plugin (xwalk) format with three top-level arrays:
+
+\`\`\`json
+{
+  "definitions": [
+    {
+      "title": "<Human Title>",
+      "id": "${ctx.blockName}",
+      "plugins": {
+        "xwalk": {
+          "page": {
+            "resourceType": "core/franklin/components/block/v1/block",
+            "template": { "name": "<Human Title>", "model": "${ctx.blockName}" }
+          }
+        }
+      }
+    }
+  ],
+  "models": [
+    { "id": "${ctx.blockName}", "fields": [ /* one field per authorable piece of content */ ] }
+  ],
+  "filters": []
+}
+\`\`\`
+
+Derive the **model fields from the Figma design**, not boilerplate. Pick the correct field \`component\` for each authorable element from the **full Universal Editor field catalog** (17 types) \u2014 do not default everything to text:
+
+| component | valueType | Use for |
+|---|---|---|
+| \`text\` | string | Single-line: titles, labels, alt text, short strings |
+| \`textarea\` | string | Multi-line plain text: descriptions, notes |
+| \`richtext\` | string | Formatted copy: body with bold/italic/lists/links |
+| \`reference\` | string | AEM asset (image/video/doc) from DAM. \`multi:true\` for many |
+| \`aem-content\` | any | Page link / URL / content path (content picker) |
+| \`aem-content-fragment\` | any | Content Fragment reference |
+| \`aem-experience-fragment\` | any | Experience Fragment reference |
+| \`aem-tag\` | string | Tag picker for categorization |
+| \`select\` | string | Single choice dropdown \u2014 **requires \`options\`** |
+| \`multiselect\` | string | Multiple choice (often \`name:"classes"\` \u2192 CSS variants) \u2014 **requires \`options\`** |
+| \`checkbox-group\` | string[] | Multiple independent toggles \u2014 **requires \`options\`** |
+| \`radio-group\` | string | Mutually exclusive choice \u2014 **requires \`options\`** |
+| \`boolean\` | boolean | Single on/off toggle |
+| \`number\` | number | Counts, limits (validation: \`numberMin\`/\`numberMax\`) |
+| \`date-time\` | date | Date/time picker |
+| \`container\` | any | Group nested \`fields\`; \`multi:true\` = repeatable items (cards/slides) |
+| \`tab\` | any | Organize the property panel into tabs (UI only, not data) |
+
+Rules:
+- Every field needs \`component\`, \`name\`, \`label\`. Include the enforced \`valueType\` from the table. Add \`value\` (default), \`description\`, \`required\`, \`condition\` (JSON Logic) where useful.
+- \`options\` format for select/multiselect/checkbox-group/radio-group: \`[{ "name": "Display", "value": "stored" }]\` (multiselect also supports grouped \`children\`).
+- **Semantic collapsing** \u2014 name paired fields so EDS collapses them into one element:
+  - \`image\` (reference) + \`imageAlt\` (text) \u2192 \`<picture><img alt="\u2026">\`
+  - \`link\` (aem-content) + \`linkText\` (text) + \`linkTitle\` (text) + \`linkType\` (text) \u2192 \`<a href title>text</a>\`
+  - \`title\` (text) + \`titleType\` (select h1\u2013h6) \u2192 \`<h2>title</h2>\` at the chosen level
+  - \`classes\` (multiselect) \u2192 values become CSS classes on the block root
+  - fields prefixed \`group_\` share one cell
+- Map Figma **text layers**: headings \u2192 \`title\`+\`titleType\`; body \u2192 \`richtext\`; short labels \u2192 \`text\`.
+- Map **image/media layers** \u2192 \`reference\` (+ \`imageAlt\`). **Links/CTAs** \u2192 \`link\`/\`linkText\`.
+- Map **component variants** \u2192 a \`multiselect\` named \`classes\` (or a \`select\`) whose options are the variant values (e.g. Theme dark/light, Layout centered) \u2192 CSS modifier classes on the block root. Keep JS/CSS variant handling in sync.
+- **Repeatable groups** (card lists, carousels, tabs): either a \`container\` field with \`multi:true\` and nested \`fields\`, or \u2014 for true child blocks \u2014 a container definition (\`template.filter\`) + an item definition (resourceType \`core/franklin/components/block/v1/block/item\`) + a matching \`filters\` entry.
+- Field \`name\`s must match what \`decorate()\` reads from the authored DOM. No underscores in names when using xwalk (except the \`group_\` grouping prefix).
+
+**Make multifields and dropdowns actually work \u2014 the config is only half; \`decorate()\` MUST consume every field:**
+- **Repeatable items** (cards, slides, accordion, list rows) \u2192 model them as a **container block**, not a flat model: (a) a container definition whose \`template\` has a \`"filter"\` (not \`"model"\`), (b) an **item** definition with \`"resourceType": "core/franklin/components/block/v1/block/item"\` and its own \`model\`, (c) a \`filters\` entry \`{ "id": "${ctx.blockName}", "components": ["${ctx.blockName}-item"] }\`. The authored block renders **one row per item** \u2014 \`decorate()\` MUST iterate them: \`[...block.children].forEach((row) => { /* build one card */ })\`. A flat model with no iteration = a block that only ever shows one item.
+- **Inline repeatable group** (e.g. 2\u20133 CTAs inside a hero) \u2192 a \`container\` field with \`"multi": true\` and nested \`fields\` (no child-block needed).
+- **Dropdowns**: a \`select\`/\`radio-group\` value arrives as a cell in the authored DOM \u2014 read it in \`decorate()\` and act on it (e.g. read \`titleType\` and swap the heading tag to \`h1..h6\`). A \`multiselect\` named \`classes\` is applied as CSS classes on the block root automatically \u2014 just write \`.${ctx.blockName}.<value>\` styles; any other \`multiselect\`/\`checkbox-group\` arrives as a CSV cell you parse.
+- **Self-check before finishing:** every field \`name\` in the model must be read by \`decorate()\` (or applied via \`classes\`). List each field and where the JS/CSS consumes it. Unconsumed fields = broken authoring.
+
+If the project uses a **single aggregated model file** (\`component-definition.json\` + \`component-models.json\` + \`component-filters.json\`) instead of per-block \`_${ctx.blockName}.json\`, detect that convention and add the block's definition/model/filter to those files instead (and register the block in the \`section\` filter). Prefer the per-block \`_${ctx.blockName}.json\` when neither exists. Full field reference and a repeatable-cards round-trip example: \`docs/universal-editor-fields.md\`.
+` : "";
+  return `# Pixel-Perfect EDS Block from ${providerName}
+
+## Task
+Generate an AEM Edge Delivery Services block named **\`${ctx.blockName}\`** that reproduces the ${providerName} design **1:1 \u2014 pixel perfect**. Exact spacing, colors, typography, and layout. Not "close enough" \u2014 identical.
+
+${fetchSection}
+
+## Step 2 \u2014 Extract Exact Values
+From the design data you fetched, record the **precise** values \u2014 do not approximate:
+1. **Layout**: Auto Layout direction, gap, padding, alignment \u2192 Flexbox/Grid with exact \`gap\`/\`padding\`
+2. **Spacing**: every margin/padding in px \u2014 convert to \`rem\` (\xF716) or reuse a matching project token
+3. **Colors**: exact hex / token for every fill, stroke, shadow \u2014 prefer bound variables over raw hex
+4. **Typography**: font-family, font-size, font-weight, line-height, letter-spacing per text layer. If the design uses a font **not already loaded by the project**, add it to the project's font pipeline (\`styles/fonts.css\` / \`loadFonts\` in \`scripts/scripts.js\`, or a \`<link>\` managed by EDS) \u2014 **never** \`@import\` or a third-party \`<link>\` inside the block CSS (it is render-blocking and fails the loading audit). Always declare a sensible fallback stack.
+5. **Dimensions**: fixed vs. fluid (\`Fill\`\u2192fluid, \`Hug\`\u2192auto, fixed px\u2192fixed) and border-radius
+6. **Effects**: box-shadow, blur, opacity, gradients \u2014 replicate exactly
+
+## Step 3 \u2014 Map to Semantic EDS Structure
+- Map layer names/roles to semantic HTML (\`<h1>\`/\`<h2>\` by text-style level, \`<p>\`, \`<a class="button">\`, \`<picture>\`, \`<figure>\`, \`<nav>\`\u2026)
+- A \`decorate(block)\` function receives a \`<div class="${ctx.blockName}">\` whose children are the **authored content** coming from the document (EDS block table rows \u2192 nested divs). Your job is to read that existing DOM and enhance/restructure it \u2014 **not** to hardcode copy.
+- Assume one row per logical content group; the first cell of each row holds the content. Normalize whatever markup EDS hands you.
+- Map Figma component **variant properties** to modifier classes on the block root (e.g. \`Theme=dark\` \u2192 \`.${ctx.blockName}.dark\`, \`Layout=centered\` \u2192 \`.${ctx.blockName}.centered\`). Read variants via metadata; handle each in CSS.
+- Follow any Figma **annotations** for behavior (autoplay, collapsed-by-default, load eagerly, truncation, tab order).
+
+## Step 4 \u2014 Generate Block Files
+
+Create these files in \`blocks/${ctx.blockName}/\`:
+
+### \`${ctx.blockName}.js\`
+\`\`\`javascript
+// EDS block: ${ctx.blockName}
+// Generated from Figma design
+export default function decorate(block) {
+  // - Vanilla JS only (no frameworks)
+  // - Read the authored children already inside \`block\`; restructure into semantic HTML
+  // - Add class names prefixed with "${ctx.blockName}-"
+  // - Wire interactions from Figma annotations (if any)
+  // - Eager-load above-fold images, lazy-load below-fold
+}
+\`\`\`
+
+### \`${ctx.blockName}.css\`
+\`\`\`css
+/* EDS block: ${ctx.blockName} */
+/* Map Figma design tokens to CSS custom properties; reuse project tokens below where they match */
+/* Mobile-first; exact values from Step 2 */
+\`\`\`
+${ueModelSection}${contentSourceSection}
+## Placeholders & assets \u2014 be visible before Universal Editor takes over
+Content images and copy come from **authoring** (the document / DAM via UE), not the repo. Do **not** ship design-tool CDN URLs (Figma / Google Stitch links are short-lived) and do **not** bundle content photos into the repo.
+- In \`decorate()\`, read the image/text from the authored DOM. When none is present yet, render a lightweight **placeholder** so the block is visible *before* an author sets the real content: an inline SVG data-URI grey box (or a CSS placeholder) at the correct \`aspect-ratio\`, and sensible placeholder copy.
+- Provide the mock for the preview in \`blocks/${ctx.blockName}/_${ctx.blockName}.preview.html\` (used by \`eds block preview\`). Keep placeholder copy there, not hardcoded in the block.
+- Only bundle genuinely **static, decorative** assets (e.g. a small icon) as an optimized inline/\`icons/\` **SVG**, referenced by project-relative path. Never bundle authorable content images.
+- Always set \`width\`/\`height\` or \`aspect-ratio\` to avoid CLS.
+
+${verifyStep}
+
+## EDS Block Conventions
+- **Full-width by default**: the block/section spans the **full viewport width** (full-bleed) \u2014 never a fixed or centered fixed-width box. Constrain only the *inner content* to a sensible \`max-width\` (centered) for line-length/readability, with fluid horizontal padding. The design frame's width (e.g. 1280px) is the content cap, not the section width.
+- **Mobile-first & fluid**: base styles target the smallest screen; layer breakpoints upward. The section must look right at any width, not only the design frame's.
+- **No frameworks**: vanilla JS and CSS only
+- **\`decorate(block)\`**: enhance the authored DOM; never inject hardcoded copy that should be authored
+- **Semantic HTML**: correct elements and heading hierarchy
+- **Class naming**: prefix all classes with the block name: \`.${ctx.blockName}-item\`, \`.${ctx.blockName}-title\`
+- **Loading strategy**: eager (above-fold/hero), lazy (below-fold/carousels), delayed (analytics)
+- **Images**: always \`alt\` (empty for decorative), \`<picture>\` with WebP where applicable
+- **Accessibility**: ARIA where needed, keyboard navigation, focus states matching the design
+- **Performance**: no heavy dependencies, minimal DOM work, CSS for animations
+${tokensHint}
+
+## Output Requirements
+1. All files in \`blocks/${ctx.blockName}/\`${ctx.withUeModel ? ` \u2014 JS, CSS **and** the Universal Editor model (\`_${ctx.blockName}.json\`)` : ""}
+2. Production-ready, Lighthouse-friendly (aim for 100), no \`console.log\`
+3. Brief inline comments only for non-obvious logic
+4. **Minimise chat output (save tokens):** write the files directly with your editing tools \u2014 do **not** paste the generated code back into the chat, and skip step-by-step narration. End with a **\u22643-line** summary: files created + any value you had to infer.
+5. Mobile-first CSS with breakpoints at 600px and 900px
+6. Prefer existing project tokens over new hardcoded values${ctx.withUeModel ? "\n7. UE model field `name`s must match what `decorate()` reads, and every Figma variant must appear as a select option wired to a CSS modifier" : ""}
+
+---
+*Prompt version: ${PROMPT_VERSION}*
+`;
+}
+async function getTokensHint(projectRoot) {
+  const stylesPath = path7.join(projectRoot, "styles", "styles.css");
+  if (!existsSync5(stylesPath)) return "";
+  try {
+    const css = await readFile4(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  ");
+    if (!props) return "";
+    return `
+## Existing Project Tokens
+The project already defines these CSS custom properties in \`styles/styles.css\`.
+Reuse them instead of hardcoding values:
+
+\`\`\`css
+:root {
+  ${props}
+}
+\`\`\`
+`;
+  } catch {
+    return "";
+  }
+}
+var PROMPT_VERSION, PROVIDER_NAMES;
+var init_prompt_builder = __esm({
+  "src/lib/figma/prompt-builder.ts"() {
+    "use strict";
+    init_esm_shims();
+    PROMPT_VERSION = "0.5.0";
+    PROVIDER_NAMES = {
+      figma: "Figma",
+      stitch: "Google Stitch",
+      canva: "Canva",
+      sketch: "Sketch"
+    };
+  }
+});
+
+// src/lib/preview/harness.ts
+function esc(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function buildInner(opts) {
+  const { blockName, sampleContent } = opts;
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<link rel="stylesheet" href="/blocks/${blockName}/${blockName}.css" />
+<style>*{box-sizing:border-box}html,body{margin:0;padding:0}</style>
+</head>
+<body>
+${sampleContent}
+<script type="module">
+  import decorate from '/blocks/${blockName}/${blockName}.js';
+  const block = document.querySelector('.${blockName}');
+  if (block) { try { decorate(block); } catch (e) { console.error('decorate() failed:', e); } }
+</script>
+<script>
+  // Live reload: refresh when eds detects a change to the block.
+  try { new EventSource('/__eds_events').onmessage = () => location.reload(); } catch (e) { /* no SSE */ }
+</script>
+</body>
+</html>`;
+}
+function buildOuter(opts) {
+  const { blockName, breakpoints, figmaUrl, frameRoute, placeholder } = opts;
+  const figmaBps = breakpoints.filter((b) => b.figma);
+  const def = (figmaBps.length ? figmaBps : breakpoints).reduce(
+    (m, b) => b.width > m.width ? b : m,
+    breakpoints[0]
+  );
+  const options = breakpoints.map(
+    (b) => `<option value="${b.width}"${b.width === def.width ? " selected" : ""}>${esc(b.label)}</option>`
+  ).join("\n      ");
+  const figmaLink = figmaUrl ? `<a class="figma-link" href="${esc(figmaUrl)}" target="_blank" rel="noopener">
+      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M15 3h6v6"/><path d="M10 14 21 3"/><path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"/></svg>
+      Open in Figma
+    </a>` : "";
+  const hint = placeholder ? `<span class="hint">placeholder content \u2014 add <code>blocks/${blockName}/_${blockName}.preview.html</code></span>` : "";
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>eds preview \u2014 ${esc(blockName)}</title>
+<style>
+  *{box-sizing:border-box}
+  html,body{margin:0;padding:0;background:#1f1f1f;color:#eaeaea;font-family:ui-sans-serif,-apple-system,"Segoe UI",sans-serif}
+  .bar{position:sticky;top:0;z-index:10;display:flex;gap:10px;align-items:center;flex-wrap:wrap;padding:12px 18px;font-size:13px;background:#141414;border-bottom:1px solid #333}
+  .bar .label{color:#8a8a8a;font-weight:600}
+  .bar .block{color:#e6e6e6;font-weight:700}
+  select#bp{appearance:none;cursor:pointer;color:#eaeaea;background:#232323;border:1px solid #3a3a3a;border-radius:8px;padding:7px 34px 7px 13px;font:inherit;font-size:12.5px;font-weight:600;background-image:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%238a8a8a' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpolyline points='6 9 12 15 18 9'/%3E%3C/svg%3E");background-repeat:no-repeat;background-position:right 10px center;background-size:14px}
+  select#bp:hover{border-color:#6a6a6a;background-color:#2e2e2e}
+  .hint{color:#8a8a8a;font-size:12px}
+  .hint code{color:#bdbdbd}
+  .figma-link{margin-left:auto;display:inline-flex;align-items:center;gap:7px;color:#cfcfcf;text-decoration:none;font-weight:600;font-size:12.5px;padding:7px 13px;border:1px solid #3a3a3a;border-radius:8px;background:#232323}
+  .figma-link svg{width:15px;height:15px}
+  .figma-link:hover{border-color:#6a6a6a;background:#2e2e2e;color:#fff}
+  .stage{padding:30px 28px;display:flex;justify-content:center;overflow-x:auto}
+  .device{position:relative;background:#fff;border:1px solid #000;transition:width .2s ease}
+  .device::before{content:attr(data-w) "px";position:absolute;top:-20px;left:0;font-size:11px;color:#8a8a8a;font-family:ui-monospace,Menlo,monospace}
+  iframe{display:block;width:100%;height:820px;border:0}
+</style>
+</head>
+<body>
+  <div class="bar">
+    <span class="label">Block</span><span class="block">${esc(blockName)}</span>
+    <label class="label" for="bp" style="margin-left:8px">Breakpoint</label>
+    <select id="bp">
+      ${options}
+      <option value="full">Full ca\u0142a szeroko\u015B\u0107</option>
+    </select>
+    ${hint}
+    ${figmaLink}
+  </div>
+  <div class="stage">
+    <div class="device" id="device" data-w="${def.width}" style="width:${def.width}px">
+      <iframe id="frame" src="${frameRoute}" title="${esc(blockName)} preview"></iframe>
+    </div>
+  </div>
+  <script>
+    const device = document.getElementById('device');
+    const bp = document.getElementById('bp');
+    function setWidth(w){
+      if(w==='full'){device.style.width='100%';device.dataset.w=Math.round(device.getBoundingClientRect().width);}
+      else{device.style.width=w+'px';device.dataset.w=w;}
+    }
+    bp.addEventListener('change',()=>setWidth(bp.value==='full'?'full':Number(bp.value)));
+    setWidth(Number(bp.value));
+  </script>
+</body>
+</html>`;
+}
+var init_harness = __esm({
+  "src/lib/preview/harness.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/lib/preview/server.ts
+import { createReadStream, existsSync as existsSync6, statSync } from "fs";
+import http from "http";
+import path8 from "path";
+function startServer(root, routes, port, host = "127.0.0.1") {
+  const resolvedRoot = path8.resolve(root);
+  const clients = /* @__PURE__ */ new Set();
+  const server = http.createServer((req, res) => {
+    const urlPath = decodeURIComponent((req.url ?? "/").split("?")[0]);
+    if (urlPath === PING_ROUTE) {
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(JSON.stringify({ eds: true }));
+      return;
+    }
+    if (urlPath === EVENTS_ROUTE) {
+      res.writeHead(200, {
+        "content-type": "text/event-stream",
+        "cache-control": "no-cache",
+        connection: "keep-alive"
+      });
+      res.write(": connected\n\n");
+      clients.add(res);
+      req.on("close", () => clients.delete(res));
+      return;
+    }
+    const route = routes[urlPath];
+    if (route) {
+      res.writeHead(200, { "content-type": route.type });
+      res.end(route.body);
+      return;
+    }
+    const filePath = path8.join(resolvedRoot, urlPath);
+    if (!filePath.startsWith(resolvedRoot)) {
+      res.writeHead(403);
+      res.end("Forbidden");
+      return;
+    }
+    if (!existsSync6(filePath) || !statSync(filePath).isFile()) {
+      res.writeHead(404, { "content-type": "text/plain" });
+      res.end(`Not found: ${urlPath}`);
+      return;
+    }
+    res.writeHead(200, {
+      "content-type": MIME[path8.extname(filePath).toLowerCase()] ?? "application/octet-stream"
+    });
+    createReadStream(filePath).pipe(res);
+  });
+  return new Promise((resolve, reject) => {
+    let attempts = 0;
+    const tryListen = (p) => {
+      server.once("error", (err) => {
+        if (err.code === "EADDRINUSE" && attempts < 10) {
+          attempts++;
+          tryListen(p + 1);
+        } else {
+          reject(err);
+        }
+      });
+      server.listen(p, host, () => {
+        resolve({
+          url: `http://${host}:${p}/`,
+          port: p,
+          reload: () => {
+            for (const c of clients) c.write("data: reload\n\n");
+          },
+          close: () => new Promise((res) => {
+            for (const c of clients) c.end();
+            server.close(() => res());
+          })
+        });
+      });
+    };
+    tryListen(port);
+  });
+}
+var MIME, PING_ROUTE, EVENTS_ROUTE;
+var init_server = __esm({
+  "src/lib/preview/server.ts"() {
+    "use strict";
+    init_esm_shims();
+    MIME = {
+      ".html": "text/html; charset=utf-8",
+      ".js": "text/javascript; charset=utf-8",
+      ".mjs": "text/javascript; charset=utf-8",
+      ".css": "text/css; charset=utf-8",
+      ".json": "application/json; charset=utf-8",
+      ".svg": "image/svg+xml",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".webp": "image/webp",
+      ".gif": "image/gif",
+      ".avif": "image/avif",
+      ".woff": "font/woff",
+      ".woff2": "font/woff2",
+      ".ico": "image/x-icon"
+    };
+    PING_ROUTE = "/__eds_ping";
+    EVENTS_ROUTE = "/__eds_events";
+  }
+});
+
+// src/commands/block/preview.ts
+var preview_exports = {};
+__export(preview_exports, {
+  previewBlock: () => previewBlock
+});
+import { existsSync as existsSync7, watch } from "fs";
+import { readFile as readFile5 } from "fs/promises";
+import path9 from "path";
+import chalk5 from "chalk";
+function labelFor(width) {
+  if (width <= 480) return `${width} mobile`;
+  if (width <= 1024) return `${width} tablet`;
+  return `${width} desktop`;
+}
+function resolveBreakpoints(widthsFlag, meta) {
+  if (widthsFlag) {
+    const widths = widthsFlag.split(",").map((w) => Number.parseInt(w.trim(), 10)).filter((w) => Number.isFinite(w) && w > 0);
+    if (widths.length) return widths.map((w) => ({ width: w, label: labelFor(w), figma: false }));
+  }
+  const metaBps = meta?.breakpoints;
+  if (Array.isArray(metaBps) && metaBps.length) {
+    return metaBps.map((b) => ({
+      width: Number(b.width),
+      label: typeof b.label === "string" ? b.label : labelFor(Number(b.width)),
+      figma: b.source === "figma"
+    })).filter((b) => Number.isFinite(b.width) && b.width > 0);
+  }
+  return DEFAULT_WIDTHS.map((w) => ({ width: w, label: labelFor(w), figma: false }));
+}
+function figmaUrlFromMeta(meta) {
+  if (!meta?.figmaFileKey || typeof meta.figmaFileKey !== "string") return void 0;
+  const node = typeof meta.figmaNodeId === "string" ? meta.figmaNodeId.replace(":", "-") : void 0;
+  const base = `https://www.figma.com/design/${meta.figmaFileKey}/preview`;
+  return node ? `${base}?node-id=${node}` : base;
+}
+function defaultSample(blockName) {
+  return `<div class="${blockName} block">
+  <div><div>
+    <h2>${blockName} heading</h2>
+    <p>Sample body copy for the preview. Replace with real authored content.</p>
+    <p><a href="#">Primary action</a></p>
+    <p><a href="#">Secondary action</a></p>
+  </div></div>
+</div>`;
+}
+async function openInBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  try {
+    const { execa } = await import("execa");
+    await execa(cmd, [url], { stdio: "ignore", shell: process.platform === "win32" });
+  } catch {
+  }
+}
+async function previewBlock(name, options = {}) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    logger.error("Not inside an EDS project (no fstab.yaml found).");
+    process.exitCode = 1;
+    return;
+  }
+  const blockDir = path9.join(projectRoot, "blocks", name);
+  if (!existsSync7(blockDir)) {
+    logger.error(`Block "${name}" not found at blocks/${name}/.`);
+    process.exitCode = 1;
+    return;
+  }
+  if (!existsSync7(path9.join(blockDir, `${name}.css`)) && !existsSync7(path9.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 = path9.join(blockDir, ".eds-meta.json");
+  if (existsSync7(metaPath)) {
+    try {
+      meta = JSON.parse(await readFile5(metaPath, "utf-8"));
+    } catch {
+    }
+  }
+  const samplePath = path9.join(blockDir, `_${name}.preview.html`);
+  let sampleContent;
+  let placeholder = false;
+  if (existsSync7(samplePath)) {
+    sampleContent = await readFile5(samplePath, "utf-8");
+  } else {
+    sampleContent = defaultSample(name);
+    placeholder = true;
+  }
+  const breakpoints = resolveBreakpoints(options.widths, meta);
+  const figmaUrl = figmaUrlFromMeta(meta);
+  const frameRoute = "/__eds_preview_frame";
+  const inner = buildInner({ blockName: name, breakpoints, sampleContent, frameRoute });
+  const outer = buildOuter({
+    blockName: name,
+    breakpoints,
+    sampleContent,
+    figmaUrl,
+    frameRoute,
+    placeholder
+  });
+  const port = Number.parseInt(options.port ?? "8777", 10);
+  const server = await startServer(
+    projectRoot,
+    {
+      "/": { body: outer, type: "text/html; charset=utf-8" },
+      [frameRoute]: { body: inner, type: "text/html; charset=utf-8" }
+    },
+    Number.isFinite(port) ? port : 8777
+  );
+  logger.logoOnce(logo(`Preview \u2014 ${name}`));
+  logger.info(heading("Live preview", server.url));
+  logger.info(
+    statusLine(
+      "pass",
+      "breakpoints",
+      `${breakpoints.map((b) => `${b.width}${b.figma ? "\u2713" : ""}`).join(", ")}, Full`
+    )
+  );
+  if (placeholder) {
+    logger.info(
+      statusLine(
+        "warn",
+        "content",
+        `placeholder \u2014 add blocks/${name}/_${name}.preview.html for real content`
+      )
+    );
+  }
+  let reloadTimer;
+  const watcher = watch(blockDir, { recursive: true }, () => {
+    clearTimeout(reloadTimer);
+    reloadTimer = setTimeout(() => server.reload(), 150);
+  });
+  logger.info("");
+  logger.info(`  ${chalk5.bold("\u279C")}  ${chalk5.cyan(server.url)}`);
+  logger.info(statusLine("pass", "live reload", "edits to the block refresh the browser"));
+  logger.info(chalk5.dim("  Press Ctrl+C to stop.\n"));
+  if (options.open !== false) await openInBrowser(server.url);
+  const stop = async () => {
+    watcher.close();
+    await server.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", stop);
+  process.on("SIGTERM", stop);
+}
+var DEFAULT_WIDTHS;
+var init_preview = __esm({
+  "src/commands/block/preview.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_harness();
+    init_server();
+    init_project();
+    init_ui();
+    DEFAULT_WIDTHS = [375, 768, 1280];
+  }
+});
+
+// src/commands/block/from-design.ts
+var from_design_exports = {};
+__export(from_design_exports, {
+  blockFromDesign: () => blockFromDesign
+});
+import { existsSync as existsSync8 } from "fs";
+import { readFile as readFile6, writeFile as writeFile3 } from "fs/promises";
+import path10 from "path";
+import chalk6 from "chalk";
+import ora from "ora";
+async function previewRunning(port = 8777) {
+  try {
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), 400);
+    const res = await fetch(`http://127.0.0.1:${port}/__eds_ping`, { signal: ctrl.signal });
+    clearTimeout(t);
+    if (!res.ok) return false;
+    const data = await res.json();
+    return data?.eds === true;
+  } catch {
+    return false;
+  }
+}
+async function runWizard(figmaUrl) {
+  const { input, select, confirm } = await import("@inquirer/prompts");
+  const provider = await select({
+    message: "1/7  Design source",
+    choices: [
+      { name: "Figma", value: "figma" },
+      { name: "Google Stitch", value: "stitch" },
+      { name: "Canva", value: "canva" },
+      { name: "Sketch", value: "sketch" }
+    ],
+    default: "figma"
+  });
+  const name = await input({
+    message: "2/7  Component name",
+    validate: (v) => kebabCaseRegex.test(v.trim()) || "Use kebab-case, e.g. hero-banner"
+  });
+  const url = figmaUrl ?? await input({
+    message: `3/7  ${PROVIDER_NAMES[provider]} link`,
+    validate: (v) => {
+      if (!v.trim()) return "Paste the design link";
+      if (provider !== "figma") return true;
+      try {
+        parseFigmaUrl(v.trim());
+        return true;
+      } catch (err) {
+        return err.message;
+      }
+    }
+  });
+  const source = await select({
+    message: "4/7  Where does the content come from?",
+    choices: [
+      { name: "Document authoring (default EDS)", value: "document" },
+      { name: "Universal Editor", value: "ue" },
+      { name: "Content Fragment", value: "cf" },
+      { name: "Mixed - Universal Editor + Content Fragment", value: "mixed" }
+    ],
+    default: "document"
+  });
+  let cfHint;
+  if (source === "cf" || source === "mixed") {
+    const hint = await input({
+      message: "     CF model / GraphQL persisted-query name (optional)"
+    });
+    cfHint = hint.trim() || void 0;
+  }
+  const ueModel = await confirm({
+    message: "5/7  Generate the Universal Editor model?",
+    default: true
+  });
+  const screenshot = await confirm({
+    message: "6/7  Fetch a screenshot for a pixel-perfect check? (off = fewer tokens)",
+    default: true
+  });
+  const agents = await detectAllAgents();
+  const runMode = await select({
+    message: "7/7  Run with",
+    choices: [
+      ...agents.map((a) => ({
+        name: `${a.type}${provider === "figma" && !a.hasFigmaMcp ? " (Figma MCP not detected)" : ""}`,
+        value: `agent:${a.type}`
+      })),
+      { name: "Preview the prompt only (--dry-run)", value: "dry-run" },
+      { name: "Save the prompt, run it later (--agent none)", value: "none" }
+    ],
+    default: agents[0] ? `agent:${agents[0].type}` : "dry-run"
+  });
+  const sourceLabel = PROVIDER_NAMES[provider].toLowerCase();
+  logger.info(heading("Summary"));
+  const w = columnWidth(["component", sourceLabel, "content", "ue model", "screenshot", "run"]);
+  logger.info(accentLine("component", name, w));
+  const designRef = provider === "figma" ? (() => {
+    const parsed = parseFigmaUrl(url.trim());
+    return parsed.nodeId ? `node ${parsed.nodeId}` : parsed.fileKey;
+  })() : url.trim();
+  logger.info(accentLine(sourceLabel, designRef, w));
+  logger.info(accentLine("content", source + (cfHint ? ` (${cfHint})` : ""), w));
+  logger.info(accentLine("ue model", ueModel ? "yes" : "no", w));
+  logger.info(accentLine("screenshot", screenshot ? "yes" : "no (token-lean)", w));
+  logger.info(accentLine("run", runMode.replace("agent:", ""), w));
+  logger.info("");
+  const go = await confirm({ message: "Generate this block?", default: true });
+  if (!go) return null;
+  const opts = {
+    figmaUrl: url.trim(),
+    name,
+    provider,
+    source,
+    cfHint,
+    ueModel,
+    screenshot
+  };
+  if (runMode === "dry-run") opts.dryRun = true;
+  else if (runMode === "none") opts.agent = "none";
+  else {
+    opts.agent = runMode.replace("agent:", "");
+    opts.yes = true;
+  }
+  return opts;
+}
+function inferBlockName(fileName) {
+  if (!fileName) return "design-block";
+  return fileName.replace(/[-_\s]+/g, "-").replace(/[^a-z0-9-]/gi, "").toLowerCase().replace(/^-+|-+$/g, "") || "design-block";
+}
+async function blockFromDesign(figmaUrlArg, optionsArg) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    logger.error(
+      "Not inside an EDS project (no fstab.yaml found). Run this from your project root."
+    );
+    process.exitCode = 1;
+    return;
+  }
+  logger.logoOnce(logo("Design \u2192 EDS block"));
+  let designUrl = figmaUrlArg;
+  let options = optionsArg;
+  if (!designUrl) {
+    const wiz = await runWizard(designUrl);
+    if (!wiz) {
+      logger.info("Cancelled.");
+      return;
+    }
+    designUrl = wiz.figmaUrl;
+    options = { ...options, ...wiz };
+  }
+  const provider = options.provider ?? "figma";
+  const providerName = PROVIDER_NAMES[provider];
+  let figma2 = null;
+  const designRef = designUrl;
+  if (provider === "figma") {
+    const spinner = ora("Parsing Figma URL...").start();
+    try {
+      figma2 = parseFigmaUrl(designUrl);
+      spinner.succeed(
+        `Parsed Figma URL  ${chalk6.dim(figma2.nodeId ? `node ${figma2.nodeId}` : `file ${figma2.fileKey}`)}`
+      );
+    } catch (err) {
+      spinner.fail(err.message);
+      process.exitCode = 1;
+      return;
+    }
+  } else {
+    logger.info(`  ${icon.pass} ${providerName} design  ${chalk6.dim(designRef)}`);
+  }
+  const blockName = options.name || (figma2 ? inferBlockName(figma2.fileName) : "");
+  if (!kebabCaseRegex.test(blockName)) {
+    logger.error(
+      `Invalid block name "${blockName}". Use --name with a kebab-case name (e.g., --name hero-banner).`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const promptSpinner = ora("Reading design tokens & building prompt...").start();
+  const prompt = await buildPrompt({
+    provider,
+    figma: figma2,
+    designRef,
+    blockName,
+    projectRoot,
+    withUeModel: options.ueModel !== false,
+    contentSource: options.source ?? "document",
+    cfHint: options.cfHint,
+    screenshot: options.screenshot !== false
+  });
+  const promptFile = await savePromptToFile(prompt, projectRoot);
+  const hasTokens = existsSync8(path10.join(projectRoot, "styles", "styles.css"));
+  promptSpinner.succeed(
+    hasTokens ? `Loaded design tokens  ${chalk6.dim("styles/styles.css")}` : `Built prompt  ${chalk6.dim("no project tokens found")}`
+  );
+  logger.info(chalk6.dim(`  prompt \u2192 ${promptFile}`));
+  if (options.dryRun) {
+    logger.info("");
+    logger.info(chalk6.yellow("Dry run mode \u2014 prompt generated but agent not invoked."));
+    logger.info(`Prompt file: ${chalk6.cyan(promptFile)}`);
+    logger.info(`Block name:  ${chalk6.cyan(blockName)}`);
+    logger.info(`Prompt version: ${PROMPT_VERSION}`);
+    logger.info("");
+    logger.info("Preview:");
+    logger.info(chalk6.dim("\u2500".repeat(60)));
+    console.log(prompt);
+    return;
+  }
+  const config = await loadConfig(projectRoot);
+  const preferredAgent = options.agent || config.agent;
+  if (options.agent === "none") {
+    logger.info("Agent skipped (--agent none). Use the prompt file manually:");
+    logger.info(`  ${chalk6.cyan(promptFile)}`);
+    return;
+  }
+  const agentSpinner = ora("Detecting AI agent...").start();
+  const agent = await detectAgent(preferredAgent);
+  if (!agent) {
+    agentSpinner.fail("No AI agent found (claude, cursor, or codex).");
+    logger.info(`Install Claude Code: ${chalk6.cyan("npm install -g @anthropic-ai/claude-code")}`);
+    logger.info(`Or use the prompt file manually: ${chalk6.cyan(promptFile)}`);
+    process.exitCode = 1;
+    return;
+  }
+  agentSpinner.succeed(`Agent ready  ${chalk6.cyan(agent.type)}  ${chalk6.dim(agent.path)}`);
+  if (provider === "figma" && !agent.hasFigmaMcp) {
+    logger.warn(`Figma MCP may not be configured for ${agent.type}.`);
+    logger.info(`Run ${chalk6.cyan("eds figma setup")} to configure it.`);
+  }
+  if (!options.yes) {
+    const { confirm } = await import("@inquirer/prompts");
+    const proceed = await confirm({
+      message: `Run ${agent.type} with the generated prompt?`,
+      default: true
+    });
+    if (!proceed) {
+      logger.info(`Prompt saved to: ${chalk6.cyan(promptFile)}`);
+      return;
+    }
+  }
+  logger.info(
+    `  ${chalk6.dim("\u2192")} Handing off to ${chalk6.cyan(agent.type)}  ${chalk6.dim(`via ${providerName} MCP`)}`
+  );
+  if (provider === "figma") {
+    logger.info(chalk6.dim("     get_design_context \xB7 get_variable_defs \xB7 get_screenshot"));
+  }
+  const success = await invokeAgent(agent, promptFile, projectRoot);
+  if (!success) {
+    process.exitCode = 1;
+    return;
+  }
+  const blockDir = path10.join(projectRoot, "blocks", blockName);
+  const ok = await verifyGeneratedBlock(blockDir, blockName, options.ueModel !== false);
+  if (existsSync8(blockDir)) {
+    const meta = {
+      provider,
+      designRef,
+      figmaFileKey: figma2?.fileKey ?? null,
+      figmaNodeId: figma2?.nodeId ?? null,
+      lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      promptVersion: PROMPT_VERSION,
+      agentUsed: agent.type
+    };
+    await writeFile3(path10.join(blockDir, ".eds-meta.json"), `${JSON.stringify(meta, null, 2)}
+`);
+  }
+  if (!ok) {
+    logger.warn(
+      `Block "${blockName}" generated with issues \u2014 review the output above before publishing.`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  logger.success(`Block "${blockName}" generation complete.`);
+  if (options.serve !== false) {
+    if (await previewRunning()) {
+      logger.info(
+        chalk6.dim(
+          "  A preview server is already running at http://127.0.0.1:8777 \u2014 your change will refresh there."
+        )
+      );
+    } else {
+      logger.info("");
+      const { previewBlock: previewBlock2 } = await Promise.resolve().then(() => (init_preview(), preview_exports));
+      await previewBlock2(blockName, {});
+    }
+  } else {
+    logger.info(`  ${chalk6.dim("\u2192")} Next:  ${chalk6.cyan(`eds block preview ${blockName}`)}`);
+  }
+}
+async function verifyGeneratedBlock(blockDir, blockName, withUeModel) {
+  const checks = [];
+  const jsPath = path10.join(blockDir, `${blockName}.js`);
+  const cssPath = path10.join(blockDir, `${blockName}.css`);
+  const hasJs = existsSync8(jsPath);
+  const hasCss = existsSync8(cssPath);
+  checks.push({
+    status: hasJs ? "pass" : "fail",
+    name: `${blockName}.js`,
+    message: hasJs ? "created" : "missing \u2014 agent did not write the JS file"
+  });
+  checks.push({
+    status: hasCss ? "pass" : "fail",
+    name: `${blockName}.css`,
+    message: hasCss ? "created" : "missing \u2014 agent did not write the CSS file"
+  });
+  if (hasJs) {
+    const js = await readFile6(jsPath, "utf-8");
+    checks.push({
+      status: /export\s+default/.test(js) ? "pass" : "fail",
+      name: "decorate export",
+      message: /export\s+default/.test(js) ? "found" : "no default export \u2014 block won't load"
+    });
+    if (js.includes("console.log")) {
+      checks.push({
+        status: "warn",
+        name: "no console.log",
+        message: "found console.log \u2014 remove before production"
+      });
+    }
+  }
+  if (hasCss) {
+    const css = await readFile6(cssPath, "utf-8");
+    checks.push({
+      status: css.includes(`.${blockName}`) ? "pass" : "warn",
+      name: "scoped CSS",
+      message: css.includes(`.${blockName}`) ? `scoped to .${blockName}` : `no .${blockName} selector \u2014 styles may leak`
+    });
+  }
+  if (withUeModel) {
+    const hasPerBlock = existsSync8(path10.join(blockDir, `_${blockName}.json`));
+    const modelsFile = path10.join(blockDir, "..", "..", "component-models.json");
+    let hasAggregated = false;
+    if (!hasPerBlock && existsSync8(modelsFile)) {
+      try {
+        hasAggregated = (await readFile6(modelsFile, "utf-8")).includes(`"${blockName}"`);
+      } catch {
+      }
+    }
+    const hasModel = hasPerBlock || hasAggregated;
+    checks.push({
+      status: hasModel ? "pass" : "warn",
+      name: "Universal Editor model",
+      message: hasModel ? hasPerBlock ? `_${blockName}.json created` : "added to component-models.json" : `missing \u2014 no _${blockName}.json (run with default UE generation, or --no-ue-model to skip)`
+    });
+    if (hasPerBlock && hasJs) {
+      try {
+        const modelRaw = await readFile6(path10.join(blockDir, `_${blockName}.json`), "utf-8");
+        const js = await readFile6(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) {
+          checks.push({
+            status: iterates ? "pass" : "warn",
+            name: "multifield wired",
+            message: iterates ? "decorate() iterates items" : "repeatable model but decorate() never iterates block.children \u2014 only one item will render"
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  logger.info(heading("Verification"));
+  const nameWidth = columnWidth(checks.map((c) => c.name));
+  for (const c of checks) {
+    logger.info(statusLine(c.status, c.name, c.message, nameWidth));
+  }
+  logger.info("");
+  return !checks.some((c) => c.status === "fail");
+}
+var init_from_design = __esm({
+  "src/commands/block/from-design.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_detect();
+    init_invoke();
+    init_config();
+    init_node_id();
+    init_prompt_builder();
+    init_logger();
+    init_project();
+    init_schemas();
+    init_ui();
+  }
+});
+
+// src/commands/block/list.ts
+var list_exports = {};
+__export(list_exports, {
+  listBlocks: () => listBlocks
+});
+import { existsSync as existsSync9 } from "fs";
+import { readFile as readFile7, readdir } from "fs/promises";
+import path11 from "path";
+import chalk7 from "chalk";
+async function listBlocks(options = {}) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    logger.error("Not inside an EDS project (no fstab.yaml found).");
+    process.exitCode = 1;
+    return;
+  }
+  const blocksDir = path11.join(projectRoot, "blocks");
+  if (!existsSync9(blocksDir)) {
+    logger.info("No blocks/ directory found.");
+    return;
+  }
+  const entries = await readdir(blocksDir, { withFileTypes: true });
+  const blocks = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const name = entry.name;
+    const blockDir = path11.join(blocksDir, name);
+    const info = {
+      name,
+      hasJs: existsSync9(path11.join(blockDir, `${name}.js`)),
+      hasCss: existsSync9(path11.join(blockDir, `${name}.css`)),
+      hasUeModel: existsSync9(path11.join(blockDir, `_${name}.json`))
+    };
+    const metaFile = path11.join(blockDir, ".eds-meta.json");
+    if (existsSync9(metaFile)) {
+      try {
+        const meta = JSON.parse(await readFile7(metaFile, "utf-8"));
+        info.figmaSource = {
+          fileKey: meta.figmaFileKey,
+          nodeId: meta.figmaNodeId,
+          lastSyncedAt: meta.lastSyncedAt
+        };
+      } catch {
+      }
+    }
+    blocks.push(info);
+  }
+  if (options.json) {
+    console.log(JSON.stringify(blocks, null, 2));
+    return;
+  }
+  if (blocks.length === 0) {
+    logger.info("No blocks found.");
+    return;
+  }
+  logger.info(heading("Blocks", `${blocks.length} in project`));
+  const nameWidth = columnWidth(blocks.map((b) => b.name));
+  for (const b of blocks) {
+    const badges = [
+      b.hasJs ? brand.ok("js") : chalk7.dim.strikethrough("js"),
+      b.hasCss ? brand.ok("css") : chalk7.dim.strikethrough("css")
+    ];
+    if (b.hasUeModel) badges.push(brand.blue("ue-model"));
+    if (b.figmaSource) badges.push(`${icon.figma} ${brand.dotPurple("figma")}`);
+    const name = padEndVisible(chalk7.bold(b.name), nameWidth);
+    logger.info(`  ${name}  ${chalk7.dim("[")}${badges.join(" ")}${chalk7.dim("]")}`);
+    if (b.figmaSource) {
+      const synced = new Date(b.figmaSource.lastSyncedAt).toLocaleDateString();
+      logger.info(
+        `  ${" ".repeat(nameWidth)}  ${icon.arrow} ${chalk7.dim(
+          `figma:${b.figmaSource.fileKey} \xB7 synced ${synced}`
+        )}`
+      );
+    }
+  }
+  logger.info("");
+}
+var init_list = __esm({
+  "src/commands/block/list.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_project();
+    init_ui();
+  }
+});
+
+// src/lib/scaffold/blocks.ts
+function json(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function blockById(id) {
+  return STANDARD_BLOCKS.find((b) => b.id === id);
+}
+var blockDef, containerDef, itemDef, STANDARD_BLOCKS;
+var init_blocks = __esm({
+  "src/lib/scaffold/blocks.ts"() {
+    "use strict";
+    init_esm_shims();
+    blockDef = (title, id, model) => ({
+      title,
+      id,
+      plugins: {
+        xwalk: {
+          page: {
+            resourceType: "core/franklin/components/block/v1/block",
+            template: { name: title, model }
+          }
+        }
+      }
+    });
+    containerDef = (title, id, filter) => ({
+      title,
+      id,
+      plugins: {
+        xwalk: {
+          page: {
+            resourceType: "core/franklin/components/block/v1/block",
+            template: { name: title, filter }
+          }
+        }
+      }
+    });
+    itemDef = (title, id, model) => ({
+      title,
+      id,
+      plugins: {
+        xwalk: {
+          page: {
+            resourceType: "core/franklin/components/block/v1/block/item",
+            template: { name: title, model }
+          }
+        }
+      }
+    });
+    STANDARD_BLOCKS = [
+      // ── hero ──────────────────────────────────────────────
+      {
+        id: "hero",
+        title: "Hero",
+        js: `// Block: hero
+export default function decorate(block) {
+  block.classList.add('hero');
+  const picture = block.querySelector('picture');
+  if (picture) picture.closest('div')?.classList.add('hero-image');
+}
+`,
+        css: `/* Block: hero */
+.hero {
+  position: relative;
+  display: grid;
+  min-height: 60vh;
+  align-content: center;
+}
+
+.hero .hero-image img {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+  z-index: -1;
+}
+
+.hero h1,
+.hero p {
+  max-width: 720px;
+  margin: 0 auto;
+  padding: 0 var(--spacing-m, 16px);
+}
+`,
+        model: json({
+          definitions: [blockDef("Hero", "hero", "hero")],
+          models: [
+            {
+              id: "hero",
+              fields: [
+                { component: "reference", valueType: "string", name: "image", label: "Image" },
+                { component: "text", valueType: "string", name: "imageAlt", label: "Alt" },
+                { component: "text", valueType: "string", name: "title", label: "Title" },
+                { component: "richtext", valueType: "string", name: "text", value: "", label: "Text" }
+              ]
+            }
+          ],
+          filters: []
+        })
+      },
+      // ── cards (container / multifield) ────────────────────
+      {
+        id: "cards",
+        title: "Cards",
+        js: `// Block: cards
+export default function decorate(block) {
+  const ul = document.createElement('ul');
+  [...block.children].forEach((row) => {
+    const li = document.createElement('li');
+    while (row.firstElementChild) li.append(row.firstElementChild);
+    [...li.children].forEach((cell) => {
+      cell.className = cell.querySelector('picture') ? 'cards-card-image' : 'cards-card-body';
+    });
+    ul.append(li);
+  });
+  block.textContent = '';
+  block.append(ul);
+}
+`,
+        css: `/* Block: cards */
+.cards ul {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(min(100%, 260px), 1fr));
+  gap: var(--spacing-m, 16px);
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.cards li {
+  border: 1px solid var(--color-line, #e5e5e5);
+  border-radius: 12px;
+  overflow: hidden;
+}
+
+.cards .cards-card-image img {
+  width: 100%;
+  aspect-ratio: 16 / 9;
+  object-fit: cover;
+}
+
+.cards .cards-card-body {
+  padding: var(--spacing-m, 16px);
+}
+`,
+        model: json({
+          definitions: [containerDef("Cards", "cards", "cards"), itemDef("Card", "card", "card")],
+          models: [
+            {
+              id: "card",
+              fields: [
+                { component: "reference", valueType: "string", name: "image", label: "Image" },
+                { component: "text", valueType: "string", name: "imageAlt", label: "Alt" },
+                { component: "text", valueType: "string", name: "title", label: "Title" },
+                { component: "richtext", valueType: "string", name: "text", value: "", label: "Text" },
+                { component: "aem-content", name: "link", label: "Link" }
+              ]
+            }
+          ],
+          filters: [{ id: "cards", components: ["card"] }]
+        })
+      },
+      // ── columns ───────────────────────────────────────────
+      {
+        id: "columns",
+        title: "Columns",
+        js: `// Block: columns
+export default function decorate(block) {
+  const cols = [...block.firstElementChild.children];
+  block.classList.add(\`columns-\${cols.length}-cols\`);
+  [...block.children].forEach((row) => {
+    [...row.children].forEach((col) => {
+      const pic = col.querySelector('picture');
+      if (pic && pic.closest('div') === col) col.classList.add('columns-img-col');
+    });
+  });
+}
+`,
+        css: `/* Block: columns */
+.columns > div {
+  display: grid;
+  gap: var(--spacing-l, 32px);
+}
+
+@media (width >= 900px) {
+  .columns > div {
+    grid-template-columns: repeat(var(--columns, 2), 1fr);
+  }
+  .columns-2-cols > div { --columns: 2; }
+  .columns-3-cols > div { --columns: 3; }
+  .columns-4-cols > div { --columns: 4; }
+}
+
+.columns img { width: 100%; height: auto; }
+`,
+        model: json({
+          definitions: [blockDef("Columns", "columns", "columns")],
+          models: [
+            {
+              id: "columns",
+              fields: [
+                {
+                  component: "richtext",
+                  valueType: "string",
+                  name: "content",
+                  value: "",
+                  label: "Content"
+                }
+              ]
+            }
+          ],
+          filters: []
+        })
+      },
+      // ── accordion (container / <details>) ─────────────────
+      {
+        id: "accordion",
+        title: "Accordion",
+        js: `// Block: accordion
+export default function decorate(block) {
+  [...block.children].forEach((row) => {
+    const [label, body] = row.children;
+    const details = document.createElement('details');
+    const summary = document.createElement('summary');
+    summary.className = 'accordion-item-label';
+    if (label) summary.append(...label.childNodes);
+    const content = document.createElement('div');
+    content.className = 'accordion-item-body';
+    if (body) content.append(...body.childNodes);
+    details.append(summary, content);
+    row.replaceWith(details);
+  });
+}
+`,
+        css: `/* Block: accordion */
+.accordion details {
+  border-bottom: 1px solid var(--color-line, #e5e5e5);
+}
+
+.accordion summary {
+  cursor: pointer;
+  padding: var(--spacing-m, 16px) 0;
+  font-weight: 600;
+  list-style: none;
+}
+
+.accordion summary::after { content: '+'; float: right; }
+.accordion details[open] summary::after { content: '\u2212'; }
+
+.accordion .accordion-item-body {
+  padding-bottom: var(--spacing-m, 16px);
+}
+`,
+        model: json({
+          definitions: [
+            containerDef("Accordion", "accordion", "accordion"),
+            itemDef("Accordion Item", "accordion-item", "accordion-item")
+          ],
+          models: [
+            {
+              id: "accordion-item",
+              fields: [
+                { component: "text", valueType: "string", name: "label", label: "Label" },
+                { component: "richtext", valueType: "string", name: "body", value: "", label: "Body" }
+              ]
+            }
+          ],
+          filters: [{ id: "accordion", components: ["accordion-item"] }]
+        })
+      },
+      // ── embed ─────────────────────────────────────────────
+      {
+        id: "embed",
+        title: "Embed",
+        js: `// Block: embed
+export default function decorate(block) {
+  const link = block.querySelector('a');
+  const url = link?.href;
+  block.textContent = '';
+  if (!url) return;
+  const wrapper = document.createElement('div');
+  wrapper.className = 'embed-wrapper';
+  const iframe = document.createElement('iframe');
+  iframe.src = url;
+  iframe.loading = 'lazy';
+  iframe.title = 'Embedded content';
+  iframe.setAttribute('allow', 'encrypted-media; fullscreen');
+  wrapper.append(iframe);
+  block.append(wrapper);
+}
+`,
+        css: `/* Block: embed */
+.embed .embed-wrapper {
+  position: relative;
+  aspect-ratio: 16 / 9;
+}
+
+.embed iframe {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  border: 0;
+}
+`,
+        model: json({
+          definitions: [blockDef("Embed", "embed", "embed")],
+          models: [
+            {
+              id: "embed",
+              fields: [{ component: "aem-content", name: "link", label: "Embed URL" }]
+            }
+          ],
+          filters: []
+        })
+      }
+    ];
+  }
+});
+
+// src/lib/scaffold/ue.ts
+function fieldReferenceFields() {
+  return [
+    { component: "tab", name: "basics", label: "Basics" },
+    { component: "text", valueType: "string", name: "text", label: "Text (single line)" },
+    {
+      component: "textarea",
+      valueType: "string",
+      name: "textarea",
+      label: "Textarea (multi-line)"
+    },
+    { component: "richtext", valueType: "string", name: "richtext", value: "", label: "Rich text" },
+    { component: "number", valueType: "number", name: "number", label: "Number" },
+    { component: "boolean", valueType: "boolean", name: "boolean", value: false, label: "Boolean" },
+    { component: "date-time", valueType: "date", name: "date", label: "Date / time" },
+    { component: "tab", name: "selection", label: "Selection" },
+    {
+      component: "select",
+      valueType: "string",
+      name: "select",
+      label: "Select",
+      value: "a",
+      options: [
+        { name: "Option A", value: "a" },
+        { name: "Option B", value: "b" }
+      ]
+    },
+    {
+      component: "radio-group",
+      valueType: "string",
+      name: "radio",
+      label: "Radio group",
+      value: "x",
+      options: [
+        { name: "X", value: "x" },
+        { name: "Y", value: "y" }
+      ]
+    },
+    {
+      component: "multiselect",
+      valueType: "string",
+      name: "classes",
+      label: "Multiselect (CSS classes)",
+      options: [
+        { name: "Highlight", value: "highlight" },
+        { name: "Dark", value: "dark" }
+      ]
+    },
+    {
+      component: "checkbox-group",
+      valueType: "string[]",
+      name: "toggles",
+      label: "Checkbox group",
+      options: [
+        { name: "Show title", value: "show-title" },
+        { name: "Show image", value: "show-image" }
+      ]
+    },
+    { component: "tab", name: "media", label: "Media & content" },
+    { component: "reference", valueType: "string", name: "image", label: "Image (DAM asset)" },
+    { component: "text", valueType: "string", name: "imageAlt", label: "Image alt" },
+    { component: "aem-content", name: "link", label: "Link (page / URL)" },
+    { component: "aem-content-fragment", name: "contentFragment", label: "Content Fragment" },
+    {
+      component: "aem-experience-fragment",
+      name: "experienceFragment",
+      label: "Experience Fragment"
+    },
+    { component: "aem-tag", valueType: "string", name: "tags", label: "Tags" },
+    { component: "tab", name: "repeatable", label: "Multifield" },
+    {
+      component: "container",
+      name: "items",
+      label: "Items (repeatable)",
+      multi: true,
+      collapsible: true,
+      fields: [
+        { component: "text", valueType: "string", name: "itemTitle", label: "Title" },
+        { component: "richtext", valueType: "string", name: "itemText", value: "", label: "Text" },
+        { component: "aem-content", name: "itemLink", label: "Link" }
+      ]
+    }
+  ];
+}
+function fieldReferenceModelFile() {
+  const model = {
+    definitions: [
+      {
+        title: "Field Reference",
+        id: "field-reference",
+        plugins: {
+          xwalk: {
+            page: {
+              resourceType: "core/franklin/components/block/v1/block",
+              template: { name: "Field Reference", model: "field-reference" }
+            }
+          }
+        }
+      }
+    ],
+    models: [{ id: "field-reference", fields: fieldReferenceFields() }],
+    filters: []
+  };
+  return `${JSON.stringify(model, null, 2)}
+`;
+}
+function mergeById(existing, additions) {
+  const seen = new Set(existing.map((e) => e.id));
+  return [...existing, ...additions.filter((a) => !seen.has(a.id))];
+}
+function mergeDefinitions(existing, defaultContent, blockDefs) {
+  const groups = existing?.groups ? [...existing.groups] : [];
+  const ensure = (id, title, comps) => {
+    let g = groups.find((x) => x.id === id);
+    if (!g) {
+      g = { id, title, components: [] };
+      groups.push(g);
+    }
+    g.components = mergeById(g.components, comps);
+  };
+  ensure("default", "Default Content", defaultContent);
+  ensure("blocks", "Blocks", blockDefs);
+  return { groups };
+}
+function mergeSectionFilter(existing, ids) {
+  const filters = existing ? [...existing] : [];
+  let section = filters.find((f) => f.id === "section");
+  if (!section) {
+    section = { id: "section", components: ["text", "image", "button", "title"] };
+    filters.push(section);
+  }
+  section.components = [.../* @__PURE__ */ new Set([...section.components, ...ids])];
+  return filters;
+}
+var DEFAULT_CONTENT_DEFINITIONS, DEFAULT_CONTENT_MODELS, FIELD_REFERENCE_JS, FIELD_REFERENCE_CSS;
+var init_ue = __esm({
+  "src/lib/scaffold/ue.ts"() {
+    "use strict";
+    init_esm_shims();
+    DEFAULT_CONTENT_DEFINITIONS = [
+      {
+        title: "Text",
+        id: "text",
+        plugins: {
+          xwalk: {
+            page: {
+              resourceType: "core/franklin/components/text/v1/text",
+              template: { text: "<p>Text</p>" }
+            }
+          }
+        }
+      },
+      {
+        title: "Image",
+        id: "image",
+        plugins: {
+          xwalk: {
+            page: {
+              resourceType: "core/franklin/components/image/v1/image",
+              template: { image: "", imageAlt: "" }
+            }
+          }
+        }
+      },
+      {
+        title: "Button",
+        id: "button",
+        plugins: {
+          xwalk: {
+            page: {
+              resourceType: "core/franklin/components/button/v1/button",
+              template: { text: "Button", href: "", type: "" }
+            }
+          }
+        }
+      },
+      {
+        title: "Title",
+        id: "title",
+        plugins: {
+          xwalk: {
+            page: {
+              resourceType: "core/franklin/components/title/v1/title",
+              template: { title: "Title", type: "h2" }
+            }
+          }
+        }
+      }
+    ];
+    DEFAULT_CONTENT_MODELS = [
+      {
+        id: "title",
+        fields: [
+          { component: "text", valueType: "string", name: "title", label: "Title" },
+          {
+            component: "select",
+            valueType: "string",
+            name: "type",
+            label: "Type",
+            value: "h2",
+            options: [
+              { name: "H1", value: "h1" },
+              { name: "H2", value: "h2" },
+              { name: "H3", value: "h3" },
+              { name: "H4", value: "h4" },
+              { name: "H5", value: "h5" },
+              { name: "H6", value: "h6" }
+            ]
+          }
+        ]
+      },
+      {
+        id: "image",
+        fields: [
+          { component: "reference", valueType: "string", name: "image", label: "Image", multi: false },
+          { component: "text", valueType: "string", name: "imageAlt", label: "Alt Text" }
+        ]
+      },
+      {
+        id: "button",
+        fields: [
+          { component: "text", valueType: "string", name: "text", label: "Text" },
+          { component: "aem-content", name: "href", label: "Link" },
+          {
+            component: "select",
+            valueType: "string",
+            name: "type",
+            label: "Type",
+            options: [
+              { name: "Default", value: "" },
+              { name: "Primary", value: "primary" },
+              { name: "Secondary", value: "secondary" }
+            ]
+          }
+        ]
+      }
+    ];
+    FIELD_REFERENCE_JS = `// Block: field-reference
+// A living reference of every Universal Editor field type (see _field-reference.json).
+// Authors use it to see what's available; delete it before launch.
+export default function decorate(block) {
+  // Default/document authoring hands the field values in as rows - nothing to
+  // enhance here beyond a scoping class. In Universal Editor the fields above
+  // are what you drop and edit.
+  block.classList.add('field-reference');
+}
+`;
+    FIELD_REFERENCE_CSS = `/* Block: field-reference */
+.field-reference {
+  display: grid;
+  gap: var(--spacing-m, 16px);
+  padding: var(--spacing-l, 32px) 0;
+}
+`;
+  }
+});
+
+// src/commands/scaffold.ts
+var scaffold_exports = {};
+__export(scaffold_exports, {
+  scaffoldBlocks: () => scaffoldBlocks,
+  scaffoldInteractive: () => scaffoldInteractive,
+  scaffoldUe: () => scaffoldUe
+});
+import { existsSync as existsSync10 } from "fs";
+import { mkdir as mkdir3, readFile as readFile8, writeFile as writeFile4 } from "fs/promises";
+import path12 from "path";
+async function readJson(file) {
+  if (!existsSync10(file)) return null;
+  try {
+    return JSON.parse(await readFile8(file, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+async function writeJson(file, data) {
+  await writeFile4(file, `${JSON.stringify(data, null, 2)}
+`);
+}
+async function scaffoldUe() {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    logger.error("Not inside an EDS project (no fstab.yaml found).");
+    process.exitCode = 1;
+    return;
+  }
+  logger.logoOnce(logo("Scaffold - Universal Editor"));
+  const created = [];
+  const blockDir = path12.join(projectRoot, "blocks", "field-reference");
+  await mkdir3(blockDir, { recursive: true });
+  await writeFile4(path12.join(blockDir, "field-reference.js"), FIELD_REFERENCE_JS);
+  await writeFile4(path12.join(blockDir, "field-reference.css"), FIELD_REFERENCE_CSS);
+  await writeFile4(path12.join(blockDir, "_field-reference.json"), fieldReferenceModelFile());
+  created.push("blocks/field-reference/ (all 17 fields + multifield)");
+  const defFile = path12.join(projectRoot, "component-definition.json");
+  const modelsFile = path12.join(projectRoot, "component-models.json");
+  const filtersFile = path12.join(projectRoot, "component-filters.json");
+  const blockDefs = [
+    {
+      title: "Field Reference",
+      id: "field-reference",
+      plugins: {
+        xwalk: {
+          page: {
+            resourceType: "core/franklin/components/block/v1/block",
+            template: { name: "Field Reference", model: "field-reference" }
+          }
+        }
+      }
+    }
+  ];
+  const definitions = mergeDefinitions(
+    await readJson(defFile),
+    DEFAULT_CONTENT_DEFINITIONS,
+    blockDefs
+  );
+  await writeJson(defFile, definitions);
+  created.push("component-definition.json (default content + field-reference)");
+  const existingModels = await readJson(modelsFile) ?? [];
+  const fieldRefModel = JSON.parse(fieldReferenceModelFile()).models[0];
+  const models = mergeById(existingModels, [...DEFAULT_CONTENT_MODELS, fieldRefModel]);
+  await writeJson(modelsFile, models);
+  created.push("component-models.json (title / image / button / field-reference)");
+  const filters = mergeSectionFilter(await readJson(filtersFile), ["field-reference"]);
+  await writeJson(filtersFile, filters);
+  created.push("component-filters.json (section filter)");
+  logger.info(heading("Created / merged"));
+  const names = created.map((c) => c.split(" ")[0]);
+  const w = columnWidth(names);
+  for (const c of created) {
+    const [name, ...rest] = c.split(" ");
+    logger.info(accentLine(name, rest.join(" ").replace(/^\((.*)\)$/, "$1"), w));
+  }
+  logger.info("");
+  logger.info(box(["Universal Editor scaffold ready"]));
+}
+async function scaffoldBlocks(names) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    logger.error("Not inside an EDS project (no fstab.yaml found).");
+    process.exitCode = 1;
+    return;
+  }
+  logger.logoOnce(logo("Scaffold \u2014 standard blocks"));
+  let selected;
+  if (names?.length) {
+    selected = names.map((n) => blockById(n.trim())).filter((b) => !!b);
+    const unknown = names.filter((n) => !blockById(n.trim()));
+    if (unknown.length) {
+      logger.warn(
+        `Unknown block(s): ${unknown.join(", ")}. Available: ${STANDARD_BLOCKS.map((b) => b.id).join(", ")}`
+      );
+    }
+  } else {
+    selected = STANDARD_BLOCKS;
+  }
+  const createdIds = [];
+  const skipped = [];
+  for (const b of selected) {
+    const dir = path12.join(projectRoot, "blocks", b.id);
+    if (existsSync10(dir)) {
+      skipped.push(b.id);
+      continue;
+    }
+    await mkdir3(dir, { recursive: true });
+    await writeFile4(path12.join(dir, `${b.id}.js`), b.js);
+    await writeFile4(path12.join(dir, `${b.id}.css`), b.css);
+    await writeFile4(path12.join(dir, `_${b.id}.json`), b.model);
+    createdIds.push(b.id);
+  }
+  const filtersFile = path12.join(projectRoot, "component-filters.json");
+  const filters = mergeSectionFilter(
+    await readJson(filtersFile),
+    selected.map((b) => b.id)
+  );
+  await writeJson(filtersFile, filters);
+  logger.info(heading("Blocks"));
+  const w = columnWidth([...createdIds, ...skipped, "component-filters"]);
+  for (const id of createdIds) logger.info(accentLine(id, "created", w));
+  for (const id of skipped) logger.info(statusLine("warn", id, "already exists \u2014 skipped", w));
+  logger.info("");
+  logger.info(box([`${createdIds.length} block(s) scaffolded + registered`]));
+}
+async function scaffoldInteractive() {
+  const { select, checkbox } = await import("@inquirer/prompts");
+  logger.logoOnce(logo("Scaffold"));
+  const what = await select({
+    message: "What do you want to scaffold?",
+    choices: [
+      { name: "Universal Editor config + field-reference (all 17 field types)", value: "ue" },
+      { name: "Standard blocks (hero, cards, columns, accordion, embed)", value: "blocks" },
+      { name: "Both", value: "both" }
+    ]
+  });
+  if (what === "ue" || what === "both") await scaffoldUe();
+  if (what === "blocks" || what === "both") {
+    const picked = await checkbox({
+      message: "Which blocks?",
+      choices: STANDARD_BLOCKS.map((b) => ({ name: b.title, value: b.id, checked: true }))
+    });
+    await scaffoldBlocks(picked);
+  }
+}
+var init_scaffold = __esm({
+  "src/commands/scaffold.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_project();
+    init_blocks();
+    init_ue();
+    init_ui();
+  }
+});
+
+// src/lib/integrations.ts
+function integrationById(id) {
+  return INTEGRATIONS.find((i) => i.id === id);
+}
+function wrapBlock(name, code) {
+  return `
+// \u2500\u2500 ${name} (eds integrate) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+{
+${code.split("\n").map((l) => l ? `  ${l}` : l).join("\n")}
+}
+`;
+}
+var INTEGRATIONS;
+var init_integrations = __esm({
+  "src/lib/integrations.ts"() {
+    "use strict";
+    init_esm_shims();
+    INTEGRATIONS = [
+      {
+        id: "gtm",
+        name: "Google Tag Manager",
+        fields: [{ name: "id", message: "GTM container ID", placeholder: "GTM-XXXXXXX" }],
+        code: (v) => `// Google Tag Manager (${v.id}) \u2014 delayed phase, after LCP.
+(function (w, d, s, l, i) {
+  w[l] = w[l] || [];
+  w[l].push({ 'gtm.start': new Date().getTime(), event: 'gtm.js' });
+  const f = d.getElementsByTagName(s)[0];
+  const j = d.createElement(s);
+  j.async = true;
+  j.src = 'https://www.googletagmanager.com/gtm.js?id=' + i;
+  f.parentNode.insertBefore(j, f);
+})(window, document, 'script', 'dataLayer', '${v.id}');`
+      },
+      {
+        id: "ga4",
+        name: "Google Analytics 4",
+        fields: [{ name: "id", message: "Measurement ID", placeholder: "G-XXXXXXXXXX" }],
+        code: (v) => `// Google Analytics 4 (${v.id}) \u2014 delayed phase.
+const gaScript = document.createElement('script');
+gaScript.async = true;
+gaScript.src = 'https://www.googletagmanager.com/gtag/js?id=${v.id}';
+document.head.appendChild(gaScript);
+window.dataLayer = window.dataLayer || [];
+function gtag() { window.dataLayer.push(arguments); }
+gtag('js', new Date());
+gtag('config', '${v.id}');`
+      },
+      {
+        id: "chat",
+        name: "Chat widget (facade)",
+        fields: [
+          { name: "label", message: "Button label", placeholder: "Chat with us" },
+          { name: "src", message: "Chat widget script URL" }
+        ],
+        code: (v) => `// Chat widget \u2014 facade pattern: load the heavy script only on first interaction.
+const chatBtn = document.createElement('button');
+chatBtn.type = 'button';
+chatBtn.className = 'chat-facade';
+chatBtn.textContent = ${JSON.stringify(v.label || "Chat")};
+chatBtn.addEventListener('click', () => {
+  const s = document.createElement('script');
+  s.async = true;
+  s.src = ${JSON.stringify(v.src || "")};
+  document.body.appendChild(s);
+  chatBtn.remove();
+}, { once: true });
+document.body.appendChild(chatBtn);`
+      },
+      {
+        id: "cookiebot",
+        name: "Cookie consent (Cookiebot)",
+        fields: [{ name: "id", message: "Cookiebot domain group ID (CBID)" }],
+        code: (v) => `// Cookiebot consent \u2014 load early in delayed; configure GTM consent mode to respect it.
+const cb = document.createElement('script');
+cb.id = 'Cookiebot';
+cb.src = 'https://consent.cookiebot.com/uc.js';
+cb.setAttribute('data-cbid', '${v.id}');
+cb.async = true;
+document.head.appendChild(cb);`
+      },
+      {
+        id: "custom",
+        name: "Custom third-party script",
+        fields: [{ name: "url", message: "Script URL" }],
+        code: (v) => `// Custom third-party script \u2014 delayed phase.
+const s = document.createElement('script');
+s.async = true;
+s.src = ${JSON.stringify(v.url || "")};
+document.head.appendChild(s);`
+      }
+    ];
+  }
+});
+
+// src/commands/integrate.ts
+var integrate_exports = {};
+__export(integrate_exports, {
+  integrate: () => integrate
+});
+import { existsSync as existsSync11 } from "fs";
+import { mkdir as mkdir4, readFile as readFile9, writeFile as writeFile5 } from "fs/promises";
+import path13 from "path";
+import chalk8 from "chalk";
+async function integrate(type) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    logger.error("Not inside an EDS project (no fstab.yaml found).");
+    process.exitCode = 1;
+    return;
+  }
+  logger.logoOnce(logo("Integrate \u2014 third-party service"));
+  const { select, input } = await import("@inquirer/prompts");
+  const chosenId = type || await select({
+    message: "Which service do you want to add?",
+    choices: INTEGRATIONS.map((i) => ({ name: i.name, value: i.id }))
+  });
+  const integration = integrationById(chosenId);
+  if (!integration) {
+    logger.error(
+      `Unknown integration "${chosenId}". Options: ${INTEGRATIONS.map((i) => i.id).join(", ")}`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const values = {};
+  for (const f of integration.fields) {
+    const answer = await input({ message: `  ${f.message}`, default: f.placeholder });
+    values[f.name] = answer.trim();
+  }
+  const block2 = wrapBlock(integration.name, integration.code(values));
+  const delayedPath = path13.join(projectRoot, "scripts", "delayed.js");
+  await mkdir4(path13.dirname(delayedPath), { recursive: true });
+  const existing = existsSync11(delayedPath) ? await readFile9(delayedPath, "utf-8") : DELAYED_HEADER;
+  await writeFile5(delayedPath, `${existing.replace(/\s*$/, "")}
+${block2}`);
+  logger.info(heading("Added"));
+  logger.info(accentLine(integration.name, "\u2192 scripts/delayed.js"));
+  logger.info("");
+  logger.info(
+    chalk8.dim("  Loads after LCP (delayed phase) \u2014 zero impact on your Core Web Vitals.")
+  );
+  if (integration.id === "gtm" || integration.id === "ga4") {
+    logger.info(
+      chalk8.dim("  Tip: gate analytics behind user consent (add the Cookiebot integration).")
+    );
+  }
+  if (integration.id === "chat") {
+    logger.info(
+      chalk8.dim("  The widget loads only when the visitor clicks the button (facade pattern).")
+    );
+  }
+  logger.info("");
+  logger.info(box(["Integration added"]));
+}
+var DELAYED_HEADER;
+var init_integrate = __esm({
+  "src/commands/integrate.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_integrations();
+    init_logger();
+    init_project();
+    init_ui();
+    DELAYED_HEADER = `// delayed.js \u2014 third-party / non-critical scripts.
+// Loaded in the EDS delayed phase (after LCP), so nothing here blocks the page.
+`;
+  }
+});
+
+// src/commands/figma/setup.ts
+var setup_exports = {};
+__export(setup_exports, {
+  figmaSetup: () => figmaSetup
+});
+import { existsSync as existsSync12 } from "fs";
+import { mkdir as mkdir5, writeFile as writeFile6 } from "fs/promises";
+import chalk9 from "chalk";
+async function figmaSetup() {
+  const { select, confirm } = await import("@inquirer/prompts");
+  logger.logoOnce(logo());
+  logger.info(heading("Figma MCP Setup Wizard"));
+  logger.info("Detecting installed AI agents...");
+  const agents = await detectAllAgents();
+  let selectedAgent;
+  if (agents.length === 0) {
+    logger.warn("No AI agents found (claude, cursor, codex).");
+    logger.info(`Install Claude Code: ${chalk9.cyan("npm install -g @anthropic-ai/claude-code")}`);
+    selectedAgent = "none";
+  } else {
+    logger.success(`Found: ${agents.map((a) => chalk9.cyan(a.type)).join(", ")}`);
+    selectedAgent = await select({
+      message: "Which agent do you want to use with eds-cli?",
+      choices: [
+        ...agents.map((a) => ({
+          name: `${a.type}${a.hasFigmaMcp ? chalk9.green(" (Figma MCP detected)") : ""}`,
+          value: a.type
+        })),
+        { name: "None (manual mode)", value: "none" }
+      ]
+    });
+  }
+  if (selectedAgent !== "none") {
+    const agent = agents.find((a) => a.type === selectedAgent);
+    if (agent && !agent.hasFigmaMcp) {
+      logger.warn(`Figma MCP is not configured for ${selectedAgent}.
+`);
+      logger.info("Install it with one of these methods:\n");
+      switch (selectedAgent) {
+        case "claude":
+          logger.info(
+            `  ${chalk9.cyan("claude mcp add --transport sse figma-sse https://mcp.figma.com/sse")}`
+          );
+          logger.info("  or for Figma Desktop app:");
+          logger.info(
+            `  ${chalk9.cyan("claude mcp add --transport http figma-desktop http://127.0.0.1:3845/mcp")}`
+          );
+          break;
+        case "cursor":
+          logger.info(`  Add to ${chalk9.cyan("~/.cursor/mcp.json")}:`);
+          logger.info(
+            chalk9.dim(
+              JSON.stringify(
+                {
+                  mcpServers: {
+                    figma: { url: "https://mcp.figma.com/sse" }
+                  }
+                },
+                null,
+                2
+              )
+            )
+          );
+          break;
+        case "codex":
+          logger.info(
+            "  See Figma MCP docs: https://help.figma.com/hc/en-us/articles/32132100833559"
+          );
+          break;
+      }
+      logger.info("");
+    } else if (agent?.hasFigmaMcp) {
+      logger.success(`Figma MCP is already configured for ${selectedAgent}!`);
+    }
+  }
+  logger.info(
+    chalk9.dim(
+      "\nNote: Figma MCP requires a Figma seat (Dev or Full on paid plans for desktop server)."
+    )
+  );
+  const shouldSave = await confirm({
+    message: "Save preferences to ~/.eds/config.json?",
+    default: true
+  });
+  if (shouldSave) {
+    const configDir = globalConfigDir();
+    if (!existsSync12(configDir)) {
+      await mkdir5(configDir, { recursive: true });
+    }
+    const config = {};
+    if (selectedAgent !== "none") {
+      config.agent = selectedAgent;
+    }
+    await writeFile6(globalConfigPath(), `${JSON.stringify(config, null, 2)}
+`, {
+      mode: 384
+    });
+    logger.success(`Config saved to ${chalk9.cyan(globalConfigPath())}`);
+  }
+  logger.info(chalk9.bold("\nSetup complete!"));
+  if (selectedAgent !== "none") {
+    logger.info(`Try: ${chalk9.cyan('eds block from-design "<figma-url>" --dry-run')}`);
+  }
+}
+var init_setup = __esm({
+  "src/commands/figma/setup.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_detect();
+    init_config();
+    init_logger();
+    init_ui();
+  }
+});
+
+// src/commands/doctor.ts
+var doctor_exports = {};
+__export(doctor_exports, {
+  doctor: () => doctor
+});
+import { existsSync as existsSync13 } from "fs";
+import { readFile as readFile10, readdir as readdir2 } from "fs/promises";
+import path14 from "path";
+import { parse as parseYaml } from "yaml";
+async function doctor(options = {}) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    logger.error("Not inside an EDS project (no fstab.yaml found).");
+    process.exitCode = 1;
+    return;
+  }
+  const project = detectProject(projectRoot);
+  if (!options.json) {
+    logger.logoOnce(logo("Doctor"));
+    logger.info(heading("Doctor", projectRoot));
+  }
+  const results = [];
+  results.push({
+    name: "fstab.yaml exists",
+    status: project.hasFstab ? "pass" : "fail",
+    message: project.hasFstab ? "Found" : "Missing \u2014 required for EDS projects"
+  });
+  if (project.hasFstab) {
+    try {
+      const content = await readFile10(path14.join(projectRoot, "fstab.yaml"), "utf-8");
+      parseYaml(content);
+      results.push({ name: "fstab.yaml valid YAML", status: "pass", message: "Valid" });
+    } catch {
+      results.push({
+        name: "fstab.yaml valid YAML",
+        status: "fail",
+        message: "Invalid YAML syntax"
+      });
+    }
+  }
+  results.push({
+    name: "head.html exists",
+    status: project.hasHeadHtml ? "pass" : "warn",
+    message: project.hasHeadHtml ? "Found" : "Missing \u2014 recommended for metadata/scripts"
+  });
+  results.push({
+    name: "blocks/ directory",
+    status: project.hasBlocks ? "pass" : "warn",
+    message: project.hasBlocks ? "Found" : "Missing \u2014 no blocks yet"
+  });
+  if (project.hasBlocks) {
+    const blocksDir = path14.join(projectRoot, "blocks");
+    const entries = await readdir2(blocksDir, { withFileTypes: true });
+    let aggregatedModels = "";
+    const aggregatedPath = path14.join(projectRoot, "component-models.json");
+    if (existsSync13(aggregatedPath)) {
+      try {
+        aggregatedModels = await readFile10(aggregatedPath, "utf-8");
+      } catch {
+      }
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const blockName = entry.name;
+      const jsFile = path14.join(blocksDir, blockName, `${blockName}.js`);
+      const hasJs = existsSync13(jsFile);
+      results.push({
+        name: `blocks/${blockName} has JS`,
+        status: hasJs ? "pass" : "warn",
+        message: hasJs ? "Found" : `Missing ${blockName}.js`
+      });
+      if (hasJs) {
+        const jsContent = await readFile10(jsFile, "utf-8");
+        if (jsContent.includes("console.log")) {
+          results.push({
+            name: `blocks/${blockName} no console.log`,
+            status: "warn",
+            message: "Found console.log \u2014 remove before production"
+          });
+        }
+      }
+      const hasPerBlockModel = existsSync13(path14.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 \u2014 authors can't edit this block in UE"
+      });
+      const metaFile = path14.join(blocksDir, blockName, ".eds-meta.json");
+      if (existsSync13(metaFile)) {
+        try {
+          const meta = JSON.parse(await readFile10(metaFile, "utf-8"));
+          const syncDate = new Date(meta.lastSyncedAt);
+          const daysSinceSync = Math.floor(
+            (Date.now() - syncDate.getTime()) / (1e3 * 60 * 60 * 24)
+          );
+          results.push({
+            name: `blocks/${blockName} Figma sync`,
+            status: daysSinceSync > 30 ? "warn" : "pass",
+            message: daysSinceSync > 30 ? `Last synced ${daysSinceSync} days ago \u2014 design may have changed` : `Synced ${daysSinceSync} days ago`
+          });
+        } catch {
+          results.push({
+            name: `blocks/${blockName} .eds-meta.json`,
+            status: "warn",
+            message: "Invalid metadata file"
+          });
+        }
+      }
+    }
+  }
+  const queryFile = path14.join(projectRoot, "helix-query.yaml");
+  if (existsSync13(queryFile)) {
+    try {
+      const content = await readFile10(queryFile, "utf-8");
+      parseYaml(content);
+      results.push({ name: "helix-query.yaml valid", status: "pass", message: "Valid YAML" });
+    } catch {
+      results.push({
+        name: "helix-query.yaml valid",
+        status: "fail",
+        message: "Invalid YAML syntax"
+      });
+    }
+  }
+  results.push({
+    name: "~/.eds/config.json",
+    status: globalConfigExists() ? "pass" : "warn",
+    message: globalConfigExists() ? "Found" : 'Missing \u2014 run "eds figma setup" to configure'
+  });
+  const fails0 = results.filter((r) => r.status === "fail");
+  const warns0 = results.filter((r) => r.status === "warn");
+  if (options.json) {
+    const summary2 = {
+      pass: results.filter((r) => r.status === "pass").length,
+      warn: warns0.length,
+      fail: fails0.length
+    };
+    console.log(JSON.stringify({ projectRoot, results, summary: summary2 }, null, 2));
+    if (fails0.length > 0) process.exitCode = 1;
+    return;
+  }
+  const nameWidth = columnWidth(results.map((r) => r.name));
+  for (const r of results) {
+    logger.info(statusLine(r.status, r.name, r.message, nameWidth));
+  }
+  const fails = results.filter((r) => r.status === "fail");
+  const warns = results.filter((r) => r.status === "warn");
+  const passes = results.filter((r) => r.status === "pass");
+  logger.info("");
+  logger.info(
+    box([summary({ pass: passes.length, warn: warns.length, fail: fails.length })])
+  );
+  if (fails.length > 0) process.exitCode = 1;
+}
+var init_doctor = __esm({
+  "src/commands/doctor.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config();
+    init_logger();
+    init_project();
+    init_ui();
+  }
+});
+
+// src/commands/audit-loading.ts
+var audit_loading_exports = {};
+__export(audit_loading_exports, {
+  auditLoading: () => auditLoading
+});
+import { existsSync as existsSync14 } from "fs";
+import { readFile as readFile11, readdir as readdir3, stat as stat3 } from "fs/promises";
+import path15 from "path";
+import chalk10 from "chalk";
+async function auditLoading(options = {}) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    logger.error("Not inside an EDS project (no fstab.yaml found).");
+    process.exitCode = 1;
+    return;
+  }
+  if (!options.json) {
+    logger.logoOnce(logo("Loading Audit"));
+    logger.info(heading("Loading Order Audit", projectRoot));
+  }
+  const results = [];
+  await checkHeadHtml(projectRoot, results);
+  await checkScriptsJs(projectRoot, results);
+  await checkStylesCss(projectRoot, results);
+  await checkDelayedJs(projectRoot, results);
+  await checkBlocks(projectRoot, results);
+  await checkAemJs(projectRoot, results);
+  if (options.json) {
+    const summary2 = {
+      pass: results.filter((r) => r.status === "pass").length,
+      warn: results.filter((r) => r.status === "warn").length,
+      fail: results.filter((r) => r.status === "fail").length,
+      info: results.filter((r) => r.status === "info").length
+    };
+    console.log(JSON.stringify({ projectRoot, results, summary: summary2 }, null, 2));
+    if (summary2.fail > 0) process.exitCode = 1;
+    return;
+  }
+  printResults(results);
+}
+async function checkHeadHtml(root, results) {
+  const filePath = path15.join(root, "head.html");
+  if (!existsSync14(filePath)) {
+    results.push({
+      rule: "head.html exists",
+      status: "warn",
+      message: "Missing head.html"
+    });
+    return;
+  }
+  const content = await readFile11(filePath, "utf-8");
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (/<script\b/i.test(line) && !/type\s*=\s*["']module["']/i.test(line) && !/<\/script>/.test(line)) {
+      results.push({
+        rule: "No render-blocking scripts in head.html",
+        status: "fail",
+        message: 'Script without type="module" blocks rendering',
+        file: "head.html",
+        line: i + 1
+      });
+    }
+  }
+  const stylesheetMatches = content.match(/<link[^>]+rel=["']stylesheet["'][^>]*>/gi) || [];
+  const extraStylesheets = stylesheetMatches.filter(
+    (tag) => !tag.includes("styles/styles.css") && !tag.includes("styles.css")
+  );
+  if (extraStylesheets.length > 0) {
+    results.push({
+      rule: "No extra stylesheets in head.html",
+      status: "warn",
+      message: `${extraStylesheets.length} extra stylesheet(s) \u2014 each competes with LCP budget`,
+      file: "head.html"
+    });
+  }
+  if (/<link[^>]+rel=["'](preload|preconnect)["']/i.test(content)) {
+    results.push({
+      rule: "No preload/preconnect in head.html",
+      status: "warn",
+      message: "preload/preconnect can hurt EDS LCP \u2014 resources compete with the 100KB budget",
+      file: "head.html"
+    });
+  }
+  if (/<script\b[^>]*>[\s\S]*?[^\s<][\s\S]*?<\/script>/i.test(content)) {
+    results.push({
+      rule: "No inline scripts in head.html",
+      status: "warn",
+      message: "Inline scripts block rendering \u2014 move to delayed.js",
+      file: "head.html"
+    });
+  }
+  const thirdPartyPattern = /(?:src|href)=["'](https?:\/\/(?!(?:localhost|127\.0\.0\.1))[^"']+)["']/gi;
+  for (const match of content.matchAll(thirdPartyPattern)) {
+    const url = match[1];
+    if (!url.includes("fonts.googleapis.com")) {
+      results.push({
+        rule: "No third-party resources in head.html",
+        status: "warn",
+        message: `Third-party resource: ${url} \u2014 move to delayed.js`,
+        file: "head.html"
+      });
+    }
+  }
+  if (/<link[^>]+as=["']font["']/i.test(content)) {
+    results.push({
+      rule: "No font preloads in head.html",
+      status: "warn",
+      message: "Font preloads consume LCP bandwidth budget \u2014 let loadFonts() handle them",
+      file: "head.html"
+    });
+  }
+  if (!results.some((r) => r.file === "head.html")) {
+    results.push({
+      rule: "head.html is clean",
+      status: "pass",
+      message: "No render-blocking issues found",
+      file: "head.html"
+    });
+  }
+}
+async function checkScriptsJs(root, results) {
+  const filePath = path15.join(root, "scripts", "scripts.js");
+  if (!existsSync14(filePath)) {
+    results.push({
+      rule: "scripts/scripts.js exists",
+      status: "warn",
+      message: "Missing scripts.js \u2014 cannot audit loading phases"
+    });
+    return;
+  }
+  const content = await readFile11(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);
+  const hasLoadDelayed = /function\s+loadDelayed|loadDelayed\s*=/i.test(content);
+  results.push({
+    rule: "loadEager phase exists",
+    status: hasLoadEager ? "pass" : "fail",
+    message: hasLoadEager ? "Found" : "Missing loadEager \u2014 LCP optimization depends on it",
+    file: "scripts/scripts.js"
+  });
+  results.push({
+    rule: "loadLazy phase exists",
+    status: hasLoadLazy ? "pass" : "fail",
+    message: hasLoadLazy ? "Found" : "Missing loadLazy \u2014 below-fold content won't load properly",
+    file: "scripts/scripts.js"
+  });
+  results.push({
+    rule: "loadDelayed phase exists",
+    status: hasLoadDelayed ? "pass" : "warn",
+    message: hasLoadDelayed ? "Found" : "Missing loadDelayed \u2014 third-party scripts may block LCP",
+    file: "scripts/scripts.js"
+  });
+  const delayedTimeoutMatch = content.match(/setTimeout\s*\([^,]+,\s*(\d+)\s*\)/);
+  if (hasLoadDelayed && delayedTimeoutMatch) {
+    const delay = Number.parseInt(delayedTimeoutMatch[1], 10);
+    if (delay < 3e3) {
+      results.push({
+        rule: "Delayed phase waits >= 3s",
+        status: "warn",
+        message: `delayed.js loads after ${delay}ms \u2014 should be >= 3000ms for LCP safety`,
+        file: "scripts/scripts.js"
+      });
+    } else {
+      results.push({
+        rule: "Delayed phase waits >= 3s",
+        status: "pass",
+        message: `${delay}ms delay before loading delayed.js`,
+        file: "scripts/scripts.js"
+      });
+    }
+  }
+  if (hasLoadEager) {
+    const eagerSection = content.match(/loadEager[\s\S]*?(?=function\s|const\s+load|$)/)?.[0] || "";
+    if (/loadSections\s*\(/.test(eagerSection)) {
+      results.push({
+        rule: "loadEager loads only first section",
+        status: "fail",
+        message: "loadEager calls loadSections() \u2014 should only load first section for fast LCP",
+        file: "scripts/scripts.js"
+      });
+    }
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (/import\s.*from\s+['"]https?:\/\//i.test(line)) {
+      results.push({
+        rule: "No third-party imports at top level",
+        status: "warn",
+        message: `Third-party import at line ${i + 1} \u2014 move to delayed.js if not critical`,
+        file: "scripts/scripts.js",
+        line: i + 1
+      });
+    }
+  }
+  if (hasLoadEager) {
+    const eagerBody = extractFunctionBody(content, "loadEager");
+    if (eagerBody && /loadHeader|loadFooter/.test(eagerBody)) {
+      results.push({
+        rule: "Header/footer not in loadEager",
+        status: "warn",
+        message: "Header/footer in loadEager delays LCP \u2014 move to loadLazy",
+        file: "scripts/scripts.js"
+      });
+    }
+  }
+}
+async function checkStylesCss(root, results) {
+  const filePath = path15.join(root, "styles", "styles.css");
+  if (!existsSync14(filePath)) return;
+  const stats = await stat3(filePath);
+  const sizeKb = stats.size / 1024;
+  results.push({
+    rule: "styles.css size within LCP budget",
+    status: sizeKb > 40 ? "warn" : "pass",
+    message: `${sizeKb.toFixed(1)} KB${sizeKb > 40 ? " \u2014 large CSS competes with 100KB LCP budget" : ""}`,
+    file: "styles/styles.css"
+  });
+  const content = await readFile11(filePath, "utf-8");
+  if (/@import\s/.test(content)) {
+    results.push({
+      rule: "No @import in styles.css",
+      status: "warn",
+      message: "@import creates a request chain \u2014 inline the CSS or use lazy-styles.css",
+      file: "styles/styles.css"
+    });
+  }
+}
+async function checkDelayedJs(root, results) {
+  const filePath = path15.join(root, "scripts", "delayed.js");
+  if (!existsSync14(filePath)) {
+    results.push({
+      rule: "scripts/delayed.js exists",
+      status: "info",
+      message: "No delayed.js \u2014 third-party scripts should go here"
+    });
+    return;
+  }
+  const content = await readFile11(filePath, "utf-8");
+  const stripped = content.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").trim();
+  if (!stripped) {
+    results.push({
+      rule: "delayed.js has content",
+      status: "info",
+      message: "delayed.js is empty \u2014 add analytics/martech here",
+      file: "scripts/delayed.js"
+    });
+  }
+}
+async function checkBlocks(root, results) {
+  const blocksDir = path15.join(root, "blocks");
+  if (!existsSync14(blocksDir)) return;
+  const entries = await readdir3(blocksDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const blockName = entry.name;
+    const jsFile = path15.join(blocksDir, blockName, `${blockName}.js`);
+    if (!existsSync14(jsFile)) continue;
+    const content = await readFile11(jsFile, "utf-8");
+    const lines = content.split("\n");
+    const heavyLibs = [
+      "jquery",
+      "lodash",
+      "moment",
+      "rxjs",
+      "d3",
+      "three",
+      "gsap",
+      "anime",
+      "chart.js",
+      "swiper"
+    ];
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].toLowerCase();
+      for (const lib of heavyLibs) {
+        if (line.includes("from") && line.includes(lib) && /import\s/.test(line)) {
+          results.push({
+            rule: "No heavy imports in blocks",
+            status: "warn",
+            message: `Imports "${lib}" \u2014 heavy library delays section loading`,
+            file: `blocks/${blockName}/${blockName}.js`,
+            line: i + 1
+          });
+        }
+      }
+    }
+    if (/document\.write/i.test(content)) {
+      results.push({
+        rule: "No document.write in blocks",
+        status: "fail",
+        message: "document.write blocks parsing and can break the page",
+        file: `blocks/${blockName}/${blockName}.js`
+      });
+    }
+    const stats = await stat3(jsFile);
+    const sizeKb = stats.size / 1024;
+    if (sizeKb > 20) {
+      results.push({
+        rule: "Block JS size reasonable",
+        status: "warn",
+        message: `${sizeKb.toFixed(1)} KB \u2014 consider splitting or lazy-loading parts`,
+        file: `blocks/${blockName}/${blockName}.js`
+      });
+    }
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const blockName = entry.name;
+    const cssFile = path15.join(blocksDir, blockName, `${blockName}.css`);
+    if (!existsSync14(cssFile)) continue;
+    const content = await readFile11(cssFile, "utf-8");
+    const selectorPattern = /^([a-z][a-z0-9-]*)\s*\{/gm;
+    for (const selectorMatch of content.matchAll(selectorPattern)) {
+      const selector = selectorMatch[1];
+      if (!["body", "html", "main"].includes(selector)) {
+        results.push({
+          rule: "Block CSS is scoped",
+          status: "warn",
+          message: `Bare element selector "${selector}" \u2014 may leak styles and cause CLS. Use .${blockName} prefix`,
+          file: `blocks/${blockName}/${blockName}.css`
+        });
+      }
+    }
+  }
+}
+async function checkAemJs(root, results) {
+  const filePath = path15.join(root, "scripts", "aem.js");
+  if (!existsSync14(filePath)) {
+    results.push({
+      rule: "scripts/aem.js exists",
+      status: "warn",
+      message: "Missing aem.js (or lib-franklin.js) \u2014 the EDS framework library"
+    });
+    return;
+  }
+  results.push({
+    rule: "aem.js present",
+    status: "pass",
+    message: "Found \u2014 remember: never modify this file",
+    file: "scripts/aem.js"
+  });
+}
+function extractFunctionBody(source, funcName) {
+  const pattern = new RegExp(`(?:async\\s+)?function\\s+${funcName}\\s*\\([^)]*\\)\\s*\\{`);
+  const match = pattern.exec(source);
+  if (!match) return null;
+  let depth = 1;
+  let i = match.index + match[0].length;
+  const start = i;
+  while (i < source.length && depth > 0) {
+    if (source[i] === "{") depth++;
+    else if (source[i] === "}") depth--;
+    i++;
+  }
+  return source.slice(start, i - 1);
+}
+function printResults(results) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const r of results) {
+    const key = r.file || "general";
+    const bucket = grouped.get(key) ?? [];
+    bucket.push(r);
+    grouped.set(key, bucket);
+  }
+  for (const [file, fileResults] of grouped) {
+    logger.info(`  ${icon.bullet} ${chalk10.underline(file)}`);
+    for (const r of fileResults) {
+      const loc = r.line ? chalk10.dim(`:${r.line}`) : "";
+      logger.info(`    ${statusIcon(r.status)} ${r.rule}${loc}`);
+      if (r.status !== "pass") {
+        logger.info(chalk10.dim(`       ${r.message}`));
+      }
+    }
+    logger.info("");
+  }
+  const counts = {
+    pass: results.filter((r) => r.status === "pass").length,
+    warn: results.filter((r) => r.status === "warn").length,
+    fail: results.filter((r) => r.status === "fail").length,
+    info: results.filter((r) => r.status === "info").length
+  };
+  logger.info(box([summary(counts)]));
+  if (counts.fail > 0) process.exitCode = 1;
+}
+var init_audit_loading = __esm({
+  "src/commands/audit-loading.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_project();
+    init_ui();
+  }
+});
+
+// src/commands/audit-security.ts
+var audit_security_exports = {};
+__export(audit_security_exports, {
+  auditSecurity: () => auditSecurity
+});
+import { existsSync as existsSync15 } from "fs";
+import { readFile as readFile12, readdir as readdir4 } from "fs/promises";
+import path16 from "path";
+import chalk11 from "chalk";
+async function* walk(dir) {
+  const entries = await readdir4(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = path16.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (IGNORE_DIRS.has(entry.name)) continue;
+      yield* walk(full);
+    } else if (entry.isFile()) {
+      yield full;
+    }
+  }
+}
+function scanContent(content, relFile, ext) {
+  const findings = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    let innerHtmlDynamicHit = false;
+    for (const rule of RULES) {
+      if (!rule.ext.includes(ext)) continue;
+      if (rule.id === "innerhtml-static" && innerHtmlDynamicHit) continue;
+      if (!rule.re.test(line)) continue;
+      if (rule.extra && !rule.extra(line)) continue;
+      if (rule.id === "innerhtml-dynamic") innerHtmlDynamicHit = true;
+      findings.push({
+        severity: rule.severity,
+        rule: rule.id,
+        message: rule.message,
+        file: relFile,
+        line: i + 1,
+        snippet: line.trim().slice(0, 100)
+      });
+    }
+  }
+  return findings;
+}
+async function auditDependencies(root) {
+  if (!existsSync15(path16.join(root, "package.json"))) {
+    return { status: "skipped", note: "no package.json" };
+  }
+  const hasLock = existsSync15(path16.join(root, "package-lock.json")) || existsSync15(path16.join(root, "npm-shrinkwrap.json"));
+  if (!hasLock && !existsSync15(path16.join(root, "node_modules"))) {
+    return { status: "skipped", note: "no package-lock.json / node_modules \u2014 run npm install" };
+  }
+  try {
+    const { execa } = await import("execa");
+    const { stdout } = await execa("npm", ["audit", "--json"], {
+      cwd: root,
+      reject: false
+    });
+    const data = JSON.parse(stdout);
+    const v = data?.metadata?.vulnerabilities ?? {};
+    const counts = {
+      critical: v.critical ?? 0,
+      high: v.high ?? 0,
+      moderate: v.moderate ?? 0,
+      low: v.low ?? 0
+    };
+    const total = counts.critical + counts.high + counts.moderate + counts.low;
+    return { status: total > 0 ? "vulnerable" : "ok", counts };
+  } catch (err) {
+    return { status: "skipped", note: `npm audit failed: ${err.message}` };
+  }
+}
+async function auditSecurity(options = {}) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    logger.error("Not inside an EDS project (no fstab.yaml found).");
+    process.exitCode = 1;
+    return;
+  }
+  const findings = [];
+  for await (const file of walk(projectRoot)) {
+    const ext = path16.extname(file).slice(1).toLowerCase();
+    if (!SCAN_EXT.has(ext)) continue;
+    const rel = path16.relative(projectRoot, file);
+    if (rel.endsWith("aem.js") || rel.endsWith("lib-franklin.js")) continue;
+    const content = await readFile12(file, "utf-8");
+    findings.push(...scanContent(content, rel, ext));
+  }
+  const deps = await auditDependencies(projectRoot);
+  const bySeverity = (s) => findings.filter((f) => f.severity === s);
+  const codeCounts = {
+    critical: bySeverity("critical").length,
+    high: bySeverity("high").length,
+    moderate: bySeverity("moderate").length,
+    low: bySeverity("low").length
+  };
+  const hardFail = codeCounts.critical > 0 || codeCounts.high > 0 || (deps.counts?.critical ?? 0) > 0 || (deps.counts?.high ?? 0) > 0;
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        { projectRoot, dependencies: deps, findings, summary: { code: codeCounts } },
+        null,
+        2
+      )
+    );
+    if (hardFail) process.exitCode = 1;
+    return;
+  }
+  logger.logoOnce(logo("Security Audit"));
+  logger.info(heading("Dependencies", "npm audit"));
+  if (deps.status === "skipped") {
+    logger.info(statusLine("info", "npm audit", deps.note ?? "skipped"));
+  } else if (deps.status === "ok") {
+    logger.info(statusLine("pass", "npm audit", "no known vulnerabilities"));
+  } else {
+    const c = deps.counts ?? { critical: 0, high: 0, moderate: 0, low: 0 };
+    logger.info(
+      statusLine(
+        c.critical + c.high > 0 ? "fail" : "warn",
+        "npm audit",
+        `${c.critical} critical, ${c.high} high, ${c.moderate} moderate, ${c.low} low \u2014 run \`npm audit fix\``
+      )
+    );
+  }
+  logger.info(heading("Exploit scan", "XSS \xB7 secrets \xB7 injection \xB7 tabnabbing"));
+  if (findings.length === 0) {
+    logger.info(statusLine("pass", "code", "no risky patterns found"));
+  } else {
+    const sorted = [...findings].sort(
+      (a, b) => SEVERITY_ORDER.indexOf(a.severity) - SEVERITY_ORDER.indexOf(b.severity)
+    );
+    for (const f of sorted) {
+      const meta = SEVERITY_META[f.severity];
+      const loc = chalk11.dim(`${f.file}:${f.line}`);
+      logger.info(`  ${statusIcon(meta.status)} ${chalk11.bold(meta.label)} ${f.message}  ${loc}`);
+      logger.info(chalk11.dim(`         ${f.snippet}`));
+    }
+  }
+  const summaryLine = summary({
+    fail: codeCounts.critical + codeCounts.high + (deps.counts?.critical ?? 0) + (deps.counts?.high ?? 0),
+    warn: codeCounts.moderate + (deps.counts?.moderate ?? 0),
+    info: codeCounts.low + (deps.counts?.low ?? 0)
+  });
+  logger.info("");
+  logger.info(
+    box([summaryLine || `${icon.pass} no vulnerabilities or risky patterns found`])
+  );
+  if (hardFail) process.exitCode = 1;
+}
+var RULES, SEVERITY_ORDER, SEVERITY_META, IGNORE_DIRS, SCAN_EXT;
+var init_audit_security = __esm({
+  "src/commands/audit-security.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_project();
+    init_ui();
+    RULES = [
+      {
+        id: "eval",
+        severity: "critical",
+        re: /\beval\s*\(/,
+        message: "eval() executes arbitrary code \u2014 prime XSS / RCE vector",
+        ext: ["js", "mjs", "html"]
+      },
+      {
+        id: "aws-key",
+        severity: "critical",
+        re: /\bAKIA[0-9A-Z]{16}\b/,
+        message: "Hardcoded AWS access key id",
+        ext: ["js", "mjs", "html", "json"]
+      },
+      {
+        id: "private-key",
+        severity: "critical",
+        re: /-----BEGIN (?:RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----/,
+        message: "Embedded private key material",
+        ext: ["js", "mjs", "html", "json", "pem", "txt"]
+      },
+      {
+        id: "new-function",
+        severity: "high",
+        re: /\bnew\s+Function\s*\(/,
+        message: "new Function() runs strings as code",
+        ext: ["js", "mjs", "html"]
+      },
+      {
+        id: "document-write",
+        severity: "high",
+        re: /document\.write(?:ln)?\s*\(/,
+        message: "document.write() enables XSS and blocks parsing",
+        ext: ["js", "mjs", "html"]
+      },
+      {
+        id: "innerhtml-dynamic",
+        severity: "high",
+        re: /\.(?:inner|outer)HTML\s*=\s*[^;\n]*(?:\$\{|\+|concat)/,
+        message: "Dynamic innerHTML assignment \u2014 sanitize or use textContent / DOM APIs",
+        ext: ["js", "mjs"]
+      },
+      {
+        id: "insert-adjacent-html",
+        severity: "high",
+        re: /insertAdjacentHTML\s*\(/,
+        message: "insertAdjacentHTML with untrusted data is an XSS vector",
+        ext: ["js", "mjs"]
+      },
+      {
+        id: "js-url",
+        severity: "high",
+        re: /(?:href|src)\s*=\s*["']?\s*javascript:/i,
+        message: "javascript: URL \u2014 XSS vector",
+        ext: ["js", "mjs", "html"]
+      },
+      {
+        id: "secret",
+        severity: "high",
+        re: /(?:api[_-]?key|secret|access[_-]?token|auth[_-]?token|client[_-]?secret|passwd|password)\s*[:=]\s*["'][^"']{8,}["']/i,
+        message: "Possible hardcoded secret / credential",
+        ext: ["js", "mjs", "html", "json"],
+        // Skip obvious placeholders.
+        extra: (line) => !/(example|placeholder|your[-_]|changeme|xxxx|<[^>]+>|\$\{)/i.test(line)
+      },
+      {
+        id: "bearer-token",
+        severity: "high",
+        re: /Bearer\s+[A-Za-z0-9\-._~+/]{20,}/,
+        message: "Hardcoded bearer token",
+        ext: ["js", "mjs", "html", "json"]
+      },
+      {
+        id: "innerhtml-static",
+        severity: "moderate",
+        re: /\.(?:inner|outer)HTML\s*=/,
+        message: "innerHTML assignment \u2014 confirm the content is trusted / sanitized",
+        ext: ["js", "mjs"]
+      },
+      {
+        id: "insecure-url",
+        severity: "moderate",
+        re: /(?:href|src)\s*=\s*["']http:\/\/(?!localhost|127\.0\.0\.1)/i,
+        message: "Insecure http:// resource \u2014 mixed content, use https://",
+        ext: ["html", "js", "mjs"]
+      },
+      {
+        id: "target-blank",
+        severity: "moderate",
+        re: /target\s*=\s*["']_blank["']/,
+        message: 'target="_blank" without rel="noopener" \u2014 reverse tabnabbing',
+        ext: ["html", "js", "mjs"],
+        extra: (line) => !/rel\s*=\s*["'][^"']*noopener/i.test(line)
+      },
+      {
+        id: "postmessage-wildcard",
+        severity: "moderate",
+        re: /postMessage\s*\([^,]+,\s*["']\*["']\s*\)/,
+        message: "postMessage to '*' origin \u2014 restrict the target origin",
+        ext: ["js", "mjs"]
+      },
+      {
+        id: "inline-handler",
+        severity: "low",
+        re: /\son[a-z]+\s*=\s*["']/i,
+        message: "Inline event handler \u2014 move to addEventListener (CSP-unfriendly)",
+        ext: ["html"]
+      },
+      {
+        id: "console-log",
+        severity: "low",
+        re: /console\.(?:log|debug)\s*\(/,
+        message: "console.log / debug left in code \u2014 potential info leak",
+        ext: ["js", "mjs"]
+      }
+    ];
+    SEVERITY_ORDER = ["critical", "high", "moderate", "low"];
+    SEVERITY_META = {
+      critical: { status: "fail", label: "CRIT" },
+      high: { status: "fail", label: "HIGH" },
+      moderate: { status: "warn", label: "MOD " },
+      low: { status: "info", label: "LOW " }
+    };
+    IGNORE_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".vscode", "coverage"]);
+    SCAN_EXT = /* @__PURE__ */ new Set(["js", "mjs", "html", "json", "pem", "txt"]);
+  }
+});
+
+// src/lib/admin-api.ts
+async function adminRequest(action, config, pagePath) {
+  const ref = config.ref || "main";
+  const normalizedPath = pagePath.startsWith("/") ? pagePath : `/${pagePath}`;
+  const url = `${ADMIN_BASE}/${action}/${config.org}/${config.site}/${ref}${normalizedPath}`;
+  logger.debug(`POST ${url}`);
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" }
+  });
+  const body = await response.json().catch(() => ({}));
+  const data = body;
+  if (!response.ok) {
+    return {
+      ok: false,
+      status: response.status,
+      path: normalizedPath,
+      message: body.message || `HTTP ${response.status}`
+    };
+  }
+  return {
+    ok: true,
+    status: response.status,
+    path: normalizedPath,
+    previewUrl: data.preview?.url,
+    liveUrl: data.live?.url
+  };
+}
+async function previewPage(config, pagePath) {
+  return adminRequest("preview", config, pagePath);
+}
+async function publishPage(config, pagePath) {
+  return adminRequest("live", config, pagePath);
+}
+async function previewPages(config, paths) {
+  return Promise.all(paths.map((p) => previewPage(config, p)));
+}
+async function publishPages(config, paths) {
+  return Promise.all(paths.map((p) => publishPage(config, p)));
+}
+var ADMIN_BASE;
+var init_admin_api = __esm({
+  "src/lib/admin-api.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    ADMIN_BASE = "https://admin.hlx.page";
+  }
+});
+
+// src/commands/preview.ts
+var preview_exports2 = {};
+__export(preview_exports2, {
+  preview: () => preview,
+  resolveAdminConfig: () => resolveAdminConfig
+});
+import chalk12 from "chalk";
+import ora2 from "ora";
+async function preview(paths, options) {
+  const projectRoot = findProjectRoot();
+  const config = await loadConfig(projectRoot);
+  const adminConfig = resolveAdminConfig(config, options);
+  if (!adminConfig) return;
+  const spinner = ora2(`Previewing ${paths.length} path(s)...`).start();
+  const results = paths.length === 1 ? [await previewPage(adminConfig, paths[0])] : await previewPages(adminConfig, paths);
+  spinner.stop();
+  let hasErrors = false;
+  for (const r of results) {
+    if (r.ok) {
+      logger.success(`${r.path} \u2192 ${chalk12.cyan(r.previewUrl || "preview updated")}`);
+    } else {
+      logger.error(`${r.path} \u2014 ${r.message}`);
+      hasErrors = true;
+    }
+  }
+  if (hasErrors) process.exitCode = 1;
+}
+function resolveAdminConfig(config, options) {
+  const org = options.org || config.admin?.org;
+  const site = options.site || config.admin?.site;
+  const ref = options.ref || config.admin?.ref || "main";
+  if (!org || !site) {
+    logger.error("Missing --org and --site. Set them via flags or in .edsrc.json:");
+    logger.info(chalk12.dim('  { "admin": { "org": "my-org", "site": "my-site" } }'));
+    process.exitCode = 1;
+    return void 0;
+  }
+  return { org, site, ref };
+}
+var init_preview2 = __esm({
+  "src/commands/preview.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_admin_api();
+    init_config();
+    init_logger();
+    init_project();
+  }
+});
+
+// src/commands/publish.ts
+var publish_exports = {};
+__export(publish_exports, {
+  publish: () => publish
+});
+import chalk13 from "chalk";
+import ora3 from "ora";
+async function publish(paths, options) {
+  const projectRoot = findProjectRoot();
+  const config = await loadConfig(projectRoot);
+  const adminConfig = resolveAdminConfig(config, options);
+  if (!adminConfig) return;
+  const spinner = ora3(`Publishing ${paths.length} path(s)...`).start();
+  const results = paths.length === 1 ? [await publishPage(adminConfig, paths[0])] : await publishPages(adminConfig, paths);
+  spinner.stop();
+  let hasErrors = false;
+  for (const r of results) {
+    if (r.ok) {
+      logger.success(`${r.path} \u2192 ${chalk13.cyan(r.liveUrl || "published")}`);
+    } else {
+      logger.error(`${r.path} \u2014 ${r.message}`);
+      hasErrors = true;
+    }
+  }
+  if (hasErrors) process.exitCode = 1;
+}
+var init_publish = __esm({
+  "src/commands/publish.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_admin_api();
+    init_config();
+    init_logger();
+    init_project();
+    init_preview2();
+  }
+});
+
+// src/commands/admin.ts
+var admin_exports = {};
+__export(admin_exports, {
+  adminWizard: () => adminWizard
+});
+async function adminWizard(initialOp) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    logger.error("Not inside an EDS project (no fstab.yaml found).");
+    process.exitCode = 1;
+    return;
+  }
+  logger.logoOnce(logo("Admin API \u2014 preview / publish"));
+  const { select, input, confirm } = await import("@inquirer/prompts");
+  const config = await loadConfig(projectRoot);
+  const admin = config.admin ?? {};
+  const op = initialOp ?? await select({
+    message: "What do you want to do?",
+    choices: [
+      { name: "Preview pages (staging)", value: "preview" },
+      { name: "Publish pages (go live)", value: "publish" }
+    ]
+  });
+  const org = (await input({ message: "GitHub org / owner", default: admin.org })).trim();
+  const site = (await input({ message: "Repository / site", default: admin.site })).trim();
+  const ref = (await input({ message: "Git ref", default: admin.ref || "main" })).trim();
+  const pathsRaw = await input({
+    message: "Paths (space- or comma-separated)",
+    default: "/"
+  });
+  const paths = pathsRaw.split(/[\s,]+/).filter(Boolean);
+  if (!org || !site || paths.length === 0) {
+    logger.error("org, site and at least one path are required.");
+    process.exitCode = 1;
+    return;
+  }
+  logger.info(heading("Summary"));
+  const w = columnWidth(["operation", "org", "site", "ref", "paths"]);
+  logger.info(accentLine("operation", op, w));
+  logger.info(accentLine("org", org, w));
+  logger.info(accentLine("site", site, w));
+  logger.info(accentLine("ref", ref, w));
+  logger.info(accentLine("paths", paths.join(", "), w));
+  logger.info("");
+  if (op === "publish") {
+    const go = await confirm({
+      message: `Publish ${paths.length} path(s) to LIVE?`,
+      default: false
+    });
+    if (!go) {
+      logger.info("Cancelled.");
+      return;
+    }
+  }
+  const options = { org, site, ref };
+  if (op === "preview") {
+    const { preview: preview2 } = await Promise.resolve().then(() => (init_preview2(), preview_exports2));
+    await preview2(paths, options);
+  } else {
+    const { publish: publish2 } = await Promise.resolve().then(() => (init_publish(), publish_exports));
+    await publish2(paths, options);
+  }
+}
+var init_admin = __esm({
+  "src/commands/admin.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config();
+    init_logger();
+    init_project();
+    init_ui();
+  }
+});
+
+// src/commands/menu.ts
+var menu_exports = {};
+__export(menu_exports, {
+  mainMenu: () => mainMenu
+});
+import { existsSync as existsSync16 } from "fs";
+import { readdir as readdir5 } from "fs/promises";
+import path17 from "path";
+async function listBlockNames(projectRoot) {
+  const dir = path17.join(projectRoot, "blocks");
+  if (!existsSync16(dir)) return [];
+  const entries = await readdir5(dir, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+}
+async function mainMenu() {
+  const { select, input } = await import("@inquirer/prompts");
+  logger.logoOnce(logo("What do you want to do?"));
+  const action = await select({
+    message: "Choose an action",
+    choices: [
+      { name: "Generate a block from a design (Figma/Stitch/Canva/Sketch)", value: "from-design" },
+      { 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" },
+      { name: "Preview a block in the browser", value: "preview-block" },
+      { name: "Preview / publish pages (Admin API)", value: "admin" },
+      { name: "Audit the project", value: "audit" },
+      { name: "Configure Figma MCP", value: "figma-setup" }
+    ]
+  });
+  switch (action) {
+    case "from-design": {
+      const { blockFromDesign: blockFromDesign2 } = await Promise.resolve().then(() => (init_from_design(), from_design_exports));
+      await blockFromDesign2(void 0, {});
+      return;
+    }
+    case "scaffold": {
+      const { scaffoldInteractive: scaffoldInteractive2 } = await Promise.resolve().then(() => (init_scaffold(), scaffold_exports));
+      await scaffoldInteractive2();
+      return;
+    }
+    case "create": {
+      const name = await input({
+        message: "Block name",
+        validate: (v) => kebabCaseRegex.test(v.trim()) || "Use kebab-case, e.g. hero-banner"
+      });
+      const { createBlock: createBlock2 } = await Promise.resolve().then(() => (init_create(), create_exports));
+      await createBlock2(name.trim(), {});
+      return;
+    }
+    case "integrate": {
+      const { integrate: integrate2 } = await Promise.resolve().then(() => (init_integrate(), integrate_exports));
+      await integrate2(void 0);
+      return;
+    }
+    case "preview-block": {
+      const projectRoot = findProjectRoot();
+      if (!projectRoot) {
+        logger.error("Not inside an EDS project (no fstab.yaml found).");
+        return;
+      }
+      const blocks = await listBlockNames(projectRoot);
+      if (blocks.length === 0) {
+        logger.warn("No blocks found in blocks/.");
+        return;
+      }
+      const name = await select({
+        message: "Which block?",
+        choices: blocks.map((b) => ({ name: b, value: b }))
+      });
+      const { previewBlock: previewBlock2 } = await Promise.resolve().then(() => (init_preview(), preview_exports));
+      await previewBlock2(name, {});
+      return;
+    }
+    case "admin": {
+      const { adminWizard: adminWizard2 } = await Promise.resolve().then(() => (init_admin(), admin_exports));
+      await adminWizard2();
+      return;
+    }
+    case "audit": {
+      const which = await select({
+        message: "Which audit?",
+        choices: [
+          { name: "Doctor \u2014 overall project health", value: "doctor" },
+          { name: "Loading \u2014 three-phase / LCP budget", value: "loading" },
+          { name: "Security \u2014 vulnerabilities & exploit patterns", value: "security" }
+        ]
+      });
+      if (which === "doctor") {
+        const { doctor: doctor2 } = await Promise.resolve().then(() => (init_doctor(), doctor_exports));
+        await doctor2({});
+      } else if (which === "loading") {
+        const { auditLoading: auditLoading2 } = await Promise.resolve().then(() => (init_audit_loading(), audit_loading_exports));
+        await auditLoading2({});
+      } else {
+        const { auditSecurity: auditSecurity2 } = await Promise.resolve().then(() => (init_audit_security(), audit_security_exports));
+        await auditSecurity2({});
+      }
+      return;
+    }
+    case "figma-setup": {
+      const { figmaSetup: figmaSetup2 } = await Promise.resolve().then(() => (init_setup(), setup_exports));
+      await figmaSetup2();
+      return;
+    }
+  }
+}
+var init_menu = __esm({
+  "src/commands/menu.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_project();
+    init_schemas();
+    init_ui();
+  }
+});
+
+// src/bin/eds.ts
+init_esm_shims();
+init_logger();
+init_ui();
+import chalk14 from "chalk";
+import { Command } from "commander";
+var program = new Command();
+program.name("eds").description("CLI for AEM Edge Delivery Services with Figma integration").version("0.4.0").option("--verbose", "Enable verbose output").option("--quiet", "Suppress non-error output").option("--json", "Output in JSON format").option("--no-color", "Disable color output").showHelpAfterError("(add --help for usage)").hook("preAction", (thisCommand) => {
+  const opts = thisCommand.opts();
+  if (opts.verbose) logger.setLevel("debug");
+  if (opts.quiet) logger.setQuiet(true);
+  if (opts.color === false) chalk14.level = 0;
+});
+program.addHelpText("beforeAll", () => logo());
+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));
+  await createBlock2(name, options);
+});
+block.command("from-design [design-url]").description(
+  "Generate an EDS block from a design (Figma/Stitch/Canva/Sketch; interactive wizard when run with no URL)"
+).option("--name <name>", "Override the inferred block name").option("--agent <type>", "Force agent type (claude|cursor|codex|none)").option("--dry-run", "Generate prompt only, do not invoke agent").option("--source <type>", "Content source: document|ue|cf|mixed (default: document)").option("--no-ue-model", "Skip the Universal Editor model (generated by default)").option("--no-screenshot", "Skip the screenshot fetch (fewer tokens; structural verification)").option("--no-serve", "Don't auto-start the live preview after generating").option("--yes", "Skip confirmation prompts").action(async (designUrl, options) => {
+  const { blockFromDesign: blockFromDesign2 } = await Promise.resolve().then(() => (init_from_design(), from_design_exports));
+  await blockFromDesign2(designUrl, options);
+});
+block.command("list").description("List all blocks in the project").action(async (options) => {
+  const { listBlocks: listBlocks2 } = await Promise.resolve().then(() => (init_list(), list_exports));
+  await listBlocks2({ ...options, json: program.opts().json });
+});
+block.command("preview <name>").description("Serve a live, breakpoint-switchable preview of a block in the browser").option("--port <port>", "Port to serve on (default: 8777, falls back if taken)").option("--widths <list>", "Comma-separated breakpoint widths (e.g. 375,768,1280)").option("--no-open", "Do not open the browser automatically").action(async (name, options) => {
+  const { previewBlock: previewBlock2 } = await Promise.resolve().then(() => (init_preview(), preview_exports));
+  await previewBlock2(name, options);
+});
+var scaffold = program.command("scaffold").description("Scaffold standard UE components and blocks").action(async () => {
+  const { scaffoldInteractive: scaffoldInteractive2 } = await Promise.resolve().then(() => (init_scaffold(), scaffold_exports));
+  await scaffoldInteractive2();
+});
+scaffold.command("ue").description("Scaffold default-content UE components + a field-reference block (all 17 fields)").action(async () => {
+  const { scaffoldUe: scaffoldUe2 } = await Promise.resolve().then(() => (init_scaffold(), scaffold_exports));
+  await scaffoldUe2();
+});
+scaffold.command("blocks [names...]").description("Scaffold standard blocks (hero, cards, columns, accordion, embed) with UE models").action(async (names) => {
+  const { scaffoldBlocks: scaffoldBlocks2 } = await Promise.resolve().then(() => (init_scaffold(), scaffold_exports));
+  await scaffoldBlocks2(names);
+});
+program.command("integrate [type]").description("Add a third-party service (GTM, GA4, chat, consent) to scripts/delayed.js").action(async (type) => {
+  const { integrate: integrate2 } = await Promise.resolve().then(() => (init_integrate(), integrate_exports));
+  await integrate2(type);
+});
+var figma = program.command("figma").description("Figma MCP integration");
+figma.command("setup").description("Configure Figma MCP for your AI agent").action(async () => {
+  const { figmaSetup: figmaSetup2 } = await Promise.resolve().then(() => (init_setup(), setup_exports));
+  await figmaSetup2();
+});
+program.command("doctor").description("Audit your EDS project for common issues").action(async () => {
+  const { doctor: doctor2 } = await Promise.resolve().then(() => (init_doctor(), doctor_exports));
+  await doctor2({ json: program.opts().json });
+});
+var audit = program.command("audit").description("Run project audits");
+audit.command("loading").description("Check loading order (eager/lazy/delayed phases, LCP budget)").action(async () => {
+  const { auditLoading: auditLoading2 } = await Promise.resolve().then(() => (init_audit_loading(), audit_loading_exports));
+  await auditLoading2({ json: program.opts().json });
+});
+audit.command("security").description(
+  "Scan for vulnerabilities (npm audit) and exploit patterns (XSS, secrets, tabnabbing)"
+).action(async () => {
+  const { auditSecurity: auditSecurity2 } = await Promise.resolve().then(() => (init_audit_security(), audit_security_exports));
+  await auditSecurity2({ json: program.opts().json });
+});
+program.command("preview [paths...]").description("Preview pages via Admin API (interactive wizard when run with no paths)").option("--org <org>", "GitHub org/owner").option("--site <site>", "Repository name").option("--ref <ref>", "Git ref (default: main)").action(async (paths, options) => {
+  if (!paths || paths.length === 0) {
+    const { adminWizard: adminWizard2 } = await Promise.resolve().then(() => (init_admin(), admin_exports));
+    await adminWizard2("preview");
+    return;
+  }
+  const { preview: preview2 } = await Promise.resolve().then(() => (init_preview2(), preview_exports2));
+  await preview2(paths, options);
+});
+program.command("publish [paths...]").description("Publish pages to live via Admin API (interactive wizard when run with no paths)").option("--org <org>", "GitHub org/owner").option("--site <site>", "Repository name").option("--ref <ref>", "Git ref (default: main)").action(async (paths, options) => {
+  if (!paths || paths.length === 0) {
+    const { adminWizard: adminWizard2 } = await Promise.resolve().then(() => (init_admin(), admin_exports));
+    await adminWizard2("publish");
+    return;
+  }
+  const { publish: publish2 } = await Promise.resolve().then(() => (init_publish(), publish_exports));
+  await publish2(paths, options);
+});
+(async () => {
+  try {
+    if (process.argv.slice(2).length === 0) {
+      if (process.stdout.isTTY) {
+        const { mainMenu: mainMenu2 } = await Promise.resolve().then(() => (init_menu(), menu_exports));
+        await mainMenu2();
+      } else {
+        program.outputHelp();
+      }
+    } else {
+      await program.parseAsync();
+    }
+  } catch (err) {
+    logger.error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+  }
+})();
+//# sourceMappingURL=eds.js.map