@openpresentation/opf 0.9.0 → 0.10.0

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

@@ -35,6 +35,45 @@ function tableRowBoundaries(value) {
   return [...allowed];
 }
 
+// src/color.ts
+function luminance(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((c) => c + c).join("")}`;
+  if (/^#[0-9a-f]{6}ff$/i.test(hex)) hex = hex.slice(0, 7);
+  if (!/^#[0-9a-f]{6}$/i.test(hex)) return void 0;
+  return [0.2126, 0.7152, 0.0722].reduce((sum, weight, index) => {
+    const offset = index * 2 + 1;
+    const n = Number.parseInt(hex.slice(offset, offset + 2), 16) / 255;
+    return sum + weight * (n <= 0.04045 ? n / 12.92 : ((n + 0.055) / 1.055) ** 2.4);
+  }, 0);
+}
+function colorContrast(foreground, background) {
+  const a = luminance(foreground), b = luminance(background);
+  return a === void 0 || b === void 0 ? void 0 : (Math.max(a, b) + 0.05) / (Math.min(a, b) + 0.05);
+}
+function textColorForFill(fill, preferred) {
+  const background = luminance(fill), contrast = colorContrast(preferred, fill);
+  if (background === void 0 || contrast === void 0 || contrast >= 4.5) return preferred;
+  return (background + 0.05) / 0.05 >= 1.05 / (background + 0.05) ? "#000000" : "#FFFFFF";
+}
+function chartColorForFill(fill, preferred) {
+  const contrast = colorContrast(preferred, fill);
+  if (contrast === void 0 || contrast >= 3) return preferred;
+  let hex = preferred.trim();
+  if (hex.length === 4) hex = `#${[...hex.slice(1)].map((c) => c + c).join("")}`;
+  const channels = [1, 3, 5].map((offset) => Number.parseInt(hex.slice(offset, offset + 2), 16));
+  for (let step = 1; step <= 255; step++) {
+    const candidates = [0, 255].map((target) => {
+      const color = `#${channels.map((channel) => Math.round(channel + (target - channel) * step / 255).toString(16).padStart(2, "0")).join("")}`.toUpperCase();
+      return { color, contrast: colorContrast(color, fill) ?? 0 };
+    }).sort((a, b) => b.contrast - a.contrast);
+    const best = candidates[0];
+    if (best && best.contrast >= 3) return best.color;
+  }
+  return textColorForFill(fill, preferred);
+}
+
 // src/composition.ts
 var MAX_COMPOSITION_DEPTH = 32;
 function resolveFontFamilies(input) {
@@ -57,6 +96,40 @@ function textWidthMeasurer(style, measurement) {
     return width;
   };
 }
+function measureTextOutline(text, fontSize, style, measurement) {
+  if (measurement?.outlineBounds === void 0) return void 0;
+  if (typeof measurement.outlineBounds !== "function") throw new TypeError("Text outline provider must be a function.");
+  const bounds = measurement.outlineBounds(text, fontSize, style);
+  if (bounds === null) return null;
+  if (!bounds || ![bounds.x, bounds.y, bounds.width, bounds.height].every(Number.isFinite) || bounds.width < 0 || bounds.height < 0) {
+    throw new RangeError("Text outline measurement must return null or finite bounds with nonnegative dimensions.");
+  }
+  return { x: bounds.x, y: bounds.y, width: bounds.width, height: bounds.height };
+}
+function placeTextLines(lines, box, alignment = "left", rasterPadding = 0) {
+  if (!Array.isArray(lines) || !box || ![box.x, box.y, box.width, box.height, rasterPadding].every(Number.isFinite) || box.width <= 0 || box.height <= 0 || rasterPadding < 0 || !["left", "center", "right"].includes(alignment)) throw new RangeError("Text placement requires lines, finite positive dimensions, nonnegative padding and a valid alignment.");
+  const factor = alignment === "right" ? 1 : alignment === "center" ? 0.5 : 0, placed = [];
+  let shift = 0, bottom = box.y, height = 0, overflow = false;
+  for (const line of lines) {
+    if (!line || ![line.width, line.y, line.baseline, line.height].every(Number.isFinite) || line.width < 0 || line.height <= 0 || line.y < 0 || line.baseline < line.y) throw new RangeError("Text lines require finite coordinates, nonnegative advances and a baseline at or below their top.");
+    const ink = line.outline;
+    if (ink !== null && (!ink || ![ink.x, ink.y, ink.width, ink.height].every(Number.isFinite) || ink.width < 0 || ink.height < 0)) throw new RangeError("Text outlines must be null or finite coordinates with nonnegative dimensions.");
+    let x = box.x + (box.width - line.width) * factor;
+    if (ink) {
+      const low = box.x + rasterPadding - ink.x, high = box.x + box.width - rasterPadding - ink.x - ink.width;
+      if (low > high + 0.01) overflow = true;
+      else x = Math.max(low, Math.min(x, high));
+      shift += Math.max(0, bottom + rasterPadding - (box.y + line.baseline + shift + ink.y));
+    }
+    const y = box.y + line.y + shift, baseline = box.y + line.baseline + shift;
+    const outline = ink ? { ...ink, x: x + ink.x, y: baseline + ink.y } : null;
+    if (outline) bottom = outline.y + outline.height + rasterPadding;
+    height = Math.max(height, y + line.height - box.y, outline ? bottom - box.y : 0);
+    if (line.width > box.width + 0.01 || height > box.height + 0.01) overflow = true;
+    placed.push({ x, y, baseline, height: line.height, width: line.width, outline });
+  }
+  return { alignment, rasterPadding, lines: placed, height, overflow };
+}
 var OPFCompositionError = class extends Error {
   constructor(diagnostics, explanation) {
     super("Slide content does not fit its composition.");
@@ -85,42 +158,22 @@ function measureText(text, fontSize) {
   return units * fontSize;
 }
 function wrapText(text, width, fontSize, measure = measureText) {
-  const result = [];
-  for (const paragraph of text.replace(/\r\n?/g, "\n").split("\n")) {
-    let line = "";
-    for (const word of paragraph.split(/\s+/u).filter(Boolean)) {
-      if (line && measure(`${line} ${word}`, fontSize) > width) {
-        result.push(line);
-        line = "";
-      }
-      if (measure(word, fontSize) <= width) {
-        line += (line ? " " : "") + word;
-        continue;
-      }
-      for (const { segment: character } of textSegments.segment(word)) {
-        if (line && measure(line + character, fontSize) > width) {
-          result.push(line);
-          line = "";
-        }
-        line += character;
-      }
-    }
-    result.push(line);
-  }
-  return result;
+  return fitSourceText(text, { width, height: Number.MAX_VALUE }, fontSize, fontSize, 1, measure, true).lines;
 }
 function fitText(text, box, requestedSize = 25, minFontSize = 16, measure = measureText) {
   if (![box.width, box.height, requestedSize, minFontSize].every(Number.isFinite) || box.width <= 0 || box.height <= 0 || requestedSize <= 0 || minFontSize <= 0) {
     throw new RangeError("Text dimensions and font sizes must be finite and positive.");
   }
-  const minimum = Math.min(minFontSize, requestedSize);
-  let fontSize = requestedSize;
-  let lines = wrapText(text, box.width, fontSize, measure);
-  while (fontSize > minimum && (lines.length * fontSize * 1.22 > box.height || lines.some((line) => measure(line, fontSize) > box.width))) {
-    fontSize = Math.max(minimum, fontSize - 1);
-    lines = wrapText(text, box.width, fontSize, measure);
+  return fitSourceText(text, box, Math.max(requestedSize, minFontSize), minFontSize, 1, measure, true);
+}
+function fitAtSizes(layout, requested, minimum, step = 1) {
+  const start = Math.max(requested, minimum);
+  if (![start, minimum, step].every((value) => Number.isFinite(value) && value > 0)) throw new RangeError("Readable font sizes and fitting steps must be finite and positive.");
+  for (let trial = 0; trial <= 64; trial++) {
+    const size = trial === 64 ? minimum : Math.max(minimum, start - trial * step), result = layout(size);
+    if (!result.overflow || size === minimum) return result;
   }
-  return { lines, fontSize, lineHeight: fontSize * 1.22, overflow: lines.length * fontSize * 1.22 > box.height + 0.01 || lines.some((line) => measure(line, fontSize) > box.width + 0.01) };
+  throw new Error("Text fitting did not evaluate its bounded floor trial.");
 }
 function layoutQuote(value, box, options = {}) {
   const shorthand = typeof value === "string";
@@ -226,10 +279,308 @@ function layoutQuote(value, box, options = {}) {
   if (diagnostics.length && options.overflow === "error") throw new OPFCompositionError(diagnostics);
   return { algorithm: "quote-flow-v1", textMeasurement: options.textMeasurement ? "provided" : "estimated", parts, diagnostics, overflow: diagnostics.length > 0 };
 }
+function layoutMetric(value, box, options = {}) {
+  const scalar = typeof value === "string" || typeof value === "number";
+  const metric = scalar ? { value } : value;
+  const isValue = (input) => typeof input === "string" || typeof input === "number" && Number.isFinite(input);
+  if (!metric || Array.isArray(metric) || !isValue(metric.value) || [metric.label, metric.description, metric.unit].some((field) => field !== void 0 && typeof field !== "string") || metric.delta !== void 0 && !isValue(metric.delta) || metric.trend !== void 0 && !["up", "down", "flat"].includes(metric.trend)) {
+    throw new TypeError("Metric content requires a finite numeric or string value and schema-valid display metadata.");
+  }
+  const scale = options.scale ?? 1, minimum = (options.minFontSize ?? 16) * scale;
+  const rasterPadding = (options.textRasterPadding ?? 1) * scale, hasOutlines = options.textMeasurement?.outlineBounds !== void 0;
+  if (![box.x, box.y, box.width, box.height, box.x + box.width, box.y + box.height, scale, minimum, Math.max(76 * scale, minimum) * 1.22].every(Number.isFinite) || box.width <= 0 || box.height <= 0 || scale <= 0 || minimum <= 0) {
+    throw new RangeError("Metric dimensions, scale and minimum font size must be finite and positive.");
+  }
+  if (!Number.isFinite(rasterPadding) || rasterPadding < 0) throw new RangeError("Metric raster padding must be finite and nonnegative.");
+  if (options.overflow !== void 0 && !["warn", "error"].includes(options.overflow)) throw new RangeError("Invalid metric overflow policy.");
+  const alignment = options.align ?? "left";
+  if (!["left", "center", "right"].includes(alignment)) throw new RangeError("Invalid metric alignment.");
+  const sourcePath = options.path ?? "metric", parts = [], diagnostics = [];
+  for (const role of ["value", "unit", "label", "description", "delta", "trend"]) {
+    const sourceValue = metric[role];
+    if (sourceValue === void 0) continue;
+    const text = String(sourceValue), path = scalar ? sourcePath : `${sourcePath}.${role}`;
+    const nominal = role === "value" ? Math.min(76 * scale, box.height * 0.28) : (role === "description" ? 20 : role === "trend" ? 18 : 23) * scale;
+    const requestedStyle = { fontFamily: (role === "value" ? options.fonts?.heading : options.fonts?.body) ?? "sans-serif", fontWeight: role === "value" ? 800 : role === "description" ? 400 : 500, italic: false, path };
+    const part = {
+      role,
+      path,
+      text,
+      sources: [{ path, value: sourceValue, start: 0, end: text.length }],
+      visible: role === "value" || text.length > 0,
+      linePositions: [],
+      box: { ...box, height: 0 },
+      requestedFontSize: Math.max(nominal, minimum),
+      minFontSize: minimum,
+      requestedStyle,
+      style: resolveTextStyle({ ...requestedStyle }, options.textMeasurement)
+    };
+    if (!part.visible) part.fit = { lines: [], sourceLines: [], fontSize: part.requestedFontSize, lineHeight: part.requestedFontSize * 1.22, tabSize: 4, tabWidth: 0, overflow: false };
+    parts.push(part);
+  }
+  const primary = parts[0], metadata = parts.filter((part) => part !== primary && part.visible), unit = metadata.find((part) => part.role === "unit");
+  const usable = (area) => [area.x, area.y, area.width, area.height, area.x + area.width, area.y + area.height].every(Number.isFinite) && area.width > 0 && area.height > 0;
+  const occupied = (fit) => fit.placement?.height ?? fit.lines.length * fit.lineHeight;
+  const gap = 8 * scale, primaryGap = 12 * scale;
+  const lineInk = (part, fit) => fit.sourceLines.map((line, index) => {
+    let outline = null;
+    for (const segment of line.segments) {
+      if (segment.kind !== "text") continue;
+      const bounds = measureTextOutline(part.text.slice(segment.start, segment.end), fit.fontSize, part.style, options.textMeasurement);
+      if (!bounds) continue;
+      const next = { ...bounds, x: segment.x + bounds.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: index * fit.lineHeight, baseline: fit.fontSize + index * fit.lineHeight, height: fit.lineHeight, outline };
+  });
+  const place = (part, fit, width) => {
+    if (!hasOutlines) return fit;
+    const placement = placeTextLines(lineInk(part, fit), { x: 0, y: 0, width, height: Number.MAX_VALUE }, alignment, rasterPadding);
+    return { ...fit, placement, overflow: placement.overflow };
+  };
+  const naturalWidth = (part, fit) => {
+    if (!hasOutlines) return Math.max(...fit.sourceLines.map((line) => line.width));
+    const width = Math.max(...lineInk(part, fit).map((line) => Math.max(line.width, line.outline ? line.outline.x + line.outline.width : 0) - Math.min(0, line.outline?.x ?? 0)));
+    return width > 0 ? width + 2 * rasterPadding : 0;
+  };
+  const cache = /* @__PURE__ */ new Map();
+  const measure = (part, size, width) => {
+    const key = JSON.stringify([part.role, size, width]);
+    let fit = cache.get(key);
+    if (!fit) {
+      fit = fitCodeText(part.text, { ...box, width: hasOutlines ? Math.max(Number.MIN_VALUE, width - 2 * rasterPadding) : width }, size, size, scale, textWidthMeasurer(part.style, options.textMeasurement));
+      fit = place(part, fit, width);
+      if (!Number.isFinite(occupied(fit))) throw new RangeError("Metric text layout exceeds finite coordinates.");
+      cache.set(key, fit);
+    }
+    return fit;
+  };
+  const fitValue = (area, singleLine) => {
+    if (!usable(area)) return void 0;
+    for (let step = 0; step <= 76; step++) {
+      const size = Math.max(minimum, primary.requestedFontSize - step * scale);
+      const natural = measure(primary, size, area.width);
+      const fit = { ...natural, overflow: !!natural.placement?.overflow || singleLine && natural.lines.length !== 1 || occupied(natural) > area.height + 0.01 || natural.sourceLines.some((line) => line.width > area.width + 0.01) };
+      if (!fit.overflow || size === minimum) return fit;
+    }
+  };
+  let selected, attempts = 0;
+  const reductions = Math.min(23, Math.ceil(Math.max(0, ...metadata.map((part) => (part.requestedFontSize - minimum) / scale))));
+  for (let reduction = 0; reduction <= reductions; reduction++) {
+    const measured = new Map(metadata.map((part) => [part, measure(part, Math.max(minimum, part.requestedFontSize - reduction * scale), box.width)]));
+    const measuredUnit = unit ? measured.get(unit) : void 0;
+    const unitWidth = unit && measuredUnit ? naturalWidth(unit, measuredUnit) : 0;
+    const unitFit = unit && measuredUnit && unitWidth > 0 ? place(unit, measuredUnit, unitWidth) : measuredUnit;
+    const inline = unitFit?.lines.length === 1 && unitWidth > 0 && unitWidth <= box.width * 0.35 && unitWidth + gap < box.width;
+    for (const arrangement of inline ? ["inline-unit", "stacked"] : ["stacked"]) {
+      attempts++;
+      const tail = metadata.filter((part) => arrangement !== "inline-unit" || part !== unit);
+      const tailHeight = tail.reduce((sum, part) => sum + occupied(measured.get(part)), 0) + Math.max(0, tail.length - 1) * gap;
+      if (!Number.isFinite(tailHeight)) throw new RangeError("Metric metadata exceeds finite coordinates.");
+      const area = { ...box, width: arrangement === "inline-unit" ? box.width - unitWidth - gap : box.width, height: box.height - tailHeight - (tail.length ? primaryGap : 0) };
+      const valueFit = fitValue(area, arrangement === "inline-unit"), valueHeight = valueFit ? occupied(valueFit) : 0;
+      const allocations = [];
+      let primaryHeight = valueHeight;
+      if (arrangement === "inline-unit" && unit && unitFit && valueFit) {
+        const valueBaseline = valueFit.placement?.lines.at(-1)?.baseline ?? valueHeight - valueFit.lineHeight + valueFit.fontSize;
+        const unitBaseline = unitFit.placement?.lines.at(-1)?.baseline ?? occupied(unitFit) - unitFit.lineHeight + unitFit.fontSize;
+        const valueY = box.y + Math.max(0, unitBaseline - valueBaseline), unitY = box.y + Math.max(0, valueBaseline - unitBaseline);
+        const measuredWidth = naturalWidth(primary, valueFit);
+        const valueWidth = Math.min(area.width, measuredWidth || valueFit.fontSize);
+        allocations.push({ part: primary, box: { ...area, y: valueY, width: valueWidth, height: valueHeight }, fit: place(primary, valueFit, valueWidth) });
+        allocations.push({ part: unit, box: { x: box.x + valueWidth + gap, y: unitY, width: unitWidth, height: occupied(unitFit) }, fit: { ...unitFit, overflow: !!unitFit.placement?.overflow } });
+        primaryHeight = Math.max(valueY - box.y + valueHeight, unitY - box.y + occupied(unitFit));
+      } else allocations.push({ part: primary, box: valueFit ? { ...area, height: valueHeight } : area, fit: valueFit });
+      let y = box.y + primaryHeight + (tail.length ? primaryGap : 0);
+      for (const part of tail) {
+        const natural = measured.get(part), height = occupied(natural);
+        allocations.push({ part, box: { ...box, y, height }, fit: { ...natural, overflow: !!natural.placement?.overflow || natural.sourceLines.some((line) => line.width > box.width + 0.01) } });
+        y += height + gap;
+      }
+      const overflow = !valueFit || valueFit.overflow || arrangement === "inline-unit" && valueFit.lines.length !== 1 || primaryHeight > area.height + 0.01 || allocations.some(({ box: area2, fit }) => !fit || fit.overflow || !usable(area2) || area2.y + area2.height > box.y + box.height + 0.01);
+      const score = allocations.reduce((sum, { part, fit }) => sum + (part.requestedFontSize - (fit?.fontSize ?? minimum)) / scale, 0);
+      const candidate = { arrangement, allocations, score, overflow };
+      if (!selected || !overflow && (selected.overflow || score < selected.score) || overflow && selected.overflow) selected = candidate;
+    }
+    if (selected && !selected.overflow && selected.score === 0) break;
+  }
+  for (const allocation of selected.allocations) {
+    allocation.part.box = allocation.box;
+    allocation.part.fit = allocation.fit;
+  }
+  const alignmentFactor = alignment === "center" ? 0.5 : alignment === "right" ? 1 : 0;
+  if (selected.arrangement === "inline-unit" && unit) {
+    const offset = (box.width - (unit.box.x + unit.box.width - box.x)) * alignmentFactor;
+    primary.box.x += offset;
+    unit.box.x += offset;
+  }
+  for (const part of parts) if (part.fit) {
+    if (part.fit.placement) {
+      part.fit = { ...part.fit, placement: { ...part.fit.placement, lines: part.fit.placement.lines.map((line) => ({ ...line, x: line.x + part.box.x, y: line.y + part.box.y, baseline: line.baseline + part.box.y, outline: line.outline ? { ...line.outline, x: line.outline.x + part.box.x, y: line.outline.y + part.box.y } : null })) } };
+      part.linePositions = part.fit.placement.lines.map(({ x, baseline }) => ({ x, baseline }));
+    } else part.linePositions = part.fit.sourceLines.map((line, index) => ({
+      x: part.box.x + (part.box.width - line.width) * alignmentFactor,
+      baseline: part.box.y + part.fit.fontSize + index * part.fit.lineHeight
+    }));
+  }
+  const report = (reason, part, roles, message) => diagnostics.push({ code: "text-overflow", reason, path: part.path, parts: roles, message });
+  for (const part of parts.filter((part2) => part2.visible)) {
+    if (!part.fit || !usable(part.box)) report("invalid-part-box", part, [part.role], `Metric ${part.role} has no usable space after metadata; increase the cell or change the arrangement.`);
+    else if (part.fit.overflow) report("text-fit", part, [part.role], `Metric ${part.role} exceeds its space at the readability floor; increase the cell or change the arrangement.`);
+    if (usable(part.box) && (part.box.x < box.x || part.box.y < box.y || part.box.x + part.box.width > box.x + box.width + 0.01 || part.box.y + part.box.height > box.y + box.height + 0.01)) {
+      report("part-outside-cell", part, [part.role], `Metric ${part.role} extends outside its cell; increase the cell or change the arrangement.`);
+    }
+  }
+  const visible = parts.filter((part) => part.visible && part.fit);
+  for (const [index, first] of visible.entries()) for (const second of visible.slice(index + 1)) {
+    if (first.box.x < second.box.x + second.box.width - 0.01 && second.box.x < first.box.x + first.box.width - 0.01 && first.box.y < second.box.y + occupied(second.fit) - 0.01 && second.box.y < first.box.y + occupied(first.fit) - 0.01) {
+      report("part-overlap", first, [first.role, second.role], "Metric part line boxes overlap; do not accept this layout without more space.");
+    }
+  }
+  if (diagnostics.length && options.overflow === "error") throw new OPFCompositionError(diagnostics);
+  return { algorithm: "metric-flow-v1", alignment, textMeasurement: options.textMeasurement ? "provided" : "estimated", arrangement: selected.arrangement, attempts, parts, diagnostics, overflow: diagnostics.length > 0 };
+}
+function layoutTimeline(value, box, options = {}) {
+  const shorthand = Array.isArray(value), timeline = shorthand ? { events: value } : value;
+  if (!timeline || !Array.isArray(timeline.events) || !timeline.events.length || [timeline.name, timeline.description].some((field) => field !== void 0 && typeof field !== "string") || timeline.events.some((event) => !event || typeof event.what !== "string" || [event.when, event.description].some((field) => field !== void 0 && typeof field !== "string"))) {
+    throw new TypeError("Timeline content requires ordered events with string labels and optional string metadata.");
+  }
+  const scale = options.scale ?? 1, minimum = (options.minFontSize ?? 16) * scale, padding = (options.textRasterPadding ?? 1) * scale;
+  if (![box.x, box.y, box.width, box.height, scale, minimum, padding].every(Number.isFinite) || box.width <= 0 || box.height <= 0 || scale <= 0 || minimum <= 0 || padding < 0) throw new RangeError("Timeline dimensions, scale and minimum must be positive, with finite nonnegative raster padding.");
+  if (options.overflow !== void 0 && !["warn", "error"].includes(options.overflow)) throw new RangeError("Invalid timeline overflow policy.");
+  const outlines = options.textMeasurement?.outlineBounds !== void 0;
+  if (outlines && typeof options.textMeasurement?.outlineBounds !== "function") throw new TypeError("Text outline provider must be a function.");
+  const path = options.path ?? "timeline", eventPath = (index) => shorthand ? `${path}.${index}` : `${path}.events.${index}`;
+  const fonts = resolveFontFamilies(options.fonts), source = [];
+  const add = (role, text, partPath, size, weight, eventIndex) => {
+    if (text === void 0) return;
+    const requestedStyle = { fontFamily: fonts.body, fontWeight: weight, italic: false, path: partPath };
+    source.push({ role, eventIndex, path: partPath, text, sources: [{ path: partPath, start: 0, end: text.length }], box: { ...box }, alignment: "center", requestedFontSize: Math.max(size * scale, minimum), minFontSize: minimum, requestedStyle, style: resolveTextStyle({ ...requestedStyle }, options.textMeasurement) });
+  };
+  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);
+  });
+  const metadata = [], events = timeline.events.map(() => []);
+  for (const part of source) if (part.eventIndex === void 0) metadata.push(part);
+  else events[part.eventIndex].push(part);
+  const cache = /* @__PURE__ */ new Map();
+  const measure = (part, size, width, alignment) => {
+    const key = JSON.stringify([part.path, size, width, alignment]);
+    let measured = cache.get(key);
+    if (measured) return measured;
+    const fit = fitText(part.text, { width: Math.max(Number.MIN_VALUE, width - (outlines ? 2 * padding : 0)), height: Number.MAX_VALUE }, size, size, textWidthMeasurer(part.style, options.textMeasurement));
+    const ink = fit.sourceLines.map((line, index) => {
+      let left = Infinity, top = Infinity, right = -Infinity, bottom = -Infinity, hasInk = false;
+      if (outlines) {
+        for (const segment of line.segments) if (segment.kind === "text") {
+          const outline = measureTextOutline(part.text.slice(segment.start, segment.end), size, part.style, options.textMeasurement);
+          if (outline) {
+            hasInk = true;
+            left = Math.min(left, outline.x + segment.x);
+            top = Math.min(top, outline.y);
+            right = Math.max(right, outline.x + segment.x + outline.width);
+            bottom = Math.max(bottom, outline.y + outline.height);
+          }
+        }
+      }
+      return { width: line.width, y: index * fit.lineHeight, baseline: size + index * fit.lineHeight, height: fit.lineHeight, outline: hasInk ? { x: left, y: top, width: right - left, height: bottom - top } : null };
+    });
+    const placement = outlines ? placeTextLines(ink, { x: 0, y: 0, width, height: Number.MAX_VALUE }, alignment, padding) : void 0;
+    const height = placement?.height ?? fit.sourceLines.length * fit.lineHeight;
+    if (!Number.isFinite(height)) throw new RangeError("Timeline text exceeds finite layout coordinates.");
+    measured = { fit, ink, height };
+    cache.set(key, measured);
+    return measured;
+  };
+  let selected, attempts = 0;
+  let reductionLimit = 0;
+  for (const part of source) reductionLimit = Math.max(reductionLimit, (part.requestedFontSize - minimum) / scale);
+  const reductions = Math.min(24, Math.ceil(reductionLimit));
+  for (let reduction = 0; reduction <= reductions; reduction++) {
+    for (const arrangement of ["alternating", "vertical"]) {
+      attempts++;
+      const parts = [], markers = [], diagnostics = [];
+      let score2 = 0;
+      const report = (part, reason, message, excess = 1) => {
+        diagnostics.push({ code: "text-overflow", reason, path: part.path, message });
+        score2 += Math.max(1, excess);
+      };
+      const place = (part, x, y2, width, alignment) => {
+        const measured = measure(part, Math.max(minimum, part.requestedFontSize - reduction * scale), Math.max(scale, width), alignment);
+        const area = { x, y: y2, width: Math.max(scale, width), height: Math.max(scale, measured.height) }, placement = outlines ? placeTextLines(measured.ink, area, alignment, padding) : void 0;
+        const fit = { ...measured.fit, ...placement ? { placement } : {}, overflow: measured.fit.overflow || !!placement?.overflow };
+        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 (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;
+      };
+      let y = box.y;
+      for (const part of metadata) {
+        const placed = place(part, box.x, y, box.width, "center");
+        y += placed.box.height + 8 * scale;
+      }
+      const available = box.y + box.height - y, count = events.length, radius = Math.min(9 * scale, box.width / Math.max(2, count) / 5, Math.max(scale, available) * 0.04);
+      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;
+        events.forEach((fields2, index) => {
+          const x = start + index * step, top = index % 2 === 0 ? y : lineY + 24 * scale, bottom = index % 2 === 0 ? lineY - 24 * scale : box.y + box.height;
+          markers.push({ path: eventPath(index), eventIndex: index, x, y: lineY, radius });
+          let cursor = top;
+          for (const part of fields2) {
+            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);
+          }
+        });
+      } else {
+        const x = box.x + radius, textX = box.x + 24 * scale, width = box.width - 24 * scale;
+        events.forEach((fields2, index) => {
+          const top = y;
+          let first2;
+          for (const part of fields2) {
+            const placed = place(part, textX, y, width, "left");
+            first2 ??= placed;
+            y += placed.box.height;
+          }
+          markers.push({ path: eventPath(index), eventIndex: index, x, y: top + Math.min(first2?.box.height ?? 2 * radius, 2 * radius) / 2, radius });
+          y += 16 * scale;
+        });
+      }
+      for (const marker of markers) if (marker.x - marker.radius < box.x - 0.01 || marker.y - marker.radius < box.y - 0.01 || marker.x + marker.radius > box.x + box.width + 0.01 || marker.y + marker.radius > box.y + box.height + 0.01) {
+        diagnostics.push({ code: "text-overflow", reason: "event-space", path: marker.path, message: "Timeline marker has no usable space; increase the cell or paginate events." });
+        score2 += 1;
+      }
+      const first = markers[0], last = markers.at(-1), connector = { x1: first.x, y1: first.y, x2: last.x, y2: last.y };
+      const candidate = { arrangement, parts, markers, connector, diagnostics, score: score2 };
+      if (!selected || score2 < selected.score) selected = candidate;
+      if (!diagnostics.length) break;
+    }
+    if (!selected.diagnostics.length) break;
+  }
+  const { score, ...result } = selected;
+  if (result.diagnostics.length && options.overflow === "error") throw new OPFCompositionError(result.diagnostics);
+  return { algorithm: "timeline-flow-v1", attempts, textMeasurement: options.textMeasurement ? "provided" : "estimated", textOutlines: outlines ? "provided" : "unavailable", ...result, overflow: result.diagnostics.length > 0 };
+}
 function fitCodeText(text, box, size, minimum, step, measure) {
+  return fitSourceText(text, box, size, minimum, step, measure);
+}
+function fitSourceText(text, box, size, minimum, step, measure, prose = false) {
   const layout = (fontSize) => {
     const tabWidth = measure(" ", fontSize) * 4;
-    if (!Number.isFinite(tabWidth) || text.includes("	") && tabWidth <= 0) throw new RangeError("Code tabs require a positive finite measured space advance.");
+    if (!Number.isFinite(tabWidth) || text.includes("	") && tabWidth <= 0) throw new RangeError("Text tabs require a positive finite measured space advance.");
     const measureLine = (start2, end2, record3 = false) => {
       let x = 0, offset = start2;
       const segments = [];
@@ -257,7 +608,8 @@ function fitCodeText(text, box, size, minimum, step, measure) {
       start = nextStart;
       end = nextStart;
     };
-    for (const token of text.matchAll(/\r\n|\r|\n|[^\S\r\n]+|[^\s]+/gu)) {
+    const tokens = prose ? /\r\n|\r|\n|[^\S\r\n\u00a0\u202f\ufeff]+|(?:[^\s]|\u00a0|\u202f|\ufeff)+/gu : /\r\n|\r|\n|[^\S\r\n]+|[^\s]+/gu;
+    for (const token of text.matchAll(tokens)) {
       if (token.index === void 0) throw new Error("Missing code token source offset.");
       const a = token.index, b = a + token[0].length;
       if (/^[\r\n]/.test(token[0])) {
@@ -273,6 +625,10 @@ function fitCodeText(text, box, size, minimum, step, measure) {
         end = b;
         continue;
       }
+      if (prose && /[\u00a0\u202f\u2060\ufeff]/u.test(token[0])) {
+        end = b;
+        continue;
+      }
       for (const segment of textSegments.segment(token[0])) {
         const next = a + segment.index + segment.segment.length;
         if (end > start && width(start, next) > box.width + 0.01) push(a + segment.index, a + segment.index, "soft");
@@ -291,12 +647,7 @@ function fitCodeText(text, box, size, minimum, step, measure) {
       overflow: sourceLines.length * lineHeight > box.height + 0.01 || sourceLines.some((line) => line.width > box.width + 0.01)
     };
   };
-  let result = layout(size);
-  while (result.overflow && size > minimum) {
-    size = Math.max(minimum, size - step);
-    result = layout(size);
-  }
-  return result;
+  return fitAtSizes(layout, size, minimum, step);
 }
 function layoutCode(value, box, options = {}) {
   const shorthand = typeof value === "string", code = shorthand ? { source: value } : value;
@@ -376,13 +727,19 @@ function layoutCode(value, box, options = {}) {
 }
 function fitRichText(input, box, requestedSize = 25, minFontSize = 16, options = { style: { fontFamily: "sans-serif", fontWeight: 400 } }) {
   if (![box.width, box.height, requestedSize, minFontSize].every((value) => Number.isFinite(value) && value > 0)) throw new RangeError("Rich text dimensions and font sizes must be finite and positive.");
-  const layout = richTextLayouter(input, box, requestedSize, options), minimum = Math.min(requestedSize, minFontSize);
-  let size = requestedSize, result = layout(size);
-  while (result.overflow && size > minimum) {
-    size = Math.max(minimum, size - 1);
-    result = layout(size);
+  const layout = richTextLayouter(input, box, requestedSize, options);
+  return fitAtSizes(layout, requestedSize, richMinimum(input, requestedSize, minFontSize));
+}
+function richMinimum(input, requested, minimum) {
+  let floor = Math.min(requested, minimum), visible = false;
+  for (const value of input) {
+    const run = typeof value === "string" ? { text: value } : value;
+    if (!run.text) continue;
+    const ratio = (run.fontSize === void 0 ? 1 : run.fontSize * 4 / 3 / requested) * (run.superscript || run.subscript ? 0.7 : 1);
+    floor = Math.max(floor, minimum / ratio);
+    visible = true;
   }
-  return result;
+  return visible ? floor : minimum;
 }
 function richTextLayouter(input, box, requestedSize, options) {
   let offset = 0;
@@ -516,13 +873,12 @@ function fitList(input, box, requestedSize = 25, minFontSize = 16, options = { s
     const height = y - box.y;
     return { listEntries: entries, lines, fontSize, lineHeight: fontSize * 1.22, height, overflow: overflow || height > box.height + 0.01 };
   };
-  const minimum = Math.min(requestedSize, minFontSize);
-  let size = requestedSize, result = layout(size);
-  while (result.overflow && size > minimum) {
-    size = Math.max(minimum, size - 1);
-    result = layout(size);
+  let minimum = minFontSize;
+  for (const item of source) {
+    minimum = Math.max(minimum, richMinimum(item.runs, requestedSize, minFontSize));
+    if (item.descriptionRuns !== void 0) minimum = Math.max(minimum, richMinimum(item.descriptionRuns, requestedSize * 0.82, minFontSize) / 0.82);
   }
-  return result;
+  return fitAtSizes(layout, requestedSize, minimum);
 }
 function contentText(field, value) {
   if (field === "text" || headings.has(field)) return flatten(value);
@@ -536,7 +892,7 @@ ${flatten(entry.description)}` : ""}`;
   return void 0;
 }
 function layoutTable(value, box, options = {}) {
-  const scale = options.scale ?? 1, requested = 15 * scale, minimum = (options.minFontSize ?? 16) * scale;
+  const scale = options.scale ?? 1, minimum = (options.minFontSize ?? 16) * scale, requested = Math.max(15 * scale, minimum);
   if (![box.x, box.y, box.width, box.height, scale, minimum].every(Number.isFinite) || box.width <= 0 || box.height <= 0 || scale <= 0 || minimum <= 0) throw new RangeError("Table dimensions, scale and font sizes must be finite and positive.");
   const grid = tableGrid(value, options.path ?? "table");
   if (grid.issues.length) throw new RangeError(`${grid.issues[0].path}: ${grid.issues[0].message}`);
@@ -547,20 +903,26 @@ function layoutTable(value, box, options = {}) {
     const style = { fontFamily: options.fontFamily ?? "sans-serif", fontWeight: cell.header ? 700 : 400, italic: false, path: cell.valuePath };
     return { ...cell, padding, width, textStyle: style };
   });
+  const cellMinimum = (cell) => Array.isArray(cell.value) ? richMinimum(cell.value, requested, minimum) : minimum;
   const fitCell = (cell, height, min) => {
     const textBox = { width: Math.max(scale, cell.width), height: Math.max(scale, height) };
     return Array.isArray(cell.value) ? fitRichText(cell.value, textBox, requested, min, { style: cell.textStyle, textMeasurement: options.textMeasurement, uniformLineHeight: true }) : fitText(flatten(cell.value), textBox, requested, min, textWidthMeasurer(resolveTextStyle(cell.textStyle, options.textMeasurement), options.textMeasurement));
   };
   const textHeight = (fit) => "height" in fit ? fit.height : fit.lines.length * fit.lineHeight;
-  const required = (cell, size) => textHeight(fitCell(cell, scale, size)) + (cell.padding.top + cell.padding.bottom) * scale;
+  const required = (cell, natural2) => {
+    const floor = cellMinimum(cell), size = natural2 ? Math.max(requested, floor) : floor;
+    const textBox = { width: Math.max(scale, cell.width), height: scale };
+    const fit = Array.isArray(cell.value) ? richTextLayouter(cell.value, textBox, requested, { style: cell.textStyle, textMeasurement: options.textMeasurement, uniformLineHeight: true })(size) : fitText(flatten(cell.value), textBox, size, size, textWidthMeasurer(resolveTextStyle(cell.textStyle, options.textMeasurement), options.textMeasurement));
+    return textHeight(fit) + (cell.padding.top + cell.padding.bottom) * scale;
+  };
   const natural = Array(grid.rowCount).fill(0), needed = Array(grid.rowCount).fill(0);
   for (const cell of cells) if (cell.rowSpan === 1) {
-    natural[cell.row] = Math.max(natural[cell.row], required(cell, requested));
-    needed[cell.row] = Math.max(needed[cell.row], required(cell, minimum));
+    natural[cell.row] = Math.max(natural[cell.row], required(cell, true));
+    needed[cell.row] = Math.max(needed[cell.row], required(cell, false));
   }
-  for (const cell of cells) if (cell.rowSpan > 1) for (const [heights2, size] of [[natural, requested], [needed, minimum]]) {
+  for (const cell of cells) if (cell.rowSpan > 1) for (const [heights2, preferredSize] of [[natural, true], [needed, false]]) {
     const current = heights2.slice(cell.row, cell.row + cell.rowSpan).reduce((a, b) => a + b, 0);
-    const extra = Math.max(0, required(cell, size) - current) / cell.rowSpan;
+    const extra = Math.max(0, required(cell, preferredSize) - current) / cell.rowSpan;
     for (let r = cell.row; r < cell.row + cell.rowSpan; r++) heights2[r] += extra;
   }
   const preferred = natural.map((height) => Math.max(54 * scale, height));
@@ -650,28 +1012,80 @@ function composeSlide(input, options = {}) {
   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 hasCards = record2(slide.design).contentBox ?? options.contentBox ?? false;
   const composition = { ...record2(layout.composition), ...record2(slide.composition) };
   assertComposition(composition);
   const padding = (composition.padding ?? 0.08) * Math.min(width, height);
   const gap = (composition.gap ?? 1 / 30) * Math.min(width, height);
   const minSize = (composition.minFontSize ?? 16) * scale;
+  const rasterPadding = (options.textRasterPadding ?? 1) * scale;
+  if (!Number.isFinite(rasterPadding) || rasterPadding < 0) throw new RangeError("Text raster padding must be finite and nonnegative.");
   const styleFor = (field, path2) => resolveTextStyle({
     fontFamily: (field === "title" ? options.fonts?.heading : field === "code" ? options.fonts?.code : options.fonts?.body) ?? (field === "code" ? "monospace" : "sans-serif"),
     fontWeight: field === "title" ? 700 : 400,
     path: path2
   }, options.textMeasurement);
   const widthFor = (field, path2) => textWidthMeasurer(styleFor(field, path2), options.textMeasurement);
-  const fitContent = (field, value, text, box, size, minimum, path2) => field === "text" && Array.isArray(value) ? fitRichText(value, box, size, minimum, { style: styleFor(field, path2), textMeasurement: options.textMeasurement }) : 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 fitPlacedText = (field, value, text, box, size, minimum, path2) => {
+    const style = styleFor(field, path2), rich = field === "text" && Array.isArray(value);
+    if (!options.textMeasurement?.outlineBounds) return rich ? fitRichText(value, box, size, minimum, { style, textMeasurement: options.textMeasurement }) : fitText(text, box, size, minimum, textWidthMeasurer(style, options.textMeasurement));
+    const alignment = (field === "title" ? record2(slide.design).titleAlignment ?? options.titleAlignment : record2(slide.design).contentAlignment ?? options.contentAlignment) ?? "left";
+    const richLayout = rich ? richTextLayouter(value, box, size, { style, textMeasurement: options.textMeasurement }) : void 0;
+    const measure = textWidthMeasurer(style, options.textMeasurement), floor = rich ? richMinimum(value, size, minimum) : minimum, start = Math.max(size, floor);
+    for (let trial = 0; trial <= 64; trial++) {
+      const fontSize = trial === 64 ? floor : Math.max(floor, start - trial * scale);
+      const fit = richLayout ? richLayout(fontSize) : fitText(text, box, fontSize, fontSize, measure);
+      const richLines = "richLines" in fit ? fit.richLines : void 0;
+      const lines = richLines ? richLines.map((line) => {
+        let outline = null;
+        for (const fragment of line.fragments) {
+          const bounds = measureTextOutline(fragment.text, fragment.fontSize, fragment.style, options.textMeasurement);
+          if (!bounds) continue;
+          const next = { ...bounds, x: fragment.x + bounds.x, y: fragment.baselineShift + bounds.y };
+          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: line.y, baseline: line.baseline, height: line.height, outline };
+      }) : fit.sourceLines.map((line, index) => {
+        let outline = null;
+        for (const segment of line.segments) {
+          if (segment.kind === "tab") continue;
+          const bounds = measureTextOutline(text.slice(segment.start, segment.end), fontSize, style, options.textMeasurement);
+          if (!bounds) continue;
+          const next = { ...bounds, x: segment.x + bounds.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: index * fit.lineHeight, baseline: fontSize + index * fit.lineHeight, height: fit.lineHeight, outline };
+      });
+      const placement = placeTextLines(lines, box, alignment, rasterPadding), result = { ...fit, placement, overflow: fit.overflow || placement.overflow };
+      if (!result.overflow || fontSize === floor) return result;
+    }
+    throw new Error("Text placement did not evaluate its bounded floor trial.");
+  };
+  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;
   for (const field of ["tag", "title", "subtitle"]) {
     if (!slide[field]) continue;
     const requested = (field === "title" ? 54 : field === "tag" ? 16 : 25) * scale;
-    const maxHeight = height * (field === "title" ? 0.26 : field === "subtitle" ? 0.12 : 0.045);
+    const maxHeight = Math.max(height * (field === "title" ? 0.26 : field === "subtitle" ? 0.12 : 0.045), minSize * 1.22 + 2 * rasterPadding);
     const box = { x: padding, y, width: width - padding * 2, height: maxHeight };
-    const text = fitText(String(slide[field]), box, requested, minSize, widthFor(field, `${path}.${field}`));
-    box.height = Math.min(maxHeight, text.lines.length * text.lineHeight);
+    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));
     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;
   }
@@ -708,6 +1122,11 @@ function composeSlide(input, options = {}) {
     return { x: box.x + amount, y: box.y + amount, width: box.width - amount * 2, height: box.height - amount * 2 };
   };
   const acceptedBox = (box) => ({ x: round(box.x), y: round(box.y), width: round(box.width), height: round(box.height) });
+  const payloadBox = (box) => {
+    if (!hasCards) 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 });
+  };
   const measureQuote = (node, box, settings) => layoutQuote(node.value, acceptedBox(box), {
     fonts: options.fonts,
     textMeasurement: options.textMeasurement,
@@ -722,12 +1141,30 @@ function composeSlide(input, options = {}) {
     minFontSize: settings.minFontSize,
     path: node.path
   });
+  const measureMetric = (node, box, settings) => layoutMetric(node.value, acceptedBox(box), {
+    fonts: options.fonts,
+    textMeasurement: options.textMeasurement,
+    scale,
+    minFontSize: settings.minFontSize,
+    path: node.path,
+    textRasterPadding: options.textRasterPadding,
+    align: record2(slide.design).contentAlignment ?? options.contentAlignment
+  });
+  const measureTimeline = (node, box, settings) => layoutTimeline(node.value, acceptedBox(box), {
+    fonts: options.fonts,
+    textMeasurement: options.textMeasurement,
+    scale,
+    minFontSize: settings.minFontSize,
+    path: node.path,
+    textRasterPadding: options.textRasterPadding
+  });
   const leafScore = (node, box, settings, penalties) => {
+    box = payloadBox(box);
     const text = contentText(node.field, node.value);
     let score = Math.abs(Math.log(box.width / box.height / 1.6));
     if (penalties) penalties.cellProportions += score;
-    if (node.field === "quote" || node.field === "code") {
-      const internal = node.field === "quote" ? measureQuote(node, box, settings) : measureCode(node, box, settings);
+    if (node.field === "quote" || node.field === "code" || node.field === "metric" || node.field === "timeline") {
+      const internal = node.field === "quote" ? measureQuote(node, box, settings) : node.field === "code" ? measureCode(node, box, settings) : node.field === "metric" ? measureMetric(node, box, settings) : measureTimeline(node, box, settings);
       const reduction = internal.parts.reduce((sum, part) => sum + (part.fit ? (part.requestedFontSize - part.fit.fontSize) / scale : 0), 0);
       score += reduction + (internal.overflow ? 1e3 : 0);
       if (penalties) {
@@ -736,7 +1173,7 @@ function composeSlide(input, options = {}) {
       }
     } else if (text) {
       const fit = fitContent(node.field, node.value, text, box, 25 * scale, (settings.minFontSize ?? 16) * scale, node.path);
-      const reduction = (25 * scale - fit.fontSize) / scale;
+      const reduction = Math.max(0, 25 * scale - fit.fontSize) / scale;
       score += reduction + (fit.overflow ? 1e3 : 0);
       if (penalties) {
         penalties.fontReduction += reduction;
@@ -798,16 +1235,20 @@ function composeSlide(input, options = {}) {
     const boxes = grid.boxes;
     if (!nodes.some((node) => node.region)) flows.push({ path: containerPath, box: { ...area }, composition: { ...settings }, columns: grid.columns, rows: grid.rows, gap: grid.gap, itemCount: nodes.length, slotCount: count });
     nodes.forEach((node, index) => {
-      const box = node.region ? regionBox(node.region, area, actualGap) : boxes[index];
+      let box = node.region ? regionBox(node.region, area, actualGap) : boxes[index];
       if (node.children) {
         const own = inheritedSettings(settings, node.composition), inner = inset(box, own);
         groups.push({ path: node.path, box, contentBox: inner, composition: own });
         arrange(node.children, inner, own, 0, (own.gap ?? 1 / 30) * Math.min(box.width, box.height), node.path);
       } else {
+        const frameBox = hasCards ? acceptedBox(box) : void 0;
+        box = payloadBox(box);
         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 internal = quoteLayout ?? codeLayout, body = internal?.parts.find((part) => part.role === "body");
+        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 text = internal ? body?.fit : textValue !== void 0 ? fitContent(node.field, node.value, textValue, box, 25 * scale, (settings.minFontSize ?? 16) * scale, node.path) : void 0;
         items.push({
           path: node.path,
@@ -816,11 +1257,14 @@ function composeSlide(input, options = {}) {
           value: node.value,
           payload: node.payload,
           box: internal ? acceptedBox(box) : box,
+          ...frameBox ? { frameBox } : {},
           text,
           textStyle: body?.style ?? styleFor(node.field, node.path),
           composition: settings,
           ...quoteLayout ? { quoteLayout } : {},
-          ...codeLayout ? { codeLayout } : {}
+          ...codeLayout ? { codeLayout } : {},
+          ...metricLayout ? { metricLayout } : {},
+          ...timelineLayout ? { timelineLayout } : {}
         });
         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." });
       }
@@ -834,6 +1278,8 @@ function composeSlide(input, options = {}) {
     if (item.field === "table" && tableOverflows(item.value, item.box, scale, item.composition, options, item.path)) diagnostics.push({ code: "text-overflow", path: item.path, message: "Table cells do not fit; use fewer rows, fewer columns, or split the table across slides." });
     if (item.quoteLayout) diagnostics.push(...item.quoteLayout.diagnostics);
     else if (item.codeLayout) diagnostics.push(...item.codeLayout.diagnostics);
+    else if (item.metricLayout) diagnostics.push(...item.metricLayout.diagnostics);
+    else if (item.timelineLayout) diagnostics.push(...item.timelineLayout.diagnostics);
     else if (item.text?.overflow) diagnostics.push({ code: "text-overflow", path: item.path, message: "Text exceeds its cell at the minimum font size; shorten it, increase its space, or split the slide." });
   }
   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]);
@@ -849,10 +1295,12 @@ function composeSlide(input, options = {}) {
     return false;
   });
   const explanation = decisions ? {
-    algorithm: "grid-score-v3",
+    algorithm: "grid-score-v8",
     textMeasurement: options.textMeasurement ? "provided" : "estimated",
+    textOutlines: options.textMeasurement?.outlineBounds ? "provided" : "unavailable",
+    textRasterPadding: rasterPadding,
     decisions,
-    unmeasuredPayloads: items.filter((item) => !headings.has(item.field) && !item.quoteLayout && !item.codeLayout && !["text", "items", "bullets", "table"].includes(item.field)).map((item) => item.path)
+    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 } : {} };
@@ -875,4 +1323,4 @@ function resolveCanvasDimensions(input) {
   return { width, height };
 }
 
-export { MAX_COMPOSITION_DEPTH, OPFCompositionError, composeSlide, fitList, fitRichText, fitText, layoutCode, layoutQuote, layoutTable, measureText, resolveCanvasDimensions, resolveFontFamilies, resolveTextStyle, tableGrid, tableRowBoundaries, textWidthMeasurer, wrapText };
+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 };