aem-eds-kit 0.4.12 → 0.4.22

package/dist/bin/eds.js

@@ -67,7 +67,7 @@ function mix(a, b, t) {
   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("")}`;
+  return `#${[r, g, bl].map((n2) => n2.toString(16).padStart(2, "0")).join("")}`;
 }
 function gradientLine(line, stops, width) {
   const chars = [...line];
@@ -127,8 +127,8 @@ function summary(counts) {
   if (counts.info) parts.push(`${icon.info} ${counts.info} info`);
   return parts.join(chalk.dim("   "));
 }
-function plural(n, word) {
-  return n === 1 ? word : `${word}s`;
+function plural(n2, word) {
+  return n2 === 1 ? word : `${word}s`;
 }
 var brand, icon, ANSI, DOTS_N, LOGO_ART, LOGO_STOPS;
 var init_ui = __esm({
@@ -273,6 +273,178 @@ ${logoArt()}
   }
 });
 
+// src/lib/sandbox/api.ts
+function headers(token) {
+  return {
+    Authorization: `Bearer ${token}`,
+    Accept: "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28",
+    "User-Agent": "aem-eds-kit",
+    "Content-Type": "application/json"
+  };
+}
+function generateEndpoint(template2) {
+  return `${API}/repos/${template2}/generate`;
+}
+async function getUser(token) {
+  const res = await fetch(`${API}/user`, { headers: headers(token) });
+  if (!res.ok) throw new Error(`GitHub auth failed: ${res.status}`);
+  return (await res.json()).login;
+}
+async function repoExists(token, owner, repo) {
+  const res = await fetch(`${API}/repos/${owner}/${repo}`, { headers: headers(token) });
+  if (res.status === 404) return false;
+  if (res.ok) return true;
+  throw new Error(`existence check failed: ${res.status} ${await res.text()}`);
+}
+async function createFromTemplate(token, template2, opts) {
+  const res = await fetch(generateEndpoint(template2), {
+    method: "POST",
+    headers: headers(token),
+    body: JSON.stringify({
+      owner: opts.owner,
+      name: opts.name,
+      private: !!opts.private,
+      include_all_branches: false
+    })
+  });
+  if (!res.ok) throw new Error(`create failed: ${res.status} ${await res.text()}`);
+  const r = await res.json();
+  return { fullName: r.full_name, htmlUrl: r.html_url, cloneUrl: r.clone_url };
+}
+async function addTopics(token, owner, repo, topics) {
+  await fetch(`${API}/repos/${owner}/${repo}/topics`, {
+    method: "PUT",
+    headers: headers(token),
+    body: JSON.stringify({ names: topics })
+  });
+}
+async function deleteRepo(token, owner, repo) {
+  const res = await fetch(`${API}/repos/${owner}/${repo}`, {
+    method: "DELETE",
+    headers: headers(token)
+  });
+  if (!res.ok && res.status !== 204) {
+    throw new Error(`delete failed: ${res.status} ${await res.text()}`);
+  }
+}
+async function searchByTopic(token, login, topic) {
+  const q = encodeURIComponent(`user:${login} topic:${topic} fork:true`);
+  const res = await fetch(`${API}/search/repositories?q=${q}&per_page=100`, {
+    headers: headers(token)
+  });
+  if (!res.ok) throw new Error(`search failed: ${res.status}`);
+  const data = await res.json();
+  return data.items.map((i) => i.full_name);
+}
+var API;
+var init_api = __esm({
+  "src/lib/sandbox/api.ts"() {
+    "use strict";
+    init_esm_shims();
+    API = "https://api.github.com";
+  }
+});
+
+// src/lib/sandbox/auth.ts
+import { existsSync } from "fs";
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import os from "os";
+import path2 from "path";
+async function getToken() {
+  const env = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+  if (env) return env;
+  if (existsSync(TOKEN_FILE)) {
+    try {
+      return JSON.parse(await readFile(TOKEN_FILE, "utf-8")).token ?? null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+async function saveToken(token) {
+  await mkdir(CONFIG_DIR, { recursive: true, mode: 448 });
+  await writeFile(TOKEN_FILE, `${JSON.stringify({ token }, null, 2)}
+`, { mode: 384 });
+}
+async function clearToken() {
+  if (existsSync(TOKEN_FILE)) await rm(TOKEN_FILE);
+}
+async function startDeviceFlow(scopes) {
+  const res = await fetch("https://github.com/login/device/code", {
+    method: "POST",
+    headers: { Accept: "application/json", "Content-Type": "application/json" },
+    body: JSON.stringify({ client_id: CLIENT_ID, scope: scopes.join(" ") })
+  });
+  if (!res.ok) throw new Error(`device code request failed: ${res.status}`);
+  return await res.json();
+}
+async function pollDeviceToken(deviceCode, interval, expiresIn) {
+  let wait = Math.max(interval, 1);
+  const deadline = Date.now() + expiresIn * 1e3;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, wait * 1e3));
+    const res = await fetch("https://github.com/login/oauth/access_token", {
+      method: "POST",
+      headers: { Accept: "application/json", "Content-Type": "application/json" },
+      body: JSON.stringify({
+        client_id: CLIENT_ID,
+        device_code: deviceCode,
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+      })
+    });
+    const data = await res.json();
+    if (data.access_token) return data.access_token;
+    if (data.error === "slow_down") wait += 5;
+    else if (data.error !== "authorization_pending") {
+      throw new Error(data.error ?? "device flow failed");
+    }
+  }
+  throw new Error("device flow timed out");
+}
+var CONFIG_DIR, TOKEN_FILE, CLIENT_ID;
+var init_auth = __esm({
+  "src/lib/sandbox/auth.ts"() {
+    "use strict";
+    init_esm_shims();
+    CONFIG_DIR = path2.join(os.homedir(), ".eds");
+    TOKEN_FILE = path2.join(CONFIG_DIR, "github.json");
+    CLIENT_ID = process.env.EDS_GITHUB_CLIENT_ID ?? "";
+  }
+});
+
+// src/lib/sandbox/github.ts
+function previewUrl(owner, repo, ref = "main") {
+  return `https://${ref}--${repo}--${owner}.aem.page/`;
+}
+function codeSyncInstallUrl() {
+  return "https://github.com/apps/aem-code-sync/installations/new";
+}
+function createArgs(repoRef, opts) {
+  return [
+    "repo",
+    "create",
+    repoRef,
+    "--template",
+    opts.template,
+    opts.private ? "--private" : "--public",
+    ...opts.clone ? ["--clone"] : []
+  ];
+}
+var SANDBOX_TOPIC, BOILERPLATES;
+var init_github = __esm({
+  "src/lib/sandbox/github.ts"() {
+    "use strict";
+    init_esm_shims();
+    SANDBOX_TOPIC = "eds-sandbox";
+    BOILERPLATES = {
+      document: "adobe/aem-boilerplate",
+      ue: "adobe/aem-boilerplate-xwalk"
+    };
+  }
+});
+
 // src/lib/schemas.ts
 import { z } from "zod";
 var figmaUrlSchema, edsConfigSchema, edsProjectSchema, edsMetaSchema, kebabCaseRegex;
@@ -315,26 +487,26 @@ var init_schemas = __esm({
 });
 
 // src/lib/project.ts
-import { existsSync } from "fs";
-import path2 from "path";
+import { existsSync as existsSync2 } from "fs";
+import path3 from "path";
 function findProjectRoot(startDir = process.cwd()) {
-  let dir = path2.resolve(startDir);
-  const { root } = path2.parse(dir);
+  let dir = path3.resolve(startDir);
+  const { root } = path3.parse(dir);
   while (dir !== root) {
-    if (ROOT_MARKERS.some((m) => existsSync(path2.join(dir, m)))) {
+    if (ROOT_MARKERS.some((m) => existsSync2(path3.join(dir, m)))) {
       return dir;
     }
-    dir = path2.dirname(dir);
+    dir = path3.dirname(dir);
   }
-  if (ROOT_MARKERS.some((m) => existsSync(path2.join(root, m)))) return root;
+  if (ROOT_MARKERS.some((m) => existsSync2(path3.join(root, m)))) return root;
   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"))
+    hasFstab: existsSync2(path3.join(rootDir, "fstab.yaml")),
+    hasBlocks: existsSync2(path3.join(rootDir, "blocks")),
+    hasHeadHtml: existsSync2(path3.join(rootDir, "head.html"))
   });
 }
 var ROOT_MARKERS;
@@ -356,14 +528,14 @@ var init_project = __esm({
 });
 
 // src/lib/scaffold/ci.ts
-import { existsSync as existsSync2 } from "fs";
-import { mkdir, writeFile } from "fs/promises";
-import path3 from "path";
+import { existsSync as existsSync3 } from "fs";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import path4 from "path";
 async function writeCiWorkflow(projectRoot) {
-  const file = path3.join(projectRoot, ".github", "workflows", "eds.yml");
-  if (existsSync2(file)) return { path: CI_WORKFLOW_PATH, created: false };
-  await mkdir(path3.dirname(file), { recursive: true });
-  await writeFile(file, CI_WORKFLOW);
+  const file = path4.join(projectRoot, ".github", "workflows", "eds.yml");
+  if (existsSync3(file)) return { path: CI_WORKFLOW_PATH, created: false };
+  await mkdir2(path4.dirname(file), { recursive: true });
+  await writeFile2(file, CI_WORKFLOW);
   return { path: CI_WORKFLOW_PATH, created: true };
 }
 var CI_WORKFLOW_PATH, CI_WORKFLOW;
@@ -419,9 +591,46 @@ jobs:
   }
 });
 
+// src/lib/scaffold/env.ts
+import { existsSync as existsSync4 } from "fs";
+import { readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
+import path5 from "path";
+function buildEnv(opts = {}) {
+  const open = opts.open ?? "/";
+  const port = opts.port ?? 3007;
+  const pagesUrl = opts.pagesUrl ?? "";
+  return `AEM_OPEN=${open}
+AEM_PORT=${port}
+AEM_PAGES_URL=${pagesUrl}
+`;
+}
+async function ensureEnvIgnored(projectRoot) {
+  const file = path5.join(projectRoot, ".gitignore");
+  let current = "";
+  if (existsSync4(file)) current = await readFile2(file, "utf-8");
+  if (current.split(/\r?\n/).some((l) => l.trim() === ".env")) return false;
+  const prefix = current && !current.endsWith("\n") ? "\n" : "";
+  await writeFile3(file, `${current}${prefix}.env
+`);
+  return true;
+}
+async function writeEnv(projectRoot, opts = {}) {
+  const file = path5.join(projectRoot, ".env");
+  const created = !existsSync4(file);
+  if (created) await writeFile3(file, buildEnv(opts));
+  const gitignoreUpdated = await ensureEnvIgnored(projectRoot);
+  return { path: ".env", created, gitignoreUpdated };
+}
+var init_env = __esm({
+  "src/lib/scaffold/env.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // src/lib/scaffold/fstab.ts
-import { writeFile as writeFile2 } from "fs/promises";
-import path4 from "path";
+import { writeFile as writeFile4 } from "fs/promises";
+import path6 from "path";
 function needsFstab(a) {
   return a !== "ue";
 }
@@ -434,7 +643,7 @@ function fstabYaml(mountpoint) {
 `;
 }
 async function writeFstab(projectRoot, mountpoint) {
-  await writeFile2(path4.join(projectRoot, "fstab.yaml"), fstabYaml(mountpoint));
+  await writeFile4(path6.join(projectRoot, "fstab.yaml"), fstabYaml(mountpoint));
   return "fstab.yaml";
 }
 function pathsJson(site) {
@@ -449,7 +658,7 @@ function pathsJson(site) {
 `;
 }
 async function writePaths(projectRoot, site) {
-  await writeFile2(path4.join(projectRoot, "paths.json"), pathsJson(site));
+  await writeFile4(path6.join(projectRoot, "paths.json"), pathsJson(site));
   return "paths.json";
 }
 var AUTHORING_NAMES;
@@ -466,6 +675,58 @@ var init_fstab = __esm({
   }
 });
 
+// src/lib/scaffold/xwalk.ts
+import { existsSync as existsSync5 } from "fs";
+import { writeFile as writeFile5 } from "fs/promises";
+import path7 from "path";
+function buildXwalk() {
+  return `${JSON.stringify(XWALK_CONFIG, null, 2)}
+`;
+}
+async function writeXwalk(projectRoot) {
+  const file = path7.join(projectRoot, "xwalk.json");
+  if (existsSync5(file)) return { path: "xwalk.json", created: false };
+  await writeFile5(file, buildXwalk());
+  return { path: "xwalk.json", created: true };
+}
+var XWALK_CONFIG;
+var init_xwalk = __esm({
+  "src/lib/scaffold/xwalk.ts"() {
+    "use strict";
+    init_esm_shims();
+    XWALK_CONFIG = {
+      public: {
+        xwalk: {
+          "multi-field": {
+            enabled: true
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/lib/ue/link.ts
+function parseRemote(url) {
+  const m = url.trim().match(/github\.com[:/]([^/]+)\/(.+?)(?:\.git)?\/?$/i);
+  return m ? { owner: m[1], repo: m[2] } : null;
+}
+function previewHost(owner, repo, ref = "main") {
+  return `${ref}--${repo}--${owner}.aem.page`;
+}
+function editorLink({ host, path: path36 = "/", org }) {
+  const cleanHost = host.replace(/^https?:\/\//, "").replace(/\/+$/, "");
+  const p = path36.startsWith("/") ? path36 : `/${path36}`;
+  const orgSeg = org ? `@${org}/` : "";
+  return `https://experience.adobe.com/#/${orgSeg}aem/editor/canvas/${cleanHost}${p}`;
+}
+var init_link = __esm({
+  "src/lib/ue/link.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // src/lib/scaffold/blocks.ts
 function json(value) {
   return `${JSON.stringify(value, null, 2)}
@@ -479,14 +740,14 @@ var init_blocks = __esm({
   "src/lib/scaffold/blocks.ts"() {
     "use strict";
     init_esm_shims();
-    blockDef = (title, id, model) => ({
+    blockDef = (title, id, model2) => ({
       title,
       id,
       plugins: {
         xwalk: {
           page: {
             resourceType: "core/franklin/components/block/v1/block",
-            template: { name: title, model }
+            template: { name: title, model: model2 }
           }
         }
       }
@@ -503,14 +764,14 @@ var init_blocks = __esm({
         }
       }
     });
-    itemDef = (title, id, model) => ({
+    itemDef = (title, id, model2) => ({
       title,
       id,
       plugins: {
         xwalk: {
           page: {
             resourceType: "core/franklin/components/block/v1/block/item",
-            template: { name: title, model }
+            template: { name: title, model: model2 }
           }
         }
       }
@@ -787,6 +1048,204 @@ export default function decorate(block) {
   }
 });
 
+// src/lib/scaffold/helpers.ts
+import { existsSync as existsSync6 } from "fs";
+import { mkdir as mkdir3, writeFile as writeFile6 } from "fs/promises";
+import path8 from "path";
+function helperById(id) {
+  return HELPERS.find((h) => h.id === id);
+}
+function resolveHelpers(ids) {
+  const want = /* @__PURE__ */ new Set();
+  const add = (id) => {
+    if (want.has(id)) return;
+    const h = helperById(id);
+    if (!h) return;
+    for (const dep of h.deps ?? []) add(dep);
+    want.add(id);
+  };
+  for (const id of ids) add(id);
+  return HELPERS.filter((h) => want.has(h.id)).map((h) => h.id);
+}
+function buildHelpers(ids) {
+  const resolved = resolveHelpers(ids);
+  const body = resolved.map((id) => helperById(id)).filter((h) => !!h).map((h) => h.code).join("\n\n");
+  return `// scripts/utils.js - common EDS helpers (generated by \`eds scaffold helpers\`).
+
+${body}
+`;
+}
+async function writeHelpers(projectRoot, ids = ALL_HELPER_IDS) {
+  const resolved = resolveHelpers(ids);
+  const file = path8.join(projectRoot, "scripts", "utils.js");
+  if (existsSync6(file)) return { path: HELPERS_PATH, created: false, helpers: resolved };
+  await mkdir3(path8.dirname(file), { recursive: true });
+  await writeFile6(file, buildHelpers(ids));
+  return { path: HELPERS_PATH, created: true, helpers: resolved };
+}
+var HELPERS_PATH, HELPERS, ALL_HELPER_IDS;
+var init_helpers = __esm({
+  "src/lib/scaffold/helpers.ts"() {
+    "use strict";
+    init_esm_shims();
+    HELPERS_PATH = "scripts/utils.js";
+    HELPERS = [
+      {
+        id: "getMetadata",
+        label: "getMetadata (read a page meta value)",
+        code: `/**
+ * Reads a page metadata value by name (meta[name] or meta[property]).
+ * @param {string} name The metadata name.
+ * @returns {string} The value, or an empty string.
+ */
+export function getMetadata(name) {
+  const meta =
+    document.querySelector(\`meta[name="\${name}"]\`) ||
+    document.querySelector(\`meta[property="\${name}"]\`);
+  return meta ? meta.content : '';
+}`
+      },
+      {
+        id: "toCamelCase",
+        label: "toCamelCase (dash/underscore/space -> camelCase)",
+        code: `/**
+ * Converts a string to camelCase, handling dashes, underscores and spaces.
+ * @param {string} value The string to convert.
+ * @returns {string} The camelCased string.
+ */
+export function toCamelCase(value) {
+  return String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[-_\\s]+(.)/g, (_, char) => char.toUpperCase());
+}`
+      },
+      {
+        id: "getLanguageRootPath",
+        label: "getLanguageRootPath (e.g. /en, /en-us)",
+        code: `/**
+ * Returns the language root of a path, e.g. '/en' or '/en-us' ('' if none).
+ * @param {string} path The page path.
+ * @returns {string} The language root prefix.
+ */
+export function getLanguageRootPath(path) {
+  const match = String(path || '').match(/^\\/[a-z]{2}(?:-[a-z]{2})?(?=\\/|$)/i);
+  return match ? match[0] : '';
+}`
+      },
+      {
+        id: "getPagePath",
+        label: "getPagePath (path without content root)",
+        deps: ["getLanguageRootPath"],
+        code: `// Content root stripped from page paths. Set this if your site is mounted under
+// a sub-path (e.g. '/content/my-site'); leave empty for a root-mounted site.
+const ROOT_PATH = '';
+
+/**
+ * Returns the page path without the content root; \`clean\` drops the language root.
+ * @param {boolean} [clean=false] Also strip the language root.
+ * @returns {string} The page path or 'NA' for the language root.
+ */
+export function getPagePath({ clean = false } = {}) {
+  const path = window.location.pathname.replace(ROOT_PATH, '').replace(/\\.html$/i, '');
+
+  if (clean) {
+    const langRoot = getLanguageRootPath(path);
+    const cleaned = path.startsWith(langRoot) ? path.slice(langRoot.length) : path;
+    return cleaned || 'NA';
+  }
+
+  return path || 'NA';
+}`
+      },
+      {
+        id: "getSiteArea",
+        label: "getSiteArea (blog / products / home)",
+        deps: ["getPagePath"],
+        code: `/**
+ * Returns the top-level area of the site from the current path - e.g. 'blog' or
+ * 'products', and 'home' at the site root. Uses the language-cleaned path, so you
+ * can tell whether you're on the blog or somewhere else.
+ * @returns {string} The site area.
+ */
+export function getSiteArea() {
+  const path = getPagePath({ clean: true });
+  if (!path || path === 'NA') return 'home';
+  return path.split('/').filter(Boolean)[0] || 'home';
+}`
+      },
+      {
+        id: "getEnvironment",
+        label: "getEnvironment (dev / stage / prod)",
+        code: `/**
+ * Detects the current environment from the hostname.
+ * @returns {'NA'|'dev'|'stage'|'prod'} The environment name.
+ */
+export function getEnvironment() {
+  const { hostname } = window.location;
+  if (hostname.includes('author')) return 'NA';
+  if (hostname === 'localhost') return 'dev';
+  const repo = hostname.match(/^[^.]+--([^.]+)--[^.]+\\.aem\\.(?:page|live)$/)?.[1] || '';
+  if (repo.includes('dev')) return 'dev';
+  if (repo.includes('stage')) return 'stage';
+  return 'prod';
+}`
+      },
+      {
+        id: "getContentTopic",
+        label: "getContentTopic (cq-tags content-topic values)",
+        deps: ["getMetadata"],
+        code: `/**
+ * Reads all content-topic values from the page's cq-tags metadata.
+ * @returns {string[]} The topics (part after \`content-topic/\`), empty if none.
+ */
+export function getContentTopic() {
+  return getMetadata('cq-tags')
+    .split(',')
+    .map((t) => t.trim())
+    .filter((t) => t.includes('content-topic/'))
+    .map((t) => t.split('content-topic/')[1]);
+}`
+      },
+      {
+        id: "isUEEdit",
+        label: "isUEEdit (Universal Editor edit mode)",
+        code: `/**
+ * Checks whether the current page is opened in the Universal Editor Edit mode.
+ * @returns {boolean} True in Universal Editor Edit mode.
+ */
+export function isUEEdit() {
+  return document.documentElement.classList.contains('adobe-ue-edit');
+}`
+      },
+      {
+        id: "isUEPreview",
+        label: "isUEPreview (Universal Editor preview mode)",
+        code: `/**
+ * Checks whether the current page is opened in the Universal Editor Preview mode.
+ * @returns {boolean} True in Universal Editor Preview mode.
+ */
+export function isUEPreview() {
+  return document.documentElement.classList.contains('adobe-ue-preview');
+}`
+      },
+      {
+        id: "isUE",
+        label: "isUE (Universal Editor, any mode)",
+        deps: ["isUEEdit", "isUEPreview"],
+        code: `/**
+ * Checks whether the current page is opened in the Universal Editor (any mode).
+ * @returns {boolean} True in the Universal Editor.
+ */
+export function isUE() {
+  return isUEEdit() || isUEPreview();
+}`
+      }
+    ];
+    ALL_HELPER_IDS = HELPERS.map((h) => h.id);
+  }
+});
+
 // src/lib/scaffold/ue.ts
 function fieldReferenceFields() {
   return [
@@ -872,7 +1331,7 @@ function fieldReferenceFields() {
   ];
 }
 function fieldReferenceModelFile() {
-  const model = {
+  const model2 = {
     definitions: [
       {
         title: "Field Reference",
@@ -890,7 +1349,7 @@ function fieldReferenceModelFile() {
     models: [{ id: "field-reference", fields: fieldReferenceFields() }],
     filters: []
   };
-  return `${JSON.stringify(model, null, 2)}
+  return `${JSON.stringify(model2, null, 2)}
 `;
 }
 function mergeById(existing, additions) {
@@ -913,7 +1372,7 @@ function mergeDefinitions(existing, defaultContent, blockDefs) {
 }
 function mergeSectionFilter(existing, ids) {
   const filters = existing ? [...existing] : [];
-  let section = filters.find((f) => f.id === "section");
+  let section = filters.find((f2) => f2.id === "section");
   if (!section) {
     section = { id: "section", components: ["text", "image", "button", "title"] };
     filters.push(section);
@@ -1049,22 +1508,25 @@ var scaffold_exports = {};
 __export(scaffold_exports, {
   scaffoldBlocks: () => scaffoldBlocks,
   scaffoldCi: () => scaffoldCi,
+  scaffoldEnv: () => scaffoldEnv,
+  scaffoldHelpers: () => scaffoldHelpers,
   scaffoldInteractive: () => scaffoldInteractive,
-  scaffoldUe: () => scaffoldUe
+  scaffoldUe: () => scaffoldUe,
+  scaffoldXwalk: () => scaffoldXwalk
 });
-import { existsSync as existsSync3 } from "fs";
-import { mkdir as mkdir2, readFile, writeFile as writeFile3 } from "fs/promises";
-import path5 from "path";
+import { existsSync as existsSync7 } from "fs";
+import { mkdir as mkdir4, readFile as readFile3, writeFile as writeFile7 } from "fs/promises";
+import path9 from "path";
 async function readJson(file) {
-  if (!existsSync3(file)) return null;
+  if (!existsSync7(file)) return null;
   try {
-    return JSON.parse(await readFile(file, "utf-8"));
+    return JSON.parse(await readFile3(file, "utf-8"));
   } catch {
     return null;
   }
 }
 async function writeJson(file, data) {
-  await writeFile3(file, `${JSON.stringify(data, null, 2)}
+  await writeFile7(file, `${JSON.stringify(data, null, 2)}
 `);
 }
 async function scaffoldUe() {
@@ -1076,15 +1538,15 @@ async function scaffoldUe() {
   }
   logger.logoOnce(logo("Scaffold - Universal Editor"));
   const created = [];
-  const blockDir = path5.join(projectRoot, "blocks", "field-reference");
-  await mkdir2(blockDir, { recursive: true });
-  await writeFile3(path5.join(blockDir, "field-reference.js"), FIELD_REFERENCE_JS);
-  await writeFile3(path5.join(blockDir, "field-reference.css"), FIELD_REFERENCE_CSS);
-  await writeFile3(path5.join(blockDir, "_field-reference.json"), fieldReferenceModelFile());
+  const blockDir = path9.join(projectRoot, "blocks", "field-reference");
+  await mkdir4(blockDir, { recursive: true });
+  await writeFile7(path9.join(blockDir, "field-reference.js"), FIELD_REFERENCE_JS);
+  await writeFile7(path9.join(blockDir, "field-reference.css"), FIELD_REFERENCE_CSS);
+  await writeFile7(path9.join(blockDir, "_field-reference.json"), fieldReferenceModelFile());
   created.push("blocks/field-reference/ (all 17 fields + multifield)");
-  const defFile = path5.join(projectRoot, "component-definition.json");
-  const modelsFile = path5.join(projectRoot, "component-models.json");
-  const filtersFile = path5.join(projectRoot, "component-filters.json");
+  const defFile = path9.join(projectRoot, "component-definition.json");
+  const modelsFile = path9.join(projectRoot, "component-models.json");
+  const filtersFile = path9.join(projectRoot, "component-filters.json");
   const blockDefs = [
     {
       title: "Field Reference",
@@ -1134,8 +1596,8 @@ async function scaffoldBlocks(names) {
   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()));
+    selected = names.map((n2) => blockById(n2.trim())).filter((b) => !!b);
+    const unknown = names.filter((n2) => !blockById(n2.trim()));
     if (unknown.length) {
       logger.warn(
         `Unknown block(s): ${unknown.join(", ")}. Available: ${STANDARD_BLOCKS.map((b) => b.id).join(", ")}`
@@ -1147,18 +1609,18 @@ async function scaffoldBlocks(names) {
   const createdIds = [];
   const skipped = [];
   for (const b of selected) {
-    const dir = path5.join(projectRoot, "blocks", b.id);
-    if (existsSync3(dir)) {
+    const dir = path9.join(projectRoot, "blocks", b.id);
+    if (existsSync7(dir)) {
       skipped.push(b.id);
       continue;
     }
-    await mkdir2(dir, { recursive: true });
-    await writeFile3(path5.join(dir, `${b.id}.js`), b.js);
-    await writeFile3(path5.join(dir, `${b.id}.css`), b.css);
-    await writeFile3(path5.join(dir, `_${b.id}.json`), b.model);
+    await mkdir4(dir, { recursive: true });
+    await writeFile7(path9.join(dir, `${b.id}.js`), b.js);
+    await writeFile7(path9.join(dir, `${b.id}.css`), b.css);
+    await writeFile7(path9.join(dir, `_${b.id}.json`), b.model);
     createdIds.push(b.id);
   }
-  const filtersFile = path5.join(projectRoot, "component-filters.json");
+  const filtersFile = path9.join(projectRoot, "component-filters.json");
   const filters = mergeSectionFilter(
     await readJson(filtersFile),
     selected.map((b) => b.id)
@@ -1193,6 +1655,96 @@ async function scaffoldCi() {
     ])
   );
 }
+async function scaffoldHelpers(ids) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    logger.error("Not inside an EDS project (no EDS project markers found).");
+    process.exitCode = 1;
+    return;
+  }
+  logger.logoOnce(logo("Scaffold - helpers"));
+  let selected = ids?.length ? ids : void 0;
+  if (!selected) {
+    if (process.stdout.isTTY) {
+      const { checkbox } = await import("@inquirer/prompts");
+      selected = await checkbox({
+        message: "Which helpers?",
+        choices: HELPERS.map((h) => ({ name: h.label, value: h.id, checked: true }))
+      });
+    } else {
+      selected = ALL_HELPER_IDS;
+    }
+  }
+  if (!selected.length) {
+    logger.info("Nothing selected.");
+    return;
+  }
+  const res = await writeHelpers(projectRoot, selected);
+  logger.info(heading("Helpers"));
+  if (res.created) {
+    logger.info(accentLine(res.path, res.helpers.join(", ")));
+  } else {
+    logger.info(statusLine("warn", res.path, "already exists - skipped"));
+  }
+  logger.info("");
+  logger.info(
+    box([
+      res.created ? `${res.helpers.length} helper(s) -> scripts/utils.js` : "Helpers left untouched"
+    ])
+  );
+}
+async function scaffoldEnv(options = {}) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    logger.error("Not inside an EDS project (no EDS project markers found).");
+    process.exitCode = 1;
+    return;
+  }
+  logger.logoOnce(logo("Scaffold - .env"));
+  let pagesUrl = options.pagesUrl;
+  if (pagesUrl === void 0) {
+    try {
+      const { execa } = await import("execa");
+      const res2 = await execa("git", ["remote", "get-url", "origin"], { cwd: projectRoot });
+      const parsed = parseRemote(res2.stdout.trim());
+      pagesUrl = parsed ? `https://${previewHost(parsed.owner, parsed.repo)}` : "";
+    } catch {
+      pagesUrl = "";
+    }
+  }
+  let open = options.open ?? "/";
+  let port = options.port ?? "3007";
+  if (!options.yes && process.stdout.isTTY) {
+    const { input } = await import("@inquirer/prompts");
+    open = await input({ message: "AEM_OPEN (path opened on start)", default: open });
+    port = await input({ message: "AEM_PORT", default: String(port) });
+    pagesUrl = await input({ message: "AEM_PAGES_URL (content origin)", default: pagesUrl });
+  }
+  const res = await writeEnv(projectRoot, { open, port, pagesUrl });
+  logger.info(heading(".env"));
+  if (res.created) logger.info(accentLine(res.path, `AEM_OPEN=${open}  AEM_PORT=${port}`));
+  else logger.info(statusLine("warn", res.path, "already exists - left untouched"));
+  if (res.gitignoreUpdated) logger.info(accentLine(".gitignore", "added .env"));
+  logger.info("");
+  logger.info(box([res.created ? ".env ready for `aem up`" : ".env left untouched"]));
+}
+async function scaffoldXwalk() {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    logger.error("Not inside an EDS project (no EDS project markers found).");
+    process.exitCode = 1;
+    return;
+  }
+  logger.logoOnce(logo("Scaffold - xwalk.json"));
+  const res = await writeXwalk(projectRoot);
+  logger.info(heading("xwalk.json"));
+  if (res.created) logger.info(accentLine(res.path, "multi-field enabled"));
+  else logger.info(statusLine("warn", res.path, "already exists - left untouched"));
+  logger.info("");
+  logger.info(
+    box([res.created ? "xwalk.json ready (UE multi-field)" : "xwalk.json left untouched"])
+  );
+}
 async function scaffoldInteractive() {
   const { select, checkbox } = await import("@inquirer/prompts");
   logger.logoOnce(logo("Scaffold"));
@@ -1202,9 +1754,14 @@ async function scaffoldInteractive() {
       { name: "Universal Editor config + field-reference (all 17 field types)", value: "ue" },
       { name: "Standard blocks (hero, cards, columns, accordion, embed)", value: "blocks" },
       { name: "GitHub Actions CI (doctor + audits + lint/build)", value: "ci" },
+      { name: "Helper functions (scripts/utils.js)", value: "helpers" },
+      { name: "Local-dev .env (aem up: port / open / pages URL)", value: "env" },
+      { name: "xwalk.json (enable Universal Editor multi-field)", value: "xwalk" },
       { name: "UE config + standard blocks", value: "both" }
     ]
   });
+  if (what === "env") return scaffoldEnv();
+  if (what === "xwalk") return scaffoldXwalk();
   if (what === "ue" || what === "both") await scaffoldUe();
   if (what === "blocks" || what === "both") {
     const picked = await checkbox({
@@ -1214,6 +1771,7 @@ async function scaffoldInteractive() {
     await scaffoldBlocks(picked);
   }
   if (what === "ci") await scaffoldCi();
+  if (what === "helpers") await scaffoldHelpers();
 }
 var init_scaffold = __esm({
   "src/commands/scaffold.ts"() {
@@ -1223,7 +1781,11 @@ var init_scaffold = __esm({
     init_project();
     init_blocks();
     init_ci();
+    init_env();
+    init_helpers();
     init_ue();
+    init_xwalk();
+    init_link();
     init_ui();
   }
 });
@@ -1233,17 +1795,27 @@ var init_exports = {};
 __export(init_exports, {
   initProject: () => initProject
 });
-import { existsSync as existsSync4 } from "fs";
-import { readFile as readFile2, writeFile as writeFile4 } from "fs/promises";
-import path6 from "path";
+import { existsSync as existsSync8 } from "fs";
+import { readFile as readFile4, writeFile as writeFile8 } from "fs/promises";
+import path10 from "path";
 import chalk3 from "chalk";
+async function derivePagesUrl(root) {
+  try {
+    const { execa } = await import("execa");
+    const res = await execa("git", ["remote", "get-url", "origin"], { cwd: root });
+    const parsed = parseRemote(res.stdout.trim());
+    return parsed ? `https://${previewHost(parsed.owner, parsed.repo)}` : "";
+  } catch {
+    return "";
+  }
+}
 async function setPackageName(root, name) {
-  const file = path6.join(root, "package.json");
-  if (!existsSync4(file)) return false;
+  const file = path10.join(root, "package.json");
+  if (!existsSync8(file)) return false;
   try {
-    const pkg = JSON.parse(await readFile2(file, "utf-8"));
+    const pkg = JSON.parse(await readFile4(file, "utf-8"));
     pkg.name = name;
-    await writeFile4(file, `${JSON.stringify(pkg, null, 2)}
+    await writeFile8(file, `${JSON.stringify(pkg, null, 2)}
 `);
     return true;
   } catch {
@@ -1253,13 +1825,13 @@ async function setPackageName(root, name) {
 async function replacePlaceholders(root, name) {
   const touched = [];
   for (const rel of ["README.md", "index.html", "head.html"]) {
-    const file = path6.join(root, rel);
-    if (!existsSync4(file)) continue;
+    const file = path10.join(root, rel);
+    if (!existsSync8(file)) continue;
     try {
-      const before = await readFile2(file, "utf-8");
+      const before = await readFile4(file, "utf-8");
       const after = before.replace(/aem-boilerplate/gi, name);
       if (after !== before) {
-        await writeFile4(file, after);
+        await writeFile8(file, after);
         touched.push(rel);
       }
     } catch {
@@ -1332,11 +1904,11 @@ async function initProject(options = {}) {
   await logger.logoOnceAnimated("Project setup");
   const { input, select, confirm } = await import("@inquirer/prompts");
   const interactive = !options.yes;
-  let defaultName = path6.basename(projectRoot);
-  const pkgFile = path6.join(projectRoot, "package.json");
-  if (existsSync4(pkgFile)) {
+  let defaultName = path10.basename(projectRoot);
+  const pkgFile = path10.join(projectRoot, "package.json");
+  if (existsSync8(pkgFile)) {
     try {
-      defaultName = JSON.parse(await readFile2(pkgFile, "utf-8")).name || defaultName;
+      defaultName = JSON.parse(await readFile4(pkgFile, "utf-8")).name || defaultName;
     } catch {
     }
   }
@@ -1399,11 +1971,19 @@ async function initProject(options = {}) {
     const ci = await writeCiWorkflow(projectRoot);
     done.push(ci.created ? ci.path : `${ci.path} (exists, skipped)`);
   }
+  if (options.env !== false) {
+    const res = await writeEnv(projectRoot, { pagesUrl: await derivePagesUrl(projectRoot) });
+    done.push(res.created ? ".env (aem up config)" : ".env (exists, skipped)");
+  }
+  if (options.xwalk !== false && authoring === "ue") {
+    const res = await writeXwalk(projectRoot);
+    done.push(res.created ? `${res.path} (UE multi-field)` : `${res.path} (exists, skipped)`);
+  }
   logger.info(heading("Configured"));
   const dw = columnWidth(done.map((d) => d.split(" ")[0]));
   for (const d of done) {
-    const [n, ...rest] = d.split(" ");
-    logger.info(accentLine(n, rest.join(" ").replace(/^\((.*)\)$/, "$1"), dw));
+    const [n2, ...rest] = d.split(" ");
+    logger.info(accentLine(n2, rest.join(" ").replace(/^\((.*)\)$/, "$1"), dw));
   }
   logger.info("");
   if (interactive) await externalSteps(authoring);
@@ -1417,321 +1997,1505 @@ var init_init = __esm({
     init_logger();
     init_project();
     init_ci();
+    init_env();
     init_fstab();
+    init_xwalk();
+    init_link();
     init_ui();
     init_scaffold();
     slug = (s) => s.trim().toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
   }
 });
 
-// src/lib/migrate/clientlib.ts
-import { existsSync as existsSync5 } from "fs";
-import { readFile as readFile3, readdir } from "fs/promises";
-import path7 from "path";
-async function listFiles(dir) {
-  const out = [];
-  const walk3 = async (d) => {
-    for (const e of await readdir(d, { withFileTypes: true })) {
-      const p = path7.join(d, e.name);
-      if (e.isDirectory()) await walk3(p);
-      else out.push(p);
-    }
-  };
-  if (existsSync5(dir)) await walk3(dir);
-  return out;
+// src/commands/sandbox.ts
+var sandbox_exports = {};
+__export(sandbox_exports, {
+  sandboxList: () => sandboxList,
+  sandboxLogin: () => sandboxLogin,
+  sandboxLogout: () => sandboxLogout,
+  sandboxNew: () => sandboxNew,
+  sandboxRm: () => sandboxRm
+});
+import path11 from "path";
+import chalk4 from "chalk";
+async function run(cmd, args, opts = {}) {
+  const { execa } = await import("execa");
+  const res = await execa(cmd, args, opts);
+  return (res.stdout ?? "").toString().trim();
 }
-async function findClientlibDir(componentDir) {
-  if (!existsSync5(componentDir)) return null;
-  const entries = await readdir(componentDir, { withFileTypes: true });
-  const match = entries.find((e) => e.isDirectory() && /clientlib/i.test(e.name));
-  if (match) return path7.join(componentDir, match.name);
-  const hasCss = entries.some((e) => e.isFile() && e.name.endsWith(".css"));
-  return hasCss ? componentDir : null;
+async function openUrl(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  try {
+    await run(cmd, [url], { stdio: "ignore" });
+  } catch {
+  }
 }
-async function readClientlibCss(clientlibDir) {
-  const all = await listFiles(clientlibDir);
-  const preprocessed = all.filter((f) => /\.(less|scss|sass)$/i.test(f)).map((f) => path7.relative(clientlibDir, f));
-  let cssFiles;
-  const cssTxt = path7.join(clientlibDir, "css.txt");
-  if (existsSync5(cssTxt)) {
-    const lines = (await readFile3(cssTxt, "utf-8")).split("\n").map((l) => l.trim());
-    let base = clientlibDir;
-    const listed = [];
-    for (const l of lines) {
-      if (!l) continue;
-      const baseMatch = l.match(/^#base\s*=\s*(.+)$/);
-      if (baseMatch) base = path7.join(clientlibDir, baseMatch[1].trim());
-      else if (!l.startsWith("#")) listed.push(l);
-    }
-    cssFiles = listed.map((rel) => path7.join(base, rel)).filter((f) => existsSync5(f) && f.endsWith(".css"));
-  } else {
-    cssFiles = all.filter((f) => f.endsWith(".css"));
+async function ghLogin() {
+  try {
+    await run("gh", ["auth", "status"]);
+    return await run("gh", ["api", "user", "-q", ".login"]);
+  } catch {
+    return null;
   }
-  const parts = [];
-  for (const f of cssFiles) parts.push(await readFile3(f, "utf-8"));
-  return {
-    css: parts.join("\n\n"),
-    files: cssFiles.map((f) => path7.relative(clientlibDir, f)),
-    preprocessed
-  };
 }
-var init_clientlib = __esm({
-  "src/lib/migrate/clientlib.ts"() {
-    "use strict";
-    init_esm_shims();
+async function resolveAuth() {
+  const token = await getToken();
+  if (token) {
+    try {
+      return { mode: "api", token, login: await getUser(token) };
+    } catch {
+    }
   }
-});
-
-// src/lib/migrate/dialog.ts
-import { XMLParser } from "fast-xml-parser";
-function tagOf(n) {
-  return Object.keys(n).find((k) => k !== ":@") ?? "";
+  const login = await ghLogin();
+  if (login) return { mode: "gh", login };
+  return null;
 }
-function childrenOf(n) {
-  const t = tagOf(n);
-  const v = n[t];
-  return Array.isArray(v) ? v : [];
+async function exists(auth, owner, name) {
+  if (auth.mode === "api") return repoExists(auth.token, owner, name);
+  try {
+    await run("gh", ["repo", "view", `${owner}/${name}`, "--json", "name"]);
+    return true;
+  } catch {
+    return false;
+  }
 }
-function attrsOf(n) {
-  return n[":@"] ?? {};
+function noAuth() {
+  logger.error("Not authenticated with GitHub.");
+  logger.info("  Run `eds sandbox login` to authorize GitHub, or install + `gh auth login`.");
+  process.exitCode = 1;
 }
-function stripType(v) {
-  return typeof v === "string" ? v.replace(/^\{[^}]+\}/, "") : v;
+async function sandboxLogin() {
+  await logger.logoOnceAnimated("Sandbox - GitHub login");
+  const { input } = await import("@inquirer/prompts");
+  if (CLIENT_ID) {
+    const code = await startDeviceFlow(["repo", "delete_repo"]);
+    logger.info(heading("Authorize GitHub"));
+    logger.info(accentLine("code", code.user_code));
+    logger.info(accentLine("open", code.verification_uri));
+    logger.info("");
+    await openUrl(code.verification_uri);
+    logger.info(chalk4.dim("  Waiting for you to authorize in the browser..."));
+    try {
+      const token2 = await pollDeviceToken(code.device_code, code.interval, code.expires_in);
+      await saveToken(token2);
+      logger.success(`Authorized as ${await getUser(token2)}.`);
+    } catch (err) {
+      logger.error(`Device flow failed: ${err.message}`);
+      process.exitCode = 1;
+    }
+    return;
+  }
+  logger.info(heading("Authorize GitHub (least-privilege token)"));
+  logger.info("  Create a fine-grained token limited to your sandboxes only:");
+  logger.info(`  ${chalk4.cyan("https://github.com/settings/personal-access-tokens/new")}`);
+  logger.info(
+    chalk4.dim("  - Resource owner: a dedicated sandbox org (recommended) or your account")
+  );
+  logger.info(
+    chalk4.dim("  - Repository access: All repositories in that org (to create new sandboxes),")
+  );
+  logger.info(chalk4.dim("    or Only select repositories to manage existing ones"));
+  logger.info(
+    chalk4.dim("  - Permissions: Administration = Read and write, Contents = Read and write,")
+  );
+  logger.info(chalk4.dim("    Metadata = Read. Set a short expiry."));
+  logger.info(
+    chalk4.dim(
+      "  Tip: `eds sandbox new --org <sandbox-org>` so nothing in your personal account is touched."
+    )
+  );
+  logger.info("");
+  if (await (await import("@inquirer/prompts")).confirm({
+    message: "Open the token page?",
+    default: true
+  })) {
+    await openUrl("https://github.com/settings/personal-access-tokens/new");
+  }
+  const token = (await input({ message: "Paste the token", validate: (v) => !!v.trim() || "Required" })).trim();
+  try {
+    const login = await getUser(token);
+    await saveToken(token);
+    logger.success(`Authorized as ${login}.`);
+  } catch {
+    logger.error("That token didn't work (check the scopes).");
+    process.exitCode = 1;
+  }
 }
-function attr(n, name) {
-  return stripType(attrsOf(n)[`@_${name}`]);
+async function sandboxLogout() {
+  await clearToken();
+  logger.success("Signed out (stored GitHub token removed).");
 }
-function leafComponent(rt, n) {
-  const multiple = attr(n, "multiple") === "true" || attr(n, "multiple") === "{Boolean}true";
-  if (rt.endsWith("/form/textfield")) return "text";
-  if (rt.endsWith("/form/textarea")) return "textarea";
-  if (rt.includes("/richtext")) return "richtext";
-  if (rt.endsWith("/form/numberfield")) return "number";
-  if (rt.endsWith("/form/checkbox")) return "boolean";
-  if (rt.endsWith("/form/radiogroup")) return "radio-group";
-  if (rt.endsWith("/form/select")) return multiple ? "multiselect" : "select";
-  if (rt.endsWith("/form/datepicker")) return "date-time";
-  if (rt.endsWith("/form/pathfield") || rt.endsWith("/form/pathbrowser")) return "aem-content";
-  if (rt.includes("/fileupload") || rt.endsWith("/form/fileupload")) return "reference";
-  if (rt.includes("tagfield") || rt.includes("tagpicker") || rt.includes("tagbrowser"))
-    return "aem-tag";
-  if (rt.includes("contentfragment")) return "aem-content-fragment";
-  if (rt.includes("experiencefragment")) return "aem-experience-fragment";
-  return null;
+async function sandboxNew(name, options = {}) {
+  const auth = await resolveAuth();
+  if (!auth) return noAuth();
+  await logger.logoOnceAnimated("Sandbox");
+  const interactive = !options.yes;
+  const { select, confirm } = await import("@inquirer/prompts");
+  let template2 = options.boilerplate;
+  if (!template2) {
+    if (options.ue) template2 = BOILERPLATES.ue;
+    else if (interactive) {
+      template2 = await select({
+        message: "Which boilerplate?",
+        choices: [
+          { name: "Document Authoring (adobe/aem-boilerplate)", value: BOILERPLATES.document },
+          {
+            name: "Universal Editor / crosswalk (adobe/aem-boilerplate-xwalk)",
+            value: BOILERPLATES.ue
+          }
+        ]
+      });
+    } else template2 = BOILERPLATES.document;
+  }
+  let priv = options.private ?? false;
+  if (options.private === void 0 && interactive) {
+    priv = await select({
+      message: "Visibility?",
+      choices: [
+        { name: "Public", value: false },
+        { name: "Private", value: true }
+      ],
+      default: false
+    });
+  }
+  const owner = options.org ?? auth.login;
+  if (await exists(auth, owner, name)) {
+    logger.error(`A repository ${owner}/${name} already exists - refusing to touch it.`);
+    logger.info(
+      chalk4.dim("  Pick another name, or remove it first (e.g. `eds sandbox rm` for a sandbox).")
+    );
+    process.exitCode = 1;
+    return;
+  }
+  logger.info(heading("Creating sandbox", `${owner}/${name}  \xB7  ${template2}`));
+  try {
+    if (auth.mode === "api") {
+      const repo = await createFromTemplate(auth.token, template2, { owner, name, private: priv });
+      await addTopics(auth.token, owner, name, [SANDBOX_TOPIC]);
+      logger.info(chalk4.dim("  Cloning..."));
+      await run("git", ["clone", repo.cloneUrl, name], { stdio: "inherit" });
+    } else {
+      const repoRef = options.org ? `${options.org}/${name}` : name;
+      await run("gh", createArgs(repoRef, { template: template2, private: priv, clone: true }), {
+        stdio: "inherit"
+      });
+      try {
+        await run("gh", ["repo", "edit", `${owner}/${name}`, "--add-topic", SANDBOX_TOPIC]);
+      } catch {
+      }
+    }
+  } catch (err) {
+    logger.error(`Create failed: ${err.message}`);
+    process.exitCode = 1;
+    return;
+  }
+  logger.info("");
+  logger.info(heading("Sandbox ready"));
+  logger.info(accentLine("repo", `https://github.com/${owner}/${name}`));
+  logger.info(accentLine("preview", previewUrl(owner, name)));
+  logger.info("");
+  if (interactive) {
+    if (await confirm({ message: "Open the AEM Code Sync install page now?", default: true })) {
+      await openUrl(codeSyncInstallUrl());
+    }
+    if (await confirm({ message: `Configure authoring now (eds init in ./${name})?`, default: true })) {
+      const prevCwd = process.cwd();
+      try {
+        process.chdir(path11.join(prevCwd, name));
+        const { initProject: initProject2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+        await initProject2({});
+      } finally {
+        process.chdir(prevCwd);
+      }
+    }
+  } else {
+    logger.info(chalk4.dim(`  Install AEM Code Sync: ${codeSyncInstallUrl()}`));
+    logger.info(chalk4.dim(`  Configure authoring: cd ${name} && eds init`));
+  }
+  logger.info("");
+  logger.info(box([`Sandbox "${name}" ready - tear down with \`eds sandbox rm ${name}\``]));
 }
-function isWrapper(rt) {
-  return rt.includes("/foundation/container") || rt.includes("/foundation/fixedcolumns") || rt.includes("/foundation/well") || rt.includes("/foundation/tabs") || rt.includes("/foundation/form/fieldset") || rt.includes("/foundation/accordion");
+async function sandboxList() {
+  const auth = await resolveAuth();
+  if (!auth) return noAuth();
+  let names = [];
+  try {
+    if (auth.mode === "api") {
+      names = await searchByTopic(auth.token, auth.login, SANDBOX_TOPIC);
+    } else {
+      const out = await run("gh", [
+        "repo",
+        "list",
+        "--topic",
+        SANDBOX_TOPIC,
+        "--limit",
+        "100",
+        "--json",
+        "nameWithOwner",
+        "-q",
+        ".[].nameWithOwner"
+      ]);
+      names = out ? out.split("\n").filter(Boolean) : [];
+    }
+  } catch (err) {
+    logger.error(`List failed: ${err.message}`);
+    process.exitCode = 1;
+    return;
+  }
+  logger.info(heading("Sandboxes", `${names.length} tagged ${SANDBOX_TOPIC}`));
+  if (names.length === 0) {
+    logger.info(chalk4.dim("  None yet. Create one with `eds sandbox new <name>`."));
+    return;
+  }
+  const w = columnWidth(names);
+  for (const full of names) {
+    const [o, n2] = full.split("/");
+    logger.info(accentLine(full, previewUrl(o, n2), w));
+  }
 }
-function valueTypeFor(c) {
-  switch (c) {
-    case "number":
-      return "number";
+async function sandboxRm(name, options = {}) {
+  const auth = await resolveAuth();
+  if (!auth) return noAuth();
+  const owner = options.org ?? auth.login;
+  const repoRef = `${owner}/${name}`;
+  if (!options.yes) {
+    const { confirm } = await import("@inquirer/prompts");
+    const go = await confirm({
+      message: `Permanently delete ${repoRef}? This cannot be undone.`,
+      default: false
+    });
+    if (!go) {
+      logger.info("Cancelled.");
+      return;
+    }
+  }
+  try {
+    if (auth.mode === "api") await deleteRepo(auth.token, owner, name);
+    else await run("gh", ["repo", "delete", repoRef, "--yes"]);
+  } catch (err) {
+    logger.error(`Delete failed: ${err.message}`);
+    logger.info(
+      chalk4.dim(
+        "  Deleting needs the delete_repo scope (re-run `eds sandbox login`, or `gh auth refresh -s delete_repo`)."
+      )
+    );
+    process.exitCode = 1;
+    return;
+  }
+  logger.info(heading("Deleted"));
+  logger.info(accentLine(repoRef, "removed"));
+}
+var init_sandbox = __esm({
+  "src/commands/sandbox.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_api();
+    init_auth();
+    init_github();
+    init_ui();
+  }
+});
+
+// src/lib/template/authoring.ts
+import { existsSync as existsSync9 } from "fs";
+import { readFile as readFile5 } from "fs/promises";
+import path12 from "path";
+import { parse as parseYaml } from "yaml";
+async function detectAuthoring(projectRoot) {
+  const fstab = path12.join(projectRoot, "fstab.yaml");
+  if (existsSync9(fstab)) {
+    try {
+      const parsed = parseYaml(await readFile5(fstab, "utf-8")) ?? {};
+      const mp = parsed.mountpoints?.["/"];
+      const url = typeof mp === "string" ? mp : mp?.url ?? "";
+      const da = url.match(/content\.da\.live\/([^/]+)\/([^/]+)/);
+      if (da) return { model: "da", org: da[1], site: da[2], mountpoint: url };
+      if (/drive\.google\.com/.test(url)) return { model: "gdrive", mountpoint: url };
+      if (/sharepoint\.com|-my\.sharepoint/.test(url))
+        return { model: "sharepoint", mountpoint: url };
+      return { model: "document", mountpoint: url };
+    } catch {
+    }
+  }
+  return { model: "ue" };
+}
+var init_authoring = __esm({
+  "src/lib/template/authoring.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/lib/template/da.ts
+function daSourceUrl(org, site, path36) {
+  const clean = path36.replace(/^\/+/, "").replace(/\.html$/i, "");
+  return `https://admin.da.live/source/${org}/${site}/${clean}.html`;
+}
+function daEditUrl(org, site, path36) {
+  const clean = path36.replace(/^\/+/, "").replace(/\.html$/i, "");
+  return `https://da.live/edit#/${org}/${site}/${clean}`;
+}
+async function pushToDa(org, site, path36, html, token) {
+  const url = daSourceUrl(org, site, path36);
+  const form = new FormData();
+  form.append("data", new Blob([html], { type: "text/html" }), "content.html");
+  const headers2 = {};
+  if (token) headers2.Authorization = `Bearer ${token}`;
+  const res = await fetch(url, { method: "POST", body: form, headers: headers2 });
+  if (!res.ok) {
+    throw new Error(`DA push failed: ${res.status} ${res.statusText}`);
+  }
+  return url;
+}
+var init_da = __esm({
+  "src/lib/template/da.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/lib/template/page.ts
+function blockDiv(name) {
+  return `      <div class="${name}">
+        <div>
+          <div>${name} content</div>
+        </div>
+      </div>`;
+}
+function metadataBlock(opts) {
+  const rows = [
+    `          <div><div>Title</div><div>${opts.title}</div></div>`,
+    `          <div><div>Description</div><div>${opts.description ?? ""}</div></div>`
+  ];
+  if (opts.area) rows.push(`          <div><div>Template</div><div>${opts.area}</div></div>`);
+  return `      <div class="metadata">
+${rows.join("\n")}
+      </div>`;
+}
+function buildPageHtml(opts) {
+  const blocks = opts.blocks ?? [];
+  const intro = `    <div>
+      <h1>${opts.title}</h1>
+      <p>${opts.description ?? "Intro copy goes here."}</p>
+    </div>`;
+  const blockSections = blocks.map((b) => `    <div>
+${blockDiv(b)}
+    </div>`);
+  const metaSection = `    <div>
+${metadataBlock(opts)}
+    </div>`;
+  return `<body>
+  <header></header>
+  <main>
+${[intro, ...blockSections, metaSection].join("\n")}
+  </main>
+  <footer></footer>
+</body>
+`;
+}
+var init_page = __esm({
+  "src/lib/template/page.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/lib/template/ue.ts
+import { existsSync as existsSync10 } from "fs";
+import { readFile as readFile6 } from "fs/promises";
+import path13 from "path";
+function fieldDefault(field) {
+  if (field.value !== void 0) return field.value;
+  switch (field.valueType) {
     case "boolean":
-      return "boolean";
-    case "date-time":
-      return "date";
-    case "checkbox-group":
-      return "string[]";
-    case "aem-content":
-    case "aem-content-fragment":
-    case "aem-experience-fragment":
-      return void 0;
+      return false;
+    case "number":
+      return 0;
+    case "string[]":
+      return [];
     default:
-      return "string";
+      return "";
   }
 }
-function cleanName(raw, fallback) {
-  const n = (raw ?? "").replace(/^\.\//, "").trim();
-  return n || fallback;
+async function blockDefaults(projectRoot, block2) {
+  const file = path13.join(projectRoot, "blocks", block2, `_${block2}.json`);
+  if (!existsSync10(file)) return {};
+  try {
+    const parsed = JSON.parse(await readFile6(file, "utf-8"));
+    const models = Array.isArray(parsed.models) ? parsed.models : [];
+    const model2 = models.find((m) => m.id === block2) ?? models[0];
+    const fields = model2?.fields ?? [];
+    const out = {};
+    for (const f2 of fields) {
+      if (f2.component === "tab") continue;
+      out[f2.name] = f2.component === "container" ? [] : fieldDefault(f2);
+    }
+    return out;
+  } catch {
+    return {};
+  }
 }
-function readOptions(fieldNode) {
-  const items = childrenOf(fieldNode).find((c) => tagOf(c) === "items");
-  if (!items) return [];
-  return childrenOf(items).map((opt) => {
-    const value = attr(opt, "value") ?? "";
-    const name = attr(opt, "text") ?? attr(opt, "jcr:title") ?? value;
-    return { name, value };
-  });
+async function buildUeTemplate(projectRoot, opts) {
+  const components = [];
+  for (const b of opts.blocks) {
+    components.push({ name: b, model: b, fields: await blockDefaults(projectRoot, b) });
+  }
+  const template2 = { title: opts.title, template: opts.name, components };
+  return `${JSON.stringify(template2, null, 2)}
+`;
 }
-function walk(nodes, out, unmapped, counter) {
-  for (const node of nodes) {
-    const rt = attr(node, "sling:resourceType") ?? "";
-    if (rt.endsWith("/foundation/tabs")) {
-      const items = childrenOf(node).find((c) => tagOf(c) === "items");
-      for (const tab of items ? childrenOf(items) : []) {
-        const label = attr(tab, "jcr:title");
-        out.push({ component: "tab", name: cleanName(void 0, tagOf(tab)), label });
-        walk(childrenOf(tab), out, unmapped, counter);
-      }
-      continue;
+var init_ue2 = __esm({
+  "src/lib/template/ue.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/commands/template.ts
+var template_exports = {};
+__export(template_exports, {
+  templateNew: () => templateNew
+});
+import { existsSync as existsSync11 } from "fs";
+import { mkdir as mkdir5, readFile as readFile7, readdir, writeFile as writeFile9 } from "fs/promises";
+import path14 from "path";
+import chalk5 from "chalk";
+async function projectBlocks(projectRoot) {
+  const dir = path14.join(projectRoot, "blocks");
+  if (!existsSync11(dir)) return [];
+  return (await readdir(dir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+}
+async function readEdsrcAdmin(projectRoot) {
+  const rc = path14.join(projectRoot, ".edsrc.json");
+  if (!existsSync11(rc)) return {};
+  try {
+    return JSON.parse(await readFile7(rc, "utf-8")).admin ?? {};
+  } catch {
+    return {};
+  }
+}
+async function registerBlocks(projectRoot, blocks) {
+  if (!blocks.length) return false;
+  const file = path14.join(projectRoot, "component-filters.json");
+  let existing = null;
+  if (existsSync11(file)) {
+    try {
+      existing = JSON.parse(await readFile7(file, "utf-8"));
+    } catch {
+      existing = null;
     }
-    if (rt.endsWith("/form/multifield")) {
-      const sub = [];
-      walk(childrenOf(node), sub, unmapped, counter);
-      const name = cleanName(attr(node, "name"), `items${counter.i++}`);
-      out.push({
-        component: "container",
-        name,
-        label: attr(node, "fieldLabel") ?? "Items",
-        multi: true,
-        collapsible: true,
-        fields: sub
+  }
+  const filters = mergeSectionFilter(existing, blocks);
+  await writeFile9(file, `${JSON.stringify(filters, null, 2)}
+`);
+  return true;
+}
+async function templateNew(nameArg, options = {}) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    logger.error("Not inside an EDS project (no EDS project markers found).");
+    process.exitCode = 1;
+    return;
+  }
+  await logger.logoOnceAnimated("Page template");
+  const { input, select, confirm } = await import("@inquirer/prompts");
+  const interactive = !options.yes;
+  const detected = await detectAuthoring(projectRoot);
+  const model2 = options.authoring ?? detected.model;
+  const name = slug2(nameArg);
+  const title = options.title ?? (interactive ? await input({ message: "Page title", default: nameArg }) : nameArg);
+  const description = options.description ?? (interactive ? await input({ message: "Description (optional)" }) : "");
+  const pagePath = options.path ?? `/templates/${name}`;
+  let blocks = options.blocks;
+  if (!blocks && interactive) {
+    const available = await projectBlocks(projectRoot);
+    const pool = available.length ? available : STANDARD_BLOCKS.map((b) => b.id);
+    const ordered = [];
+    let adding = true;
+    while (adding) {
+      const pick = await select({
+        message: `Add a block in order (${ordered.length} so far)`,
+        choices: [
+          ...pool.map((b) => ({ name: b, value: b })),
+          { name: ordered.length ? "- done -" : "- done (empty page) -", value: "__done" }
+        ]
       });
-      continue;
+      if (pick === "__done") adding = false;
+      else ordered.push(pick);
     }
-    const comp = rt ? leafComponent(rt, node) : null;
-    if (comp) {
-      const name = cleanName(attr(node, "name"), `field${counter.i++}`);
-      const field = { component: comp, name };
-      const vt = valueTypeFor(comp);
-      if (vt) field.valueType = vt;
-      const label = attr(node, "fieldLabel") ?? attr(node, "text");
-      if (label) field.label = label;
-      if (comp === "select" || comp === "radio-group" || comp === "multiselect") {
-        const options = readOptions(node);
-        if (options.length) field.options = options;
+    blocks = ordered;
+  }
+  const seeded = blocks ?? [];
+  const html = buildPageHtml({
+    title,
+    description: description || void 0,
+    blocks: seeded,
+    area: options.area
+  });
+  const localRel = path14.join("templates", `${name}.html`);
+  await mkdir5(path14.join(projectRoot, "templates"), { recursive: true });
+  await writeFile9(path14.join(projectRoot, localRel), html);
+  logger.info(heading("Page template", `${pagePath}  \xB7  ${model2}`));
+  logger.info(accentLine(localRel, `${seeded.length} block(s) + metadata`));
+  if (model2 === "da") {
+    const admin = await readEdsrcAdmin(projectRoot);
+    const org = options.org ?? admin.org ?? detected.org;
+    const site = options.site ?? admin.site ?? detected.site;
+    const wantPush = options.push ?? (interactive ? await confirm({ message: "Push to DA (da.live)?", default: true }) : true);
+    if (wantPush) {
+      if (!org || !site) {
+        logger.warn("No DA org/site. Pass --org/--site or set admin in .edsrc.json.");
+      } else {
+        try {
+          await pushToDa(org, site, pagePath, html, process.env.DA_TOKEN);
+          logger.info(accentLine("pushed to DA", daEditUrl(org, site, pagePath)));
+        } catch (err) {
+          logger.error(`DA push failed: ${err.message}`);
+          logger.info(chalk5.dim("  Open projects allow anonymous writes; others need DA_TOKEN."));
+        }
       }
-      const def = attr(node, "value") ?? (comp === "boolean" ? attr(node, "checked") : void 0);
-      if (def !== void 0 && def !== "") field.value = comp === "boolean" ? def === "true" : def;
-      out.push(field);
-      continue;
     }
-    if (rt && attr(node, "name") && !isWrapper(rt)) unmapped.add(rt);
-    walk(childrenOf(node), out, unmapped, counter);
-  }
-}
-function parseDialog(xml) {
-  const parser = new XMLParser({
-    ignoreAttributes: false,
-    attributeNamePrefix: "@_",
-    preserveOrder: true,
+  } else if (model2 === "gdrive" || model2 === "sharepoint") {
+    const where = model2 === "gdrive" ? "a Google Doc" : "a Word doc";
+    logger.info("");
+    logger.info(
+      chalk5.dim(`  Document model: import ${localRel} into ${where} in your mounted folder,`)
+    );
+    logger.info(
+      chalk5.dim("  then preview/publish. (Share the folder + install aem-code-sync first.)")
+    );
+  } else if (model2 === "ue") {
+    const jsonRel = path14.join("templates", `${name}.json`);
+    await writeFile9(
+      path14.join(projectRoot, jsonRel),
+      await buildUeTemplate(projectRoot, { title, name, blocks: seeded })
+    );
+    logger.info(
+      accentLine(jsonRel, `initial content (${seeded.length} component(s), in order)`)
+    );
+    const registered = await registerBlocks(projectRoot, seeded);
+    if (registered) {
+      logger.info(
+        accentLine("component-filters.json", "seeded blocks allowed in Universal Editor")
+      );
+    }
+    logger.info("");
+    logger.info(
+      chalk5.dim("  Universal Editor: use the template JSON as the page's initial content, then")
+    );
+    logger.info(chalk5.dim("  author it in the Universal Editor (wire the repo to AEM)."));
+  }
+  logger.info("");
+  logger.info(box([`"${name}" template (${model2}) - preview with \`eds preview ${pagePath}\``]));
+}
+var slug2;
+var init_template = __esm({
+  "src/commands/template.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_project();
+    init_blocks();
+    init_ue();
+    init_authoring();
+    init_da();
+    init_page();
+    init_ue2();
+    init_ui();
+    slug2 = (s) => s.trim().toLowerCase().replace(/[^a-z0-9-/]+/g, "-").replace(/^-+|-+$/g, "");
+  }
+});
+
+// src/lib/migrate/clientlib.ts
+import { existsSync as existsSync12 } from "fs";
+import { readFile as readFile8, readdir as readdir2 } from "fs/promises";
+import path15 from "path";
+async function listFiles(dir) {
+  const out = [];
+  const walk3 = async (d) => {
+    for (const e of await readdir2(d, { withFileTypes: true })) {
+      const p = path15.join(d, e.name);
+      if (e.isDirectory()) await walk3(p);
+      else out.push(p);
+    }
+  };
+  if (existsSync12(dir)) await walk3(dir);
+  return out;
+}
+async function findClientlibDir(componentDir) {
+  if (!existsSync12(componentDir)) return null;
+  const entries = await readdir2(componentDir, { withFileTypes: true });
+  const match = entries.find((e) => e.isDirectory() && /clientlib/i.test(e.name));
+  if (match) return path15.join(componentDir, match.name);
+  const hasCss = entries.some((e) => e.isFile() && e.name.endsWith(".css"));
+  return hasCss ? componentDir : null;
+}
+async function readClientlibCss(clientlibDir) {
+  const all = await listFiles(clientlibDir);
+  const preprocessed = all.filter((f2) => /\.(less|scss|sass)$/i.test(f2)).map((f2) => path15.relative(clientlibDir, f2));
+  let cssFiles;
+  const cssTxt = path15.join(clientlibDir, "css.txt");
+  if (existsSync12(cssTxt)) {
+    const lines = (await readFile8(cssTxt, "utf-8")).split("\n").map((l) => l.trim());
+    let base = clientlibDir;
+    const listed = [];
+    for (const l of lines) {
+      if (!l) continue;
+      const baseMatch = l.match(/^#base\s*=\s*(.+)$/);
+      if (baseMatch) base = path15.join(clientlibDir, baseMatch[1].trim());
+      else if (!l.startsWith("#")) listed.push(l);
+    }
+    cssFiles = listed.map((rel) => path15.join(base, rel)).filter((f2) => existsSync12(f2) && f2.endsWith(".css"));
+  } else {
+    cssFiles = all.filter((f2) => f2.endsWith(".css"));
+  }
+  const parts = [];
+  for (const f2 of cssFiles) parts.push(await readFile8(f2, "utf-8"));
+  return {
+    css: parts.join("\n\n"),
+    files: cssFiles.map((f2) => path15.relative(clientlibDir, f2)),
+    preprocessed
+  };
+}
+var init_clientlib = __esm({
+  "src/lib/migrate/clientlib.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/lib/migrate/dialog.ts
+import { XMLParser } from "fast-xml-parser";
+function tagOf(n2) {
+  return Object.keys(n2).find((k) => k !== ":@") ?? "";
+}
+function childrenOf(n2) {
+  const t = tagOf(n2);
+  const v = n2[t];
+  return Array.isArray(v) ? v : [];
+}
+function attrsOf(n2) {
+  return n2[":@"] ?? {};
+}
+function stripType(v) {
+  return typeof v === "string" ? v.replace(/^\{[^}]+\}/, "") : v;
+}
+function attr(n2, name) {
+  return stripType(attrsOf(n2)[`@_${name}`]);
+}
+function leafComponent(rt, n2) {
+  const multiple = attr(n2, "multiple") === "true" || attr(n2, "multiple") === "{Boolean}true";
+  if (rt.endsWith("/form/textfield")) return "text";
+  if (rt.endsWith("/form/textarea")) return "textarea";
+  if (rt.includes("/richtext")) return "richtext";
+  if (rt.endsWith("/form/numberfield")) return "number";
+  if (rt.endsWith("/form/checkbox")) return "boolean";
+  if (rt.endsWith("/form/radiogroup")) return "radio-group";
+  if (rt.endsWith("/form/select")) return multiple ? "multiselect" : "select";
+  if (rt.endsWith("/form/datepicker")) return "date-time";
+  if (rt.endsWith("/form/pathfield") || rt.endsWith("/form/pathbrowser")) return "aem-content";
+  if (rt.includes("/fileupload") || rt.endsWith("/form/fileupload")) return "reference";
+  if (rt.includes("tagfield") || rt.includes("tagpicker") || rt.includes("tagbrowser"))
+    return "aem-tag";
+  if (rt.includes("contentfragment")) return "aem-content-fragment";
+  if (rt.includes("experiencefragment")) return "aem-experience-fragment";
+  return null;
+}
+function isWrapper(rt) {
+  return rt.includes("/foundation/container") || rt.includes("/foundation/fixedcolumns") || rt.includes("/foundation/well") || rt.includes("/foundation/tabs") || rt.includes("/foundation/form/fieldset") || rt.includes("/foundation/accordion");
+}
+function valueTypeFor(c) {
+  switch (c) {
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date-time":
+      return "date";
+    case "checkbox-group":
+      return "string[]";
+    case "aem-content":
+    case "aem-content-fragment":
+    case "aem-experience-fragment":
+      return void 0;
+    default:
+      return "string";
+  }
+}
+function cleanName(raw, fallback) {
+  const n2 = (raw ?? "").replace(/^\.\//, "").trim();
+  return n2 || fallback;
+}
+function readOptions(fieldNode) {
+  const items = childrenOf(fieldNode).find((c) => tagOf(c) === "items");
+  if (!items) return [];
+  return childrenOf(items).map((opt) => {
+    const value = attr(opt, "value") ?? "";
+    const name = attr(opt, "text") ?? attr(opt, "jcr:title") ?? value;
+    return { name, value };
+  });
+}
+function walk(nodes, out, unmapped, counter) {
+  for (const node of nodes) {
+    const rt = attr(node, "sling:resourceType") ?? "";
+    if (rt.endsWith("/foundation/tabs")) {
+      const items = childrenOf(node).find((c) => tagOf(c) === "items");
+      for (const tab of items ? childrenOf(items) : []) {
+        const label = attr(tab, "jcr:title");
+        out.push({ component: "tab", name: cleanName(void 0, tagOf(tab)), label });
+        walk(childrenOf(tab), out, unmapped, counter);
+      }
+      continue;
+    }
+    if (rt.endsWith("/form/multifield")) {
+      const sub = [];
+      walk(childrenOf(node), sub, unmapped, counter);
+      const name = cleanName(attr(node, "name"), `items${counter.i++}`);
+      out.push({
+        component: "container",
+        name,
+        label: attr(node, "fieldLabel") ?? "Items",
+        multi: true,
+        collapsible: true,
+        fields: sub
+      });
+      continue;
+    }
+    const comp = rt ? leafComponent(rt, node) : null;
+    if (comp) {
+      const name = cleanName(attr(node, "name"), `field${counter.i++}`);
+      const field = { component: comp, name };
+      const vt = valueTypeFor(comp);
+      if (vt) field.valueType = vt;
+      const label = attr(node, "fieldLabel") ?? attr(node, "text");
+      if (label) field.label = label;
+      if (comp === "select" || comp === "radio-group" || comp === "multiselect") {
+        const options = readOptions(node);
+        if (options.length) field.options = options;
+      }
+      const def = attr(node, "value") ?? (comp === "boolean" ? attr(node, "checked") : void 0);
+      if (def !== void 0 && def !== "") field.value = comp === "boolean" ? def === "true" : def;
+      out.push(field);
+      continue;
+    }
+    if (rt && attr(node, "name") && !isWrapper(rt)) unmapped.add(rt);
+    walk(childrenOf(node), out, unmapped, counter);
+  }
+}
+function parseDialog(xml) {
+  const parser = new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    preserveOrder: true,
     removeNSPrefix: false,
     trimValues: true
   });
   const tree = parser.parse(xml);
-  const root = tree.find((n) => tagOf(n) === "jcr:root");
+  const root = tree.find((n2) => tagOf(n2) === "jcr:root");
   const fields = [];
   const unmapped = /* @__PURE__ */ new Set();
   if (root) walk(childrenOf(root), fields, unmapped, { i: 1 });
   return { fields, unmapped: [...unmapped] };
 }
-var init_dialog = __esm({
-  "src/lib/migrate/dialog.ts"() {
+var init_dialog = __esm({
+  "src/lib/migrate/dialog.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/lib/migrate/component.ts
+import { existsSync as existsSync13 } from "fs";
+import { readFile as readFile9 } from "fs/promises";
+import path16 from "path";
+import { XMLParser as XMLParser2 } from "fast-xml-parser";
+function findDialogFile(componentDir) {
+  const candidates = [
+    path16.join(componentDir, "_cq_dialog", ".content.xml"),
+    path16.join(componentDir, "_cq_dialog.xml"),
+    path16.join(componentDir, "cq:dialog", ".content.xml")
+  ];
+  return candidates.find((c) => existsSync13(c)) ?? null;
+}
+async function readComponentTitle(componentDir) {
+  const file = path16.join(componentDir, ".content.xml");
+  if (!existsSync13(file)) return void 0;
+  try {
+    const parser = new XMLParser2({ ignoreAttributes: false, attributeNamePrefix: "@_" });
+    const parsed = parser.parse(await readFile9(file, "utf-8"));
+    const root = parsed["jcr:root"] ?? {};
+    const title = root["@_jcr:title"];
+    return typeof title === "string" ? title.replace(/^\{[^}]+\}/, "") : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function readDialogFields(componentDir) {
+  const dialog = findDialogFile(componentDir);
+  if (!dialog) return null;
+  return parseDialog(await readFile9(dialog, "utf-8"));
+}
+function migratedModelFile(blockName, title, fields) {
+  const model2 = {
+    definitions: [
+      {
+        title,
+        id: blockName,
+        plugins: {
+          xwalk: {
+            page: {
+              resourceType: "core/franklin/components/block/v1/block",
+              template: { name: title, model: blockName }
+            }
+          }
+        }
+      }
+    ],
+    models: [{ id: blockName, fields }],
+    filters: []
+  };
+  return `${JSON.stringify(model2, null, 2)}
+`;
+}
+function migratedBlockJs(blockName, fields) {
+  const hasContainer = fields.some((f2) => f2.component === "container" && f2.multi);
+  const body = hasContainer ? `  // This block was migrated from a classic AEM component with a multifield.
+  // Each child row is one repeated item - enhance them here.
+  [...block.children].forEach((row) => {
+    row.classList.add('${blockName}-item');
+  });` : `  // Migrated from a classic AEM component. The authored fields arrive as
+  // rows; read and enhance them here (port the old HTL logic as needed).`;
+  return `// Block: ${blockName}
+// Migrated from a classic AEM component by \`eds migrate component\`.
+// TODO: port the component's HTL/JS behaviour into this decorator.
+export default function decorate(block) {
+  block.classList.add('${blockName}');
+${body}
+}
+`;
+}
+function migratedBlockCss(blockName) {
+  return `/* Block: ${blockName} */
+/* Migrated from a classic AEM component. Bring the component's styles here */
+/* (from its clientlib or the rendered page) and keep them scoped to the block. */
+.${blockName} {
+}
+`;
+}
+var init_component = __esm({
+  "src/lib/migrate/component.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_dialog();
+  }
+});
+
+// src/lib/track.ts
+function trackSnippet(blockName, param, events) {
+  const parts = [`  // --- ${TRACK_MARKER} ---`];
+  if (events.click) {
+    parts.push(
+      `  ${param}.addEventListener('click', (ev) => {`,
+      "    const el = ev.target.closest('a, button');",
+      "    if (!el) return;",
+      `    trackEvent({ event: 'block_click', block: '${blockName}', label: el.dataset.track || el.textContent.trim() });`,
+      "  });"
+    );
+  }
+  if (events.submit) {
+    parts.push(
+      `  ${param}.addEventListener('submit', () => {`,
+      `    trackEvent({ event: 'form_submit', block: '${blockName}' });`,
+      "  });"
+    );
+  }
+  return parts.join("\n");
+}
+function instrumentJs(js, blockName, events) {
+  if (js.includes(TRACK_MARKER)) return { js, changed: false, reason: "already instrumented" };
+  if (!events.click && !events.submit) return { js, changed: false, reason: "no events selected" };
+  const decorate = js.match(
+    /export default (?:async )?function decorate\s*\(\s*([A-Za-z_$][\w$]*)?[^)]*\)\s*\{/
+  );
+  if (!decorate || decorate.index === void 0) {
+    return { js, changed: false, reason: "no `export default function decorate(...)` found" };
+  }
+  const param = decorate[1] || "block";
+  let out = js;
+  if (!out.includes("scripts/analytics.js")) {
+    const imports = [...out.matchAll(/^import .*$/gm)];
+    if (imports.length) {
+      const last = imports[imports.length - 1];
+      const at2 = (last.index ?? 0) + last[0].length;
+      out = `${out.slice(0, at2)}
+${IMPORT_LINE}${out.slice(at2)}`;
+    } else {
+      out = `${IMPORT_LINE}
+
+${out}`;
+    }
+  }
+  const d2 = out.match(
+    /export default (?:async )?function decorate\s*\(\s*([A-Za-z_$][\w$]*)?[^)]*\)\s*\{/
+  );
+  if (!d2 || d2.index === void 0)
+    return { js: out, changed: false, reason: "decorate not found" };
+  const at = d2.index + d2[0].length;
+  const snippet = trackSnippet(blockName, param, events);
+  out = `${out.slice(0, at)}
+${snippet}
+${out.slice(at)}`;
+  return { js: out, changed: true };
+}
+var TRACK_MARKER, IMPORT_LINE;
+var init_track = __esm({
+  "src/lib/track.ts"() {
+    "use strict";
+    init_esm_shims();
+    TRACK_MARKER = "analytics (eds track)";
+    IMPORT_LINE = "import { trackEvent } from '../../scripts/analytics.js';";
+  }
+});
+
+// src/commands/track.ts
+var track_exports = {};
+__export(track_exports, {
+  trackBlock: () => trackBlock
+});
+import { existsSync as existsSync14 } from "fs";
+import { readFile as readFile10, writeFile as writeFile10 } from "fs/promises";
+import path17 from "path";
+import chalk6 from "chalk";
+async function trackBlock(blockName, options = {}) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    logger.error("Not inside an EDS project (no EDS project markers found).");
+    process.exitCode = 1;
+    return;
+  }
+  logger.logoOnce(logo("Track block"));
+  const jsPath = path17.join(projectRoot, "blocks", blockName, `${blockName}.js`);
+  if (!existsSync14(jsPath)) {
+    logger.error(`Block "${blockName}" not found (no blocks/${blockName}/${blockName}.js).`);
+    process.exitCode = 1;
+    return;
+  }
+  const events = { click: options.click !== false, submit: options.submit !== false };
+  const res = instrumentJs(await readFile10(jsPath, "utf-8"), blockName, events);
+  if (!res.changed) {
+    logger.warn(`Not instrumented: ${res.reason}.`);
+    return;
+  }
+  await writeFile10(jsPath, res.js);
+  logger.info(heading("Instrumented"));
+  const picked = [events.click ? "block_click" : null, events.submit ? "form_submit" : null].filter(
+    Boolean
+  );
+  logger.info(accentLine(`blocks/${blockName}/${blockName}.js`, picked.join(" + ")));
+  if (!existsSync14(path17.join(projectRoot, "scripts", "analytics.js"))) {
+    logger.info("");
+    logger.warn("scripts/analytics.js is missing - run `eds integrate gtm` to create it.");
+  }
+  logger.info("");
+  logger.info(chalk6.dim("  Events push to window.dataLayer via trackEvent - GTM picks them up."));
+}
+var init_track2 = __esm({
+  "src/commands/track.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_project();
+    init_track();
+    init_ui();
+  }
+});
+
+// src/commands/migrate.ts
+var migrate_exports = {};
+__export(migrate_exports, {
+  migrateComponent: () => migrateComponent
+});
+import { existsSync as existsSync15 } from "fs";
+import { mkdir as mkdir6, writeFile as writeFile11 } from "fs/promises";
+import path18 from "path";
+function clientlibBlockCss(blockName, css, files) {
+  return `/* Block: ${blockName} */
+/* Migrated from the component clientlib: ${files.join(", ")}. */
+/* TODO: review selectors and scope them under .${blockName} (and port any LESS/SCSS). */
+
+${css.trim()}
+`;
+}
+function previewFields(fields, depth = 0) {
+  const lines = [];
+  for (const f2 of fields) {
+    const indent = "  ".repeat(depth);
+    if (f2.component === "tab") {
+      lines.push(`${indent}${brand.blue("\u25B8")} ${f2.label ?? f2.name}`);
+    } else {
+      const opts = f2.options?.length ? ` (${f2.options.length} options)` : "";
+      const multi = f2.multi ? " \xB7multi" : "";
+      const label = f2.label ? `- ${f2.label}` : "";
+      lines.push(`${indent}${brand.accent(f2.component)}${multi}  ${f2.name}${opts}  ${label}`);
+      if (f2.fields?.length) lines.push(...previewFields(f2.fields, depth + 1));
+    }
+  }
+  return lines;
+}
+function countLeaves(fields) {
+  let n2 = 0;
+  for (const f2 of fields) {
+    if (f2.component === "tab") continue;
+    n2 += 1;
+    if (f2.fields) n2 += countLeaves(f2.fields);
+  }
+  return n2;
+}
+async function migrateComponent(dirArg, options = {}) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    logger.error("Not inside an EDS project (no EDS project markers found).");
+    process.exitCode = 1;
+    return;
+  }
+  await logger.logoOnceAnimated("Migrate component");
+  const { input, confirm } = await import("@inquirer/prompts");
+  const interactive = !options.yes;
+  let componentDir = dirArg;
+  if (!componentDir && interactive) {
+    componentDir = await input({
+      message: "Path to the classic component folder",
+      validate: (v) => existsSync15(v.trim()) || "Folder not found"
+    });
+  }
+  if (!componentDir) {
+    logger.error("Provide the path to the classic component folder.");
+    process.exitCode = 1;
+    return;
+  }
+  componentDir = path18.resolve(componentDir.trim());
+  if (!findDialogFile(componentDir)) {
+    logger.error(`No Touch UI dialog (_cq_dialog/.content.xml) found in ${componentDir}.`);
+    process.exitCode = 1;
+    return;
+  }
+  const parsed = await readDialogFields(componentDir);
+  if (!parsed || parsed.fields.length === 0) {
+    logger.warn("Dialog found but no mappable fields were detected.");
+    if (parsed?.unmapped.length)
+      logger.info(`Unmapped resourceTypes: ${parsed.unmapped.join(", ")}`);
+    process.exitCode = 1;
+    return;
+  }
+  const title = await readComponentTitle(componentDir) ?? path18.basename(componentDir);
+  const blockName = options.name && slug3(options.name) || (interactive ? slug3(await input({ message: "Block name", default: slug3(title) })) : slug3(title));
+  logger.info(heading("Mapped fields", `${countLeaves(parsed.fields)} from dialog`));
+  for (const line of previewFields(parsed.fields)) logger.info(`  ${line}`);
+  if (parsed.unmapped.length) {
+    logger.info("");
+    logger.warn(`Skipped (unrecognised): ${parsed.unmapped.join(", ")}`);
+  }
+  logger.info("");
+  if (interactive) {
+    const go = await confirm({ message: `Generate block "${blockName}"?`, default: true });
+    if (!go) {
+      logger.info("Cancelled.");
+      return;
+    }
+  }
+  const blockDir = path18.join(projectRoot, "blocks", blockName);
+  if (existsSync15(blockDir)) {
+    logger.error(
+      `Block "${blockName}" already exists at blocks/${blockName}. Use --name to pick another.`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const clibDir = options.clientlib ? path18.resolve(options.clientlib.trim()) : await findClientlibDir(componentDir);
+  let cssContent = migratedBlockCss(blockName);
+  let cssMessage = "empty - add styles from clientlib / rendered CSS";
+  let preprocessedNote = [];
+  if (clibDir && existsSync15(clibDir)) {
+    const lib = await readClientlibCss(clibDir);
+    if (lib.css.trim()) {
+      cssContent = clientlibBlockCss(blockName, lib.css, lib.files);
+      cssMessage = `from clientlib (${lib.files.length} file(s)) - review & scope`;
+    }
+    preprocessedNote = lib.preprocessed;
+  }
+  await mkdir6(blockDir, { recursive: true });
+  await writeFile11(
+    path18.join(blockDir, `${blockName}.js`),
+    migratedBlockJs(blockName, parsed.fields)
+  );
+  await writeFile11(path18.join(blockDir, `${blockName}.css`), cssContent);
+  await writeFile11(
+    path18.join(blockDir, `_${blockName}.json`),
+    migratedModelFile(blockName, title, parsed.fields)
+  );
+  logger.info(heading("Created"));
+  const files = [`${blockName}.js`, `${blockName}.css`, `_${blockName}.json`];
+  const w = columnWidth(files);
+  logger.info(accentLine(`${blockName}.js`, "decorator stub (port HTL logic)", w));
+  logger.info(accentLine(`${blockName}.css`, cssMessage, w));
+  logger.info(accentLine(`_${blockName}.json`, "Universal Editor model", w));
+  if (preprocessedNote.length) {
+    logger.info("");
+    logger.warn(`LESS/SCSS found (needs a build, not copied): ${preprocessedNote.join(", ")}`);
+  }
+  logger.info("");
+  if (interactive) {
+    const addTracking = await confirm({
+      message: "Instrument this block for analytics (dataLayer)?",
+      default: false
+    });
+    if (addTracking) {
+      const { trackBlock: trackBlock2 } = await Promise.resolve().then(() => (init_track2(), track_exports));
+      await trackBlock2(blockName, {});
+    }
+  }
+  logger.info(
+    box([`"${blockName}" migrated. Next: add CSS, then \`eds block preview ${blockName}\``])
+  );
+}
+var slug3;
+var init_migrate = __esm({
+  "src/commands/migrate.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_clientlib();
+    init_component();
+    init_project();
+    init_ui();
+    slug3 = (s) => s.trim().toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
+  }
+});
+
+// src/lib/model/helpers.ts
+function n(prefix, base) {
+  if (!prefix) return base;
+  return prefix + base.charAt(0).toUpperCase() + base.slice(1);
+}
+var f;
+var init_helpers2 = __esm({
+  "src/lib/model/helpers.ts"() {
+    "use strict";
+    init_esm_shims();
+    f = {
+      text: (name, label) => ({
+        component: "text",
+        valueType: "string",
+        name,
+        label
+      }),
+      textarea: (name, label) => ({
+        component: "textarea",
+        valueType: "string",
+        name,
+        label
+      }),
+      richtext: (name, label) => ({
+        component: "richtext",
+        valueType: "string",
+        name,
+        value: "",
+        label
+      }),
+      number: (name, label) => ({
+        component: "number",
+        valueType: "number",
+        name,
+        label
+      }),
+      boolean: (name, label, value = false) => ({
+        component: "boolean",
+        valueType: "boolean",
+        name,
+        value,
+        label
+      }),
+      dateTime: (name, label) => ({
+        component: "date-time",
+        valueType: "date",
+        name,
+        label
+      }),
+      select: (name, label, options, value) => ({
+        component: "select",
+        valueType: "string",
+        name,
+        label,
+        options,
+        ...value !== void 0 ? { value } : {}
+      }),
+      multiselect: (name, label, options) => ({
+        component: "multiselect",
+        valueType: "string",
+        name,
+        label,
+        options
+      }),
+      radioGroup: (name, label, options, value) => ({
+        component: "radio-group",
+        valueType: "string",
+        name,
+        label,
+        options,
+        ...value !== void 0 ? { value } : {}
+      }),
+      checkboxGroup: (name, label, options) => ({
+        component: "checkbox-group",
+        valueType: "string[]",
+        name,
+        label,
+        options
+      }),
+      reference: (name, label) => ({
+        component: "reference",
+        valueType: "string",
+        name,
+        label
+      }),
+      aemContent: (name, label) => ({ component: "aem-content", name, label }),
+      aemContentFragment: (name, label) => ({
+        component: "aem-content-fragment",
+        name,
+        label
+      }),
+      aemExperienceFragment: (name, label) => ({
+        component: "aem-experience-fragment",
+        name,
+        label
+      }),
+      aemTag: (name, label) => ({
+        component: "aem-tag",
+        valueType: "string",
+        name,
+        label
+      }),
+      tab: (name, label) => ({ component: "tab", name, label }),
+      container: (name, label, fields, collapsible = true) => ({
+        component: "container",
+        name,
+        label,
+        multi: true,
+        collapsible,
+        fields
+      })
+    };
+  }
+});
+
+// src/lib/model/partials.ts
+function partialById(id) {
+  return PARTIALS.find((p) => p.id === id);
+}
+var HEADING_LEVELS, LINK_TARGETS, BUTTON_STYLES, SECTION_STYLES, heading2, eyebrow, image, richtext, link, cta, ctaGroup, classes, embed, teaser, card, PARTIALS;
+var init_partials = __esm({
+  "src/lib/model/partials.ts"() {
     "use strict";
     init_esm_shims();
+    init_helpers2();
+    HEADING_LEVELS = [
+      { name: "H1", value: "h1" },
+      { name: "H2", value: "h2" },
+      { name: "H3", value: "h3" },
+      { name: "H4", value: "h4" },
+      { name: "H5", value: "h5" },
+      { name: "H6", value: "h6" }
+    ];
+    LINK_TARGETS = [
+      { name: "Same tab", value: "_self" },
+      { name: "New tab", value: "_blank" }
+    ];
+    BUTTON_STYLES = [
+      { name: "Default", value: "" },
+      { name: "Primary", value: "primary" },
+      { name: "Secondary", value: "secondary" }
+    ];
+    SECTION_STYLES = [
+      { name: "Highlight", value: "highlight" },
+      { name: "Dark", value: "dark" },
+      { name: "Centered", value: "centered" },
+      { name: "Full width", value: "full-width" }
+    ];
+    heading2 = (p = "") => [
+      f.text(n(p, "title"), "Title"),
+      f.select(n(p, "titleType"), "Heading level", HEADING_LEVELS, "h2")
+    ];
+    eyebrow = (p = "") => [f.text(n(p, "eyebrow"), "Eyebrow")];
+    image = (p = "") => [
+      f.reference(n(p, "image"), "Image"),
+      f.text(n(p, "imageAlt"), "Alt text")
+    ];
+    richtext = (p = "") => [f.richtext(n(p, "text"), "Text")];
+    link = (p = "") => [
+      f.text(n(p, "linkText"), "Link text"),
+      f.aemContent(n(p, "link"), "Link"),
+      f.select(n(p, "linkTarget"), "Open in", LINK_TARGETS, "_self")
+    ];
+    cta = (p = "") => [
+      ...link(p),
+      f.select(n(p, "ctaStyle"), "Style", BUTTON_STYLES, "")
+    ];
+    ctaGroup = (p = "") => [
+      f.container(n(p, "ctas") || "ctas", "Buttons", cta())
+    ];
+    classes = (p = "") => [
+      f.multiselect(n(p, "classes"), "Styles", SECTION_STYLES)
+    ];
+    embed = (p = "") => [f.aemContent(n(p, "url"), "URL (video / embed)")];
+    teaser = (p = "") => [
+      ...image(p),
+      ...eyebrow(p),
+      ...heading2(p),
+      ...richtext(p),
+      ...cta(p)
+    ];
+    card = (p = "") => [
+      ...image(p),
+      f.text(n(p, "title"), "Title"),
+      f.richtext(n(p, "description"), "Description"),
+      ...link(p)
+    ];
+    PARTIALS = [
+      { id: "heading", label: "Heading (title + level)", build: heading2 },
+      { id: "eyebrow", label: "Eyebrow (kicker line)", build: eyebrow },
+      { id: "image", label: "Image (reference + alt)", build: image },
+      { id: "richtext", label: "Rich text body", build: richtext },
+      { id: "link", label: "Link (text + url + target)", build: link },
+      { id: "cta", label: "CTA (link + style)", build: cta },
+      { id: "cta-group", label: "CTA group (repeatable buttons)", build: ctaGroup },
+      { id: "classes", label: "Section styles (CSS modifiers)", build: classes },
+      { id: "embed", label: "Embed / video (URL)", build: embed },
+      { id: "teaser", label: "Teaser (image + eyebrow + title + text + CTA)", build: teaser },
+      { id: "card", label: "Card (image + title + description + link)", build: card }
+    ];
   }
 });
 
-// src/lib/migrate/component.ts
-import { existsSync as existsSync6 } from "fs";
-import { readFile as readFile4 } from "fs/promises";
-import path8 from "path";
-import { XMLParser as XMLParser2 } from "fast-xml-parser";
-function findDialogFile(componentDir) {
-  const candidates = [
-    path8.join(componentDir, "_cq_dialog", ".content.xml"),
-    path8.join(componentDir, "_cq_dialog.xml"),
-    path8.join(componentDir, "cq:dialog", ".content.xml")
-  ];
-  return candidates.find((c) => existsSync6(c)) ?? null;
-}
-async function readComponentTitle(componentDir) {
-  const file = path8.join(componentDir, ".content.xml");
-  if (!existsSync6(file)) return void 0;
+// src/commands/model.ts
+var model_exports = {};
+__export(model_exports, {
+  modelAdd: () => modelAdd
+});
+import { existsSync as existsSync16 } from "fs";
+import { readFile as readFile11, writeFile as writeFile12 } from "fs/promises";
+import path19 from "path";
+async function modelAdd(blockArg, partialArgs, options = {}) {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    logger.error("Not inside an EDS project (no EDS project markers found).");
+    process.exitCode = 1;
+    return;
+  }
+  logger.logoOnce(logo("Model - add partials"));
+  const { select, checkbox } = await import("@inquirer/prompts");
+  const interactive = !options.yes;
+  let blockName = blockArg;
+  if (!blockName && interactive) {
+    const { readdir: readdir9 } = await import("fs/promises");
+    const blocksDir = path19.join(projectRoot, "blocks");
+    const dirs = existsSync16(blocksDir) ? (await readdir9(blocksDir, { withFileTypes: true })).filter(
+      (e) => e.isDirectory() && existsSync16(path19.join(blocksDir, e.name, `_${e.name}.json`))
+    ).map((e) => e.name) : [];
+    if (dirs.length === 0) {
+      logger.error("No block with a _<name>.json model found. Create one with `eds block create`.");
+      process.exitCode = 1;
+      return;
+    }
+    blockName = await select({
+      message: "Which block's model?",
+      choices: dirs.map((d) => ({ name: d, value: d }))
+    });
+  }
+  if (!blockName) {
+    logger.error("Provide a block name.");
+    process.exitCode = 1;
+    return;
+  }
+  const modelFile = path19.join(projectRoot, "blocks", blockName, `_${blockName}.json`);
+  if (!existsSync16(modelFile)) {
+    logger.error(`No model at blocks/${blockName}/_${blockName}.json. Create the block first.`);
+    process.exitCode = 1;
+    return;
+  }
+  let ids = partialArgs;
+  if (ids.length === 0 && interactive) {
+    ids = await checkbox({
+      message: "Which partials to add?",
+      choices: PARTIALS.map((p) => ({ name: p.label, value: p.id }))
+    });
+  }
+  const partials = ids.map((id) => partialById(id.trim())).filter((p) => !!p);
+  const unknown = ids.filter((id) => !partialById(id.trim()));
+  if (unknown.length) {
+    logger.warn(
+      `Unknown partial(s): ${unknown.join(", ")}. Available: ${PARTIALS.map((p) => p.id).join(", ")}`
+    );
+  }
+  if (partials.length === 0) {
+    logger.info("Nothing to add.");
+    return;
+  }
+  let model2;
   try {
-    const parser = new XMLParser2({ ignoreAttributes: false, attributeNamePrefix: "@_" });
-    const parsed = parser.parse(await readFile4(file, "utf-8"));
-    const root = parsed["jcr:root"] ?? {};
-    const title = root["@_jcr:title"];
-    return typeof title === "string" ? title.replace(/^\{[^}]+\}/, "") : void 0;
+    model2 = JSON.parse(await readFile11(modelFile, "utf-8"));
   } catch {
-    return void 0;
+    logger.error(`Could not parse ${modelFile}.`);
+    process.exitCode = 1;
+    return;
   }
-}
-async function readDialogFields(componentDir) {
-  const dialog = findDialogFile(componentDir);
-  if (!dialog) return null;
-  return parseDialog(await readFile4(dialog, "utf-8"));
-}
-function migratedModelFile(blockName, title, fields) {
-  const model = {
-    definitions: [
-      {
-        title,
-        id: blockName,
-        plugins: {
-          xwalk: {
-            page: {
-              resourceType: "core/franklin/components/block/v1/block",
-              template: { name: title, model: blockName }
-            }
-          }
-        }
+  const models = Array.isArray(model2.models) ? model2.models : [];
+  const target = models.find((m) => m.id === blockName) ?? models[0];
+  if (!target) {
+    logger.error("Model has no `models[]` entry to add fields to.");
+    process.exitCode = 1;
+    return;
+  }
+  target.fields = Array.isArray(target.fields) ? target.fields : [];
+  const existing = new Set(target.fields.map((x) => x.name));
+  const added = [];
+  const skipped = [];
+  for (const p of partials) {
+    for (const field of p.build()) {
+      if (existing.has(field.name)) {
+        skipped.push(field.name);
+        continue;
       }
-    ],
-    models: [{ id: blockName, fields }],
-    filters: []
-  };
-  return `${JSON.stringify(model, null, 2)}
-`;
-}
-function migratedBlockJs(blockName, fields) {
-  const hasContainer = fields.some((f) => f.component === "container" && f.multi);
-  const body = hasContainer ? `  // This block was migrated from a classic AEM component with a multifield.
-  // Each child row is one repeated item - enhance them here.
-  [...block.children].forEach((row) => {
-    row.classList.add('${blockName}-item');
-  });` : `  // Migrated from a classic AEM component. The authored fields arrive as
-  // rows; read and enhance them here (port the old HTL logic as needed).`;
-  return `// Block: ${blockName}
-// Migrated from a classic AEM component by \`eds migrate component\`.
-// TODO: port the component's HTL/JS behaviour into this decorator.
-export default function decorate(block) {
-  block.classList.add('${blockName}');
-${body}
-}
-`;
-}
-function migratedBlockCss(blockName) {
-  return `/* Block: ${blockName} */
-/* Migrated from a classic AEM component. Bring the component's styles here */
-/* (from its clientlib or the rendered page) and keep them scoped to the block. */
-.${blockName} {
-}
-`;
+      existing.add(field.name);
+      target.fields.push(field);
+      added.push(field.name);
+    }
+  }
+  await writeFile12(modelFile, `${JSON.stringify(model2, null, 2)}
+`);
+  logger.info(heading("Model updated", `blocks/${blockName}/_${blockName}.json`));
+  logger.info(accentLine("partials", partials.map((p) => p.id).join(", ")));
+  logger.info(accentLine("fields added", added.length ? added.join(", ") : "(none)"));
+  if (skipped.length) logger.info(statusLine("warn", "skipped (exists)", skipped.join(", ")));
+  logger.info("");
+  logger.info(box([`${added.length} field(s) added to "${blockName}"`]));
 }
-var init_component = __esm({
-  "src/lib/migrate/component.ts"() {
+var init_model = __esm({
+  "src/commands/model.ts"() {
     "use strict";
     init_esm_shims();
-    init_dialog();
+    init_logger();
+    init_partials();
+    init_project();
+    init_ui();
   }
 });
 
-// src/lib/track.ts
-function trackSnippet(blockName, param, events) {
-  const parts = [`  // --- ${TRACK_MARKER} ---`];
-  if (events.click) {
-    parts.push(
-      `  ${param}.addEventListener('click', (ev) => {`,
-      "    const el = ev.target.closest('a, button');",
-      "    if (!el) return;",
-      `    trackEvent({ event: 'block_click', block: '${blockName}', label: el.dataset.track || el.textContent.trim() });`,
-      "  });"
-    );
-  }
-  if (events.submit) {
-    parts.push(
-      `  ${param}.addEventListener('submit', () => {`,
-      `    trackEvent({ event: 'form_submit', block: '${blockName}' });`,
-      "  });"
-    );
-  }
-  return parts.join("\n");
+// src/lib/schema/jsonld.ts
+function schemaTypeById(id) {
+  return SCHEMA_TYPES.find((t) => t.id.toLowerCase() === id.toLowerCase());
 }
-function instrumentJs(js, blockName, events) {
-  if (js.includes(TRACK_MARKER)) return { js, changed: false, reason: "already instrumented" };
-  if (!events.click && !events.submit) return { js, changed: false, reason: "no events selected" };
+function injectJsonLd(js, type) {
+  if (js.includes(SCHEMA_MARKER)) return { js, changed: false, reason: "already has JSON-LD" };
   const decorate = js.match(
     /export default (?:async )?function decorate\s*\(\s*([A-Za-z_$][\w$]*)?[^)]*\)\s*\{/
   );
@@ -1739,254 +3503,404 @@ function instrumentJs(js, blockName, events) {
     return { js, changed: false, reason: "no `export default function decorate(...)` found" };
   }
   const param = decorate[1] || "block";
-  let out = js;
-  if (!out.includes("scripts/analytics.js")) {
-    const imports = [...out.matchAll(/^import .*$/gm)];
-    if (imports.length) {
-      const last = imports[imports.length - 1];
-      const at2 = (last.index ?? 0) + last[0].length;
-      out = `${out.slice(0, at2)}
-${IMPORT_LINE}${out.slice(at2)}`;
-    } else {
-      out = `${IMPORT_LINE}
-
-${out}`;
-    }
+  const at = decorate.index + decorate[0].length;
+  const snippet = `
+  // --- ${SCHEMA_MARKER}: ${type.id}) ---
+  {
+    const root = ${param};
+    const ld = ${type.object};
+    const ldScript = document.createElement('script');
+    ldScript.type = 'application/ld+json';
+    ldScript.textContent = JSON.stringify(ld);
+    document.head.append(ldScript);
   }
-  const d2 = out.match(
-    /export default (?:async )?function decorate\s*\(\s*([A-Za-z_$][\w$]*)?[^)]*\)\s*\{/
-  );
-  if (!d2 || d2.index === void 0)
-    return { js: out, changed: false, reason: "decorate not found" };
-  const at = d2.index + d2[0].length;
-  const snippet = trackSnippet(blockName, param, events);
-  out = `${out.slice(0, at)}
-${snippet}
-${out.slice(at)}`;
-  return { js: out, changed: true };
+`;
+  return { js: `${js.slice(0, at)}${snippet}${js.slice(at)}`, changed: true };
 }
-var TRACK_MARKER, IMPORT_LINE;
-var init_track = __esm({
-  "src/lib/track.ts"() {
+var SCHEMA_MARKER, SCHEMA_TYPES;
+var init_jsonld = __esm({
+  "src/lib/schema/jsonld.ts"() {
     "use strict";
     init_esm_shims();
-    TRACK_MARKER = "analytics (eds track)";
-    IMPORT_LINE = "import { trackEvent } from '../../scripts/analytics.js';";
+    SCHEMA_MARKER = "json-ld (eds schema";
+    SCHEMA_TYPES = [
+      {
+        id: "Article",
+        label: "Article / BlogPosting",
+        object: `{
+      '@context': 'https://schema.org',
+      '@type': 'Article',
+      headline: root.querySelector('h1, h2, h3')?.textContent?.trim() || document.title,
+      image: [...root.querySelectorAll('img')].map((img) => img.src),
+      description: root.querySelector('p')?.textContent?.trim(),
+      url: window.location.href,
+      // TODO: author, datePublished, dateModified
+    }`
+      },
+      {
+        id: "FAQPage",
+        label: "FAQ page",
+        object: `{
+      '@context': 'https://schema.org',
+      '@type': 'FAQPage',
+      mainEntity: [...root.children].map((row) => {
+        const [q, a] = row.children;
+        return {
+          '@type': 'Question',
+          name: q?.textContent?.trim(),
+          acceptedAnswer: { '@type': 'Answer', text: a?.innerHTML?.trim() },
+        };
+      }),
+    }`
+      },
+      {
+        id: "BreadcrumbList",
+        label: "Breadcrumb list",
+        object: `{
+      '@context': 'https://schema.org',
+      '@type': 'BreadcrumbList',
+      itemListElement: [...root.querySelectorAll('a')].map((a, i) => ({
+        '@type': 'ListItem',
+        position: i + 1,
+        name: a.textContent?.trim(),
+        item: a.href,
+      })),
+    }`
+      },
+      {
+        id: "Product",
+        label: "Product",
+        object: `{
+      '@context': 'https://schema.org',
+      '@type': 'Product',
+      name: root.querySelector('h1, h2, h3')?.textContent?.trim(),
+      image: [...root.querySelectorAll('img')].map((img) => img.src),
+      description: root.querySelector('p')?.textContent?.trim(),
+      // TODO: brand, sku, offers { '@type': 'Offer', price, priceCurrency, availability }
+    }`
+      },
+      {
+        id: "Organization",
+        label: "Organization",
+        object: `{
+      '@context': 'https://schema.org',
+      '@type': 'Organization',
+      name: document.title,
+      url: window.location.origin,
+      logo: root.querySelector('img')?.src,
+      // TODO: sameAs: [social profile URLs], contactPoint
+    }`
+      },
+      {
+        id: "LocalBusiness",
+        label: "Local business",
+        object: `{
+      '@context': 'https://schema.org',
+      '@type': 'LocalBusiness',
+      name: root.querySelector('h1, h2, h3')?.textContent?.trim() || document.title,
+      image: root.querySelector('img')?.src,
+      url: window.location.origin,
+      // TODO: address (PostalAddress), telephone, openingHours, geo
+    }`
+      },
+      {
+        id: "Event",
+        label: "Event",
+        object: `{
+      '@context': 'https://schema.org',
+      '@type': 'Event',
+      name: root.querySelector('h1, h2, h3')?.textContent?.trim(),
+      image: [...root.querySelectorAll('img')].map((img) => img.src),
+      url: window.location.href,
+      // TODO: startDate, endDate, location (Place), offers
+    }`
+      },
+      {
+        id: "VideoObject",
+        label: "Video",
+        object: `{
+      '@context': 'https://schema.org',
+      '@type': 'VideoObject',
+      name: root.querySelector('h1, h2, h3')?.textContent?.trim() || document.title,
+      thumbnailUrl: root.querySelector('img')?.src,
+      contentUrl: root.querySelector('a[href], video source[src]')?.href,
+      // TODO: description, uploadDate, duration (ISO 8601)
+    }`
+      },
+      {
+        id: "Recipe",
+        label: "Recipe",
+        object: `{
+      '@context': 'https://schema.org',
+      '@type': 'Recipe',
+      name: root.querySelector('h1, h2, h3')?.textContent?.trim(),
+      image: [...root.querySelectorAll('img')].map((img) => img.src),
+      recipeIngredient: [...root.querySelectorAll('li')].map((li) => li.textContent?.trim()),
+      // TODO: recipeInstructions, prepTime, cookTime, nutrition
+    }`
+      },
+      {
+        id: "HowTo",
+        label: "How-to",
+        object: `{
+      '@context': 'https://schema.org',
+      '@type': 'HowTo',
+      name: root.querySelector('h1, h2, h3')?.textContent?.trim(),
+      step: [...root.querySelectorAll('li')].map((li, i) => ({
+        '@type': 'HowToStep',
+        position: i + 1,
+        text: li.textContent?.trim(),
+      })),
+    }`
+      }
+    ];
   }
 });
 
-// src/commands/track.ts
-var track_exports = {};
-__export(track_exports, {
-  trackBlock: () => trackBlock
+// src/commands/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  schemaBlock: () => schemaBlock
 });
-import { existsSync as existsSync7 } from "fs";
-import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
-import path9 from "path";
-import chalk4 from "chalk";
-async function trackBlock(blockName, options = {}) {
+import { existsSync as existsSync17 } from "fs";
+import { readFile as readFile12, writeFile as writeFile13 } from "fs/promises";
+import path20 from "path";
+import chalk7 from "chalk";
+async function schemaBlock(blockName, options = {}) {
   const projectRoot = findProjectRoot();
   if (!projectRoot) {
     logger.error("Not inside an EDS project (no EDS project markers found).");
     process.exitCode = 1;
     return;
   }
-  logger.logoOnce(logo("Track block"));
-  const jsPath = path9.join(projectRoot, "blocks", blockName, `${blockName}.js`);
-  if (!existsSync7(jsPath)) {
+  logger.logoOnce(logo("Schema - JSON-LD"));
+  const jsPath = path20.join(projectRoot, "blocks", blockName, `${blockName}.js`);
+  if (!existsSync17(jsPath)) {
     logger.error(`Block "${blockName}" not found (no blocks/${blockName}/${blockName}.js).`);
     process.exitCode = 1;
     return;
   }
-  const events = { click: options.click !== false, submit: options.submit !== false };
-  const res = instrumentJs(await readFile5(jsPath, "utf-8"), blockName, events);
+  let typeId = options.type;
+  if (!typeId && !options.yes) {
+    const { select } = await import("@inquirer/prompts");
+    typeId = await select({
+      message: "Which schema.org type?",
+      choices: SCHEMA_TYPES.map((t) => ({ name: `${t.id} - ${t.label}`, value: t.id }))
+    });
+  }
+  const type = typeId ? schemaTypeById(typeId) : void 0;
+  if (!type) {
+    logger.error(
+      `Unknown schema type "${typeId}". Options: ${SCHEMA_TYPES.map((t) => t.id).join(", ")}`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const res = injectJsonLd(await readFile12(jsPath, "utf-8"), type);
   if (!res.changed) {
-    logger.warn(`Not instrumented: ${res.reason}.`);
+    logger.warn(`Not added: ${res.reason}.`);
     return;
   }
-  await writeFile5(jsPath, res.js);
-  logger.info(heading("Instrumented"));
-  const picked = [events.click ? "block_click" : null, events.submit ? "form_submit" : null].filter(
-    Boolean
+  await writeFile13(jsPath, res.js);
+  logger.info(heading("JSON-LD added"));
+  logger.info(accentLine(`blocks/${blockName}/${blockName}.js`, `${type.id} (${type.label})`));
+  logger.info("");
+  logger.info(
+    chalk7.dim(
+      "  Review the generated object - some fields are heuristic or TODO. Validate at search.google.com/test/rich-results."
+    )
   );
-  logger.info(accentLine(`blocks/${blockName}/${blockName}.js`, picked.join(" + ")));
-  if (!existsSync7(path9.join(projectRoot, "scripts", "analytics.js"))) {
-    logger.info("");
-    logger.warn("scripts/analytics.js is missing - run `eds integrate gtm` to create it.");
+}
+var init_schema = __esm({
+  "src/commands/schema.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    init_project();
+    init_jsonld();
+    init_ui();
   }
-  logger.info("");
-  logger.info(chalk4.dim("  Events push to window.dataLayer via trackEvent - GTM picks them up."));
+});
+
+// src/lib/ue/check.ts
+function metaContent(html, name) {
+  for (const tag of html.match(/<meta\b[^>]*>/gi) ?? []) {
+    if (tag.match(/\bname=["']([^"']+)["']/i)?.[1] === name) {
+      return tag.match(/\bcontent=["']([^"']*)["']/i)?.[1] ?? "";
+    }
+  }
+  return null;
+}
+function hasAemConnection(html) {
+  return metaContent(html, AEM_CONNECTION_META) !== null;
 }
-var init_track2 = __esm({
-  "src/commands/track.ts"() {
+function modelIds(componentModels) {
+  if (!Array.isArray(componentModels)) return [];
+  return componentModels.map((m) => m && typeof m === "object" ? m.id : void 0).filter((id) => typeof id === "string");
+}
+function assessReadiness(input) {
+  const isUeProject = !!input.configPresent["component-definition.json"] && !!input.configPresent["component-models.json"];
+  const ids = new Set(input.modelIds);
+  const blocks = input.blocks.map((b) => {
+    const editable = b.hasModelFile || ids.has(b.name);
+    return {
+      name: b.name,
+      editable,
+      reason: editable ? void 0 : "no UE model (_<name>.json or component-models entry)"
+    };
+  });
+  return { isUeProject, blocks };
+}
+var UE_CONFIG_FILES, AEM_CONNECTION_META;
+var init_check = __esm({
+  "src/lib/ue/check.ts"() {
     "use strict";
     init_esm_shims();
-    init_logger();
-    init_project();
-    init_track();
-    init_ui();
+    UE_CONFIG_FILES = [
+      "component-definition.json",
+      "component-models.json",
+      "component-filters.json"
+    ];
+    AEM_CONNECTION_META = "urn:adobe:aue:system:aemconnection";
   }
 });
 
-// src/commands/migrate.ts
-var migrate_exports = {};
-__export(migrate_exports, {
-  migrateComponent: () => migrateComponent
+// src/commands/ue.ts
+var ue_exports = {};
+__export(ue_exports, {
+  ueCheck: () => ueCheck,
+  ueOpen: () => ueOpen
 });
-import { existsSync as existsSync8 } from "fs";
-import { mkdir as mkdir3, writeFile as writeFile6 } from "fs/promises";
-import path10 from "path";
-function clientlibBlockCss(blockName, css, files) {
-  return `/* Block: ${blockName} */
-/* Migrated from the component clientlib: ${files.join(", ")}. */
-/* TODO: review selectors and scope them under .${blockName} (and port any LESS/SCSS). */
-
-${css.trim()}
-`;
+import { existsSync as existsSync18 } from "fs";
+import { readFile as readFile13, readdir as readdir3 } from "fs/promises";
+import path21 from "path";
+import chalk8 from "chalk";
+async function readJson2(file) {
+  if (!existsSync18(file)) return null;
+  try {
+    return JSON.parse(await readFile13(file, "utf-8"));
+  } catch {
+    return null;
+  }
 }
-function previewFields(fields, depth = 0) {
-  const lines = [];
-  for (const f of fields) {
-    const indent = "  ".repeat(depth);
-    if (f.component === "tab") {
-      lines.push(`${indent}${brand.blue("\u25B8")} ${f.label ?? f.name}`);
-    } else {
-      const opts = f.options?.length ? ` (${f.options.length} options)` : "";
-      const multi = f.multi ? " \xB7multi" : "";
-      const label = f.label ? `- ${f.label}` : "";
-      lines.push(`${indent}${brand.accent(f.component)}${multi}  ${f.name}${opts}  ${label}`);
-      if (f.fields?.length) lines.push(...previewFields(f.fields, depth + 1));
-    }
+async function scanBlocks(root) {
+  const blocksDir = path21.join(root, "blocks");
+  if (!existsSync18(blocksDir)) return [];
+  const entries = await readdir3(blocksDir, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory()).map((e) => ({
+    name: e.name,
+    hasModelFile: existsSync18(path21.join(blocksDir, e.name, `_${e.name}.json`))
+  }));
+}
+async function openUrl2(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" });
+  } catch {
   }
-  return lines;
 }
-function countLeaves(fields) {
-  let n = 0;
-  for (const f of fields) {
-    if (f.component === "tab") continue;
-    n += 1;
-    if (f.fields) n += countLeaves(f.fields);
+async function gitRemote(root) {
+  try {
+    const { execa } = await import("execa");
+    const res = await execa("git", ["remote", "get-url", "origin"], { cwd: root });
+    return res.stdout.trim() || null;
+  } catch {
+    return null;
   }
-  return n;
 }
-async function migrateComponent(dirArg, options = {}) {
-  const projectRoot = findProjectRoot();
-  if (!projectRoot) {
+async function ueCheck() {
+  const root = findProjectRoot();
+  if (!root) {
     logger.error("Not inside an EDS project (no EDS project markers found).");
     process.exitCode = 1;
     return;
   }
-  await logger.logoOnceAnimated("Migrate component");
-  const { input, confirm } = await import("@inquirer/prompts");
-  const interactive = !options.yes;
-  let componentDir = dirArg;
-  if (!componentDir && interactive) {
-    componentDir = await input({
-      message: "Path to the classic component folder",
-      validate: (v) => existsSync8(v.trim()) || "Folder not found"
-    });
-  }
-  if (!componentDir) {
-    logger.error("Provide the path to the classic component folder.");
-    process.exitCode = 1;
-    return;
-  }
-  componentDir = path10.resolve(componentDir.trim());
-  if (!findDialogFile(componentDir)) {
-    logger.error(`No Touch UI dialog (_cq_dialog/.content.xml) found in ${componentDir}.`);
-    process.exitCode = 1;
-    return;
-  }
-  const parsed = await readDialogFields(componentDir);
-  if (!parsed || parsed.fields.length === 0) {
-    logger.warn("Dialog found but no mappable fields were detected.");
-    if (parsed?.unmapped.length)
-      logger.info(`Unmapped resourceTypes: ${parsed.unmapped.join(", ")}`);
-    process.exitCode = 1;
-    return;
+  logger.logoOnce(logo("Universal Editor - readiness"));
+  const configPresent = {};
+  for (const f2 of UE_CONFIG_FILES) configPresent[f2] = existsSync18(path21.join(root, f2));
+  const componentModels = await readJson2(path21.join(root, "component-models.json"));
+  const blocks = await scanBlocks(root);
+  const { isUeProject, blocks: blockReadiness } = assessReadiness({
+    configPresent,
+    blocks,
+    modelIds: modelIds(componentModels)
+  });
+  logger.info(heading("Universal Editor config"));
+  const names = [...UE_CONFIG_FILES];
+  const w = columnWidth(names);
+  for (const f2 of names) {
+    logger.info(statusLine(configPresent[f2] ? "pass" : "fail", f2, void 0, w));
   }
-  const title = await readComponentTitle(componentDir) ?? path10.basename(componentDir);
-  const blockName = options.name && slug2(options.name) || (interactive ? slug2(await input({ message: "Block name", default: slug2(title) })) : slug2(title));
-  logger.info(heading("Mapped fields", `${countLeaves(parsed.fields)} from dialog`));
-  for (const line of previewFields(parsed.fields)) logger.info(`  ${line}`);
-  if (parsed.unmapped.length) {
+  if (!isUeProject) {
     logger.info("");
-    logger.warn(`Skipped (unrecognised): ${parsed.unmapped.join(", ")}`);
-  }
-  logger.info("");
-  if (interactive) {
-    const go = await confirm({ message: `Generate block "${blockName}"?`, default: true });
-    if (!go) {
-      logger.info("Cancelled.");
-      return;
-    }
-  }
-  const blockDir = path10.join(projectRoot, "blocks", blockName);
-  if (existsSync8(blockDir)) {
-    logger.error(
-      `Block "${blockName}" already exists at blocks/${blockName}. Use --name to pick another.`
+    logger.warn(
+      "This doesn't look like a Universal Editor (crosswalk) project - run `eds scaffold ue` first."
     );
     process.exitCode = 1;
     return;
   }
-  const clibDir = options.clientlib ? path10.resolve(options.clientlib.trim()) : await findClientlibDir(componentDir);
-  let cssContent = migratedBlockCss(blockName);
-  let cssMessage = "empty - add styles from clientlib / rendered CSS";
-  let preprocessedNote = [];
-  if (clibDir && existsSync8(clibDir)) {
-    const lib = await readClientlibCss(clibDir);
-    if (lib.css.trim()) {
-      cssContent = clientlibBlockCss(blockName, lib.css, lib.files);
-      cssMessage = `from clientlib (${lib.files.length} file(s)) - review & scope`;
-    }
-    preprocessedNote = lib.preprocessed;
+  const headFile = path21.join(root, "head.html");
+  if (existsSync18(headFile)) {
+    const connected = hasAemConnection(await readFile13(headFile, "utf-8"));
+    logger.info(
+      statusLine(
+        connected ? "pass" : "info",
+        "head.html",
+        connected ? "aemconnection present" : "no aemconnection (fine for cloud author)"
+      )
+    );
   }
-  await mkdir3(blockDir, { recursive: true });
-  await writeFile6(
-    path10.join(blockDir, `${blockName}.js`),
-    migratedBlockJs(blockName, parsed.fields)
-  );
-  await writeFile6(path10.join(blockDir, `${blockName}.css`), cssContent);
-  await writeFile6(
-    path10.join(blockDir, `_${blockName}.json`),
-    migratedModelFile(blockName, title, parsed.fields)
-  );
-  logger.info(heading("Created"));
-  const files = [`${blockName}.js`, `${blockName}.css`, `_${blockName}.json`];
-  const w = columnWidth(files);
-  logger.info(accentLine(`${blockName}.js`, "decorator stub (port HTL logic)", w));
-  logger.info(accentLine(`${blockName}.css`, cssMessage, w));
-  logger.info(accentLine(`_${blockName}.json`, "Universal Editor model", w));
-  if (preprocessedNote.length) {
-    logger.info("");
-    logger.warn(`LESS/SCSS found (needs a build, not copied): ${preprocessedNote.join(", ")}`);
+  logger.info(heading("Blocks", `${blockReadiness.length} found`));
+  if (blockReadiness.length === 0) {
+    logger.info(chalk8.dim("  No blocks yet."));
+  } else {
+    const bw = columnWidth(blockReadiness.map((b) => b.name));
+    for (const b of blockReadiness) {
+      logger.info(statusLine(b.editable ? "pass" : "warn", b.name, b.reason, bw));
+    }
   }
+  const editable = blockReadiness.filter((b) => b.editable).length;
+  const notEditable = blockReadiness.length - editable;
   logger.info("");
-  if (interactive) {
-    const addTracking = await confirm({
-      message: "Instrument this block for analytics (dataLayer)?",
-      default: false
-    });
-    if (addTracking) {
-      const { trackBlock: trackBlock2 } = await Promise.resolve().then(() => (init_track2(), track_exports));
-      await trackBlock2(blockName, {});
+  logger.info(summary({ pass: editable, warn: notEditable }));
+  logger.info(chalk8.dim("  Open a page in the editor with `eds ue open <path>`."));
+}
+async function ueOpen(pagePath, options = {}) {
+  const root = findProjectRoot() ?? process.cwd();
+  const pPath = pagePath ?? options.path ?? "/";
+  let host = options.url;
+  if (!host) {
+    const remote = await gitRemote(root);
+    const parsed = remote ? parseRemote(remote) : null;
+    if (!parsed) {
+      logger.error("Couldn't determine the preview host from git.");
+      logger.info(
+        chalk8.dim(
+          "  Pass it explicitly: `eds ue open <path> --url main--<repo>--<owner>.aem.page`"
+        )
+      );
+      process.exitCode = 1;
+      return;
     }
+    host = previewHost(parsed.owner, parsed.repo, options.ref ?? "main");
   }
-  logger.info(
-    box([`"${blockName}" migrated. Next: add CSS, then \`eds block preview ${blockName}\``])
-  );
+  const link2 = editorLink({ host, path: pPath, org: options.org });
+  logger.info(heading("Universal Editor"));
+  logger.info(accentLine("page", `${host}${pPath.startsWith("/") ? "" : "/"}${pPath}`));
+  logger.info(accentLine("open", link2));
+  if (options.open !== false) await openUrl2(link2);
+  else logger.info(chalk8.dim("  (use without --no-open to launch the browser)"));
 }
-var slug2;
-var init_migrate = __esm({
-  "src/commands/migrate.ts"() {
+var init_ue3 = __esm({
+  "src/commands/ue.ts"() {
     "use strict";
     init_esm_shims();
     init_logger();
-    init_clientlib();
-    init_component();
     init_project();
+    init_check();
+    init_link();
     init_ui();
-    slug2 = (s) => s.trim().toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
   }
 });
 
@@ -1996,16 +3910,16 @@ __export(create_exports, {
   createBlock: () => createBlock,
   ueModelFor: () => ueModelFor
 });
-import { existsSync as existsSync9 } from "fs";
-import { mkdir as mkdir4, writeFile as writeFile7 } from "fs/promises";
-import path11 from "path";
-import chalk5 from "chalk";
+import { existsSync as existsSync19 } from "fs";
+import { mkdir as mkdir7, writeFile as writeFile14 } from "fs/promises";
+import path22 from "path";
+import chalk9 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 = {
+  const model2 = {
     definitions: [
       {
         title,
@@ -2058,7 +3972,7 @@ function ueModelFor(name) {
     ],
     filters: []
   };
-  return `${JSON.stringify(model, null, 2)}
+  return `${JSON.stringify(model2, null, 2)}
 `;
 }
 async function createBlock(name, options = {}) {
@@ -2077,13 +3991,13 @@ async function createBlock(name, options = {}) {
     process.exitCode = 1;
     return;
   }
-  const blocksDir = path11.join(projectRoot, "blocks", name);
-  if (existsSync9(blocksDir)) {
+  const blocksDir = path22.join(projectRoot, "blocks", name);
+  if (existsSync19(blocksDir)) {
     logger.error(`Block "${name}" already exists at ${blocksDir}`);
     process.exitCode = 1;
     return;
   }
-  await mkdir4(blocksDir, { recursive: true });
+  await mkdir7(blocksDir, { recursive: true });
   const jsContent = `export default function decorate(block) {
   // TODO: implement ${name} block
 }
@@ -2092,14 +4006,14 @@ async function createBlock(name, options = {}) {
   /* TODO: style ${name} block */
 }
 `;
-  await writeFile7(path11.join(blocksDir, `${name}.js`), jsContent);
-  await writeFile7(path11.join(blocksDir, `${name}.css`), cssContent);
+  await writeFile14(path22.join(blocksDir, `${name}.js`), jsContent);
+  await writeFile14(path22.join(blocksDir, `${name}.css`), cssContent);
   const withUe = options.ueModel !== false;
   if (withUe) {
-    await writeFile7(path11.join(blocksDir, `_${name}.json`), ueModelFor(name));
+    await writeFile14(path22.join(blocksDir, `_${name}.json`), ueModelFor(name));
   }
   logger.success(
-    `Block "${name}" created at ${chalk5.cyan(path11.relative(projectRoot, blocksDir))}${withUe ? chalk5.dim(" (+ Universal Editor model)") : ""}`
+    `Block "${name}" created at ${chalk9.cyan(path22.relative(projectRoot, blocksDir))}${withUe ? chalk9.dim(" (+ Universal Editor model)") : ""}`
   );
 }
 var init_create = __esm({
@@ -2113,10 +4027,10 @@ var init_create = __esm({
 });
 
 // src/lib/agents/detect.ts
-import { existsSync as existsSync10 } from "fs";
-import { readFile as readFile6 } from "fs/promises";
+import { existsSync as existsSync20 } from "fs";
+import { readFile as readFile14 } from "fs/promises";
 import { homedir } from "os";
-import path12 from "path";
+import path23 from "path";
 async function whichBinary(name) {
   const { execaCommand } = await import("execa");
   try {
@@ -2144,8 +4058,8 @@ function findFigmaServerKey(node) {
 async function findFigmaMcpServer(configPaths) {
   for (const configPath of configPaths) {
     try {
-      if (!existsSync10(configPath)) continue;
-      const content = await readFile6(configPath, "utf-8");
+      if (!existsSync20(configPath)) continue;
+      const content = await readFile14(configPath, "utf-8");
       try {
         const key = findFigmaServerKey(JSON.parse(content));
         if (key) return key;
@@ -2167,7 +4081,7 @@ async function detectAgent(preferred) {
         return {
           type: def.type,
           path: binPath,
-          configDir: existsSync10(def.configDir) ? def.configDir : void 0,
+          configDir: existsSync20(def.configDir) ? def.configDir : void 0,
           hasFigmaMcp: !!figmaMcpServerName,
           figmaMcpServerName
         };
@@ -2182,7 +4096,7 @@ async function detectAgent(preferred) {
       return {
         type: def.type,
         path: binPath,
-        configDir: existsSync10(def.configDir) ? def.configDir : void 0,
+        configDir: existsSync20(def.configDir) ? def.configDir : void 0,
         hasFigmaMcp: !!figmaMcpServerName,
         figmaMcpServerName
       };
@@ -2199,7 +4113,7 @@ async function detectAllAgents() {
       agents.push({
         type: def.type,
         path: binPath,
-        configDir: existsSync10(def.configDir) ? def.configDir : void 0,
+        configDir: existsSync20(def.configDir) ? def.configDir : void 0,
         hasFigmaMcp: !!figmaMcpServerName,
         figmaMcpServerName
       });
@@ -2217,22 +4131,22 @@ var init_detect = __esm({
       {
         type: "claude",
         binary: "claude",
-        configDir: path12.join(homedir(), ".claude"),
+        configDir: path23.join(homedir(), ".claude"),
         mcpConfigPaths: [
-          path12.join(homedir(), ".claude", "plugins.json"),
-          path12.join(homedir(), ".claude.json")
+          path23.join(homedir(), ".claude", "plugins.json"),
+          path23.join(homedir(), ".claude.json")
         ]
       },
       {
         type: "cursor",
         binary: "cursor",
-        configDir: path12.join(homedir(), ".cursor"),
-        mcpConfigPaths: [path12.join(homedir(), ".cursor", "mcp.json")]
+        configDir: path23.join(homedir(), ".cursor"),
+        mcpConfigPaths: [path23.join(homedir(), ".cursor", "mcp.json")]
       },
       {
         type: "codex",
         binary: "codex",
-        configDir: path12.join(homedir(), ".codex"),
+        configDir: path23.join(homedir(), ".codex"),
         mcpConfigPaths: []
       }
     ];
@@ -2240,27 +4154,27 @@ var init_detect = __esm({
 });
 
 // src/lib/agents/invoke.ts
-import { mkdir as mkdir5, readFile as readFile7, writeFile as writeFile8 } from "fs/promises";
+import { mkdir as mkdir8, readFile as readFile15, writeFile as writeFile15 } from "fs/promises";
 import { tmpdir } from "os";
-import path13 from "path";
+import path24 from "path";
 import readline from "readline";
-import chalk6 from "chalk";
+import chalk10 from "chalk";
 async function savePromptToFile(prompt, projectRoot) {
-  const base = projectRoot ? path13.join(projectRoot, "tmp") : tmpdir();
-  const dir = path13.join(base, "eds-cli");
-  await mkdir5(dir, { recursive: true });
+  const base = projectRoot ? path24.join(projectRoot, "tmp") : tmpdir();
+  const dir = path24.join(base, "eds-cli");
+  await mkdir8(dir, { recursive: true });
   const filename = `from-design-${Date.now()}.md`;
-  const filePath = path13.join(dir, filename);
-  await writeFile8(filePath, prompt, "utf-8");
+  const filePath = path24.join(dir, filename);
+  await writeFile15(filePath, prompt, "utf-8");
   return filePath;
 }
 async function invokeAgent(agent, promptFile, cwd) {
   const { execa } = await import("execa");
-  const prompt = await readFile7(promptFile, "utf-8");
+  const prompt = await readFile15(promptFile, "utf-8");
   try {
     switch (agent.type) {
       case "claude": {
-        logger.info(`Running Claude Code ${chalk6.dim("- live log:")}`);
+        logger.info(`Running Claude Code ${chalk10.dim("- live log:")}`);
         const figmaServers = [
           ...agent.figmaMcpServerName ? [agent.figmaMcpServerName] : [],
           "figma-sse",
@@ -2323,10 +4237,10 @@ 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  ${chalk6.dim(elapsed())}`, color: "yellow" }).start();
+  const spinner = ora4({ text: `thinking  ${chalk10.dim(elapsed())}`, color: "yellow" }).start();
   let activity = "thinking";
   const timer = setInterval(() => {
-    spinner.text = `${activity}  ${chalk6.dim(elapsed())}`;
+    spinner.text = `${activity}  ${chalk10.dim(elapsed())}`;
   }, 300);
   const pending = /* @__PURE__ */ new Map();
   const emit = (line) => {
@@ -2352,7 +4266,7 @@ async function renderClaudeStream(sub, cwd) {
           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(chalk6.dim(first));
+              if (first) emit(chalk10.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, {
@@ -2368,8 +4282,8 @@ async function renderClaudeStream(sub, cwd) {
               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 ? ` ${chalk6.red("failed")}` : "";
-                emit(`${p.label}  ${chalk6.dim(dur)}${failed}`);
+                const failed = "is_error" in block2 && block2.is_error ? ` ${chalk10.red("failed")}` : "";
+                emit(`${p.label}  ${chalk10.dim(dur)}${failed}`);
                 pending.delete(block2.tool_use_id);
               }
             }
@@ -2381,9 +4295,9 @@ async function renderClaudeStream(sub, cwd) {
         }
       }
     }
-    for (const p of pending.values()) emit(`${p.label}  ${chalk6.dim("\u2026")}`);
+    for (const p of pending.values()) emit(`${p.label}  ${chalk10.dim("\u2026")}`);
     clearInterval(timer);
-    if (result) spinner.succeed(`${brand.accent("agent finished")}  ${chalk6.dim(result)}`);
+    if (result) spinner.succeed(`${brand.accent("agent finished")}  ${chalk10.dim(result)}`);
     else spinner.stop();
   } catch (err) {
     clearInterval(timer);
@@ -2396,22 +4310,22 @@ function toolLabel(name, input, cwd) {
   const rel = (key) => {
     const p = input?.[key];
     if (typeof p !== "string") return "";
-    return p.startsWith(cwd) ? path13.relative(cwd, p) : path13.basename(p);
+    return p.startsWith(cwd) ? path24.relative(cwd, p) : path24.basename(p);
   };
   if (name.includes("figma")) {
     const short = name.split("__").pop() ?? name;
-    return `${icon.figma} ${chalk6.bold(short)}  ${chalk6.dim("Figma MCP")}`;
+    return `${icon.figma} ${chalk10.bold(short)}  ${chalk10.dim("Figma MCP")}`;
   }
   switch (name) {
     case "Write":
     case "Edit":
     case "NotebookEdit":
-      return `${brand.accent("\u270E")} ${chalk6.cyan(rel("file_path"))}`;
+      return `${brand.accent("\u270E")} ${chalk10.cyan(rel("file_path"))}`;
     case "Read":
-      return chalk6.dim(`\xB7 read ${rel("file_path")}`);
+      return chalk10.dim(`\xB7 read ${rel("file_path")}`);
     case "Bash": {
       const cmd = typeof input?.command === "string" ? input.command.split("\n")[0].slice(0, 70) : "";
-      return chalk6.dim(`$ ${cmd}`);
+      return chalk10.dim(`$ ${cmd}`);
     }
     default:
       return `${brand.blue("\u2192")} ${name}`;
@@ -2427,13 +4341,13 @@ var init_invoke = __esm({
 });
 
 // src/lib/config.ts
-import { existsSync as existsSync11 } from "fs";
-import { readFile as readFile8 } from "fs/promises";
+import { existsSync as existsSync21 } from "fs";
+import { readFile as readFile16 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import path14 from "path";
+import path25 from "path";
 async function loadJsonFile(filePath) {
   try {
-    const content = await readFile8(filePath, "utf-8");
+    const content = await readFile16(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return void 0;
@@ -2441,7 +4355,7 @@ async function loadJsonFile(filePath) {
 }
 async function loadConfig(projectRoot) {
   const globalRaw = await loadJsonFile(GLOBAL_CONFIG_PATH);
-  const projectRaw = projectRoot ? await loadJsonFile(path14.join(projectRoot, PROJECT_CONFIG_NAME)) : void 0;
+  const projectRaw = projectRoot ? await loadJsonFile(path25.join(projectRoot, PROJECT_CONFIG_NAME)) : void 0;
   const merged = {
     ...typeof globalRaw === "object" && globalRaw !== null ? globalRaw : {},
     ...typeof projectRaw === "object" && projectRaw !== null ? projectRaw : {}
@@ -2460,7 +4374,7 @@ function globalConfigPath() {
   return GLOBAL_CONFIG_PATH;
 }
 function globalConfigExists() {
-  return existsSync11(GLOBAL_CONFIG_PATH);
+  return existsSync21(GLOBAL_CONFIG_PATH);
 }
 var GLOBAL_CONFIG_DIR, GLOBAL_CONFIG_PATH, PROJECT_CONFIG_NAME;
 var init_config = __esm({
@@ -2469,8 +4383,8 @@ var init_config = __esm({
     init_esm_shims();
     init_logger();
     init_schemas();
-    GLOBAL_CONFIG_DIR = path14.join(homedir2(), ".eds");
-    GLOBAL_CONFIG_PATH = path14.join(GLOBAL_CONFIG_DIR, "config.json");
+    GLOBAL_CONFIG_DIR = path25.join(homedir2(), ".eds");
+    GLOBAL_CONFIG_PATH = path25.join(GLOBAL_CONFIG_DIR, "config.json");
     PROJECT_CONFIG_NAME = ".edsrc.json";
   }
 });
@@ -2520,9 +4434,9 @@ var init_node_id = __esm({
 });
 
 // src/lib/figma/prompt-builder.ts
-import { existsSync as existsSync12 } from "fs";
-import { readFile as readFile9 } from "fs/promises";
-import path15 from "path";
+import { existsSync as existsSync22 } from "fs";
+import { readFile as readFile17 } from "fs/promises";
+import path26 from "path";
 function contentSourceGuidance(source, cfHint, blockName) {
   if (!source || source === "document" || source === "ue") return "";
   const q = cfHint ? ` (model / persisted query: \`${cfHint}\`)` : "";
@@ -2651,6 +4565,9 @@ Rules:
 - **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\`.
+
+**Reusable field groups (partials):** when the design shows one of these common shapes, reuse the standard group instead of inventing fields \u2014 same groups \`eds model add\` uses, so the model stays consistent across the project:
+${PARTIALS.map((p) => `- \`${p.id}\` \u2014 ${p.label}`).join("\n")}
 ` : "";
   return `# Pixel-Perfect EDS Block from ${providerName}
 
@@ -2734,10 +4651,10 @@ ${tokensHint}
 `;
 }
 async function getTokensHint(projectRoot) {
-  const stylesPath = path15.join(projectRoot, "styles", "styles.css");
-  if (!existsSync12(stylesPath)) return "";
+  const stylesPath = path26.join(projectRoot, "styles", "styles.css");
+  if (!existsSync22(stylesPath)) return "";
   try {
-    const css = await readFile9(stylesPath, "utf-8");
+    const css = await readFile17(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  ");
@@ -2762,6 +4679,7 @@ var init_prompt_builder = __esm({
   "src/lib/figma/prompt-builder.ts"() {
     "use strict";
     init_esm_shims();
+    init_partials();
     PROMPT_VERSION = "0.5.0";
     PROVIDER_NAMES = {
       figma: "Figma",
@@ -2878,11 +4796,11 @@ var init_harness = __esm({
 });
 
 // src/lib/preview/server.ts
-import { createReadStream, existsSync as existsSync13, statSync } from "fs";
+import { createReadStream, existsSync as existsSync23, statSync } from "fs";
 import http from "http";
-import path16 from "path";
+import path27 from "path";
 function startServer(root, routes, port, host = "127.0.0.1") {
-  const resolvedRoot = path16.resolve(root);
+  const resolvedRoot = path27.resolve(root);
   const clients = /* @__PURE__ */ new Set();
   const server = http.createServer((req, res) => {
     const urlPath = decodeURIComponent((req.url ?? "/").split("?")[0]);
@@ -2908,19 +4826,19 @@ function startServer(root, routes, port, host = "127.0.0.1") {
       res.end(route.body);
       return;
     }
-    const filePath = path16.join(resolvedRoot, urlPath);
+    const filePath = path27.join(resolvedRoot, urlPath);
     if (!filePath.startsWith(resolvedRoot)) {
       res.writeHead(403);
       res.end("Forbidden");
       return;
     }
-    if (!existsSync13(filePath) || !statSync(filePath).isFile()) {
+    if (!existsSync23(filePath) || !statSync(filePath).isFile()) {
       res.writeHead(404, { "content-type": "text/plain" });
       res.end(`Not found: ${urlPath}`);
       return;
     }
     res.writeHead(200, {
-      "content-type": MIME[path16.extname(filePath).toLowerCase()] ?? "application/octet-stream"
+      "content-type": MIME[path27.extname(filePath).toLowerCase()] ?? "application/octet-stream"
     });
     createReadStream(filePath).pipe(res);
   });
@@ -2984,10 +4902,10 @@ var preview_exports = {};
 __export(preview_exports, {
   previewBlock: () => previewBlock
 });
-import { existsSync as existsSync14, watch } from "fs";
-import { readFile as readFile10 } from "fs/promises";
-import path17 from "path";
-import chalk7 from "chalk";
+import { existsSync as existsSync24, watch } from "fs";
+import { readFile as readFile18 } from "fs/promises";
+import path28 from "path";
+import chalk11 from "chalk";
 function labelFor(width) {
   if (width <= 480) return `${width} mobile`;
   if (width <= 1024) return `${width} tablet`;
@@ -3039,30 +4957,30 @@ async function previewBlock(name, options = {}) {
     process.exitCode = 1;
     return;
   }
-  const blockDir = path17.join(projectRoot, "blocks", name);
-  if (!existsSync14(blockDir)) {
+  const blockDir = path28.join(projectRoot, "blocks", name);
+  if (!existsSync24(blockDir)) {
     logger.error(`Block "${name}" not found at blocks/${name}/.`);
     process.exitCode = 1;
     return;
   }
-  if (!existsSync14(path17.join(blockDir, `${name}.css`)) && !existsSync14(path17.join(blockDir, `${name}.js`))) {
+  if (!existsSync24(path28.join(blockDir, `${name}.css`)) && !existsSync24(path28.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 = path17.join(blockDir, ".eds-meta.json");
-  if (existsSync14(metaPath)) {
+  const metaPath = path28.join(blockDir, ".eds-meta.json");
+  if (existsSync24(metaPath)) {
     try {
-      meta = JSON.parse(await readFile10(metaPath, "utf-8"));
+      meta = JSON.parse(await readFile18(metaPath, "utf-8"));
     } catch {
     }
   }
-  const samplePath = path17.join(blockDir, `_${name}.preview.html`);
+  const samplePath = path28.join(blockDir, `_${name}.preview.html`);
   let sampleContent;
   let placeholder = false;
-  if (existsSync14(samplePath)) {
-    sampleContent = await readFile10(samplePath, "utf-8");
+  if (existsSync24(samplePath)) {
+    sampleContent = await readFile18(samplePath, "utf-8");
   } else {
     sampleContent = defaultSample(name);
     placeholder = true;
@@ -3112,9 +5030,9 @@ async function previewBlock(name, options = {}) {
     reloadTimer = setTimeout(() => server.reload(), 150);
   });
   logger.info("");
-  logger.info(`  ${chalk7.bold("\u279C")}  ${chalk7.cyan(server.url)}`);
+  logger.info(`  ${chalk11.bold("\u279C")}  ${chalk11.cyan(server.url)}`);
   logger.info(statusLine("pass", "live reload", "edits to the block refresh the browser"));
-  logger.info(chalk7.dim("  Press Ctrl+C to stop.\n"));
+  logger.info(chalk11.dim("  Press Ctrl+C to stop.\n"));
   if (options.open !== false) await openInBrowser(server.url);
   const stop = async () => {
     watcher.close();
@@ -3143,10 +5061,10 @@ var from_design_exports = {};
 __export(from_design_exports, {
   blockFromDesign: () => blockFromDesign
 });
-import { existsSync as existsSync15 } from "fs";
-import { readFile as readFile11, writeFile as writeFile9 } from "fs/promises";
-import path18 from "path";
-import chalk8 from "chalk";
+import { existsSync as existsSync25 } from "fs";
+import { readFile as readFile19, writeFile as writeFile16 } from "fs/promises";
+import path29 from "path";
+import chalk12 from "chalk";
 import ora from "ora";
 async function previewRunning(port = 8777) {
   try {
@@ -3296,7 +5214,7 @@ async function blockFromDesign(figmaUrlArg, optionsArg) {
     try {
       figma2 = parseFigmaUrl(designUrl);
       spinner.succeed(
-        `Parsed Figma URL  ${chalk8.dim(figma2.nodeId ? `node ${figma2.nodeId}` : `file ${figma2.fileKey}`)}`
+        `Parsed Figma URL  ${chalk12.dim(figma2.nodeId ? `node ${figma2.nodeId}` : `file ${figma2.fileKey}`)}`
       );
     } catch (err) {
       spinner.fail(err.message);
@@ -3304,7 +5222,7 @@ async function blockFromDesign(figmaUrlArg, optionsArg) {
       return;
     }
   } else {
-    logger.info(`  ${icon.pass} ${providerName} design  ${chalk8.dim(designRef)}`);
+    logger.info(`  ${icon.pass} ${providerName} design  ${chalk12.dim(designRef)}`);
   }
   const blockName = options.name || (figma2 ? inferBlockName(figma2.fileName) : "");
   if (!kebabCaseRegex.test(blockName)) {
@@ -3327,20 +5245,20 @@ async function blockFromDesign(figmaUrlArg, optionsArg) {
     screenshot: options.screenshot !== false
   });
   const promptFile = await savePromptToFile(prompt, projectRoot);
-  const hasTokens = existsSync15(path18.join(projectRoot, "styles", "styles.css"));
+  const hasTokens = existsSync25(path29.join(projectRoot, "styles", "styles.css"));
   promptSpinner.succeed(
-    hasTokens ? `Loaded design tokens  ${chalk8.dim("styles/styles.css")}` : `Built prompt  ${chalk8.dim("no project tokens found")}`
+    hasTokens ? `Loaded design tokens  ${chalk12.dim("styles/styles.css")}` : `Built prompt  ${chalk12.dim("no project tokens found")}`
   );
-  logger.info(chalk8.dim(`  prompt \u2192 ${promptFile}`));
+  logger.info(chalk12.dim(`  prompt \u2192 ${promptFile}`));
   if (options.dryRun) {
     logger.info("");
-    logger.info(chalk8.yellow("Dry run mode \u2014 prompt generated but agent not invoked."));
-    logger.info(`Prompt file: ${chalk8.cyan(promptFile)}`);
-    logger.info(`Block name:  ${chalk8.cyan(blockName)}`);
+    logger.info(chalk12.yellow("Dry run mode \u2014 prompt generated but agent not invoked."));
+    logger.info(`Prompt file: ${chalk12.cyan(promptFile)}`);
+    logger.info(`Block name:  ${chalk12.cyan(blockName)}`);
     logger.info(`Prompt version: ${PROMPT_VERSION}`);
     logger.info("");
     logger.info("Preview:");
-    logger.info(chalk8.dim("\u2500".repeat(60)));
+    logger.info(chalk12.dim("\u2500".repeat(60)));
     console.log(prompt);
     return;
   }
@@ -3348,22 +5266,22 @@ async function blockFromDesign(figmaUrlArg, optionsArg) {
   const preferredAgent = options.agent || config.agent;
   if (options.agent === "none") {
     logger.info("Agent skipped (--agent none). Use the prompt file manually:");
-    logger.info(`  ${chalk8.cyan(promptFile)}`);
+    logger.info(`  ${chalk12.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: ${chalk8.cyan("npm install -g @anthropic-ai/claude-code")}`);
-    logger.info(`Or use the prompt file manually: ${chalk8.cyan(promptFile)}`);
+    logger.info(`Install Claude Code: ${chalk12.cyan("npm install -g @anthropic-ai/claude-code")}`);
+    logger.info(`Or use the prompt file manually: ${chalk12.cyan(promptFile)}`);
     process.exitCode = 1;
     return;
   }
-  agentSpinner.succeed(`Agent ready  ${chalk8.cyan(agent.type)}  ${chalk8.dim(agent.path)}`);
+  agentSpinner.succeed(`Agent ready  ${chalk12.cyan(agent.type)}  ${chalk12.dim(agent.path)}`);
   if (provider === "figma" && !agent.hasFigmaMcp) {
     logger.warn(`Figma MCP may not be configured for ${agent.type}.`);
-    logger.info(`Run ${chalk8.cyan("eds figma setup")} to configure it.`);
+    logger.info(`Run ${chalk12.cyan("eds figma setup")} to configure it.`);
   }
   if (!options.yes) {
     const { confirm } = await import("@inquirer/prompts");
@@ -3372,24 +5290,24 @@ async function blockFromDesign(figmaUrlArg, optionsArg) {
       default: true
     });
     if (!proceed) {
-      logger.info(`Prompt saved to: ${chalk8.cyan(promptFile)}`);
+      logger.info(`Prompt saved to: ${chalk12.cyan(promptFile)}`);
       return;
     }
   }
   logger.info(
-    `  ${chalk8.dim("\u2192")} Handing off to ${chalk8.cyan(agent.type)}  ${chalk8.dim(`via ${providerName} MCP`)}`
+    `  ${chalk12.dim("\u2192")} Handing off to ${chalk12.cyan(agent.type)}  ${chalk12.dim(`via ${providerName} MCP`)}`
   );
   if (provider === "figma") {
-    logger.info(chalk8.dim("     get_design_context \xB7 get_variable_defs \xB7 get_screenshot"));
+    logger.info(chalk12.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 = path18.join(projectRoot, "blocks", blockName);
+  const blockDir = path29.join(projectRoot, "blocks", blockName);
   const ok = await verifyGeneratedBlock(blockDir, blockName, options.ueModel !== false);
-  if (existsSync15(blockDir)) {
+  if (existsSync25(blockDir)) {
     const meta = {
       provider,
       designRef,
@@ -3399,7 +5317,7 @@ async function blockFromDesign(figmaUrlArg, optionsArg) {
       promptVersion: PROMPT_VERSION,
       agentUsed: agent.type
     };
-    await writeFile9(path18.join(blockDir, ".eds-meta.json"), `${JSON.stringify(meta, null, 2)}
+    await writeFile16(path29.join(blockDir, ".eds-meta.json"), `${JSON.stringify(meta, null, 2)}
 `);
   }
   if (!ok) {
@@ -3424,7 +5342,7 @@ async function blockFromDesign(figmaUrlArg, optionsArg) {
   if (options.serve !== false) {
     if (await previewRunning()) {
       logger.info(
-        chalk8.dim(
+        chalk12.dim(
           "  A preview server is already running at http://127.0.0.1:8777 \u2014 your change will refresh there."
         )
       );
@@ -3434,15 +5352,15 @@ async function blockFromDesign(figmaUrlArg, optionsArg) {
       await previewBlock2(blockName, {});
     }
   } else {
-    logger.info(`  ${chalk8.dim("\u2192")} Next:  ${chalk8.cyan(`eds block preview ${blockName}`)}`);
+    logger.info(`  ${chalk12.dim("\u2192")} Next:  ${chalk12.cyan(`eds block preview ${blockName}`)}`);
   }
 }
 async function verifyGeneratedBlock(blockDir, blockName, withUeModel) {
   const checks = [];
-  const jsPath = path18.join(blockDir, `${blockName}.js`);
-  const cssPath = path18.join(blockDir, `${blockName}.css`);
-  const hasJs = existsSync15(jsPath);
-  const hasCss = existsSync15(cssPath);
+  const jsPath = path29.join(blockDir, `${blockName}.js`);
+  const cssPath = path29.join(blockDir, `${blockName}.css`);
+  const hasJs = existsSync25(jsPath);
+  const hasCss = existsSync25(cssPath);
   checks.push({
     status: hasJs ? "pass" : "fail",
     name: `${blockName}.js`,
@@ -3454,7 +5372,7 @@ async function verifyGeneratedBlock(blockDir, blockName, withUeModel) {
     message: hasCss ? "created" : "missing \u2014 agent did not write the CSS file"
   });
   if (hasJs) {
-    const js = await readFile11(jsPath, "utf-8");
+    const js = await readFile19(jsPath, "utf-8");
     checks.push({
       status: /export\s+default/.test(js) ? "pass" : "fail",
       name: "decorate export",
@@ -3469,7 +5387,7 @@ async function verifyGeneratedBlock(blockDir, blockName, withUeModel) {
     }
   }
   if (hasCss) {
-    const css = await readFile11(cssPath, "utf-8");
+    const css = await readFile19(cssPath, "utf-8");
     checks.push({
       status: css.includes(`.${blockName}`) ? "pass" : "warn",
       name: "scoped CSS",
@@ -3477,12 +5395,12 @@ async function verifyGeneratedBlock(blockDir, blockName, withUeModel) {
     });
   }
   if (withUeModel) {
-    const hasPerBlock = existsSync15(path18.join(blockDir, `_${blockName}.json`));
-    const modelsFile = path18.join(blockDir, "..", "..", "component-models.json");
+    const hasPerBlock = existsSync25(path29.join(blockDir, `_${blockName}.json`));
+    const modelsFile = path29.join(blockDir, "..", "..", "component-models.json");
     let hasAggregated = false;
-    if (!hasPerBlock && existsSync15(modelsFile)) {
+    if (!hasPerBlock && existsSync25(modelsFile)) {
       try {
-        hasAggregated = (await readFile11(modelsFile, "utf-8")).includes(`"${blockName}"`);
+        hasAggregated = (await readFile19(modelsFile, "utf-8")).includes(`"${blockName}"`);
       } catch {
       }
     }
@@ -3494,8 +5412,8 @@ async function verifyGeneratedBlock(blockDir, blockName, withUeModel) {
     });
     if (hasPerBlock && hasJs) {
       try {
-        const modelRaw = await readFile11(path18.join(blockDir, `_${blockName}.json`), "utf-8");
-        const js = await readFile11(jsPath, "utf-8");
+        const modelRaw = await readFile19(path29.join(blockDir, `_${blockName}.json`), "utf-8");
+        const js = await readFile19(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) {
@@ -3538,10 +5456,10 @@ var list_exports = {};
 __export(list_exports, {
   listBlocks: () => listBlocks
 });
-import { existsSync as existsSync16 } from "fs";
-import { readFile as readFile12, readdir as readdir2 } from "fs/promises";
-import path19 from "path";
-import chalk9 from "chalk";
+import { existsSync as existsSync26 } from "fs";
+import { readFile as readFile20, readdir as readdir4 } from "fs/promises";
+import path30 from "path";
+import chalk13 from "chalk";
 async function listBlocks(options = {}) {
   const projectRoot = findProjectRoot();
   if (!projectRoot) {
@@ -3549,27 +5467,27 @@ async function listBlocks(options = {}) {
     process.exitCode = 1;
     return;
   }
-  const blocksDir = path19.join(projectRoot, "blocks");
-  if (!existsSync16(blocksDir)) {
+  const blocksDir = path30.join(projectRoot, "blocks");
+  if (!existsSync26(blocksDir)) {
     logger.info("No blocks/ directory found.");
     return;
   }
-  const entries = await readdir2(blocksDir, { withFileTypes: true });
+  const entries = await readdir4(blocksDir, { withFileTypes: true });
   const blocks = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     const name = entry.name;
-    const blockDir = path19.join(blocksDir, name);
+    const blockDir = path30.join(blocksDir, name);
     const info = {
       name,
-      hasJs: existsSync16(path19.join(blockDir, `${name}.js`)),
-      hasCss: existsSync16(path19.join(blockDir, `${name}.css`)),
-      hasUeModel: existsSync16(path19.join(blockDir, `_${name}.json`))
+      hasJs: existsSync26(path30.join(blockDir, `${name}.js`)),
+      hasCss: existsSync26(path30.join(blockDir, `${name}.css`)),
+      hasUeModel: existsSync26(path30.join(blockDir, `_${name}.json`))
     };
-    const metaFile = path19.join(blockDir, ".eds-meta.json");
-    if (existsSync16(metaFile)) {
+    const metaFile = path30.join(blockDir, ".eds-meta.json");
+    if (existsSync26(metaFile)) {
       try {
-        const meta = JSON.parse(await readFile12(metaFile, "utf-8"));
+        const meta = JSON.parse(await readFile20(metaFile, "utf-8"));
         info.figmaSource = {
           fileKey: meta.figmaFileKey,
           nodeId: meta.figmaNodeId,
@@ -3592,17 +5510,17 @@ async function listBlocks(options = {}) {
   const nameWidth = columnWidth(blocks.map((b) => b.name));
   for (const b of blocks) {
     const badges = [
-      b.hasJs ? brand.ok("js") : chalk9.dim.strikethrough("js"),
-      b.hasCss ? brand.ok("css") : chalk9.dim.strikethrough("css")
+      b.hasJs ? brand.ok("js") : chalk13.dim.strikethrough("js"),
+      b.hasCss ? brand.ok("css") : chalk13.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(chalk9.bold(b.name), nameWidth);
-    logger.info(`  ${name}  ${chalk9.dim("[")}${badges.join(" ")}${chalk9.dim("]")}`);
+    const name = padEndVisible(chalk13.bold(b.name), nameWidth);
+    logger.info(`  ${name}  ${chalk13.dim("[")}${badges.join(" ")}${chalk13.dim("]")}`);
     if (b.figmaSource) {
       const synced = new Date(b.figmaSource.lastSyncedAt).toLocaleDateString();
       logger.info(
-        `  ${" ".repeat(nameWidth)}  ${icon.arrow} ${chalk9.dim(
+        `  ${" ".repeat(nameWidth)}  ${icon.arrow} ${chalk13.dim(
           `figma:${b.figmaSource.fileKey} \xB7 synced ${synced}`
         )}`
       );
@@ -3782,10 +5700,10 @@ var integrate_exports = {};
 __export(integrate_exports, {
   integrate: () => integrate
 });
-import { existsSync as existsSync17 } from "fs";
-import { mkdir as mkdir6, readFile as readFile13, writeFile as writeFile10 } from "fs/promises";
-import path20 from "path";
-import chalk10 from "chalk";
+import { existsSync as existsSync27 } from "fs";
+import { mkdir as mkdir9, readFile as readFile21, writeFile as writeFile17 } from "fs/promises";
+import path31 from "path";
+import chalk14 from "chalk";
 async function integrate(type) {
   const projectRoot = findProjectRoot();
   if (!projectRoot) {
@@ -3808,16 +5726,16 @@ async function integrate(type) {
     return;
   }
   const values = {};
-  for (const f of integration.fields) {
-    const answer = await input({ message: `  ${f.message}`, default: f.placeholder });
-    values[f.name] = answer.trim();
+  for (const f2 of integration.fields) {
+    const answer = await input({ message: `  ${f2.message}`, default: f2.placeholder });
+    values[f2.name] = answer.trim();
   }
   const modulePaths = [];
   if (integration.module) {
     for (const mod of integration.module(values)) {
-      const abs = path20.join(projectRoot, mod.file);
-      await mkdir6(path20.dirname(abs), { recursive: true });
-      await writeFile10(abs, mod.content);
+      const abs = path31.join(projectRoot, mod.file);
+      await mkdir9(path31.dirname(abs), { recursive: true });
+      await writeFile17(abs, mod.content);
       modulePaths.push(mod.file);
     }
   }
@@ -3825,26 +5743,26 @@ async function integrate(type) {
 // ${integration.name} (eds integrate)
 ${integration.code(values)}
 ` : wrapBlock(integration.name, integration.code(values));
-  const delayedPath = path20.join(projectRoot, "scripts", "delayed.js");
-  await mkdir6(path20.dirname(delayedPath), { recursive: true });
-  const existing = existsSync17(delayedPath) ? await readFile13(delayedPath, "utf-8") : DELAYED_HEADER;
-  await writeFile10(delayedPath, `${existing.replace(/\s*$/, "")}
+  const delayedPath = path31.join(projectRoot, "scripts", "delayed.js");
+  await mkdir9(path31.dirname(delayedPath), { recursive: true });
+  const existing = existsSync27(delayedPath) ? await readFile21(delayedPath, "utf-8") : DELAYED_HEADER;
+  await writeFile17(delayedPath, `${existing.replace(/\s*$/, "")}
 ${block2}`);
   logger.info(heading("Added"));
   for (const p of modulePaths) logger.info(accentLine(integration.name, `wrote ${p}`));
   logger.info(accentLine(integration.name, "wired into scripts/delayed.js"));
   logger.info("");
   logger.info(
-    chalk10.dim("  Loads after LCP (delayed phase) - zero impact on your Core Web Vitals.")
+    chalk14.dim("  Loads after LCP (delayed phase) - zero impact on your Core Web Vitals.")
   );
   if (integration.id === "gtm" || integration.id === "ga4") {
     logger.info(
-      chalk10.dim("  Tip: gate analytics behind user consent (add the Cookiebot integration).")
+      chalk14.dim("  Tip: gate analytics behind user consent (add the Cookiebot integration).")
     );
   }
   if (integration.id === "chat") {
     logger.info(
-      chalk10.dim("  The widget loads only when the visitor clicks the button (facade pattern).")
+      chalk14.dim("  The widget loads only when the visitor clicks the button (facade pattern).")
     );
   }
   logger.info("");
@@ -3870,9 +5788,9 @@ var setup_exports = {};
 __export(setup_exports, {
   figmaSetup: () => figmaSetup
 });
-import { existsSync as existsSync18 } from "fs";
-import { mkdir as mkdir7, writeFile as writeFile11 } from "fs/promises";
-import chalk11 from "chalk";
+import { existsSync as existsSync28 } from "fs";
+import { mkdir as mkdir10, writeFile as writeFile18 } from "fs/promises";
+import chalk15 from "chalk";
 async function figmaSetup() {
   const { select, confirm } = await import("@inquirer/prompts");
   logger.logoOnce(logo());
@@ -3882,15 +5800,15 @@ async function figmaSetup() {
   let selectedAgent;
   if (agents.length === 0) {
     logger.warn("No AI agents found (claude, cursor, codex).");
-    logger.info(`Install Claude Code: ${chalk11.cyan("npm install -g @anthropic-ai/claude-code")}`);
+    logger.info(`Install Claude Code: ${chalk15.cyan("npm install -g @anthropic-ai/claude-code")}`);
     selectedAgent = "none";
   } else {
-    logger.success(`Found: ${agents.map((a) => chalk11.cyan(a.type)).join(", ")}`);
+    logger.success(`Found: ${agents.map((a) => chalk15.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 ? chalk11.green(" (Figma MCP detected)") : ""}`,
+          name: `${a.type}${a.hasFigmaMcp ? chalk15.green(" (Figma MCP detected)") : ""}`,
           value: a.type
         })),
         { name: "None (manual mode)", value: "none" }
@@ -3906,17 +5824,17 @@ async function figmaSetup() {
       switch (selectedAgent) {
         case "claude":
           logger.info(
-            `  ${chalk11.cyan("claude mcp add --transport sse figma-sse https://mcp.figma.com/sse")}`
+            `  ${chalk15.cyan("claude mcp add --transport sse figma-sse https://mcp.figma.com/sse")}`
           );
           logger.info("  or for Figma Desktop app:");
           logger.info(
-            `  ${chalk11.cyan("claude mcp add --transport http figma-desktop http://127.0.0.1:3845/mcp")}`
+            `  ${chalk15.cyan("claude mcp add --transport http figma-desktop http://127.0.0.1:3845/mcp")}`
           );
           break;
         case "cursor":
-          logger.info(`  Add to ${chalk11.cyan("~/.cursor/mcp.json")}:`);
+          logger.info(`  Add to ${chalk15.cyan("~/.cursor/mcp.json")}:`);
           logger.info(
-            chalk11.dim(
+            chalk15.dim(
               JSON.stringify(
                 {
                   mcpServers: {
@@ -3941,7 +5859,7 @@ async function figmaSetup() {
     }
   }
   logger.info(
-    chalk11.dim(
+    chalk15.dim(
       "\nNote: Figma MCP requires a Figma seat (Dev or Full on paid plans for desktop server)."
     )
   );
@@ -3951,22 +5869,22 @@ async function figmaSetup() {
   });
   if (shouldSave) {
     const configDir = globalConfigDir();
-    if (!existsSync18(configDir)) {
-      await mkdir7(configDir, { recursive: true });
+    if (!existsSync28(configDir)) {
+      await mkdir10(configDir, { recursive: true });
     }
     const config = {};
     if (selectedAgent !== "none") {
       config.agent = selectedAgent;
     }
-    await writeFile11(globalConfigPath(), `${JSON.stringify(config, null, 2)}
+    await writeFile18(globalConfigPath(), `${JSON.stringify(config, null, 2)}
 `, {
       mode: 384
     });
-    logger.success(`Config saved to ${chalk11.cyan(globalConfigPath())}`);
+    logger.success(`Config saved to ${chalk15.cyan(globalConfigPath())}`);
   }
-  logger.info(chalk11.bold("\nSetup complete!"));
+  logger.info(chalk15.bold("\nSetup complete!"));
   if (selectedAgent !== "none") {
-    logger.info(`Try: ${chalk11.cyan('eds block from-design "<figma-url>" --dry-run')}`);
+    logger.info(`Try: ${chalk15.cyan('eds block from-design "<figma-url>" --dry-run')}`);
   }
 }
 var init_setup = __esm({
@@ -3985,10 +5903,10 @@ var doctor_exports = {};
 __export(doctor_exports, {
   doctor: () => doctor
 });
-import { existsSync as existsSync19 } from "fs";
-import { readFile as readFile14, readdir as readdir3 } from "fs/promises";
-import path21 from "path";
-import { parse as parseYaml } from "yaml";
+import { existsSync as existsSync29 } from "fs";
+import { readFile as readFile22, readdir as readdir5 } from "fs/promises";
+import path32 from "path";
+import { parse as parseYaml2 } from "yaml";
 async function doctor(options = {}) {
   const projectRoot = findProjectRoot();
   if (!projectRoot) {
@@ -4009,8 +5927,8 @@ async function doctor(options = {}) {
   });
   if (project.hasFstab) {
     try {
-      const content = await readFile14(path21.join(projectRoot, "fstab.yaml"), "utf-8");
-      parseYaml(content);
+      const content = await readFile22(path32.join(projectRoot, "fstab.yaml"), "utf-8");
+      parseYaml2(content);
       results.push({ name: "fstab.yaml valid YAML", status: "pass", message: "Valid" });
     } catch {
       results.push({
@@ -4031,28 +5949,28 @@ async function doctor(options = {}) {
     message: project.hasBlocks ? "Found" : "Missing - no blocks yet"
   });
   if (project.hasBlocks) {
-    const blocksDir = path21.join(projectRoot, "blocks");
-    const entries = await readdir3(blocksDir, { withFileTypes: true });
+    const blocksDir = path32.join(projectRoot, "blocks");
+    const entries = await readdir5(blocksDir, { withFileTypes: true });
     let aggregatedModels = "";
-    const aggregatedPath = path21.join(projectRoot, "component-models.json");
-    if (existsSync19(aggregatedPath)) {
+    const aggregatedPath = path32.join(projectRoot, "component-models.json");
+    if (existsSync29(aggregatedPath)) {
       try {
-        aggregatedModels = await readFile14(aggregatedPath, "utf-8");
+        aggregatedModels = await readFile22(aggregatedPath, "utf-8");
       } catch {
       }
     }
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const blockName = entry.name;
-      const jsFile = path21.join(blocksDir, blockName, `${blockName}.js`);
-      const hasJs = existsSync19(jsFile);
+      const jsFile = path32.join(blocksDir, blockName, `${blockName}.js`);
+      const hasJs = existsSync29(jsFile);
       results.push({
         name: `blocks/${blockName} has JS`,
         status: hasJs ? "pass" : "warn",
         message: hasJs ? "Found" : `Missing ${blockName}.js`
       });
       if (hasJs) {
-        const jsContent = await readFile14(jsFile, "utf-8");
+        const jsContent = await readFile22(jsFile, "utf-8");
         if (jsContent.includes("console.log")) {
           results.push({
             name: `blocks/${blockName} no console.log`,
@@ -4061,17 +5979,17 @@ async function doctor(options = {}) {
           });
         }
       }
-      const hasPerBlockModel = existsSync19(path21.join(blocksDir, blockName, `_${blockName}.json`));
+      const hasPerBlockModel = existsSync29(path32.join(blocksDir, blockName, `_${blockName}.json`));
       const hasAggregatedModel = aggregatedModels.includes(`"${blockName}"`);
       results.push({
         name: `blocks/${blockName} UE model`,
         status: hasPerBlockModel || hasAggregatedModel ? "pass" : "warn",
         message: hasPerBlockModel || hasAggregatedModel ? hasPerBlockModel ? `_${blockName}.json` : "in component-models.json" : "no Universal Editor model - authors can't edit this block in UE"
       });
-      const metaFile = path21.join(blocksDir, blockName, ".eds-meta.json");
-      if (existsSync19(metaFile)) {
+      const metaFile = path32.join(blocksDir, blockName, ".eds-meta.json");
+      if (existsSync29(metaFile)) {
         try {
-          const meta = JSON.parse(await readFile14(metaFile, "utf-8"));
+          const meta = JSON.parse(await readFile22(metaFile, "utf-8"));
           const syncDate = new Date(meta.lastSyncedAt);
           const daysSinceSync = Math.floor(
             (Date.now() - syncDate.getTime()) / (1e3 * 60 * 60 * 24)
@@ -4091,11 +6009,11 @@ async function doctor(options = {}) {
       }
     }
   }
-  const queryFile = path21.join(projectRoot, "helix-query.yaml");
-  if (existsSync19(queryFile)) {
+  const queryFile = path32.join(projectRoot, "helix-query.yaml");
+  if (existsSync29(queryFile)) {
     try {
-      const content = await readFile14(queryFile, "utf-8");
-      parseYaml(content);
+      const content = await readFile22(queryFile, "utf-8");
+      parseYaml2(content);
       results.push({ name: "helix-query.yaml valid", status: "pass", message: "Valid YAML" });
     } catch {
       results.push({
@@ -4151,10 +6069,10 @@ var audit_loading_exports = {};
 __export(audit_loading_exports, {
   auditLoading: () => auditLoading
 });
-import { existsSync as existsSync20 } from "fs";
-import { readFile as readFile15, readdir as readdir4, stat as stat3 } from "fs/promises";
-import path22 from "path";
-import chalk12 from "chalk";
+import { existsSync as existsSync30 } from "fs";
+import { readFile as readFile23, readdir as readdir6, stat as stat3 } from "fs/promises";
+import path33 from "path";
+import chalk16 from "chalk";
 async function auditLoading(options = {}) {
   const projectRoot = findProjectRoot();
   if (!projectRoot) {
@@ -4187,8 +6105,8 @@ async function auditLoading(options = {}) {
   printResults(results);
 }
 async function checkHeadHtml(root, results) {
-  const filePath = path22.join(root, "head.html");
-  if (!existsSync20(filePath)) {
+  const filePath = path33.join(root, "head.html");
+  if (!existsSync30(filePath)) {
     results.push({
       rule: "head.html exists",
       status: "warn",
@@ -4196,7 +6114,7 @@ async function checkHeadHtml(root, results) {
     });
     return;
   }
-  const content = await readFile15(filePath, "utf-8");
+  const content = await readFile23(filePath, "utf-8");
   const lines = content.split("\n");
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
@@ -4268,8 +6186,8 @@ async function checkHeadHtml(root, results) {
   }
 }
 async function checkScriptsJs(root, results) {
-  const filePath = path22.join(root, "scripts", "scripts.js");
-  if (!existsSync20(filePath)) {
+  const filePath = path33.join(root, "scripts", "scripts.js");
+  if (!existsSync30(filePath)) {
     results.push({
       rule: "scripts/scripts.js exists",
       status: "warn",
@@ -4277,7 +6195,7 @@ async function checkScriptsJs(root, results) {
     });
     return;
   }
-  const content = await readFile15(filePath, "utf-8");
+  const content = await readFile23(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);
@@ -4355,8 +6273,8 @@ async function checkScriptsJs(root, results) {
   }
 }
 async function checkStylesCss(root, results) {
-  const filePath = path22.join(root, "styles", "styles.css");
-  if (!existsSync20(filePath)) return;
+  const filePath = path33.join(root, "styles", "styles.css");
+  if (!existsSync30(filePath)) return;
   const stats = await stat3(filePath);
   const sizeKb = stats.size / 1024;
   results.push({
@@ -4365,7 +6283,7 @@ async function checkStylesCss(root, results) {
     message: `${sizeKb.toFixed(1)} KB${sizeKb > 40 ? " \u2014 large CSS competes with 100KB LCP budget" : ""}`,
     file: "styles/styles.css"
   });
-  const content = await readFile15(filePath, "utf-8");
+  const content = await readFile23(filePath, "utf-8");
   if (/@import\s/.test(content)) {
     results.push({
       rule: "No @import in styles.css",
@@ -4376,8 +6294,8 @@ async function checkStylesCss(root, results) {
   }
 }
 async function checkDelayedJs(root, results) {
-  const filePath = path22.join(root, "scripts", "delayed.js");
-  if (!existsSync20(filePath)) {
+  const filePath = path33.join(root, "scripts", "delayed.js");
+  if (!existsSync30(filePath)) {
     results.push({
       rule: "scripts/delayed.js exists",
       status: "info",
@@ -4385,7 +6303,7 @@ async function checkDelayedJs(root, results) {
     });
     return;
   }
-  const content = await readFile15(filePath, "utf-8");
+  const content = await readFile23(filePath, "utf-8");
   const stripped = content.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").trim();
   if (!stripped) {
     results.push({
@@ -4397,15 +6315,15 @@ async function checkDelayedJs(root, results) {
   }
 }
 async function checkBlocks(root, results) {
-  const blocksDir = path22.join(root, "blocks");
-  if (!existsSync20(blocksDir)) return;
-  const entries = await readdir4(blocksDir, { withFileTypes: true });
+  const blocksDir = path33.join(root, "blocks");
+  if (!existsSync30(blocksDir)) return;
+  const entries = await readdir6(blocksDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     const blockName = entry.name;
-    const jsFile = path22.join(blocksDir, blockName, `${blockName}.js`);
-    if (!existsSync20(jsFile)) continue;
-    const content = await readFile15(jsFile, "utf-8");
+    const jsFile = path33.join(blocksDir, blockName, `${blockName}.js`);
+    if (!existsSync30(jsFile)) continue;
+    const content = await readFile23(jsFile, "utf-8");
     const lines = content.split("\n");
     const heavyLibs = [
       "jquery",
@@ -4455,9 +6373,9 @@ async function checkBlocks(root, results) {
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     const blockName = entry.name;
-    const cssFile = path22.join(blocksDir, blockName, `${blockName}.css`);
-    if (!existsSync20(cssFile)) continue;
-    const content = await readFile15(cssFile, "utf-8");
+    const cssFile = path33.join(blocksDir, blockName, `${blockName}.css`);
+    if (!existsSync30(cssFile)) continue;
+    const content = await readFile23(cssFile, "utf-8");
     const selectorPattern = /^([a-z][a-z0-9-]*)\s*\{/gm;
     for (const selectorMatch of content.matchAll(selectorPattern)) {
       const selector = selectorMatch[1];
@@ -4473,8 +6391,8 @@ async function checkBlocks(root, results) {
   }
 }
 async function checkAemJs(root, results) {
-  const filePath = path22.join(root, "scripts", "aem.js");
-  if (!existsSync20(filePath)) {
+  const filePath = path33.join(root, "scripts", "aem.js");
+  if (!existsSync30(filePath)) {
     results.push({
       rule: "scripts/aem.js exists",
       status: "warn",
@@ -4512,12 +6430,12 @@ function printResults(results) {
     grouped.set(key, bucket);
   }
   for (const [file, fileResults] of grouped) {
-    logger.info(`  ${icon.bullet} ${chalk12.underline(file)}`);
+    logger.info(`  ${icon.bullet} ${chalk16.underline(file)}`);
     for (const r of fileResults) {
-      const loc = r.line ? chalk12.dim(`:${r.line}`) : "";
+      const loc = r.line ? chalk16.dim(`:${r.line}`) : "";
       logger.info(`    ${statusIcon(r.status)} ${r.rule}${loc}`);
       if (r.status !== "pass") {
-        logger.info(chalk12.dim(`       ${r.message}`));
+        logger.info(chalk16.dim(`       ${r.message}`));
       }
     }
     logger.info("");
@@ -4546,14 +6464,14 @@ var audit_security_exports = {};
 __export(audit_security_exports, {
   auditSecurity: () => auditSecurity
 });
-import { existsSync as existsSync21 } from "fs";
-import { readFile as readFile16, readdir as readdir5 } from "fs/promises";
-import path23 from "path";
-import chalk13 from "chalk";
+import { existsSync as existsSync31 } from "fs";
+import { readFile as readFile24, readdir as readdir7 } from "fs/promises";
+import path34 from "path";
+import chalk17 from "chalk";
 async function* walk2(dir) {
-  const entries = await readdir5(dir, { withFileTypes: true });
+  const entries = await readdir7(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const full = path23.join(dir, entry.name);
+    const full = path34.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (IGNORE_DIRS.has(entry.name)) continue;
       yield* walk2(full);
@@ -4587,11 +6505,11 @@ function scanContent(content, relFile, ext) {
   return findings;
 }
 async function auditDependencies(root) {
-  if (!existsSync21(path23.join(root, "package.json"))) {
+  if (!existsSync31(path34.join(root, "package.json"))) {
     return { status: "skipped", note: "no package.json" };
   }
-  const hasLock = existsSync21(path23.join(root, "package-lock.json")) || existsSync21(path23.join(root, "npm-shrinkwrap.json"));
-  if (!hasLock && !existsSync21(path23.join(root, "node_modules"))) {
+  const hasLock = existsSync31(path34.join(root, "package-lock.json")) || existsSync31(path34.join(root, "npm-shrinkwrap.json"));
+  if (!hasLock && !existsSync31(path34.join(root, "node_modules"))) {
     return { status: "skipped", note: "no package-lock.json / node_modules \u2014 run npm install" };
   }
   try {
@@ -4623,15 +6541,15 @@ async function auditSecurity(options = {}) {
   }
   const findings = [];
   for await (const file of walk2(projectRoot)) {
-    const ext = path23.extname(file).slice(1).toLowerCase();
+    const ext = path34.extname(file).slice(1).toLowerCase();
     if (!SCAN_EXT.has(ext)) continue;
-    const rel = path23.relative(projectRoot, file);
+    const rel = path34.relative(projectRoot, file);
     if (rel.endsWith("aem.js") || rel.endsWith("lib-franklin.js")) continue;
-    const content = await readFile16(file, "utf-8");
+    const content = await readFile24(file, "utf-8");
     findings.push(...scanContent(content, rel, ext));
   }
   const deps = await auditDependencies(projectRoot);
-  const bySeverity = (s) => findings.filter((f) => f.severity === s);
+  const bySeverity = (s) => findings.filter((f2) => f2.severity === s);
   const codeCounts = {
     critical: bySeverity("critical").length,
     high: bySeverity("high").length,
@@ -4673,11 +6591,11 @@ async function auditSecurity(options = {}) {
     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 = chalk13.dim(`${f.file}:${f.line}`);
-      logger.info(`  ${statusIcon(meta.status)} ${chalk13.bold(meta.label)} ${f.message}  ${loc}`);
-      logger.info(chalk13.dim(`         ${f.snippet}`));
+    for (const f2 of sorted) {
+      const meta = SEVERITY_META[f2.severity];
+      const loc = chalk17.dim(`${f2.file}:${f2.line}`);
+      logger.info(`  ${statusIcon(meta.status)} ${chalk17.bold(meta.label)} ${f2.message}  ${loc}`);
+      logger.info(chalk17.dim(`         ${f2.snippet}`));
     }
   }
   const summaryLine = summary({
@@ -4884,7 +6802,7 @@ __export(preview_exports2, {
   preview: () => preview,
   resolveAdminConfig: () => resolveAdminConfig
 });
-import chalk14 from "chalk";
+import chalk18 from "chalk";
 import ora2 from "ora";
 async function preview(paths, options) {
   const projectRoot = findProjectRoot();
@@ -4897,7 +6815,7 @@ async function preview(paths, options) {
   let hasErrors = false;
   for (const r of results) {
     if (r.ok) {
-      logger.success(`${r.path} \u2192 ${chalk14.cyan(r.previewUrl || "preview updated")}`);
+      logger.success(`${r.path} \u2192 ${chalk18.cyan(r.previewUrl || "preview updated")}`);
     } else {
       logger.error(`${r.path} \u2014 ${r.message}`);
       hasErrors = true;
@@ -4911,7 +6829,7 @@ function resolveAdminConfig(config, options) {
   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(chalk14.dim('  { "admin": { "org": "my-org", "site": "my-site" } }'));
+    logger.info(chalk18.dim('  { "admin": { "org": "my-org", "site": "my-site" } }'));
     process.exitCode = 1;
     return void 0;
   }
@@ -4933,7 +6851,7 @@ var publish_exports = {};
 __export(publish_exports, {
   publish: () => publish
 });
-import chalk15 from "chalk";
+import chalk19 from "chalk";
 import ora3 from "ora";
 async function publish(paths, options) {
   const projectRoot = findProjectRoot();
@@ -4946,7 +6864,7 @@ async function publish(paths, options) {
   let hasErrors = false;
   for (const r of results) {
     if (r.ok) {
-      logger.success(`${r.path} \u2192 ${chalk15.cyan(r.liveUrl || "published")}`);
+      logger.success(`${r.path} \u2192 ${chalk19.cyan(r.liveUrl || "published")}`);
     } else {
       logger.error(`${r.path} \u2014 ${r.message}`);
       hasErrors = true;
@@ -5045,13 +6963,13 @@ var menu_exports = {};
 __export(menu_exports, {
   mainMenu: () => mainMenu
 });
-import { existsSync as existsSync22 } from "fs";
-import { readdir as readdir6 } from "fs/promises";
-import path24 from "path";
+import { existsSync as existsSync32 } from "fs";
+import { readdir as readdir8 } from "fs/promises";
+import path35 from "path";
 async function listBlockNames(projectRoot) {
-  const dir = path24.join(projectRoot, "blocks");
-  if (!existsSync22(dir)) return [];
-  const entries = await readdir6(dir, { withFileTypes: true });
+  const dir = path35.join(projectRoot, "blocks");
+  if (!existsSync32(dir)) return [];
+  const entries = await readdir8(dir, { withFileTypes: true });
   return entries.filter((e) => e.isDirectory()).map((e) => e.name);
 }
 async function mainMenu() {
@@ -5061,6 +6979,8 @@ async function mainMenu() {
     message: "Choose an action",
     choices: [
       { name: "Set up this project (authoring model, CI, naming)", value: "init" },
+      { name: "Generate a page template (initial content)", value: "template" },
+      { name: "Create a disposable sandbox repo on GitHub", value: "sandbox" },
       {
         name: "Generate a block from a design (Figma/Stitch/Canva/Sketch/Framer)",
         value: "from-design"
@@ -5069,7 +6989,10 @@ async function mainMenu() {
       { 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: "Add fields to a block model (partials)", value: "model" },
       { name: "Instrument a block for analytics (dataLayer)", value: "track" },
+      { name: "Add JSON-LD structured data to a block", value: "schema" },
+      { name: "Check Universal Editor readiness / open the editor", value: "ue" },
       { name: "Preview a block in the browser", value: "preview-block" },
       { name: "Preview / publish pages (Admin API)", value: "admin" },
       { name: "Audit the project", value: "audit" },
@@ -5082,6 +7005,24 @@ async function mainMenu() {
       await initProject2({});
       return;
     }
+    case "template": {
+      const name = await input({
+        message: "Template name",
+        validate: (v) => !!v.trim() || "Required"
+      });
+      const { templateNew: templateNew2 } = await Promise.resolve().then(() => (init_template(), template_exports));
+      await templateNew2(name.trim(), {});
+      return;
+    }
+    case "sandbox": {
+      const name = await input({
+        message: "Sandbox repo name",
+        validate: (v) => /^[a-z0-9][a-z0-9._-]*$/i.test(v.trim()) || "Use a valid repo name"
+      });
+      const { sandboxNew: sandboxNew2 } = await Promise.resolve().then(() => (init_sandbox(), sandbox_exports));
+      await sandboxNew2(name.trim(), {});
+      return;
+    }
     case "from-design": {
       const { blockFromDesign: blockFromDesign2 } = await Promise.resolve().then(() => (init_from_design(), from_design_exports));
       await blockFromDesign2(void 0, {});
@@ -5130,6 +7071,11 @@ async function mainMenu() {
       await previewBlock2(name, {});
       return;
     }
+    case "model": {
+      const { modelAdd: modelAdd2 } = await Promise.resolve().then(() => (init_model(), model_exports));
+      await modelAdd2(void 0, [], {});
+      return;
+    }
     case "track": {
       const projectRoot = findProjectRoot();
       if (!projectRoot) {
@@ -5149,6 +7095,43 @@ async function mainMenu() {
       await trackBlock2(name, {});
       return;
     }
+    case "schema": {
+      const projectRoot = findProjectRoot();
+      if (!projectRoot) {
+        logger.error("Not inside an EDS project (no EDS project markers 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 { schemaBlock: schemaBlock2 } = await Promise.resolve().then(() => (init_schema(), schema_exports));
+      await schemaBlock2(name, {});
+      return;
+    }
+    case "ue": {
+      const which = await select({
+        message: "Universal Editor:",
+        choices: [
+          { name: "Check readiness (which blocks are editable)", value: "check" },
+          { name: "Open a page in the editor", value: "open" }
+        ]
+      });
+      if (which === "check") {
+        const { ueCheck: ueCheck2 } = await Promise.resolve().then(() => (init_ue3(), ue_exports));
+        await ueCheck2();
+      } else {
+        const pagePath = await input({ message: "Page path", default: "/" });
+        const { ueOpen: ueOpen2 } = await Promise.resolve().then(() => (init_ue3(), ue_exports));
+        await ueOpen2(pagePath.trim() || "/", {});
+      }
+      return;
+    }
     case "admin": {
       const { adminWizard: adminWizard2 } = await Promise.resolve().then(() => (init_admin(), admin_exports));
       await adminWizard2();
@@ -5194,13 +7177,13 @@ var init_menu = __esm({
 
 // src/bin/eds.ts
 init_esm_shims();
-import chalk16 from "chalk";
+import chalk20 from "chalk";
 import { Command } from "commander";
 
 // package.json
 var package_default = {
   name: "aem-eds-kit",
-  version: "0.4.12",
+  version: "0.4.22",
   description: "CLI for AEM Edge Delivery Services with Figma MCP integration",
   type: "module",
   engines: {
@@ -5276,10 +7259,40 @@ program.name("eds").description("CLI for AEM Edge Delivery Services with Figma i
   const opts = thisCommand.opts();
   if (opts.verbose) logger.setLevel("debug");
   if (opts.quiet) logger.setQuiet(true);
-  if (opts.color === false) chalk16.level = 0;
+  if (opts.color === false) chalk20.level = 0;
 });
 program.addHelpText("beforeAll", () => logo());
-program.command("init").description("Set up a freshly cloned EDS boilerplate for your authoring model (interactive)").option("--name <name>", "Project name (kebab-case)").option("--authoring <model>", "Authoring model: ue | da | gdrive | sharepoint").option("--mountpoint <url>", "Content source URL (document models)").option("--org <org>", "DA org (authoring=da)").option("--site <site>", "DA site (authoring=da)").option("--no-ci", "Skip the GitHub Actions CI workflow").option("--yes", "Skip prompts; apply with flags/defaults").action(async (options) => {
+var sandbox = program.command("sandbox").description("Disposable EDS sandbox repos on GitHub");
+sandbox.command("new <name>").description("Create a disposable EDS repo from a boilerplate (GitHub auth, no gh required)").option("--org <org>", "Create under a GitHub org (else your account)").option("--boilerplate <repo>", "Template repo (default adobe/aem-boilerplate)").option("--ue", "Use the crosswalk / Universal Editor boilerplate").option("--private", "Create a private repo").option("--yes", "Skip the guided prompts (use flags/defaults)").action(async (name, options) => {
+  const { sandboxNew: sandboxNew2 } = await Promise.resolve().then(() => (init_sandbox(), sandbox_exports));
+  await sandboxNew2(name, options);
+});
+sandbox.command("login").description("Authorize GitHub (OAuth device flow or a token) - no gh needed").action(async () => {
+  const { sandboxLogin: sandboxLogin2 } = await Promise.resolve().then(() => (init_sandbox(), sandbox_exports));
+  await sandboxLogin2();
+});
+sandbox.command("logout").description("Remove the stored GitHub token").action(async () => {
+  const { sandboxLogout: sandboxLogout2 } = await Promise.resolve().then(() => (init_sandbox(), sandbox_exports));
+  await sandboxLogout2();
+});
+sandbox.command("list").description("List your EDS sandboxes (repos tagged eds-sandbox)").action(async () => {
+  const { sandboxList: sandboxList2 } = await Promise.resolve().then(() => (init_sandbox(), sandbox_exports));
+  await sandboxList2();
+});
+sandbox.command("rm <name>").description("Delete a sandbox repo (destructive)").option("--org <org>", "Owner org (else your account)").option("--yes", "Skip the confirmation").action(async (name, options) => {
+  const { sandboxRm: sandboxRm2 } = await Promise.resolve().then(() => (init_sandbox(), sandbox_exports));
+  await sandboxRm2(name, options);
+});
+var template = program.command("template").description("Generate page templates / initial content");
+template.command("new <name>").description("Generate EDS page initial content (sections + blocks + metadata), DA push optional").option("--path <path>", "Content path (default: /templates/<name>)").option("--title <title>", "Page title").option("--description <text>", "Page description").option(
+  "--blocks <list>",
+  "Comma-separated block ids to seed",
+  (v) => v.split(",").map((b) => b.trim())
+).option("--area <area>", "Site area / template label (stored in metadata)").option("--authoring <model>", "Force authoring model: da | gdrive | sharepoint | ue").option("--push", "Push the page to DA (da.live)").option("--org <org>", "DA org (else from .edsrc.json)").option("--site <site>", "DA site (else from .edsrc.json)").option("--yes", "Skip prompts").action(async (name, options) => {
+  const { templateNew: templateNew2 } = await Promise.resolve().then(() => (init_template(), template_exports));
+  await templateNew2(name, options);
+});
+program.command("init").description("Set up a freshly cloned EDS boilerplate for your authoring model (interactive)").option("--name <name>", "Project name (kebab-case)").option("--authoring <model>", "Authoring model: ue | da | gdrive | sharepoint").option("--mountpoint <url>", "Content source URL (document models)").option("--org <org>", "DA org (authoring=da)").option("--site <site>", "DA site (authoring=da)").option("--no-ci", "Skip the GitHub Actions CI workflow").option("--no-env", "Skip the local-dev .env (aem up config)").option("--no-xwalk", "Skip xwalk.json (UE multi-field)").option("--yes", "Skip prompts; apply with flags/defaults").action(async (options) => {
   const { initProject: initProject2 } = await Promise.resolve().then(() => (init_init(), init_exports));
   await initProject2(options);
 });
@@ -5288,11 +7301,30 @@ migrate.command("component [dir]").description("Migrate a classic AEM component'
   const { migrateComponent: migrateComponent2 } = await Promise.resolve().then(() => (init_migrate(), migrate_exports));
   await migrateComponent2(dir, options);
 });
+var model = program.command("model").description("Compose Universal Editor models");
+model.command("add <block> [partials...]").description("Add reusable field groups (partials) to a block's UE model").option("--yes", "Skip prompts").action(async (blockName, partials, options) => {
+  const { modelAdd: modelAdd2 } = await Promise.resolve().then(() => (init_model(), model_exports));
+  await modelAdd2(blockName, partials, options);
+});
+var schema = program.command("schema").description("Structured data (JSON-LD) for blocks");
+schema.command("block <name>").description("Inject a JSON-LD (schema.org) builder into a block's decorate()").option("--type <type>", "schema.org type (Article, FAQPage, Product, ...)").option("--yes", "Skip prompts").action(async (name, options) => {
+  const { schemaBlock: schemaBlock2 } = await Promise.resolve().then(() => (init_schema(), schema_exports));
+  await schemaBlock2(name, options);
+});
 var track = program.command("track").description("Instrument blocks for analytics");
 track.command("block <name>").description("Add dataLayer tracking (click + form submit) to a block's decorate()").option("--no-click", "Skip click tracking").option("--no-submit", "Skip form-submit tracking").action(async (name, options) => {
   const { trackBlock: trackBlock2 } = await Promise.resolve().then(() => (init_track2(), track_exports));
   await trackBlock2(name, options);
 });
+var ue = program.command("ue").description("Universal Editor - readiness check + editor deep link");
+ue.command("check").description("Check whether blocks are Universal-Editor-ready (offline)").action(async () => {
+  const { ueCheck: ueCheck2 } = await Promise.resolve().then(() => (init_ue3(), ue_exports));
+  await ueCheck2();
+});
+ue.command("open [path]").description("Open a page in the hosted Universal Editor (preview host from git)").option("--org <slug>", "IMS org slug (skips the org picker)").option("--ref <branch>", "Branch/ref for the preview host (default: main)").option("--url <host>", "Override the delivery host (e.g. main--repo--owner.aem.page)").option("--no-open", "Print the link without opening the browser").action(async (pagePath, options) => {
+  const { ueOpen: ueOpen2 } = await Promise.resolve().then(() => (init_ue3(), ue_exports));
+  await ueOpen2(pagePath, options);
+});
 var block = program.command("block").description("Manage EDS blocks");
 block.command("create <name>").description("Scaffold a new EDS block (with Universal Editor model by default)").option("--no-ue-model", "Skip the Universal Editor model (generated by default)").action(async (name, options) => {
   const { createBlock: createBlock2 } = await Promise.resolve().then(() => (init_create(), create_exports));
@@ -5328,6 +7360,18 @@ scaffold.command("ci").description("Scaffold a GitHub Actions workflow (doctor +
   const { scaffoldCi: scaffoldCi2 } = await Promise.resolve().then(() => (init_scaffold(), scaffold_exports));
   await scaffoldCi2();
 });
+scaffold.command("helpers [names...]").description("Scaffold scripts/utils.js with chosen EDS helpers (interactive picker)").action(async (names) => {
+  const { scaffoldHelpers: scaffoldHelpers2 } = await Promise.resolve().then(() => (init_scaffold(), scaffold_exports));
+  await scaffoldHelpers2(names);
+});
+scaffold.command("env").description("Write a local-dev .env for `aem up` (AEM_OPEN / AEM_PORT / AEM_PAGES_URL)").option("--open <path>", "AEM_OPEN - path opened on start (default: /)").option("--port <port>", "AEM_PORT - proxy port (default: 3007)").option("--pages-url <url>", "AEM_PAGES_URL - content origin (default: from git remote)").option("--yes", "Skip prompts; use flags/defaults").action(async (options) => {
+  const { scaffoldEnv: scaffoldEnv2 } = await Promise.resolve().then(() => (init_scaffold(), scaffold_exports));
+  await scaffoldEnv2(options);
+});
+scaffold.command("xwalk").description("Write xwalk.json enabling Universal Editor multi-field support").action(async () => {
+  const { scaffoldXwalk: scaffoldXwalk2 } = await Promise.resolve().then(() => (init_scaffold(), scaffold_exports));
+  await scaffoldXwalk2();
+});
 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);