@reddoorla/maintenance 0.69.0 → 0.72.0

package/dist/blux-FKZYMKLF.js

@@ -0,0 +1,2205 @@
+import {
+  collectAssetUrls
+} from "./chunk-SL24DCGC.js";
+
+// src/cli/commands/blux.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join, dirname } from "path";
+import { glob } from "tinyglobby";
+
+// src/blux/parse.ts
+var hasDisable = (cls) => typeof cls === "string" && cls.split(/\s+/).includes("disable");
+function visibleText(text, style) {
+  const s = typeof text === "number" && Number.isFinite(text) ? String(text) : text;
+  if (typeof s !== "string" || s.trim() === "") return void 0;
+  if (hasDisable(style)) return void 0;
+  if (typeof style === "object" && style !== null && hasDisable(style.class)) return void 0;
+  return s.trim();
+}
+function asObject(v) {
+  if (!v || typeof v !== "object" || Array.isArray(v)) {
+    throw new Error("Invalid site.json: expected an object");
+  }
+  return v;
+}
+function parseBluxSite(input) {
+  const j = asObject(input);
+  const content = j.content ?? {};
+  const styles = j.styles ?? {};
+  const nav = j.navigation?.[0]?.items ?? [];
+  return {
+    meta: {
+      name: String(j.name ?? ""),
+      domain: String(j.domain ?? ""),
+      bluxSiteId: String(j.id ?? "")
+    },
+    pages: Array.isArray(content.pages) ? content.pages : [],
+    feeds: j.feeds ?? {},
+    media: j.media ?? {},
+    styles,
+    nav,
+    settings: j.settings ?? {}
+  };
+}
+
+// src/blux/archetype.ts
+var nonEmpty = (v) => v != null && v !== "" && !(Array.isArray(v) && v.length === 0) && !(typeof v === "object" && !Array.isArray(v) && Object.keys(v).length === 0);
+function archetype(b) {
+  const heading = visibleText(b.title, b._title) !== void 0;
+  const text = visibleText(b.body, b._body) !== void 0;
+  const media = nonEmpty(b.media?.media);
+  const bg = nonEmpty(b.backgroundMedia?.media);
+  const kids = Array.isArray(b.items) && b.items.length > 0;
+  const cls = nonEmpty(b.class) ? String(b.class) : null;
+  if (kids && cls === "slides")
+    return { sliceType: "slider", variation: "default", confidence: 0.85 };
+  if (bg)
+    return { sliceType: "hero", variation: "default", confidence: heading || text ? 0.9 : 0.7 };
+  if (kids)
+    return { sliceType: "grid", variation: "default", confidence: cls === "grid" ? 0.9 : 0.7 };
+  if (media && heading && text)
+    return { sliceType: "media_text", variation: "imageRight", confidence: 0.9 };
+  if (media && (heading || text))
+    return { sliceType: "media_text", variation: "imageRight", confidence: 0.75 };
+  if (media) return { sliceType: "media_text", variation: "imageRight", confidence: 0.6 };
+  if (heading && text) return { sliceType: "rich_text", variation: "default", confidence: 0.85 };
+  if (heading || text) return { sliceType: "rich_text", variation: "default", confidence: 0.6 };
+  return { sliceType: "rich_text", variation: "default", confidence: 0.2 };
+}
+
+// src/blux/normalize.ts
+function textRole(style) {
+  const cls = typeof style === "object" && style !== null ? style.class : style;
+  if (typeof cls !== "string") return void 0;
+  return cls.split(/\s+/).find((c) => /^text\d+$/.test(c));
+}
+var str = (x) => typeof x === "string" ? x : typeof x === "number" ? String(x) : "";
+function cleanCssValue(x) {
+  const s = str(x).trim();
+  if (s === "" || s === "px") return "";
+  if (!/\s/.test(s) && /px$/.test(s) && !/^-?(\d+(\.\d+)?|\.\d+)px$/.test(s)) return "";
+  return s;
+}
+function inlineStyle(style) {
+  if (typeof style !== "object" || style === null) return void 0;
+  const out = {};
+  for (const [k, v] of Object.entries(style)) {
+    if (k === "class") continue;
+    const cleaned = cleanCssValue(v);
+    if (cleaned) out[k] = cleaned;
+  }
+  return Object.keys(out).length ? out : void 0;
+}
+function parseGoogleFonts(google) {
+  if (!google.trim()) return [];
+  return google.split("|").map((spec) => {
+    const [rawFamily = "", rawWeights = ""] = spec.split(":");
+    const family = rawFamily.replace(/\+/g, " ").trim();
+    const weights = rawWeights.split(",").map((w) => w.trim()).filter(Boolean).map((w) => w === "regular" ? "400" : w);
+    return { family, weights: weights.length ? weights : ["400"] };
+  }).filter((f) => f.family);
+}
+function fontFamilyFromStyle(m) {
+  const ident = str(m["font-ident"]);
+  if (ident.startsWith("T:")) {
+    const fam = ident.split(":")[1]?.trim();
+    if (fam) return fam;
+  }
+  return str(m["font-family"]).replace(/['"]/g, "");
+}
+function typekitFontLoads(fontString) {
+  const byFamily = /* @__PURE__ */ new Map();
+  for (const ident of fontString.split(",").map((s) => s.trim())) {
+    if (!ident.startsWith("T:")) continue;
+    const [, family = "", variant = ""] = ident.split(":");
+    const fam = family.trim();
+    if (!fam) continue;
+    const v = variant.trim();
+    const digit = /^[ni](\d)$/.exec(v);
+    const weight = digit ? `${Number(digit[1]) * 100}` : v === "regular" ? "400" : v;
+    if (!weight) continue;
+    const ws = byFamily.get(fam) ?? [];
+    if (!ws.includes(weight)) ws.push(weight);
+    byFamily.set(fam, ws);
+  }
+  return [...byFamily].map(([family, weights]) => ({ family, weights }));
+}
+function mergeFontLoads(base2, extra) {
+  const out = base2.map((f) => ({ family: f.family, weights: [...f.weights] }));
+  for (const e of extra) {
+    const existing = out.find((f) => f.family === e.family);
+    if (existing) {
+      for (const w of e.weights) if (!existing.weights.includes(w)) existing.weights.push(w);
+    } else {
+      out.push({ family: e.family, weights: [...e.weights] });
+    }
+  }
+  return out;
+}
+var CONFIDENCE_MIN = 0.5;
+function sectionFromBlock(b, pageUid, diagnostics) {
+  const a = archetype(b);
+  if (a.confidence < CONFIDENCE_MIN) {
+    diagnostics.push({
+      kind: "low-confidence-block",
+      where: pageUid,
+      message: `block mapped to ${a.sliceType} at ${a.confidence}`
+    });
+  }
+  const heading = visibleText(b.title, b._title);
+  const body = visibleText(b.body, b._body);
+  const headingRole = heading !== void 0 ? textRole(b._title) : void 0;
+  const bodyRole = body !== void 0 ? textRole(b._body) : void 0;
+  const headingStyle = heading !== void 0 ? inlineStyle(b._title) : void 0;
+  const bodyStyle = body !== void 0 ? inlineStyle(b._body) : void 0;
+  const block = {};
+  for (const [k, v] of Object.entries(b.styles ?? {})) {
+    const cleaned = cleanCssValue(v);
+    if (cleaned) block[k] = cleaned;
+  }
+  const presentation = {
+    ...headingRole ? { headingRole } : {},
+    ...bodyRole ? { bodyRole } : {},
+    ...headingStyle ? { headingStyle } : {},
+    ...bodyStyle ? { bodyStyle } : {},
+    ...Object.keys(block).length ? { block } : {}
+  };
+  const section = {
+    sliceType: a.sliceType,
+    variation: a.variation,
+    confidence: a.confidence,
+    fields: {
+      ...heading !== void 0 ? { heading } : {},
+      ...body !== void 0 ? { body } : {},
+      ...b.media?.media ? { media: b.media.media } : {},
+      ...b.backgroundMedia?.media ? { backgroundMedia: b.backgroundMedia.media } : {},
+      ...b.ratio ? { ratio: String(b.ratio) } : {},
+      ...b.loadEffect ? { anim: String(b.loadEffect) } : {}
+    },
+    ...Object.keys(presentation).length ? { presentation } : {}
+  };
+  if (Array.isArray(b.items) && b.items.length > 0) {
+    section.children = b.items.map((child) => sectionFromBlock(child, pageUid, diagnostics));
+  }
+  return section;
+}
+function slugify(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "page";
+}
+function normalizePages(raw) {
+  const diagnostics = [];
+  const pages = raw.pages.map((p) => {
+    const uid = slugify(String(p.title ?? ""));
+    return {
+      uid,
+      title: String(p.title ?? ""),
+      description: String(p.description ?? ""),
+      sections: (p.items ?? []).map((b) => sectionFromBlock(b, uid, diagnostics))
+    };
+  });
+  return { pages, diagnostics };
+}
+function normalizeTheme(raw) {
+  const colors = Object.entries(raw.styles.colors ?? {}).map(([role, value]) => ({
+    role,
+    value: String(value)
+  }));
+  const textStyles = [];
+  for (const v of Object.values(raw.styles.text ?? {})) {
+    const entry = v ?? {};
+    const innerKey = Object.keys(entry).find((k) => /^\.text\d+$/.test(k));
+    if (!innerKey) continue;
+    const m = entry[innerKey] ?? {};
+    const transform = cleanCssValue(m["text-transform"]);
+    const tracking = cleanCssValue(m["letter-spacing"]);
+    const mobileSize = cleanCssValue(m["__media_mobile_font-size"]);
+    const mobileLineHeight = cleanCssValue(m["__media_mobile_line-height"]);
+    textStyles.push({
+      role: innerKey.slice(1),
+      // ".text11" -> "text11"
+      label: str(entry._label),
+      fontFamily: fontFamilyFromStyle(m),
+      size: cleanCssValue(m["font-size"]) || "16px",
+      weight: typeof m["font-weight"] === "number" ? m["font-weight"] : str(m["font-weight"]) || 400,
+      lineHeight: cleanCssValue(m["line-height"]) || "1.5",
+      ...transform && transform !== "none" ? { transform } : {},
+      ...tracking ? { letterSpacing: tracking } : {},
+      ...mobileSize ? { mobileSize } : {},
+      ...mobileLineHeight ? { mobileLineHeight } : {}
+    });
+  }
+  const fonts = raw.settings.fonts ?? {};
+  const roleFont = (r) => textStyles.find((t) => t.role === r)?.fontFamily ?? "";
+  return {
+    colors,
+    fonts: {
+      heading: str(fonts.heading) || roleFont("text0"),
+      body: str(fonts.body) || roleFont("text1")
+    },
+    fontLoad: mergeFontLoads(
+      parseGoogleFonts(str(fonts.google)),
+      typekitFontLoads(str(fonts.string))
+    ),
+    textStyles
+  };
+}
+
+// src/blux/collections.ts
+function singularSlug(name) {
+  const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+  return slug.replace(/s$/, "") || "item";
+}
+var RICHTEXT_KEYS = /* @__PURE__ */ new Set(["body", "description"]);
+function fieldType(key, value) {
+  if (RICHTEXT_KEYS.has(key)) return "richtext";
+  if (value && typeof value === "object" && "media" in value) return "image";
+  if (Array.isArray(value)) return "group";
+  if (typeof value === "boolean") return "boolean";
+  if (typeof value === "number") return "number";
+  if (key === "date") return "date";
+  if (/^(url|link)/.test(key)) return "link";
+  return "text";
+}
+var isStyleKey = (key) => key.startsWith("_");
+function deriveFields(feed) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const d of feed.fields ?? []) {
+    if (d.field) seen.set(d.field, "text");
+  }
+  for (const item of feed.items ?? []) {
+    for (const [key, value] of Object.entries(item)) {
+      if (isStyleKey(key)) continue;
+      if (!seen.has(key) || seen.get(key) === "text") seen.set(key, fieldType(key, value));
+    }
+  }
+  return [...seen.entries()].map(([key, type]) => ({ key, type }));
+}
+function recordUid(values, i) {
+  const title = typeof values.title === "string" ? values.title : "";
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return slug || `item-${i}`;
+}
+function modelCollections(raw) {
+  const out = [];
+  for (const feed of Object.values(raw.feeds)) {
+    const label = String(feed.name ?? "");
+    const items = feed.items ?? [];
+    const records = items.map((item, i) => {
+      const mediaRefs = [];
+      for (const value of Object.values(item)) {
+        if (value && typeof value === "object" && typeof value.media === "string") {
+          mediaRefs.push(value.media);
+        }
+      }
+      const values = Object.fromEntries(Object.entries(item).filter(([key]) => !isStyleKey(key)));
+      return { uid: recordUid(item, i), values, mediaRefs };
+    });
+    out.push({
+      apiId: singularSlug(label),
+      label,
+      publishRoute: feed.publish ? String(feed.publish) : null,
+      fields: deriveFields(feed),
+      records
+    });
+  }
+  return out;
+}
+
+// src/blux/assemble.ts
+function assembleIR(input) {
+  const raw = parseBluxSite(input.siteJson);
+  const { pages, diagnostics: pageDiags } = normalizePages(raw);
+  const theme = normalizeTheme(raw);
+  const collections = modelCollections(raw);
+  const urlMap = collectAssetUrls(input.htmls);
+  const diagnostics = [...pageDiags];
+  const assets = Object.entries(raw.media).map(([id, m]) => {
+    const sourceUrl = urlMap.get(id) ?? null;
+    if (!sourceUrl) {
+      diagnostics.push({
+        kind: "unresolved-asset",
+        where: id,
+        message: `no CDN url for ${m.name ?? id}`
+      });
+    }
+    return {
+      id,
+      sourceUrl,
+      name: String(m.name ?? ""),
+      mime: String(m.type ?? ""),
+      alt: String(m.name ?? "")
+    };
+  });
+  return {
+    meta: raw.meta,
+    theme,
+    pages,
+    collections,
+    assets,
+    diagnostics
+  };
+}
+
+// src/blux/emit/plan.ts
+var richText = (html) => ({ __richtext_html: html });
+var assetRef = (id) => ({ __asset_id: id });
+
+// src/blux/emit/custom-types.ts
+var FIELD_CONFIG = {
+  text: () => ({ type: "Text", config: {} }),
+  richtext: () => ({
+    type: "StructuredText",
+    config: { multi: "paragraph,strong,em,hyperlink,list-item,o-list-item" }
+  }),
+  image: () => ({ type: "Image", config: { constraint: {}, thumbnails: [] } }),
+  group: () => ({ type: "Group", config: { fields: { value: { type: "Text", config: {} } } } }),
+  date: () => ({ type: "Date", config: {} }),
+  boolean: () => ({ type: "Boolean", config: {} }),
+  number: () => ({ type: "Number", config: {} }),
+  link: () => ({ type: "Link", config: { allowTargetBlank: true } })
+};
+function buildCustomType(c) {
+  const Main = {};
+  for (const f of c.fields) {
+    const spec = FIELD_CONFIG[f.type]();
+    Main[f.key] = { ...spec, config: { ...spec.config, label: f.key } };
+  }
+  return {
+    id: c.apiId,
+    label: c.label,
+    repeatable: true,
+    json: { id: c.apiId, label: c.label, repeatable: true, status: true, json: { Main } }
+  };
+}
+
+// src/blux/emit/coerce-html.ts
+var BLOCK_RE = /<(h[1-6]|p|div)(\s[^>]*)?>[\s\S]*?<\/\1>/i;
+function coerceHeadingHtml(html, allowed) {
+  const m = html.match(BLOCK_RE);
+  const block = m ? m[0] : html;
+  const tagMatch = block.match(/^<(h[1-6]|p|div)(\s[^>]*)?>/i);
+  const tag = tagMatch?.[1]?.toLowerCase();
+  if (tag && allowed.includes(tag)) return block;
+  const levels = allowed.filter((t) => /^h[1-6]$/.test(t)).map((t) => Number(t[1]));
+  const target = tag && tag.startsWith("h") ? `h${levels.reduce((b, l) => Math.abs(l - Number(tag[1])) < Math.abs(b - Number(tag[1])) ? l : b)}` : `h${Math.max(...levels)}`;
+  if (!tag) return `<${target}>${block}</${target}>`;
+  return block.replace(new RegExp(`^<${tag}`, "i"), `<${target}`).replace(new RegExp(`</${tag}>$`, "i"), `</${target}>`);
+}
+function demoteHeadingsHtml(html) {
+  return html.replace(/<(\/?)h[1-6](\s[^>]*)?>/gi, "<$1p$2>");
+}
+
+// src/blux/emit/slices.ts
+var HEADING_TAGS = {
+  hero: ["h1", "h2"],
+  media_text: ["h2", "h3"],
+  section_grid: ["h2", "h3"],
+  section_grid_item: ["h3", "h4"]
+};
+function rt(html) {
+  return html ? richText(html) : void 0;
+}
+function rtHeading(html, slot) {
+  return html ? richText(coerceHeadingHtml(html, HEADING_TAGS[slot])) : void 0;
+}
+function rtBody(html) {
+  return html ? richText(demoteHeadingsHtml(html)) : void 0;
+}
+function img(id) {
+  return id ? assetRef(id) : void 0;
+}
+function compact(o) {
+  return Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0));
+}
+function sectionToSlice(s) {
+  const f = s.fields;
+  switch (s.sliceType) {
+    case "hero":
+      return {
+        slice_type: "hero",
+        variation: "default",
+        primary: compact({
+          heading: rtHeading(f.heading, "hero"),
+          body: rtBody(f.body),
+          background_image: img(f.backgroundMedia ?? f.media)
+        }),
+        items: []
+      };
+    case "media_text":
+      return {
+        slice_type: "media_text",
+        variation: s.variation === "imageLeft" ? "imageLeft" : "imageRight",
+        primary: compact({
+          heading: rtHeading(f.heading, "media_text"),
+          body: rtBody(f.body),
+          media: img(f.media)
+        }),
+        items: []
+      };
+    case "collection_list":
+      return {
+        slice_type: "collection_list",
+        variation: s.variation === "list" ? "list" : "grid",
+        primary: compact({
+          heading: rtHeading(f.heading, "section_grid"),
+          collection_type: s.collectionRef?.apiId ?? "",
+          max_items: 24
+        }),
+        items: []
+      };
+    case "grid":
+    case "slider":
+      return {
+        slice_type: "section_grid",
+        variation: "default",
+        primary: compact({
+          heading: rtHeading(f.heading, "section_grid"),
+          columns: f.columns ?? 3
+        }),
+        items: (s.children ?? []).map(
+          (c) => compact({
+            item_heading: rtHeading(c.fields.heading, "section_grid_item"),
+            item_body: rtBody(c.fields.body),
+            item_media: img(c.fields.media)
+          })
+        ).filter((item) => Object.keys(item).length > 0)
+      };
+    case "rich_text":
+    default:
+      return {
+        slice_type: "rich_text",
+        variation: "default",
+        primary: compact({ content: rt(f.heading ? `${f.heading}${f.body ?? ""}` : f.body) }),
+        items: []
+      };
+  }
+}
+
+// src/blux/emit/flatten.ts
+var isContainer = (s) => s.sliceType === "grid" || s.sliceType === "slider";
+var isFlatLeaf = (s) => (s.sliceType === "media_text" || s.sliceType === "rich_text") && !(s.children ?? []).length;
+function flattenSections(sections) {
+  const out = [];
+  for (const s of sections) {
+    const children = s.children ?? [];
+    if (s.sliceType === "hero" && s.fields.media && s.fields.backgroundMedia) {
+      const { media, ...heroFields } = s.fields;
+      const { children: _heroKids, ...heroSelf } = s;
+      out.push({ ...heroSelf, fields: heroFields });
+      out.push({
+        sliceType: "media_text",
+        variation: "imageRight",
+        confidence: s.confidence,
+        fields: { media }
+      });
+      out.push(...flattenSections(children));
+      continue;
+    }
+    const keepable = isContainer(s) && !s.fields.media && !s.fields.body;
+    if (!children.length) {
+      if (isContainer(s) && !keepable) {
+        out.push({ ...s, sliceType: s.fields.media ? "media_text" : "rich_text" });
+      } else {
+        out.push(s);
+      }
+    } else if (keepable && children.every(isFlatLeaf)) {
+      out.push(s);
+    } else if (isContainer(s)) {
+      const { children: _kids, ...self } = s;
+      if (self.fields.media) {
+        out.push({ ...self, sliceType: "media_text" });
+      } else if (self.fields.heading || self.fields.body) {
+        out.push({ ...self, sliceType: "rich_text" });
+      }
+      out.push(...flattenSections(children));
+    } else {
+      const { children: _hoisted, ...self } = s;
+      out.push(self);
+      out.push(...flattenSections(children));
+    }
+  }
+  return out;
+}
+
+// src/blux/emit/migration-plan.ts
+var IMAGE_FIELDS = /* @__PURE__ */ new Set(["background_image", "media", "item_media"]);
+var RICHTEXT = /* @__PURE__ */ new Set(["body", "description"]);
+function isEmptyPage(p) {
+  return !p.sections.length && !p.title.trim();
+}
+var NON_IMAGE_EXT = /\.(mp4|mov|webm|avi|mp3|wav|pdf|zip)$/i;
+function isImageAsset(a) {
+  if (!a) return true;
+  if (a.mime) return a.mime.startsWith("image/");
+  return !NON_IMAGE_EXT.test(a.name);
+}
+function recordData(rec) {
+  const data = {};
+  for (const [key, value] of Object.entries(rec.values)) {
+    if (value && typeof value === "object" && typeof value.media === "string") {
+      data[key] = assetRef(value.media);
+    } else if (RICHTEXT.has(key) && typeof value === "string") {
+      data[key] = richText(demoteHeadingsHtml(value));
+    } else {
+      data[key] = value;
+    }
+  }
+  return data;
+}
+function buildMigrationPlan(ir) {
+  const diagnostics = [];
+  const customTypes = ir.collections.map(buildCustomType);
+  const assetById = new Map(ir.assets.map((a) => [a.id, a]));
+  const dropNonImages = (rec, keys, where) => {
+    for (const [key, val] of Object.entries(rec)) {
+      if (keys && !keys.has(key) || !val || typeof val !== "object" || !("__asset_id" in val))
+        continue;
+      const asset = assetById.get(val.__asset_id);
+      if (!isImageAsset(asset)) {
+        diagnostics.push({
+          kind: "non-image-in-image-field",
+          where: `${where}.${key}`,
+          message: `${asset?.mime || "unknown mime"} asset dropped from image field`
+        });
+        delete rec[key];
+      }
+    }
+  };
+  const documents = [];
+  const stylesManifest = [];
+  for (const page of ir.pages) {
+    if (isEmptyPage(page)) {
+      diagnostics.push({
+        kind: "empty-page",
+        where: page.uid,
+        message: "page has no title and no sections; skipped"
+      });
+      continue;
+    }
+    const slices = [];
+    const styleEntries = [];
+    for (const section of flattenSections(page.sections)) {
+      const slice = sectionToSlice(section);
+      for (const rec of [slice.primary, ...slice.items]) {
+        dropNonImages(rec, IMAGE_FIELDS, `${page.uid}/${slice.slice_type}`);
+      }
+      const STRUCTURAL = /* @__PURE__ */ new Set(["columns", "collection_type", "max_items"]);
+      const hasContent = Object.keys(slice.primary).some((k) => !STRUCTURAL.has(k)) || slice.items.length > 0;
+      if (!hasContent) {
+        diagnostics.push({
+          kind: "empty-slice",
+          where: `${page.uid}/${slice.slice_type}`,
+          message: "slice has no content after filtering; dropped"
+        });
+        continue;
+      }
+      const itemPresentations = (section.children ?? []).filter((c) => c.fields.heading || c.fields.body || c.fields.media).map((c) => c.presentation ?? null);
+      const entry = {
+        index: slices.length,
+        sliceType: slice.slice_type,
+        ...section.presentation ? { presentation: section.presentation } : {},
+        ...slice.slice_type === "section_grid" && itemPresentations.some(Boolean) ? { items: itemPresentations } : {}
+      };
+      if (entry.presentation || entry.items) styleEntries.push(entry);
+      slices.push(slice);
+    }
+    stylesManifest.push({ pageUid: page.uid, slices: styleEntries });
+    documents.push({
+      type: "page",
+      uid: page.uid,
+      // the page type's title is StructuredText(single heading1)
+      data: {
+        title: richText(coerceHeadingHtml(page.title || page.uid, ["h1"])),
+        slices
+      }
+    });
+  }
+  for (const c of ir.collections) {
+    for (const rec of c.records) {
+      const data = recordData(rec);
+      dropNonImages(data, null, `${c.apiId}/${rec.uid}`);
+      documents.push({ type: c.apiId, uid: rec.uid, data });
+    }
+  }
+  const assets = ir.assets.filter((a) => a.sourceUrl !== null).map((a) => ({ id: a.id, url: a.sourceUrl, alt: a.alt }));
+  return { customTypes, documents, assets, stylesManifest, diagnostics };
+}
+
+// src/blux/emit/theme.ts
+function emitThemeCss(theme) {
+  const lines = [];
+  if (theme.fontLoad.length) {
+    const spec = theme.fontLoad.map((f) => `${f.family} ${f.weights.join(",")}`).join("; ");
+    lines.push(`/* Fonts to load \u2014 ${spec} */`);
+  }
+  lines.push("@theme {");
+  for (const c of theme.colors) lines.push(`  --color-${c.role}: ${c.value};`);
+  lines.push(`  --font-heading: ${theme.fonts.heading || "sans-serif"};`);
+  lines.push(`  --font-body: ${theme.fonts.body || "sans-serif"};`);
+  for (const t of theme.textStyles) {
+    if (t.label) lines.push(`  /* ${t.role} \u2014 ${t.label} */`);
+    lines.push(`  --text-${t.role}: ${t.size};`);
+    lines.push(`  --text-${t.role}--line-height: ${t.lineHeight};`);
+    lines.push(`  --text-${t.role}--font-weight: ${t.weight};`);
+    if (t.fontFamily) lines.push(`  --text-${t.role}--font-family: ${t.fontFamily};`);
+    if (t.transform) lines.push(`  --text-${t.role}--text-transform: ${t.transform};`);
+    if (t.letterSpacing) lines.push(`  --text-${t.role}--letter-spacing: ${t.letterSpacing};`);
+    if (t.mobileSize) lines.push(`  --text-${t.role}--mobile-font-size: ${t.mobileSize};`);
+    if (t.mobileLineHeight)
+      lines.push(`  --text-${t.role}--mobile-line-height: ${t.mobileLineHeight};`);
+  }
+  lines.push("}");
+  return lines.join("\n") + "\n";
+}
+function emitRolesCss(theme) {
+  if (!theme.textStyles.length) return "";
+  const lines = [
+    "/* Role utilities \u2014 one .txt-role-textN per Blux text style, mapping its",
+    "   @theme vars onto the heading/paragraph it wraps. Generated by blux emit. */"
+  ];
+  for (const t of theme.textStyles) {
+    const r = t.role;
+    lines.push(`.txt-role-${r} :is(h1, h2, h3, h4, h5, h6, p) {`);
+    if (t.fontFamily) lines.push(`  font-family: var(--text-${r}--font-family);`);
+    lines.push(
+      `  font-size: var(--text-${r});`,
+      `  font-weight: var(--text-${r}--font-weight);`,
+      `  line-height: var(--text-${r}--line-height);`,
+      `  letter-spacing: var(--text-${r}--letter-spacing, normal);`,
+      `  text-transform: var(--text-${r}--text-transform, none);`,
+      `  margin: 0;`,
+      `}`
+    );
+  }
+  return lines.join("\n") + "\n";
+}
+
+// src/blux/emit/review.ts
+function buildReviewManifest(ir, opts) {
+  const pairs = ir.pages.filter((p) => !isEmptyPage(p)).map((p) => ({
+    uid: p.uid,
+    converted: `${opts.convertedBase}/${p.uid}`,
+    // The home page maps to the site root; other pages to /uid.
+    original: p.uid === "home" ? `${opts.bluxBase}/` : `${opts.bluxBase}/${p.uid}`
+  }));
+  return { pairs, diagnostics: ir.diagnostics };
+}
+
+// src/blux/validate.ts
+var DROP_ELEMENTS = /<(script|style|head|noscript|svg|template)[\s\S]*?<\/\1>/gi;
+var COMMENTS = /<!--[\s\S]*?-->/g;
+function decodeEntities(s) {
+  return s.replace(/&#(\d+);/g, (_, n) => codePoint(Number(n))).replace(/&#x([0-9a-f]+);/gi, (_, h) => codePoint(parseInt(h, 16))).replace(/&nbsp;/gi, " ").replace(/&(?:amp);/gi, "&").replace(/&(?:lt);/gi, "<").replace(/&(?:gt);/gi, ">").replace(/&(?:quot);/gi, '"').replace(/&(?:apos|#39);/gi, "'").replace(/&[a-z][a-z0-9]*;/gi, " ");
+}
+function codePoint(n) {
+  try {
+    return String.fromCodePoint(n);
+  } catch {
+    return " ";
+  }
+}
+function normalizeText(s) {
+  return decodeEntities(s).toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+function hasWord(run) {
+  return /[a-z0-9]{3,}/.test(run);
+}
+function flattenText(html) {
+  const text = html.replace(DROP_ELEMENTS, " ").replace(COMMENTS, " ").replace(/<[^>]+>/g, " ");
+  return normalizeText(text);
+}
+function extractTextRuns(html) {
+  const stripped = html.replace(DROP_ELEMENTS, " ").replace(COMMENTS, " ");
+  const seen = /* @__PURE__ */ new Set();
+  for (const piece of stripped.split(/<[^>]+>/)) {
+    const run = normalizeText(piece);
+    if (hasWord(run)) seen.add(run);
+  }
+  return [...seen];
+}
+function validateCoverage(exportHtml, renderedHtml) {
+  const runs = extractTextRuns(exportHtml);
+  const blob = ` ${flattenText(renderedHtml)} `;
+  const missing = runs.filter((run) => !blob.includes(` ${run} `));
+  const covered = runs.length - missing.length;
+  const coveragePct = runs.length === 0 ? 100 : Math.round(covered / runs.length * 100);
+  return { total: runs.length, covered, missing, coveragePct };
+}
+
+// src/blux/grid/parse-grid.ts
+import { parse as parse2 } from "node-html-parser";
+
+// src/blux/grid/token.ts
+var TOKEN_RE = /\bgrid-(\d+|any)(?:-(r|s)(\d+))?\b/;
+function parseGridToken(className) {
+  const m = TOKEN_RE.exec(className);
+  if (!m) return null;
+  const cols = m[1] === "any" ? "any" : Number(m[1]);
+  const token = { cols, raw: m[0] };
+  if (m[2] === "r") token.ratio = Number(m[3]);
+  if (m[2] === "s") token.spacing = Number(m[3]);
+  return token;
+}
+
+// src/blux/grid/leaf.ts
+import { parse } from "node-html-parser";
+var ROLE_RE = /\btext\d+\b/;
+function textRoleFromClass(className) {
+  return ROLE_RE.exec(className)?.[0];
+}
+function headingLevel(el) {
+  const m = /^H([1-6])$/.exec(el.tagName ?? "");
+  return m ? Number(m[1]) : 2;
+}
+function blockPlainText(html) {
+  const BR = "\uE000";
+  const text = parse(html.replace(/<br\b[^>]*>/gi, BR)).text;
+  return text.replace(/\s+/g, " ").replace(/ *\uE000 */g, "\n").trim();
+}
+function uuidFromUrl(url) {
+  const base2 = url.split(/[?#]/)[0] ?? "";
+  const file = base2.split("/").pop() ?? "";
+  const dot = file.lastIndexOf(".");
+  return dot > 0 ? { id: file.slice(0, dot), ext: file.slice(dot + 1) } : { id: file };
+}
+function stripAssetExt(rawId, ext) {
+  return ext && rawId.endsWith(`.${ext}`) ? rawId.slice(0, -(ext.length + 1)) : rawId;
+}
+function cssProp(style, prop) {
+  const m = new RegExp(`(?:^|;|\\s)${prop}\\s*:\\s*([^;]+)`, "i").exec(style);
+  return m?.[1]?.trim();
+}
+var CENTERED = /* @__PURE__ */ new Set(["center", "center center", "50% 50%", "50%"]);
+function readBgSizing(el) {
+  const style = el.getAttribute("style") ?? "";
+  const out = {};
+  const size = cssProp(style, "background-size")?.toLowerCase();
+  if (size === "auto" || size === "contain") out.fit = size;
+  const pos = cssProp(style, "background-position");
+  if (pos && !CENTERED.has(pos.toLowerCase())) out.position = pos;
+  return out;
+}
+function readImgSizing(holder) {
+  const style = holder.getAttribute("style") ?? "";
+  const out = {};
+  const w = cssProp(style, "width");
+  const wpx = w ? /^(\d+(?:\.\d+)?)px$/i.exec(w) : null;
+  if (wpx?.[1]) out.width = Math.round(parseFloat(wpx[1]));
+  const ogr = holder.querySelector(".mediaRatio")?.getAttribute("data-og-ratio");
+  if (ogr) {
+    const n = Number(ogr);
+    if (Number.isFinite(n)) out.aspect = Math.round(n * 1e3) / 1e3;
+  }
+  const fit = cssProp(style, "background-size")?.toLowerCase();
+  if (fit === "contain" || fit === "cover") out.fit = fit;
+  const mh = cssProp(style, "min-height");
+  if (mh) out.minHeight = mh;
+  return out;
+}
+function readVideoPlayback(video) {
+  const flags = ["controls", "playsinline", "autoplay", "loop", "muted"];
+  const pb = {};
+  for (const f of flags) if (video.hasAttribute(f)) pb[f] = true;
+  return Object.keys(pb).length ? pb : void 0;
+}
+function readVideoAspect(video) {
+  let raw;
+  let anc = video.parentNode;
+  for (let i = 0; i < 3 && anc && !raw; i++) {
+    raw = anc.getAttribute?.("data-og-ratio") ?? void 0;
+    if (!raw) {
+      const mr = anc.querySelector?.(".mediaRatio");
+      raw = mr ? cssProp(mr.getAttribute("style") ?? "", "padding-bottom") : void 0;
+    }
+    anc = anc.parentNode;
+  }
+  if (!raw) return void 0;
+  const n = parseFloat(raw.replace(/%\s*$/, ""));
+  return Number.isFinite(n) ? Math.round(n * 1e3) / 1e3 : void 0;
+}
+function mediaFromElement(el) {
+  if (el.tagName === "VIDEO") {
+    const src = el.getAttribute("src") ?? "";
+    const { id, ext } = uuidFromUrl(src);
+    if (!id) return null;
+    const clean = src.split(/[?#]/)[0] ?? "";
+    const slash = clean.lastIndexOf("/");
+    const base2 = slash >= 0 ? clean.slice(0, slash + 1) : void 0;
+    const aspect = readVideoAspect(el);
+    const playback = readVideoPlayback(el);
+    return {
+      kind: "video",
+      assetId: id,
+      ...ext ? { ext } : {},
+      ...base2 ? { base: base2 } : {},
+      ...aspect !== void 0 ? { aspect } : {},
+      ...playback ? { playback } : {}
+    };
+  }
+  const img2 = el.classList.contains("camediaload") && el.getAttribute("data-media") ? el : el.querySelector(".camediaload[data-media]");
+  if (img2) {
+    const rawId = img2.getAttribute("data-media");
+    if (rawId) {
+      const ext = img2.getAttribute("data-ext") ?? void 0;
+      const base2 = img2.getAttribute("data-base") ?? void 0;
+      return {
+        kind: "image",
+        assetId: stripAssetExt(rawId, ext),
+        ...ext ? { ext } : {},
+        ...base2 ? { base: base2 } : {},
+        ...readImgSizing(img2)
+      };
+    }
+  }
+  const video = el.querySelector("video");
+  if (video) return mediaFromElement(video);
+  return null;
+}
+
+// src/blux/grid/parse-grid.ts
+var DEFAULT_TOKEN = { cols: 1, raw: "grid-1" };
+var isElement = (n) => n.tagName !== void 0 && n.tagName !== null;
+var hasClass = (el, c) => el.classNames.split(/\s+/).includes(c);
+var isMediaHolder = (el) => hasClass(el, "block-media-holder") || hasClass(el, "camediaload") && !!el.getAttribute("data-media") || el.tagName === "VIDEO";
+var isLeafElement = (el) => hasClass(el, "block-title") || hasClass(el, "block-body") || hasClass(el, "block-subtitle") || isMediaHolder(el);
+var isLeafAnchor = (el) => el.tagName === "A" && collectStructuralChildren(el).length === 0;
+var isStructural = (el) => isLeafElement(el) || el.hasAttribute("data-exec") || // Blux custom-code embed (e.g. map mount)
+hasClass(el, "cagrid") || isLeafAnchor(el) || parseGridToken(el.classNames) !== null;
+function collectStructuralChildren(el) {
+  const out = [];
+  for (const child of el.childNodes) {
+    if (!isElement(child)) continue;
+    if (isStructural(child)) out.push(child);
+    else out.push(...collectStructuralChildren(child));
+  }
+  return out;
+}
+function nodeHasText(n) {
+  if (n.kind === "heading" || n.kind === "body") return blockPlainText(n.html) !== "";
+  if (n.kind === "subtitle") return n.text.trim() !== "";
+  return false;
+}
+function isDisabledWithin(caption, holder) {
+  let a = caption;
+  while (a) {
+    if (hasClass(a, "disable")) return true;
+    if (a === holder) return false;
+    a = a.parentNode;
+  }
+  return false;
+}
+function parseNode(el) {
+  if (hasClass(el, "block-title") && /^H[1-6]$/.test(el.tagName ?? "")) {
+    const role = textRoleFromClass(el.classNames);
+    return {
+      kind: "heading",
+      ...role ? { role } : {},
+      level: headingLevel(el),
+      html: el.innerHTML
+    };
+  }
+  if (hasClass(el, "block-body")) {
+    const role = textRoleFromClass(el.classNames);
+    return { kind: "body", ...role ? { role } : {}, html: el.innerHTML };
+  }
+  if (hasClass(el, "block-subtitle")) {
+    const role = textRoleFromClass(el.classNames);
+    return { kind: "subtitle", ...role ? { role } : {}, text: blockPlainText(el.innerHTML) };
+  }
+  if (isMediaHolder(el)) {
+    const media = mediaFromElement(el);
+    if (media) {
+      const captions = el.querySelectorAll(".block-title, .block-body, .block-subtitle").filter((c) => !isDisabledWithin(c, el)).map((c) => parseNode(c)).filter(nodeHasText);
+      if (captions.length) {
+        return { kind: "stack", children: [{ kind: "media", media }, ...captions] };
+      }
+      return { kind: "media", media };
+    }
+  }
+  if (el.hasAttribute("data-exec")) {
+    return { kind: "raw", html: el.outerHTML };
+  }
+  if (el.tagName === "A") {
+    return { kind: "raw", html: el.outerHTML };
+  }
+  return parseContainer(el);
+}
+function parseContainer(el) {
+  const kids = collectStructuralChildren(el);
+  const parsed = kids.map((k) => ({ token: parseGridToken(k.classNames), node: parseNode(k) })).filter((p) => !(p.node.kind === "raw" && p.node.html.trim() === ""));
+  const isGrid = hasClass(el, "cagrid");
+  const tokenCount = parsed.filter((p) => p.token).length;
+  if ((isGrid || tokenCount >= 2) && parsed.length > 0) {
+    const cells = parsed.map((p) => ({ token: p.token ?? DEFAULT_TOKEN, node: p.node }));
+    if (hasClass(el, "caslider")) {
+      const cols = Number(el.getAttribute("data-columns"));
+      const slider = Number.isInteger(cols) && cols > 0 ? { columns: cols } : {};
+      return { kind: "row", cells, slider };
+    }
+    return { kind: "row", cells };
+  }
+  const [only] = parsed;
+  if (parsed.length === 1 && only) return only.node;
+  if (parsed.length === 0) return { kind: "raw", html: el.innerHTML };
+  return { kind: "stack", children: parsed.map((p) => p.node) };
+}
+var BAND_ID_RE = /^page-block-(\d+)$/;
+function bandBackground(el) {
+  if (!hasClass(el, "camediaload")) return void 0;
+  const rawId = el.getAttribute("data-media");
+  if (!rawId) return void 0;
+  const ext = el.getAttribute("data-ext") ?? void 0;
+  const base2 = el.getAttribute("data-base") ?? void 0;
+  return {
+    kind: "image",
+    assetId: stripAssetExt(rawId, ext),
+    ...ext ? { ext } : {},
+    ...base2 ? { base: base2 } : {},
+    // A band background carries its own render sizing (background-size/position);
+    // a corner-anchored `auto` accent must not be centered + full-bleed.
+    ...readBgSizing(el)
+  };
+}
+function parseGridBands(html) {
+  const root = parse2(html);
+  const content = root.querySelector("#page-content");
+  if (!content) return [];
+  const bands = [];
+  for (const child of content.childNodes) {
+    if (!isElement(child)) continue;
+    const m = BAND_ID_RE.exec(child.getAttribute("id") ?? "");
+    if (!m) continue;
+    const idStr = m[1];
+    if (idStr === void 0) continue;
+    const background = bandBackground(child);
+    bands.push({
+      index: Number(idStr),
+      ...background ? { background } : {},
+      root: parseContainer(child)
+    });
+  }
+  return bands;
+}
+
+// src/blux/grid/classify-band.ts
+function collectMedia(node) {
+  switch (node.kind) {
+    case "media":
+      return [node.media];
+    case "row":
+      return node.cells.flatMap((c) => collectMedia(c.node));
+    case "stack":
+      return node.children.flatMap(collectMedia);
+    case "heading":
+    case "body":
+    case "subtitle":
+    case "widget":
+    case "raw":
+      return [];
+  }
+}
+function collectText(node) {
+  switch (node.kind) {
+    case "heading":
+    case "body":
+    case "subtitle":
+      return [node];
+    case "row":
+      return node.cells.flatMap((c) => collectText(c.node));
+    case "stack":
+      return node.children.flatMap(collectText);
+    case "media":
+    case "widget":
+    case "raw":
+      return [];
+  }
+}
+function collectWidgets(node) {
+  switch (node.kind) {
+    case "widget":
+      return [node.widget];
+    case "row":
+      return node.cells.flatMap((c) => collectWidgets(c.node));
+    case "stack":
+      return node.children.flatMap(collectWidgets);
+    case "heading":
+    case "body":
+    case "subtitle":
+    case "media":
+    case "raw":
+      return [];
+  }
+}
+function collectRaws(node) {
+  switch (node.kind) {
+    case "raw":
+      return [node];
+    case "row":
+      return node.cells.flatMap((c) => collectRaws(c.node));
+    case "stack":
+      return node.children.flatMap(collectRaws);
+    case "heading":
+    case "body":
+    case "subtitle":
+    case "media":
+    case "widget":
+      return [];
+  }
+}
+function topRowNode(node) {
+  if (node.kind === "row") return node;
+  if (node.kind === "stack" && node.children.length === 1) {
+    const [only] = node.children;
+    if (only && only.kind === "row") return only;
+  }
+  return null;
+}
+function isEmptyRaw(node) {
+  if (node.kind !== "raw") return false;
+  const text = node.html.replace(/<[^>]*>/g, "").trim();
+  return text.length === 0;
+}
+function base(band) {
+  return { index: band.index, ...band.background ? { background: band.background } : {} };
+}
+function nodeText(node) {
+  switch (node.kind) {
+    case "heading":
+    case "body":
+      return blockPlainText(node.html);
+    case "subtitle":
+      return node.text.trim();
+    case "row":
+    case "stack":
+    case "media":
+    case "widget":
+    case "raw":
+      return "";
+  }
+}
+function pureCellMedia(cell) {
+  return cell.node.kind === "media" ? cell.node.media : null;
+}
+function textRoleMeta(heading, subtitle) {
+  return {
+    ...heading?.kind === "heading" && heading.role ? { headingRole: heading.role } : {},
+    ...heading?.kind === "heading" ? { headingLevel: heading.level } : {},
+    ...subtitle?.kind === "subtitle" && subtitle.role ? { subtitleRole: subtitle.role } : {}
+  };
+}
+function cellRatio(cell) {
+  const t = cell.token;
+  if (typeof t.ratio === "number") return t.ratio;
+  if (t.cols === "any") return 50;
+  return Math.round(100 / t.cols);
+}
+function carouselSlides(cells) {
+  const out = [];
+  for (const c of cells) {
+    const n = c.node;
+    if (n.kind === "media") {
+      out.push({ media: n.media });
+      continue;
+    }
+    if (n.kind === "stack" && n.children.length === 2) {
+      const [m, h] = n.children;
+      if (m?.kind === "media" && h?.kind === "heading") {
+        out.push({
+          media: m.media,
+          caption: { html: h.html, level: h.level, ...h.role ? { role: h.role } : {} }
+        });
+        continue;
+      }
+    }
+    return null;
+  }
+  return out.length >= 2 ? out : null;
+}
+function galleryMedia(cells) {
+  const out = [];
+  for (const c of cells) {
+    const m = pureCellMedia(c);
+    if (!m) return null;
+    out.push(m);
+  }
+  return out.length >= 2 ? out : null;
+}
+function rewriteMapMounts(node, isMapMount) {
+  if (isMapMount(node)) return { kind: "widget", widget: { type: "map" } };
+  switch (node.kind) {
+    case "row":
+      return {
+        kind: "row",
+        cells: node.cells.map((c) => ({
+          token: c.token,
+          node: rewriteMapMounts(c.node, isMapMount)
+        })),
+        // Keep the slider marker — dropping it here would silently demote a
+        // Carousel to Grid whenever a map config is present.
+        ...node.slider ? { slider: node.slider } : {}
+      };
+    case "stack":
+      return { kind: "stack", children: node.children.map((n) => rewriteMapMounts(n, isMapMount)) };
+    case "heading":
+    case "body":
+    case "subtitle":
+    case "media":
+    case "widget":
+    case "raw":
+      return node;
+  }
+}
+function soleSignificant(node) {
+  let kids;
+  switch (node.kind) {
+    case "row":
+      kids = node.cells.map((c) => c.node);
+      break;
+    case "stack":
+      kids = node.children;
+      break;
+    case "heading":
+    case "body":
+    case "subtitle":
+    case "media":
+    case "widget":
+    case "raw":
+      kids = [node];
+      break;
+  }
+  const significant = kids.filter((n) => !isEmptyRaw(n));
+  return significant.length === 1 && significant[0] ? significant[0] : node;
+}
+function classifyBand(band, opts = {}) {
+  const root = opts.isMapMount ? rewriteMapMounts(band.root, opts.isMapMount) : band.root;
+  const widgets = collectWidgets(root);
+  const media = collectMedia(root);
+  const text = collectText(root);
+  const rowNode = topRowNode(root);
+  const row = rowNode ? rowNode.cells : null;
+  const hasSignificantRaw = collectRaws(root).some((n) => !isEmptyRaw(n));
+  const sole = soleSignificant(root);
+  if (sole.kind === "widget" && sole.widget.type === "map") {
+    return { slice: "LocationMap", ...base(band) };
+  }
+  if (media.length === 1 && media[0]?.kind === "video" && text.length === 0 && widgets.length === 0 && row === null && !hasSignificantRaw) {
+    const v = media[0];
+    return { slice: "VideoFeature", ...base(band), media: v };
+  }
+  const headings = text.filter((n) => n.kind === "heading");
+  const subtitles = text.filter((n) => n.kind === "subtitle");
+  const bodies = text.filter((n) => n.kind === "body");
+  if (media.length === 0 && row === null && widgets.length === 0 && !hasSignificantRaw) {
+    if (headings.length === 1 && subtitles.length <= 1 && bodies.length === 0 && !band.background) {
+      const first = headings[0];
+      const sub = subtitles[0];
+      return {
+        slice: "TitleBand",
+        ...base(band),
+        heading: first ? nodeText(first) : "",
+        ...sub ? { subtitle: nodeText(sub) } : {},
+        ...textRoleMeta(first, sub)
+      };
+    }
+    if (headings.length === 0 && subtitles.length === 0 && bodies.length > 0 && !band.background) {
+      return {
+        slice: "RichText",
+        ...base(band),
+        html: bodies.map((b) => b.kind === "body" ? b.html : "").join("\n")
+      };
+    }
+  }
+  if (band.background && headings.length === 1 && subtitles.length <= 1 && bodies.length <= 1 && row === null && media.length === 0 && widgets.length === 0 && !hasSignificantRaw) {
+    const h = headings[0];
+    const sub = subtitles[0];
+    const bod = bodies[0];
+    return {
+      slice: "Hero",
+      ...base(band),
+      ...h ? { heading: nodeText(h) } : {},
+      ...sub ? { subtitle: nodeText(sub) } : {},
+      ...bod && bod.kind === "body" ? { body: bod.html } : {},
+      ...textRoleMeta(h, sub)
+    };
+  }
+  if (rowNode?.slider) {
+    const slides = carouselSlides(rowNode.cells);
+    if (slides) {
+      const spec = { slice: "Carousel", ...base(band), slides };
+      if (rowNode.slider.columns !== void 0) spec.columns = rowNode.slider.columns;
+      return spec;
+    }
+  }
+  if (row) {
+    const gm = galleryMedia(row);
+    if (gm) return { slice: "Gallery", ...base(band), media: gm };
+  }
+  if (media.length === 1 && text.length === 0 && row === null && widgets.length === 0 && !hasSignificantRaw) {
+    const m = media[0];
+    if (m) return { slice: "MediaFull", ...base(band), media: m };
+  }
+  if (row && row.length === 2) {
+    const [c0, c1] = row;
+    if (c0 && c1) {
+      const m0 = pureCellMedia(c0);
+      const m1 = pureCellMedia(c1);
+      const t0 = collectText(c0.node).length > 0;
+      const t1 = collectText(c1.node).length > 0;
+      if (m0 && !m1 && t1) {
+        return {
+          slice: "SplitFeature",
+          ...base(band),
+          media: m0,
+          mediaSide: "left",
+          ratio: cellRatio(c0),
+          text: c1.node
+        };
+      }
+      if (m1 && !m0 && t0) {
+        return {
+          slice: "SplitFeature",
+          ...base(band),
+          media: m1,
+          mediaSide: "right",
+          ratio: cellRatio(c1),
+          text: c0.node
+        };
+      }
+    }
+  }
+  return { slice: "Grid", ...base(band), root };
+}
+function classifyBands(bands, opts = {}) {
+  return bands.map((b) => classifyBand(b, opts));
+}
+
+// src/blux/grid/extract-map.ts
+var SCRIPT_RE = /<script\b[^>]*>([\s\S]*?)<\/script>/g;
+function findScript(html, marker) {
+  for (const m of html.matchAll(SCRIPT_RE)) {
+    const body = m[1];
+    if (body !== void 0 && marker.test(body)) return body;
+  }
+  return null;
+}
+function extractStyles(script) {
+  const at = script.indexOf("styles:[");
+  if (at === -1) return [];
+  const start = at + "styles:".length;
+  let depth = 0;
+  for (let i = start; i < script.length; i++) {
+    const ch = script[i];
+    if (ch === "[") depth++;
+    else if (ch === "]") {
+      depth--;
+      if (depth === 0) {
+        try {
+          const raw = script.slice(start, i + 1);
+          const jsonish = raw.replace(/([{,])\s*([A-Za-z_][A-Za-z0-9_.]*)\s*:/g, '$1"$2":');
+          const parsed = JSON.parse(jsonish);
+          return Array.isArray(parsed) ? parsed : [];
+        } catch {
+          return [];
+        }
+      }
+    }
+  }
+  return [];
+}
+var LAYER_RE = /(\w+)\s*:\s*new google\.maps\.KmlLayer\(\{([^}]*)\}\)/g;
+function extractMapConfig(html) {
+  const init = findScript(html, /function initMap\(\)[\s\S]*new google\.maps\.Map/);
+  if (!init) return null;
+  const mountId = /getElementById\(\s*["']([^"']+)["']\s*\)/.exec(init)?.[1];
+  if (!mountId) return null;
+  const layers = [];
+  let mid;
+  for (const m of init.matchAll(LAYER_RE)) {
+    const name = m[1];
+    const args = m[2];
+    if (!name || args === void 0) continue;
+    const layerMid = /[?&]mid=([^&"']+)/.exec(args)?.[1];
+    const lid = /[?&]lid=([^&"']+)/.exec(args)?.[1];
+    if (!layerMid || !lid) continue;
+    mid ??= layerMid;
+    layers.push({
+      name,
+      lid,
+      initiallyVisible: /\bmap\s*:\s*map\b/.test(args),
+      preserveViewport: /preserveViewport\s*:\s*true/.test(args)
+    });
+  }
+  if (!mid || layers.length === 0) return null;
+  const centerM = /center\s*:\s*\{\s*lat\s*:\s*(-?[\d.]+)\s*,\s*lng\s*:\s*(-?[\d.]+)\s*\}/.exec(
+    init
+  );
+  const zoomM = /zoom\s*:\s*(\d+)/.exec(init);
+  const mountTag = new RegExp(`<[^>]*\\bid=["']${mountId}["'][^>]*>`, "i").exec(html)?.[0] ?? "";
+  const height = /height\s*:\s*([\d.]+(?:px|%|vh|vw|em|rem))/i.exec(mountTag)?.[1];
+  const toggles = extractToggles(html);
+  return {
+    mountId,
+    mid,
+    layers,
+    toggles,
+    styles: extractStyles(init),
+    ...centerM?.[1] && centerM[2] ? { center: { lat: Number(centerM[1]), lng: Number(centerM[2]) } } : {},
+    ...zoomM?.[1] ? { zoom: Number(zoomM[1]) } : {},
+    ...height ? { height } : {},
+    ...toggles.length ? { defaultToggle: 0 } : {}
+  };
+}
+function makeIsMapMount(config) {
+  const marker = `id="${config.mountId}"`;
+  return (node) => node.kind === "raw" && node.html.includes(marker);
+}
+function extractToggles(html) {
+  const labels = [...html.matchAll(/map_icon_text">([^<]*)</g)].map((m) => m[1]).filter((l) => l !== void 0);
+  const click = findScript(html, /clickMap\s*=\s*\{\s*0\s*:/);
+  if (!click || labels.length === 0) return [];
+  const bodyM = /clickMap\s*=\s*(\{[\s\S]*?\}\})\s*;/.exec(click);
+  if (!bodyM?.[1]) return [];
+  const groups = [];
+  for (const g of bodyM[1].matchAll(/(\d+)\s*:\s*function\s*\(onoff\)\s*\{([^}]*)\}/g)) {
+    const idx = Number(g[1]);
+    const body = g[2] ?? "";
+    const layerNames = [
+      ...new Set(
+        [...body.matchAll(/mapLayers\.(\w+)\./g)].map((m) => m[1]).filter((n) => n !== void 0)
+      )
+    ];
+    const label = labels[idx];
+    if (label === void 0) return [];
+    groups[idx] = { label, layers: layerNames, panelIndex: idx };
+  }
+  return groups.length === labels.length && groups.every((g) => g !== void 0) ? groups : [];
+}
+
+// src/blux/emit/block-styles.ts
+function blockStylesByIndex(siteJson) {
+  const out = /* @__PURE__ */ new Map();
+  const blocks = siteJson?.content?.pages?.[0]?.items;
+  if (!Array.isArray(blocks)) return out;
+  blocks.forEach((b, i) => {
+    const styles = b?.styles ?? {};
+    const cleaned = {};
+    for (const [k, v] of Object.entries(styles)) {
+      const c = cleanCssValue(v);
+      if (c) cleaned[k] = c;
+    }
+    if (Object.keys(cleaned).length) out.set(i, cleaned);
+  });
+  return out;
+}
+
+// src/blux/emit/grid-slice.ts
+function stripTags(html) {
+  return html.replace(/<[^>]*>/g, "").replace(/\s+/g, " ").trim();
+}
+function sliceSpecToPlanSlice(spec) {
+  switch (spec.slice) {
+    case "Hero":
+      return {
+        slice_type: "hero",
+        variation: "band",
+        items: [],
+        primary: {
+          band: spec.index,
+          ...spec.heading ? { heading: spec.heading } : {},
+          ...spec.subtitle ? { subtitle: spec.subtitle } : {},
+          ...spec.body ? { body: stripTags(spec.body) } : {}
+        }
+      };
+    case "TitleBand":
+      return {
+        slice_type: "title_band",
+        variation: "default",
+        items: [],
+        primary: {
+          band: spec.index,
+          heading: spec.heading,
+          ...spec.subtitle ? { subtitle: spec.subtitle } : {}
+        }
+      };
+    case "RichText":
+      return {
+        slice_type: "rich_text",
+        variation: "default",
+        items: [],
+        primary: { content: richText(spec.html), band: spec.index }
+      };
+    case "SplitFeature":
+      return {
+        slice_type: "split_feature",
+        variation: "default",
+        items: [],
+        primary: { band: spec.index }
+      };
+    case "Gallery":
+      return {
+        slice_type: "gallery",
+        variation: "default",
+        items: [],
+        primary: { band: spec.index }
+      };
+    case "Carousel":
+      return {
+        slice_type: "carousel",
+        variation: "default",
+        items: spec.slides.map(
+          (s) => s.caption ? { caption: blockPlainText(s.caption.html) } : {}
+        ),
+        primary: { band: spec.index }
+      };
+    case "MediaFull":
+    case "VideoFeature":
+      return {
+        slice_type: "media_full",
+        variation: "default",
+        items: [],
+        primary: { band: spec.index }
+      };
+    case "LocationMap":
+      return {
+        slice_type: "location_map",
+        variation: "default",
+        items: [],
+        primary: { band: spec.index }
+      };
+    case "Grid":
+      return {
+        slice_type: "grid_band",
+        variation: "default",
+        items: [],
+        primary: { band: spec.index }
+      };
+  }
+}
+
+// src/blux/emit/grid-plan.ts
+function mediaCdnUrl(m) {
+  return m.base ? `${m.base}${m.assetId}${m.ext ? `.${m.ext}` : ""}` : null;
+}
+function mediaUrl(m, sourceUrlById) {
+  return mediaCdnUrl(m) ?? sourceUrlById.get(m.assetId) ?? null;
+}
+function collectPlanAssets(specs, resolve, diagnostics) {
+  const byId = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  const add = (m) => {
+    if (seen.has(m.assetId)) return;
+    seen.add(m.assetId);
+    const asset = resolve(m);
+    if (asset) byId.set(m.assetId, asset);
+    else
+      diagnostics?.push({
+        kind: "unresolved-asset",
+        where: m.assetId,
+        message: `media ${m.assetId} has no CDN base nor IR source url \u2014 not uploaded`
+      });
+  };
+  for (const spec of specs) {
+    if (spec.background) add(spec.background);
+    switch (spec.slice) {
+      case "Gallery":
+        spec.media.forEach(add);
+        break;
+      case "Carousel":
+        spec.slides.forEach((s) => add(s.media));
+        break;
+      case "MediaFull":
+      case "VideoFeature":
+        add(spec.media);
+        break;
+      case "SplitFeature":
+        add(spec.media);
+        collectMedia(spec.text).forEach(add);
+        break;
+      case "Grid":
+        collectMedia(spec.root).forEach(add);
+        break;
+      default:
+        break;
+    }
+  }
+  return [...byId.values()];
+}
+function buildGridPlan(specs, ir) {
+  const page = ir.pages[0];
+  const uid = page?.uid ?? "home";
+  const title = page?.title ?? uid;
+  const doc = {
+    type: "page",
+    uid,
+    data: { title: richText(`<h1>${title}</h1>`), slices: specs.map(sliceSpecToPlanSlice) }
+  };
+  const assetById = new Map(ir.assets.map((a) => [a.id, a]));
+  const sourceUrlById = new Map(ir.assets.map((a) => [a.id, a.sourceUrl]));
+  const resolve = (m) => {
+    const asset = assetById.get(m.assetId);
+    const url = mediaUrl(m, sourceUrlById);
+    return url ? { id: m.assetId, url, alt: asset?.alt ?? "" } : null;
+  };
+  const diagnostics = [...ir.diagnostics ?? []];
+  const assets = collectPlanAssets(specs, resolve, diagnostics);
+  const customTypes = ir.collections.map(buildCustomType);
+  return { customTypes, documents: [doc], assets, stylesManifest: [], diagnostics };
+}
+
+// src/blux/emit/presentation.ts
+function renderToken(t) {
+  return {
+    cols: t.cols,
+    ...t.ratio !== void 0 ? { ratio: t.ratio } : {},
+    ...t.spacing !== void 0 ? { spacing: t.spacing } : {}
+  };
+}
+function renderNode(node, resolve) {
+  switch (node.kind) {
+    case "row": {
+      const cells = [];
+      for (const c of node.cells) {
+        const rn = renderNode(c.node, resolve);
+        if (rn) cells.push({ token: renderToken(c.token), node: rn });
+      }
+      return { kind: "row", cells };
+    }
+    case "stack": {
+      const children = [];
+      for (const c of node.children) {
+        const rn = renderNode(c, resolve);
+        if (rn) children.push(rn);
+      }
+      return { kind: "stack", children };
+    }
+    case "heading":
+      return {
+        kind: "heading",
+        level: node.level,
+        html: node.html,
+        ...node.role ? { role: node.role } : {}
+      };
+    case "body":
+      return { kind: "body", html: node.html, ...node.role ? { role: node.role } : {} };
+    case "subtitle":
+      return { kind: "subtitle", text: node.text, ...node.role ? { role: node.role } : {} };
+    case "media": {
+      const m = resolve(node.media);
+      return m ? { kind: "media", media: m } : null;
+    }
+    case "raw":
+      return { kind: "raw", html: node.html };
+    case "widget":
+      return { kind: "widget", widget: node.widget };
+  }
+}
+function hasMapWidget(node) {
+  if (node.kind === "widget") return node.widget.type === "map";
+  if (node.kind === "row") return node.cells.some((c) => hasMapWidget(c.node));
+  if (node.kind === "stack") return node.children.some(hasMapWidget);
+  return false;
+}
+function buildPresentation(specs, deps) {
+  const bands = {};
+  for (const spec of specs) {
+    const bp = {};
+    const style = deps.styleFor(spec.index);
+    if (style) bp.style = style;
+    if (spec.background) {
+      const bg = deps.resolveMedia(spec.background);
+      if (bg) bp.background = bg;
+    }
+    switch (spec.slice) {
+      case "Hero":
+      case "TitleBand": {
+        const meta = {
+          ...spec.headingRole ? { headingRole: spec.headingRole } : {},
+          ...spec.headingLevel !== void 0 ? { headingLevel: spec.headingLevel } : {},
+          ...spec.subtitleRole ? { subtitleRole: spec.subtitleRole } : {}
+        };
+        if (Object.keys(meta).length) bp.text = meta;
+        break;
+      }
+      case "RichText":
+        break;
+      // content is in the page doc
+      case "Gallery": {
+        const g = spec.media.map(deps.resolveMedia).filter((m) => m !== null);
+        if (g.length) bp.gallery = g;
+        break;
+      }
+      case "Carousel": {
+        const slides = [];
+        for (const s of spec.slides) {
+          const media = deps.resolveMedia(s.media);
+          if (!media) break;
+          const slide = {
+            media
+          };
+          if (s.caption) {
+            const caption = { level: s.caption.level };
+            if (s.caption.role !== void 0) caption.role = s.caption.role;
+            slide.caption = caption;
+          }
+          slides.push(slide);
+        }
+        if (slides.length > 0) {
+          bp.carousel = spec.columns !== void 0 ? { slides, columns: spec.columns } : { slides };
+        }
+        break;
+      }
+      case "MediaFull":
+      case "VideoFeature": {
+        const m = deps.resolveMedia(spec.media);
+        if (m) bp.media = m;
+        break;
+      }
+      case "SplitFeature": {
+        const media = deps.resolveMedia(spec.media);
+        const text = renderNode(spec.text, deps.resolveMedia);
+        if (media && text) bp.split = { mediaSide: spec.mediaSide, ratio: spec.ratio, media, text };
+        break;
+      }
+      case "LocationMap":
+        if (deps.map) bp.map = deps.map;
+        break;
+      case "Grid": {
+        const tree = renderNode(spec.root, deps.resolveMedia);
+        if (tree) bp.tree = tree;
+        if (deps.map && hasMapWidget(spec.root)) bp.map = deps.map;
+        break;
+      }
+    }
+    bands[String(spec.index)] = bp;
+  }
+  return { bands };
+}
+
+// src/blux/emit/convert.ts
+function mapRenderFromConfig(c) {
+  return {
+    mid: c.mid,
+    layers: c.layers,
+    toggles: c.toggles,
+    styles: c.styles,
+    ...c.center ? { center: c.center } : {},
+    ...c.zoom !== void 0 ? { zoom: c.zoom } : {},
+    ...c.height ? { height: c.height } : {},
+    ...c.defaultToggle !== void 0 ? { defaultToggle: c.defaultToggle } : {}
+  };
+}
+function convertExport({
+  html,
+  siteJson
+}) {
+  const bands = parseGridBands(html);
+  const mapConfig = extractMapConfig(html);
+  const specs = classifyBands(bands, mapConfig ? { isMapMount: makeIsMapMount(mapConfig) } : {});
+  const ir = assembleIR({ siteJson, htmls: [html] });
+  const assetsById = new Map(ir.assets.map((a) => [a.id, a]));
+  const sourceUrlById = new Map(ir.assets.map((a) => [a.id, a.sourceUrl]));
+  const styles = blockStylesByIndex(siteJson);
+  const deps = {
+    resolveMedia: (m) => {
+      const url = mediaUrl(m, sourceUrlById);
+      if (!url) return null;
+      const alt = assetsById.get(m.assetId)?.alt;
+      const rm = {
+        kind: m.kind,
+        url,
+        ...alt ? { alt } : {},
+        ...m.width !== void 0 ? { width: m.width } : {},
+        ...m.aspect !== void 0 ? { aspect: m.aspect } : {},
+        ...m.fit ? { fit: m.fit } : {},
+        ...m.position ? { position: m.position } : {},
+        ...m.minHeight ? { minHeight: m.minHeight } : {},
+        ...m.playback ? { playback: m.playback } : {}
+      };
+      return rm;
+    },
+    styleFor: (i) => styles.get(i),
+    map: mapConfig ? mapRenderFromConfig(mapConfig) : null
+  };
+  const plan = buildGridPlan(specs, ir);
+  const presentation = buildPresentation(specs, deps);
+  return { bands, specs, ir, mapConfig, plan, presentation };
+}
+
+// src/blux/emit/validate-layout.ts
+function tokKey(t) {
+  return `${t.cols}${t.ratio !== void 0 ? `r${t.ratio}` : ""}${t.spacing !== void 0 ? `s${t.spacing}` : ""}`;
+}
+function sigOf(node) {
+  switch (node.kind) {
+    case "row":
+      return `row[${node.cells.map((c) => `${tokKey(c.token)}:${sigOf(c.node)}`).join(",")}]`;
+    case "stack":
+      return `stack[${node.children.map(sigOf).join(",")}]`;
+    case "heading":
+      return `h${node.level}`;
+    case "body":
+      return "body";
+    case "subtitle":
+      return "subtitle";
+    case "media":
+      return `media:${node.media.kind}`;
+    case "widget":
+      return `widget:${node.widget.type}`;
+    case "raw":
+      return "raw";
+  }
+}
+function sourceLabel(spec) {
+  switch (spec.slice) {
+    case "Grid":
+      return sigOf(spec.root);
+    case "Gallery":
+      return `gallery(${spec.media.length})`;
+    case "Carousel":
+      return `carousel(${spec.slides.length})`;
+    case "MediaFull":
+      return "media_full";
+    case "VideoFeature":
+      return "video";
+    case "SplitFeature":
+      return `split(${spec.mediaSide},${spec.ratio})`;
+    case "LocationMap":
+      return "location_map";
+    case "Hero":
+      return "hero";
+    case "TitleBand":
+      return "title_band";
+    case "RichText":
+      return "rich_text";
+  }
+}
+function validateLayout(specs, presentation) {
+  const findings = [];
+  const rows = [];
+  const manifestKeys = Object.keys(presentation.bands);
+  let gridBands = 0;
+  if (specs.length !== manifestKeys.length) {
+    findings.push({ kind: "band-count", specs: specs.length, manifest: manifestKeys.length });
+  }
+  for (const spec of specs) {
+    const source = sourceLabel(spec);
+    const bp = presentation.bands[String(spec.index)];
+    if (!bp) {
+      findings.push({ kind: "band-missing", band: spec.index });
+      rows.push({ band: spec.index, slice: spec.slice, source, converted: "\u2205", ok: false });
+      continue;
+    }
+    const before = findings.length;
+    let converted = source;
+    if (spec.background && !bp.background) {
+      findings.push({ kind: "media-dropped", band: spec.index, where: "background" });
+    }
+    switch (spec.slice) {
+      case "Grid": {
+        gridBands++;
+        converted = bp.tree ? sigOf(bp.tree) : "\u2205";
+        if (source !== converted) {
+          findings.push({
+            kind: "tree-drift",
+            band: spec.index,
+            expected: source,
+            actual: converted
+          });
+        }
+        if (hasMapWidget(spec.root) && !bp.map) {
+          findings.push({ kind: "map-missing", band: spec.index });
+        }
+        break;
+      }
+      case "Gallery": {
+        const got = bp.gallery?.length ?? 0;
+        converted = `gallery(${got})`;
+        if (got < spec.media.length) {
+          findings.push({
+            kind: "media-dropped",
+            band: spec.index,
+            where: `gallery ${got}/${spec.media.length}`
+          });
+        }
+        break;
+      }
+      case "Carousel": {
+        const got = bp.carousel?.slides.length ?? 0;
+        converted = `carousel(${got})`;
+        if (got < spec.slides.length) {
+          findings.push({
+            kind: "media-dropped",
+            band: spec.index,
+            where: `carousel ${got}/${spec.slides.length}`
+          });
+        }
+        break;
+      }
+      case "MediaFull":
+      case "VideoFeature": {
+        if (!bp.media) {
+          converted = "\u2205";
+          findings.push({ kind: "media-dropped", band: spec.index, where: "media" });
+        }
+        break;
+      }
+      case "SplitFeature": {
+        if (!bp.split) {
+          converted = "\u2205";
+          findings.push({ kind: "media-dropped", band: spec.index, where: "split" });
+        } else {
+          converted = `split(${bp.split.mediaSide},${bp.split.ratio})`;
+          if (converted !== source) {
+            findings.push({
+              kind: "tree-drift",
+              band: spec.index,
+              expected: source,
+              actual: converted
+            });
+          }
+          const expectedText = sigOf(spec.text);
+          const actualText = sigOf(bp.split.text);
+          if (expectedText !== actualText) {
+            findings.push({
+              kind: "tree-drift",
+              band: spec.index,
+              expected: `split.text ${expectedText}`,
+              actual: `split.text ${actualText}`
+            });
+          }
+        }
+        break;
+      }
+      case "LocationMap": {
+        if (!bp.map) {
+          converted = "\u2205";
+          findings.push({ kind: "map-missing", band: spec.index });
+        }
+        break;
+      }
+      case "Hero":
+      case "TitleBand":
+      case "RichText":
+        break;
+      // text lives in the page doc (gated by grid-slice.test.ts); nothing manifest-carried to lose beyond background
+      default: {
+        const _exhaustive = spec;
+        throw new Error(`validateLayout: unhandled slice ${_exhaustive.slice}`);
+      }
+    }
+    rows.push({
+      band: spec.index,
+      slice: spec.slice,
+      source,
+      converted,
+      ok: findings.length === before
+    });
+  }
+  return { bands: specs.length, gridBands, faithful: findings.length === 0, findings, rows };
+}
+function fmtFinding(f) {
+  switch (f.kind) {
+    case "band-count":
+      return `  band count mismatch: ${f.specs} source bands vs ${f.manifest} manifest bands`;
+    case "band-missing":
+      return `  band ${f.band}: no manifest entry`;
+    case "tree-drift":
+      return `  band ${f.band}: grid tree drift
+      expected ${f.expected}
+      actual   ${f.actual}`;
+    case "media-dropped":
+      return `  band ${f.band}: media dropped (${f.where})`;
+    case "map-missing":
+      return `  band ${f.band}: map config missing`;
+  }
+}
+function formatLayoutReport(r) {
+  const headline = `layout fidelity: ${r.faithful ? "FAITHFUL" : `${r.findings.length} finding(s)`} \u2014 ${r.bands} bands (${r.gridBands} grid-tree checked)`;
+  const table = r.rows.map((x) => {
+    const tag = x.ok ? "ok" : "!!";
+    const sig = x.ok ? x.source : `${x.source} -> ${x.converted}`;
+    return `  band ${String(x.band).padStart(2)} ${x.slice.padEnd(13)} ${tag}  ${sig}`;
+  });
+  const detail = r.findings.length ? ["findings:", ...r.findings.map(fmtFinding)] : [];
+  return [headline, ...table, ...detail].join("\n");
+}
+
+// src/blux/emit/rewrite-manifest.ts
+var swap = (m, map) => {
+  const url = map.get(m.url);
+  return url ? { ...m, url } : m;
+};
+function walkNode(node, map) {
+  switch (node.kind) {
+    case "row":
+      return {
+        kind: "row",
+        cells: node.cells.map((c) => ({ token: c.token, node: walkNode(c.node, map) }))
+      };
+    case "stack":
+      return { kind: "stack", children: node.children.map((c) => walkNode(c, map)) };
+    case "media":
+      return { kind: "media", media: swap(node.media, map) };
+    default:
+      return node;
+  }
+}
+function walkBand(bp, map) {
+  const out = { ...bp };
+  if (bp.background) out.background = swap(bp.background, map);
+  if (bp.media) out.media = swap(bp.media, map);
+  if (bp.gallery) out.gallery = bp.gallery.map((m) => swap(m, map));
+  if (bp.carousel)
+    out.carousel = {
+      ...bp.carousel,
+      slides: bp.carousel.slides.map((s) => ({ ...s, media: swap(s.media, map) }))
+    };
+  if (bp.tree) out.tree = walkNode(bp.tree, map);
+  if (bp.split)
+    out.split = {
+      ...bp.split,
+      media: swap(bp.split.media, map),
+      text: walkNode(bp.split.text, map)
+    };
+  return out;
+}
+function rewriteManifestUrls(manifest, urlMap) {
+  const bands = {};
+  for (const [k, bp] of Object.entries(manifest.bands)) bands[k] = walkBand(bp, urlMap);
+  return { bands };
+}
+
+// src/cli/commands/blux.ts
+async function runBluxCommand(action, dir, opts) {
+  if (action === "emit") {
+    if (!dir) return { output: "blux emit needs a Blux export directory.", code: 1 };
+    let siteJson;
+    try {
+      siteJson = JSON.parse(await readFile(join(dir, "site.json"), "utf-8"));
+    } catch (err) {
+      return {
+        output: `could not read site.json in ${dir}: ${err.message}`,
+        code: 1
+      };
+    }
+    const out = opts.out ?? join(dir, "blux-out");
+    const htmlPaths = (await glob(["**/*.html"], { cwd: dir, absolute: true, ignore: ["blux-out/**"] })).sort();
+    const htmls = await Promise.all(htmlPaths.map((p) => readFile(p, "utf-8")));
+    const ir = assembleIR({ siteJson, htmls });
+    let probeLine = "";
+    if (opts.probe) {
+      const { probeAssetUrls } = await import("./probe-DJAMLVTT.js");
+      const used = /* @__PURE__ */ new Set();
+      const collect = (v) => {
+        if (!v || typeof v !== "object") return;
+        if ("__asset_id" in v) used.add(v.__asset_id);
+        else if (Array.isArray(v)) v.forEach(collect);
+        else Object.values(v).forEach(collect);
+      };
+      buildMigrationPlan(ir).documents.forEach((d) => collect(d.data));
+      const targets = ir.assets.filter((a) => used.has(a.id) && !a.sourceUrl);
+      const probed = await probeAssetUrls(targets, ir.meta.bluxSiteId, opts.fetchImpl ?? fetch);
+      let hits = 0;
+      for (const a of ir.assets) {
+        const url = probed.get(a.id);
+        if (url) {
+          a.sourceUrl = url;
+          hits++;
+        }
+      }
+      ir.diagnostics = ir.diagnostics.filter(
+        (d) => !(d.kind === "unresolved-asset" && probed.get(d.where))
+      );
+      probeLine = `probe resolved ${hits}/${targets.length} used assets`;
+    }
+    const plan = buildMigrationPlan(ir);
+    const manifest = buildReviewManifest(ir, {
+      convertedBase: opts.convertedBase ?? "http://localhost:5173",
+      bluxBase: opts.bluxBase ?? `https://${ir.meta.domain}`
+    });
+    await mkdir(join(out, "customtypes"), { recursive: true });
+    await writeFile(join(out, "ir.json"), JSON.stringify(ir, null, 2));
+    await writeFile(join(out, "migration-plan.json"), JSON.stringify(plan, null, 2));
+    const rolesCss = emitRolesCss(ir.theme);
+    await writeFile(
+      join(out, "theme.css"),
+      emitThemeCss(ir.theme) + (rolesCss ? "\n" + rolesCss : "")
+    );
+    await writeFile(join(out, "review-manifest.json"), JSON.stringify(manifest, null, 2));
+    await writeFile(
+      join(out, "styles-manifest.json"),
+      JSON.stringify(plan.stylesManifest, null, 2)
+    );
+    for (const ct of plan.customTypes) {
+      await writeFile(join(out, "customtypes", `${ct.id}.json`), JSON.stringify(ct.json, null, 2));
+    }
+    const resolved = ir.assets.filter((a) => a.sourceUrl !== null).length;
+    const diagnostics = [...ir.diagnostics, ...plan.diagnostics];
+    const lines = [
+      `site: ${ir.meta.name} (${ir.meta.domain})`,
+      ...probeLine ? [probeLine] : [],
+      `pages: ${ir.pages.length} | custom types: ${plan.customTypes.length} | documents: ${plan.documents.length} | assets: ${resolved}/${ir.assets.length} resolved`,
+      `diagnostics: ${diagnostics.length}`,
+      ...diagnostics.map((d) => `  - [${d.kind}] ${d.where}: ${d.message}`),
+      `wrote ${out}`
+    ];
+    return { output: lines.join("\n"), code: 0 };
+  }
+  if (action === "migrate") {
+    if (!dir) {
+      return {
+        output: "blux migrate needs an emitted output directory (or a plan .json path).",
+        code: 1
+      };
+    }
+    if (!process.env.PRISMIC_REPOSITORY_NAME || !process.env.PRISMIC_WRITE_TOKEN) {
+      return {
+        output: "Set PRISMIC_REPOSITORY_NAME and PRISMIC_WRITE_TOKEN to run a live migration.",
+        code: 1
+      };
+    }
+    const planPath = dir.endsWith(".json") ? dir : join(dir, "migration-plan.json");
+    const plan = JSON.parse(await readFile(planPath, "utf-8"));
+    const { pushCustomTypes, runMigration } = await import("./run-migration-LJNNZWIV.js");
+    const pushed = await pushCustomTypes(plan.customTypes);
+    const r = await runMigration(plan, (line) => process.stderr.write(`${line}
+`));
+    const missing = r.missingAssets.length ? `
+WARNING missing assets: ${r.missingAssets.join(", ")}` : "";
+    let manifestNote = "";
+    const manifestPath = join(dirname(planPath), "blux-presentation.json");
+    try {
+      const manifest = JSON.parse(await readFile(manifestPath, "utf-8"));
+      const rewritten = rewriteManifestUrls(manifest, r.assetUrlByCdn);
+      await writeFile(manifestPath, JSON.stringify(rewritten, null, 2) + "\n");
+      manifestNote = "\nmanifest media rewritten to Prismic urls";
+    } catch {
+    }
+    return {
+      output: `custom types pushed: ${pushed.join(", ") || "none"}
+assets: ${r.assetsUploaded} uploaded, ${r.assetsReused} reused | documents: ${r.docsCreated} created, ${r.docsUpdated} updated \u2192 ${process.env.PRISMIC_REPOSITORY_NAME} (publish the migration release in the dashboard)` + missing + manifestNote,
+      code: 0
+    };
+  }
+  if (action === "validate") {
+    if (!dir) return { output: "blux validate needs a Blux export directory.", code: 1 };
+    let exportHtml;
+    try {
+      exportHtml = await readFile(join(dir, "index.html"), "utf-8");
+    } catch (err) {
+      return { output: `could not read index.html in ${dir}: ${err.message}`, code: 1 };
+    }
+    let rendered = null;
+    if (opts.against) {
+      try {
+        if (/^https?:\/\//.test(opts.against)) {
+          const res = await (opts.fetchImpl ?? fetch)(opts.against);
+          if (!res.ok) {
+            return {
+              output: `could not fetch --against ${opts.against}: HTTP ${res.status}`,
+              code: 1
+            };
+          }
+          rendered = await res.text();
+        } else {
+          rendered = await readFile(opts.against, "utf-8");
+        }
+      } catch (err) {
+        return {
+          output: `could not read --against ${opts.against}: ${err.message}`,
+          code: 1
+        };
+      }
+    }
+    let siteJson;
+    try {
+      siteJson = JSON.parse(await readFile(join(dir, "site.json"), "utf-8"));
+    } catch (err) {
+      return { output: `could not read site.json in ${dir}: ${err.message}`, code: 1 };
+    }
+    const { specs, presentation } = convertExport({ html: exportHtml, siteJson });
+    const layout = validateLayout(specs, presentation);
+    const lines = [formatLayoutReport(layout)];
+    if (rendered !== null) {
+      const report = validateCoverage(exportHtml, rendered);
+      lines.push(
+        "",
+        `content coverage: ${report.covered}/${report.total} runs (${report.coveragePct}%)`,
+        ...report.missing.length ? [
+          "missing runs \u2014 export text absent from the render:",
+          ...report.missing.map((m) => `  - ${m}`)
+        ] : ["all export text runs present in the render"]
+      );
+    }
+    return { output: lines.join("\n"), code: layout.faithful ? 0 : 1 };
+  }
+  if (action === "grid") {
+    if (!dir) return { output: "blux grid needs a Blux export directory.", code: 1 };
+    let html;
+    try {
+      html = await readFile(join(dir, "index.html"), "utf-8");
+    } catch (err) {
+      return {
+        output: `could not read index.html in ${dir}: ${err.message}`,
+        code: 1
+      };
+    }
+    const bands = parseGridBands(html);
+    const outDir = opts.out ?? join(dir, "blux-out");
+    await mkdir(outDir, { recursive: true });
+    await writeFile(join(outDir, "grid-tree.json"), JSON.stringify(bands, null, 2));
+    const mapConfig = extractMapConfig(html);
+    if (mapConfig) {
+      await writeFile(
+        join(outDir, "map-config.json"),
+        JSON.stringify(mapConfig, null, 2) + "\n",
+        "utf-8"
+      );
+    }
+    return {
+      output: `Parsed ${bands.length} bands \u2192 ${join(outDir, "grid-tree.json")}` + (mapConfig ? ", map config extracted" : ""),
+      code: 0
+    };
+  }
+  if (action === "convert") {
+    if (!dir) return { output: "blux convert needs a Blux export directory.", code: 1 };
+    let html;
+    let siteJson;
+    try {
+      html = await readFile(join(dir, "index.html"), "utf-8");
+      siteJson = JSON.parse(await readFile(join(dir, "site.json"), "utf-8"));
+    } catch (err) {
+      return { output: `could not read export in ${dir}: ${err.message}`, code: 1 };
+    }
+    const { bands, mapConfig, plan, presentation, ir, specs } = convertExport({ html, siteJson });
+    const outDir = opts.out ?? join(dir, "blux-out");
+    await mkdir(outDir, { recursive: true });
+    await writeFile(join(outDir, "migration-plan.json"), JSON.stringify(plan, null, 2));
+    await writeFile(
+      join(outDir, "blux-presentation.json"),
+      JSON.stringify(presentation, null, 2) + "\n"
+    );
+    await writeFile(
+      join(outDir, "theme.css"),
+      emitThemeCss(ir.theme) + "\n" + emitRolesCss(ir.theme)
+    );
+    if (mapConfig) {
+      await writeFile(join(outDir, "map-config.json"), JSON.stringify(mapConfig, null, 2) + "\n");
+    }
+    const layout = validateLayout(specs, presentation);
+    await writeFile(join(outDir, "layout-report.json"), JSON.stringify(layout, null, 2) + "\n");
+    const sliceCount = plan.documents[0]?.data.slices?.length ?? 0;
+    return {
+      output: `Converted ${bands.length} bands \u2192 ${outDir} (${Object.keys(presentation.bands).length} manifest bands, ${sliceCount} slices` + (mapConfig ? ", map config extracted" : "") + ")\n" + formatLayoutReport(layout),
+      code: 0
+    };
+  }
+  return {
+    output: `unknown blux action '${action}'. Use: emit, migrate, validate, grid, convert.`,
+    code: 1
+  };
+}
+export {
+  runBluxCommand
+};
+//# sourceMappingURL=blux-FKZYMKLF.js.map