@openpresentation/opf 0.18.4 → 0.20.1

package/dist/{chunk-MBU42S5Y.js → chunk-UAXSW6VV.js}

@@ -1,5 +1,3 @@
-import { checkCatalogsOption, resolveReference, unresolvedReference, provenanceOf } from './chunk-SPFV27O5.js';
-
 // src/table.ts
 var record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
 function tableGrid(value, path = "table") {
@@ -1187,10 +1185,10 @@ function slideSectionDiagnostics(presentation, uses) {
   const out = [];
   presentation.slides.forEach((slide, index) => {
     if (!isRecord(slide) || typeof slide.section === "string" && slide.section !== "") return;
-    const own2 = `/slides/${index}/`;
+    const own3 = `/slides/${index}/`;
     const design = isRecord(slide.design) ? slide.design : {};
     const inherited = ["header", "footer"].filter((kind2) => design[kind2] === void 0).map((kind2) => `/design/${kind2}/`);
-    const where = paths.find((path) => path.startsWith(own2) || inherited.some((prefix) => path.startsWith(prefix)));
+    const where = paths.find((path) => path.startsWith(own3) || inherited.some((prefix) => path.startsWith(prefix)));
     if (where === void 0) return;
     out.push({ code: "variable-builtin-missing", severity: "warning", path: `/slides/${index}`, id: "slide.section", message: `Slide ${index + 1} has no section, so '{{slide.section}}' (used at ${where}) resolves to nothing on it; give the slide a section or remove the token.` });
   });
@@ -1989,7 +1987,8 @@ function intrinsicImageAspect(value, assets) {
 }
 
 // src/design-hints.ts
-var DESIGN_HINT_KEYS = ["titleAlignment", "contentAlignment", "contentBox", "contentDirection", "chartPrimary", "imageFit", "listBullet"];
+var DESIGN_HINT_KEYS = ["titleAlignment", "contentAlignment", "contentBox", "contentDirection", "chartPrimary", "imageFit", "listBullet", "mirror"];
+var THEME_DESIGN_KEYS = ["titleAlignment", "contentAlignment", "contentBox", "contentDirection", "imageFit", "listBullet"];
 var ALIGNMENTS = ["left", "center", "right"];
 var VALUES = {
   titleAlignment: ALIGNMENTS,
@@ -1998,12 +1997,14 @@ var VALUES = {
   contentDirection: ["horizontal", "vertical"],
   chartPrimary: ["none", "top", "bottom", "left", "right"],
   imageFit: ["cover", "contain", "stretch"],
-  listBullet: ["character", "image"]
+  listBullet: ["character", "image"],
+  mirror: "boolean"
 };
+var themeKeys = new Set(THEME_DESIGN_KEYS);
 var accepts = (key, value) => VALUES[key] === "boolean" ? typeof value === "boolean" : VALUES[key].includes(value);
 var object = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
 function resolveDesignHints(options = {}) {
-  const slide = object(object(options.slide).design), host = object(options.deck), deck = object(object(options.presentation).design), layout = object(object(options.layout).design);
+  const slide = object(object(options.slide).design), host = object(options.deck), deck = object(object(options.presentation).design), theme = object(object(options.theme).design), layout = object(object(options.layout).design);
   const index = options.slideIndex ?? 0;
   const result = { sources: {}, paths: {} };
   const set2 = (key, value, source, path) => {
@@ -2015,6 +2016,7 @@ function resolveDesignHints(options = {}) {
     if (accepts(key, slide[key])) set2(key, slide[key], "slide", `slides.${index}.design.${key}`);
     else if (accepts(key, host[key])) set2(key, host[key], "deck", `design.${key}`);
     else if (accepts(key, deck[key])) set2(key, deck[key], "deck", `design.${key}`);
+    else if (themeKeys.has(key) && accepts(key, theme[key])) set2(key, theme[key], "theme", slide.theme !== void 0 ? `slides.${index}.design.theme` : "design.theme");
     else if (accepts(key, layout[key])) set2(key, layout[key], "layout", `slides.${index}.layout`);
   }
   return result;
@@ -2043,73 +2045,447 @@ function readingRows(items) {
   return rows3.map((row) => row.items.sort((a, b) => index.get(a) - index.get(b)));
 }
 
-// src/layout-content.ts
-var LAYOUT_BODY_KINDS = ["text", "list", "image", "video", "chart", "table", "code", "metric", "quote", "timeline"];
-var MAX_PLACEHOLDER_GROUP_DEPTH = 3;
-var bodyKinds = new Set(LAYOUT_BODY_KINDS);
+// src/layout-template.ts
+var REGION_KINDS = ["text", "list", "image", "video", "chart", "table", "code", "metric", "quote", "timeline", "group"];
+var REGION_ROLES = ["primary", "secondary", "media", "supporting"];
+var REGION_FLOWS = ["none", "grid", "column", "auto"];
+var REGION_ANCHORS = ["top", "middle", "bottom"];
+var HEADING_AREAS = ["title", "subtitle"];
+var RESERVED_REGION_NAMES = ["title", "subtitle", "tag", "auto", "left", "center", "right", "top", "middle", "bottom"];
+var MAX_TEMPLATE_TRACKS = 12;
+var MAX_REGION_BLOCKS = 12;
+var AUTO_LAYOUT = "auto";
+var OPFLayoutTemplateError = class extends RangeError {
+  constructor(issues) {
+    super(`The layout template is invalid: ${issues.map((issue) => `${issue.path || "/"}: ${issue.message}`).join("; ")}`);
+    this.issues = issues;
+    this.name = "OPFLayoutTemplateError";
+  }
+  issues;
+  code = "layout-template";
+};
+var NAME = /^[a-z][a-z0-9-]*$/;
 var record4 = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
-function isPlaceholderGroup(placeholder) {
-  return record4(placeholder).type === "group";
-}
-function layoutSlots(layout, base = "layout.placeholders") {
-  const walk2 = (entries, path, depth) => (Array.isArray(entries) ? entries : []).map((entry, index) => {
-    const placeholder = record4(entry), slotPath = `${path}.${index}`;
-    const type = typeof placeholder.type === "string" ? placeholder.type : "";
-    if (type !== "group") {
-      if (depth > 0 && !bodyKinds.has(type)) throw new RangeError(`${slotPath}: a placeholder group holds body regions only, not '${type}'.`);
-      return { type, path: slotPath, depth, placeholder };
-    }
-    if (depth >= MAX_PLACEHOLDER_GROUP_DEPTH) throw new RangeError(`${slotPath}: placeholder groups nest at most ${MAX_PLACEHOLDER_GROUP_DEPTH} levels inside a layout record.`);
-    if (!Array.isArray(placeholder.placeholders) || !placeholder.placeholders.length) throw new RangeError(`${slotPath}: a placeholder group needs at least one placeholder.`);
-    return { type, path: slotPath, depth, placeholder, children: walk2(placeholder.placeholders, `${slotPath}.placeholders`, depth + 1) };
-  });
-  return walk2(layout?.placeholders, base, 0);
+var pointerSegment = (segment2) => segment2.replaceAll("~", "~0").replaceAll("/", "~1");
+var reserved = new Set(RESERVED_REGION_NAMES);
+var headingNames = new Set(HEADING_AREAS);
+var positive = (value) => typeof value === "number" && Number.isFinite(value) && value > 0;
+function isLayoutTemplate(layout) {
+  return Object.hasOwn(record4(layout), "areas");
+}
+function layoutRegion(name, value) {
+  const entry = record4(value);
+  const accepts2 = Array.isArray(entry.accepts) ? [...new Set(entry.accepts.filter((kind2) => REGION_KINDS.includes(kind2)))] : [];
+  const flow = REGION_FLOWS.includes(entry.flow) ? entry.flow : "auto";
+  const max = Number.isInteger(entry.max) && entry.max >= 1 && entry.max <= MAX_REGION_BLOCKS ? entry.max : flow === "none" ? 1 : 6;
+  return {
+    name,
+    accepts: accepts2,
+    role: REGION_ROLES.includes(entry.role) ? entry.role : "primary",
+    flow,
+    max,
+    bleed: entry.bleed === true,
+    listColumns: entry.listColumns === "auto" ? "auto" : 1,
+    anchor: REGION_ANCHORS.includes(entry.anchor) ? entry.anchor : "top",
+    empty: entry.empty === "keep" ? "keep" : "collapse"
+  };
 }
-function layoutLeaves(layout) {
-  const leaves = [];
-  const visit = (slots) => {
-    for (const slot of slots) slot.children ? visit(slot.children) : leaves.push({ type: slot.type, path: slot.path, depth: slot.depth, placeholder: slot.placeholder });
+function parse(layout) {
+  const value = record4(layout);
+  const issues = [];
+  const grid = (code, path, message) => issues.push({ code, path, message });
+  const areas = value.areas;
+  if (!Array.isArray(areas) || !areas.length) {
+    grid("layout-template", "/areas", "a template needs 1 to 12 rows of area names");
+    return { issues };
+  }
+  if (areas.length > MAX_TEMPLATE_TRACKS) grid("layout-template", "/areas", `a template has at most ${MAX_TEMPLATE_TRACKS} rows; this one has ${areas.length}`);
+  const cells = areas.map((row, index) => {
+    if (!Array.isArray(row)) {
+      grid("layout-template", `/areas/${index}`, "each row is an array of area names; use nested arrays instead of space-separated strings");
+      return [];
+    }
+    const words = [];
+    if (!row.length) grid("layout-template", `/areas/${index}`, 'a row needs at least one area name or "."');
+    row.forEach((cell, column) => {
+      if (typeof cell !== "string") grid("layout-template", `/areas/${index}/${column}`, 'each cell is one area name or "."');
+      else {
+        words.push(cell);
+        if (cell !== "." && !NAME.test(cell)) grid("layout-template", `/areas/${index}/${column}`, `'${cell}' is not an area name (lowercase letters, digits and hyphens, starting with a letter) or "."`);
+      }
+    });
+    return words;
+  });
+  const width = cells[0]?.length ?? 0;
+  cells.forEach((row, index) => {
+    if (index > 0 && row.length !== width && row.length) grid("layout-template", `/areas/${index}`, `every row has the same number of cells; row ${index + 1} has ${row.length}, row 1 has ${width}`);
+  });
+  if (width > MAX_TEMPLATE_TRACKS) grid("layout-template", "/areas", `a template has at most ${MAX_TEMPLATE_TRACKS} columns; this one has ${width}`);
+  const columns2 = value.columns === void 0 ? Array.from({ length: width }, () => 1) : value.columns;
+  const rows3 = value.rows === void 0 ? Array.from({ length: cells.length }, () => 1) : value.rows;
+  if (!Array.isArray(columns2) || columns2.length !== width || !columns2.every(positive)) grid("layout-template", "/columns", `columns needs one positive number per cell of a row (${width})`);
+  if (!Array.isArray(rows3) || rows3.length !== cells.length || !rows3.every((size) => size === "auto" || positive(size))) grid("layout-template", "/rows", `rows needs one positive number or "auto" per row (${cells.length})`);
+  if (issues.length) return { issues };
+  const bounds = /* @__PURE__ */ new Map();
+  cells.forEach((row, r) => {
+    row.forEach((name, c) => {
+      if (name === ".") return;
+      const found = bounds.get(name);
+      if (!found) bounds.set(name, { top: r, left: c, bottom: r, right: c, count: 1 });
+      else {
+        found.top = Math.min(found.top, r);
+        found.left = Math.min(found.left, c);
+        found.bottom = Math.max(found.bottom, r);
+        found.right = Math.max(found.right, c);
+        found.count++;
+      }
+    });
+  });
+  const list = [];
+  for (const [name, box] of bounds) {
+    const filled = (box.bottom - box.top + 1) * (box.right - box.left + 1);
+    let rectangle = filled === box.count;
+    for (let r = box.top; rectangle && r <= box.bottom; r++) for (let c = box.left; c <= box.right; c++) if (cells[r][c] !== name) {
+      rectangle = false;
+      break;
+    }
+    if (!rectangle) {
+      grid("layout-template", "/areas", `the cells of '${name}' do not form one filled rectangle`);
+      continue;
+    }
+    list.push({ name, row: box.top, column: box.left, rowSpan: box.bottom - box.top + 1, columnSpan: box.right - box.left + 1, heading: headingNames.has(name) });
+  }
+  if (issues.length) return { issues };
+  list.sort((a, b) => a.row - b.row || a.column - b.column);
+  const entries = record4(value.regions);
+  const region = (path, message) => grid("layout-region", path, message);
+  if (value.regions !== void 0 && (value.regions === null || typeof value.regions !== "object" || Array.isArray(value.regions))) region("/regions", "regions is an object keyed by region name");
+  for (const name of Object.keys(entries)) {
+    if (reserved.has(name)) region(`/regions/${pointerSegment(name)}`, `'${name}' is reserved and cannot name a region (reserved: ${RESERVED_REGION_NAMES.join(", ")})`);
+    else if (!bounds.has(name)) region(`/regions/${pointerSegment(name)}`, `region '${name}' has no area in areas`);
+  }
+  for (const area of list) {
+    if (area.heading) continue;
+    if (reserved.has(area.name)) {
+      if (!Object.hasOwn(entries, area.name)) region("/areas", `'${area.name}' is reserved and cannot name a body area (reserved: ${RESERVED_REGION_NAMES.join(", ")})`);
+      continue;
+    }
+    if (!Object.hasOwn(entries, area.name)) region("/regions", `body area '${area.name}' has no entry in regions`);
+  }
+  if (bounds.has("subtitle") && !bounds.has("title")) region("/areas", "a 'subtitle' area needs a 'title' area");
+  for (const [name, entry] of Object.entries(entries)) {
+    const raw = record4(entry);
+    if (raw.flow === "none" && raw.max !== void 0 && raw.max !== 1) region(`/regions/${pointerSegment(name)}/max`, `a region with flow "none" holds one block; max must be 1, not ${JSON.stringify(raw.max)}`);
+  }
+  const regions = list.filter((area) => !area.heading && !reserved.has(area.name) && Object.hasOwn(entries, area.name)).map((area) => layoutRegion(area.name, entries[area.name]));
+  for (const entry of regions) if (!entry.accepts.length) region(`/regions/${pointerSegment(entry.name)}/accepts`, `region '${entry.name}' accepts no content kind`);
+  if (value.overflowRegion !== void 0 && !regions.some((entry) => entry.name === value.overflowRegion)) region("/overflowRegion", `overflowRegion ${JSON.stringify(value.overflowRegion)} is not a region of this layout`);
+  if (issues.length) return { issues };
+  const overflowRegion = typeof value.overflowRegion === "string" ? value.overflowRegion : regions.find((entry) => entry.role === "primary" && entry.flow !== "none")?.name;
+  return {
+    issues,
+    template: {
+      rows: rows3.slice(),
+      columns: columns2.slice(),
+      grid: cells,
+      areas: list,
+      regions,
+      ...overflowRegion !== void 0 ? { overflowRegion } : {},
+      title: bounds.has("title"),
+      subtitle: bounds.has("subtitle")
+    }
   };
-  visit(layoutSlots(layout));
-  return leaves;
 }
-function layoutStructure(layout) {
-  const describe = (slots) => slots.map((slot) => {
-    if (!slot.children) return slot.type;
-    const mode = record4(slot.placeholder.composition).mode;
-    return `${typeof mode === "string" && mode !== "auto" ? mode : "group"} (${describe(slot.children)})`;
-  }).join(", ");
-  return describe(layoutSlots(layout));
+function layoutTemplateIssues(layout) {
+  return isLayoutTemplate(layout) ? parse(layout).issues : [];
 }
-function hasPlaceholderGroups(layout) {
-  return Array.isArray(layout?.placeholders) && layout.placeholders.some(isPlaceholderGroup);
+function layoutTemplate(layout) {
+  const parsed = parse(layout);
+  if (!parsed.template) throw new OPFLayoutTemplateError(parsed.issues);
+  return parsed.template;
 }
-function layoutContent(layout) {
-  const heading = { title: false, subtitle: false, tag: false };
-  const counts = /* @__PURE__ */ new Map();
-  let count = 0;
-  const visit = (entries, depth) => {
-    for (const entry of Array.isArray(entries) ? entries : []) {
-      const type = record4(entry).type;
-      if (type === "group") {
-        if (depth < MAX_PLACEHOLDER_GROUP_DEPTH) visit(record4(entry).placeholders, depth + 1);
-        continue;
-      }
-      if (type === "title" || type === "subtitle" || type === "tag") {
-        if (depth === 0) heading[type] = true;
-      } else if (typeof type === "string" && bodyKinds.has(type)) {
-        counts.set(type, (counts.get(type) ?? 0) + 1);
-        count += 1;
-      }
+
+// src/bind-regions.ts
+var FIELDS = ["text", "items", "bullets", "image", "video", "chart", "table", "code", "metric", "quote", "timeline"];
+var FIELD_KINDS = { text: "text", bullets: "text", items: "list", image: "image", video: "video", chart: "chart", table: "table", code: "code", metric: "metric", quote: "quote", timeline: "timeline" };
+var IMAGE_EDGES = ["left", "right", "top", "bottom"];
+var PROMOTED_REGION_KEY = /^(top|middle|bottom)(\+(top|middle|bottom))*(:(left|center|right)(\+(left|center|right))*)?$|^(left|center|right)(\+(left|center|right))*$/;
+var record5 = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+var empty = (value) => value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0;
+function blockKind(block) {
+  const value = record5(block);
+  if (Array.isArray(value.blocks)) return "group";
+  if (typeof value.type === "string" && value.type !== "group" && Object.values(FIELD_KINDS).includes(value.type)) return value.type;
+  const field = FIELDS.find((name) => value[name] !== void 0);
+  return field ? FIELD_KINDS[field] : "text";
+}
+function leafKinds(block, into = /* @__PURE__ */ new Set(), depth = 0) {
+  if (depth > 32) return into;
+  for (const child of Array.isArray(block.blocks) ? block.blocks : []) {
+    const value = record5(child);
+    if (Array.isArray(value.blocks)) leafKinds(value, into, depth + 1);
+    else into.add(blockKind(value));
+  }
+  return into;
+}
+function regionAccepts(region, block) {
+  const kind2 = blockKind(block);
+  if (region.accepts.includes(kind2)) return true;
+  if (kind2 !== "group") return false;
+  const kinds = leafKinds(record5(block));
+  return kinds.size > 0 && [...kinds].every((leaf) => region.accepts.includes(leaf));
+}
+function placedImageBlocks(slide) {
+  const value = record5(slide);
+  const placed = /* @__PURE__ */ new Set();
+  if (!Array.isArray(value.blocks) || Object.keys(value).some((key) => PROMOTED_REGION_KEY.test(key))) return placed;
+  const used = /* @__PURE__ */ new Set();
+  value.blocks.forEach((block, index) => {
+    const host = record5(block);
+    if (Array.isArray(host.blocks) || host.image === void 0 || host.placement === void 0) return;
+    const edge = record5(host.placement).edge;
+    if (!IMAGE_EDGES.includes(edge) || used.has(edge)) return;
+    used.add(edge);
+    placed.add(index);
+  });
+  return placed;
+}
+function rootNodes(slide, slideIndex = 0) {
+  const value = record5(slide), base = `slides.${slideIndex}`;
+  if (Array.isArray(value.blocks)) {
+    const placed = placedImageBlocks(value);
+    return value.blocks.flatMap((block, index) => {
+      const host = record5(block);
+      if (placed.has(index)) return [];
+      if (!Array.isArray(host.blocks) && FIELDS.every((field) => empty(host[field]))) return [];
+      if (Array.isArray(host.blocks) && !host.blocks.length) return [];
+      return [{ path: `${base}.blocks.${index}`, kind: blockKind(host), block: index, value: host }];
+    });
+  }
+  const nodes = [];
+  for (const field of FIELDS) {
+    if (empty(value[field]) || field === "bullets" && !empty(value.text)) continue;
+    const fields2 = field === "text" && !empty(value.bullets) ? ["text", "bullets"] : [field];
+    nodes.push({ path: `${base}.${field}`, kind: FIELD_KINDS[field], fields: fields2, value: Object.fromEntries(fields2.map((name) => [name, value[name]])) });
+  }
+  return nodes;
+}
+function regionRoleRank(role, kind2) {
+  const media = kind2 === "image" || kind2 === "video";
+  return media ? { media: 0, primary: 1, secondary: 2, supporting: 3 }[role] : { primary: 0, secondary: 1, supporting: 2, media: 3 }[role];
+}
+function bindRegions(slide, layout, options = {}) {
+  const template = layoutTemplate(layout);
+  const value = record5(slide), index = options.slideIndex ?? 0;
+  const regions = template.regions.map((region) => ({ name: region.name, blocks: [], overflow: [] }));
+  const result = { regions, below: [], diagnostics: [] };
+  if (Object.keys(value).some((key) => PROMOTED_REGION_KEY.test(key))) return result;
+  const byName = new Map(template.regions.map((region, order2) => [region.name, { region, binding: regions[order2], order: order2 }]));
+  const room = (name) => {
+    const entry = byName.get(name);
+    return entry.binding.blocks.length < entry.region.max;
+  };
+  const nodes = rootNodes(value, index);
+  const rest = [];
+  for (const node of nodes) {
+    const pin = node.block !== void 0 ? node.value.region : void 0;
+    if (typeof pin !== "string") {
+      rest.push(node);
+      continue;
     }
+    const target = byName.get(pin), pinPath = `${node.path}.region`;
+    if (!target) result.diagnostics.push({ code: "region-unknown", path: pinPath, region: pin, message: `The layout has no region '${pin}'; the block is placed by its kind instead.` });
+    else if (!regionAccepts(target.region, node.value)) result.diagnostics.push({ code: "region-kind", path: pinPath, region: pin, message: `Region '${pin}' does not accept ${node.kind} content (it accepts ${target.region.accepts.join(", ")}); the block is placed by its kind instead.` });
+    else if (!room(pin)) result.diagnostics.push({ code: "region-full", path: pinPath, region: pin, message: `Region '${pin}' already holds its ${target.region.max} block${target.region.max === 1 ? "" : "s"}; the block is placed by its kind instead.` });
+    else {
+      target.binding.blocks.push({ path: node.path, kind: node.kind, block: node.block, pinned: true });
+      continue;
+    }
+    rest.push(node);
+  }
+  const overflowName = template.overflowRegion;
+  for (const node of rest) {
+    const bound = { path: node.path, kind: node.kind, ...node.block !== void 0 ? { block: node.block } : {}, ...node.fields ? { fields: node.fields } : {} };
+    let best;
+    for (const [name, entry] of byName) {
+      if (!regionAccepts(entry.region, node.value) || !room(name)) continue;
+      const rank = regionRoleRank(entry.region.role, node.kind);
+      if (!best || rank < best.rank || rank === best.rank && entry.order < best.order) best = { rank, order: entry.order, name };
+    }
+    if (best) {
+      byName.get(best.name).binding.blocks.push(bound);
+      continue;
+    }
+    if (overflowName === void 0) {
+      result.below.push(bound);
+      result.diagnostics.push({ code: "layout-unplaced", path: node.path, message: "No region of the layout takes this block; it is drawn below the layout's grid. Choose another layout, pin it to a region, or paginate." });
+      continue;
+    }
+    const overflow = byName.get(overflowName);
+    if (room(overflowName)) {
+      overflow.binding.blocks.push(bound);
+      continue;
+    }
+    overflow.binding.overflow.push(bound);
+    result.diagnostics.push({ code: "layout-unplaced", path: node.path, region: overflowName, message: `No region of the layout has room for this block; it is drawn in '${overflowName}' beyond its ${overflow.region.max} block${overflow.region.max === 1 ? "" : "s"}. Paginate to move it to a continuation slide, choose another layout, or remove a block.` });
+  }
+  const order = new Map(nodes.map((node, position) => [node.path, position]));
+  for (const binding of regions) binding.blocks.sort((a, b) => order.get(a.path) - order.get(b.path));
+  return result;
+}
+
+// src/template-geometry.ts
+function gridFlowShape(count, landscape) {
+  if (!Number.isInteger(count) || count < 1) return { columns: 1, rows: 0, perRow: [] };
+  let columns2;
+  if (landscape) columns2 = count <= 3 ? count : count === 4 ? 2 : count <= 6 ? 3 : 4;
+  else columns2 = count <= 3 ? 1 : count <= 6 ? 2 : Math.ceil(count / 3);
+  const rows3 = Math.ceil(count / columns2);
+  const perRow = Array.from({ length: rows3 }, (_, row) => Math.min(columns2, count - row * columns2));
+  return { columns: columns2, rows: rows3, perRow };
+}
+function flowShape(arrangement, count, landscape) {
+  if (count < 1) return { columns: 1, rows: 0, perRow: [] };
+  if (arrangement === "row") return { columns: count, rows: 1, perRow: [count] };
+  if (arrangement === "column") return { columns: 1, rows: count, perRow: Array.from({ length: count }, () => 1) };
+  return gridFlowShape(count, landscape);
+}
+function flowCells(shape, box, requestedGap) {
+  if (!shape.rows) return { cells: [], gap: requestedGap };
+  const gap = Math.max(0, Math.min(requestedGap, box.width / (shape.columns * 2), box.height / (shape.rows * 2)));
+  const width = (box.width - gap * (shape.columns - 1)) / shape.columns;
+  const height = (box.height - gap * (shape.rows - 1)) / shape.rows;
+  const cells = [];
+  shape.perRow.forEach((count, row) => {
+    const used = count * width + (count - 1) * gap, start = box.x + (box.width - used) / 2;
+    for (let column = 0; column < count; column++) cells.push({ x: count === shape.columns ? box.x + column * (width + gap) : start + column * (width + gap), y: box.y + row * (height + gap), width, height });
+  });
+  return { cells, gap };
+}
+function columnWidths(sizes, total, gap) {
+  const sum = sizes.reduce((a, b) => a + b, 0);
+  const rest = Math.max(0, total - Math.max(0, sizes.length - 1) * gap);
+  return sizes.map((size) => sum > 0 ? rest * size / sum : 0);
+}
+function collapseAreas(grid, empty2, heading, absorbs = () => true) {
+  const owner = grid.map((row) => [...row]);
+  const joined = /* @__PURE__ */ new Map();
+  const rect = (name) => {
+    let top = Infinity, left = Infinity, bottom = -1, right = -1;
+    owner.forEach((row, r) => {
+      row.forEach((cell, c) => {
+        if (cell === name) {
+          top = Math.min(top, r);
+          left = Math.min(left, c);
+          bottom = Math.max(bottom, r);
+          right = Math.max(right, c);
+        }
+      });
+    });
+    return bottom < 0 ? void 0 : { row: top, column: left, rowSpan: bottom - top + 1, columnSpan: right - left + 1 };
   };
-  visit(layout?.placeholders, 0);
-  let kind2 = "title", best = 0;
-  for (const [candidate, total] of counts) if (total > best) {
-    kind2 = candidate;
-    best = total;
+  const order = [];
+  for (const row of owner) for (const cell of row) if (cell !== "." && !order.includes(cell)) order.push(cell);
+  const pending = order.filter((name) => empty2.has(name));
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const name of pending) {
+      if (joined.has(name)) continue;
+      const own3 = rect(name);
+      if (!own3) continue;
+      const neighbour = (side) => {
+        const cells = [];
+        if (side === "start" || side === "end") {
+          const column = side === "start" ? own3.column - 1 : own3.column + own3.columnSpan;
+          if (column < 0 || column >= (owner[0]?.length ?? 0)) return void 0;
+          for (let r = own3.row; r < own3.row + own3.rowSpan; r++) cells.push(owner[r][column]);
+        } else {
+          const row = side === "above" ? own3.row - 1 : own3.row + own3.rowSpan;
+          if (row < 0 || row >= owner.length) return void 0;
+          for (let c = own3.column; c < own3.column + own3.columnSpan; c++) cells.push(owner[row][c]);
+        }
+        const candidate = cells[0];
+        if (candidate === void 0 || candidate === "." || candidate === name || cells.some((cell) => cell !== candidate)) return void 0;
+        if (empty2.has(candidate) || !absorbs(candidate)) return void 0;
+        const other = rect(candidate);
+        const fits = side === "start" || side === "end" ? other.row === own3.row && other.rowSpan === own3.rowSpan : other.column === own3.column && other.columnSpan === own3.columnSpan;
+        return fits ? candidate : void 0;
+      };
+      const sides = ["start", "end", "below", "above"];
+      let target;
+      for (const body of [true, false]) {
+        for (const side of sides) {
+          const candidate = neighbour(side);
+          if (candidate !== void 0 && heading(candidate) !== body) {
+            target = candidate;
+            break;
+          }
+        }
+        if (target !== void 0) break;
+      }
+      if (target === void 0) continue;
+      for (const row of owner) row.forEach((cell, c) => {
+        if (cell === name) row[c] = target;
+      });
+      joined.set(name, target);
+      changed = true;
+    }
   }
-  return { kind: kind2, count, heading };
+  return { grid: owner, joined };
+}
+function areaRects(grid) {
+  const rects = /* @__PURE__ */ new Map();
+  grid.forEach((row, r) => {
+    row.forEach((name, c) => {
+      if (name === ".") return;
+      const found = rects.get(name);
+      if (!found) rects.set(name, { row: r, column: c, rowSpan: 1, columnSpan: 1 });
+      else {
+        found.rowSpan = Math.max(found.rowSpan, r - found.row + 1);
+        found.columnSpan = Math.max(found.columnSpan, c - found.column + 1);
+      }
+    });
+  });
+  return rects;
+}
+function listColumnBreaks(heights, levels, count) {
+  const n = heights.length;
+  if (count <= 1 || n < 2) return [];
+  const allowed = Array.from({ length: n }, (_, index) => index > 0 && (levels[index] ?? 0) === 0);
+  const prefix = [0];
+  for (const height of heights) prefix.push(prefix.at(-1) + height);
+  const span = (from, to) => prefix[to] - prefix[from];
+  const memo = /* @__PURE__ */ new Map();
+  const solve = (start, columns2) => {
+    const key = `${start}:${columns2}`;
+    const found = memo.get(key);
+    if (found) return found;
+    let best = { cost: span(start, n), breaks: [] };
+    if (columns2 > 1) for (let next = start + 1; next < n; next++) {
+      if (!allowed[next]) continue;
+      const rest = solve(next, columns2 - 1);
+      const cost = Math.max(span(start, next), rest.cost);
+      if (cost < best.cost - 1e-9) best = { cost, breaks: [next, ...rest.breaks] };
+    }
+    memo.set(key, best);
+    return best;
+  };
+  return solve(0, count).breaks;
+}
+function allocateRows(rows3, total, gap) {
+  const auto = rows3.map((row) => row.size === "auto" ? Math.max(0, Math.min(row.need, row.kind === "below" ? total : total / 2)) : 0);
+  const visible = rows3.filter((row, index) => row.size !== "auto" || auto[index] > 0).length;
+  const headings2 = rows3.reduce((sum, row, index) => sum + (row.kind === "heading" ? auto[index] : 0), 0);
+  const space = Math.max(0, total - headings2 - Math.max(0, visible - 1) * gap);
+  const numeric = rows3.reduce((sum, row) => sum + (row.size === "auto" ? 0 : row.size), 0);
+  const numericNeed = rows3.reduce((sum, row) => sum + (row.size === "auto" ? 0 : Math.max(0, row.need)), 0);
+  const reserve = numeric > 0 ? Math.min(numericNeed, space / 2) : 0;
+  const body = rows3.reduce((sum, row, index) => sum + (row.size === "auto" && row.kind !== "heading" ? auto[index] : 0), 0);
+  const factor = body > space - reserve && body > 0 ? Math.max(0, space - reserve) / body : 1;
+  const heights = rows3.map((row, index) => row.size === "auto" ? row.kind === "heading" ? auto[index] : auto[index] * factor : 0);
+  const rest = Math.max(0, space - heights.reduce((sum, height, index) => sum + (rows3[index].kind === "heading" ? 0 : height), 0));
+  return rows3.map((row, index) => row.size === "auto" ? heights[index] : numeric > 0 ? rest * row.size / numeric : 0);
 }
 
 // src/direction.ts
@@ -2152,6 +2528,215 @@ function paragraphDirectionAt(text2, deckDirection) {
   };
 }
 
+// src/catalog-refs.ts
+var catalogKinds = ["layouts", "themes", "colorSchemes", "fontSchemes", "narratives", "audiences", "purposes", "tones"];
+var CATALOG_REFERENCE_PATTERN = /^(?:([a-z][a-z0-9-]*):)?([a-z][a-z0-9-]*)$/;
+var CATALOG_GROUP_PATTERN = /^[a-z][a-z0-9-]*$/;
+function provenanceOf(found) {
+  const { record: _record, ...provenance } = found;
+  return provenance;
+}
+var OPFCatalogsOptionError = class extends TypeError {
+  code = "invalid-catalogs";
+  constructor(entry, detail) {
+    super(`${entry}: the catalogs option must be an array of registered catalogs ({ source, <kind>: { <id>: record } } with known catalog kinds); ${detail}.`);
+    this.name = "OPFCatalogsOptionError";
+  }
+};
+function checkCatalogsOption(catalogs, entry) {
+  if (catalogs === void 0) return [];
+  if (!Array.isArray(catalogs)) throw new OPFCatalogsOptionError(entry, `got ${catalogs === null ? "null" : typeof catalogs}`);
+  catalogs.forEach((catalog, index) => {
+    if (!isRec(catalog) || typeof catalog.source !== "string") throw new OPFCatalogsOptionError(entry, `catalogs[${index}] is not an object with a string source`);
+    for (const [kind2, records] of Object.entries(catalog)) {
+      if (kind2 === "source") continue;
+      if (!catalogKinds.includes(kind2)) throw new OPFCatalogsOptionError(entry, `catalogs[${index}].${kind2} is not a catalog kind`);
+      if (!isRec(records)) throw new OPFCatalogsOptionError(entry, `catalogs[${index}].${kind2} is not an object of records keyed by id`);
+    }
+  });
+  return catalogs;
+}
+var OPFUnresolvedReferenceError = class extends Error {
+  diagnostics;
+  constructor(diagnostics) {
+    super(diagnostics.map((diagnostic) => diagnostic.message).join(" "));
+    this.name = "OPFUnresolvedReferenceError";
+    this.diagnostics = diagnostics;
+  }
+};
+var isRec = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var rec = (value) => isRec(value) ? value : {};
+var own2 = (value, key) => Object.hasOwn(value, key);
+function parseReference(reference) {
+  if (typeof reference !== "string") return void 0;
+  const match = CATALOG_REFERENCE_PATTERN.exec(reference);
+  if (!match) return void 0;
+  const [, group, id] = match;
+  return group === void 0 ? { id } : { group, id };
+}
+function groupsOf(document) {
+  return rec(rec(document).catalogs);
+}
+function catalogGroupDeclared(document, name) {
+  const groups = groupsOf(document);
+  return own2(groups, name) && (isRec(groups[name]) || name === "default" && groups[name] === false);
+}
+function catalogGroupSource(document, name, options = {}) {
+  if (name === "custom") return void 0;
+  const group = groupsOf(document)[name];
+  if (name === "default") {
+    if (group === false) return void 0;
+    const source2 = rec(group).source;
+    return typeof source2 === "string" ? source2 : options.catalogs?.[0]?.source;
+  }
+  const source = rec(group).source;
+  return typeof source === "string" ? source : void 0;
+}
+function registeredCatalog(source, options = {}) {
+  if (source === void 0) return void 0;
+  return options.catalogs?.find((catalog) => catalog?.source === source);
+}
+function lookupInGroup(document, kind2, group, id, reference, options = {}) {
+  const groups = groupsOf(document);
+  if (group === "default" && groups.default === false) return void 0;
+  if (group !== "default" && group !== "custom" && !isRec(groups[group])) return void 0;
+  const source = catalogGroupSource(document, group, options);
+  const embedded = rec(rec(groups[group])[kind2]);
+  if (own2(embedded, id) && isRec(embedded[id])) {
+    return { kind: kind2, reference, id, group, ...source !== void 0 ? { source } : {}, origin: "document", record: embedded[id] };
+  }
+  if (group === "custom") return void 0;
+  const hosted = registeredCatalog(source, options)?.[kind2];
+  if (hosted && own2(hosted, id) && isRec(hosted[id])) {
+    return { kind: kind2, reference, id, group, ...source !== void 0 ? { source } : {}, origin: "host", record: hosted[id] };
+  }
+  return void 0;
+}
+function resolveReference(document, kind2, reference, options = {}) {
+  checkCatalogsOption(options.catalogs, "resolveReference");
+  const parsed = parseReference(reference);
+  if (!parsed) return void 0;
+  const written = reference;
+  if (parsed.group !== void 0) return lookupInGroup(document, kind2, parsed.group, parsed.id, written, options);
+  const order = [...new Set([options.group, "custom", "default"].filter((group) => typeof group === "string"))];
+  for (const group of order) {
+    const found = lookupInGroup(document, kind2, group, parsed.id, written, options);
+    if (found) return found;
+  }
+  return void 0;
+}
+var KIND_NOUNS = {
+  layouts: "Layout",
+  themes: "Theme",
+  colorSchemes: "Colour scheme",
+  fontSchemes: "Font scheme",
+  narratives: "Narrative",
+  audiences: "Audience",
+  purposes: "Purpose",
+  tones: "Tone"
+};
+function unresolvedReference(document, kind2, reference, path, options = {}) {
+  const parsed = parseReference(reference);
+  const group = parsed?.group ?? "default";
+  const source = catalogGroupSource(document, group, options);
+  const noun = KIND_NOUNS[kind2];
+  const where = parsed?.group !== void 0 && !catalogGroupDeclared(document, parsed.group) ? `the document declares no catalogs.${parsed.group} group` : group === "custom" ? "it is not in catalogs.custom" : group === "default" && groupsOf(document).default === false ? "it is not in catalogs.custom and catalogs.default is false" : source === void 0 ? `it is not embedded in catalogs.${group === "default" ? "custom or catalogs.default" : group} and no catalog is registered for it` : `it is not embedded in catalogs.${group === "default" ? "custom or catalogs.default" : group} and the catalog registered for ${source} ${registeredCatalog(source, options) ? "has no such record" : "is not registered"}`;
+  const fallback = kind2 === "layouts" ? "automatic" : "engine-default";
+  return {
+    code: "unresolved-reference",
+    kind: kind2,
+    reference,
+    path,
+    group,
+    ...source !== void 0 ? { source } : {},
+    fallback,
+    message: `${noun} '${reference}' resolves nowhere: ${where}; ${fallback === "automatic" ? "the slide composes automatically" : "the engine default is used"}.`
+  };
+}
+var pushReference = (sites, kind2, value, path, group) => {
+  if (typeof value === "string" && parseReference(value)) sites.push({ kind: kind2, reference: value, path, ...group !== void 0 ? { group } : {} });
+};
+var pushObjectReference = (sites, kind2, value, path, group) => {
+  if (typeof value === "string") pushReference(sites, kind2, value, path, group);
+  else if (isRec(value)) pushReference(sites, kind2, value.id, [...path, "id"], group);
+};
+function designSites(sites, design, path) {
+  if (!isRec(design)) return;
+  pushReference(sites, "themes", design.theme, [...path, "theme"]);
+  pushObjectReference(sites, "colorSchemes", design.colorScheme, [...path, "colorScheme"]);
+  pushObjectReference(sites, "fontSchemes", design.fontScheme, [...path, "fontScheme"]);
+}
+function recordReferenceSites(kind2, record9, path, group) {
+  const sites = [];
+  if (kind2 === "themes" && isRec(record9)) {
+    pushObjectReference(sites, "colorSchemes", record9.colorScheme, [...path, "colorScheme"], group);
+    pushObjectReference(sites, "fontSchemes", record9.fontScheme, [...path, "fontScheme"], group);
+  }
+  return sites;
+}
+function catalogReferenceSites(document, options = {}) {
+  const deck = rec(document);
+  const sites = [];
+  pushReference(sites, "narratives", deck.narrative, ["narrative"]);
+  if (Array.isArray(deck.audience)) deck.audience.forEach((entry, index) => {
+    pushObjectReference(sites, "audiences", entry, ["audience", index]);
+  });
+  else pushObjectReference(sites, "audiences", deck.audience, ["audience"]);
+  pushObjectReference(sites, "purposes", deck.purpose, ["purpose"]);
+  pushObjectReference(sites, "tones", deck.tone, ["tone"]);
+  if (isRec(deck.language)) {
+    pushReference(sites, "fontSchemes", deck.language.fontScheme, ["language", "fontScheme"]);
+    pushReference(sites, "fontSchemes", deck.language.googleFontScheme, ["language", "googleFontScheme"]);
+  }
+  designSites(sites, deck.design, ["design"]);
+  if (options.slides !== false && Array.isArray(deck.slides))
+    deck.slides.forEach((slide, index) => {
+      if (!isRec(slide)) return;
+      if (slide.layout !== "auto") pushReference(sites, "layouts", slide.layout, ["slides", index, "layout"]);
+      designSites(sites, slide.design, ["slides", index, "design"]);
+    });
+  if (options.records !== false)
+    for (const [group, value] of Object.entries(groupsOf(document))) {
+      if (!isRec(value)) continue;
+      for (const kind2 of catalogKinds)
+        for (const [id, record9] of Object.entries(rec(value[kind2]))) sites.push(...recordReferenceSites(kind2, record9, ["catalogs", group, kind2, id], group));
+    }
+  return sites;
+}
+var dottedPath = (path) => path.join(".");
+var pointerPath = (path) => path.length ? `/${path.map((part) => String(part).replaceAll("~", "~0").replaceAll("/", "~1")).join("/")}` : "";
+function catalogRecords(document, kind2, options = {}) {
+  checkCatalogsOption(options.catalogs, "catalogRecords");
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (entry) => {
+    if (seen.has(entry.reference)) return;
+    seen.add(entry.reference);
+    result.push(entry);
+  };
+  const groups = groupsOf(document);
+  const names = [.../* @__PURE__ */ new Set(["custom", "default", ...Object.keys(groups)])];
+  for (const group of names) {
+    if (group === "default" && groups.default === false) continue;
+    if (group !== "custom" && group !== "default" && !isRec(groups[group])) continue;
+    const prefix = group === "custom" || group === "default" ? "" : `${group}:`;
+    for (const id of Object.keys(rec(rec(groups[group])[kind2]))) {
+      const found = lookupInGroup(document, kind2, group, id, `${prefix}${id}`, options);
+      if (found) add(found);
+    }
+    if (group === "custom") continue;
+    const hosted = registeredCatalog(catalogGroupSource(document, group, options), options)?.[kind2];
+    for (const id of Object.keys(hosted ?? {})) {
+      const found = lookupInGroup(document, kind2, group, id, `${prefix}${id}`, options);
+      if (found) add(found);
+    }
+  }
+  return result;
+}
+function embeddedCopy(record9) {
+  return Object.fromEntries(Object.entries(rec(record9)).filter(([key]) => key !== "$schema" && key !== "id" && !key.startsWith("x-")).map(([key, value]) => [key, structuredClone(value)]));
+}
+
 // src/generated/engine-data.ts
 var engineDefaultsSource = {
   "theme": {
@@ -2198,10 +2783,10 @@ var SOCIAL_PLATFORMS = engineVocabulariesSource.socialPlatforms;
 var LANGUAGES = engineVocabulariesSource.languages;
 
 // src/design-records.ts
-var isRec = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var rec = (value) => isRec(value) ? value : {};
+var isRec2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var rec2 = (value) => isRec2(value) ? value : {};
 function resolveRecordReference(document, kind2, reference, path, fallback, options, diagnostics) {
-  const object2 = isRec(reference) ? reference : void 0;
+  const object2 = isRec2(reference) ? reference : void 0;
   const id = typeof reference === "string" ? reference : typeof object2?.id === "string" ? object2.id : void 0;
   if (id === void 0) return { record: { ...fallback, ...object2 } };
   const found = resolveReference(document, kind2, id, options);
@@ -2210,27 +2795,27 @@ function resolveRecordReference(document, kind2, reference, path, fallback, opti
 }
 function resolveDesignRecords(document, slideIndex, options = {}) {
   checkCatalogsOption(options.catalogs, "resolveDesignRecords");
-  const deck = rec(document);
+  const deck = rec2(document);
   const slides = Array.isArray(deck.slides) ? deck.slides : [];
-  const own2 = slideIndex === void 0 ? {} : rec(rec(slides[slideIndex]).design);
-  const shared = rec(deck.design);
-  const design = { ...shared, ...own2 };
+  const own3 = slideIndex === void 0 ? {} : rec2(rec2(slides[slideIndex]).design);
+  const shared = rec2(deck.design);
+  const design = { ...shared, ...own3 };
   const slidePath = `slides.${slideIndex}.design`;
   const diagnostics = [];
-  const themePath = own2.theme !== void 0 ? `${slidePath}.theme` : "design.theme";
+  const themePath = own3.theme !== void 0 ? `${slidePath}.theme` : "design.theme";
   const themeFound = typeof design.theme === "string" ? resolveReference(document, "themes", design.theme, options) : void 0;
   if (typeof design.theme === "string" && !themeFound) diagnostics.push(unresolvedReference(document, "themes", design.theme, themePath, options));
   const theme = themeFound ? { ...themeFound.record } : { ...ENGINE_DEFAULT_THEME };
   const inTheme = { ...options, ...themeFound ? { group: themeFound.group } : {} };
   const inThemePath = (key) => themeFound?.origin === "document" ? `catalogs.${themeFound.group}.themes.${themeFound.id}.${key}` : themePath;
   const colorFromDesign = design.colorScheme !== void 0;
-  const colorSchemePath = own2.colorScheme !== void 0 ? `${slidePath}.colorScheme` : shared.colorScheme !== void 0 ? "design.colorScheme" : inThemePath("colorScheme");
+  const colorSchemePath = own3.colorScheme !== void 0 ? `${slidePath}.colorScheme` : shared.colorScheme !== void 0 ? "design.colorScheme" : inThemePath("colorScheme");
   const color = resolveRecordReference(document, "colorSchemes", colorFromDesign ? design.colorScheme : theme.colorScheme, colorFromDesign ? colorSchemePath : inThemePath("colorScheme"), ENGINE_DEFAULT_COLOR_SCHEME, colorFromDesign ? options : inTheme, diagnostics);
   const fontFromDesign = design.fontScheme !== void 0;
-  const fontSchemePath = own2.fontScheme !== void 0 ? `${slidePath}.fontScheme` : shared.fontScheme !== void 0 ? "design.fontScheme" : inThemePath("fontScheme");
+  const fontSchemePath = own3.fontScheme !== void 0 ? `${slidePath}.fontScheme` : shared.fontScheme !== void 0 ? "design.fontScheme" : inThemePath("fontScheme");
   const font = resolveRecordReference(document, "fontSchemes", fontFromDesign ? design.fontScheme : theme.fontScheme, fontSchemePath, ENGINE_DEFAULT_FONT_SCHEME, fontFromDesign ? options : inTheme, diagnostics);
   const fontReference = fontFromDesign ? design.fontScheme : theme.fontScheme;
-  const fontSchemeReference = typeof fontReference === "string" ? fontReference : isRec(fontReference) && typeof fontReference.id === "string" ? fontReference.id : void 0;
+  const fontSchemeReference = typeof fontReference === "string" ? fontReference : isRec2(fontReference) && typeof fontReference.id === "string" ? fontReference.id : void 0;
   const provenance = {
     ...themeFound ? { theme: provenanceOf(themeFound) } : {},
     ...color.provenance ? { colorScheme: color.provenance } : {},
@@ -2551,11 +3136,11 @@ function listNumbers(items, numbering) {
     const object2 = isObject(item) ? item : void 0;
     const level = object2?.level === void 0 ? 0 : object2.level;
     if (typeof level !== "number" || !Number.isInteger(level) || level < 0) throw new RangeError("List levels must be nonnegative integers.");
-    const own2 = object2?.start;
-    if (own2 !== void 0 && (typeof own2 !== "number" || !Number.isInteger(own2) || own2 < 1 || own2 > MAX_NUMBERING_VALUE)) throw new RangeError(`A list item start must be an integer from 1 to ${MAX_NUMBERING_VALUE}.`);
+    const own3 = object2?.start;
+    if (own3 !== void 0 && (typeof own3 !== "number" || !Number.isInteger(own3) || own3 < 1 || own3 > MAX_NUMBERING_VALUE)) throw new RangeError(`A list item start must be an integer from 1 to ${MAX_NUMBERING_VALUE}.`);
     const { style: authored, start, suffix } = numberingAtLevel(levels, level);
     const previous = counters[level];
-    const value = own2 ?? (previous === void 0 ? start : previous + 1);
+    const value = own3 ?? (previous === void 0 ? start : previous + 1);
     counters[level] = value;
     counters.length = level + 1;
     const adapted = !numberingStyleDraws(authored, value);
@@ -2720,6 +3305,7 @@ function resolveColorRoles(colorScheme, options = {}) {
     background,
     surface,
     surfaceAlt: surfaceAltColor(surface, text2),
+    border: dark ? "#475569" : "#CBD5E1",
     text: text2,
     textSecondary: keepAlpha(colorScheme.textSecondary) ?? (dark ? slot("light2", "#E2E8F0") : slot("dark2", "#334155")),
     hyperlink: readableLink(slot("hyperlink", DEFAULT_HYPERLINK), background, text2),
@@ -3624,8 +4210,8 @@ function codeSyntaxPalette(theme = {}, options = {}) {
   return palette;
 }
 function codeSyntaxPaletteForScheme(scheme, options = {}) {
-  const record7 = scheme && typeof scheme === "object" ? scheme : {};
-  const pick = (role, slot, fallback) => normalize(record7[role]) ?? normalize(record7[slot]) ?? fallback;
+  const record9 = scheme && typeof scheme === "object" ? scheme : {};
+  const pick = (role, slot, fallback) => normalize(record9[role]) ?? normalize(record9[slot]) ?? fallback;
   return codeSyntaxPalette({ primary: pick("primary", "accent1", "#2563EB"), secondary: pick("secondary", "accent2", "#0F766E"), accent: pick("accent", "accent3", "#F59E0B") }, options);
 }
 
@@ -3777,8 +4363,8 @@ var blend = (from, to, amount) => {
   return toHex(a.map((value, index) => value + (b[index] - value) * amount));
 };
 function codeHighlightColors(scheme, palette = codeSyntaxPaletteForScheme(scheme)) {
-  const record7 = scheme && typeof scheme === "object" ? scheme : {};
-  const primary = normalize(record7.primary) ?? normalize(record7.accent1) ?? "#2563EB";
+  const record9 = scheme && typeof scheme === "object" ? scheme : {};
+  const primary = normalize(record9.primary) ?? normalize(record9.accent1) ?? "#2563EB";
   const [hue, saturation] = toHsl(primary);
   const tint = fromHsl(hue, Math.min(saturation, 0.7), 0.45);
   const band = blend(CODE_PANEL_BACKGROUND, tint, CODE_HIGHLIGHT_BAND_TINT);
@@ -3975,7 +4561,7 @@ var CAPTION_FONT_RATIO = 0.6;
 var CAPTION_MAX_RATIO = 0.35;
 var FOOTNOTE_MAX_RATIO = 0.35;
 var CAPTIONABLE_FIELDS = Object.freeze(["image", "chart", "table", "video"]);
-var record5 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+var record6 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
 var isRecord3 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
 var round = (value) => Math.round(value * 1e6) / 1e6 || value;
 var regionKey = /^(top|middle|bottom|left|center|right)([+:]|$)/;
@@ -3983,7 +4569,7 @@ var TEXT_FIELDS = ["text", "items", "bullets"];
 var HEADING_FIELDS = ["tag", "title", "subtitle"];
 function annotationText(value) {
   if (typeof value === "string") return value;
-  if (Array.isArray(value)) return value.map((run) => typeof run === "string" ? run : record5(run).text ?? "").join("");
+  if (Array.isArray(value)) return value.map((run) => typeof run === "string" ? run : record6(run).text ?? "").join("");
   if (isRecord3(value) && value.text !== void 0) return annotationText(value.text);
   return value === void 0 || value === null ? "" : String(value);
 }
@@ -4015,7 +4601,7 @@ function walkCitationRuns(slide, basePath, visit) {
     });
   };
   const host = (node, path, depth) => {
-    const payload = record5(node);
+    const payload = record6(node);
     if (Array.isArray(payload.blocks)) {
       if (depth > 32) return;
       payload.blocks.forEach((block, index) => {
@@ -4030,7 +4616,7 @@ function walkCitationRuns(slide, basePath, visit) {
     }
     if (isRecord3(payload.quote)) runs(payload.quote.text, `${path}.quote.text`);
   };
-  const value = record5(slide);
+  const value = record6(slide);
   for (const field of HEADING_FIELDS) runs(value[field], `${basePath}.${field}`);
   const regions = Object.keys(value).filter((key) => regionKey.test(key)).sort();
   if (regions.length) {
@@ -4047,7 +4633,7 @@ function walkCitationRuns(slide, basePath, visit) {
 }
 var citationMarkerText = (numbers) => numbers.join(",");
 function referenceList(presentation) {
-  const list = record5(presentation).references;
+  const list = record6(presentation).references;
   return Array.isArray(list) ? list.filter((item) => isRecord3(item) && typeof item.id === "string") : [];
 }
 function numberSlide(slide, slideIndex, references, numbering) {
@@ -4080,7 +4666,7 @@ function numberSlide(slide, slideIndex, references, numbering) {
 }
 function collectCitations(presentation) {
   const references = referenceList(presentation), numbering = { notes: [], byId: /* @__PURE__ */ new Map() }, slides = /* @__PURE__ */ new Map();
-  const list = record5(presentation).slides;
+  const list = record6(presentation).slides;
   if (Array.isArray(list)) list.forEach((slide, index) => {
     const result = numberSlide(slide, index, references, numbering);
     if (result) slides.set(index, result);
@@ -4090,7 +4676,7 @@ function collectCitations(presentation) {
 }
 function slideCitations(slide, slideIndex, presentation) {
   const references = referenceList(presentation), numbering = { notes: [], byId: /* @__PURE__ */ new Map() };
-  const list = record5(presentation).slides;
+  const list = record6(presentation).slides;
   if (Array.isArray(list)) for (let index = 0; index < Math.min(slideIndex, list.length); index += 1) numberSlide(list[index], index, references, numbering);
   return numberSlide(slide, slideIndex, references, numbering);
 }
@@ -4153,12 +4739,39 @@ function referencesSlide(presentation, options = {}) {
   return { title, items };
 }
 
+// src/layout-content.ts
+var LAYOUT_BODY_KINDS = ["text", "list", "image", "video", "chart", "table", "code", "metric", "quote", "timeline"];
+var record7 = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+function layoutStructure(layout) {
+  if (!isLayoutTemplate(layout)) return "";
+  return templateAreas(layout).map((entry) => entry.region ? `${entry.name} (${entry.region.flow}: ${entry.region.accepts.join(", ")})` : entry.name).join(", ");
+}
+function layoutContent(layout) {
+  const areas = isLayoutTemplate(layout) ? templateAreas(layout) : [];
+  const regions = areas.flatMap((entry) => entry.region ? [entry.region] : []);
+  const lead = regions.find((region) => region.role === "primary") ?? regions[0];
+  const leadKind = lead?.accepts.find((kind2) => kind2 !== "group");
+  const title = areas.some((entry) => entry.name === "title");
+  return { kind: leadKind ?? "title", count: regions.length, heading: { title, subtitle: title || areas.some((entry) => entry.name === "subtitle"), tag: title } };
+}
+function templateAreas(layout) {
+  const value = record7(layout), regions = record7(value.regions);
+  const rows3 = Array.isArray(value.areas) ? value.areas.filter((row) => Array.isArray(row) && row.every((cell) => typeof cell === "string")) : [];
+  const seen = /* @__PURE__ */ new Set(), out = [];
+  for (const row of rows3) for (const name of row) {
+    if (!name || name === "." || seen.has(name)) continue;
+    seen.add(name);
+    out.push(name === "title" || name === "subtitle" || !Object.hasOwn(regions, name) ? { name } : { name, region: layoutRegion(name, regions[name]) });
+  }
+  return out;
+}
+
 // src/composition.ts
 var MAX_COMPOSITION_DEPTH = 32;
 var FALLBACK_CODE_FAMILY = "Roboto Mono";
 var DEFAULT_FONT_FAMILIES = { heading: String(ENGINE_DEFAULT_FONT_SCHEME.major), body: String(ENGINE_DEFAULT_FONT_SCHEME.minor) };
 function resolveFontFamilies(input) {
-  const scheme = record6(input);
+  const scheme = record8(input);
   const family = (value) => typeof value === "string" && value ? value : void 0;
   const accent = family(scheme.accent);
   return {
@@ -4229,12 +4842,6 @@ function translateTextFit(fit, dy) {
     }
   };
 }
-var FIELD_KINDS = { text: "text", bullets: "text", items: "list", image: "image", video: "video", chart: "chart", table: "table", code: "code", metric: "metric", quote: "quote", timeline: "timeline" };
-function chartPrimaryLayout(side, kinds) {
-  const first = side === "left" || side === "top";
-  const group = { type: "group", composition: {}, placeholders: kinds.map((type) => ({ type })) };
-  return { composition: { mode: side === "left" || side === "right" ? "row" : "column", weights: first ? [3, 2] : [2, 3] }, placeholders: first ? [{ type: "chart" }, group] : [group, { type: "chart" }] };
-}
 var OPFCompositionError = class extends Error {
   constructor(diagnostics, explanation) {
     super("Slide content does not fit its composition.");
@@ -4250,11 +4857,11 @@ var fields = ["text", "items", "bullets", "image", "video", "chart", "table", "c
 var headings = /* @__PURE__ */ new Set(["title", "subtitle", "tag"]);
 var rows2 = ["top", "middle", "bottom"];
 var columns = ["left", "center", "right"];
-var record6 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+var record8 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
 var kind = (field) => field === "items" ? "list" : field === "bullets" ? "text" : field;
 var round2 = (value) => Math.round(value * 1e6) / 1e6 || value;
 var PLACEMENT_BAND = 0.5;
-var IMAGE_EDGES = ["left", "right", "top", "bottom"];
+var IMAGE_EDGES2 = ["left", "right", "top", "bottom"];
 var IMAGE_FITS = ["cover", "contain", "stretch"];
 var BACKGROUND_FITS = ["cover", "contain", "stretch", "tile"];
 var IMAGE_SOURCE = /^(asset:|https:\/\/|data:|\.\/|\.\.\/)/;
@@ -4269,7 +4876,7 @@ var pathNumber = (value) => String(round2(value));
 var IMAGE_SHAPES = { rectangle: "rect", rounded: "roundRect", circle: "ellipse", hexagon: "hexagon" };
 var roundBox = (box) => ({ x: round2(box.x), y: round2(box.y), width: round2(box.width), height: round2(box.height) });
 var imageFocus = (value) => {
-  const focus = record6(value), x = finite(focus.x, 0, 1), y = finite(focus.y, 0, 1);
+  const focus = record8(value), x = finite(focus.x, 0, 1), y = finite(focus.y, 0, 1);
   return x !== void 0 && y !== void 0 ? { x, y } : { x: 0.5, y: 0.5 };
 };
 function imageShape(kind2, box, cornerRadius = 1 / 6) {
@@ -4310,7 +4917,7 @@ function fitImage(frame, fit, aspect, focus = { x: 0.5, y: 0.5 }) {
 }
 function imageBackground(value) {
   if (typeof value === "string") return IMAGE_SOURCE.test(value) ? { src: value, fit: "cover", focus: { x: 0.5, y: 0.5 } } : void 0;
-  const background = record6(value);
+  const background = record8(value);
   if (background.type !== "image" || typeof background.src !== "string" || !background.src) return void 0;
   const opacity = finite(background.opacity, 0, 1);
   return {
@@ -4325,13 +4932,13 @@ function imageBackground(value) {
 }
 function composeRecolor(value) {
   if (value === "grayscale") return { type: "grayscale" };
-  const duotone = record6(value);
+  const duotone = record8(value);
   return duotone.dark !== void 0 && duotone.light !== void 0 ? { type: "duotone", dark: duotone.dark, light: duotone.light } : void 0;
 }
 function composeOverlay(value, frame, shape, path, mirrorSide, diagnostics) {
-  const overlay = record6(value), opacity = finite(overlay.opacity, 0, 1);
+  const overlay = record8(value), opacity = finite(overlay.opacity, 0, 1);
   if (overlay.color === void 0 || opacity === void 0) return void 0;
-  const edge = IMAGE_EDGES.includes(overlay.edge) ? mirrorSide(overlay.edge) : void 0;
+  const edge = IMAGE_EDGES2.includes(overlay.edge) ? mirrorSide(overlay.edge) : void 0;
   if (edge && shape.kind !== "rectangle") {
     diagnostics.push({ code: "unsupported-image-treatment", path: `${path}.edge`, message: "An edge overlay needs a rectangle frame; a band cannot follow a rounded, circular or hexagonal mask as one native shape. Remove edge or use shape rectangle." });
     return void 0;
@@ -4354,7 +4961,7 @@ function composeImage(host, hostPath, region, frameArea, context) {
   const focus = imageFocus(host.focus);
   const shape = imageShape(kindName, box, finite(host.cornerRadius, 0, 0.5));
   const result = { region: roundBox(region), box, fit, focus, shape };
-  const border = record6(host.border), borderWidth = finite(border.width, 0, 64);
+  const border = record8(host.border), borderWidth = finite(border.width, 0, 64);
   if (border.color !== void 0 && borderWidth) result.border = { color: border.color, width: round2(borderWidth * scale) };
   const opacity = finite(host.opacity, 0, 1);
   if (opacity !== void 0 && opacity < 1) result.opacity = opacity;
@@ -4368,8 +4975,8 @@ function composeImage(host, hostPath, region, frameArea, context) {
   return result;
 }
 function resolveBackgroundImage(slide, presentation, themeBackground, width, height, path, mirrorSide, diagnostics) {
-  const own2 = record6(slide.design), deck = record6(record6(presentation).design);
-  const [value, at3] = own2.background !== void 0 ? [own2.background, `${path}.design.background`] : deck.background !== void 0 ? [deck.background, "design.background"] : [themeBackground, "theme"];
+  const own3 = record8(slide.design), deck = record8(record8(presentation).design);
+  const [value, at3] = own3.background !== void 0 ? [own3.background, `${path}.design.background`] : deck.background !== void 0 ? [deck.background, "design.background"] : [themeBackground, "theme"];
   const background = imageBackground(value);
   if (!background) return void 0;
   const box = { x: 0, y: 0, width, height };
@@ -4379,7 +4986,7 @@ function resolveBackgroundImage(slide, presentation, themeBackground, width, hei
   if (recolor) result.recolor = recolor;
   const overlay = composeOverlay(background.overlay, box, imageShape("rectangle", box), `${at3}.overlay`, mirrorSide, diagnostics);
   if (overlay) result.overlay = overlay;
-  const aspect = background.fit === "tile" ? void 0 : intrinsicImageAspect(background.src, record6(presentation).assets);
+  const aspect = background.fit === "tile" ? void 0 : intrinsicImageAspect(background.src, record8(presentation).assets);
   if (aspect) result.picture = fitImage(box, background.fit, aspect, background.focus);
   return result;
 }
@@ -4410,8 +5017,8 @@ function breaksInsideWord(text2, fit) {
   });
 }
 function layoutFurniture(input, options = {}) {
-  const slide = record6(input), width = options.width ?? 1280, height = options.height ?? 720, scale = Math.min(width, height) / 720;
-  const settings = { ...record6(record6(options.layout).composition), ...record6(slide.composition) };
+  const slide = record8(input), width = options.width ?? 1280, height = options.height ?? 720, scale = Math.min(width, height) / 720;
+  const settings = { ...record8(record8(options.layout).composition), ...record8(slide.composition) };
   assertComposition(settings);
   const furnitureRtl = (options.direction ?? resolveSlideDirection(options.presentation, options.slideIndex)) === "rtl";
   const minimum = snapFontSizeUp((settings.minFontSize ?? 16) * scale), size = gridFontSize(13 * scale, minimum), padding = (options.textRasterPadding ?? 2) * scale;
@@ -4423,13 +5030,13 @@ function layoutFurniture(input, options = {}) {
   if (options.date !== void 0 && (typeof options.date !== "string" || !parseIsoDate(options.date))) throw new RangeError("The furniture date option must be an ISO YYYY-MM-DD calendar date.");
   const outlines = options.textMeasurement?.outlineBounds !== void 0, parts = [], diagnostics = [];
   const sourceRoot = `slides.${options.slideIndex ?? 0}`, organizations = Array.isArray(options.presentation?.organization) ? options.presentation.organization : [options.presentation?.organization];
-  const primaryIndex = organizations.findIndex((item) => record6(item).role === "primary"), organizationIndex2 = primaryIndex >= 0 ? primaryIndex : organizations.findIndex(Boolean);
-  const organization = record6(organizations[organizationIndex2]), organizationRoot = Array.isArray(options.presentation?.organization) ? `organization.${organizationIndex2}` : "organization";
+  const primaryIndex = organizations.findIndex((item) => record8(item).role === "primary"), organizationIndex2 = primaryIndex >= 0 ? primaryIndex : organizations.findIndex(Boolean);
+  const organization = record8(organizations[organizationIndex2]), organizationRoot = Array.isArray(options.presentation?.organization) ? `organization.${organizationIndex2}` : "organization";
   const fontFamily = options.fontFamilies?.body ?? "sans-serif";
   let headerBottom = 0, footerTop = height, configured = false;
   const error = (path, message, code = "text-overflow") => diagnostics.push({ code, path, message });
   for (const kind2 of ["header", "footer"]) {
-    const local = record6(slide.design)[kind2] !== void 0, value = local ? record6(slide.design)[kind2] : options.presentation?.design?.[kind2];
+    const local = record8(slide.design)[kind2] !== void 0, value = local ? record8(slide.design)[kind2] : options.presentation?.design?.[kind2];
     if (value === void 0 || value === false) continue;
     const root = local ? `${sourceRoot}.design.${kind2}` : `design.${kind2}`;
     if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError("Header/footer content must be an object or false.");
@@ -4437,7 +5044,7 @@ function layoutFurniture(input, options = {}) {
     const zones = [];
     for (const [index, zone] of ["left", "center", "right"].entries()) {
       const side = furnitureRtl && zone !== "center" ? zone === "left" ? "right" : "left" : zone;
-      const content = record6(record6(value)[zone]), path = `${root}.${zone}`, x = width * (0.07 + (furnitureRtl ? 2 - index : index) * 0.3), zoneWidth = width * 0.26;
+      const content = record8(record8(value)[zone]), path = `${root}.${zone}`, x = width * (0.07 + (furnitureRtl ? 2 - index : index) * 0.3), zoneWidth = width * 0.26;
       const pending = [];
       const add = (field, text2, generated = false, sourcePath, extras = {}) => {
         if (text2 === void 0) return;
@@ -4446,7 +5053,7 @@ function layoutFurniture(input, options = {}) {
         pending.push({ type: "text", field, text: text2, generated, sourcePath: sourcePath ?? (!generated ? partPath : void 0), extras, partPath, style: resolveTextStyle({ fontFamily, fontWeight: 400, italic: false, path: partPath }, options.textMeasurement) });
       };
       const addImage = (source, sourcePath, reference) => {
-        const imageHeight = Math.max(32 * scale, Math.min(height * 0.05, 72 * scale)), imageWidth = Math.min(zoneWidth, imageHeight * (intrinsicImageAspect(source, record6(options.presentation).assets) ?? 1));
+        const imageHeight = Math.max(32 * scale, Math.min(height * 0.05, 72 * scale)), imageWidth = Math.min(zoneWidth, imageHeight * (intrinsicImageAspect(source, record8(options.presentation).assets) ?? 1));
         pending.push({ type: "image", sourcePath, image: source, ...reference !== void 0 ? { reference } : {}, width: imageWidth, height: imageHeight });
       };
       if (content.image !== void 0) {
@@ -4465,7 +5072,7 @@ function layoutFurniture(input, options = {}) {
         add("text", resolved.text, false, void 0, { fields: resolved.fields });
       } else add("text", content.text);
       if (content.socials === true) {
-        const links = Object.entries(record6(organization.socials)).filter(([, value2]) => typeof value2 === "string" && value2.trim()).map(([platform, value2]) => ({ platform, sourcePath: `${organizationRoot}.socials.${platform}`, ...resolveSocialProfile(platform, value2, "organization") }));
+        const links = Object.entries(record8(organization.socials)).filter(([, value2]) => typeof value2 === "string" && value2.trim()).map(([platform, value2]) => ({ platform, sourcePath: `${organizationRoot}.socials.${platform}`, ...resolveSocialProfile(platform, value2, "organization") }));
         if (links.length) add("socials", links.map((link) => link.text).join("\n"), true, `${organizationRoot}.socials`, { links });
         else error(`${path}.socials`, "Generated social profiles need a primary organization with socials.", "unresolved-content");
       }
@@ -4572,11 +5179,22 @@ function layoutFurniture(input, options = {}) {
 var textSegments = new Intl.Segmenter("und", { granularity: "grapheme" });
 var WRAP_TOLERANCE = 0.01;
 var HANGING_SPACE = /[^\S\r\n\u00a0\u202f\ufeff]/u;
+var SCRIPT_WIDTH_FACTORS = [
+  [/\p{Script=Tamil}/u, 1.53],
+  [/\p{Script=Malayalam}/u, 1.76],
+  [/\p{Script=Sinhala}/u, 1.44],
+  [/\p{Script=Myanmar}/u, 1.18],
+  [/\p{Script=Ethiopic}/u, 1.13],
+  [/\p{Script=Georgian}/u, 1.28]
+];
 function measureText(text2, fontSize) {
   let units = 0;
   for (const character of text2) {
-    if (/\p{Mark}|\u200d|\ufe0f/u.test(character)) continue;
-    units += character === " " ? 0.32 : /[A-Z0-9]/.test(character) ? 0.62 : character.codePointAt(0) > 11904 ? 1 : 0.54;
+    if (/\p{Mn}|\p{Me}|\u200d|\ufe0f/u.test(character)) continue;
+    if (/\p{Mc}/u.test(character) && /\p{Script=Latin}|\p{Script=Han}|\p{Script=Hangul}|\p{Script=Hiragana}|\p{Script=Katakana}/u.test(character)) continue;
+    const base = character === " " ? 0.32 : /[A-Z0-9]/.test(character) ? 0.62 : character.codePointAt(0) > 11904 ? 1 : 0.54;
+    const factor = SCRIPT_WIDTH_FACTORS.find(([script]) => script.test(character))?.[1] ?? 1;
+    units += base * factor;
   }
   return units * fontSize;
 }
@@ -4727,6 +5345,22 @@ function layoutQuote(value, box, options = {}) {
       photoFits = selected.photoFits;
     }
   }
+  if (body.fit && !body.fit.overflow && photoFits && (!attribution || attribution.fit && !attribution.fit.overflow)) {
+    body.box.height = body.fit.placement?.height ?? heightOf(body.fit);
+    const footerTop = body.box.y + body.box.height + 18;
+    const previousTop = Math.min(attribution?.box.y ?? Infinity, photo?.box.y ?? Infinity);
+    if (Number.isFinite(previousTop)) {
+      const shift = footerTop - previousTop;
+      if (attribution) {
+        attribution.box.y += shift;
+        attribution.fit = translateTextFit(attribution.fit, shift);
+      }
+      if (photo) {
+        photo.box.y += shift;
+        photo.shape = imageShape("circle", photo.box);
+      }
+    }
+  }
   if (hasPhoto && !photo) photoFits = false;
   for (const part of parts) {
     const area = part.box;
@@ -4746,7 +5380,11 @@ function layoutQuote(value, box, options = {}) {
     report("part-overlap", path, ["body", "footer"], "Quote body and photo overlap; do not accept this layout without more space.");
   }
   if (diagnostics.length && options.overflow === "error") throw new OPFCompositionError(diagnostics);
-  return { algorithm: "quote-flow-v1", textMeasurement: options.textMeasurement ? "provided" : "estimated", parts, ...photo ? { photo } : {}, diagnostics, overflow: diagnostics.length > 0 };
+  const occupiedParts = parts.filter((part) => part.fit).map((part) => ({ ...part.box, height: part.fit.placement?.height ?? heightOf(part.fit) }));
+  if (photo) occupiedParts.push(photo.box);
+  const bottom = Math.max(box.y, ...occupiedParts.map((area) => area.y + area.height));
+  const bounds = { x: box.x, y: box.y, width: box.width, height: bottom - box.y };
+  return { bounds, algorithm: "quote-flow-v1", textMeasurement: options.textMeasurement ? "provided" : "estimated", parts, ...photo ? { photo } : {}, diagnostics, overflow: diagnostics.length > 0 };
 }
 function layoutMetric(value, box, options = {}) {
   const scalar = typeof value === "string" || typeof value === "number";
@@ -4797,16 +5435,16 @@ function layoutMetric(value, box, options = {}) {
     let outline = null;
     for (const segment2 of line.segments) {
       if (segment2.kind !== "text") continue;
-      const bounds = measureTextOutline(part.text.slice(segment2.start, segment2.end), fit.fontSize, part.style, options.textMeasurement);
-      if (!bounds) continue;
-      const next = { ...bounds, x: segment2.x + bounds.x };
+      const bounds2 = measureTextOutline(part.text.slice(segment2.start, segment2.end), fit.fontSize, part.style, options.textMeasurement);
+      if (!bounds2) continue;
+      const next = { ...bounds2, x: segment2.x + bounds2.x };
       if (!outline) outline = next;
       else {
-        const right = Math.max(outline.x + outline.width, next.x + next.width), bottom = Math.max(outline.y + outline.height, next.y + next.height);
+        const right = Math.max(outline.x + outline.width, next.x + next.width), bottom2 = Math.max(outline.y + outline.height, next.y + next.height);
         outline.x = Math.min(outline.x, next.x);
         outline.y = Math.min(outline.y, next.y);
         outline.width = right - outline.x;
-        outline.height = bottom - outline.y;
+        outline.height = bottom2 - outline.y;
       }
     }
     return { width: line.width, y: index * fit.lineHeight, baseline: fit.fontSize + index * fit.lineHeight, height: fit.lineHeight, outline };
@@ -4916,7 +5554,9 @@ function layoutMetric(value, box, options = {}) {
     }
   }
   if (diagnostics.length && options.overflow === "error") throw new OPFCompositionError(diagnostics);
-  return { algorithm: "metric-flow-v1", alignment, textMeasurement: options.textMeasurement ? "provided" : "estimated", arrangement: selected.arrangement, ...metric.sentiment === void 0 ? {} : { sentiment: metric.sentiment }, attempts, parts, diagnostics, overflow: diagnostics.length > 0 };
+  const bottom = Math.max(box.y, ...visible.map((part) => part.box.y + occupied(part.fit)));
+  const bounds = { x: box.x, y: box.y, width: box.width, height: bottom - box.y };
+  return { bounds, algorithm: "metric-flow-v1", alignment, textMeasurement: options.textMeasurement ? "provided" : "estimated", arrangement: selected.arrangement, ...metric.sentiment === void 0 ? {} : { sentiment: metric.sentiment }, attempts, parts, diagnostics, overflow: diagnostics.length > 0 };
 }
 var TIMELINE_STATUS_VALUES = ["done", "current", "planned"];
 var TIMELINE_RING_RATIO = 1.6;
@@ -4942,9 +5582,9 @@ function layoutTimeline(value, box, options = {}) {
   add("name", timeline.name, `${path}.name`, 24, 700);
   add("description", timeline.description, `${path}.description`, 18, 400);
   timeline.events.forEach((event, index) => {
-    add("when", event.when, `${eventPath(index)}.when`, 16, 500, index);
-    add("what", event.what, `${eventPath(index)}.what`, 16, 500, index);
-    add("event-description", event.description, `${eventPath(index)}.description`, 16, 500, index);
+    add("when", event.when, `${eventPath(index)}.when`, 18, 500, index);
+    add("what", event.what, `${eventPath(index)}.what`, 22, 600, index);
+    add("event-description", event.description, `${eventPath(index)}.description`, 18, 400, index);
   });
   const metadata = [], events = timeline.events.map(() => []);
   for (const part of source) if (part.eventIndex === void 0) metadata.push(part);
@@ -4998,6 +5638,7 @@ function layoutTimeline(value, box, options = {}) {
         const accepted = { ...part, box: area, alignment, fit };
         parts.push(accepted);
         if (fit.overflow) report(accepted, "text-fit", "Timeline field exceeds its readable width; increase its space or split the timeline.");
+        if (breaksInsideWord(part.text, fit)) report(accepted, "text-fit", "Timeline field would split a word; use a wider vertical arrangement or paginate events.");
         if (area.x < box.x - 0.01 || area.y < box.y - 0.01 || area.x + area.width > box.x + box.width + 0.01 || area.y + area.height > box.y + box.height + 0.01) report(accepted, "part-outside-cell", "Timeline field extends outside its cell; increase the cell or paginate events.", Math.max(area.x + area.width - box.x - box.width, area.y + area.height - box.y - box.height));
         return accepted;
       };
@@ -5015,27 +5656,35 @@ function layoutTimeline(value, box, options = {}) {
       };
       if (arrangement === "alternating") {
         const width = box.width / Math.max(2, count), step = (box.width - width) / Math.max(1, count - 1), start = count === 1 ? box.x + box.width / 2 : box.x + width / 2;
-        const lineY = y + Math.max(scale, available) * 0.46;
+        const fieldGap = 4 * scale, clearance = 24 * scale;
+        const heights = events.map((fields2) => fields2.reduce((height, part) => height + measure(part, gridFontSize(part.requestedFontSize - reduction * scale, minimum), width, "center").height, 0) + Math.max(0, fields2.length - 1) * fieldGap);
+        const markerExtent = hasRing ? ringRadius + strokeWidth / 2 : radius;
+        const upper = Math.max(markerExtent, ...heights.filter((_, index) => index % 2 === 0).map((height) => height + clearance));
+        const lower = Math.max(markerExtent, ...heights.filter((_, index) => index % 2 === 1).map((height) => height + clearance));
+        const lineY = y + Math.max(0, (available - upper - lower) / 2) + upper;
         events.forEach((fields2, index) => {
-          const x = start + (rtl ? count - 1 - index : index) * step, top = index % 2 === 0 ? y : lineY + 24 * scale, bottom = index % 2 === 0 ? lineY - 24 * scale : box.y + box.height;
+          const x = start + (rtl ? count - 1 - index : index) * step, top = index % 2 === 0 ? lineY - clearance - heights[index] : lineY + clearance, bottom = index % 2 === 0 ? lineY - clearance : box.y + box.height;
           markers.push(marker(index, x, lineY));
           let cursor = top;
-          for (const part of fields2) {
+          for (const [fieldIndex, part] of fields2.entries()) {
             const placed = place(part, x - width / 2, cursor, width, "center");
             cursor += placed.box.height;
             if (cursor > bottom + 0.01) report(placed, "event-space", "Timeline event labels exceed their side of the connector; change the arrangement or paginate events.", cursor - bottom);
+            if (fieldIndex < fields2.length - 1) cursor += fieldGap;
           }
         });
       } else {
-        const lead = hasRing ? ringRadius + strokeWidth / 2 : radius, gap = 24 * scale + (lead - radius);
+        const outlined = timeline.events.some((event) => event.status === "planned");
+        const lead = hasRing ? ringRadius + strokeWidth / 2 : radius + (outlined ? strokeWidth / 2 : 0), gap = 2 * lead + 12 * scale;
         const x = rtl ? box.x + box.width - lead : box.x + lead, textX = rtl ? box.x : box.x + gap, width = box.width - gap;
         events.forEach((fields2, index) => {
           const top = y;
           let first2;
-          for (const part of fields2) {
+          for (const [fieldIndex, part] of fields2.entries()) {
             const placed = place(part, textX, y, width, "left");
             first2 ??= placed;
             y += placed.box.height;
+            if (fieldIndex < fields2.length - 1) y += 4 * scale;
           }
           markers.push(marker(index, x, top + Math.min(first2?.box.height ?? 2 * radius, 2 * radius) / 2));
           y += 16 * scale;
@@ -5067,19 +5716,19 @@ function fitSourceText(text2, box, size, minimum, step, measure, prose = false,
   const layout = (fontSize) => {
     const tabWidth = measure(" ", fontSize) * 4;
     if (!Number.isFinite(tabWidth) || text2.includes("	") && tabWidth <= 0) throw new RangeError("Text tabs require a positive finite measured space advance.");
-    const measureLine = (start2, end2, record7 = false) => {
+    const measureLine = (start2, end2, record9 = false) => {
       let x = 0, offset = start2;
       const segments = [];
       for (const [index, segment2] of text2.slice(start2, end2).split("	").entries()) {
         if (index) {
           const next = (Math.floor(x / tabWidth + 1e-9) + 1) * tabWidth;
-          if (record7) segments.push({ kind: "tab", start: offset, end: offset + 1, x, width: next - x });
+          if (record9) segments.push({ kind: "tab", start: offset, end: offset + 1, x, width: next - x });
           x = next;
           offset++;
         }
         if (segment2) {
           const advance = measure(segment2, fontSize);
-          if (record7) segments.push({ kind: "text", start: offset, end: offset + segment2.length, x, width: advance });
+          if (record9) segments.push({ kind: "text", start: offset, end: offset + segment2.length, x, width: advance });
           x += advance;
           offset += segment2.length;
         }
@@ -5358,7 +6007,10 @@ function richTextLayouter(input, box, requestedSize, options, minimum = 0) {
   return layout;
 }
 var PICTURE_BULLET_SCALE = 0.65;
-function fitList(input, box, requestedSize = 25, minFontSize = 16, options = { style: { fontFamily: "sans-serif", fontWeight: 400 } }) {
+function contentNominalSize(field) {
+  return field === "items" || field === "bullets" ? 32 : 25;
+}
+function fitList(input, box, requestedSize = contentNominalSize("items"), minFontSize = 16, options = { style: { fontFamily: "sans-serif", fontWeight: 400 } }) {
   if (!Array.isArray(input) || ![box.width, box.height, requestedSize, minFontSize].every((value) => Number.isFinite(value) && value > 0)) throw new RangeError("List content, dimensions and font sizes must be valid.");
   const source = input.map((value, index) => {
     const object2 = typeof value === "object" && !Array.isArray(value) ? value : void 0;
@@ -5436,12 +6088,12 @@ function fitList(input, box, requestedSize = 25, minFontSize = 16, options = { s
 function contentText(field, value) {
   if (field === "text" || headings.has(field)) return flatten(value);
   if (field === "items" || field === "bullets") return (Array.isArray(value) ? value : [value]).map((item) => {
-    const entry = record6(item);
+    const entry = record8(item);
     return `\u2022 ${flatten(item)}${entry.description ? `
 ${flatten(entry.description)}` : ""}`;
   }).join("\n");
-  if (field === "code") return flatten(record6(value).source ?? value);
-  if (field === "quote") return flatten(record6(value).text ?? value);
+  if (field === "code") return flatten(record8(value).source ?? value);
+  if (field === "quote") return flatten(record8(value).text ?? value);
   return void 0;
 }
 function layoutTable(value, box, options = {}) {
@@ -5450,6 +6102,11 @@ function layoutTable(value, box, options = {}) {
   const inline = inlineTableData(value, options.presentation);
   const grid = tableGrid(inline, options.path ?? "table");
   if (grid.issues.length) throw new RangeError(`${grid.issues[0].path}: ${grid.issues[0].message}`);
+  const numeric = new Set(grid.rows.flat().filter((cell) => !cell.header && typeof cell.value === "number" && Number.isFinite(cell.value)));
+  const numericColumns = new Set(Array.from({ length: grid.columnCount }, (_, column) => column).filter((column) => {
+    const body = grid.rows.flat().filter((cell) => !cell.header && cell.column === column && cell.value !== null && cell.value !== void 0);
+    return body.length > 0 && body.every((cell) => cell.colSpan === 1 && numeric.has(cell));
+  }));
   const formats = resolveTableData(inline).formats;
   for (const row of grid.rows) for (const cell of row) {
     if (cell.header) continue;
@@ -5461,7 +6118,9 @@ function layoutTable(value, box, options = {}) {
     const padding = { top: 8, right: 10, bottom: 4, left: 10, ...cell.style.padding };
     const width = cellWidth * cell.colSpan - (padding.left + padding.right) * scale;
     const style = { fontFamily: options.fontFamily ?? "sans-serif", fontWeight: cell.header ? 700 : 400, italic: false, path: cell.valuePath };
-    return { ...cell, padding, width, textStyle: style };
+    const numericDefault = numeric.has(cell) || cell.header && cell.colSpan === 1 && numericColumns.has(cell.column);
+    const alignment = cell.style.align ?? options.alignment ?? (numericDefault ? options.direction === "rtl" ? "left" : "right" : "left");
+    return { ...cell, padding, width, textStyle: style, alignment };
   });
   const cellMinimum = (cell) => Array.isArray(cell.value) ? richMinimum(cell.value, requested, minimum) : minimum;
   const fitCell = (cell, height, min) => {
@@ -5501,7 +6160,7 @@ function layoutTable(value, box, options = {}) {
     const offset = cell.style.verticalAlign === "bottom" ? Math.max(0, available - height) : cell.style.verticalAlign === "middle" ? Math.max(0, (available - height) / 2) : 0;
     const textBox = { x: cellBox.x + cell.padding.left * scale, y: cellBox.y + cell.padding.top * scale + offset, width: Math.max(scale, cell.width), height: Math.max(scale, available - offset) };
     overflow ||= cell.width <= 0 || available <= 0 || fit.overflow;
-    rows3[cell.row].cells.push({ value: cell.value, input: cell.input, path: cell.valuePath, sourcePath: cell.path, style: cell.style, row: cell.row, column: cell.column, rowSpan: cell.rowSpan, colSpan: cell.colSpan, header: cell.header, rich: Array.isArray(cell.value), box: cellBox, textBox, textStyle: resolveTextStyle(cell.textStyle, options.textMeasurement), fit, ...fit.directions ? { direction: fit.directions[0] } : {} });
+    rows3[cell.row].cells.push({ value: cell.value, input: cell.input, path: cell.valuePath, sourcePath: cell.path, style: cell.style, alignment: cell.alignment, row: cell.row, column: cell.column, rowSpan: cell.rowSpan, colSpan: cell.colSpan, header: cell.header, rich: Array.isArray(cell.value), box: cellBox, textBox, textStyle: resolveTextStyle(cell.textStyle, options.textMeasurement), fit, ...fit.directions ? { direction: fit.directions[0] } : {} });
   }
   return { rows: rows3, columnCount, height: sum(heights), overflow };
 }
@@ -5512,7 +6171,7 @@ function flatten(value) {
   if (value == null) return "";
   if (typeof value !== "object") return String(value);
   if (Array.isArray(value)) return value.map(flatten).join("");
-  const item = record6(value);
+  const item = record8(value);
   return flatten(item.text ?? item.value ?? item.source ?? JSON.stringify(value));
 }
 function regionParts(key) {
@@ -5567,16 +6226,43 @@ function assertComposition(value) {
   if (value.weights !== void 0 && (!Array.isArray(value.weights) || !value.weights.length || value.weights.length > 12 || value.weights.some((weight) => !Number.isFinite(weight) || weight <= 0 || weight > 100))) throw new RangeError("Invalid composition.weights.");
   if (value.overflow !== void 0 && !["warn", "error"].includes(value.overflow)) throw new RangeError("Invalid composition.overflow.");
 }
+var LAYOUT_MASTER = /* @__PURE__ */ Symbol("opf.layoutMaster");
+function mergeListColumns(columns2) {
+  const fits = columns2.map((column) => column.text), first = fits[0];
+  const directions = fits.flatMap((fit) => fit.directions ?? []);
+  return { ...first, listEntries: fits.flatMap((fit) => fit.listEntries), lines: fits.flatMap((fit) => fit.lines), height: Math.max(...fits.map((fit) => fit.height)), overflow: fits.some((fit) => fit.overflow), ...first.directions ? { directions } : {} };
+}
+function composeLayoutAreas(layout, options = {}) {
+  const template = layoutTemplate(layout), source = record8(layout);
+  const kept = { ...source, regions: Object.fromEntries(Object.entries(record8(source.regions)).map(([name, value]) => [name, { ...record8(value), empty: "keep" }])) };
+  const { mirror, bleed = true, placements = [], ...compose } = options;
+  const slide = {
+    ...template.title ? { title: "Title", subtitle: "Subtitle" } : {},
+    ...placements.length ? { blocks: placements.map((placement) => ({ image: "https://example.invalid/placeholder.png", placement: { ...placement } })) } : {},
+    ...mirror !== void 0 ? { design: { mirror } } : {}
+  };
+  const result = composeSlide(slide, { ...compose, layout: kept, [LAYOUT_MASTER]: true });
+  const areas = template.areas.map((area) => {
+    if (area.heading) {
+      const found = result.headingAreas?.find((entry) => entry.name === area.name);
+      return { name: area.name, heading: true, box: found ? { ...found.box } : { x: 0, y: 0, width: 0, height: 0 }, ...found?.parts ? { parts: found.parts } : {} };
+    }
+    const region = result.regions.find((entry) => entry.name === area.name);
+    return { name: area.name, heading: false, box: { ...!bleed && region.areaBox ? region.areaBox : region.box } };
+  });
+  return { contentBox: { ...result.contentBox }, areas };
+}
 function composeSlide(input, options = {}) {
-  const slide = record6(input), layout = record6(options.layout);
+  const slide = record8(input), layout = record8(options.layout);
   const width = options.width ?? 1280, height = options.height ?? 720;
   if (![width, height].every((value) => Number.isFinite(value) && value > 0)) throw new RangeError("Canvas dimensions must be finite and positive.");
   const scale = Math.min(width, height) / 720;
   const deckDirection = options.direction ?? resolveSlideDirection(options.presentation, options.slideIndex);
   const rtl = deckDirection === "rtl", textDirection = rtl ? "rtl" : void 0;
-  const hints = resolveDesignHints({ slide, layout, presentation: options.presentation, slideIndex: options.slideIndex, deck: { titleAlignment: options.titleAlignment, contentAlignment: options.contentAlignment, contentBox: options.contentBox } });
+  const template = isLayoutTemplate(layout) ? layoutTemplate(layout) : void 0;
+  const hints = resolveDesignHints({ slide, layout, theme: { design: options.themeDesign }, presentation: options.presentation, slideIndex: options.slideIndex, deck: { titleAlignment: options.titleAlignment, contentAlignment: options.contentAlignment, contentBox: options.contentBox } });
   const hasCards = hints.contentBox ?? false;
-  const composition = { ...record6(layout.composition), ...record6(slide.composition) };
+  const composition = { ...record8(layout.composition), ...record8(slide.composition) };
   assertComposition(composition);
   const padding = (composition.padding ?? 0.08) * Math.min(width, height);
   const gap = (composition.gap ?? 1 / 30) * Math.min(width, height);
@@ -5657,17 +6343,15 @@ function composeSlide(input, options = {}) {
   const mirrorSide = (side) => !rtl ? side : side === "left" ? "right" : side === "right" ? "left" : side;
   const backgroundImage = resolveBackgroundImage(slide, options.presentation, options.themeBackground, width, height, path, mirrorSide, imageDiagnostics);
   const regions = Object.keys(slide).filter((key) => regionParts(key)).sort();
-  const assets = record6(options.presentation).assets;
+  const assets = record8(options.presentation).assets;
   const imageContext = (placement) => ({ fit: hints.imageFit, scale, mirrorSide, diagnostics: imageDiagnostics, assets, ...placement ? { placement } : {} });
   const area = { left: 0, top: 0, right: width, bottom: height };
-  const imagePlaceholders = layoutLeaves(layout).flatMap((leaf) => leaf.type === "image" ? [{ placeholder: leaf.placeholder, path: leaf.path, depth: leaf.depth }] : []);
-  const topImages = regions.length ? [] : Array.isArray(slide.blocks) ? slide.blocks.flatMap((block, index) => !Array.isArray(record6(block).blocks) && record6(block).image !== void 0 ? [{ host: record6(block), hostPath: `${path}.blocks.${index}`, block: index }] : []) : slide.image !== void 0 ? [{ host: { type: "image", image: slide.image }, hostPath: path }] : [];
+  const topImages = regions.length ? [] : Array.isArray(slide.blocks) ? slide.blocks.flatMap((block, index) => !Array.isArray(record8(block).blocks) && record8(block).image !== void 0 ? [{ host: record8(block), hostPath: `${path}.blocks.${index}`, block: index }] : []) : slide.image !== void 0 ? [{ host: { type: "image", image: slide.image }, hostPath: path }] : [];
   const placed = [], usedEdges = /* @__PURE__ */ new Set();
-  topImages.forEach((node, order) => {
-    const slot = imagePlaceholders[order];
-    const own2 = node.block !== void 0 && node.host.placement !== void 0 ? record6(node.host.placement) : void 0;
-    const value = own2 ?? (slot?.depth === 0 && slot.placeholder.placement !== void 0 ? record6(slot.placeholder.placement) : void 0);
-    if (!value || !IMAGE_EDGES.includes(value.edge)) return;
+  topImages.forEach((node) => {
+    const own3 = node.block !== void 0 && node.host.placement !== void 0 ? record8(node.host.placement) : void 0;
+    const value = own3;
+    if (!value || !IMAGE_EDGES2.includes(value.edge)) return;
     const edge = mirrorSide(value.edge);
     if (usedEdges.has(edge)) return;
     usedEdges.add(edge);
@@ -5679,8 +6363,8 @@ function composeSlide(input, options = {}) {
     else if (edge === "right") area.right = region.x;
     else if (edge === "top") area.top += band;
     else area.bottom = region.y;
-    const placement = { edge, size, inset: value.inset === true, path: own2 ? `${node.hostPath}.placement` : `${slot.path}.placement` };
-    placed.push({ ...node, placement, region, slot: order });
+    const placement = { edge, size, inset: value.inset === true, path: `${node.hostPath}.placement` };
+    placed.push({ ...node, placement, region });
   });
   const placedBlocks = new Set(placed.flatMap((entry) => entry.block !== void 0 ? [entry.block] : []));
   const placedRoot = placed.some((entry) => entry.block === void 0);
@@ -5696,17 +6380,16 @@ function composeSlide(input, options = {}) {
     diagnostics.push(...footnotes.diagnostics);
     bodyBottom = footnotes.box.y - gap * 0.5;
   }
-  const layoutPlaceholders = Array.isArray(layout.placeholders) ? layout.placeholders : [];
   const hasLayoutRecord = options.layout !== void 0 && options.layout !== null && typeof options.layout === "object";
-  const headingOnlyLayout = layoutPlaceholders.length > 0 && layoutPlaceholders.every((placeholder) => headings.has(placeholder.type ?? "") || placeholder.type === "image" && typeof placeholder.placement === "object" && placeholder.placement !== null);
   const emptyPayload = (value) => value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0;
   const emptyHost = (host) => emptyPayload(host.blocks) && fields.every((field) => emptyPayload(host[field]));
   const flowBlocks = Array.isArray(slide.blocks) ? slide.blocks.filter((_, index) => !placedBlocks.has(index)) : slide.blocks;
-  const hasBodyPayload = regions.some((key) => !emptyHost(record6(slide[key]))) || !emptyPayload(flowBlocks) || fields.some((field) => !(placedRoot && field === "image") && !emptyPayload(slide[field]));
-  const isCover = !hasBodyPayload && (headingOnlyLayout || !hasLayoutRecord);
+  const hasBodyPayload = regions.some((key) => !emptyHost(record8(slide[key]))) || !emptyPayload(flowBlocks) || fields.some((field) => !(placedRoot && field === "image") && !emptyPayload(slide[field]));
+  const useTemplate = template !== void 0 && !regions.length;
+  const isCover = !hasBodyPayload && (useTemplate || !hasLayoutRecord);
   coverGroup = isCover;
   let logo;
-  if (isCover) {
+  if (isCover && options[LAYOUT_MASTER] !== true) {
     const resolved = resolveLogo(options.presentation, slide, { shape: "full", onDark: options.darkBackground, slideIndex: options.slideIndex });
     if (resolved) {
       const logoHeight = 56 * scale;
@@ -5717,7 +6400,7 @@ function composeSlide(input, options = {}) {
   }
   let y = logo ? logo.box.y + logo.box.height + gap : headingTop;
   const headingItems = [];
-  for (const field of ["tag", "title", "subtitle"]) {
+  for (const field of useTemplate ? [] : ["tag", "title", "subtitle"]) {
     if (!slide[field] || Array.isArray(slide[field]) && !annotationText(slide[field])) continue;
     const requested = (field === "title" ? 54 : field === "tag" ? 16 : 25) * scale;
     const maxHeight = Math.max(height * (field === "title" ? 0.26 : field === "subtitle" ? 0.12 : 0.045), minSize * 1.22 + 2 * rasterPadding);
@@ -5769,7 +6452,7 @@ function composeSlide(input, options = {}) {
   const collect = (host, basePath, depth = 0, ancestors = []) => {
     if (Array.isArray(host.blocks)) {
       if (depth >= MAX_COMPOSITION_DEPTH || ancestors.includes(host)) throw new RangeError(`Content groups must be acyclic and nest at most ${MAX_COMPOSITION_DEPTH} levels.`);
-      const settings = record6(host.composition);
+      const settings = record8(host.composition);
       assertComposition(settings);
       return [{
         field: "blocks",
@@ -5778,7 +6461,7 @@ function composeSlide(input, options = {}) {
         path: basePath,
         payload: host,
         composition: settings,
-        children: host.blocks.flatMap((block, index) => collect(record6(block), `${basePath}.blocks.${index}`, depth + 1, [...ancestors, host]))
+        children: host.blocks.flatMap((block, index) => collect(record8(block), `${basePath}.blocks.${index}`, depth + 1, [...ancestors, host]))
       }];
     }
     const captioned = host.caption !== void 0 ? fields.filter((field) => host[field] !== void 0 && CAPTIONABLE_FIELDS.includes(field)) : [];
@@ -5788,27 +6471,27 @@ function composeSlide(input, options = {}) {
       type: host.type ?? kind(field),
       value: fieldValue(field),
       path: `${basePath}.${field}`,
-      payload: field === "image" ? imagePayload(host) : { type: host.type ?? kind(field), [field]: fieldValue(field), ...host.numbering !== void 0 && (field === "items" || field === "bullets") ? { numbering: host.numbering } : {} },
+      payload: field === "image" ? imagePayload(host) : { type: host.type ?? kind(field), [field]: fieldValue(field), ...host.numbering !== void 0 && (field === "items" || field === "bullets") ? { numbering: host.numbering } : {}, ...host.columns !== void 0 && (field === "items" || field === "bullets") ? { columns: host.columns } : {} },
       ...field === "image" ? { host, hostPath: basePath } : {},
       ...captioned.length === 1 && captioned[0] === field ? { caption: host.caption, captionPath: `${basePath}.caption` } : {}
     }));
   };
   const regionsInReadingOrder = visualReadingOrder(regions.map((key) => ({ key, box: regionBox(regionParts(key), contentBox, gap) }))).map((entry) => entry.key);
-  const pending = regions.length ? regionsInReadingOrder.flatMap((key) => collect(record6(slide[key]), `${path}.${key}`).map((item) => ({ ...item, region: regionParts(key) }))) : Array.isArray(slide.blocks) ? slide.blocks.flatMap((block, index) => placedBlocks.has(index) ? [] : collect(record6(block), `${path}.blocks.${index}`)) : collect(placedRoot ? { ...slide, image: void 0 } : slide, path);
+  const pending = regions.length ? regionsInReadingOrder.flatMap((key) => collect(record8(slide[key]), `${path}.${key}`).map((item) => ({ ...item, region: regionParts(key) }))) : Array.isArray(slide.blocks) ? slide.blocks.flatMap((block, index) => placedBlocks.has(index) ? [] : collect(record8(block), `${path}.blocks.${index}`)) : collect(placedRoot ? { ...slide, image: void 0 } : slide, path);
   const groups = [], flows = [];
   const decisions = options.explain ? [] : void 0;
-  const inheritedSettings = (parent, own2 = {}) => ({
+  const inheritedSettings = (parent, own3 = {}) => ({
     minFontSize: parent.minFontSize,
-    ...own2,
-    overflow: parent.overflow === "error" ? "error" : own2.overflow ?? parent.overflow
+    ...own3,
+    overflow: parent.overflow === "error" ? "error" : own3.overflow ?? parent.overflow
   });
   const inset = (box, settings) => {
     const amount = (settings.padding ?? 0) * Math.min(box.width, box.height);
     return { x: box.x + amount, y: box.y + amount, width: box.width - amount * 2, height: box.height - amount * 2 };
   };
   const acceptedBox = (box) => ({ x: round2(box.x), y: round2(box.y), width: round2(box.width), height: round2(box.height) });
-  const payloadBox = (box) => {
-    if (!hasCards) return box;
+  const payloadBox = (box, cards = hasCards) => {
+    if (!cards) return box;
     const frame = acceptedBox(box), padding2 = Math.min(12 * scale, frame.width / 4, frame.height / 4);
     return acceptedBox({ x: frame.x + padding2, y: frame.y + padding2, width: frame.width - 2 * padding2, height: frame.height - 2 * padding2 });
   };
@@ -5867,8 +6550,8 @@ function composeSlide(input, options = {}) {
         penalties.textOverflow += internal.overflow ? 1e3 : 0;
       }
     } else if (text2) {
-      const fit = fitContent(node.field, node.value, text2, box, 25 * scale, snapFontSizeUp((settings.minFontSize ?? 16) * scale), node.path, node.payload.numbering);
-      const reduction = Math.max(0, snapFontSizeDown(25 * scale) - fit.fontSize) / scale;
+      const fit = fitContent(node.field, node.value, text2, box, contentNominalSize(node.field) * scale, snapFontSizeUp((settings.minFontSize ?? 16) * scale), node.path, node.payload.numbering);
+      const reduction = Math.max(0, snapFontSizeDown(contentNominalSize(node.field) * scale) - fit.fontSize) / scale;
       score += reduction + (fit.overflow ? 1e3 : 0);
       if (penalties) {
         penalties.fontReduction += reduction;
@@ -5892,24 +6575,13 @@ function composeSlide(input, options = {}) {
   };
   const scoreNode = (node, box, settings, penalties) => {
     if (!node.children) return leafScore(node, box, settings, penalties);
-    const own2 = inheritedSettings(settings, node.composition), area2 = inset(box, own2), slotCount = Math.max(node.children.length, node.reserved ?? 0);
-    const cols = defaultColumns(slotCount, area2, own2);
-    const boxes = gridBoxes(slotCount, area2, cols, (own2.gap ?? 1 / 30) * Math.min(box.width, box.height), own2.weights ?? [], modeFor(own2) === "column");
-    return node.children.reduce((score, child, index) => score + scoreNode(child, boxes[index], own2, penalties), 0);
+    const own3 = inheritedSettings(settings, node.composition), area2 = inset(box, own3), slotCount = Math.max(node.children.length, 0);
+    const cols = defaultColumns(slotCount, area2, own3);
+    const boxes = gridBoxes(slotCount, area2, cols, (own3.gap ?? 1 / 30) * Math.min(box.width, box.height), own3.weights ?? [], modeFor(own3) === "column");
+    return node.children.reduce((score, child, index) => score + scoreNode(child, boxes[index], own3, penalties), 0);
   };
-  const slots = [];
-  const emptySlots = (entries, boxes, settings) => entries.forEach((entry, index) => {
-    const box = boxes[index];
-    if (!box) return;
-    slots.push({ path: entry.path, type: entry.type, depth: entry.depth, box: acceptedBox(box) });
-    if (!entry.children) return;
-    const own2 = inheritedSettings(settings, record6(entry.placeholder.composition)), inner = inset(box, own2);
-    const cols = defaultColumns(entry.children.length, inner, own2);
-    const mirror = (cell) => rtl ? { ...cell, x: inner.x + inner.width - (cell.x - inner.x) - cell.width } : cell;
-    emptySlots(entry.children, gridBoxes(entry.children.length, inner, cols, (own2.gap ?? 1 / 30) * Math.min(box.width, box.height), own2.weights ?? [], modeFor(own2) === "column").map(mirror), own2);
-  });
-  const arrange = (nodes, area2, settings, reserved = 0, gapOverride, containerPath = path, recorded = true, template) => {
-    const count = Math.max(nodes.length, reserved);
+  const arrange = (nodes, area2, settings, reserved2 = 0, gapOverride, containerPath = path, recorded = true) => {
+    const count = Math.max(nodes.length, reserved2);
     if (!count) return;
     const mode = modeFor(settings), localGap = (settings.gap ?? 1 / 30) * Math.min(area2.width, area2.height);
     const actualGap = gapOverride ?? (settings === rootSettings ? gap : localGap);
@@ -5920,9 +6592,9 @@ function composeSlide(input, options = {}) {
       let best = Infinity;
       for (let candidate = 1; candidate <= Math.min(count, settings.columns ?? 6); candidate++) {
         const boxes2 = gridBoxes(count, area2, candidate, actualGap, settings.weights ?? [], false);
-        const emptySlots2 = (Math.ceil(count / candidate) * candidate - count) * 2;
-        const penalties = candidates ? { cellProportions: 0, fontReduction: 0, textOverflow: 0, tableOverflow: 0, smallCells: 0, emptySlots: emptySlots2 } : void 0;
-        const score = nodes.reduce((sum, node, i) => sum + scoreNode(node, boxes2[i], settings, penalties), 0) + emptySlots2;
+        const emptySlots = (Math.ceil(count / candidate) * candidate - count) * 2;
+        const penalties = candidates ? { cellProportions: 0, fontReduction: 0, textOverflow: 0, tableOverflow: 0, smallCells: 0, emptySlots } : void 0;
+        const score = nodes.reduce((sum, node, i) => sum + scoreNode(node, boxes2[i], settings, penalties), 0) + emptySlots;
         if (penalties && candidates) candidates.push({ columns: candidate, rows: Math.ceil(count / candidate), score, penalties });
         if (score < best) {
           best = score;
@@ -5940,114 +6612,387 @@ function composeSlide(input, options = {}) {
     const grid = gridGeometry(count, area2, cols, actualGap, settings.weights ?? [], mode === "column");
     const mirrored = (box) => rtl ? { ...box, x: area2.x + area2.width - (box.x - area2.x) - box.width } : box;
     const boxes = grid.boxes.map(mirrored);
-    if (template) emptySlots(template.slice(nodes.length), boxes.slice(nodes.length), settings);
     if (recorded && !hasRegions) flows.push({ path: containerPath, box: { ...area2 }, composition: { ...settings }, columns: rtl ? grid.columns.map((track) => ({ offset: area2.width - track.offset - track.size, size: track.size })) : grid.columns, rows: grid.rows, gap: grid.gap, itemCount: nodes.length, slotCount: count });
     nodes.forEach((node, index) => {
-      let box = node.region ? mirrored(regionBox(node.region, area2, actualGap)) : boxes[index];
-      if (node.slot) slots.push({ path: node.slot.path, type: node.slot.type, depth: node.slot.depth, box: acceptedBox(box), ...node.slot.children ? {} : { content: node.path } });
-      if (node.children) {
-        const own2 = inheritedSettings(settings, node.composition), inner = inset(box, own2);
-        if (!node.synthetic) groups.push({ path: node.path, box, contentBox: inner, composition: own2 });
-        arrange(node.children, inner, own2, node.reserved ?? 0, (own2.gap ?? 1 / 30) * Math.min(box.width, box.height), node.path, !node.synthetic, node.slots);
-      } else {
-        const frameBox = hasCards ? acceptedBox(box) : void 0;
-        box = payloadBox(box);
-        const caption = captionOf(node, box);
-        if (caption) {
-          box = caption.mediaBox;
-          diagnostics.push(...caption.diagnostics);
+      const box = node.region ? mirrored(regionBox(node.region, area2, actualGap)) : boxes[index];
+      placeNode(node, box, settings);
+    });
+  };
+  let regionTag, templateCell = false;
+  const placeNode = (node, box, settings, cards = hasCards, listColumns, metricReferenceHeight) => {
+    if (node.children) {
+      const own3 = inheritedSettings(settings, node.composition), inner = inset(box, own3);
+      if (!node.synthetic) groups.push({ path: node.path, box, contentBox: inner, composition: own3 });
+      arrange(node.children, inner, own3, 0, (own3.gap ?? 1 / 30) * Math.min(box.width, box.height), node.path, !node.synthetic);
+      return;
+    }
+    const frameBox = cards ? acceptedBox(box) : void 0;
+    const metricHeight = metricReferenceHeight === void 0 ? void 0 : payloadBox({ ...box, height: metricReferenceHeight }, cards).height;
+    box = payloadBox(box, cards);
+    const caption = captionOf(node, box);
+    if (caption) {
+      box = caption.mediaBox;
+      diagnostics.push(...caption.diagnostics);
+    }
+    const textValue = contentText(node.field, node.value);
+    const quoteLayout = node.field === "quote" ? measureQuote(node, box, settings) : void 0;
+    const codeLayout = node.field === "code" ? measureCode(node, box, settings) : void 0;
+    const metricLayout = node.field === "metric" ? measureMetric(node, { ...box, height: metricHeight ?? box.height }, settings) : void 0;
+    const timelineLayout = node.field === "timeline" ? measureTimeline(node, box, settings) : void 0;
+    const internal = quoteLayout ?? codeLayout ?? metricLayout ?? timelineLayout, body = internal?.parts.find((part) => part.role === "body" || part.role === "value");
+    const columns2 = textValue !== void 0 && !internal ? listColumnsFor(node, box, settings, listColumns) : void 0;
+    const text2 = internal ? body?.fit : columns2 ? columns2.length > 1 ? mergeListColumns(columns2) : columns2[0].text : textValue !== void 0 ? fitContent(node.field, node.value, textValue, box, contentNominalSize(node.field) * scale, snapFontSizeUp((settings.minFontSize ?? 16) * scale), node.path, node.payload.numbering) : void 0;
+    const image = node.field === "image" ? composeImage(node.host ?? {}, node.hostPath ?? node.path, box, box, imageContext()) : void 0;
+    items.push({
+      path: node.path,
+      field: node.field,
+      type: node.type,
+      value: node.value,
+      payload: node.payload,
+      box: internal ? acceptedBox(box) : box,
+      ...image ? { image } : {},
+      ...frameBox ? { frameBox } : {},
+      text: text2,
+      textStyle: body?.style ?? styleFor(node.field, node.path),
+      composition: settings,
+      alignment: alignmentFor(node.field),
+      ...quoteLayout ? { quoteLayout } : {},
+      ...codeLayout ? { codeLayout } : {},
+      ...metricLayout ? { metricLayout } : {},
+      ...timelineLayout ? { timelineLayout } : {},
+      ...bulletImage && node.payload.numbering === void 0 && (node.field === "items" || node.field === "bullets") ? { bulletImage } : {},
+      ...caption ? { caption } : {},
+      ...regionTag !== void 0 ? { region: regionTag } : {},
+      ...columns2 && columns2.length > 1 ? { listColumns: columns2 } : {}
+    });
+    if (box.width < 100 * scale || !templateCell && box.height < 60 * scale) diagnostics.push({ code: "small-cell", path: node.path, message: "Content cell is too small for comfortable reading; use fewer blocks or a different composition." });
+  };
+  const listColumnsFor = (node, box, settings, regionMode) => {
+    if (node.field !== "items" && node.field !== "bullets") return void 0;
+    const values = node.value;
+    if (!Array.isArray(values) || values.length < 2) return void 0;
+    const own3 = node.payload.columns;
+    const mode = own3 === "auto" || own3 === 1 || own3 === 2 || own3 === 3 ? own3 : regionMode;
+    if (mode === void 0 || mode === 1) return void 0;
+    const start = contentNominalSize(node.field) * scale, floor = snapFontSizeUp((settings.minFontSize ?? 16) * scale);
+    const numbering = node.payload.numbering;
+    const listOptions = { ...richOptions(styleFor(node.field, node.path)), ...numbering !== void 0 ? { numbering } : bulletImage ? { bulletImage } : {} };
+    const columnGap = (count2) => Math.min(gap, box.width / (count2 * 2));
+    const columnBoxes = (count2) => {
+      const between = columnGap(count2), columnWidth = (box.width - between * (count2 - 1)) / count2;
+      const ordered = Array.from({ length: count2 }, (_, index) => ({ x: box.x + index * (columnWidth + between), y: box.y, width: columnWidth, height: box.height }));
+      return rtl ? ordered.map((cell) => ({ ...cell, x: box.x + box.width - (cell.x - box.x) - cell.width })) : ordered;
+    };
+    const chunk = (from, to) => numbering !== void 0 ? sliceNumberedItems(values, numbering, from, to) : values.slice(from, to);
+    const sourcePaths = (index) => {
+      const source = values[index], object2 = source !== null && typeof source === "object" && !Array.isArray(source);
+      return { textPath: `${node.path}.${index}${object2 ? ".text" : ""}`, descriptionPath: `${node.path}.${index}.description` };
+    };
+    const renumber = (fit, from) => ({ ...fit, listEntries: fit.listEntries.map((entry) => ({ ...entry, index: entry.index + from, ...sourcePaths(entry.index + from) })) });
+    const split = (count2, size2, minimum) => {
+      const boxes = columnBoxes(count2);
+      const whole = fitList(values, { ...boxes[0], height: 1e6 }, start, start, listOptions);
+      const first = whole.listEntries[0].textBox.y;
+      const heights = whole.listEntries.map((entry, index) => (whole.listEntries[index + 1]?.textBox.y ?? first + whole.height) - entry.textBox.y);
+      const breaks = [0, ...listColumnBreaks(heights, whole.listEntries.map((entry) => entry.level), count2), values.length];
+      return boxes.slice(0, breaks.length - 1).map((cell, index) => ({ box: cell, start: breaks[index], end: breaks[index + 1], text: renumber(fitList(chunk(breaks[index], breaks[index + 1]), cell, size2, minimum, listOptions), breaks[index]) }));
+    };
+    const quarter = width / 4;
+    const counts = typeof mode === "number" ? [mode] : [2, 3].filter((count2) => (box.width - columnGap(count2) * (count2 - 1)) / count2 >= quarter);
+    if (mode === "auto") {
+      if (!fitList(values, box, start, start, listOptions).overflow) return void 0;
+      for (const count2 of counts) {
+        const columns2 = split(count2, start, start);
+        if (columns2.every((column) => !column.text.overflow)) return columns2;
+      }
+    }
+    const count = counts.at(-1);
+    if (count === void 0) return void 0;
+    const shrunk = split(count, start, floor);
+    const size = Math.min(...shrunk.map((column) => column.text.fontSize));
+    return shrunk.map((column) => ({ ...column, text: renumber(fitList(chunk(column.start, column.end), column.box, size, size, listOptions), column.start) }));
+  };
+  const LONG_LINES = 6, LONG_CODE_LINES = 12, startSize = 25 * scale;
+  const estimatedLines = (value, cellWidth, size) => flatten(value).split("\n").reduce((sum, paragraph) => sum + Math.max(1, wrapText(paragraph, Math.max(1, cellWidth), size).length), 0);
+  const isLong = (node, cellWidth) => {
+    if (node.children) return node.children.some((child) => isLong(child, cellWidth));
+    if (node.field === "text") return estimatedLines(node.value, cellWidth, startSize) > LONG_LINES;
+    if (node.field === "items" || node.field === "bullets") {
+      const listSize = contentNominalSize(node.field) * scale;
+      let lines = 0;
+      for (const entry of Array.isArray(node.value) ? node.value : []) {
+        const object2 = entry !== null && typeof entry === "object" && !Array.isArray(entry) ? entry : void 0;
+        const indent = listSize * 1.1 * (1 + (typeof object2?.level === "number" ? object2.level : 0));
+        lines += estimatedLines(object2 ? object2.text : entry, cellWidth - indent, listSize);
+        if (object2?.description !== void 0) lines += estimatedLines(object2.description, cellWidth - indent, listSize * 0.82);
+      }
+      return lines > LONG_LINES;
+    }
+    if (node.field === "quote") return estimatedLines(typeof node.value === "string" ? node.value : record8(node.value).text, cellWidth, startSize) > LONG_LINES;
+    if (node.field === "table") {
+      const value = record8(node.value);
+      return (Array.isArray(value.rows) ? value.rows.length + (Array.isArray(value.columns) ? 1 : 0) : 0) > LONG_LINES;
+    }
+    if (node.field === "code") return String(typeof node.value === "string" ? node.value : record8(node.value).source ?? "").split("\n").length > LONG_CODE_LINES;
+    return false;
+  };
+  const naturalHeight = (node, cellWidth, cards, metricReferenceHeight, naturalSettings = composition) => {
+    const pad = cards ? 2 * Math.min(12 * scale, cellWidth / 4) : 0, inner = Math.max(scale, cellWidth - pad);
+    if (node.children) return node.children.reduce((sum, child) => sum + naturalHeight(child, cellWidth, false), 0) + gap * Math.max(0, node.children.length - 1) + pad;
+    let content;
+    if (node.field === "text" || node.field === "items" || node.field === "bullets") {
+      const size = contentNominalSize(node.field) * scale;
+      const fit = fitContent(node.field, node.value, contentText(node.field, node.value) ?? "", { x: 0, y: 0, width: inner, height: 1e6 }, size, size, node.path, node.payload.numbering);
+      content = "height" in fit && typeof fit.height === "number" ? fit.height : fit.lines.length * fit.lineHeight;
+    } else if (node.field === "quote") content = measureQuote(node, { x: 0, y: 0, width: inner, height: 1e6 }, naturalSettings).bounds.height + 18;
+    else if (node.field === "code") content = String(typeof node.value === "string" ? node.value : record8(node.value).source ?? "").split("\n").length * 18 * 1.4 * scale + 24 * scale;
+    else if (node.field === "metric") content = measureMetric(node, { x: 0, y: 0, width: inner, height: metricReferenceHeight === void 0 ? 1e6 : Math.max(scale, metricReferenceHeight - pad) }, naturalSettings).bounds.height;
+    else if (node.field === "timeline") content = 170 * scale;
+    else if (node.field === "table") {
+      const value = record8(node.value);
+      content = ((Array.isArray(value.rows) ? value.rows.length : 4) + 1) * 36 * scale;
+    } else content = inner / 1.6;
+    return content + (node.caption !== void 0 ? 32 * scale : 0) + pad;
+  };
+  const templateRegions = [], headingAreas = [];
+  const requestedTemplateGap = gap;
+  const composeTemplate = () => {
+    const plan2 = template, frame = contentBox;
+    const binding = bindRegions(slide, layout, { slideIndex: options.slideIndex ?? 0 });
+    for (const entry of binding.diagnostics) diagnostics.push({ code: entry.code, path: entry.path, message: entry.message, ...entry.region !== void 0 ? { region: entry.region } : {} });
+    const unitOf = (bound) => {
+      const host = bound.block !== void 0 ? record8(slide.blocks[bound.block]) : { ...Object.fromEntries((bound.fields ?? []).map((field) => [field, slide[field]])), ...Object.fromEntries(["type", "caption", "numbering"].filter((key) => slide[key] !== void 0).map((key) => [key, slide[key]])) };
+      const parts = collect(host, bound.block !== void 0 ? `${path}.blocks.${bound.block}` : path);
+      return parts.length === 1 ? parts[0] : { field: "blocks", type: "group", value: parts.map((part) => part.payload), path: bound.path, payload: {}, children: parts, composition: { mode: "column" }, synthetic: true };
+    };
+    const contents = new Map(binding.regions.map((entry) => [entry.name, [...entry.blocks, ...entry.overflow].map(unitOf)]));
+    const BELOW = "(below)";
+    const belowUnits = binding.below.map(unitOf);
+    const belowRegion = { name: BELOW, accepts: [], role: "supporting", flow: "auto", max: belowUnits.length, bleed: false, listColumns: 1, anchor: "top", empty: "collapse" };
+    const unitsOf = (name) => name === BELOW ? belowUnits : contents.get(name) ?? [];
+    const shown = (field) => !!slide[field] && !(Array.isArray(slide[field]) && !annotationText(slide[field]));
+    const titleFields = ["tag", "title", ...plan2.subtitle ? [] : ["subtitle"]].filter(shown);
+    const subtitleFields = plan2.subtitle && shown("subtitle") ? ["subtitle"] : [];
+    const columnCount = plan2.columns.length;
+    const cells = plan2.grid.map((row) => [...row]);
+    const rowSizes = [...plan2.rows];
+    const implicitTitle = !plan2.title && titleFields.length > 0;
+    if (implicitTitle) {
+      cells.unshift(Array.from({ length: columnCount }, () => "title"));
+      rowSizes.unshift("auto");
+    }
+    if (belowUnits.length) {
+      cells.push(Array.from({ length: columnCount }, () => BELOW));
+      rowSizes.push("auto");
+    }
+    const gap2 = Math.max(0, Math.min(requestedTemplateGap, frame.width / (columnCount * 2), frame.height / (rowSizes.length * 2)));
+    const regionOf = new Map(plan2.regions.map((region) => [region.name, region]));
+    const empty2 = /* @__PURE__ */ new Set();
+    for (const region of plan2.regions) if (!unitsOf(region.name).length && region.empty !== "keep") empty2.add(region.name);
+    if (plan2.title && !titleFields.length) empty2.add("title");
+    if (plan2.subtitle && !subtitleFields.length) empty2.add("subtitle");
+    const collapsed = collapseAreas(cells, empty2, (name) => name === "title" || name === "subtitle", (name) => name !== BELOW);
+    const rects = areaRects(collapsed.grid), ownRects = areaRects(cells);
+    const widths = columnWidths(plan2.columns, frame.width, gap2);
+    const columnX = [];
+    widths.reduce((x, size) => {
+      columnX.push(x);
+      return x + size + gap2;
+    }, 0);
+    const spanWidth = (rect) => widths.slice(rect.column, rect.column + rect.columnSpan).reduce((a, b) => a + b, 0) + gap2 * (rect.columnSpan - 1);
+    const headingItemsAt = (fields2, x, y2, areaWidth) => {
+      const list = [];
+      let top = y2;
+      for (const field of fields2) {
+        const requested = (field === "title" ? 54 : field === "tag" ? 16 : 25) * scale;
+        const maxHeight = Math.max(height * (field === "title" ? 0.26 : field === "subtitle" ? 0.12 : 0.045), minSize * 1.22 + 2 * rasterPadding);
+        const box = { x, y: top, width: areaWidth, height: maxHeight };
+        const text2 = fitPlacedText(field, slide[field], annotationText(slide[field]), box, requested, minSize, `${path}.${field}`);
+        box.height = Math.min(maxHeight, Math.max("richLines" in text2 ? text2.height : text2.lines.length * text2.lineHeight, text2.placement?.height ?? 0));
+        list.push({ path: `${path}.${field}`, field, type: "text", value: slide[field], payload: { text: slide[field] }, box, text: text2, textStyle: styleFor(field, `${path}.${field}`), composition, alignment: alignmentFor(field) });
+        top += box.height + gap2 * 0.5;
+      }
+      return list;
+    };
+    const groupHeight = (list) => list.length ? list.at(-1).box.y + list.at(-1).box.height - list[0].box.y : 0;
+    const arrangementOf = (region, units, cell) => {
+      if (direction !== void 0 && region.flow !== "none") return direction === "horizontal" ? "row" : "column";
+      const flow = region.flow === "none" && units.length > 1 ? "auto" : region.flow;
+      if (flow === "none" || flow === "column") return "column";
+      if (flow === "grid") return "grid";
+      const shape = gridFlowShape(units.length, cell.width >= cell.height);
+      const cards = hasCards && !region.bleed;
+      const cellWidth = (cell.width - gap2 * (shape.columns - 1)) / shape.columns - (cards ? 2 * Math.min(12 * scale, cell.width / 4) : 0);
+      return units.some((unit) => isLong(unit, cellWidth)) ? "column" : "grid";
+    };
+    const regionNeed = (name, areaWidth) => {
+      const units = unitsOf(name), region = name === BELOW ? belowRegion : regionOf.get(name);
+      if (!units.length) return region.empty === "keep" ? 2 * startSize * 1.22 + (hasCards && !region.bleed ? 2 * Math.min(12 * scale, areaWidth / 4) : 0) : 0;
+      const shape = flowShape(arrangementOf(region, units, { width: areaWidth, height: areaWidth / 4 }), units.length, true);
+      const cellWidth = (areaWidth - gap2 * (shape.columns - 1)) / shape.columns, cards = hasCards && !region.bleed;
+      let total = 0, index = 0;
+      for (const count of shape.perRow) {
+        let row = 0;
+        for (let k = 0; k < count; k++) row = Math.max(row, naturalHeight(units[index++], cellWidth, cards));
+        total += row;
+      }
+      return total + gap2 * Math.max(0, shape.rows - 1);
+    };
+    const areaNeed = (name, rect) => name === "title" ? groupHeight(headingItemsAt(titleFields, 0, 0, spanWidth(rect))) : name === "subtitle" ? groupHeight(headingItemsAt(subtitleFields, 0, 0, spanWidth(rect))) : regionNeed(name, spanWidth(rect));
+    const demands = rowSizes.map((size, row) => {
+      let need = 0, heading = false, below = false;
+      for (const [name, rect] of rects) {
+        if (size === "auto" ? rect.row !== row || rect.rowSpan !== 1 : row < rect.row || row >= rect.row + rect.rowSpan) continue;
+        if (size !== "auto" && rect.rowSpan > 1 && rowSizes.slice(rect.row, rect.row + rect.rowSpan).some((entry) => entry === "auto")) continue;
+        const value = areaNeed(name, rect) / rect.rowSpan;
+        if (value > need) {
+          need = value;
+          heading = name === "title" || name === "subtitle";
+          below = name === BELOW;
         }
-        const textValue = contentText(node.field, node.value);
-        const quoteLayout = node.field === "quote" ? measureQuote(node, box, settings) : void 0;
-        const codeLayout = node.field === "code" ? measureCode(node, box, settings) : void 0;
-        const metricLayout = node.field === "metric" ? measureMetric(node, box, settings) : void 0;
-        const timelineLayout = node.field === "timeline" ? measureTimeline(node, box, settings) : void 0;
-        const internal = quoteLayout ?? codeLayout ?? metricLayout ?? timelineLayout, body = internal?.parts.find((part) => part.role === "body" || part.role === "value");
-        const text2 = internal ? body?.fit : textValue !== void 0 ? fitContent(node.field, node.value, textValue, box, 25 * scale, snapFontSizeUp((settings.minFontSize ?? 16) * scale), node.path, node.payload.numbering) : void 0;
-        const image = node.field === "image" ? composeImage(node.host ?? {}, node.hostPath ?? node.path, box, box, imageContext()) : void 0;
-        items.push({
-          path: node.path,
-          field: node.field,
-          type: node.type,
-          value: node.value,
-          payload: node.payload,
-          box: internal ? acceptedBox(box) : box,
-          ...image ? { image } : {},
-          ...frameBox ? { frameBox } : {},
-          text: text2,
-          textStyle: body?.style ?? styleFor(node.field, node.path),
-          composition: settings,
-          alignment: alignmentFor(node.field),
-          ...quoteLayout ? { quoteLayout } : {},
-          ...codeLayout ? { codeLayout } : {},
-          ...metricLayout ? { metricLayout } : {},
-          ...timelineLayout ? { timelineLayout } : {},
-          ...bulletImage && node.payload.numbering === void 0 && (node.field === "items" || node.field === "bullets") ? { bulletImage } : {},
-          ...caption ? { caption } : {}
-        });
-        if (box.width < 100 * scale || box.height < 60 * scale) diagnostics.push({ code: "small-cell", path: node.path, message: "Content cell is too small for comfortable reading; use fewer blocks or a different composition." });
       }
+      return { size, need, kind: heading ? "heading" : below ? "below" : "body" };
     });
+    const heights = allocateRows(demands, frame.height, gap2);
+    const rowY = [];
+    heights.reduce((y2, size, row) => {
+      rowY.push(size > 0 || !heights.slice(0, row).some((above) => above > 0) ? y2 : y2 - gap2);
+      return size > 0 ? y2 + size + gap2 : y2;
+    }, 0);
+    const logical = (rect) => {
+      const last = rect.row + rect.rowSpan - 1, y2 = frame.y + rowY[rect.row];
+      return { x: frame.x + columnX[rect.column], y: y2, width: spanWidth(rect), height: Math.max(0, frame.y + rowY[last] + heights[last] - y2) };
+    };
+    const flip = hints.mirror === true !== rtl;
+    const physical = (cell) => flip ? { ...cell, x: frame.x + frame.width - (cell.x - frame.x) - cell.width } : cell;
+    const bleed = (cell) => {
+      const near = (a, b) => Math.abs(a - b) < 0.01;
+      const left = near(cell.x, frame.x) ? area.left : cell.x, top = near(cell.y, frame.y) ? area.top : cell.y;
+      const right = near(cell.x + cell.width, frame.x + frame.width) ? area.right : cell.x + cell.width;
+      const bottom = near(cell.y + cell.height, frame.y + frame.height) ? area.bottom : cell.y + cell.height;
+      return { x: left, y: top, width: right - left, height: bottom - top };
+    };
+    const placeHeadings = (name, fields2) => {
+      const rect = rects.get(name), original = ownRects.get(name);
+      if (!rect) {
+        if (original) headingAreas.push({ name, box: roundBox(physical(logical(original))), collapsed: true });
+        return;
+      }
+      const cell = physical(logical(rect));
+      const list = headingItemsAt(fields2, cell.x, cell.y, cell.width);
+      const centred = !rowSizes.slice(rect.row, rect.row + rect.rowSpan).every((size) => size === "auto");
+      const shift = centred ? Math.max(0, (cell.height - groupHeight(list)) / 2) : 0;
+      for (const item of list) {
+        if (shift) {
+          item.box.y += shift;
+          if (item.text) item.text = translateTextFit(item.text, shift);
+        }
+        if (furniture && item.box.y + item.box.height > bodyBottom + 0.01) diagnostics.push({ code: "text-overflow", path: item.path, message: "Repeated furniture leaves too little room for this heading. Change the header/footer or slide design." });
+        items.push(item);
+      }
+      let parts;
+      const upper = list.filter((item) => item.field !== "subtitle"), lower = list.find((item) => item.field === "subtitle");
+      if (name === "title" && !plan2.subtitle && list.length) {
+        const bottom = cell.y + cell.height, last = upper.at(-1);
+        const split = Math.min(bottom, lower ? lower.box.y : last.box.y + last.box.height + gap2 * 0.5);
+        const titleBottom = Math.max(cell.y, last ? last.box.y + last.box.height : split - gap2 * 0.5);
+        parts = { title: roundBox({ x: cell.x, y: cell.y, width: cell.width, height: titleBottom - cell.y }), subtitle: roundBox({ x: cell.x, y: split, width: cell.width, height: Math.max(0, bottom - split) }) };
+      }
+      headingAreas.push({ name, box: roundBox(cell), ...name === "title" && implicitTitle ? { implicit: true } : {}, ...parts ? { parts } : {} });
+    };
+    placeHeadings("title", titleFields);
+    if (plan2.subtitle) placeHeadings("subtitle", subtitleFields);
+    const slideComposition = record8(slide.composition);
+    const overridden = ["mode", "columns", "weights"].some((key) => slideComposition[key] !== void 0) ? plan2.regions.find((region) => region.role === "primary" && region.flow !== "none")?.name : void 0;
+    const settings = { ...composition };
+    const placeRegion = (region, units, area2) => {
+      regionTag = region.name === BELOW ? void 0 : region.name;
+      const cell = { ...area2, width: Math.max(scale, area2.width), height: Math.max(scale, area2.height) };
+      templateCell = true;
+      try {
+        const cards = hasCards && !region.bleed;
+        if (region.name === overridden) {
+          arrange(units, cell, { ...settings, mode: slideComposition.mode ?? "auto" }, 0, gap2, path, true);
+          return "composition";
+        }
+        const arrangement = arrangementOf(region, units, cell);
+        let boxes = flowCells(flowShape(arrangement, units.length, cell.width >= cell.height), cell, gap2).cells;
+        const referenceHeights = boxes.map((box) => box.height);
+        if (arrangement === "column" && region.anchor !== "top" && units.every((unit) => !unit.children && (unit.field === "text" || unit.field === "items" || unit.field === "bullets" || !unit.caption && (unit.field === "quote" || unit.field === "metric")))) {
+          const naturals = units.map((unit, index) => naturalHeight(unit, cell.width, cards, referenceHeights[index], settings) + 2 * rasterPadding + scale);
+          const used = naturals.reduce((a, b) => a + b, 0) + gap2 * (units.length - 1);
+          if (used < cell.height) {
+            let y2 = cell.y + (region.anchor === "middle" ? (cell.height - used) / 2 : cell.height - used);
+            boxes = naturals.map((size) => {
+              const next = { x: cell.x, y: y2, width: cell.width, height: size };
+              y2 += size + gap2;
+              return next;
+            });
+          }
+        }
+        if ((arrangement === "grid" || arrangement === "row") && region.anchor !== "top") {
+          const naturals = boxes.map((box, index) => {
+            const unit = units[index];
+            return unit.children || unit.caption || !["text", "items", "bullets", "quote", "metric"].includes(unit.field) ? void 0 : naturalHeight(unit, box.width, cards, referenceHeights[index], settings) + 2 * rasterPadding + scale;
+          });
+          boxes = boxes.map((box, index) => {
+            const height2 = naturals[index];
+            if (height2 === void 0 || height2 >= box.height) return box;
+            const rowHeight = Math.max(...boxes.flatMap((peer, peerIndex) => peer.y === box.y && naturals[peerIndex] !== void 0 ? [naturals[peerIndex]] : []));
+            const spare = Math.max(0, box.height - rowHeight);
+            return { ...box, y: box.y + (region.anchor === "middle" ? spare / 2 : spare), height: height2 };
+          });
+        }
+        if (rtl) boxes = boxes.map((box) => ({ ...box, x: cell.x + cell.width - (box.x - cell.x) - box.width }));
+        units.forEach((unit, index) => {
+          placeNode(unit, boxes[index], settings, cards, region.listColumns, region.anchor === "top" ? void 0 : referenceHeights[index]);
+        });
+        return arrangement;
+      } finally {
+        regionTag = void 0;
+        templateCell = false;
+      }
+    };
+    for (const region of plan2.regions) {
+      const units = unitsOf(region.name), bound = binding.regions.find((entry) => entry.name === region.name);
+      const rect = rects.get(region.name);
+      let cell = physical(logical(rect ?? ownRects.get(region.name)));
+      const areaBox = region.bleed && rect ? roundBox(cell) : void 0;
+      if (region.bleed && rect) cell = bleed(cell);
+      const arrangement = units.length && rect ? placeRegion(region, units, cell) : void 0;
+      templateRegions.push({
+        name: region.name,
+        box: roundBox(cell),
+        accepts: [...region.accepts],
+        role: region.role,
+        flow: region.flow,
+        max: region.max,
+        anchor: region.anchor,
+        ...arrangement ? { arrangement } : {},
+        content: bound.blocks.map((block) => block.path),
+        ...bound.overflow.length ? { overflow: bound.overflow.map((block) => block.path) } : {},
+        ...collapsed.joined.has(region.name) ? { collapsed: true } : {},
+        ...region.bleed ? { bleed: true } : {},
+        ...areaBox ? { areaBox } : {}
+      });
+    }
+    if (belowUnits.length) placeRegion(belowRegion, belowUnits, physical(logical(rects.get(BELOW))));
   };
-  const placeholders = Array.isArray(layout.placeholders) ? layout.placeholders.filter((p) => !headings.has(p.type)) : [];
-  const placedSlots = new Set(placed.flatMap((entry) => imagePlaceholders[entry.slot] ? [imagePlaceholders[entry.slot].placeholder] : []));
-  if (placedSlots.size) {
-    for (let index = placeholders.length - 1; index >= 0; index--) if (placedSlots.has(placeholders[index])) placeholders.splice(index, 1);
-  }
-  const ownMode = record6(slide.composition).mode;
+  const ownMode = record8(slide.composition).mode;
   const direction = hints.contentDirection;
   const directionMode = direction === "vertical" ? "column" : direction === "horizontal" ? "row" : "auto";
   const chartHint = hints.chartPrimary;
   const chartSide = chartHint === "left" || chartHint === "right" || chartHint === "top" || chartHint === "bottom" ? chartHint : void 0;
   const chartIndex = pending.findIndex((node) => !node.children && node.field === "chart");
-  const chartPrimary = chartSide !== void 0 && !ownMode && !regions.length && chartIndex >= 0 && pending.some((node) => node.children || node.field !== "chart") ? chartSide : void 0;
-  const kindOf = (node) => node.children ? node.children[0] ? kindOf(node.children[0]) : "text" : FIELD_KINDS[node.field] ?? "text";
-  const sugar = chartPrimary ? chartPrimaryLayout(chartPrimary, pending.filter((_, index) => index !== chartIndex).map(kindOf)) : void 0;
-  const rootSettings = sugar ? { ...composition, ...sugar.composition, columns: void 0 } : { ...composition, mode: composition.mode ?? directionMode };
-  const recordSlots = sugar ? [] : layoutSlots(layout).filter((slot) => !headings.has(slot.type) && !placedSlots.has(slot.placeholder));
-  const templated = !sugar && !regions.length && recordSlots.some((slot) => slot.children) && pending.every((node) => !node.children);
-  const fillSlots = (entries, queue, cursor, recordSlot) => {
-    const nodes = [];
-    for (const entry of entries) {
-      if (cursor.next >= queue.length) break;
-      if (!entry.children) {
-        nodes.push({ ...queue[cursor.next++], ...recordSlot ? { slot: entry } : {} });
-        continue;
-      }
-      const own2 = record6(entry.placeholder.composition);
-      assertComposition(own2);
-      const children = fillSlots(entry.children, queue, cursor, recordSlot);
-      nodes.push({
-        field: "blocks",
-        type: "group",
-        value: children.map((child) => child.payload),
-        path,
-        payload: {},
-        children,
-        composition: own2,
-        synthetic: true,
-        reserved: own2.mode ? 0 : entry.children.length,
-        ...recordSlot ? { slot: entry, slots: entry.children } : {}
-      });
-    }
-    return nodes;
-  };
-  if (sugar) {
+  const chartPrimary = chartSide !== void 0 && !useTemplate && !ownMode && !regions.length && chartIndex >= 0 && pending.some((node) => node.children || node.field !== "chart") ? chartSide : void 0;
+  const firstChart = chartPrimary === "left" || chartPrimary === "top";
+  const rootSettings = chartPrimary ? { ...composition, mode: chartPrimary === "left" || chartPrimary === "right" ? "row" : "column", weights: firstChart ? [3, 2] : [2, 3], columns: void 0 } : { ...composition, mode: composition.mode ?? directionMode };
+  if (useTemplate) composeTemplate();
+  else if (chartPrimary) {
     const primary = pending[chartIndex], rest = pending.filter((_, index) => index !== chartIndex);
-    const queue = chartPrimary === "left" || chartPrimary === "top" ? [primary, ...rest] : [...rest, primary];
-    arrange(fillSlots(layoutSlots(sugar, "design.chartPrimary"), queue, { next: 0 }, false), contentBox, rootSettings, 0);
-  } else if (templated) {
-    const cursor = { next: 0 };
-    const nodes = fillSlots(recordSlots, pending, cursor, true);
-    arrange([...nodes, ...pending.slice(cursor.next)], contentBox, rootSettings, composition.mode ? 0 : placeholders.length, void 0, path, true, recordSlots);
-    const order = /* @__PURE__ */ new Map();
-    const number = (entries) => entries.forEach((entry) => {
-      order.set(entry.path, order.size);
-      if (entry.children) number(entry.children);
-    });
-    number(recordSlots);
-    slots.sort((a, b) => order.get(a.path) - order.get(b.path));
-  } else arrange(pending, contentBox, rootSettings, composition.mode ? 0 : placeholders.length);
+    const support = { field: "blocks", type: "group", value: rest.map((node) => node.payload), path, payload: {}, children: rest, composition: {}, synthetic: true };
+    arrange(firstChart ? [primary, support] : [support, primary], contentBox, rootSettings, 0);
+  } else arrange(pending, contentBox, rootSettings, 0);
   if (listBullet?.value === "image" && !bulletImage && items.some((item) => (item.field === "items" || item.field === "bullets") && item.payload.numbering === void 0)) {
     diagnostics.push({ code: "unresolved-content", path: listBullet.path, message: "Picture bullets (listBullet: image) need an organization logo (the primary organization, or the one design.logo names); the marker glyph is drawn instead." });
   }
@@ -6087,8 +7032,7 @@ function composeSlide(input, options = {}) {
   } : void 0;
   if (failures.length) throw new OPFCompositionError(failures, explanation);
   diagnostics.push(...imageDiagnostics, ...numberingDiagnostics);
-  for (const slot of slots) for (const key of ["x", "y", "width", "height"]) slot.box[key] = round2(slot.box[key]);
-  return { width, height, contentBox, items, groups, flows, ...slots.length ? { slots } : {}, diagnostics, composition, design: hints, ...furniture ? { furniture } : {}, ...backgroundImage ? { backgroundImage } : {}, ...logo ? { logo } : {}, ...rtl ? { direction: "rtl" } : {}, ...footnotes ? { footnotes } : {}, ...explanation ? { explanation } : {} };
+  return { width, height, contentBox, items, groups, flows, ...useTemplate ? { regions: templateRegions, headingAreas } : {}, diagnostics, composition, design: hints, ...furniture ? { furniture } : {}, ...backgroundImage ? { backgroundImage } : {}, ...logo ? { logo } : {}, ...rtl ? { direction: "rtl" } : {}, ...footnotes ? { footnotes } : {}, ...explanation ? { explanation } : {} };
 }
 function resolveCanvasDimensions(input) {
   const presets = {
@@ -6103,7 +7047,7 @@ function resolveCanvasDimensions(input) {
     letter: [11, 8.5],
     a4: [11.69, 8.27]
   };
-  const value = record6(input);
+  const value = record8(input);
   const preset = presets[typeof input === "string" ? input : value.preset] ?? presets.widescreen;
   const width = (value.widthInches ?? preset[0]) * 96;
   const height = (value.heightInches ?? preset[1]) * 96;
@@ -6111,4 +7055,4 @@ function resolveCanvasDimensions(input) {
   return { width, height };
 }
 
-export { CAPTIONABLE_FIELDS, CAPTION_FONT_RATIO, CAPTION_MAX_RATIO, CHART_HIGHLIGHT_MUTED_MIN_CONTRAST, CHART_HIGHLIGHT_MUTED_MIX, CHART_SERIES_MIN_DIFFERENCE, CHART_SERIES_MIN_LIGHTNESS_STEP, CHART_TYPES, CITATION_MARKER_RAISE, CITATION_MARKER_SCALE, CODE_HIGHLIGHT_LANGUAGES, CODE_HIGHLIGHT_MAX_LENGTH, CODE_PANEL_BACKGROUND, CODE_PANEL_FOREGROUND, CODE_SYNTAX_MIN_CONTRAST, DARK_BACKGROUND_LUMINANCE, DEFAULT_CHART_LABEL_SEPARATOR, DEFAULT_FURNITURE_DATE_FORMAT, DEFAULT_VARIABLE_DATE_FORMAT, DESIGN_HINT_KEYS, ENGINE_DEFAULT_CHART_TYPES, ENGINE_DEFAULT_COLOR_SCHEME, ENGINE_DEFAULT_FONT_SCHEME, ENGINE_DEFAULT_THEME, FONT_SIZE_GRID_PER_PX, FOOTNOTE_MAX_RATIO, FURNITURE_GAP, FURNITURE_IMAGE_SHARE, LANGUAGES, LAYOUT_BODY_KINDS, LOGO_SHAPES, MAX_COMPOSITION_DEPTH, MAX_NUMBERING_LEVELS, MAX_NUMBERING_VALUE, MAX_PLACEHOLDER_GROUP_DEPTH, MAX_ROMAN_VALUE, METRIC_TREND_MIN_CONTRAST, METRIC_TREND_SHAPES, NUMBERING_STYLES, NUMBERING_SUFFIXES, OPFCompositionError, OPFVariableError, PATTERN_PRESETS, PATTERN_PRESET_ALIASES, PATTERN_TILE_SIZE, PICTURE_BULLET_SCALE, SLIDE_SCOPED_BUILTINS, SOCIAL_PLATFORMS, SURFACE_ALT_MIN_CONTRAST, SURFACE_ALT_MIX, TIMELINE_OUTLINE_MIN_CONTRAST, TIMELINE_STATUSES, TIMELINE_TEXT_MIN_CONTRAST, VARIABLE_KINDS, annotationText, captionSettings, chartColorForFill, chartHighlightColors, chartHighlightMarks, chartLabelText, chartNumber, chartNumberFixesByCell, chartOptionSupport, chartOptionTarget, chartPaletteForFill, chartPrimaryLayout, citationMarkerText, codeHighlightBands, codeHighlightColors, codeHighlightLines, codeHighlightSlice, codeLineNumbers, codeLineRuns, codeSyntaxPalette, codeSyntaxPaletteForScheme, coerceVariableValue, collectCitations, colorContrast, composeSlide, datasetDiagnostics, defaultSlideBackground, fitImage, fitList, fitRichText, fitText, formatChartLabelNumber, formatChartLabelPercent, formatDataNumber, formatFurnitureDate, formatListNumber, formatVariableNumber, fromExcelNumberFormat, hasContentVariables, hasPlaceholderGroups, imageBackground, imageShape, inlineChartData, inlineDatasets, inlineTableData, instantiateForValidation, intrinsicImageAspect, intrinsicImageSize, isDarkColor, isDatasetRef, isPlaceholderGroup, isRecord, isTemplate, isXYChartType, layoutCaption, layoutCode, layoutContent, layoutFootnotes, layoutFurniture, layoutLeaves, layoutMetric, layoutQuote, layoutSlots, layoutStructure, layoutTable, layoutTimeline, layoutWatermark, listBuiltinVariables, listNumbers, listVariables, measureText, measureTextOutline, metricTrendColor, metricTrendMark, metricTrendPoints, normalizeHexColor, normalizeLanguageFamily, numberFormatError, numberingAtLevel, numberingFindings, numberingStyleDraws, paragraphDirection, paragraphDirectionAt, pathFor, patternBitmap, patternRuns, physicalAlignment, placeTextLines, promotedRegionKeys, readingRows, referencesSlide, resolveCanvasDimensions, resolveChartData, resolveChartOptions, resolveCodeLanguage, resolveColorRef, resolveColorRoles, resolveDesignHints, resolveDesignRecords, resolveFontFamilies, resolveFontScheme, resolveLogo, resolveNumbering, resolvePatternPreset, resolveScriptFonts, resolveSlideDirection, resolveSlideVariables, resolveSocialProfile, resolveTableData, resolveTextStyle, resolveVariables, scriptFontRole, sliceNumberedItems, slideCitations, slideTokenSpans, snapFontSizeDown, snapFontSizeUp, suggestChartNumberFix, surfaceAltColor, tableCellDisplayValue, tableGrid, tableRowBoundaries, textColorForFill, textWidthMeasurer, timelineMarkerShapes, timelineTextColor, toExcelNumberFormat, tokenizeCode, unusedDatasets, usesSlideBuiltin, variableDeclarations, visitContentPayloads, visualReadingOrder, walkCitationRuns, wrapText };
+export { AUTO_LAYOUT, CAPTIONABLE_FIELDS, CAPTION_FONT_RATIO, CAPTION_MAX_RATIO, CATALOG_GROUP_PATTERN, CATALOG_REFERENCE_PATTERN, CHART_HIGHLIGHT_MUTED_MIN_CONTRAST, CHART_HIGHLIGHT_MUTED_MIX, CHART_SERIES_MIN_DIFFERENCE, CHART_SERIES_MIN_LIGHTNESS_STEP, CHART_TYPES, CITATION_MARKER_RAISE, CITATION_MARKER_SCALE, CODE_HIGHLIGHT_LANGUAGES, CODE_HIGHLIGHT_MAX_LENGTH, CODE_PANEL_BACKGROUND, CODE_PANEL_FOREGROUND, CODE_SYNTAX_MIN_CONTRAST, DARK_BACKGROUND_LUMINANCE, DEFAULT_CHART_LABEL_SEPARATOR, DEFAULT_FURNITURE_DATE_FORMAT, DEFAULT_VARIABLE_DATE_FORMAT, DESIGN_HINT_KEYS, ENGINE_DEFAULT_CHART_TYPES, ENGINE_DEFAULT_COLOR_SCHEME, ENGINE_DEFAULT_FONT_SCHEME, ENGINE_DEFAULT_THEME, FONT_SIZE_GRID_PER_PX, FOOTNOTE_MAX_RATIO, FURNITURE_GAP, FURNITURE_IMAGE_SHARE, HEADING_AREAS, LANGUAGES, LAYOUT_BODY_KINDS, LOGO_SHAPES, MAX_COMPOSITION_DEPTH, MAX_NUMBERING_LEVELS, MAX_NUMBERING_VALUE, MAX_REGION_BLOCKS, MAX_ROMAN_VALUE, MAX_TEMPLATE_TRACKS, METRIC_TREND_MIN_CONTRAST, METRIC_TREND_SHAPES, NUMBERING_STYLES, NUMBERING_SUFFIXES, OPFCatalogsOptionError, OPFCompositionError, OPFLayoutTemplateError, OPFUnresolvedReferenceError, OPFVariableError, PATTERN_PRESETS, PATTERN_PRESET_ALIASES, PATTERN_TILE_SIZE, PICTURE_BULLET_SCALE, PROMOTED_REGION_KEY, REGION_ANCHORS, REGION_FLOWS, REGION_KINDS, REGION_ROLES, RESERVED_REGION_NAMES, SLIDE_SCOPED_BUILTINS, SOCIAL_PLATFORMS, SURFACE_ALT_MIN_CONTRAST, SURFACE_ALT_MIX, THEME_DESIGN_KEYS, TIMELINE_OUTLINE_MIN_CONTRAST, TIMELINE_STATUSES, TIMELINE_TEXT_MIN_CONTRAST, VARIABLE_KINDS, allocateRows, annotationText, bindRegions, blockKind, captionSettings, catalogGroupDeclared, catalogGroupSource, catalogKinds, catalogRecords, catalogReferenceSites, chartColorForFill, chartHighlightColors, chartHighlightMarks, chartLabelText, chartNumber, chartNumberFixesByCell, chartOptionSupport, chartOptionTarget, chartPaletteForFill, checkCatalogsOption, citationMarkerText, codeHighlightBands, codeHighlightColors, codeHighlightLines, codeHighlightSlice, codeLineNumbers, codeLineRuns, codeSyntaxPalette, codeSyntaxPaletteForScheme, coerceVariableValue, collectCitations, colorContrast, composeLayoutAreas, composeSlide, datasetDiagnostics, defaultSlideBackground, dottedPath, embeddedCopy, fitImage, fitList, fitRichText, fitText, formatChartLabelNumber, formatChartLabelPercent, formatDataNumber, formatFurnitureDate, formatListNumber, formatVariableNumber, fromExcelNumberFormat, gridFlowShape, hasContentVariables, imageBackground, imageShape, inlineChartData, inlineDatasets, inlineTableData, instantiateForValidation, intrinsicImageAspect, intrinsicImageSize, isDarkColor, isDatasetRef, isLayoutTemplate, isRecord, isTemplate, isXYChartType, layoutCaption, layoutCode, layoutContent, layoutFootnotes, layoutFurniture, layoutMetric, layoutQuote, layoutRegion, layoutStructure, layoutTable, layoutTemplate, layoutTemplateIssues, layoutTimeline, layoutWatermark, listBuiltinVariables, listColumnBreaks, listNumbers, listVariables, measureText, measureTextOutline, metricTrendColor, metricTrendMark, metricTrendPoints, normalizeHexColor, normalizeLanguageFamily, numberFormatError, numberingAtLevel, numberingFindings, numberingStyleDraws, paragraphDirection, paragraphDirectionAt, parseReference, pathFor, patternBitmap, patternRuns, physicalAlignment, placeTextLines, placedImageBlocks, pointerPath, promotedRegionKeys, provenanceOf, readingRows, recordReferenceSites, referencesSlide, regionAccepts, regionRoleRank, registeredCatalog, resolveCanvasDimensions, resolveChartData, resolveChartOptions, resolveCodeLanguage, resolveColorRef, resolveColorRoles, resolveDesignHints, resolveDesignRecords, resolveFontFamilies, resolveFontScheme, resolveLogo, resolveNumbering, resolvePatternPreset, resolveReference, resolveScriptFonts, resolveSlideDirection, resolveSlideVariables, resolveSocialProfile, resolveTableData, resolveTextStyle, resolveVariables, rootNodes, scriptFontRole, sliceNumberedItems, slideCitations, slideTokenSpans, snapFontSizeDown, snapFontSizeUp, suggestChartNumberFix, surfaceAltColor, tableCellDisplayValue, tableGrid, tableRowBoundaries, textColorForFill, textWidthMeasurer, timelineMarkerShapes, timelineTextColor, toExcelNumberFormat, tokenizeCode, unresolvedReference, unusedDatasets, usesSlideBuiltin, variableDeclarations, visitContentPayloads, visualReadingOrder, walkCitationRuns, wrapText };