@openpresentation/opf 0.10.0 → 0.11.0

package/dist/{chunk-GCB6LGJM.js → chunk-CHKJ4QHQ.js}

@@ -1,9 +1,89 @@
-import { MAX_COMPOSITION_DEPTH, tableGrid } from './chunk-BAWLYSUN.js';
-import { schemas, schemaEntries } from './chunk-GQSK3T7X.js';
-import { catalogSchemaNames } from './chunk-TWMRZ43O.js';
+import { MAX_COMPOSITION_DEPTH, tableGrid } from './chunk-FTWNWFIV.js';
+import { schemas, schemaEntries } from './chunk-GN52EE3P.js';
+import { catalogSchemaNames } from './chunk-6FU2KICU.js';
 import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
 
+// src/content-walk.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function pathFor(parentPath, key) {
+  return parentPath === "/" ? `/${key}` : `${parentPath}/${key.replaceAll("~", "~0").replaceAll("/", "~1")}`;
+}
+var bareIdPattern = /^[a-z0-9][a-z0-9-]*$/;
+var promotedRegionKeys = [
+  "left",
+  "center",
+  "right",
+  "left+center",
+  "center+right",
+  "left+center+right",
+  "top",
+  "middle",
+  "bottom",
+  "top+middle",
+  "middle+bottom",
+  "top+middle+bottom",
+  "top:left",
+  "top:center",
+  "top:right",
+  "top:left+center",
+  "top:center+right",
+  "top:left+center+right",
+  "middle:left",
+  "middle:center",
+  "middle:right",
+  "middle:left+center",
+  "middle:center+right",
+  "middle:left+center+right",
+  "bottom:left",
+  "bottom:center",
+  "bottom:right",
+  "bottom:left+center",
+  "bottom:center+right",
+  "bottom:left+center+right",
+  "top+middle:left",
+  "top+middle:center",
+  "top+middle:right",
+  "top+middle:left+center",
+  "top+middle:center+right",
+  "top+middle:left+center+right",
+  "middle+bottom:left",
+  "middle+bottom:center",
+  "middle+bottom:right",
+  "middle+bottom:left+center",
+  "middle+bottom:center+right",
+  "middle+bottom:left+center+right",
+  "top+middle+bottom:left",
+  "top+middle+bottom:center",
+  "top+middle+bottom:right",
+  "top+middle+bottom:left+center",
+  "top+middle+bottom:center+right",
+  "top+middle+bottom:left+center+right"
+];
+function visitContentPayloads(slide, slidePath, visit) {
+  const walk = (payload, path, depth, ancestors) => {
+    visit(payload, path);
+    if (!Array.isArray(payload.blocks) || depth >= MAX_COMPOSITION_DEPTH || ancestors.includes(payload)) return;
+    const nested = [...ancestors, payload];
+    const blocksPath = pathFor(path, "blocks");
+    payload.blocks.forEach((block, index) => {
+      if (isRecord(block)) walk(block, `${blocksPath}/${index}`, depth + 1, nested);
+    });
+  };
+  if (Array.isArray(slide.blocks)) {
+    const blocksPath = pathFor(slidePath, "blocks");
+    slide.blocks.forEach((block, index) => {
+      if (isRecord(block)) walk(block, `${blocksPath}/${index}`, 0, []);
+    });
+  }
+  for (const key of promotedRegionKeys) {
+    const region = slide[key];
+    if (isRecord(region)) walk(region, pathFor(slidePath, key), 0, []);
+  }
+}
+
 // src/generated/catalog-ids.ts
 var catalogIds = {
   audiences: [
@@ -67,10 +147,12 @@ var catalogIds = {
     "number-4x",
     "number-5x",
     "number-6x",
+    "quote-1x",
     "table-1x",
     "text-1x",
     "text-2x",
     "text-3x",
+    "timeline-1x",
     "title",
     "title-subtitle"
   ],
@@ -464,56 +546,6 @@ var OPFValidationError = class extends Error {
 var schemaNameByCatalogKind = catalogSchemaNames;
 var ajv;
 var dynamicSchemaCache = /* @__PURE__ */ new WeakMap();
-var promotedRegionKeys = [
-  "left",
-  "center",
-  "right",
-  "left+center",
-  "center+right",
-  "left+center+right",
-  "top",
-  "middle",
-  "bottom",
-  "top+middle",
-  "middle+bottom",
-  "top+middle+bottom",
-  "top:left",
-  "top:center",
-  "top:right",
-  "top:left+center",
-  "top:center+right",
-  "top:left+center+right",
-  "middle:left",
-  "middle:center",
-  "middle:right",
-  "middle:left+center",
-  "middle:center+right",
-  "middle:left+center+right",
-  "bottom:left",
-  "bottom:center",
-  "bottom:right",
-  "bottom:left+center",
-  "bottom:center+right",
-  "bottom:left+center+right",
-  "top+middle:left",
-  "top+middle:center",
-  "top+middle:right",
-  "top+middle:left+center",
-  "top+middle:center+right",
-  "top+middle:left+center+right",
-  "middle+bottom:left",
-  "middle+bottom:center",
-  "middle+bottom:right",
-  "middle+bottom:left+center",
-  "middle+bottom:center+right",
-  "middle+bottom:left+center+right",
-  "top+middle+bottom:left",
-  "top+middle+bottom:center",
-  "top+middle+bottom:right",
-  "top+middle+bottom:left+center",
-  "top+middle+bottom:center+right",
-  "top+middle+bottom:left+center+right"
-];
 var promotedRegionKeySet = new Set(promotedRegionKeys);
 var rootPayloadFields = [
   "type",
@@ -653,18 +685,12 @@ function semanticIssue(path, message, params = {}) {
     params
   };
 }
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function hasOwn(value, key) {
   return Object.hasOwn(value, key);
 }
 function isEnUkTag(value) {
   return typeof value === "string" && value.toLowerCase() === "en-uk";
 }
-function pathFor(parentPath, key) {
-  return parentPath === "/" ? `/${key}` : `${parentPath}/${key.replaceAll("~", "~0").replaceAll("/", "~1")}`;
-}
 function presentFields(value, fields) {
   return fields.filter((field) => hasOwn(value, field));
 }
@@ -837,27 +863,32 @@ function validatePresentationSemantics(value) {
       replacement: "en-GB"
     }));
   }
-  const slideIds = /* @__PURE__ */ new Set();
+  const documentIds = /* @__PURE__ */ new Map();
   value.slides.forEach((slide, index) => {
     if (isRecord(slide)) {
+      const slidePath = `/slides/${index}`;
       if (typeof slide.id === "string") {
-        if (slideIds.has(slide.id)) issues.push(semanticIssue(`/slides/${index}/id`, "slide ids must be unique within a presentation", { id: slide.id }));
-        slideIds.add(slide.id);
+        const seen = documentIds.get(slide.id);
+        if (seen === "slide") issues.push(semanticIssue(`${slidePath}/id`, "slide ids must be unique within a presentation", { id: slide.id }));
+        else if (seen === "payload") issues.push(semanticIssue(`${slidePath}/id`, "slide id duplicates a content payload id; ids must be unique among slide and payload ids within a presentation", { id: slide.id }));
+        else documentIds.set(slide.id, "slide");
       }
-      issues.push(...validateSlideRegions(slide, `/slides/${index}`));
-      const visitTables = (node, path) => {
-        if (isRecord(node.table)) for (const issue of tableGrid(node.table).issues) issues.push(semanticIssue(pathFor(path, "table") + issue.path.slice(5).replaceAll(".", "/"), issue.message));
-        if (Array.isArray(node.blocks)) node.blocks.forEach((block, i) => {
-          if (isRecord(block)) visitTables(block, `${path}/blocks/${i}`);
-        });
-        for (const key of promotedRegionKeys) if (isRecord(node[key])) visitTables(node[key], pathFor(path, key));
+      visitContentPayloads(slide, slidePath, (payload, path) => {
+        if (typeof payload.id === "string") {
+          if (documentIds.has(payload.id)) issues.push(semanticIssue(`${path}/id`, "content payload ids must be unique among slide and payload ids within a presentation", { id: payload.id }));
+          else documentIds.set(payload.id, "payload");
+        }
+      });
+      issues.push(...validateSlideRegions(slide, slidePath));
+      const payloadTableIssues = (payload, path) => {
+        if (isRecord(payload.table)) for (const issue of tableGrid(payload.table).issues) issues.push(semanticIssue(pathFor(path, "table") + issue.path.slice(5).replaceAll(".", "/"), issue.message));
       };
-      visitTables(slide, `/slides/${index}`);
+      payloadTableIssues(slide, slidePath);
+      visitContentPayloads(slide, slidePath, payloadTableIssues);
     }
   });
   return issues;
 }
-var bareIdPattern = /^[a-z0-9][a-z0-9-]*$/;
 function inlineCatalogEntry(context, kind) {
   const catalogsField = context.document.catalogs;
   if (!isRecord(catalogsField)) {
@@ -876,7 +907,7 @@ function unknownIdWarning(kind, value, path, context) {
       if (Array.isArray(entry.records) && entry.records.some((record) => isRecord(record) && record.id === value)) {
         return void 0;
       }
-      if (typeof entry.source === "string") {
+      if (typeof entry.source === "string" || Array.isArray(entry.source) && entry.source.length > 0) {
         return void 0;
       }
     }
@@ -930,6 +961,126 @@ function chartTypeWarnings(payload, path, context) {
   }
   return issues;
 }
+var cellBorderEdges = ["top", "right", "bottom", "left"];
+var variableIdPattern = /^[a-z][a-z0-9-]*$/;
+var hexColorPattern = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+var schemeColorNames = /* @__PURE__ */ new Set([
+  "accent1",
+  "accent2",
+  "accent3",
+  "accent4",
+  "accent5",
+  "accent6",
+  "dark1",
+  "dark2",
+  "light1",
+  "light2",
+  "hyperlink",
+  "followedHyperlink",
+  "primary",
+  "secondary",
+  "accent",
+  "background",
+  "surface",
+  "text",
+  "textSecondary"
+]);
+function variableReferenceWarnings(value) {
+  if (!Array.isArray(value.slides)) {
+    return [];
+  }
+  const variables = isRecord(value.variables) ? value.variables : {};
+  const issues = [];
+  const colorRef = (entry, path) => {
+    if (typeof entry !== "string" || !entry.startsWith("var:")) return;
+    const id = entry.slice("var:".length);
+    if (!variableIdPattern.test(id) || hasOwn(variables, id)) return;
+    issues.push(semanticIssue(path, `unknown variable '${id}'; declare it in the top-level variables map`, { id }));
+  };
+  const runColor = (entry, path) => {
+    if (typeof entry !== "string") return;
+    if (hexColorPattern.test(entry) || schemeColorNames.has(entry)) return;
+    if (entry.startsWith("var:") && variableIdPattern.test(entry.slice("var:".length))) {
+      colorRef(entry, path);
+      return;
+    }
+    issues.push(semanticIssue(
+      path,
+      `run color '${entry}' is not a hex color, a color-scheme name, or a 'var:' reference; renderers fall back to the theme color`,
+      { color: entry }
+    ));
+  };
+  const richText = (entry, path) => {
+    if (!Array.isArray(entry)) return;
+    entry.forEach((run, index) => {
+      if (isRecord(run)) runColor(run.color, `${path}/${index}/color`);
+    });
+  };
+  const cellStyle = (style, path) => {
+    if (!isRecord(style)) return;
+    colorRef(style.fill, pathFor(path, "fill"));
+    colorRef(style.color, pathFor(path, "color"));
+    if (!isRecord(style.borders)) return;
+    const bordersPath = pathFor(path, "borders");
+    for (const edge of cellBorderEdges) {
+      const border = style.borders[edge];
+      if (isRecord(border)) colorRef(border.color, `${pathFor(bordersPath, edge)}/color`);
+    }
+  };
+  const tableCell = (cell, path) => {
+    if (Array.isArray(cell)) {
+      richText(cell, path);
+      return;
+    }
+    if (!isRecord(cell)) return;
+    richText(cell.value, pathFor(path, "value"));
+    cellStyle(cell.style, pathFor(path, "style"));
+  };
+  const table = (node, path) => {
+    if (!isRecord(node)) return;
+    if (Array.isArray(node.columns)) {
+      const columnsPath = pathFor(path, "columns");
+      node.columns.forEach((column, index) => {
+        tableCell(column, `${columnsPath}/${index}`);
+      });
+    }
+    if (Array.isArray(node.rows)) {
+      const rowsPath = pathFor(path, "rows");
+      node.rows.forEach((row, rowIndex) => {
+        if (!Array.isArray(row)) return;
+        row.forEach((cell, cellIndex) => {
+          tableCell(cell, `${rowsPath}/${rowIndex}/${cellIndex}`);
+        });
+      });
+    }
+  };
+  const textEntries = (entries, path) => {
+    if (!Array.isArray(entries)) return;
+    entries.forEach((entry, index) => {
+      const entryPath = `${path}/${index}`;
+      if (Array.isArray(entry)) {
+        richText(entry, entryPath);
+        return;
+      }
+      if (!isRecord(entry)) return;
+      richText(entry.text, pathFor(entryPath, "text"));
+      richText(entry.description, pathFor(entryPath, "description"));
+    });
+  };
+  const payload = (node, path) => {
+    richText(node.text, pathFor(path, "text"));
+    textEntries(node.items, pathFor(path, "items"));
+    textEntries(node.bullets, pathFor(path, "bullets"));
+    table(node.table, pathFor(path, "table"));
+  };
+  value.slides.forEach((slide, index) => {
+    if (!isRecord(slide)) return;
+    const slidePath = `/slides/${index}`;
+    payload(slide, slidePath);
+    visitContentPayloads(slide, slidePath, payload);
+  });
+  return issues;
+}
 function presentationReferenceWarnings(value) {
   if (!isRecord(value) || !Array.isArray(value.slides)) {
     return [];
@@ -940,6 +1091,7 @@ function presentationReferenceWarnings(value) {
     pushIfDefined(issues, unknownIdWarning("narratives", value.narrative, "/narrative", context));
   }
   issues.push(...designReferenceWarnings(value.design, "/design", context));
+  issues.push(...variableReferenceWarnings(value));
   value.slides.forEach((slide, index) => {
     if (!isRecord(slide)) {
       return;
@@ -1055,4 +1207,4 @@ function assertValidCatalogRecord(kind, value) {
   assertValid(value, kind);
 }
 
-export { OPFValidationError, assertValid, assertValidCatalogRecord, assertValidPresentation, validate, validateCatalogRecord, validatePresentation, validationDefinition };
+export { OPFValidationError, assertValid, assertValidCatalogRecord, assertValidPresentation, bareIdPattern, isRecord, promotedRegionKeys, validate, validateCatalogRecord, validatePresentation, validationDefinition, visitContentPayloads };

package/dist/{chunk-NPOKUFEX.js → chunk-EQHZ3ZO4.js}

@@ -1,6 +1,6 @@
-import { validatePresentation, validationDefinition, validateCatalogRecord } from './chunk-GCB6LGJM.js';
-import { schemas, schemaEntries } from './chunk-GQSK3T7X.js';
-import { catalogKinds, catalogEntries, catalogSchemaNames } from './chunk-TWMRZ43O.js';
+import { validatePresentation, validationDefinition, validateCatalogRecord } from './chunk-CHKJ4QHQ.js';
+import { schemas, schemaEntries } from './chunk-GN52EE3P.js';
+import { catalogKinds, catalogEntries, catalogSchemaNames } from './chunk-6FU2KICU.js';
 import { parseTree, printParseErrorCode, getNodePath } from 'jsonc-parser';
 
 var own = (value, key) => Object.hasOwn(value, key);

package/dist/{chunk-BAWLYSUN.js → chunk-FTWNWFIV.js}

@@ -36,6 +36,77 @@ function tableRowBoundaries(value) {
 }
 
 // src/color.ts
+var schemeColorSlots = /* @__PURE__ */ new Set([
+  "accent1",
+  "accent2",
+  "accent3",
+  "accent4",
+  "accent5",
+  "accent6",
+  "dark1",
+  "dark2",
+  "light1",
+  "light2",
+  "hyperlink",
+  "followedHyperlink"
+]);
+var schemeColorRoles = /* @__PURE__ */ new Set([
+  "primary",
+  "secondary",
+  "accent",
+  "background",
+  "surface",
+  "text",
+  "textSecondary"
+]);
+var defaultRoleSlots = {
+  primary: "accent1",
+  secondary: "accent2",
+  accent: "accent3",
+  background: "light1",
+  surface: "light2",
+  text: "dark1",
+  textSecondary: "dark2"
+};
+function normalizeHexColor(value) {
+  if (typeof value !== "string") return void 0;
+  let hex = value.trim();
+  if (/^#[0-9a-f]{3}$/i.test(hex)) hex = `#${[...hex.slice(1)].map((char) => char + char).join("")}`;
+  if (/^#[0-9a-f]{6}([0-9a-f]{2})?$/i.test(hex)) return hex.length === 9 ? `#${hex.slice(1, 7).toUpperCase()}` : hex.toUpperCase();
+  return void 0;
+}
+function schemeSlot(colorScheme, slot, fallback) {
+  return normalizeHexColor(colorScheme[slot]) ?? fallback;
+}
+function resolveVariable(variables, id, fallback) {
+  const entry = variables[id];
+  if (typeof entry === "string") return normalizeHexColor(entry) ?? fallback;
+  if (entry && typeof entry === "object" && entry.type === "color") {
+    return normalizeHexColor(entry.value) ?? fallback;
+  }
+  return fallback;
+}
+function resolveColorRef(reference, options) {
+  const { colorScheme, roles, variables = {}, fallback } = options;
+  const literal = normalizeHexColor(reference);
+  if (literal) return literal;
+  if (reference.startsWith("var:")) {
+    const id = reference.slice("var:".length);
+    if (/^[a-z][a-z0-9-]*$/.test(id)) return resolveVariable(variables, id, fallback);
+    return fallback;
+  }
+  if (schemeColorRoles.has(reference)) {
+    const roleKey = reference;
+    const fromRoles = roles?.[roleKey];
+    if (fromRoles) return normalizeHexColor(fromRoles) ?? fallback;
+    const fromScheme = normalizeHexColor(colorScheme[reference]);
+    if (fromScheme) return fromScheme;
+    const slot = defaultRoleSlots[reference];
+    return slot ? schemeSlot(colorScheme, slot, fallback) : fallback;
+  }
+  if (schemeColorSlots.has(reference)) return schemeSlot(colorScheme, reference, fallback);
+  return fallback;
+}
 function luminance(value) {
   if (typeof value !== "string") return void 0;
   let hex = value.trim();
@@ -146,8 +217,105 @@ var headings = /* @__PURE__ */ new Set(["title", "subtitle", "tag"]);
 var rows = ["top", "middle", "bottom"];
 var columns = ["left", "center", "right"];
 var record2 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
-var kind = (field) => field === "items" || field === "bullets" ? "list" : field;
+var kind = (field) => field === "items" ? "list" : field === "bullets" ? "text" : field;
 var round = (value) => Math.round(value * 1e6) / 1e6 || value;
+function layoutFurniture(input, options = {}) {
+  const slide = record2(input), width = options.width ?? 1280, height = options.height ?? 720, scale = Math.min(width, height) / 720;
+  const settings = { ...record2(record2(options.layout).composition), ...record2(slide.composition) };
+  assertComposition(settings);
+  const minimum = (settings.minFontSize ?? 16) * scale, size = Math.max(13 * scale, minimum), padding = (options.textRasterPadding ?? 2) * scale;
+  if (![width, height, scale, minimum, padding].every(Number.isFinite) || width <= 0 || height <= 0 || minimum <= 0 || padding < 0) throw new RangeError("Furniture requires finite positive dimensions and nonnegative raster padding.");
+  const number = options.slideNumber ?? (options.slideIndex ?? 0) + 1;
+  if (!Number.isSafeInteger(number) || number < 1) throw new RangeError("Displayed slide number must be a positive safe integer.");
+  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) => record2(item).role === "primary"), organizationIndex = primaryIndex >= 0 ? primaryIndex : organizations.findIndex(Boolean);
+  const organization = record2(organizations[organizationIndex]), organizationPath = Array.isArray(options.presentation?.organization) ? `organization.${organizationIndex}.name` : "organization.name";
+  const fontFamily = options.fonts?.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 = record2(slide.design)[kind2] !== void 0, value = local ? record2(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.");
+    configured = true;
+    const zones = [];
+    for (const [index, zone] of ["left", "center", "right"].entries()) {
+      const content = record2(record2(value)[zone]), path = `${root}.${zone}`, x = width * (0.07 + index * 0.3), zoneWidth = width * 0.26, zoneParts = [];
+      let y = 0;
+      const add = (field, text, generated = false, sourcePath) => {
+        if (text === void 0) return;
+        if (typeof text !== "string") throw new TypeError(`Furniture field ${path}.${field} requires string content.`);
+        const partPath = `${path}.${field}`, style = resolveTextStyle({ fontFamily, fontWeight: 400, italic: false, path: partPath }, options.textMeasurement);
+        const fit = fitText(text, { width: Math.max(Number.MIN_VALUE, zoneWidth - (outlines ? 2 * padding : 0)), height: Number.MAX_VALUE }, size, size, textWidthMeasurer(style, options.textMeasurement));
+        const ink = fit.sourceLines.map((line, index2) => {
+          let outline = null;
+          if (outlines) {
+            for (const segment of line.segments) if (segment.kind === "text") {
+              const bounds = measureTextOutline(text.slice(segment.start, segment.end), size, style, options.textMeasurement);
+              if (bounds) {
+                const next = { ...bounds, x: bounds.x + segment.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);
+                  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;
+                }
+              }
+            }
+          }
+          return { width: line.width, y: index2 * fit.lineHeight, baseline: size + index2 * fit.lineHeight, height: fit.lineHeight, outline };
+        });
+        const natural = outlines ? placeTextLines(ink, { x, y, width: zoneWidth, height: Number.MAX_VALUE }, zone, padding) : void 0;
+        const partHeight = natural?.height ?? fit.sourceLines.length * fit.lineHeight;
+        if (!Number.isFinite(partHeight)) throw new RangeError("Furniture exceeds finite layout coordinates.");
+        const box = { x, y, width: zoneWidth, height: Math.max(scale, partHeight) }, placement = outlines ? placeTextLines(ink, box, zone, padding) : void 0;
+        const accepted = { ...fit, ...placement ? { placement } : {}, overflow: fit.overflow || !!placement?.overflow };
+        zoneParts.push({ type: "text", kind: kind2, zone, field, path: partPath, sourcePath: sourcePath ?? (!generated ? partPath : void 0), generated, text, style, requestedFontSize: 13 * scale, minFontSize: minimum, box, alignment: zone, fit: accepted });
+        if (accepted.overflow) error(partPath, "Repeated text exceeds its zone at the selected readability floor; change the furniture or slide design.");
+        y += box.height;
+      };
+      if (content.image !== void 0) {
+        const box = { x, y, width: zoneWidth, height: Math.max(32 * scale, Math.min(height * 0.05, 72 * scale)) };
+        zoneParts.push({ type: "image", kind: kind2, zone, field: "image", path: `${path}.image`, sourcePath: `${path}.image`, generated: false, image: content.image, box, alignment: zone });
+        y += box.height;
+      }
+      add("text", content.text);
+      if (content.organization === true) {
+        if (typeof organization.name === "string") add("organization", organization.name, true, organizationPath);
+        else error(`${path}.organization`, "Generated organization name needs a named organization in the presentation.", "unresolved-content");
+      }
+      if (content.section === true) {
+        if (typeof slide.section === "string") add("section", slide.section, true, `${sourceRoot}.section`);
+        else error(`${path}.section`, "Generated section needs a literal slide section.", "unresolved-content");
+      }
+      if (content.slideNumber === true) add("slideNumber", String(number), true);
+      if (content.date === true) error(`${path}.date`, "Use a literal date string for deterministic header/footer content.", "unresolved-content");
+      else if (typeof content.date === "string") add("date", content.date);
+      zones.push(zoneParts);
+    }
+    const tallest = Math.max(0, ...zones.map((zone) => zone.reduce((sum, part) => sum + part.box.height, 0)));
+    if (!tallest) continue;
+    const top = kind2 === "header" ? height * 0.025 : Math.max(height * 0.025, height - height * 0.04 - tallest);
+    if (kind2 === "header") headerBottom = top + tallest;
+    else footerTop = top;
+    for (const zone of zones) for (const part of zone) {
+      part.box.y += top;
+      if (part.type === "text" && part.fit.placement) for (const line of part.fit.placement.lines) {
+        line.y += top;
+        line.baseline += top;
+        if (line.outline) line.outline.y += top;
+      }
+      if (part.box.y + part.box.height > height - height * 0.04 + 0.01) error(part.path, "Repeated header/footer content extends beyond the usable slide height. Change its content or design before pagination.");
+      parts.push(part);
+    }
+  }
+  if (headerBottom > footerTop + 0.01) error(parts.find((part) => part.kind === "footer")?.path ?? sourceRoot, "Header and footer content overlap; repeated content cannot be repaired by splitting body content.");
+  return { algorithm: "furniture-flow-v2", configured, textMeasurement: options.textMeasurement ? "provided" : "estimated", textOutlines: outlines ? "provided" : "unavailable", parts, headerBottom, footerTop, diagnostics, overflow: diagnostics.length > 0 };
+}
 var textSegments = new Intl.Segmenter("und", { granularity: "grapheme" });
 function measureText(text, fontSize) {
   let units = 0;
@@ -1078,7 +1246,11 @@ function composeSlide(input, options = {}) {
   const fitContent = (field, value, text, box, size, minimum, path2) => field === "text" ? fitPlacedText(field, value, text, box, size, minimum, path2) : field === "items" || field === "bullets" ? fitList(value, box, size, minimum, { style: styleFor(field, path2), textMeasurement: options.textMeasurement }) : fitText(text, box, size, minimum, widthFor(field, path2));
   const path = `slides.${options.slideIndex ?? 0}`;
   const items = [], diagnostics = [];
-  let y = padding;
+  const measuredFurniture = layoutFurniture(slide, options);
+  const furniture = measuredFurniture.configured || measuredFurniture.diagnostics.length ? measuredFurniture : void 0;
+  if (furniture) diagnostics.push(...furniture.diagnostics);
+  const bodyBottom = Math.min(height - padding, furniture && furniture.footerTop < height ? furniture.footerTop - gap * 0.5 : height - padding);
+  let y = Math.max(padding, furniture?.headerBottom ? furniture.headerBottom + gap * 0.5 : padding);
   for (const field of ["tag", "title", "subtitle"]) {
     if (!slide[field]) continue;
     const requested = (field === "title" ? 54 : field === "tag" ? 16 : 25) * scale;
@@ -1086,11 +1258,12 @@ function composeSlide(input, options = {}) {
     const box = { x: padding, y, width: width - padding * 2, height: maxHeight };
     const text = fitPlacedText(field, slide[field], String(slide[field]), box, requested, minSize, `${path}.${field}`);
     box.height = Math.min(maxHeight, Math.max(text.lines.length * text.lineHeight, text.placement?.height ?? 0));
+    if (furniture && box.y + box.height > bodyBottom + 0.01) diagnostics.push({ code: "text-overflow", path: `${path}.${field}`, message: "Repeated furniture leaves too little room for this heading. Change the header/footer or slide design." });
     items.push({ path: `${path}.${field}`, field, type: "text", value: slide[field], payload: { text: slide[field] }, box, text, textStyle: styleFor(field, `${path}.${field}`), composition });
     y += box.height + gap * 0.5;
   }
   if (items.length) y += gap * 0.5;
-  const contentBox = { x: padding, y, width: width - padding * 2, height: Math.max(scale, height - padding - y) };
+  const contentBox = { x: padding, y, width: width - padding * 2, height: Math.max(scale, bodyBottom - y) };
   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.`);
@@ -1285,6 +1458,7 @@ function composeSlide(input, options = {}) {
   for (const group of groups) for (const box of [group.box, group.contentBox]) for (const key of ["x", "y", "width", "height"]) box[key] = round(box[key]);
   const strictPaths = new Set(items.filter((item) => item.composition.overflow === "error").map((item) => item.path));
   const failures = diagnostics.filter((diagnostic) => {
+    if (composition.overflow === "error") return true;
     let path2 = diagnostic.path;
     while (path2) {
       if (strictPaths.has(path2)) return true;
@@ -1295,7 +1469,7 @@ function composeSlide(input, options = {}) {
     return false;
   });
   const explanation = decisions ? {
-    algorithm: "grid-score-v8",
+    algorithm: "grid-score-v9",
     textMeasurement: options.textMeasurement ? "provided" : "estimated",
     textOutlines: options.textMeasurement?.outlineBounds ? "provided" : "unavailable",
     textRasterPadding: rasterPadding,
@@ -1303,7 +1477,7 @@ function composeSlide(input, options = {}) {
     unmeasuredPayloads: items.filter((item) => !headings.has(item.field) && !item.quoteLayout && !item.codeLayout && !item.metricLayout && !item.timelineLayout && !["text", "items", "bullets", "table"].includes(item.field)).map((item) => item.path)
   } : void 0;
   if (failures.length) throw new OPFCompositionError(failures, explanation);
-  return { width, height, contentBox, items, groups, flows, diagnostics, composition, ...explanation ? { explanation } : {} };
+  return { width, height, contentBox, items, groups, flows, diagnostics, composition, ...furniture ? { furniture } : {}, ...explanation ? { explanation } : {} };
 }
 function resolveCanvasDimensions(input) {
   const presets = {
@@ -1323,4 +1497,4 @@ function resolveCanvasDimensions(input) {
   return { width, height };
 }
 
-export { MAX_COMPOSITION_DEPTH, OPFCompositionError, chartColorForFill, colorContrast, composeSlide, fitList, fitRichText, fitText, layoutCode, layoutMetric, layoutQuote, layoutTable, layoutTimeline, measureText, measureTextOutline, placeTextLines, resolveCanvasDimensions, resolveFontFamilies, resolveTextStyle, tableGrid, tableRowBoundaries, textColorForFill, textWidthMeasurer, wrapText };
+export { MAX_COMPOSITION_DEPTH, OPFCompositionError, chartColorForFill, colorContrast, composeSlide, fitList, fitRichText, fitText, layoutCode, layoutFurniture, layoutMetric, layoutQuote, layoutTable, layoutTimeline, measureText, measureTextOutline, normalizeHexColor, placeTextLines, resolveCanvasDimensions, resolveColorRef, resolveFontFamilies, resolveTextStyle, tableGrid, tableRowBoundaries, textColorForFill, textWidthMeasurer, wrapText };