@openpresentation/opf 0.13.0 → 0.14.0

package/dist/{chunk-MPM7NRG7.js → chunk-6OXY2CP3.js}

@@ -1,4 +1,4 @@
-import { catalogs } from './chunk-E34DJ5LL.js';
+import { catalogs } from './chunk-XOZ4KMSR.js';
 
 // src/table.ts
 var record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
@@ -7,7 +7,7 @@ function tableGrid(value, path = "table") {
   const values = [...hasHeaders ? [table.columns] : [], ...Array.isArray(table.rows) ? table.rows : []];
   const columnCount = values.reduce((count, row) => Math.max(count, Array.isArray(row) ? row.length : 0), 1), rowCount = values.length;
   const owners = Array.from({ length: rowCount }, () => Array(columnCount));
-  const rows2 = Array.from({ length: rowCount }, () => []), issues = [];
+  const rows3 = Array.from({ length: rowCount }, () => []), issues = [];
   const location = (r, c) => `${path}.${hasHeaders && r === 0 ? "columns" : `rows.${r - Number(hasHeaders)}`}.${c}`;
   for (let r = 0; r < rowCount; r++) for (let c = 0; c < columnCount; c++) {
     const input = values[r]?.[c], cellPath = location(r, c), existing = owners[r][c];
@@ -15,21 +15,21 @@ function tableGrid(value, path = "table") {
       if (input !== null) issues.push({ path: cellPath, message: "A position covered by a spanning cell must explicitly contain null; content cannot be hidden." });
       continue;
     }
-    const object = record(input), styled = Object.hasOwn(object, "value");
-    const column = !styled && hasHeaders && r === 0 && typeof object.name === "string";
-    const rowSpan = styled ? object.rowSpan ?? 1 : 1, colSpan = styled ? object.colSpan ?? 1 : 1;
+    const object2 = record(input), styled = Object.hasOwn(object2, "value");
+    const column = !styled && hasHeaders && r === 0 && typeof object2.name === "string";
+    const rowSpan = styled ? object2.rowSpan ?? 1 : 1, colSpan = styled ? object2.colSpan ?? 1 : 1;
     if (!Number.isSafeInteger(rowSpan) || !Number.isSafeInteger(colSpan) || rowSpan < 1 || colSpan < 1 || r + rowSpan > rowCount || c + colSpan > columnCount || hasHeaders && r === 0 && rowSpan > 1) {
       issues.push({ path: cellPath, message: "Cell spans must be positive integers within the table grid and cannot cross from headers into body rows." });
       continue;
     }
-    const cell = { input, value: styled ? object.value : column ? object.name : input, style: styled ? record(object.style) : {}, row: r, column: c, rowSpan, colSpan, header: hasHeaders && r === 0, path: cellPath, valuePath: styled ? cellPath + ".value" : column ? cellPath + ".name" : cellPath };
-    rows2[r].push(cell);
+    const cell = { input, value: styled ? object2.value : column ? object2.name : input, style: styled ? record(object2.style) : {}, row: r, column: c, rowSpan, colSpan, header: hasHeaders && r === 0, path: cellPath, valuePath: styled ? cellPath + ".value" : column ? cellPath + ".name" : cellPath };
+    rows3[r].push(cell);
     for (let y = r; y < r + rowSpan; y++) for (let x = c; x < c + colSpan; x++) {
       if (owners[y][x]) issues.push({ path: cellPath, message: "Cell spans cannot overlap another spanning cell." });
       else owners[y][x] = cell;
     }
   }
-  return { rows: rows2, columnCount, rowCount, hasHeaders, owners, issues };
+  return { rows: rows3, columnCount, rowCount, hasHeaders, owners, issues };
 }
 function tableRowBoundaries(value) {
   const grid = tableGrid(value), offset = Number(grid.hasHeaders), count = grid.rowCount - offset;
@@ -38,562 +38,6 @@ function tableRowBoundaries(value) {
   return [...allowed];
 }
 
-// src/generated/catalog-ids.ts
-var catalogIds = {
-  audiences: [
-    "executives",
-    "board",
-    "engineering-team",
-    "investors",
-    "customers",
-    "sales-team",
-    "marketing-team",
-    "all-hands",
-    "candidates",
-    "regulators",
-    "executive",
-    "investor",
-    "technical",
-    "sales",
-    "marketing",
-    "academic",
-    "internal-team",
-    "customer",
-    "general-public",
-    "media",
-    "partner",
-    "regulatory"
-  ],
-  purposes: [
-    "inform",
-    "decide",
-    "align",
-    "persuade",
-    "educate",
-    "report",
-    "pitch",
-    "sell",
-    "plan"
-  ],
-  tones: [
-    "formal",
-    "casual",
-    "inspirational",
-    "technical",
-    "persuasive",
-    "authoritative",
-    "conversational"
-  ],
-  themes: [
-    "minimal",
-    "classic",
-    "dark",
-    "bold"
-  ],
-  layouts: [
-    "blank",
-    "chart-1x",
-    "chart-2x",
-    "chart-3x",
-    "code-1x",
-    "image-1x",
-    "image-2x",
-    "image-3x",
-    "image-bleed",
-    "list-1x",
-    "list-2x",
-    "list-3x",
-    "list-4x",
-    "list-5x",
-    "list-6x",
-    "media-1x",
-    "number-1x",
-    "number-2x",
-    "number-3x",
-    "number-4x",
-    "number-5x",
-    "number-6x",
-    "quote-1x",
-    "table-1x",
-    "text-1x",
-    "text-2x",
-    "text-3x",
-    "timeline-1x",
-    "title",
-    "title-subtitle",
-    "title-slide",
-    "two-column",
-    "image-focus",
-    "data-visualization",
-    "quote-highlight",
-    "section-divider",
-    "agenda",
-    "thank-you-cta",
-    "bullet-list",
-    "three-column",
-    "icon-grid",
-    "faq",
-    "stats-metrics",
-    "comparison",
-    "swot-analysis",
-    "matrix-quadrant",
-    "funnel-pyramid",
-    "timeline",
-    "process-flow",
-    "photo-grid",
-    "before-after",
-    "testimonial-grid",
-    "team-bio",
-    "pricing-table",
-    "roadmap",
-    "product-feature",
-    "executive-summary",
-    "key-takeaway",
-    "chapter-recap",
-    "qa-discussion",
-    "single-message-statement",
-    "one-column-explainer",
-    "case-study",
-    "pros-cons",
-    "feature-comparison-matrix",
-    "venn-overlap",
-    "decision-tree",
-    "kpi-scorecard",
-    "dashboard",
-    "waterfall-bridge",
-    "benchmark-target-table",
-    "heatmap-cohort",
-    "risk-heatmap",
-    "forecast-scenario",
-    "swimlane-process",
-    "gantt-project-plan",
-    "circular-lifecycle",
-    "customer-journey",
-    "org-chart",
-    "capability-map",
-    "logic-tree",
-    "hub-and-spoke",
-    "architecture-stack",
-    "ecosystem-map",
-    "network-dependency-map",
-    "wheel-radial",
-    "geographic-map",
-    "screenshot-walkthrough",
-    "market-size",
-    "persona-grid",
-    "competitive-landscape",
-    "business-model-canvas",
-    "customer-logos",
-    "executive-decision",
-    "status-rag",
-    "raci-matrix",
-    "action-plan",
-    "assumptions-dependencies",
-    "appendix-index",
-    "detailed-data-table"
-  ],
-  chartTypes: [
-    "100pct-stacked-area-3x",
-    "100pct-stacked-bar-3x",
-    "100pct-stacked-column-3x",
-    "area",
-    "bar",
-    "box-and-whisker",
-    "column",
-    "doughnut",
-    "filled-radar",
-    "funnel",
-    "histogram",
-    "line",
-    "line-with-markers",
-    "pareto",
-    "pie",
-    "radar",
-    "radar-with-markers",
-    "scatter",
-    "stacked-area-3x",
-    "stacked-bar-3x",
-    "stacked-column-3x",
-    "stacked-line-3x",
-    "stacked-line-with-markers-3x",
-    "treemap",
-    "waterfall",
-    "world",
-    "100pct-bullet-bar",
-    "100pct-bullet-bar-2x",
-    "100pct-bullet-bar-3x",
-    "100pct-bullet-column",
-    "100pct-bullet-column-2x",
-    "100pct-bullet-column-3x",
-    "100pct-progress-bar",
-    "100pct-stacked-area-2x",
-    "100pct-stacked-bar-2x",
-    "100pct-stacked-column-2x",
-    "australia",
-    "box-and-whisker-2x",
-    "box-and-whisker-3x",
-    "bullet-bar",
-    "bullet-bar-2x",
-    "bullet-bar-3x",
-    "bullet-column",
-    "bullet-column-2x",
-    "bullet-column-3x",
-    "canada",
-    "clustered-bar-2x",
-    "clustered-column",
-    "dot-plot",
-    "dot-plot-2x",
-    "dot-plot-3x",
-    "dot-plot-4x",
-    "dot-plot-5x",
-    "dot-plot-6x",
-    "dumbbell",
-    "line-2x",
-    "line-3x",
-    "line-with-high-low",
-    "line-with-high-low-and-markers",
-    "line-with-markers-2x",
-    "line-with-markers-3x",
-    "sparkline",
-    "sparkline-2x",
-    "sparkline-3x",
-    "sparkline-4x",
-    "sparkline-5x",
-    "sparkline-6x",
-    "stacked-area-2x",
-    "stacked-bar-2x",
-    "stacked-column-2x",
-    "stacked-line-2x",
-    "stacked-line-with-markers-2x",
-    "treemap-2x",
-    "treemap-3x",
-    "united-kingdom",
-    "united-states"
-  ],
-  narratives: [
-    "problem-solution",
-    "scqa",
-    "pyramid-principle",
-    "situation-complication-resolution",
-    "what-so-what-now-what",
-    "strategic-narrative",
-    "golden-circle",
-    "conference-talk",
-    "transformation-arc",
-    "pitch-deck",
-    "early-startup-pitch",
-    "venture-pitch",
-    "persuasive-sales",
-    "sparkline",
-    "company-intro",
-    "marketing-strategy",
-    "product-launch",
-    "strategic-advisory",
-    "challenge-resolution",
-    "project-proposal",
-    "vision-roadmap",
-    "failure-analysis",
-    "star-method",
-    "classic-story",
-    "heros-journey",
-    "business-narrative",
-    "change-story",
-    "rags-to-riches",
-    "underdog-victory",
-    "survival-story",
-    "educate",
-    "persuade",
-    "reveal",
-    "justice",
-    "innovation",
-    "focus",
-    "qbr",
-    "business-review",
-    "board-meeting",
-    "weekly-progress",
-    "status-update",
-    "performance-review",
-    "survey-analysis",
-    "trend-analysis",
-    "data-story",
-    "employee-review",
-    "performance-improvement-plan",
-    "capacity-planning"
-  ],
-  socialPlatforms: [
-    "linkedin",
-    "x",
-    "github",
-    "youtube",
-    "instagram",
-    "facebook",
-    "tiktok",
-    "threads",
-    "mastodon",
-    "bluesky"
-  ],
-  languages: [
-    "afrikaans",
-    "albanian",
-    "amharic",
-    "arabic",
-    "armenian",
-    "aymara",
-    "azerbaijani",
-    "bengali",
-    "berber-latin",
-    "bosnian-latin",
-    "bulgarian",
-    "catalan",
-    "cebuano",
-    "chinese-simplified",
-    "chinese-traditional",
-    "chittagonian",
-    "croatian",
-    "czech",
-    "danish",
-    "dutch",
-    "english",
-    "english-au",
-    "english-ca",
-    "english-gb",
-    "english-in",
-    "english-us",
-    "estonian",
-    "filipino",
-    "finnish",
-    "french",
-    "fulfulde",
-    "galician",
-    "georgian",
-    "german",
-    "greek",
-    "gujarati",
-    "hausa",
-    "hebrew",
-    "hindi",
-    "hungarian",
-    "igbo",
-    "indonesian",
-    "italian",
-    "japanese",
-    "kannada",
-    "kazakh",
-    "khmer",
-    "kinyarwanda",
-    "korean",
-    "kurmanji",
-    "latvian",
-    "lithuanian",
-    "macedonian",
-    "malagasy",
-    "malay",
-    "malayalam",
-    "maori",
-    "marathi",
-    "mongolian",
-    "nepali",
-    "norwegian",
-    "odia",
-    "oromo",
-    "pashto",
-    "persian",
-    "polish",
-    "portuguese",
-    "punjabi-gurmukhi",
-    "punjabi-shahmukhi",
-    "romanian",
-    "russian",
-    "serbian-cyrillic",
-    "serbian-latin",
-    "shona",
-    "slovak",
-    "slovenian",
-    "somali",
-    "spanish",
-    "swahili",
-    "swedish",
-    "tagalog",
-    "tajik",
-    "tamil",
-    "telugu",
-    "thai",
-    "turkish",
-    "ukrainian",
-    "urdu",
-    "uzbek-latin",
-    "vietnamese-quoc-ngu",
-    "xhosa",
-    "yoruba",
-    "zulu"
-  ],
-  colorSchemes: [
-    "black-and-white",
-    "bold-red",
-    "boost",
-    "burnt-orange",
-    "cool-horizon",
-    "corporate-blue",
-    "deep-purple",
-    "forest-green",
-    "golden-yellow",
-    "luxury",
-    "pastel-red",
-    "slate-gray",
-    "steel-blue",
-    "vibes"
-  ],
-  fontSchemes: [
-    "consolas",
-    "courier-new",
-    "arial",
-    "calibri",
-    "impact",
-    "lucida-sans",
-    "segoe-ui",
-    "segoe-ui-light",
-    "tahoma",
-    "trebuchet-ms",
-    "verdana",
-    "bookman",
-    "century-schoolbook",
-    "constantia",
-    "garamond",
-    "rockwell",
-    "times-new-roman",
-    "aptos",
-    "grandview",
-    "seaford",
-    "skeena",
-    "tenorite",
-    "georgia",
-    "microsoft-yahei",
-    "simsun",
-    "fangsong",
-    "yu-gothic",
-    "pmingliu",
-    "mingliu",
-    "ms-mincho",
-    "malgun-gothic",
-    "batang",
-    "gungsuh",
-    "mangal",
-    "nirmala-ui",
-    "latha",
-    "david",
-    "miriam",
-    "gisha",
-    "vrinda",
-    "shruti",
-    "tunga",
-    "kartika",
-    "kalinga",
-    "raavi",
-    "gautami",
-    "arabic-typesetting",
-    "microsoft-jhenghei",
-    "meiryo",
-    "angsana-new",
-    "aparajita",
-    "dilleniaupc",
-    "sakkal-majalla",
-    "shonar-bangla",
-    "sylfaen",
-    "traditional-arabic",
-    "montserrat",
-    "open-sans",
-    "poppins",
-    "pt-serif",
-    "raleway",
-    "roboto",
-    "noto-sans-arabic",
-    "noto-sans-armenian",
-    "noto-sans-bengali",
-    "noto-sans-devangari",
-    "noto-sans-georgian",
-    "noto-sans-gujarati",
-    "noto-sans-gurmukhi",
-    "noto-sans-hebrew",
-    "noto-sans-jp",
-    "noto-sans-kannada",
-    "noto-sans-kr",
-    "noto-sans-malayalam",
-    "noto-sans-mongolian",
-    "noto-sans-oriya",
-    "noto-sans-sc",
-    "noto-sans-tamil",
-    "noto-sans-tc",
-    "noto-sans-telugu",
-    "noto-sans",
-    "noto-sans-thai",
-    "noto-nastaliq-urdu",
-    "noto-naksh-arabic",
-    "noto-sans-ethiopic",
-    "noto-sans-khmer",
-    "nyala",
-    "daunpenh",
-    "khmer-ui"
-  ]
-};
-var deprecatedCatalogIds = {
-  "audiences/executives": "executive",
-  "audiences/investors": "investor",
-  "audiences/customers": "customer",
-  "audiences/sales-team": "sales",
-  "audiences/marketing-team": "marketing",
-  "audiences/regulators": "regulatory",
-  "chartTypes/100pct-bullet-bar": "100pct-stacked-bar-3x",
-  "chartTypes/100pct-bullet-bar-2x": "100pct-stacked-bar-3x",
-  "chartTypes/100pct-bullet-bar-3x": "100pct-stacked-bar-3x",
-  "chartTypes/100pct-bullet-column": "100pct-stacked-column-3x",
-  "chartTypes/100pct-bullet-column-2x": "100pct-stacked-column-3x",
-  "chartTypes/100pct-bullet-column-3x": "100pct-stacked-column-3x",
-  "chartTypes/100pct-progress-bar": "100pct-stacked-bar-3x",
-  "chartTypes/100pct-stacked-area-2x": "100pct-stacked-area-3x",
-  "chartTypes/100pct-stacked-bar-2x": "100pct-stacked-bar-3x",
-  "chartTypes/100pct-stacked-column-2x": "100pct-stacked-column-3x",
-  "chartTypes/australia": "world",
-  "chartTypes/box-and-whisker-2x": "box-and-whisker",
-  "chartTypes/box-and-whisker-3x": "box-and-whisker",
-  "chartTypes/bullet-bar": "bar",
-  "chartTypes/bullet-bar-2x": "bar",
-  "chartTypes/bullet-bar-3x": "bar",
-  "chartTypes/bullet-column": "column",
-  "chartTypes/bullet-column-2x": "column",
-  "chartTypes/bullet-column-3x": "column",
-  "chartTypes/canada": "world",
-  "chartTypes/clustered-bar-2x": "bar",
-  "chartTypes/clustered-column": "column",
-  "chartTypes/dot-plot": "scatter",
-  "chartTypes/dot-plot-2x": "scatter",
-  "chartTypes/dot-plot-3x": "scatter",
-  "chartTypes/dot-plot-4x": "scatter",
-  "chartTypes/dot-plot-5x": "scatter",
-  "chartTypes/dot-plot-6x": "scatter",
-  "chartTypes/dumbbell": "scatter",
-  "chartTypes/line-2x": "line",
-  "chartTypes/line-3x": "line",
-  "chartTypes/line-with-high-low": "line",
-  "chartTypes/line-with-high-low-and-markers": "line-with-markers",
-  "chartTypes/line-with-markers-2x": "line-with-markers",
-  "chartTypes/line-with-markers-3x": "line-with-markers",
-  "chartTypes/sparkline": "line",
-  "chartTypes/sparkline-2x": "line",
-  "chartTypes/sparkline-3x": "line",
-  "chartTypes/sparkline-4x": "line",
-  "chartTypes/sparkline-5x": "line",
-  "chartTypes/sparkline-6x": "line",
-  "chartTypes/stacked-area-2x": "stacked-area-3x",
-  "chartTypes/stacked-bar-2x": "stacked-bar-3x",
-  "chartTypes/stacked-column-2x": "stacked-column-3x",
-  "chartTypes/stacked-line-2x": "stacked-line-3x",
-  "chartTypes/stacked-line-with-markers-2x": "stacked-line-with-markers-3x",
-  "chartTypes/treemap-2x": "treemap",
-  "chartTypes/treemap-3x": "treemap",
-  "chartTypes/united-kingdom": "world",
-  "chartTypes/united-states": "world"
-};
-
 // src/chart-options.ts
 var END_POSITIONS = ["center", "inside-end", "inside-base", "outside-end"];
 var STACKED_POSITIONS = ["center", "inside-end", "inside-base"];
@@ -602,9 +46,12 @@ var PIE_POSITIONS = ["center", "inside-end", "outside-end"];
 var NONE = [];
 var VALUE_CATEGORY = ["category", "value"];
 var ALL_CONTENT = ["category", "value", "percent"];
-var categoryKinds = /* @__PURE__ */ new Set(["bar", "line", "area", "scatter", "histogram", "pareto", "box", "waterfall", "funnel"]);
-var valueKinds = /* @__PURE__ */ new Set(["bar", "line", "area", "scatter", "histogram", "pareto", "box", "waterfall"]);
-var legendKinds = /* @__PURE__ */ new Set(["bar", "line", "area", "pie", "doughnut", "scatter", "radar", "box"]);
+var COMBO_POSITIONS = ["center", "inside-end", "inside-base", "outside-end", "above", "below", "left", "right"];
+var categoryKinds = /* @__PURE__ */ new Set(["bar", "line", "area", "scatter", "histogram", "pareto", "box", "waterfall", "funnel", "combo"]);
+var valueKinds = /* @__PURE__ */ new Set(["bar", "line", "area", "scatter", "histogram", "pareto", "box", "waterfall", "combo"]);
+var legendKinds = /* @__PURE__ */ new Set(["bar", "line", "area", "pie", "doughnut", "scatter", "radar", "box", "combo"]);
+var highlightSeriesKinds = /* @__PURE__ */ new Set(["bar", "line", "area", "scatter", "radar"]);
+var highlightCategoryKinds = /* @__PURE__ */ new Set(["bar", "line", "pie", "doughnut"]);
 function labelSupport(target) {
   const none = { supported: true, content: VALUE_CATEGORY, positions: NONE, defaultPosition: null, defaultOn: false };
   switch (target.kind) {
@@ -613,6 +60,9 @@ function labelSupport(target) {
     case "line":
     case "scatter":
       return { ...none, positions: POINT_POSITIONS, defaultPosition: "above" };
+    // Columns take the clustered positions and lines the point positions ('center' fits both); each part falls back to its own default.
+    case "combo":
+      return { ...none, positions: COMBO_POSITIONS, defaultPosition: "outside-end" };
     case "pie":
       return { ...none, content: ALL_CONTENT, positions: PIE_POSITIONS, defaultPosition: "outside-end" };
     case "doughnut":
@@ -634,25 +84,26 @@ function labelSupport(target) {
 }
 function chartOptionSupport(target) {
   return {
-    axisTitles: { category: categoryKinds.has(target.kind), value: valueKinds.has(target.kind) },
+    axisTitles: { category: categoryKinds.has(target.kind), value: valueKinds.has(target.kind), secondary: target.kind === "combo" },
     legend: legendKinds.has(target.kind),
+    highlight: { series: highlightSeriesKinds.has(target.kind), categories: highlightCategoryKinds.has(target.kind) },
     dataLabels: labelSupport(target)
   };
 }
 var KEPT = {
   column: { kind: "bar" },
-  "stacked-column-3x": { kind: "bar", stacked: true },
-  "100pct-stacked-column-3x": { kind: "bar", stacked: true },
+  "stacked-column": { kind: "bar", stacked: true },
+  "100pct-stacked-column": { kind: "bar", stacked: true },
   bar: { kind: "bar" },
-  "stacked-bar-3x": { kind: "bar", stacked: true },
-  "100pct-stacked-bar-3x": { kind: "bar", stacked: true },
+  "stacked-bar": { kind: "bar", stacked: true },
+  "100pct-stacked-bar": { kind: "bar", stacked: true },
   line: { kind: "line" },
   "line-with-markers": { kind: "line" },
-  "stacked-line-3x": { kind: "line", stacked: true },
-  "stacked-line-with-markers-3x": { kind: "line", stacked: true },
+  "stacked-line": { kind: "line", stacked: true },
+  "stacked-line-with-markers": { kind: "line", stacked: true },
   area: { kind: "area" },
-  "stacked-area-3x": { kind: "area", stacked: true },
-  "100pct-stacked-area-3x": { kind: "area", stacked: true },
+  "stacked-area": { kind: "area", stacked: true },
+  "100pct-stacked-area": { kind: "area", stacked: true },
   pie: { kind: "pie" },
   doughnut: { kind: "doughnut" },
   scatter: { kind: "scatter" },
@@ -665,14 +116,14 @@ var KEPT = {
   "box-and-whisker": { kind: "box" },
   waterfall: { kind: "waterfall" },
   funnel: { kind: "funnel" },
-  world: { kind: "map" }
+  world: { kind: "map" },
+  combo: { kind: "combo" }
 };
 function chartOptionTarget(typeId) {
   if (typeof typeId !== "string") return void 0;
   const raw = typeId.trim().toLowerCase();
   const id = raw === "donut" ? "doughnut" : raw;
-  const kept = deprecatedCatalogIds[`chartTypes/${id}`] ?? id;
-  const target = Object.hasOwn(KEPT, kept) ? KEPT[kept] : void 0;
+  const target = Object.hasOwn(KEPT, id) ? KEPT[id] : void 0;
   return target ? { ...target } : void 0;
 }
 var record2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -686,11 +137,25 @@ function resolveChartOptions(chart, target) {
   const support = target ? chartOptionSupport(target) : void 0;
   const adapt = (option, reason, message) => result.diagnostics.push({ code: "chart-option-adapted", option, reason, message });
   const kind2 = target?.kind ?? "unknown";
+  const combo = target?.kind === "combo";
+  if (!combo) {
+    for (const option of ["line", "secondaryAxis"]) {
+      if (chart[option] !== void 0) adapt(option, "unsupported-type", `Only a 'combo' chart draws line series${option === "secondaryAxis" ? " on a secondary axis" : ""}; ${option} is ignored on a '${kind2}' chart.`);
+    }
+  }
   if (record2(chart.axisTitles)) {
-    for (const axis of ["category", "value"]) {
+    for (const axis of ["category", "value", "secondary"]) {
       const raw = chart.axisTitles[axis];
       if (typeof raw !== "string" || !raw.trim()) continue;
-      if (support && !support.axisTitles[axis]) {
+      if (axis === "secondary" && support && !support.axisTitles.secondary) {
+        adapt("axisTitles.secondary", "unsupported-type", `Only a 'combo' chart has a secondary value axis; the secondary axis title is not drawn or exported on a '${kind2}' chart.`);
+        continue;
+      }
+      if (axis === "secondary" && combo && !(Array.isArray(chart.secondaryAxis) && chart.secondaryAxis.some((name) => typeof name === "string"))) {
+        adapt("axisTitles.secondary", "unsupported-type", "This combo chart plots no series on a secondary axis (secondaryAxis is absent); the secondary axis title is not drawn or exported.");
+        continue;
+      }
+      if (axis !== "secondary" && support && !support.axisTitles[axis]) {
         adapt(`axisTitles.${axis}`, "unsupported-type", `A '${kind2}' chart has no ${axis} axis to title; the ${axis} axis title is not drawn or exported.`);
         continue;
       }
@@ -717,8 +182,18 @@ function resolveChartOptions(chart, target) {
       if (!content.length) content.push("value");
       const positions = support?.dataLabels.positions ?? NONE;
       let position = support?.dataLabels.defaultPosition ?? null;
-      if (typeof options.position === "string" && POSITIONS.has(options.position) && options.position !== "auto") {
-        if (!support || positions.includes(options.position)) position = options.position;
+      let linePosition;
+      const requestedPosition = typeof options.position === "string" && POSITIONS.has(options.position) && options.position !== "auto" ? options.position : void 0;
+      if (combo) {
+        linePosition = "above";
+        if (requestedPosition) {
+          if (END_POSITIONS.includes(requestedPosition)) position = requestedPosition;
+          else adapt("dataLabels.position", "unsupported-position", `The column series of a combo chart cannot place data labels '${requestedPosition}'; they use outside-end.`);
+          if (POINT_POSITIONS.includes(requestedPosition)) linePosition = requestedPosition;
+          else adapt("dataLabels.position", "unsupported-position", `The line series of a combo chart cannot place data labels '${requestedPosition}'; they use above.`);
+        }
+      } else if (requestedPosition) {
+        if (!support || positions.includes(requestedPosition)) position = requestedPosition;
         else adapt("dataLabels.position", "unsupported-position", `A '${kind2}'${target?.stacked ? " stacked" : ""} chart cannot place data labels '${options.position}'; the type's default position is used.`);
       }
       let separator = typeof options.separator === "string" ? options.separator : DEFAULT_CHART_LABEL_SEPARATOR;
@@ -726,10 +201,23 @@ function resolveChartOptions(chart, target) {
         separator = separator.replace(/[\r\n]+/g, " ");
         adapt("dataLabels.separator", "unsupported-content", "A data label is one line; the line break in the separator is replaced with a space.");
       }
-      result.dataLabels = { content, position, separator };
+      result.dataLabels = { content, position, separator, ...linePosition ? { linePosition } : {} };
     }
   }
-  result.active = result.legend !== void 0 || result.dataLabels !== void 0 || result.dataLabelsOff === true || result.axisTitles.category !== void 0 || result.axisTitles.value !== void 0;
+  if (record2(chart.highlight)) {
+    const names = (value) => Array.isArray(value) ? [...new Set(value.filter((entry) => typeof entry === "string"))] : [];
+    const kept = { series: [], categories: [] };
+    for (const part of ["series", "categories"]) {
+      const requested = names(chart.highlight[part]);
+      if (!requested.length) continue;
+      if (support && !support.highlight[part]) {
+        const alternative = part === "series" ? support.highlight.categories ? " (name categories instead)" : "" : support.highlight.series ? " (name series instead)" : "";
+        adapt(`highlight.${part}`, "unsupported-type", `A '${kind2}' chart cannot highlight ${part}${alternative}; the highlighted ${part} are ignored.`);
+      } else kept[part] = requested;
+    }
+    if (kept.series.length || kept.categories.length) result.highlight = kept;
+  }
+  result.active = result.legend !== void 0 || result.dataLabels !== void 0 || result.dataLabelsOff === true || result.axisTitles.category !== void 0 || result.axisTitles.value !== void 0 || result.axisTitles.secondary !== void 0;
   return result;
 }
 function formatChartLabelNumber(value) {
@@ -741,6 +229,14 @@ function formatChartLabelPercent(share) {
 function chartLabelText(parts, content, separator = DEFAULT_CHART_LABEL_SEPARATOR) {
   return CONTENT_ORDER.filter((part) => content.includes(part) && parts[part] !== void 0).map((part) => parts[part]).join(separator);
 }
+function chartHighlightMarks(highlight, data) {
+  if (!highlight) return void 0;
+  const first = data.columns.length > 1 ? data.hasX ? 2 : 1 : 0;
+  const series = data.columns.slice(first).map((name) => highlight.series.includes(name));
+  const label = (cell) => cell === null || cell === void 0 ? "" : String(cell);
+  const categories = data.columns.length > 1 ? data.rows.map((row) => highlight.categories.includes(label(row[0]))) : data.rows.map(() => false);
+  return series.some(Boolean) || categories.some(Boolean) ? { series, categories } : void 0;
+}
 
 // src/content-walk.ts
 function isRecord(value) {
@@ -928,6 +424,24 @@ function formatSlideNumber(format, current, total) {
   return { text: text2, fields: fields2 };
 }
 
+// src/deck-metadata.ts
+function recordsOf(value) {
+  return (Array.isArray(value) ? value : value === void 0 || value === null ? [] : [value]).filter(isRecord);
+}
+function speakersOf(presentation) {
+  return isRecord(presentation) ? recordsOf(presentation.speaker) : [];
+}
+function organizationsOf(presentation) {
+  return isRecord(presentation) ? recordsOf(presentation.organization) : [];
+}
+function primarySpeaker(presentation) {
+  return speakersOf(presentation)[0];
+}
+function primaryOrganization(presentation) {
+  const organizations = organizationsOf(presentation);
+  return organizations.find((item) => item.role === "primary") ?? organizations[0];
+}
+
 // src/variables.ts
 var VARIABLE_KINDS = ["color", "text", "number", "date", "image", "url", "list"];
 var DEFAULT_VARIABLE_DATE_FORMAT = "MMMM d, yyyy";
@@ -941,12 +455,15 @@ var OPFVariableError = class extends Error {
   }
 };
 var idPattern = /^[a-z][a-z0-9-]*$/;
-var referencePattern = /^var:([a-z][a-z0-9-]*)$/;
+var nameSource = String.raw`[a-z][a-z0-9-]*|(?:deck|speaker|organization)(?:\.[A-Za-z0-9_-]+){1,2}`;
+var referencePattern = new RegExp(String.raw`^var:(${nameSource})$`);
+var builtinNamePattern = /^(?:speakers|(?:deck|speaker|organization)(?:\.[A-Za-z0-9_-]+){1,2})$/;
+var builtinUsePattern = /\{\{\s*(?:speakers\b|(?:deck|speaker|organization)\.)|^var:(?:speakers$|(?:deck|speaker|organization)\.)/;
 var hexPattern = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
 var urlPattern = /^(?:https?:\/\/|mailto:|tel:)\S+$/;
 var datePrefixPattern = /^(\d{4}-\d{2}-\d{2})(?:[T ].*)?$/;
 var decimalPattern = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
-var tokenPattern = /\\\{\{|\{\{\s*([a-z][a-z0-9-]*)\s*(?:\|([^{}]*))?\}\}/g;
+var tokenPattern = new RegExp(String.raw`\\\{\{|\{\{\s*(${nameSource})\s*(?:\|([^{}]*))?\}\}`, "g");
 var SAMPLES = {
   color: "#000000",
   text: "Sample text",
@@ -1039,8 +556,18 @@ function variableDeclarations(presentation) {
   }
   return out;
 }
+function usesBuiltins(value, root = true) {
+  if (typeof value === "string") return value.length >= 6 && builtinUsePattern.test(value);
+  if (Array.isArray(value)) return value.some((entry) => usesBuiltins(entry, false));
+  if (!isRecord(value)) return false;
+  for (const [key, entry] of Object.entries(value)) {
+    if (skippedKeys.has(key) || root && skippedRootKeys.has(key)) continue;
+    if (usesBuiltins(entry, false)) return true;
+  }
+  return false;
+}
 function hasContentVariables(presentation) {
-  return isTemplate(presentation) || variableDeclarations(presentation).some((declaration) => declaration.kind !== "color");
+  return isTemplate(presentation) || variableDeclarations(presentation).some((declaration) => declaration.kind !== "color") || usesBuiltins(presentation);
 }
 var POSITIVE_ZERO = "0";
 function formatVariableNumber(value, pattern) {
@@ -1127,6 +654,93 @@ function inlineText(effective, format, path, context) {
       return value.join(format ?? ", ");
   }
 }
+var DECK_FIELDS = { name: "text", description: "text", author: "text" };
+var SPEAKER_FIELDS = { name: "text", title: "text", email: "text", phone: "text", bio: "text", photo: "image" };
+var ORGANIZATION_FIELDS = { name: "text", legalName: "text", tagline: "text", domain: "text", email: "text", phone: "text", logo: "image" };
+function isBuiltinName(name) {
+  return builtinNamePattern.test(name);
+}
+function builtinFields(root) {
+  return root === "deck" ? DECK_FIELDS : root === "speaker" ? SPEAKER_FIELDS : ORGANIZATION_FIELDS;
+}
+function present(value) {
+  if (typeof value === "string") return value.trim() === "" ? void 0 : value;
+  if (isRecord(value)) return typeof value.src === "string" && value.src.trim() ? value : void 0;
+  return void 0;
+}
+function builtinSource(name, doc) {
+  if (name === "speakers") {
+    const names = speakersOf(doc).map((speaker) => present(speaker.name)).filter((entry) => typeof entry === "string");
+    return { ok: true, kind: "list", raw: names.length ? names : void 0 };
+  }
+  const parts = name.split(".");
+  const root = parts[0];
+  const fields2 = builtinFields(root);
+  const list = (names) => names.map((entry) => `'${entry}'`).join(", ");
+  if (root === "deck") {
+    const field2 = parts[1];
+    if (parts.length !== 2 || !Object.hasOwn(fields2, field2)) return { ok: false, message: `'${name}' is not a built-in variable; the deck built-ins are ${list(Object.keys(fields2).map((key) => `deck.${key}`))}.` };
+    const value = doc[field2];
+    return { ok: true, kind: "text", raw: field2 === "author" && Array.isArray(value) ? present(value.filter((entry) => typeof entry === "string").join(", ")) : present(value) };
+  }
+  const field = parts[parts.length - 1];
+  if (!Object.hasOwn(fields2, field)) {
+    return { ok: false, message: `'${name}' is not a built-in variable: '${field}' is not a ${root} field; the fields are ${list(Object.keys(fields2))}.` };
+  }
+  let entity;
+  if (parts.length === 2) entity = root === "speaker" ? primarySpeaker(doc) : primaryOrganization(doc);
+  else {
+    const id = parts[1];
+    const entries = root === "speaker" ? speakersOf(doc) : organizationsOf(doc);
+    entity = entries.find((entry) => entry.id === id);
+    if (!entity) return { ok: false, message: `'${name}' names no ${root} with id '${id}'.` };
+  }
+  return { ok: true, kind: fields2[field], raw: present(entity?.[field]) };
+}
+function builtinEffective(name, path, context) {
+  if (context.resolvingBuiltins.has(name)) return void 0;
+  const cached = context.builtins.get(name);
+  if (cached !== void 0) {
+    if (cached === null) diag(context, unknownBuiltin(name, path, context), `ubi:${name}:${path}`);
+    else if (cached.status === "unfilled") diag(context, missingBuiltin(name, path), `bim:${name}:${path}`);
+    return cached ?? void 0;
+  }
+  const source = builtinSource(name, context.doc);
+  if (!source.ok) {
+    context.builtins.set(name, null);
+    diag(context, unknownBuiltin(name, path, context), `ubi:${name}:${path}`);
+    return void 0;
+  }
+  const declaration = { id: name, kind: source.kind, path: "", required: context.keepMissingBuiltins };
+  let effective;
+  const coerced = source.raw === void 0 ? void 0 : coerceVariableValue(source.kind, source.raw);
+  if (coerced?.ok) {
+    let value = coerced.value;
+    if (typeof value === "string" && value.includes("{{")) {
+      context.resolvingBuiltins.add(name);
+      value = interpolate(value, path, context).value;
+      context.resolvingBuiltins.delete(name);
+    }
+    effective = { declaration: { ...declaration, value }, status: "filled", value, provided: false };
+  } else {
+    effective = { declaration, status: "unfilled", provided: false };
+    diag(context, missingBuiltin(name, path), `bim:${name}:${path}`);
+  }
+  context.builtins.set(name, effective);
+  return effective;
+}
+function unknownBuiltin(name, path, context) {
+  const source = builtinSource(name, context.doc);
+  return { code: "variable-unknown-builtin", severity: "error", path, id: name, message: source.ok ? `'${name}' is not a built-in variable.` : source.message };
+}
+function missingBuiltin(name, path) {
+  return { code: "variable-builtin-missing", severity: "warning", path, id: name, message: `Built-in '${name}' has no value in this document, so it resolves to nothing; add the field it reads (see docs/templates-and-variables.md).` };
+}
+function lookupVariable(id, path, context) {
+  const declared = context.effective.get(id);
+  if (declared || !isBuiltinName(id)) return declared;
+  return builtinEffective(id, path, context);
+}
 function interpolate(text2, path, context) {
   let changed = false;
   const value = text2.replace(tokenPattern, (match, id, format) => {
@@ -1138,9 +752,9 @@ function interpolate(text2, path, context) {
       return match;
     }
     context.uses.push({ id, path, form: "token" });
-    const effective = context.effective.get(id);
+    const effective = lookupVariable(id, path, context);
     if (!effective) {
-      diag(context, { code: "variable-unknown", severity: "warning", path, id, message: `'{{${id}}}' names no declared variable; declare '${id}' in the top-level variables map, or write '\\{{' for literal braces.` }, `unk:${id}:${path}`);
+      if (!isBuiltinName(id)) diag(context, { code: "variable-unknown", severity: "warning", path, id, message: `'{{${id}}}' names no declared variable; declare '${id}' in the top-level variables map, or write '\\{{' for literal braces.` }, `unk:${id}:${path}`);
       return match;
     }
     if (effective.status === "unfilled" && !context.shape) {
@@ -1168,7 +782,7 @@ function reduceString(text2, path, parentIsArray, context) {
   const reference = referencePattern.exec(text2);
   if (reference) {
     const id = reference[1];
-    const effective = context.effective.get(id);
+    const effective = lookupVariable(id, path, context);
     if (effective && effective.declaration.kind !== "color") {
       context.uses.push({ id, path, form: "reference" });
       if (effective.status === "unfilled" && !context.shape) {
@@ -1250,7 +864,11 @@ function plan(presentation, values, options) {
     unescape: false,
     shape: options.shape === true,
     content: hasContentVariables(presentation) || template,
-    seen: /* @__PURE__ */ new Set()
+    seen: /* @__PURE__ */ new Set(),
+    doc: presentation,
+    keepMissingBuiltins: options.examples === true,
+    builtins: /* @__PURE__ */ new Map(),
+    resolvingBuiltins: /* @__PURE__ */ new Set()
   };
   const unfilled = [];
   const examplesUsed = [];
@@ -1374,6 +992,32 @@ function listVariables(presentation, values = {}) {
     };
   });
 }
+var FIELD_LABELS = { name: "name", legalName: "legal name", tagline: "tagline", domain: "domain", email: "email", phone: "phone", logo: "logo", title: "title", bio: "bio", photo: "photo", description: "description", author: "author" };
+function listBuiltinVariables(presentation) {
+  if (!isRecord(presentation)) return [];
+  const names = [];
+  for (const field of Object.keys(DECK_FIELDS)) names.push({ name: `deck.${field}`, label: `Deck ${FIELD_LABELS[field]}` });
+  for (const field of Object.keys(SPEAKER_FIELDS)) names.push({ name: `speaker.${field}`, label: `Speaker ${FIELD_LABELS[field]}` });
+  names.push({ name: "speakers", label: "All speaker names" });
+  for (const field of Object.keys(ORGANIZATION_FIELDS)) names.push({ name: `organization.${field}`, label: `Organization ${FIELD_LABELS[field]}` });
+  for (const [root, entries] of [["speaker", speakersOf(presentation)], ["organization", organizationsOf(presentation)]]) {
+    for (const entry of entries) {
+      if (typeof entry.id !== "string" || entry.id === "") continue;
+      for (const field of Object.keys(builtinFields(root))) names.push({ name: `${root}.${entry.id}.${field}`, label: `${root === "speaker" ? "Speaker" : "Organization"} ${entry.id} ${FIELD_LABELS[field]}` });
+    }
+  }
+  const built = plan(presentation, {}, { examples: false, partial: true, shape: true });
+  built.context.content = true;
+  walk(presentation, "", false, built.context);
+  const out = [];
+  for (const { name, label } of names) {
+    const source = builtinSource(name, presentation);
+    if (!source.ok) continue;
+    const coerced = source.raw === void 0 ? void 0 : coerceVariableValue(source.kind, source.raw);
+    out.push({ name, kind: source.kind, label, ...coerced?.ok ? { value: coerced.value } : {}, available: coerced?.ok === true, uses: built.context.uses.filter((use) => use.id === name) });
+  }
+  return out;
+}
 
 // src/chart-data.ts
 var record3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -1451,7 +1095,7 @@ function excelInteger(integer) {
   const placeholders = "#".repeat(width - zeros) + "0".repeat(zeros);
   return placeholders.replace(/\B(?=(.{3})+$)/g, ",");
 }
-function excelNumberFormat(format) {
+function toExcelNumberFormat(format) {
   if (format === void 0 || format === "") return "General";
   const parts = formatParts(format);
   if (!parts) return "General";
@@ -1489,7 +1133,7 @@ function excelTokens(code) {
   }
   return tokens;
 }
-function numberFormatFromExcel(code) {
+function fromExcelNumberFormat(code) {
   if (typeof code !== "string") return void 0;
   const trimmed = code.trim();
   if (trimmed === "" || /^general$/i.test(trimmed)) return void 0;
@@ -1580,8 +1224,8 @@ function inlinedData(ref, datasets) {
   const diagnostics = [];
   const selection = selectFields(dataset.columns, ref.fields, "", "", diagnostics);
   if (diagnostics.some((entry) => entry.code === "dataset-field-unknown")) return void 0;
-  const rows2 = dataset.rows.map((row) => selection.indices.map((index) => Array.isArray(row) && index < row.length ? structuredClone(row[index]) : null));
-  return { columns: selection.columns.map(inlineColumn), rows: rows2, ...record3(dataset.source) ? { source: structuredClone(dataset.source) } : {} };
+  const rows3 = dataset.rows.map((row) => selection.indices.map((index) => Array.isArray(row) && index < row.length ? structuredClone(row[index]) : null));
+  return { columns: selection.columns.map(inlineColumn), rows: rows3, ...record3(dataset.source) ? { source: structuredClone(dataset.source) } : {} };
 }
 function inlineDatasets(document) {
   if (!record3(document)) return document;
@@ -1655,7 +1299,7 @@ function resolveChartData(chart, document, options = {}) {
   const data = record3(chart) ? chart.data : void 0;
   if (!record3(data)) return fail("no-columns", "The chart has no data.");
   let columns2;
-  let rows2;
+  let rows3;
   let columnsPath;
   let rowsPath;
   let source;
@@ -1675,15 +1319,12 @@ function resolveChartData(chart, document, options = {}) {
     const selection = selectFields(dataset.columns, data.fields, at(base, "data", "fields"), columnsPath, diagnostics);
     columns2 = selection.columns;
     selected = selection.indices;
-    rows2 = dataset.rows;
+    rows3 = dataset.rows;
     if (record3(dataset.source)) source = dataset.source;
-  } else if (typeof data.src === "string") {
-    diagnostics.push({ code: "chart-data-source-unresolved", severity: "warning", path: at(base, "data", "src"), message: `chart data source '${data.src}' is not loaded by any engine; the preview and export draw a placeholder. Import the data inline (columns and rows, with a 'source' for provenance) or reference a dataset` });
-    return fail("data-not-inline", "The chart reads an external data source, which no engine resolves.");
   } else {
     if (!Array.isArray(data.columns)) return fail("no-columns", "The chart data has no columns.");
     columns2 = data.columns;
-    rows2 = Array.isArray(data.rows) ? data.rows : [];
+    rows3 = Array.isArray(data.rows) ? data.rows : [];
     columnsPath = at(base, "data", "columns");
     rowsPath = at(base, "data", "rows");
     formatDiagnostics(columns2, columnsPath, diagnostics);
@@ -1741,10 +1382,46 @@ function resolveChartData(chart, document, options = {}) {
     series = [x];
     x = void 0;
   }
+  let combo;
+  if (record3(chart) && chartOptionTarget(chart.type)?.kind === "combo") {
+    const listed = (option, problem) => {
+      const found = /* @__PURE__ */ new Set();
+      const value = chart[option];
+      if (!Array.isArray(value)) return found;
+      value.forEach((name, index) => {
+        const path = at(base, option, index);
+        const column = known(name, path);
+        if (column === void 0) return;
+        const reason = problem(column);
+        if (reason) diagnostics.push({ code: "chart-mapping-adapted", severity: "warning", path, message: `${JSON.stringify(name)} ${reason}` });
+        else found.add(column);
+      });
+      return found;
+    };
+    const notPlotted = "is not a plotted series of the chart";
+    const lines = listed("line", (column) => series.includes(column) ? void 0 : `${notPlotted}; it is not drawn as a line`);
+    if (chart.line === void 0 && series.length >= 2) lines.add(series[series.length - 1]);
+    if (series.length && series.every((column) => lines.has(column))) {
+      lines.delete(series[0]);
+      diagnostics.push({ code: "chart-mapping-adapted", severity: "warning", path: at(base, chart.line === void 0 ? "type" : "line"), message: series.length === 1 ? `a combo chart needs at least two series, one drawn as columns and one as a line; its one series ${JSON.stringify(names[series[0]])} is drawn as columns` : `a combo chart keeps at least one column series; ${JSON.stringify(names[series[0]])} is drawn as columns, not as a line` });
+    } else if (series.length === 1) {
+      diagnostics.push({ code: "chart-mapping-adapted", severity: "warning", path: at(base, "type"), message: `a combo chart needs at least two series, one drawn as columns and one as a line; its one series ${JSON.stringify(names[series[0]])} is drawn as columns` });
+    }
+    const secondary = listed("secondaryAxis", (column) => !series.includes(column) ? `${notPlotted}; it has no axis to move to` : !lines.has(column) ? "is drawn as columns; only a line series can use the secondary axis, so it stays on the primary axis" : void 0);
+    const bars = series.filter((column) => !lines.has(column));
+    const primaryLines = series.filter((column) => lines.has(column) && !secondary.has(column));
+    const secondaryLines = series.filter((column) => lines.has(column) && secondary.has(column));
+    series = [...bars, ...primaryLines, ...secondaryLines];
+    combo = [
+      ...bars.map(() => ({ role: "bar", axis: "primary" })),
+      ...primaryLines.map(() => ({ role: "line", axis: "primary" })),
+      ...secondaryLines.map(() => ({ role: "line", axis: "secondary" }))
+    ];
+  }
   const order = [category, ...x === void 0 ? [] : [x], ...series];
-  if (!rows2.length) return fail("no-rows", "The chart data has no rows.");
+  if (!rows3.length) return fail("no-rows", "The chart data has no rows.");
   const lone = names.length === 1 && !diagnostics.some((entry) => entry.code === "dataset-field-unknown");
-  const out = rows2.map((row, rowIndex) => order.map((column, position) => {
+  const out = rows3.map((row, rowIndex) => order.map((column, position) => {
     const sourceIndex = selected ? selected[column] : column;
     const cell = Array.isArray(row) && sourceIndex < row.length ? row[sourceIndex] : null;
     if (position === 0 && !lone) return cell === void 0 ? null : cell;
@@ -1754,6 +1431,26 @@ function resolveChartData(chart, document, options = {}) {
     }
     return number;
   }));
+  const highlight = record3(chart) && record3(chart.highlight) ? chart.highlight : void 0;
+  if (highlight) {
+    const plotted = order.slice(order.length - series.length).map((index) => names[index]);
+    const labels = lone ? void 0 : new Set(out.map((row) => row[0] === null || row[0] === void 0 ? "" : String(row[0])));
+    const listed = (value) => Array.isArray(value) ? value : [];
+    const highlightPath = at(base, "highlight");
+    listed(highlight.series).forEach((name, index) => {
+      const path = at(highlightPath, "series", index);
+      if (typeof name !== "string" || !names.includes(name)) {
+        diagnostics.push({ code: "chart-highlight-unknown-name", severity: "error", path, message: `highlight names series ${JSON.stringify(name)}, which the chart data does not have as a column; use one of ${names.map((entry) => JSON.stringify(entry)).join(", ")}` });
+      } else if (!plotted.includes(name)) {
+        diagnostics.push({ code: "chart-highlight-adapted", severity: "warning", path, message: `highlight names column ${JSON.stringify(name)}, which is not plotted as a series (it is the category or X column, or the mapping leaves it out); it highlights nothing` });
+      }
+    });
+    listed(highlight.categories).forEach((name, index) => {
+      if (typeof name === "string" && labels?.has(name)) return;
+      const shown = labels ? [...labels].slice(0, 12).map((entry) => JSON.stringify(entry)).join(", ") : "";
+      diagnostics.push({ code: "chart-highlight-unknown-name", severity: "error", path: at(highlightPath, "categories", index), message: `highlight names category ${JSON.stringify(name)}, which no row of the chart data has as its label${shown ? `; the labels are ${shown}${labels.size > 12 ? ", ..." : ""}` : ""}` });
+    });
+  }
   return {
     ok: true,
     columns: order.map((index) => names[index]),
@@ -1762,6 +1459,7 @@ function resolveChartData(chart, document, options = {}) {
     rows: out,
     ...source ? { source } : {},
     ...datasetId !== void 0 ? { dataset: datasetId } : {},
+    ...combo ? { combo } : {},
     diagnostics
   };
 }
@@ -1778,18 +1476,18 @@ function chartNumberFixes(chart, document, options) {
   if (!candidates.size) return fixes;
   const data = chart.data;
   let columns2;
-  let rows2;
+  let rows3;
   let columnsPath;
   let rowsPath;
   if (isDatasetRef(data)) {
     const dataset = datasetsOf(document)[data.dataset];
     columns2 = dataset.columns;
-    rows2 = dataset.rows;
+    rows3 = dataset.rows;
     columnsPath = at("/datasets", data.dataset, "columns");
     rowsPath = at("/datasets", data.dataset, "rows");
   } else {
     columns2 = data.columns;
-    rows2 = data.rows;
+    rows3 = data.rows;
     columnsPath = at(options.path ?? "", "data", "columns");
     rowsPath = at(options.path ?? "", "data", "rows");
   }
@@ -1797,7 +1495,7 @@ function chartNumberFixes(chart, document, options) {
     const header = columns2[column];
     const name = columnName(header);
     if (name === void 0 || columnFormat(header) !== void 0) continue;
-    const fix = columnFix(rows2, column, rowsPath);
+    const fix = columnFix(rows3, column, rowsPath);
     if (!fix) continue;
     fixes.set(column, {
       patches: [...fix.patches, { op: "replace", path: at(columnsPath, column), value: record3(header) ? { ...header, format: fix.format } : { name, format: fix.format } }],
@@ -1808,14 +1506,14 @@ function chartNumberFixes(chart, document, options) {
   }
   return fixes;
 }
-function columnFix(rows2, column, rowsPath) {
+function columnFix(rows3, column, rowsPath) {
   const cells = [];
   let prefix;
   let suffix;
   let grouping = false;
   let wide = false;
   const decimals = [];
-  for (const [index, row] of rows2.entries()) {
+  for (const [index, row] of rows3.entries()) {
     const cell = Array.isArray(row) && column < row.length ? row[column] : null;
     if (cell === null || cell === void 0 || cell === "") continue;
     const patch = chartNumber(cell) === null;
@@ -1870,12 +1568,12 @@ function resolveTableData(table, document, options = {}) {
     const columnsPath = at("/datasets", id, "columns");
     formatDiagnostics(dataset.columns, columnsPath, diagnostics);
     const selection = selectFields(dataset.columns, table.fields, at(base, "fields"), columnsPath, diagnostics);
-    const rows3 = dataset.rows.map((row) => selection.indices.map((index) => Array.isArray(row) && index < row.length ? row[index] : null));
-    return { columns: selection.columns, rows: rows3, formats: selection.formats, dataset: id, diagnostics };
+    const rows4 = dataset.rows.map((row) => selection.indices.map((index) => Array.isArray(row) && index < row.length ? row[index] : null));
+    return { columns: selection.columns, rows: rows4, formats: selection.formats, dataset: id, diagnostics };
   }
   const columns2 = Array.isArray(table.columns) ? table.columns : void 0;
-  const rows2 = Array.isArray(table.rows) ? table.rows.filter(Array.isArray) : [];
-  const width = Math.max(columns2?.length ?? 0, ...rows2.map((row) => row.length), 0);
+  const rows3 = Array.isArray(table.rows) ? table.rows.filter(Array.isArray) : [];
+  const width = Math.max(columns2?.length ?? 0, ...rows3.map((row) => row.length), 0);
   const formats = Array.from({ length: width }, (_, index) => {
     const header = columns2?.[index];
     return columnFormat(header) ?? cellFormat(header);
@@ -1893,7 +1591,7 @@ function resolveTableData(table, document, options = {}) {
       check(cell, at(base, "rows", rowIndex, index));
     });
   });
-  return { ...columns2 ? { columns: columns2 } : {}, rows: rows2, formats, diagnostics };
+  return { ...columns2 ? { columns: columns2 } : {}, rows: rows3, formats, diagnostics };
 }
 function tableCellDisplayValue(cell, columnFormat2) {
   if (record3(cell) && own(cell, "value")) {
@@ -2019,6 +1717,38 @@ function intrinsicImageAspect(value, assets) {
   return size ? size.width / size.height : void 0;
 }
 
+// src/design-hints.ts
+var DESIGN_HINT_KEYS = ["titleAlignment", "contentAlignment", "contentBox", "contentDirection", "chartPrimary", "imageFill", "listBullet"];
+var ALIGNMENTS = ["left", "center", "right"];
+var VALUES = {
+  titleAlignment: ALIGNMENTS,
+  contentAlignment: ALIGNMENTS,
+  contentBox: "boolean",
+  contentDirection: ["horizontal", "vertical"],
+  chartPrimary: ["none", "top", "bottom", "left", "right"],
+  imageFill: ["crop", "fit"],
+  listBullet: ["character", "image"]
+};
+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 index = options.slideIndex ?? 0;
+  const result = { sources: {}, paths: {} };
+  const set2 = (key, value, source, path) => {
+    result[key] = value;
+    result.sources[key] = source;
+    result.paths[key] = path;
+  };
+  for (const key of DESIGN_HINT_KEYS) {
+    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 (accepts(key, layout[key])) set2(key, layout[key], "layout", `slides.${index}.layout`);
+  }
+  return result;
+}
+
 // src/reading-order.ts
 function visualReadingOrder(items, direction = "ltr") {
   const index = new Map(items.map((item, i) => [item, i]));
@@ -2028,18 +1758,18 @@ function visualReadingOrder(items, direction = "ltr") {
 function readingRows(items) {
   const index = new Map(items.map((item, i) => [item, i]));
   const sorted = [...items].sort((a, b) => a.box.y - b.box.y || a.box.x - b.box.x || index.get(a) - index.get(b));
-  const rows2 = [];
+  const rows3 = [];
   for (const item of sorted) {
     const centre = item.box.y + item.box.height / 2;
-    const row = rows2.find((candidate) => centre >= candidate.top && centre <= candidate.bottom);
+    const row = rows3.find((candidate) => centre >= candidate.top && centre <= candidate.bottom);
     if (row) {
       row.items.push(item);
       row.top = Math.min(row.top, item.box.y);
       row.bottom = Math.max(row.bottom, item.box.y + item.box.height);
-    } else rows2.push({ top: item.box.y, bottom: item.box.y + item.box.height, items: [item] });
+    } else rows3.push({ top: item.box.y, bottom: item.box.y + item.box.height, items: [item] });
   }
-  rows2.sort((a, b) => a.top - b.top);
-  return rows2.map((row) => row.items.sort((a, b) => index.get(a) - index.get(b)));
+  rows3.sort((a, b) => a.top - b.top);
+  return rows3.map((row) => row.items.sort((a, b) => index.get(a) - index.get(b)));
 }
 
 // src/direction.ts
@@ -2083,6 +1813,12 @@ function paragraphDirectionAt(text2, deckDirection) {
 }
 
 // src/script-fonts.ts
+function normalizeLanguageFamily(value) {
+  if (value === "latin") return "latin";
+  if (value === "ea" || value === "eastAsian") return "ea";
+  if (value === "cs" || value === "complexScript") return "cs";
+  return void 0;
+}
 var eastAsianScripts = /* @__PURE__ */ new Set(["Hani", "Hans", "Hant", "Hanb", "Jpan", "Kore", "Hang", "Jamo", "Hira", "Kana", "Hrkt", "Bopo", "Yiii"]);
 var complexScripts = /* @__PURE__ */ new Set([
   "Arab",
@@ -2253,13 +1989,8 @@ function pairFamilies(value) {
 function schemeServesLanguage(scheme, language) {
   const entries = Array.isArray(scheme.languages) ? scheme.languages.filter((entry) => typeof entry === "string") : [];
   if (entries.length === 0) return true;
-  const name = text(language.name)?.toLowerCase();
-  if (!name) return false;
-  const base = name.replace(/\s*\([^)]*\)\s*$/, "");
-  return entries.some((entry) => {
-    const value = entry.trim().toLowerCase();
-    return value === name || value === base;
-  });
+  const id = text(language.id);
+  return id !== void 0 && entries.includes(id);
 }
 function resolveScriptFonts(input, options = {}) {
   const document = isRecord(input) ? input : {};
@@ -2291,16 +2022,16 @@ function resolveScriptFonts(input, options = {}) {
   const scriptRole = scriptFontRole(script);
   const declaredDirection = record6.direction;
   const direction = declaredDirection === "rtl" || declaredDirection === "ltr" ? declaredDirection : rtlScripts.has(script) ? "rtl" : "ltr";
-  const app = options.app ?? "PowerPoint";
-  const preferred = app === "Google Slides" ? record6.googleFontScheme : record6.fontScheme;
-  const alternate = app === "Google Slides" ? record6.fontScheme : record6.googleFontScheme;
+  const app = options.app ?? "powerpoint";
+  const preferred = app === "google-slides" ? record6.googleFontScheme : record6.fontScheme;
+  const alternate = app === "google-slides" ? record6.fontScheme : record6.googleFontScheme;
   const languageScheme = resolveReference(lookup, "fontSchemes", preferred) ?? resolveReference(lookup, "fontSchemes", alternate);
   const languageFamilies = pairFamilies(languageScheme);
   const schemeAdmitsLanguage = schemeServesLanguage(scheme, record6);
   const slot = (role, family) => {
     const explicit = pairFamilies(scheme[role]);
     if (explicit) return { ...explicit, source: "fontScheme" };
-    if (scheme.languageFamily === family && schemeAdmitsLanguage) return { ...latin, source: "schemeFamily" };
+    if (normalizeLanguageFamily(scheme.languageFamily) === family && schemeAdmitsLanguage) return { ...latin, source: "schemeFamily" };
     if (scriptRole === role && languageFamilies) return { ...languageFamilies, source: "language" };
     return { heading: latin.heading, body: latin.body, source: "latin" };
   };
@@ -2403,10 +2134,10 @@ function listNumbers(items, numbering) {
   const levels = resolveNumbering(numbering);
   const counters = [];
   return items.map((item, index) => {
-    const object = isObject(item) ? item : void 0;
-    const level = object?.level === void 0 ? 0 : object.level;
+    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 = object?.start;
+    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 { style: authored, start, suffix } = numberingAtLevel(levels, level);
     const previous = counters[level];
@@ -2425,8 +2156,8 @@ function sliceNumberedItems(items, numbering, from, to = items.length) {
     const wanted = whole[from + index].value;
     if (listNumbers(result.slice(0, index + 1), numbering)[index].value === wanted) continue;
     const item = result[index];
-    const object = isObject(item) ? item : { text: item };
-    result[index] = { ...object, start: wanted };
+    const object2 = isObject(item) ? item : { text: item };
+    result[index] = { ...object2, start: wanted };
   }
   return result;
 }
@@ -2479,6 +2210,7 @@ var schemeColorRoles = /* @__PURE__ */ new Set([
   "accent",
   "background",
   "surface",
+  "surfaceAlt",
   "text",
   "textSecondary"
 ]);
@@ -2522,6 +2254,11 @@ function resolveColorRef(reference, options) {
     const roleKey = reference;
     const fromRoles = roles?.[roleKey];
     if (fromRoles) return normalizeHexColor(fromRoles) ?? fallback;
+    if (reference === "surfaceAlt") {
+      const surface = resolveColorRef("surface", { colorScheme, roles, variables, fallback: "#FFFFFF" });
+      const text2 = resolveColorRef("text", { colorScheme, roles, variables, fallback: textColorForFill(surface, "#000000") });
+      return surfaceAltColor(surface, text2);
+    }
     const fromScheme = normalizeHexColor(colorScheme[reference]);
     if (fromScheme) return fromScheme;
     const slot = defaultRoleSlots[reference];
@@ -2530,6 +2267,52 @@ function resolveColorRef(reference, options) {
   if (schemeColorSlots.has(reference)) return schemeSlot(colorScheme, reference, fallback);
   return fallback;
 }
+var DARK_BACKGROUND_LUMINANCE = 0.179;
+function isDarkColor(color) {
+  const hex = normalizeHexColor(color);
+  const value = hex ? luminance(hex) : void 0;
+  return value !== void 0 && value < DARK_BACKGROUND_LUMINANCE;
+}
+function defaultSlideBackground(colorScheme) {
+  return keepAlpha(colorScheme.background) ?? slotKeepingAlpha(colorScheme, "light1", "#FFFFFF");
+}
+function keepAlpha(value) {
+  if (typeof value !== "string") return void 0;
+  const hex = value.trim();
+  if (/^#[0-9a-f]{8}$/i.test(hex)) return hex.toUpperCase();
+  return normalizeHexColor(hex);
+}
+function slotKeepingAlpha(colorScheme, slot, fallback) {
+  return keepAlpha(colorScheme[slot]) ?? fallback;
+}
+var DEFAULT_HYPERLINK = "#0563C1";
+var DEFAULT_FOLLOWED_HYPERLINK = "#954F72";
+var MIN_LINK_CONTRAST = 4.5;
+function readableLink(link, background, text2) {
+  const linkHex = normalizeHexColor(link), backgroundHex = normalizeHexColor(background);
+  const contrast2 = linkHex && backgroundHex ? colorContrast(linkHex, backgroundHex) : void 0;
+  return contrast2 !== void 0 && contrast2 < MIN_LINK_CONTRAST ? text2 : link;
+}
+function resolveColorRoles(colorScheme, options = {}) {
+  const slot = (name, fallback) => slotKeepingAlpha(colorScheme, name, fallback);
+  const background = keepAlpha(options.background) ?? defaultSlideBackground(colorScheme);
+  const dark = isDarkColor(background);
+  const text2 = dark ? slot("light1", "#FFFFFF") : keepAlpha(colorScheme.text) ?? slot("dark1", "#111827");
+  const surface = keepAlpha(colorScheme.surface) ?? (dark ? slot("dark2", "#1E293B") : slot("light2", "#F8FAFC"));
+  return {
+    primary: keepAlpha(colorScheme.primary) ?? slot("accent1", "#2563EB"),
+    secondary: keepAlpha(colorScheme.secondary) ?? slot("accent2", "#0F766E"),
+    accent: keepAlpha(colorScheme.accent) ?? slot("accent3", "#F59E0B"),
+    background,
+    surface,
+    surfaceAlt: surfaceAltColor(surface, text2),
+    text: text2,
+    textSecondary: keepAlpha(colorScheme.textSecondary) ?? (dark ? slot("light2", "#E2E8F0") : slot("dark2", "#334155")),
+    hyperlink: readableLink(slot("hyperlink", DEFAULT_HYPERLINK), background, text2),
+    followedHyperlink: slot("followedHyperlink", DEFAULT_FOLLOWED_HYPERLINK),
+    dark
+  };
+}
 function luminance(value) {
   if (typeof value !== "string") return void 0;
   let hex = value.trim();
@@ -2547,19 +2330,19 @@ function colorContrast(foreground, 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;
+  const background = luminance(fill), contrast2 = colorContrast(preferred, fill);
+  if (background === void 0 || contrast2 === void 0 || contrast2 >= 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;
+  const contrast2 = colorContrast(preferred, fill);
+  if (contrast2 === void 0 || contrast2 >= 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));
+  const channels2 = [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();
+      const color = `#${channels2.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];
@@ -2581,8 +2364,8 @@ var toLinear = (channel) => {
   return n <= 0.04045 ? n / 12.92 : ((n + 0.055) / 1.055) ** 2.4;
 };
 var fromLinear = (value) => 255 * (value <= 31308e-7 ? value * 12.92 : 1.055 * value ** (1 / 2.4) - 0.055);
-function labOf(channels) {
-  const [r, g, b] = channels.map(toLinear);
+function labOf(channels2) {
+  const [r, g, b] = channels2.map(toLinear);
   const f = (t) => t > 216 / 24389 ? Math.cbrt(t) : (24389 / 27 * t + 16) / 116;
   const fx = f((0.4124564 * r + 0.3575761 * g + 0.1804375 * b) / D65[0]), fy = f(0.2126729 * r + 0.7151522 * g + 0.072175 * b), fz = f((0.0193339 * r + 0.119192 * g + 0.9503041 * b) / D65[2]);
   return [116 * fy - 16, 500 * (fx - fy), 200 * (fy - fz)];
@@ -2598,21 +2381,21 @@ function labToLinear([l, a, b]) {
   ];
   return rgb.every((channel) => channel >= -5e-4 && channel <= 1.0005) ? rgb : void 0;
 }
-var hexOfChannels = (channels) => `#${channels.map((channel) => Math.max(0, Math.min(255, Math.round(channel))).toString(16).padStart(2, "0")).join("").toUpperCase()}`;
+var hexOfChannels = (channels2) => `#${channels2.map((channel) => Math.max(0, Math.min(255, Math.round(channel))).toString(16).padStart(2, "0")).join("").toUpperCase()}`;
 function labWithLightness(l, a, b) {
   const chroma = Math.hypot(a, b), hue = Math.atan2(b, a);
   const at3 = (scale) => labToLinear([l, Math.cos(hue) * chroma * scale, Math.sin(hue) * chroma * scale]);
-  let linear = at3(1);
-  if (!linear) {
+  let linear2 = at3(1);
+  if (!linear2) {
     let low = 0, high = 1;
     for (let step = 0; step < 24; step++) {
       const mid = (low + high) / 2;
       if (at3(mid)) low = mid;
       else high = mid;
     }
-    linear = at3(low) ?? [0, 0, 0];
+    linear2 = at3(low) ?? [0, 0, 0];
   }
-  return hexOfChannels(linear.map((channel) => fromLinear(Math.max(0, Math.min(1, channel)))));
+  return hexOfChannels(linear2.map((channel) => fromLinear(Math.max(0, Math.min(1, channel)))));
 }
 function labDifference(a, b) {
   return Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
@@ -2621,15 +2404,15 @@ var CHART_SERIES_SHORTFALL_WEIGHT = 8;
 function chartPaletteForFill(fill, palette) {
   const opaqueFill = colorContrast(fill, fill) !== void 0;
   const preferredLab = palette.map((color) => {
-    const channels = opaqueChannels(color);
-    return channels ? labOf(channels) : void 0;
+    const channels2 = opaqueChannels(color);
+    return channels2 ? labOf(channels2) : void 0;
   });
   const adjusted = palette.map((color) => chartColorForFill(fill, color));
   const kept = palette.map((color, index) => opaqueFill && preferredLab[index] !== void 0 && adjusted[index] === color);
   const placed = palette.map((_, index) => kept[index] || !opaqueFill || !preferredLab[index] ? adjusted[index] : void 0);
   const placedLab = placed.map((color) => {
-    const channels = color === void 0 ? void 0 : opaqueChannels(color);
-    return channels ? labOf(channels) : void 0;
+    const channels2 = color === void 0 ? void 0 : opaqueChannels(color);
+    return channels2 ? labOf(channels2) : void 0;
   });
   palette.forEach((_, index) => {
     const wanted = preferredLab[index], base = adjusted[index];
@@ -2653,8 +2436,8 @@ function chartPaletteForFill(fill, palette) {
     }
     let best = { color: base, lab: baseLab, cost: cost({ moved: 0, ...start }), moved: 0 };
     for (let step = 0; step <= 400; step++) {
-      const color = labWithLightness(step / 4, wanted[1], wanted[2]), contrast = colorContrast(color, fill);
-      if (contrast === void 0 || contrast < 3) continue;
+      const color = labWithLightness(step / 4, wanted[1], wanted[2]), contrast2 = colorContrast(color, fill);
+      if (contrast2 === void 0 || contrast2 < 3) continue;
       const lab = labOf(opaqueChannels(color)), moved = Math.abs(lab[0] - baseLab[0]), total = cost({ moved, ...shortfall(lab) });
       if (total < best.cost - 1e-9 || Math.abs(total - best.cost) <= 1e-9 && moved < best.moved) best = { color, lab, cost: total, moved };
     }
@@ -2663,6 +2446,1113 @@ function chartPaletteForFill(fill, palette) {
   });
   return placed;
 }
+var CHART_HIGHLIGHT_MUTED_MIX = 0.3;
+var CHART_HIGHLIGHT_MUTED_MIN_CONTRAST = 1.6;
+var mixChannels = (from, to, amount) => hexOfChannels(from.map((channel, index) => channel + (to[index] - channel) * amount));
+function chartHighlightColors(surface, primary, text2) {
+  const fill = normalizeHexColor(surface) ?? "#FFFFFF";
+  const accent = chartColorForFill(fill, normalizeHexColor(primary) ?? "#000000");
+  const ink = normalizeHexColor(text2) ?? textColorForFill(fill, "#000000");
+  const from = opaqueChannels(fill), to = opaqueChannels(ink);
+  let muted = mixChannels(from, to, CHART_HIGHLIGHT_MUTED_MIX);
+  for (let amount = CHART_HIGHLIGHT_MUTED_MIX; (colorContrast(muted, fill) ?? Infinity) < CHART_HIGHLIGHT_MUTED_MIN_CONTRAST && amount < 1; ) {
+    amount = Math.min(1, amount + 0.02);
+    muted = mixChannels(from, to, amount);
+  }
+  return { accent, muted };
+}
+var SURFACE_ALT_MIX = 0.1;
+var SURFACE_ALT_MIN_CONTRAST = 1.1;
+function surfaceAltColor(surface, text2) {
+  const fill = normalizeHexColor(surface) ?? "#FFFFFF";
+  const ink = normalizeHexColor(text2) ?? textColorForFill(fill, "#000000");
+  const from = opaqueChannels(fill), toText = opaqueChannels(ink);
+  const step = (color) => (colorContrast(color, fill) ?? 1) >= SURFACE_ALT_MIN_CONTRAST;
+  const readable = (color) => (colorContrast(ink, color) ?? 0) >= 4.5 || (colorContrast(ink, color) ?? 0) >= (colorContrast(ink, fill) ?? 0);
+  for (let amount = SURFACE_ALT_MIX; amount <= 0.5 + 1e-9; amount += 0.02) {
+    const band = mixChannels(from, toText, amount);
+    if (!readable(band)) break;
+    if (step(band)) return band;
+  }
+  const away = (luminance(ink) ?? 0) > (luminance(fill) ?? 0) ? [0, 0, 0] : [255, 255, 255];
+  for (let amount = SURFACE_ALT_MIX; amount <= 1 + 1e-9; amount += 0.02) {
+    const band = mixChannels(from, away, Math.min(1, amount));
+    if (step(band)) return band;
+  }
+  return mixChannels(from, toText, SURFACE_ALT_MIX);
+}
+
+// src/legible-color.ts
+var channels = (hex) => [1, 3, 5].map((offset) => Number.parseInt(hex.slice(offset, offset + 2), 16));
+var toHex = (values) => `#${values.map((value) => Math.max(0, Math.min(255, Math.round(value))).toString(16).padStart(2, "0")).join("").toUpperCase()}`;
+var linear = (value) => {
+  const n = value / 255;
+  return n <= 0.04045 ? n / 12.92 : ((n + 0.055) / 1.055) ** 2.4;
+};
+var luminance2 = (hex) => {
+  const [r, g, b] = channels(hex);
+  return 0.2126 * linear(r) + 0.7152 * linear(g) + 0.0722 * linear(b);
+};
+var contrast = (a, b) => {
+  const x = luminance2(a), y = luminance2(b);
+  return (Math.max(x, y) + 0.05) / (Math.min(x, y) + 0.05);
+};
+var normalize = (value) => {
+  if (typeof value !== "string") return void 0;
+  const text2 = value.trim();
+  if (/^#[0-9a-f]{3}$/i.test(text2)) return `#${[...text2.slice(1)].map((c) => c + c).join("")}`.toUpperCase();
+  return /^#[0-9a-f]{6}([0-9a-f]{2})?$/i.test(text2) ? text2.slice(0, 7).toUpperCase() : void 0;
+};
+function toHsl(hex) {
+  const [r, g, b] = channels(hex).map((value) => value / 255);
+  const max = Math.max(r, g, b), min = Math.min(r, g, b), l = (max + min) / 2, d = max - min;
+  if (d === 0) return [0, 0, l];
+  const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+  const h = max === r ? (g - b) / d + (g < b ? 6 : 0) : max === g ? (b - r) / d + 2 : (r - g) / d + 4;
+  return [h * 60, s, l];
+}
+function fromHsl(h, s, l) {
+  const hue = (h % 360 + 360) % 360, c = (1 - Math.abs(2 * l - 1)) * s, x = c * (1 - Math.abs(hue / 60 % 2 - 1)), m = l - c / 2;
+  const [r, g, b] = hue < 60 ? [c, x, 0] : hue < 120 ? [x, c, 0] : hue < 180 ? [0, c, x] : hue < 240 ? [0, x, c] : hue < 300 ? [x, 0, c] : [c, 0, x];
+  return toHex([(r + m) * 255, (g + m) * 255, (b + m) * 255]);
+}
+function legible(foreground, background, minimum) {
+  if (contrast(foreground, background) >= minimum) return foreground;
+  const [h, s, l] = toHsl(foreground), preferred = luminance2(background) < 0.5 ? 1 : -1;
+  for (const direction of [preferred, -preferred]) {
+    for (let step = 1; step <= 100; step++) {
+      const lightness = l + direction * step / 100;
+      if (lightness < 0 || lightness > 1) break;
+      const candidate = fromHsl(h, s, lightness);
+      if (contrast(candidate, background) >= minimum) return candidate;
+    }
+  }
+  return contrast("#FFFFFF", background) >= contrast("#000000", background) ? "#FFFFFF" : "#000000";
+}
+
+// src/code-syntax.ts
+var CODE_HIGHLIGHT_MAX_LENGTH = 2e5;
+var CODE_SYNTAX_MIN_CONTRAST = 4.5;
+var CODE_PANEL_BACKGROUND = "#111827";
+var CODE_PANEL_FOREGROUND = "#E5E7EB";
+var set = (words) => new Set((words ?? "").split(/\s+/).filter(Boolean));
+var JS_KEYWORDS = "break case catch class const continue debugger default delete do else enum export extends finally for from function if import in instanceof let new of return static super switch this throw try typeof var void while with yield async await as get set declare namespace module abstract implements interface private protected public readonly override keyof satisfies type is infer";
+var JS = { line: ["//"], block: [["/*", "*/"]], strings: "'\"`", keywords: JS_KEYWORDS, literals: "true false null undefined NaN Infinity", types: "string number boolean object symbol bigint never unknown any void", defs: { function: "function", class: "type", interface: "type", enum: "type", type: "type" }, capsTypes: true, calls: true, decorators: true };
+var C_LIKE_KEYWORDS = "auto break case catch char class const constexpr continue default delete do double else enum explicit extern false final float for friend goto if inline int long mutable namespace new noexcept nullptr operator override private protected public register return short signed sizeof static struct switch template this throw true try typedef typename union unsigned using virtual void volatile while";
+var LANGUAGES = {
+  javascript: JS,
+  typescript: JS,
+  python: { line: ["#"], strings: `'"`, triple: ['"""', "'''"], keywords: "and as assert async await break class continue def del elif else except finally for from global if import in is lambda nonlocal not or pass raise return try while with yield match case self cls", literals: "True False None", types: "int float str bool bytes list dict set tuple object type", defs: { def: "function", class: "type" }, capsTypes: true, calls: true, decorators: true },
+  rust: { line: ["//"], block: [["/*", "*/"]], strings: '"', rawStrings: "r", keywords: "as async await break const continue crate dyn else enum extern fn for if impl in let loop match mod move mut pub ref return self Self static struct super trait type unsafe use where while", literals: "true false", types: "i8 i16 i32 i64 i128 isize u8 u16 u32 u64 u128 usize f32 f64 bool char str String Vec Option Result Box", defs: { fn: "function", struct: "type", enum: "type", trait: "type", type: "type", mod: "type" }, capsTypes: true, calls: true, macros: true },
+  go: { line: ["//"], block: [["/*", "*/"]], strings: "\"'`", noEscapes: "`", keywords: "break case chan const continue default defer else fallthrough for func go goto if import interface map package range return select struct switch type var", literals: "true false nil iota", types: "int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 uintptr float32 float64 complex64 complex128 string bool byte rune error any", defs: { func: "function", type: "type" }, capsTypes: true, calls: true },
+  bash: { line: ["#"], strings: `'"`, noEscapes: "'", keywords: "if then else elif fi for while until do done case esac in function select time return exit break continue export local readonly declare unset set shift source alias trap eval exec", literals: "true false", variables: true, calls: false },
+  json: { line: ["//"], block: [["/*", "*/"]], strings: '"', literals: "true false null", quotedKeys: true },
+  yaml: { kind: "yaml" },
+  toml: { kind: "ini", line: ["#"] },
+  ini: { kind: "ini", line: ["#", ";"] },
+  markup: { kind: "markup" },
+  css: { kind: "css" },
+  sql: { line: ["--"], block: [["/*", "*/"]], strings: `'"`, ci: true, keywords: "add all alter and any as asc between by case check column commit constraint create cross database default delete desc distinct drop else end exists foreign from full group having if in index inner insert into is join key left like limit not null offset on or order outer primary references replace right rollback select set table then top union unique update values view when where with", literals: "true false", types: "int integer bigint smallint decimal numeric float real double varchar char text date time timestamp boolean serial uuid json" },
+  java: { line: ["//"], block: [["/*", "*/"]], strings: `"'`, keywords: "abstract assert break case catch class const continue default do else enum extends final finally for goto if implements import instanceof interface native new package private protected public return static strictfp super switch synchronized this throw throws transient try var volatile while record sealed permits", literals: "true false null", types: "boolean byte char double float int long short void String Object", defs: { class: "type", interface: "type", enum: "type", record: "type" }, capsTypes: true, calls: true, decorators: true },
+  csharp: { line: ["//"], block: [["/*", "*/"]], strings: `"'`, keywords: "abstract as async await base break case catch checked class const continue default delegate do else enum event explicit extern finally fixed for foreach goto if implicit in interface internal is lock namespace new operator out override params private protected public readonly ref return sealed sizeof stackalloc static struct switch this throw try typeof unchecked unsafe using var virtual volatile while record init required", literals: "true false null", types: "bool byte char decimal double float int long object sbyte short string uint ulong ushort void dynamic", defs: { class: "type", interface: "type", struct: "type", enum: "type", record: "type" }, capsTypes: true, calls: true, decorators: false },
+  kotlin: { line: ["//"], block: [["/*", "*/"]], strings: `"'`, triple: ['"""'], keywords: "abstract actual annotation as break by catch class companion const constructor continue crossinline data do else enum expect external final finally for fun get if import in infix init inline inner interface internal is it lateinit lazy noinline object open operator out override package private protected public reified return sealed set super suspend tailrec this throw try typealias val var vararg when where while", literals: "true false null", types: "Int Long Short Byte Float Double Boolean Char String Unit Any Nothing", defs: { fun: "function", class: "type", interface: "type", object: "type" }, capsTypes: true, calls: true, decorators: true },
+  swift: { line: ["//"], block: [["/*", "*/"]], strings: '"', triple: ['"""'], keywords: "actor as associatedtype async await break case catch class continue default defer deinit do else enum extension fallthrough fileprivate for func guard if import in init inout internal is let nonisolated open operator private protocol public repeat rethrows return self Self static struct subscript super switch throw throws try typealias var where while", literals: "true false nil", types: "Int Double Float Bool String Character Array Dictionary Set Optional Any", defs: { func: "function", class: "type", struct: "type", enum: "type", protocol: "type", extension: "type" }, capsTypes: true, calls: true, decorators: true },
+  ruby: { line: ["#"], strings: `'"`, keywords: "alias and begin break case class def defined do else elsif end ensure for if in module next not or redo rescue retry return self super then undef unless until when while yield require require_relative include extend attr_accessor attr_reader attr_writer private protected public", literals: "true false nil", defs: { def: "function", class: "type", module: "type" }, capsTypes: true, calls: true },
+  php: { line: ["//", "#"], block: [["/*", "*/"]], strings: `'"`, keywords: "abstract and array as break callable case catch class clone const continue declare default do echo else elseif empty enddeclare endfor endforeach endif endswitch endwhile extends final finally fn for foreach function global goto if implements include include_once instanceof insteadof interface isset list match namespace new or print private protected public readonly require require_once return static switch throw trait try unset use var while xor yield", literals: "true false null TRUE FALSE NULL", defs: { function: "function", class: "type", interface: "type", trait: "type" }, capsTypes: true, calls: true, variables: true },
+  c: { line: ["//"], block: [["/*", "*/"]], strings: `"'`, keywords: C_LIKE_KEYWORDS, literals: "true false NULL nullptr", types: "size_t ssize_t int8_t int16_t int32_t int64_t uint8_t uint16_t uint32_t uint64_t bool FILE", calls: true, capsTypes: false, directives: true, defs: { struct: "type", enum: "type", union: "type", class: "type" } },
+  hcl: { line: ["#", "//"], block: [["/*", "*/"]], strings: '"', keywords: "resource data variable output locals module provider terraform for in if else dynamic content backend required_providers lifecycle", literals: "true false null", types: "string number bool list map set object tuple any", calls: true },
+  dockerfile: { line: ["#"], strings: `'"`, keywords: "FROM RUN CMD LABEL MAINTAINER EXPOSE ENV ADD COPY ENTRYPOINT VOLUME USER WORKDIR ARG ONBUILD STOPSIGNAL HEALTHCHECK SHELL AS", variables: true }
+};
+var ALIASES = {
+  js: "javascript",
+  javascript: "javascript",
+  mjs: "javascript",
+  cjs: "javascript",
+  jsx: "javascript",
+  node: "javascript",
+  nodejs: "javascript",
+  ts: "typescript",
+  typescript: "typescript",
+  tsx: "typescript",
+  mts: "typescript",
+  cts: "typescript",
+  python: "python",
+  py: "python",
+  python3: "python",
+  py3: "python",
+  rust: "rust",
+  rs: "rust",
+  go: "go",
+  golang: "go",
+  bash: "bash",
+  sh: "bash",
+  shell: "bash",
+  zsh: "bash",
+  console: "bash",
+  shellscript: "bash",
+  fish: "bash",
+  json: "json",
+  jsonc: "json",
+  json5: "json",
+  yaml: "yaml",
+  yml: "yaml",
+  toml: "toml",
+  ini: "ini",
+  conf: "ini",
+  cfg: "ini",
+  properties: "ini",
+  env: "ini",
+  markup: "markup",
+  html: "markup",
+  xml: "markup",
+  svg: "markup",
+  xhtml: "markup",
+  vue: "markup",
+  plist: "markup",
+  css: "css",
+  scss: "css",
+  less: "css",
+  sass: "css",
+  sql: "sql",
+  postgres: "sql",
+  postgresql: "sql",
+  mysql: "sql",
+  sqlite: "sql",
+  pgsql: "sql",
+  java: "java",
+  csharp: "csharp",
+  cs: "csharp",
+  "c#": "csharp",
+  kotlin: "kotlin",
+  kt: "kotlin",
+  swift: "swift",
+  ruby: "ruby",
+  rb: "ruby",
+  php: "php",
+  c: "c",
+  h: "c",
+  cpp: "c",
+  "c++": "c",
+  cc: "c",
+  cxx: "c",
+  hpp: "c",
+  hh: "c",
+  objc: "c",
+  hcl: "hcl",
+  terraform: "hcl",
+  tf: "hcl",
+  tfvars: "hcl",
+  dockerfile: "dockerfile",
+  docker: "dockerfile"
+};
+var CODE_HIGHLIGHT_LANGUAGES = Object.freeze(Object.keys(LANGUAGES));
+function resolveCodeLanguage(language) {
+  if (typeof language !== "string") return void 0;
+  const key = language.trim().toLowerCase().replace(/^(?:language|lang)[-:]/, "").replace(/^\./, "");
+  return Object.hasOwn(ALIASES, key) ? ALIASES[key] : void 0;
+}
+var IDENT = /[\p{L}_$][\p{L}\p{N}_$]*/uy;
+var NUMBER = /(?:0[xX][\da-fA-F_]+|0[bB][01_]+|0[oO][0-7_]+|\d[\d_]*(?:\.\d[\d_]*)?(?:[eE][+-]?\d[\d_]*)?)[a-zA-Z]{0,4}/y;
+var isIdentChar = (character) => character !== void 0 && /[\p{L}\p{N}_$]/u.test(character);
+function endOfLine(source, from) {
+  const index = source.slice(from).search(/\r\n|\r|\n/);
+  return index < 0 ? source.length : from + index;
+}
+function pushToken(tokens, start, end, kind2) {
+  if (end <= start) return;
+  const last = tokens[tokens.length - 1];
+  if (last && last.kind === kind2 && last.end === start && kind2 !== "function" && kind2 !== "property") last.end = end;
+  else tokens.push({ start, end, kind: kind2 });
+}
+function scanQuoted(source, from, quote, escapes, multiline) {
+  let index = from + 1;
+  while (index < source.length) {
+    const character = source[index];
+    if (escapes && character === "\\") {
+      index += 2;
+      continue;
+    }
+    if (character === quote) return index + 1;
+    if (!multiline && (character === "\n" || character === "\r")) return index;
+    index++;
+  }
+  return source.length;
+}
+function scanGeneric(source, def) {
+  const tokens = [];
+  const keywords = set(def.keywords), literals = set(def.literals), types = set(def.types);
+  const fold = (word) => def.ci ? word.toLowerCase() : word;
+  if (def.ci) for (const list of [keywords, literals, types]) for (const word of [...list]) {
+    list.delete(word);
+    list.add(word.toLowerCase());
+  }
+  const strings = def.strings ?? "", lineComments = def.line ?? [], blocks = def.block ?? [], triples = def.triple ?? [];
+  let index = 0, pendingDef;
+  const atLineStart = (position) => {
+    let at3 = position - 1;
+    while (at3 >= 0 && (source[at3] === " " || source[at3] === "	")) at3--;
+    return at3 < 0 || source[at3] === "\n" || source[at3] === "\r";
+  };
+  while (index < source.length) {
+    const character = source[index];
+    if (/\s/.test(character)) {
+      index++;
+      continue;
+    }
+    const lineComment = lineComments.find((opener) => source.startsWith(opener, index));
+    if (lineComment && !(lineComment === "#" && def.directives) && !(lineComment === "#" && def.variables && source[index - 1] === "$") && !(def.variables && lineComment === "#" && index > 0 && !/[\s;&|(]/.test(source[index - 1]))) {
+      const end = endOfLine(source, index);
+      pushToken(tokens, index, end, "comment");
+      index = end;
+      continue;
+    }
+    const block = blocks.find(([opener]) => source.startsWith(opener, index));
+    if (block) {
+      const close = source.indexOf(block[1], index + block[0].length);
+      const end = close < 0 ? source.length : close + block[1].length;
+      pushToken(tokens, index, end, "comment");
+      index = end;
+      continue;
+    }
+    if (def.directives && character === "#" && atLineStart(index)) {
+      const match = /#[ \t]*\w+/y;
+      match.lastIndex = index;
+      const found = match.exec(source);
+      if (found) {
+        pushToken(tokens, index, index + found[0].length, "keyword");
+        index += found[0].length;
+        if (/include/.test(found[0])) {
+          const header = /[ \t]*(<[^>\n]*>)/y;
+          header.lastIndex = index;
+          const matched = header.exec(source);
+          if (matched) {
+            const start = index + matched[0].length - matched[1].length;
+            pushToken(tokens, start, start + matched[1].length, "string");
+            index += matched[0].length;
+          }
+        }
+        continue;
+      }
+    }
+    const triple = triples.find((opener) => source.startsWith(opener, index));
+    if (triple) {
+      const close = source.indexOf(triple, index + 3);
+      const end = close < 0 ? source.length : close + 3;
+      pushToken(tokens, index, end, "string");
+      index = end;
+      pendingDef = void 0;
+      continue;
+    }
+    if (def.rawStrings && character === def.rawStrings && /^r#*"/.test(source.slice(index, index + 8)) && !isIdentChar(source[index - 1])) {
+      const hashes = /^r(#*)"/.exec(source.slice(index, index + 8))[1];
+      const close = source.indexOf(`"${hashes}`, index + 2 + hashes.length);
+      const end = close < 0 ? source.length : close + 1 + hashes.length;
+      pushToken(tokens, index, end, "string");
+      index = end;
+      continue;
+    }
+    if (strings.includes(character)) {
+      if (def === LANGUAGES.rust && character === "'" && !/^'(?:\\.[^']*|[^\\'])'/.test(source.slice(index, index + 12))) {
+        const match = /'[\p{L}_][\p{L}\p{N}_]*/uy;
+        match.lastIndex = index;
+        const found = match.exec(source);
+        const end2 = index + (found ? found[0].length : 1);
+        if (found) pushToken(tokens, index, end2, "type");
+        index = end2;
+        continue;
+      }
+      const escapes = !(def.noEscapes ?? "").includes(character);
+      const multiline = character === "`";
+      const end = scanQuoted(source, index, character, escapes, multiline);
+      let kind2 = "string";
+      if (def.quotedKeys) {
+        const after = /^[ \t]*:/.exec(source.slice(end, end + 40));
+        if (after) kind2 = "property";
+      }
+      pushToken(tokens, index, end, kind2);
+      index = end;
+      pendingDef = void 0;
+      continue;
+    }
+    if (def.variables && character === "$") {
+      const match = /\$(?:\{[^}\n]*\}|[A-Za-z_]\w*|[0-9@#?!$*-])/y;
+      match.lastIndex = index;
+      const found = match.exec(source);
+      if (found) {
+        pushToken(tokens, index, index + found[0].length, "property");
+        index += found[0].length;
+        continue;
+      }
+    }
+    if (def.decorators && character === "@" && /[\p{L}_]/u.test(source[index + 1] ?? "")) {
+      const match = /@[\p{L}_][\p{L}\p{N}_$.]*/uy;
+      match.lastIndex = index;
+      const found = match.exec(source);
+      pushToken(tokens, index, index + found[0].length, "function");
+      index += found[0].length;
+      continue;
+    }
+    if (/\d/.test(character) && !isIdentChar(source[index - 1])) {
+      NUMBER.lastIndex = index;
+      const found = NUMBER.exec(source);
+      if (found) {
+        pushToken(tokens, index, index + found[0].length, "number");
+        index += found[0].length;
+        pendingDef = void 0;
+        continue;
+      }
+    }
+    if (def === LANGUAGES.python && /[rRbBfFuU]/.test(character) && /^[rRbBfFuU]{1,2}['"]/.test(source.slice(index, index + 3)) && !isIdentChar(source[index - 1])) {
+      const prefix = /^[rRbBfFuU]{1,2}/.exec(source.slice(index, index + 3))[0].length;
+      const quote = source[index + prefix];
+      const triple2 = source.startsWith(quote.repeat(3), index + prefix);
+      let end;
+      if (triple2) {
+        const close = source.indexOf(quote.repeat(3), index + prefix + 3);
+        end = close < 0 ? source.length : close + 3;
+      } else end = scanQuoted(source, index + prefix, quote, !/[rR]/.test(source.slice(index, index + prefix)), false);
+      pushToken(tokens, index, end, "string");
+      index = end;
+      pendingDef = void 0;
+      continue;
+    }
+    IDENT.lastIndex = index;
+    const identifier = IDENT.exec(source);
+    if (identifier) {
+      const word = identifier[0], end = index + word.length, folded = fold(word);
+      let kind2;
+      if (pendingDef && !keywords.has(folded)) kind2 = pendingDef;
+      else if (keywords.has(folded)) {
+        kind2 = "keyword";
+        pendingDef = def.defs && Object.hasOwn(def.defs, folded) ? def.defs[folded] : void 0;
+        pushToken(tokens, index, end, kind2);
+        index = end;
+        continue;
+      } else if (literals.has(word) || literals.has(folded)) kind2 = "number";
+      else if (types.has(folded)) kind2 = "type";
+      else if (def.calls && source[end] === "(") kind2 = "function";
+      else if (def.macros && source[end] === "!" && /[([{]/.test(source[end + 1] ?? "")) kind2 = "function";
+      else if (def.capsTypes && /^[A-Z]/.test(word) && /[a-z]/.test(word)) kind2 = "type";
+      pendingDef = void 0;
+      if (kind2) pushToken(tokens, index, end, kind2);
+      index = end;
+      continue;
+    }
+    pendingDef = void 0;
+    index++;
+  }
+  return tokens;
+}
+var YAML_LITERALS = /* @__PURE__ */ new Set(["true", "false", "null", "yes", "no", "on", "off", "~", "True", "False", "Null", "TRUE", "FALSE", "NULL"]);
+function scanYamlValue(source, start, end, tokens, comments) {
+  let index = start;
+  while (index < end) {
+    const character = source[index];
+    if (character === "#" && (index === start || /\s/.test(source[index - 1])) && comments.includes("#")) {
+      pushToken(tokens, index, end, "comment");
+      return;
+    }
+    if (character === ";" && comments.includes(";") && (index === start || /\s/.test(source[index - 1]))) {
+      pushToken(tokens, index, end, "comment");
+      return;
+    }
+    if (character === '"' || character === "'") {
+      const close = scanQuoted(source, index, character, character === '"', false);
+      pushToken(tokens, index, Math.min(close, end), "string");
+      index = Math.min(close, end);
+      continue;
+    }
+    if ((character === "&" || character === "*") && /[\w-]/.test(source[index + 1] ?? "")) {
+      const match = /[&*][\w-]+/y;
+      match.lastIndex = index;
+      const found2 = match.exec(source);
+      pushToken(tokens, index, index + found2[0].length, "type");
+      index += found2[0].length;
+      continue;
+    }
+    if (!isIdentChar(source[index - 1]) && /[\d-]/.test(character)) {
+      const match = /-?\d[\d_]*(?:\.\d+)?(?:[eE][+-]?\d+)?(?=[\s,\]}]|$)/y;
+      match.lastIndex = index;
+      const found2 = match.exec(source);
+      if (found2 && index + found2[0].length <= end) {
+        pushToken(tokens, index, index + found2[0].length, "number");
+        index += found2[0].length;
+        continue;
+      }
+    }
+    const word = /[\w.~-]+/y;
+    word.lastIndex = index;
+    const found = word.exec(source);
+    if (found) {
+      if (YAML_LITERALS.has(found[0]) && !/[\w.-]/.test(source[index + found[0].length] ?? "")) pushToken(tokens, index, index + found[0].length, "number");
+      index += found[0].length;
+      continue;
+    }
+    index++;
+  }
+}
+function lineRanges(source) {
+  const ranges = [];
+  let cursor = 0;
+  const pattern = /\r\n|\r|\n/g;
+  for (let match = pattern.exec(source); match; match = pattern.exec(source)) {
+    ranges.push({ start: cursor, end: match.index });
+    cursor = match.index + match[0].length;
+  }
+  ranges.push({ start: cursor, end: source.length });
+  return ranges;
+}
+function yamlKey(source, from, to) {
+  const first = source[from];
+  if (first === void 0 || from >= to) return void 0;
+  let index = from;
+  if (first === '"' || first === "'") {
+    index = Math.min(scanQuoted(source, from, first, first === '"', false), to);
+    let at3 = index;
+    while (at3 < to && (source[at3] === " " || source[at3] === "	")) at3++;
+    return source[index - 1] === first && source[at3] === ":" && (at3 + 1 >= to || /\s/.test(source[at3 + 1])) ? { nameEnd: index, colon: at3 } : void 0;
+  }
+  if (/[\s#:{}[\],&*!|>%@`]/.test(first) || first === "-" && /[\s#:]/.test(source[from + 1] ?? " ")) return void 0;
+  for (; index < to; index++) {
+    const character = source[index];
+    if (character === "#" && /\s/.test(source[index - 1])) return void 0;
+    if (character === ":" && (index + 1 >= to || /\s/.test(source[index + 1]))) {
+      let nameEnd = index;
+      while (nameEnd > from && /\s/.test(source[nameEnd - 1])) nameEnd--;
+      return nameEnd > from ? { nameEnd, colon: index } : void 0;
+    }
+  }
+  return void 0;
+}
+function scanYaml(source) {
+  const tokens = [];
+  let blockIndent = -1;
+  for (const { start, end } of lineRanges(source)) {
+    const text2 = source.slice(start, end), indent = /^ */.exec(text2)[0].length;
+    if (blockIndent >= 0) {
+      if (text2.trim() === "" || indent > blockIndent) {
+        if (text2.trim() !== "") pushToken(tokens, start + indent, end, "string");
+        continue;
+      }
+      blockIndent = -1;
+    }
+    if (/^\s*#/.test(text2)) {
+      pushToken(tokens, start + indent, end, "comment");
+      continue;
+    }
+    if (/^(?:---|\.\.\.)(?:\s|$)/.test(text2)) {
+      pushToken(tokens, start, start + 3, "keyword");
+      scanYamlValue(source, start + 3, end, tokens, "#");
+      continue;
+    }
+    let cursor = start + indent;
+    const dash = /^(?:-\s+)+/.exec(text2.slice(indent));
+    if (dash) cursor += dash[0].length;
+    let valueStart = cursor;
+    const key = yamlKey(source, cursor, end);
+    if (key) {
+      pushToken(tokens, cursor, key.nameEnd, "property");
+      valueStart = key.colon + 1;
+    }
+    scanYamlValue(source, valueStart, end, tokens, "#");
+    if (/(?:^|\s)[|>][+-]?\d?\s*(?:#.*)?$/.test(text2.slice(valueStart - start))) blockIndent = indent;
+  }
+  return tokens;
+}
+function scanIni(source, def) {
+  const tokens = [], comments = (def.line ?? []).join("");
+  for (const { start, end } of lineRanges(source)) {
+    const text2 = source.slice(start, end), indent = /^\s*/.exec(text2)[0].length, first = text2[indent];
+    if (first === void 0) continue;
+    if (comments.includes(first)) {
+      pushToken(tokens, start + indent, end, "comment");
+      continue;
+    }
+    if (first === "[") {
+      const close = text2.indexOf("]", indent);
+      const stop = close < 0 ? end : start + close + 1;
+      pushToken(tokens, start + indent, stop, "type");
+      scanYamlValue(source, stop, end, tokens, comments);
+      continue;
+    }
+    const key = /^("[^"\n]*"|'[^'\n]*'|[^\s=:#;"']+(?:\s+[^\s=:#;"']+)*)\s*[=:]/.exec(text2.slice(indent));
+    let valueStart = start + indent;
+    if (key) {
+      pushToken(tokens, start + indent, start + indent + key[1].length, "property");
+      valueStart = start + indent + key[0].length;
+    }
+    scanYamlValue(source, valueStart, end, tokens, comments);
+  }
+  return tokens;
+}
+function scanMarkup(source) {
+  const tokens = [];
+  let index = 0;
+  while (index < source.length) {
+    const open = source.indexOf("<", index);
+    if (open < 0) break;
+    if (source.startsWith("<!--", open)) {
+      const close = source.indexOf("-->", open + 4);
+      const end = close < 0 ? source.length : close + 3;
+      pushToken(tokens, open, end, "comment");
+      index = end;
+      continue;
+    }
+    if (source.startsWith("<![CDATA[", open)) {
+      const close = source.indexOf("]]>", open);
+      const end = close < 0 ? source.length : close + 3;
+      pushToken(tokens, open, end, "string");
+      index = end;
+      continue;
+    }
+    const name = /<([/?!]?)([A-Za-z][\w:.-]*|DOCTYPE)?/y;
+    name.lastIndex = open;
+    const found = name.exec(source);
+    if (!found || !found[2]) {
+      index = open + 1;
+      continue;
+    }
+    pushToken(tokens, open + 1, open + found[0].length, "keyword");
+    index = open + found[0].length;
+    while (index < source.length && source[index] !== ">") {
+      const character = source[index];
+      if (character === '"' || character === "'") {
+        const close = source.indexOf(character, index + 1);
+        const end = close < 0 ? source.length : close + 1;
+        pushToken(tokens, index, end, "string");
+        index = end;
+        continue;
+      }
+      const attribute = /[A-Za-z_:@#][\w:.@#-]*/y;
+      attribute.lastIndex = index;
+      const matched = attribute.exec(source);
+      if (matched) {
+        pushToken(tokens, index, index + matched[0].length, "property");
+        index += matched[0].length;
+        continue;
+      }
+      index++;
+    }
+    if (source[index] === ">") index++;
+  }
+  return tokens;
+}
+function scanCss(source) {
+  const tokens = [];
+  let index = 0, depth = 0;
+  while (index < source.length) {
+    const character = source[index];
+    if (/\s/.test(character)) {
+      index++;
+      continue;
+    }
+    if (source.startsWith("/*", index)) {
+      const close = source.indexOf("*/", index + 2);
+      const end = close < 0 ? source.length : close + 2;
+      pushToken(tokens, index, end, "comment");
+      index = end;
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      const end = scanQuoted(source, index, character, true, false);
+      pushToken(tokens, index, end, "string");
+      index = end;
+      continue;
+    }
+    if (character === "{") {
+      depth++;
+      index++;
+      continue;
+    }
+    if (character === "}") {
+      depth = Math.max(0, depth - 1);
+      index++;
+      continue;
+    }
+    if (character === "@") {
+      const match = /@[\w-]+/y;
+      match.lastIndex = index;
+      const found2 = match.exec(source);
+      if (found2) {
+        pushToken(tokens, index, index + found2[0].length, "keyword");
+        index += found2[0].length;
+        continue;
+      }
+    }
+    if (character === "!") {
+      const match = /!\s*important/y;
+      match.lastIndex = index;
+      const found2 = match.exec(source);
+      if (found2) {
+        pushToken(tokens, index, index + found2[0].length, "keyword");
+        index += found2[0].length;
+        continue;
+      }
+    }
+    if (character === "#" && depth > 0) {
+      const match = /#[\da-fA-F]{3,8}\b/y;
+      match.lastIndex = index;
+      const found2 = match.exec(source);
+      if (found2) {
+        pushToken(tokens, index, index + found2[0].length, "number");
+        index += found2[0].length;
+        continue;
+      }
+    }
+    if (depth > 0 && (/\d/.test(character) || (character === "-" || character === "." || character === "+") && /\d/.test(source[index + 1] ?? ""))) {
+      const match = /[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?(?:%|[a-zA-Z]+)?/y;
+      match.lastIndex = index;
+      const found2 = match.exec(source);
+      if (found2 && !isIdentChar(source[index - 1])) {
+        pushToken(tokens, index, index + found2[0].length, "number");
+        index += found2[0].length;
+        continue;
+      }
+    }
+    const word = /-?[\p{L}_][\p{L}\p{N}_-]*/uy;
+    word.lastIndex = index;
+    const found = word.exec(source);
+    if (found) {
+      const end = index + found[0].length;
+      let back = index - 1;
+      while (back >= 0 && /\s/.test(source[back])) back--;
+      const before = back >= 0 ? source[back] : "";
+      if (depth > 0 && /^\s*:(?!:)/.test(source.slice(end, end + 8)) && (before === "{" || before === ";" || before === "")) pushToken(tokens, index, end, "property");
+      else if (source[end] === "(") pushToken(tokens, index, end, "function");
+      index = end;
+      continue;
+    }
+    if (depth === 0 && (character === "." || character === "#")) {
+      const match = /[.#][\p{L}_-][\p{L}\p{N}_-]*/uy;
+      match.lastIndex = index;
+      const matched = match.exec(source);
+      if (matched) {
+        pushToken(tokens, index, index + matched[0].length, "type");
+        index += matched[0].length;
+        continue;
+      }
+    }
+    index++;
+  }
+  return tokens;
+}
+function tokenizeCode(source, language) {
+  const id = resolveCodeLanguage(language);
+  if (id === void 0 || typeof source !== "string" || source.length === 0 || source.length > CODE_HIGHLIGHT_MAX_LENGTH) return [];
+  const def = LANGUAGES[id];
+  let tokens;
+  switch (def.kind) {
+    case "yaml":
+      tokens = scanYaml(source);
+      break;
+    case "ini":
+      tokens = scanIni(source, def);
+      break;
+    case "markup":
+      tokens = scanMarkup(source);
+      break;
+    case "css":
+      tokens = scanCss(source);
+      break;
+    default:
+      tokens = scanGeneric(source, def);
+  }
+  return tokens.filter((token) => token.end > token.start).sort((a, b) => a.start - b.start);
+}
+function codeLineRuns(tokens, start, end, source) {
+  const runs = [];
+  const push = (from, to, kind2) => {
+    if (kind2 === void 0 || source === void 0 || !source.slice(from, to).includes("	")) {
+      runs.push(kind2 === void 0 ? { start: from, end: to } : { start: from, end: to, kind: kind2 });
+      return;
+    }
+    let at3 = from;
+    for (let index = from; index < to; index++) {
+      if (source[index] !== "	") continue;
+      if (index > at3) runs.push({ start: at3, end: index, kind: kind2 });
+      runs.push({ start: index, end: index + 1 });
+      at3 = index + 1;
+    }
+    if (at3 < to) runs.push({ start: at3, end: to, kind: kind2 });
+  };
+  let cursor = start;
+  for (const token of tokens) {
+    if (token.end <= start) continue;
+    if (token.start >= end) break;
+    const from = Math.max(token.start, start), to = Math.min(token.end, end);
+    if (from > cursor) push(cursor, from);
+    push(from, to, token.kind);
+    cursor = to;
+  }
+  if (cursor < end) push(cursor, end);
+  return runs;
+}
+var distance = (a, b) => Math.hypot(...channels(a).map((value, index) => value - channels(b)[index]));
+var FALLBACK = { keyword: "#C4B5FD", string: "#86EFAC", number: "#FCD34D", function: "#93C5FD", type: "#67E8F9", property: "#F9A8D4", comment: "#94A3B8" };
+function codeSyntaxPalette(theme = {}, options = {}) {
+  const background = normalize(options.background) ?? CODE_PANEL_BACKGROUND, plain = normalize(options.foreground) ?? CODE_PANEL_FOREGROUND;
+  const minimum = options.minimumContrast ?? CODE_SYNTAX_MIN_CONTRAST;
+  const palette = { plain: legible(plain, background, minimum) };
+  const taken = [palette.plain];
+  const slots = [["keyword", theme.primary], ["string", theme.accent], ["number", theme.secondary], ["comment", theme.mutedText], ["function", void 0], ["type", void 0], ["property", void 0]];
+  for (const [kind2, themed] of slots) {
+    const candidates = [normalize(themed), FALLBACK[kind2]].filter((value) => value !== void 0).map((value) => legible(value, background, minimum));
+    let [h, s, l] = toHsl(FALLBACK[kind2]);
+    let pick = candidates.find((candidate) => taken.every((other) => distance(candidate, other) >= 48));
+    for (let turn = 0; pick === void 0 && turn < 9; turn++) {
+      h += 40;
+      const candidate = legible(fromHsl(h, s, l), background, minimum);
+      if (taken.every((other) => distance(candidate, other) >= 48)) pick = candidate;
+    }
+    palette[kind2] = pick ?? candidates[candidates.length - 1];
+    taken.push(palette[kind2]);
+  }
+  return palette;
+}
+function codeSyntaxPaletteForScheme(scheme, options = {}) {
+  const record6 = scheme && typeof scheme === "object" ? scheme : {};
+  const pick = (role, slot, fallback) => normalize(record6[role]) ?? normalize(record6[slot]) ?? fallback;
+  return codeSyntaxPalette({ primary: pick("primary", "accent1", "#2563EB"), secondary: pick("secondary", "accent2", "#0F766E"), accent: pick("accent", "accent3", "#F59E0B") }, options);
+}
+
+// src/metric-trend.ts
+var METRIC_DEFAULT_SENTIMENT = Object.freeze({ up: "positive", down: "negative", flat: "neutral" });
+function metricEffectiveSentiment(trend, sentiment) {
+  return sentiment ?? METRIC_DEFAULT_SENTIMENT[trend];
+}
+var METRIC_TREND_SHAPES = Object.freeze({ up: "upArrow", down: "downArrow", flat: "rightArrow" });
+var METRIC_TREND_MIN_CONTRAST = 4.5;
+var SEMANTIC = {
+  positive: { light: "#15803D", dark: "#4ADE80" },
+  negative: { light: "#B91C1C", dark: "#F87171" }
+};
+function metricTrendColor(trend, options) {
+  const background = normalize(options.background) ?? "#FFFFFF";
+  const sentiment = metricEffectiveSentiment(trend, options.sentiment);
+  if (sentiment === "neutral") return legible(normalize(options.neutral) ?? (luminance2(background) < 0.5 ? "#CBD5E1" : "#475569"), background, METRIC_TREND_MIN_CONTRAST);
+  const pair = SEMANTIC[sentiment];
+  return legible(luminance2(background) < 0.5 ? pair.dark : pair.light, background, METRIC_TREND_MIN_CONTRAST);
+}
+function metricTrendPoints(shape, box) {
+  const { x: l, y: t, width: w, height: h } = box, r = l + w, b = t + h, hc = l + w / 2, vc = t + h / 2, ss = Math.min(w, h);
+  if (shape === "rightArrow") {
+    const x12 = r - ss * 0.5, y1 = vc - h * 0.25, y22 = vc + h * 0.25;
+    return [[l, y1], [x12, y1], [x12, t], [r, vc], [x12, b], [x12, y22], [l, y22]];
+  }
+  const dy = ss * 0.5, x1 = hc - w * 0.25, x2 = hc + w * 0.25;
+  if (shape === "upArrow") {
+    const y22 = t + dy;
+    return [[l, y22], [hc, t], [r, y22], [x2, y22], [x2, b], [x1, b], [x1, y22]];
+  }
+  const y2 = b - dy;
+  return [[l, y2], [x1, y2], [x1, t], [x2, t], [x2, y2], [r, y2], [hc, b]];
+}
+function metricTrendMark(layout, options) {
+  const part = layout.parts.find((candidate) => candidate.role === "trend");
+  if (!part || !part.visible || !part.fit || part.fit.sourceLines.length === 0) return void 0;
+  const trend = part.text.trim();
+  if (!Object.hasOwn(METRIC_TREND_SHAPES, trend)) return void 0;
+  const line = part.fit.sourceLines[0], origin = part.linePositions[0];
+  if (!origin || line.width <= 0) return void 0;
+  const size = part.fit.fontSize * 0.72, gap = part.fit.fontSize * 0.3, left = part.box.x, right = part.box.x + part.box.width;
+  const after = origin.x + line.width + gap, before = origin.x - gap - size;
+  const fitsAfter = after + size <= right + 0.01, fitsBefore = before >= left - 0.01;
+  const x = layout.alignment === "left" ? fitsAfter ? after : fitsBefore ? before : void 0 : fitsBefore ? before : fitsAfter ? after : void 0;
+  if (x === void 0) return void 0;
+  const shape = METRIC_TREND_SHAPES[trend], box = { x, y: origin.baseline - size, width: size, height: size };
+  const sentiment = metricEffectiveSentiment(trend, options.sentiment ?? layout.sentiment);
+  return { trend, sentiment, shape, box, points: metricTrendPoints(shape, box), color: metricTrendColor(trend, { ...options, sentiment }), ariaLabel: `Trend: ${trend}`, path: part.path };
+}
+
+// src/timeline-status.ts
+var TIMELINE_STATUSES = Object.freeze(["done", "current", "planned"]);
+var TIMELINE_TEXT_MIN_CONTRAST = 4.5;
+var TIMELINE_OUTLINE_MIN_CONTRAST = 3;
+function timelineMarkerShapes(marker, colors) {
+  const background = normalize(colors.background) ?? "#FFFFFF";
+  const primary = normalize(colors.primary), outline = primary ? legible(primary, background, TIMELINE_OUTLINE_MIN_CONTRAST) : colors.primary;
+  const shapes = [];
+  const width = marker.strokeWidth ?? 0;
+  if (marker.status === "current" && marker.ring) {
+    shapes.push({ role: "ring", shape: "ellipse", cx: marker.x, cy: marker.y, radius: marker.ring.radius, fill: colors.background, stroke: { color: outline, width } });
+  }
+  if (marker.status === "planned") {
+    shapes.push({ role: "marker", shape: "ellipse", cx: marker.x, cy: marker.y, radius: marker.radius, fill: colors.background, stroke: { color: outline, width } });
+  } else {
+    shapes.push({ role: "marker", shape: "ellipse", cx: marker.x, cy: marker.y, radius: marker.radius, fill: colors.primary });
+  }
+  return shapes;
+}
+function timelineTextColor(part, colors) {
+  if (part.status !== "planned") return colors.text;
+  const background = normalize(colors.background) ?? "#FFFFFF", muted = normalize(colors.mutedText);
+  return muted ? legible(muted, background, TIMELINE_TEXT_MIN_CONTRAST) : colors.mutedText;
+}
+
+// src/code-highlight.ts
+function codeLineCount(source) {
+  let count = 1;
+  for (let index = 0; index < source.length; index++) {
+    const char = source[index];
+    if (char === "\r" && source[index + 1] === "\n") index++;
+    if (char === "\r" || char === "\n") count++;
+  }
+  return count > 1 && /(?:\r\n|\r|\n)$/.test(source) ? count - 1 : count;
+}
+var isLine = (value) => typeof value === "number" && Number.isInteger(value) && value >= 1;
+function codeHighlightLines(highlight, source) {
+  const lineCount = codeLineCount(source), marked = /* @__PURE__ */ new Set(), issues = [];
+  if (!Array.isArray(highlight)) return { lineCount, lines: [], issues };
+  highlight.forEach((entry, index) => {
+    const range = Array.isArray(entry) ? entry : [entry, entry];
+    if (range.length !== 2 || !isLine(range[0]) || !isLine(range[1])) {
+      issues.push({ code: "code-highlight-invalid", index, message: "A code highlight entry is a line number or a [start, end] pair of line numbers from 1." });
+      return;
+    }
+    const [start, end] = range;
+    if (start > end) {
+      issues.push({ code: "code-highlight-range-reversed", index, message: `The highlight range [${start}, ${end}] ends before it starts, so it marks no line; write [${end}, ${start}].` });
+      return;
+    }
+    if (end > lineCount) issues.push({ code: "code-highlight-out-of-range", index, message: `The highlight ${start === end ? `line ${start}` : `range [${start}, ${end}]`} is past the last line (the code has ${lineCount} ${lineCount === 1 ? "line" : "lines"}); lines beyond it are ignored.` });
+    for (let line = start; line <= Math.min(end, lineCount); line++) marked.add(line);
+  });
+  return { lineCount, lines: [...marked].sort((a, b) => a - b), issues };
+}
+function codeHighlightList(lines) {
+  const sorted = [...new Set(lines)].sort((a, b) => a - b), out = [];
+  for (let index = 0; index < sorted.length; ) {
+    let end = index;
+    while (sorted[end + 1] === sorted[end] + 1) end++;
+    out.push(end === index ? sorted[index] : [sorted[index], sorted[end]]);
+    index = end + 1;
+  }
+  return out;
+}
+function codeLineNumbers(sourceLines) {
+  let line = 1;
+  return sourceLines.map((entry) => {
+    const number = line;
+    if (entry.boundary === "hard") line++;
+    return number;
+  });
+}
+function codeHighlightBands(sourceLines, lines) {
+  if (!lines.length) return [];
+  const marked = new Set(lines), numbers = codeLineNumbers(sourceLines), bands = [];
+  numbers.forEach((number, index) => {
+    if (!marked.has(number)) return;
+    const last = bands.at(-1);
+    if (last && last.last === index - 1) last.last = index;
+    else bands.push({ first: index, last: index });
+  });
+  return bands;
+}
+function codeHighlightSlice(highlight, source, start, end) {
+  const { lines } = codeHighlightLines(highlight, source);
+  if (!lines.length) return void 0;
+  const breaks = (text2) => (text2.match(/\r\n|\r|\n/g) ?? []).length;
+  const before = breaks(source.slice(0, start)), count = codeLineCount(source.slice(start, end));
+  const kept = lines.filter((line) => line > before && line <= before + count).map((line) => line - before);
+  return kept.length ? codeHighlightList(kept) : void 0;
+}
+var CODE_HIGHLIGHT_DIM = 0.35;
+var CODE_HIGHLIGHT_BAND_TINT = 0.3;
+var blend = (from, to, amount) => {
+  const a = channels(from), b = channels(to);
+  return toHex(a.map((value, index) => value + (b[index] - value) * amount));
+};
+function codeHighlightColors(scheme, palette = codeSyntaxPaletteForScheme(scheme)) {
+  const record6 = scheme && typeof scheme === "object" ? scheme : {};
+  const primary = normalize(record6.primary) ?? normalize(record6.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);
+  const lit = {}, dim = {};
+  for (const key of Object.keys(palette)) {
+    lit[key] = legible(palette[key], band, CODE_SYNTAX_MIN_CONTRAST);
+    dim[key] = legible(blend(palette[key], CODE_PANEL_BACKGROUND, CODE_HIGHLIGHT_DIM), CODE_PANEL_BACKGROUND, CODE_SYNTAX_MIN_CONTRAST);
+  }
+  return { band, lit, dim };
+}
+
+// src/watermark.ts
+var WATERMARK_TEXT_ROTATION = -30;
+var WATERMARK_TEXT_MAX_WIDTH = 0.7;
+var WATERMARK_TEXT_MAX_HEIGHT = 0.3;
+function layoutWatermark(text2, size, options = {}) {
+  const value = typeof text2 === "string" ? text2.replace(/\s*[\r\n]+\s*/g, " ").trim() : "";
+  if (!value) return void 0;
+  const { width, height } = size;
+  if (![width, height].every((n) => Number.isFinite(n) && n > 0)) throw new RangeError("Watermark slide size must be finite and positive.");
+  const fontFamily = options.fontFamily ?? "sans-serif", fontWeight = options.fontWeight ?? 700;
+  const style = resolveTextStyle({ fontFamily, fontWeight, italic: false, path: "design.watermark" }, options.textMeasurement);
+  const measure = textWidthMeasurer(style, options.textMeasurement);
+  const reference = 100, unit = measure(value, reference);
+  const wanted = unit > 0 ? WATERMARK_TEXT_MAX_WIDTH * width * reference / unit : WATERMARK_TEXT_MAX_HEIGHT * Math.min(width, height);
+  const fontSize = Math.max(1, Math.min(wanted, WATERMARK_TEXT_MAX_HEIGHT * Math.min(width, height)));
+  const textWidth = measure(value, fontSize);
+  const boxWidth = textWidth + fontSize * 0.5, boxHeight = fontSize * 1.4;
+  return {
+    text: value,
+    fontFamily: style.fontFamily,
+    fontWeight,
+    style,
+    fontSize,
+    textWidth,
+    box: { x: (width - boxWidth) / 2, y: (height - boxHeight) / 2, width: boxWidth, height: boxHeight },
+    rotation: WATERMARK_TEXT_ROTATION
+  };
+}
+
+// src/pattern-fills.ts
+var PATTERN_PRESETS = Object.freeze([
+  "pct5",
+  "pct10",
+  "pct20",
+  "pct25",
+  "pct30",
+  "pct40",
+  "pct50",
+  "pct60",
+  "pct70",
+  "pct75",
+  "pct80",
+  "pct90",
+  "horz",
+  "vert",
+  "ltHorz",
+  "ltVert",
+  "dkHorz",
+  "dkVert",
+  "narHorz",
+  "narVert",
+  "dashHorz",
+  "dashVert",
+  "cross",
+  "dnDiag",
+  "upDiag",
+  "ltDnDiag",
+  "ltUpDiag",
+  "dkDnDiag",
+  "dkUpDiag",
+  "wdDnDiag",
+  "wdUpDiag",
+  "dashDnDiag",
+  "dashUpDiag",
+  "diagCross",
+  "smCheck",
+  "lgCheck",
+  "smGrid",
+  "lgGrid",
+  "dotGrid",
+  "smConfetti",
+  "lgConfetti",
+  "horzBrick",
+  "diagBrick",
+  "solidDmnd",
+  "openDmnd",
+  "dotDmnd",
+  "plaid",
+  "sphere",
+  "weave",
+  "divot",
+  "shingle",
+  "wave",
+  "trellis",
+  "zigZag"
+]);
+var PATTERN_PRESET_ALIASES = Object.freeze({ diagStripe: "wdUpDiag" });
+var PATTERN_TILE_SIZE = 8;
+var MEASURED = {
+  pct5: "#......./......../......../......../....#.../......../......../........",
+  pct10: "#......./......../....#.../......../#......./......../....#.../........",
+  pct20: "#...#.../......../..#...#./......../#...#.../......../..#...#./........",
+  pct25: "#...#.../..#...#./#...#.../..#...#./#...#.../..#...#./#...#.../..#...#.",
+  pct30: "#.#.#.#./.#...#../#.#.#.#./...#...#/#.#.#.#./.#...#../#.#.#.#./...#...#",
+  pct40: "#.#.#.#./.#.#.#.#/#.#.#.#./.#.#...#/#.#.#.#./.#.#.#.#/#.#.#.#./...#.#.#",
+  pct50: "#.#.#.#./.#.#.#.#/#.#.#.#./.#.#.#.#/#.#.#.#./.#.#.#.#/#.#.#.#./.#.#.#.#",
+  pct60: "###.###./.#.#.#.#/#.###.##/.#.#.#.#/###.###./.#.#.#.#/#.###.##/.#.#.#.#",
+  pct70: ".###.###/##.###.#/.###.###/##.###.#/.###.###/##.###.#/.###.###/##.###.#",
+  pct75: ".###.###/########/##.###.#/########/.###.###/########/##.###.#/########",
+  pct80: "###.####/########/#######./########/###.####/########/#######./########",
+  pct90: "########/########/########/####.###/########/########/########/.#######",
+  horz: "########/......../......../......../......../......../......../........",
+  vert: "#......./#......./#......./#......./#......./#......./#......./#.......",
+  ltHorz: "########/......../......../......../########/......../......../........",
+  ltVert: "#...#.../#...#.../#...#.../#...#.../#...#.../#...#.../#...#.../#...#...",
+  dkHorz: "########/########/......../......../########/########/......../........",
+  dkVert: "##..##../##..##../##..##../##..##../##..##../##..##../##..##../##..##..",
+  narHorz: "########/......../########/......../########/......../########/........",
+  narVert: ".#.#.#.#/.#.#.#.#/.#.#.#.#/.#.#.#.#/.#.#.#.#/.#.#.#.#/.#.#.#.#/.#.#.#.#",
+  dashHorz: "####..../......../......../......../....####/......../......../........",
+  dashVert: "#......./#......./#......./#......./....#.../....#.../....#.../....#...",
+  cross: "########/#......./#......./#......./#......./#......./#......./#.......",
+  dnDiag: "#......./.#....../..#...../...#..../....#.../.....#../......#./.......#",
+  upDiag: ".......#/......#./.....#../....#.../...#..../..#...../.#....../#.......",
+  ltDnDiag: "#...#.../.#...#../..#...#./...#...#/#...#.../.#...#../..#...#./...#...#",
+  ltUpDiag: "...#...#/..#...#./.#...#../#...#.../...#...#/..#...#./.#...#../#...#...",
+  dkDnDiag: "##..##../.##..##./..##..##/#..##..#/##..##../.##..##./..##..##/#..##..#",
+  dkUpDiag: "..##..##/.##..##./##..##../#..##..#/..##..##/.##..##./##..##../#..##..#",
+  wdDnDiag: "##.....#/###...../.###..../..###.../...###../....###./.....###/#.....##",
+  wdUpDiag: "#.....##/.....###/....###./...###../..###.../.###..../###...../##.....#",
+  dashDnDiag: "......../......../#...#.../.#...#../..#...#./...#...#/......../........",
+  dashUpDiag: "......../......../...#...#/..#...#./.#...#../#...#.../......../........",
+  diagCross: "#......#/.#....#./..#..#../...##.../...##.../..#..#../.#....#./#......#",
+  smCheck: "#..##..#/.##..##./.##..##./#..##..#/#..##..#/.##..##./.##..##./#..##..#",
+  lgCheck: "####..../####..../####..../####..../....####/....####/....####/....####",
+  smGrid: "########/#...#.../#...#.../#...#.../########/#...#.../#...#.../#...#...",
+  lgGrid: "########/#......./#......./#......./#......./#......./#......./#.......",
+  dotGrid: "#.#.#.#./......../#......./......../#......./......../#......./........",
+  smConfetti: "#......./....#.../.#....../......#./...#..../.......#/..#...../.....#..",
+  lgConfetti: "#.##...#/..##..../......##/...##.##/##.##.../##....../....##../#...##.#",
+  horzBrick: "########/#......./#......./#......./########/....#.../....#.../....#...",
+  diagBrick: ".......#/......#./.....#../....#.../...##.../..#..#../.#....#./#......#",
+  solidDmnd: "...#..../..###.../.#####../#######./.#####../..###.../...#..../........",
+  openDmnd: "#.....#./.#...#../..#.#.../...#..../..#.#.../.#...#../#.....#./.......#",
+  dotDmnd: "#......./......../..#...#./......../....#.../......../..#...#./........",
+  plaid: "#.#.#.#./.#.#.#.#/#.#.#.#./.#.#.#.#/####..../####..../####..../####....",
+  sphere: ".###.###/#...#..#/#...####/#...####/.###.###/#..##.../#####.../#####...",
+  weave: "#...#.../.#.#.#../..#...#./.#...#.#/#...#.../...#.#../..#...#./.#.#...#",
+  divot: "......../...#..../....#.../...#..../......../#......./.......#/#.......",
+  shingle: "......##/#....#../.#..#.../..##..../....##../......#./.......#/.......#",
+  wave: "......../...##.../..#..#.#/##....../......../...##.../..#..#.#/##......",
+  trellis: "########/.##..##./########/#..##..#/########/.##..##./########/#..##..#",
+  zigZag: "#......#/.#....#./..#..#../...##.../#......#/.#....#./..#..#../...##..."
+};
+function rows(preset) {
+  const art = MEASURED[preset];
+  if (!art) return void 0;
+  return art.split("/").map((row) => [...row].reduce((bits, cell, index) => cell === "#" ? bits | 128 >> index : bits, 0));
+}
+var BITMAPS = /* @__PURE__ */ new Map();
+for (const preset of PATTERN_PRESETS) {
+  const bitmap = rows(preset);
+  if (bitmap) BITMAPS.set(preset, Object.freeze(bitmap));
+}
+function resolvePatternPreset(preset) {
+  if (typeof preset !== "string") return void 0;
+  if (BITMAPS.has(preset)) return preset;
+  return Object.hasOwn(PATTERN_PRESET_ALIASES, preset) ? PATTERN_PRESET_ALIASES[preset] : void 0;
+}
+function patternBitmap(preset) {
+  const resolved = resolvePatternPreset(preset);
+  return resolved === void 0 ? void 0 : BITMAPS.get(resolved);
+}
+function patternRuns(preset) {
+  const bitmap = patternBitmap(preset);
+  if (!bitmap) return void 0;
+  const runs = [];
+  bitmap.forEach((row, y) => {
+    for (let x = 0; x < 8; x++) {
+      if (!(row & 128 >> x)) continue;
+      const start = x;
+      while (x + 1 < 8 && row & 128 >> x + 1) x++;
+      runs.push({ x: start, y, width: x - start + 1 });
+    }
+  });
+  return runs;
+}
 
 // src/annotations.ts
 var CITATION_MARKER_SCALE = 2 / 3;
@@ -2676,6 +3566,7 @@ var isRecord3 = (value) => !!value && typeof value === "object" && !Array.isArra
 var round = (value) => Math.round(value * 1e6) / 1e6 || value;
 var regionKey = /^(top|middle|bottom|left|center|right)([+:]|$)/;
 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 : record4(run).text ?? "").join("");
@@ -2723,8 +3614,10 @@ function walkCitationRuns(slide, basePath, visit) {
       if (field === "text") runs(payload.text, `${path}.text`);
       else list(payload[field], `${path}.${field}`);
     }
+    if (isRecord3(payload.quote)) runs(payload.quote.text, `${path}.quote.text`);
   };
   const value = record4(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) {
     for (const key of regions) host(value[key], `${basePath}.${key}`, 0);
@@ -2846,6 +3739,29 @@ 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 bodyKinds = new Set(LAYOUT_BODY_KINDS);
+function layoutContent(record6) {
+  const heading = { title: false, subtitle: false, tag: false };
+  const counts = /* @__PURE__ */ new Map();
+  let count = 0;
+  for (const placeholder of Array.isArray(record6?.placeholders) ? record6.placeholders : []) {
+    const type = placeholder?.type;
+    if (type === "title" || type === "subtitle" || type === "tag") heading[type] = true;
+    else if (typeof type === "string" && bodyKinds.has(type)) {
+      counts.set(type, (counts.get(type) ?? 0) + 1);
+      count += 1;
+    }
+  }
+  let kind2 = "title", best = 0;
+  for (const [candidate, total] of counts) if (total > best) {
+    kind2 = candidate;
+    best = total;
+  }
+  return { kind: kind2, count, heading };
+}
+
 // src/composition.ts
 var MAX_COMPOSITION_DEPTH = 32;
 var FALLBACK_CODE_FAMILY = "Roboto Mono";
@@ -2862,7 +3778,7 @@ function resolveFontSchemeReference(reference, lookup, path = "design.fontScheme
 }
 function resolveFontFamilies(input) {
   const scheme = record5(input);
-  const family = (value) => typeof value === "string" ? value : record5(value).family;
+  const family = (value) => typeof value === "string" && value ? value : void 0;
   const accent = family(scheme.accent);
   return {
     heading: family(scheme.heading) ?? scheme.major ?? scheme.minor ?? DEFAULT_FONT_FAMILIES.heading,
@@ -2946,7 +3862,7 @@ var OPFCompositionError = class extends Error {
 var fields = ["text", "items", "bullets", "image", "video", "chart", "table", "code", "metric", "quote", "timeline"];
 var headings = /* @__PURE__ */ new Set(["title", "subtitle", "tag"]);
 var COVER_LAYOUT_IDS = /* @__PURE__ */ new Set(["title", "title-subtitle"]);
-var rows = ["top", "middle", "bottom"];
+var rows2 = ["top", "middle", "bottom"];
 var columns = ["left", "center", "right"];
 var record5 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
 var kind = (field) => field === "items" ? "list" : field === "bullets" ? "text" : field;
@@ -2982,14 +3898,14 @@ function resolveSlideImage(slide, layout, presentation, width, height, path, pad
   const configured = local ? own2.slideImage : deck.slideImage;
   if (!configured || typeof configured !== "object" && typeof configured !== "string") return void 0;
   const treatment = typeof configured === "object" && !Array.isArray(configured) && "position" in configured ? record5(configured) : void 0;
-  const alignment = typeof layout.slideImageAlignment === "string" ? layout.slideImageAlignment.toLowerCase() : void 0;
-  const authoredPosition = treatment ? treatment.position : SLIDE_IMAGE_POSITIONS.find((value2) => value2 === alignment) ?? "background";
+  const layoutImage = record5(record5(layout.design).slideImage), layoutPosition = layoutImage.position;
+  const authoredPosition = treatment ? treatment.position : SLIDE_IMAGE_POSITIONS.find((value2) => value2 === layoutPosition) ?? "background";
   if (!SLIDE_IMAGE_POSITIONS.includes(authoredPosition)) return void 0;
   const mirrorSide = (side) => !rtl ? side : side === "left" ? "right" : side === "right" ? "left" : side;
   const position = mirrorSide(authoredPosition);
   const designSource = treatment ? treatment.src : configured;
   const root = slide.image, sameSource = root !== void 0 && designSource !== void 0 && assetSource(root) === assetSource(designSource);
-  if (!local && layout.slideImage !== true && !sameSource) return void 0;
+  if (!local && record5(layout.design).slideImage === void 0 && !sameSource) return void 0;
   const replacesContent = root !== void 0 && (designSource === void 0 || sameSource);
   const value = replacesContent ? root : designSource;
   const source = assetSource(value);
@@ -3058,10 +3974,10 @@ function resolveLogo(presentation, slide, options = {}) {
     if (typeof value === "string" || typeof value === "object" && !Array.isArray(value) && "src" in record5(value)) {
       return usable(value) ? { source: value, path, variant: "default", slot } : null;
     }
-    const set = record5(value);
-    if (!Object.keys(set).some((key) => LOGO_SET_KEYS.has(key))) return null;
+    const set2 = record5(value);
+    if (!Object.keys(set2).some((key) => LOGO_SET_KEYS.has(key))) return null;
     for (const key of chain) {
-      const variant = set[key];
+      const variant = set2[key];
       if (variant !== void 0 && usable(variant)) return { source: variant, path: `${path}.${key}`, variant: key, slot };
     }
     return null;
@@ -3108,8 +4024,9 @@ function layoutFurniture(input, options = {}) {
   const sourceRoot = `slides.${options.slideIndex ?? 0}`, organizations = Array.isArray(options.presentation?.organization) ? options.presentation.organization : [options.presentation?.organization];
   const primaryIndex = organizations.findIndex((item) => record5(item).role === "primary"), organizationIndex = primaryIndex >= 0 ? primaryIndex : organizations.findIndex(Boolean);
   const organization = record5(organizations[organizationIndex]), organizationRoot = Array.isArray(options.presentation?.organization) ? `organization.${organizationIndex}` : "organization", organizationPath = `${organizationRoot}.name`;
+  const speakers = Array.isArray(options.presentation?.speaker) ? options.presentation.speaker : [options.presentation?.speaker], speaker = record5(speakers[0]), speakerRoot = Array.isArray(options.presentation?.speaker) ? "speaker.0" : "speaker";
   const inlinePlatforms = record5(record5(options.presentation?.catalogs).socialPlatforms).records, platformRecords = [...Array.isArray(inlinePlatforms) ? inlinePlatforms : [], ...options.socialPlatforms ?? []];
-  const fontFamily = options.fonts?.body ?? "sans-serif";
+  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"]) {
@@ -3179,6 +4096,10 @@ function layoutFurniture(input, options = {}) {
         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.speaker === true) {
+        if (typeof speaker.name === "string" && speaker.name.trim()) add("speaker", typeof speaker.title === "string" && speaker.title.trim() ? `${speaker.name}, ${speaker.title}` : speaker.name, true, `${speakerRoot}.name`);
+        else error(`${path}.speaker`, "Generated speaker needs a named speaker in the presentation.", "unresolved-content");
+      }
       if (content.socials === true) {
         const links = Object.entries(record5(organization.socials)).filter(([, value2]) => typeof value2 === "string" && value2.trim()).map(([platform, value2]) => ({ platform, sourcePath: `${organizationRoot}.socials.${platform}`, ...resolveSocialProfile(platform, value2, platformRecords, "organization") }));
         if (links.length) add("socials", links.map((link) => link.text).join("\n"), true, `${organizationRoot}.socials`, { links });
@@ -3272,12 +4193,25 @@ function fitAtSizes(layout, requested, minimum, step = 1, snap = true) {
   }
   throw new Error("Text fitting did not evaluate its bounded floor trial.");
 }
+var PHOTO_RATIO = 3;
+var PHOTO_GAP = 0.75;
+function quoteBodyRuns(runs) {
+  if (!runs.length) return ['""'];
+  const last = runs.length - 1;
+  return runs.map((run, index) => {
+    const before = index === 0 ? '"' : "", after = index === last ? '"' : "";
+    return typeof run === "string" ? before + run + after : { ...run, text: before + run.text + after };
+  });
+}
 function layoutQuote(value, box, options = {}) {
   const shorthand = typeof value === "string";
   const quote = shorthand ? { text: value } : value;
-  if (!quote || Array.isArray(quote) || typeof quote.text !== "string" || [quote.attribution, quote.source].some((field) => field !== void 0 && typeof field !== "string")) {
-    throw new TypeError("Quote content must be a string or a text object with optional string attribution/source.");
+  const photoValue = quote?.photo;
+  if (!quote || Array.isArray(quote) || typeof quote.text !== "string" && !Array.isArray(quote.text) || [quote.attribution, quote.role, quote.source].some((field) => field !== void 0 && typeof field !== "string") || photoValue !== void 0 && typeof photoValue !== "string" && !(typeof photoValue === "object" && photoValue !== null && typeof photoValue.src === "string")) {
+    throw new TypeError("Quote content must be a string or a text object (text a string or TextRun[]) with optional string attribution/role/source and an asset photo.");
   }
+  const richBody = Array.isArray(quote.text) ? quote.text : void 0;
+  const quoteText = richBody ? annotationText(richBody) : quote.text;
   const scale = options.scale ?? 1, minimum = snapFontSizeUp((options.minFontSize ?? 16) * scale);
   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("Quote dimensions, scale and minimum font size must be finite and positive.");
@@ -3287,78 +4221,96 @@ function layoutQuote(value, box, options = {}) {
   const diagnostics = [], parts = [];
   const report = (reason, diagnosticPath, roles, message) => diagnostics.push({ code: "text-overflow", reason, path: diagnosticPath, parts: roles, message });
   const source = (sourcePath, text2, outputStart) => ({ path: sourcePath, start: 0, end: text2.length, outputStart, outputEnd: outputStart + text2.length });
-  const add = (role, text2, sources, area, fontSize, fontFamily, fontWeight, partPath) => {
+  const add = (role, text2, sources, area, fontSize, fontFamily, fontWeight, partPath, runs) => {
     const requestedStyle = { fontFamily, fontWeight, italic: false, path: partPath };
     const style = resolveTextStyle({ ...requestedStyle }, options.textMeasurement);
     const requestedFontSize = gridFontSize(fontSize * scale, minimum);
-    const part = { role, path: partPath, text: text2, sources, box: area, requestedFontSize, minFontSize: minimum, requestedStyle, style };
+    const part = { role, path: partPath, text: text2, sources, box: area, requestedFontSize, minFontSize: minimum, requestedStyle, style, ...runs ? { runs } : {} };
     parts.push(part);
     return part;
   };
   let footer = "";
   const footerSources = [];
-  for (const field of ["attribution", "source"]) {
+  for (const field of ["attribution", "role", "source"]) {
     const text2 = quote[field];
     if (!text2) continue;
-    if (footer) footer += " - ";
+    if (footer) footer += field === "role" ? "\n" : " - ";
     footerSources.push(source(`${path}.${field}`, text2, footer.length));
     footer += text2;
   }
+  const hasPhoto = photoValue !== void 0, hasFooter = footer !== "", hasBlock = hasPhoto || hasFooter;
+  const photoPath = `${path}.photo`, rtl = options.direction === "rtl";
   const bodyPath = shorthand ? path : `${path}.text`;
   const body = add(
     "body",
-    `"${quote.text}"`,
-    [source(bodyPath, quote.text, 1)],
-    { x: box.x + 18, y: box.y + 18, width: box.width - 36, height: box.height - (footer ? 94 : 36) },
+    `"${quoteText}"`,
+    [source(bodyPath, quoteText, 1)],
+    { x: box.x + 18, y: box.y + 18, width: box.width - 36, height: box.height - (hasBlock ? 94 : 36) },
     28,
-    options.fonts?.accent ?? options.fonts?.heading ?? "sans-serif",
+    options.fontFamilies?.accent ?? options.fontFamilies?.heading ?? "sans-serif",
     600,
-    bodyPath
+    bodyPath,
+    richBody ? quoteBodyRuns(richBody) : void 0
   );
-  const attribution = footer ? add(
+  const attribution = hasFooter ? add(
     "footer",
     footer,
     footerSources,
     { x: box.x + 18, y: box.y + box.height - 58, width: box.width - 36, height: 40 },
     17,
-    options.fonts?.body ?? "sans-serif",
+    options.fontFamilies?.body ?? "sans-serif",
     500,
     path
   ) : void 0;
+  const footerRequested = attribution?.requestedFontSize ?? gridFontSize(17 * scale, minimum);
   const usable = (area) => [area.x, area.y, area.width, area.height].every(Number.isFinite) && area.width > 0 && area.height > 0;
-  const fit = (part, area, size = part.requestedFontSize, floor = minimum) => usable(area) ? fitText(part.text, area, size, floor, textWidthMeasurer(part.style, options.textMeasurement), options.direction) : void 0;
+  const fit = (part, area, size = part.requestedFontSize, floor = minimum) => !usable(area) ? void 0 : part.runs ? fitRichText(part.runs, area, size, floor, { style: part.style, textMeasurement: options.textMeasurement, ...options.citationMarker ? { citationMarker: options.citationMarker } : {}, ...options.direction ? { direction: options.direction } : {} }) : fitText(part.text, area, size, floor, textWidthMeasurer(part.style, options.textMeasurement), options.direction);
+  const heightOf = (fit2) => "richLines" in fit2 ? fit2.height : fit2.lines.length * fit2.lineHeight;
   const inner = { x: box.x + 18, y: box.y + 18, width: box.width - 36, height: box.height - 36 };
-  if (!attribution) body.fit = fit(body, body.box);
+  let photo, photoFits = true;
+  if (!hasBlock) body.fit = fit(body, body.box);
   else if (usable(inner) && inner.height > 18) {
     const available = inner.height - 18;
     const preferredBody = fit(body, inner, body.requestedFontSize, body.requestedFontSize);
     const minimumBody = body.requestedFontSize === minimum ? preferredBody : fit(body, inner, minimum, minimum);
-    const preferredBodyHeight = preferredBody.lines.length * preferredBody.lineHeight;
-    const minimumBodyHeight = minimumBody.lines.length * minimumBody.lineHeight;
+    const preferredBodyHeight = heightOf(preferredBody);
+    const minimumBodyHeight = heightOf(minimumBody);
     let selected;
-    for (const size of /* @__PURE__ */ new Set([attribution.requestedFontSize, minimum])) {
-      const natural = fit(attribution, inner, size, size);
-      const naturalHeight = natural.lines.length * natural.lineHeight;
-      const preferredHeight = Math.max(40, naturalHeight);
-      const bodyReservation = Math.min(minimumBodyHeight, Math.max(minimumBody.lineHeight, available - natural.lineHeight));
-      const footerHeight = preferredBodyHeight + preferredHeight <= available + 0.01 ? preferredHeight : Math.min(naturalHeight, Math.max(0, available - bodyReservation));
+    for (const size of /* @__PURE__ */ new Set([footerRequested, minimum])) {
+      const diameter = hasPhoto ? PHOTO_RATIO * size : 0, gap = hasPhoto ? PHOTO_GAP * size : 0;
+      const textArea = { ...inner, width: inner.width - diameter - gap, x: rtl ? inner.x : inner.x + diameter + gap };
+      const natural = attribution ? fit(attribution, textArea, size, size) : void 0;
+      const naturalHeight = natural ? natural.lines.length * natural.lineHeight : 0;
+      const blockHeight = Math.max(naturalHeight, diameter);
+      const lineHeight = natural?.lineHeight ?? size * 1.22;
+      const preferredHeight = Math.max(40, blockHeight);
+      const bodyReservation = Math.min(minimumBodyHeight, Math.max(minimumBody.lineHeight, available - lineHeight));
+      const footerHeight = preferredBodyHeight + preferredHeight <= available + 0.01 ? preferredHeight : Math.min(blockHeight, Math.max(0, available - bodyReservation));
       const bodyBox = { ...inner, height: available - footerHeight };
       const footerBox = { ...inner, y: inner.y + inner.height - footerHeight, height: footerHeight };
       const bodyFit = fit(body, bodyBox);
-      const footerFit = usable(footerBox) ? { ...natural, overflow: natural.overflow || naturalHeight > footerHeight + 0.01 } : void 0;
-      const overflow = !bodyFit || !footerFit || bodyFit.overflow || footerFit.overflow;
-      const score = (body.requestedFontSize - (bodyFit?.fontSize ?? minimum) + attribution.requestedFontSize - size) / scale;
+      const photoBox = hasPhoto ? { x: rtl ? inner.x + inner.width - diameter : inner.x, y: footerBox.y + (footerHeight - diameter) / 2, width: diameter, height: diameter } : void 0;
+      const textBox = attribution ? hasPhoto ? { ...textArea, y: footerBox.y + Math.max(0, footerHeight - naturalHeight) / 2, height: Math.min(naturalHeight, footerHeight) } : footerBox : void 0;
+      const footerFit = attribution && natural && usable(footerBox) ? { ...natural, overflow: natural.overflow || naturalHeight > footerHeight + 0.01 } : void 0;
+      const fitsPhoto = !hasPhoto || diameter <= footerHeight + 0.01 && (!attribution || usable(textArea));
+      const overflow = !bodyFit || bodyFit.overflow || (attribution ? !footerFit || footerFit.overflow : false) || !fitsPhoto;
+      const score = (body.requestedFontSize - (bodyFit?.fontSize ?? minimum) + footerRequested - size) / scale;
       if (!selected || !overflow && (selected.overflow || score < selected.score) || overflow && selected.overflow) {
-        selected = { bodyBox, footerBox, bodyFit, footerFit, score, overflow };
+        selected = { bodyBox, footerBox, textBox, photoBox, bodyFit, footerFit, score, overflow, photoFits: fitsPhoto };
       }
     }
     if (selected) {
       body.box = selected.bodyBox;
       body.fit = selected.bodyFit;
-      attribution.box = selected.footerBox;
-      attribution.fit = selected.footerFit;
+      if (attribution) {
+        attribution.box = selected.textBox ?? selected.footerBox;
+        attribution.fit = selected.footerFit;
+      }
+      if (selected.photoBox) photo = { path: photoPath, value: photoValue, box: selected.photoBox, shape: slideImageShape("circle", selected.photoBox) };
+      photoFits = selected.photoFits;
     }
   }
+  if (hasPhoto && !photo) photoFits = false;
   for (const part of parts) {
     const area = part.box;
     if (!part.fit) {
@@ -3370,17 +4322,20 @@ function layoutQuote(value, box, options = {}) {
       report("part-outside-cell", part.path, [part.role], `Quote ${part.role} extends outside its cell; increase the cell size or change the arrangement.`);
     }
   }
-  if (body?.fit && attribution?.fit && body.box.y + body.fit.lines.length * body.fit.lineHeight > attribution.box.y + 0.01 && attribution.box.y + attribution.fit.lines.length * attribution.fit.lineHeight > body.box.y + 0.01) {
+  if (hasPhoto && !photoFits) report("photo-fit", photoPath, ["footer"], "Quote photo does not fit beside the attribution at the readability floor; increase the cell size, shorten the text or remove the photo.");
+  if (body?.fit && attribution?.fit && body.box.y + heightOf(body.fit) > attribution.box.y + 0.01 && attribution.box.y + attribution.fit.lines.length * attribution.fit.lineHeight > body.box.y + 0.01) {
     report("part-overlap", path, ["body", "footer"], "Quote body and footer line boxes overlap; do not accept this layout without more space.");
+  } else if (body?.fit && photo && body.box.y + heightOf(body.fit) > photo.box.y + 0.01) {
+    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, diagnostics, overflow: diagnostics.length > 0 };
+  return { 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";
   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)) {
+  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) || metric.sentiment !== void 0 && !["positive", "negative", "neutral"].includes(metric.sentiment)) {
     throw new TypeError("Metric content requires a finite numeric or string value and schema-valid display metadata.");
   }
   const scale = options.scale ?? 1, minimum = snapFontSizeUp((options.minFontSize ?? 16) * scale);
@@ -3398,7 +4353,7 @@ function layoutMetric(value, box, options = {}) {
     if (sourceValue === void 0) continue;
     const text2 = 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 requestedStyle = { fontFamily: (role === "value" ? options.fontFamilies?.heading : options.fontFamilies?.body) ?? "sans-serif", fontWeight: role === "value" ? 800 : role === "description" ? 400 : 500, italic: false, path };
     const part = {
       role,
       path,
@@ -3544,24 +4499,28 @@ 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, attempts, parts, diagnostics, overflow: diagnostics.length > 0 };
+  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 };
 }
+var TIMELINE_STATUS_VALUES = ["done", "current", "planned"];
+var TIMELINE_RING_RATIO = 1.6;
 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.");
   }
+  if (timeline.events.some((event) => event.status !== void 0 && !TIMELINE_STATUS_VALUES.includes(event.status))) throw new TypeError("Timeline event status must be 'done', 'current' or 'planned'.");
   const scale = options.scale ?? 1, minimum = snapFontSizeUp((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, rtl = options.direction === "rtl";
   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 fonts = resolveFontFamilies(options.fontFamilies), source = [];
   const add = (role, text2, partPath, size, weight, eventIndex) => {
     if (text2 === void 0) return;
-    const requestedStyle = { fontFamily: fonts.body, fontWeight: weight, italic: false, path: partPath };
-    source.push({ role, eventIndex, path: partPath, text: text2, sources: [{ path: partPath, start: 0, end: text2.length }], box: { ...box }, alignment: "center", requestedFontSize: gridFontSize(size * scale, minimum), minFontSize: minimum, requestedStyle, style: resolveTextStyle({ ...requestedStyle }, options.textMeasurement) });
+    const status = eventIndex === void 0 ? void 0 : timeline.events[eventIndex].status;
+    const requestedStyle = { fontFamily: fonts.body, fontWeight: status === "current" && role === "what" ? 700 : weight, italic: false, path: partPath };
+    source.push({ role, eventIndex, ...status ? { status } : {}, path: partPath, text: text2, sources: [{ path: partPath, start: 0, end: text2.length }], box: { ...box }, alignment: "center", requestedFontSize: gridFontSize(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);
@@ -3631,12 +4590,18 @@ function layoutTimeline(value, box, options = {}) {
         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);
+      const statusOf = (index) => timeline.events[index].status, ringRadius = radius * TIMELINE_RING_RATIO, strokeWidth = Math.min(2 * scale, radius / 2);
+      const hasRing = timeline.events.some((event) => event.status === "current");
+      const marker = (index, x, y2) => {
+        const status = statusOf(index);
+        return { path: eventPath(index), eventIndex: index, x, y: y2, radius, ...status ? { status } : {}, ...status === "current" ? { ring: { radius: ringRadius } } : {}, ...status === "current" || status === "planned" ? { strokeWidth } : {} };
+      };
       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 + (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;
-          markers.push({ path: eventPath(index), eventIndex: index, x, y: lineY, radius });
+          markers.push(marker(index, x, lineY));
           let cursor = top;
           for (const part of fields2) {
             const placed = place(part, x - width / 2, cursor, width, "center");
@@ -3645,7 +4610,8 @@ function layoutTimeline(value, box, options = {}) {
           }
         });
       } else {
-        const x = rtl ? box.x + box.width - radius : box.x + radius, textX = rtl ? box.x : box.x + 24 * scale, width = box.width - 24 * scale;
+        const lead = hasRing ? ringRadius + strokeWidth / 2 : radius, gap = 24 * scale + (lead - radius);
+        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;
@@ -3654,13 +4620,16 @@ function layoutTimeline(value, box, options = {}) {
             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 });
+          markers.push(marker(index, x, top + Math.min(first2?.box.height ?? 2 * radius, 2 * radius) / 2));
           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;
+      for (const marker2 of markers) {
+        const extent = (marker2.ring?.radius ?? marker2.radius) + (marker2.strokeWidth ?? 0) / 2;
+        if (marker2.x - extent < box.x - 0.01 || marker2.y - extent < box.y - 0.01 || marker2.x + extent > box.x + box.width + 0.01 || marker2.y + extent > box.y + box.height + 0.01) {
+          diagnostics.push({ code: "text-overflow", reason: "event-space", path: marker2.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 = rtl ? { x1: Math.min(first.x, last.x), y1: first.y, x2: Math.max(first.x, last.x), y2: last.y } : { x1: first.x, y1: first.y, x2: last.x, y2: last.y };
       const candidate = { arrangement, parts, markers, connector, diagnostics, score: score2 };
@@ -3771,7 +4740,7 @@ function layoutCode(value, box, options = {}) {
   const path = options.path ?? "code", inner = { x: box.x + 18, y: box.y + 18, width: box.width - 36, height: box.height - 36 };
   const parts = [], diagnostics = [];
   const add = (role, text2, partPath, generated = false) => {
-    const requestedStyle = { fontFamily: options.fonts?.code ?? "monospace", fontWeight: role === "body" ? 400 : 700, italic: false, path: partPath };
+    const requestedStyle = { fontFamily: options.fontFamilies?.code ?? "monospace", fontWeight: role === "body" ? 400 : 700, italic: false, path: partPath };
     const part = {
       role,
       path: partPath,
@@ -3857,7 +4826,8 @@ function richTextLayouter(input, box, requestedSize, options, minimum = 0) {
     if (typeof run?.text !== "string" || run.fontSize !== void 0 && (!Number.isFinite(run.fontSize) || run.fontSize <= 0)) throw new RangeError("Rich text runs need text and a positive finite font size.");
     const start = offset;
     offset += run.text.length;
-    const style = resolveTextStyle({ ...options.style, fontFamily: run.fontFamily ?? options.style.fontFamily, fontWeight: run.bold === void 0 ? options.style.fontWeight : run.bold ? 700 : 400, italic: run.italic ?? options.style.italic, path: options.style.path ? `${options.style.path}.${runIndex}` : void 0 }, options.textMeasurement);
+    const resolvedStyle = resolveTextStyle({ ...options.style, fontFamily: run.fontFamily ?? (run.code === true ? options.codeFontFamily ?? "monospace" : options.style.fontFamily), fontWeight: run.bold === void 0 ? options.style.fontWeight : run.bold ? 700 : 400, italic: run.italic ?? options.style.italic, path: options.style.path ? `${options.style.path}.${runIndex}` : void 0 }, options.textMeasurement);
+    const style = typeof run.lang === "string" && run.lang ? { ...resolvedStyle, lang: run.lang } : resolvedStyle;
     const marker = options.citationMarker && options.style.path && run.text ? options.citationMarker(`${options.style.path}.${runIndex}`) : void 0;
     return { run, runIndex, start, end: offset, style, ...marker ? { marker } : {} };
   });
@@ -3974,15 +4944,15 @@ var PICTURE_BULLET_SCALE = 0.65;
 function fitList(input, box, requestedSize = 25, 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 object = typeof value === "object" && !Array.isArray(value) ? value : void 0;
-    const text2 = object ? object.text : value, description = object?.description, level = object?.level ?? 0;
+    const object2 = typeof value === "object" && !Array.isArray(value) ? value : void 0;
+    const text2 = object2 ? object2.text : value, description = object2?.description, level = object2?.level ?? 0;
     if (!Number.isInteger(level) || level < 0) throw new RangeError("List levels must be nonnegative integers.");
     const runs = (value2) => typeof value2 === "string" ? [value2] : value2;
     if (!Array.isArray(runs(text2)) || description !== void 0 && !Array.isArray(runs(description))) throw new TypeError("List text and descriptions must be strings or text runs.");
     const base = options.style.path ? `${options.style.path}.${index}` : void 0;
     const plain = (value2) => typeof value2 === "string" ? value2 : value2.map((run) => typeof run === "string" ? run : run.text).join("");
     const direction = options.direction === "rtl" ? paragraphDirection(plain(text2), "rtl") : void 0;
-    return { index, level, direction, value: text2, descriptionValue: description, textPath: base ? base + (object ? ".text" : "") : void 0, descriptionPath: base ? base + ".description" : void 0, runs: runs(text2), descriptionRuns: description === void 0 ? void 0 : runs(description) };
+    return { index, level, direction, value: text2, descriptionValue: description, textPath: base ? base + (object2 ? ".text" : "") : void 0, descriptionPath: base ? base + ".description" : void 0, runs: runs(text2), descriptionRuns: description === void 0 ? void 0 : runs(description) };
   });
   const numbers = options.numbering === void 0 ? void 0 : listNumbers(input, options.numbering);
   const markerStyleFor = (item) => {
@@ -4079,13 +5049,13 @@ function layoutTable(value, box, options = {}) {
   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, direction: options.direction }) : fitText(flatten(cell.value), textBox, requested, min, textWidthMeasurer(resolveTextStyle(cell.textStyle, options.textMeasurement), options.textMeasurement), options.direction);
+    return Array.isArray(cell.value) ? fitRichText(cell.value, textBox, requested, min, { style: cell.textStyle, ...options.codeFontFamily ? { codeFontFamily: options.codeFontFamily } : {}, textMeasurement: options.textMeasurement, uniformLineHeight: true, direction: options.direction }) : fitText(flatten(cell.value), textBox, requested, min, textWidthMeasurer(resolveTextStyle(cell.textStyle, options.textMeasurement), options.textMeasurement), options.direction);
   };
   const textHeight = (fit) => "height" in fit ? fit.height : fit.lines.length * fit.lineHeight;
   const required = (cell, natural2) => {
     const floor = cellMinimum(cell), size = gridFontSize(natural2 ? Math.max(requested, floor) : 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 }, minimum)(size) : fitText(flatten(cell.value), textBox, size, size, textWidthMeasurer(resolveTextStyle(cell.textStyle, options.textMeasurement), options.textMeasurement));
+    const fit = Array.isArray(cell.value) ? richTextLayouter(cell.value, textBox, requested, { style: cell.textStyle, ...options.codeFontFamily ? { codeFontFamily: options.codeFontFamily } : {}, textMeasurement: options.textMeasurement, uniformLineHeight: true }, minimum)(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);
@@ -4106,7 +5076,7 @@ function layoutTable(value, box, options = {}) {
   const ys = [box.y];
   for (const height of heights) ys.push(ys.at(-1) + height);
   let overflow = false;
-  const rows2 = heights.map((height, r) => ({ box: { x: box.x, y: ys[r], width: box.width, height }, cells: [] }));
+  const rows3 = heights.map((height, r) => ({ box: { x: box.x, y: ys[r], width: box.width, height }, cells: [] }));
   for (const cell of cells) {
     const cellBox = { x: box.x + (options.direction === "rtl" ? columnCount - cell.column - cell.colSpan : cell.column) * cellWidth, y: ys[cell.row], width: cell.colSpan * cellWidth, height: ys[cell.row + cell.rowSpan] - ys[cell.row] };
     const available = cellBox.height - (cell.padding.top + cell.padding.bottom) * scale;
@@ -4114,12 +5084,12 @@ 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;
-    rows2[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, 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: rows2, columnCount, height: sum(heights), overflow };
+  return { rows: rows3, columnCount, height: sum(heights), overflow };
 }
 function tableOverflows(value, box, scale, settings, options, path) {
-  return box.width <= 0 || box.height <= 0 || layoutTable(value, box, { scale, minFontSize: settings.minFontSize, fontFamily: options.fonts?.body, textMeasurement: options.textMeasurement, path, presentation: options.presentation }).overflow;
+  return box.width <= 0 || box.height <= 0 || layoutTable(value, box, { scale, minFontSize: settings.minFontSize, fontFamily: options.fontFamilies?.body, ...options.fontFamilies?.code ? { codeFontFamily: options.fontFamilies.code } : {}, textMeasurement: options.textMeasurement, path, presentation: options.presentation }).overflow;
 }
 function flatten(value) {
   if (value == null) return "";
@@ -4135,10 +5105,10 @@ function regionParts(key) {
   };
   const parts = key.split(":");
   if (parts.length === 2) {
-    const r = span(parts[0], rows), c = span(parts[1], columns);
+    const r = span(parts[0], rows2), c = span(parts[1], columns);
     if (r && c) return [r, c];
   } else if (parts.length === 1) {
-    const r = span(key, rows), c = span(key, columns);
+    const r = span(key, rows2), c = span(key, columns);
     if (r) return [r, [0, 1, 2]];
     if (c) return [[0, 1, 2], c];
   }
@@ -4187,7 +5157,8 @@ function composeSlide(input, options = {}) {
   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 hasCards = record5(slide.design).contentBox ?? options.contentBox ?? false;
+  const hints = resolveDesignHints({ slide, layout, presentation: options.presentation, slideIndex: options.slideIndex, deck: { titleAlignment: options.titleAlignment, contentAlignment: options.contentAlignment, contentBox: options.contentBox } });
+  const hasCards = hints.contentBox ?? false;
   const composition = { ...record5(layout.composition), ...record5(slide.composition) };
   assertComposition(composition);
   const padding = (composition.padding ?? 0.08) * Math.min(width, height);
@@ -4196,15 +5167,13 @@ function composeSlide(input, options = {}) {
   const rasterPadding = (options.textRasterPadding ?? 1) * scale;
   if (!Number.isFinite(rasterPadding) || rasterPadding < 0) throw new RangeError("Text raster padding must be finite and nonnegative.");
   let coverGroup = false;
-  const alignmentFor = (field) => (field === "title" || coverGroup && (field === "tag" || field === "subtitle") && record5(slide.design).contentAlignment === void 0 ? record5(slide.design).titleAlignment ?? options.titleAlignment : record5(slide.design).contentAlignment ?? options.contentAlignment) ?? "left";
+  const alignmentFor = (field) => (field === "title" || coverGroup && (field === "tag" || field === "subtitle") && hints.sources.contentAlignment !== "slide" ? hints.titleAlignment : hints.contentAlignment) ?? "left";
   const styleFor = (field, path2) => resolveTextStyle({
-    fontFamily: (field === "title" ? options.fonts?.heading : field === "code" ? options.fonts?.code : field === "tag" ? options.fonts?.accent ?? options.fonts?.body : options.fonts?.body) ?? (field === "code" ? "monospace" : "sans-serif"),
+    fontFamily: (field === "title" ? options.fontFamilies?.heading : field === "code" ? options.fontFamilies?.code : field === "tag" ? options.fontFamilies?.accent ?? options.fontFamilies?.body : options.fontFamilies?.body) ?? (field === "code" ? "monospace" : "sans-serif"),
     fontWeight: field === "title" ? 700 : 400,
     path: path2
   }, options.textMeasurement);
-  const slideDesign = record5(slide.design), deckDesign = record5(record5(options.presentation).design);
-  const designHint = (field) => slideDesign[field] !== void 0 ? { value: slideDesign[field], path: `slides.${options.slideIndex ?? 0}.design.${field}` } : deckDesign[field] !== void 0 ? { value: deckDesign[field], path: `design.${field}` } : void 0;
-  const listBullet = designHint("listBullet");
+  const listBullet = hints.listBullet !== void 0 ? { value: hints.listBullet, path: hints.paths.listBullet } : void 0;
   const bulletImage = listBullet?.value === "image" ? (() => {
     const resolved = resolveLogo(options.presentation, slide, { slot: "icon", onDark: options.darkBackground, slideIndex: options.slideIndex });
     return resolved ? { source: resolved.source, path: resolved.path } : void 0;
@@ -4212,9 +5181,9 @@ function composeSlide(input, options = {}) {
   const widthFor = (field, path2) => textWidthMeasurer(styleFor(field, path2), options.textMeasurement);
   const citations = slideCitations(slide, options.slideIndex ?? 0, options.presentation);
   const citationMarker = citations ? (runPath) => citations.markers.get(runPath) : void 0;
-  const richOptions = (style) => ({ style, textMeasurement: options.textMeasurement, ...citationMarker ? { citationMarker } : {}, ...rtl ? { direction: "rtl" } : {} });
+  const richOptions = (style) => ({ style, textMeasurement: options.textMeasurement, ...options.fontFamilies?.code ? { codeFontFamily: options.fontFamilies.code } : {}, ...citationMarker ? { citationMarker } : {}, ...rtl ? { direction: "rtl" } : {} });
   const fitPlacedText = (field, value, text2, box, size, minimum, path2, explicitAlignment) => {
-    const style = styleFor(field, path2), rich = field === "text" && Array.isArray(value);
+    const style = styleFor(field, path2), rich = (field === "text" || headings.has(field)) && Array.isArray(value);
     if (!options.textMeasurement?.outlineBounds) return rich ? fitRichText(value, box, size, minimum, richOptions(style)) : fitText(text2, box, size, minimum, textWidthMeasurer(style, options.textMeasurement), textDirection);
     const alignment = explicitAlignment ?? alignmentFor(field);
     const richLayout = rich ? richTextLayouter(value, box, size, richOptions(style), minimum) : void 0;
@@ -4307,12 +5276,12 @@ function composeSlide(input, options = {}) {
   let y = logo ? logo.box.y + logo.box.height + gap : headingTop;
   const headingItems = [];
   for (const field of ["tag", "title", "subtitle"]) {
-    if (!slide[field]) continue;
+    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);
     const box = { x: area.left + padding, y, width: area.right - area.left - padding * 2, height: maxHeight };
-    const text2 = fitPlacedText(field, slide[field], String(slide[field]), box, requested, minSize, `${path}.${field}`);
-    box.height = Math.min(maxHeight, Math.max(text2.lines.length * text2.lineHeight, text2.placement?.height ?? 0));
+    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));
     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." });
     const item = { 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) };
     headingItems.push(item);
@@ -4377,22 +5346,23 @@ function composeSlide(input, options = {}) {
     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,
+    fontFamilies: options.fontFamilies,
     textMeasurement: options.textMeasurement,
     scale,
     minFontSize: settings.minFontSize,
     path: node.path,
-    direction: textDirection
+    direction: textDirection,
+    ...citationMarker ? { citationMarker } : {}
   });
   const measureCode = (node, box, settings) => layoutCode(node.value, acceptedBox(box), {
-    fonts: options.fonts,
+    fontFamilies: options.fontFamilies,
     textMeasurement: options.textMeasurement,
     scale,
     minFontSize: settings.minFontSize,
     path: node.path
   });
   const measureMetric = (node, box, settings) => layoutMetric(node.value, acceptedBox(box), {
-    fonts: options.fonts,
+    fontFamilies: options.fontFamilies,
     textMeasurement: options.textMeasurement,
     scale,
     minFontSize: settings.minFontSize,
@@ -4402,7 +5372,7 @@ function composeSlide(input, options = {}) {
     direction: textDirection
   });
   const measureTimeline = (node, box, settings) => layoutTimeline(node.value, acceptedBox(box), {
-    fonts: options.fonts,
+    fontFamilies: options.fontFamilies,
     textMeasurement: options.textMeasurement,
     scale,
     minFontSize: settings.minFontSize,
@@ -4539,18 +5509,17 @@ function composeSlide(input, options = {}) {
   };
   const placeholders = Array.isArray(layout.placeholders) ? layout.placeholders.filter((p) => !headings.has(p.type)) : [];
   if (slideImage?.replacesContent) {
-    const picture = placeholders.findIndex((p) => p.type === "picture");
+    const picture = placeholders.findIndex((p) => p.type === "image");
     if (picture >= 0) placeholders.splice(picture, 1);
   }
   const ownMode = record5(slide.composition).mode;
-  const direction = designHint("contentDirection")?.value;
-  const directionMode = direction === "vertical" ? "column" : direction === "horizontal" ? "row" : void 0;
-  const layoutDirectionMode = layout.slideLayoutDirection === "Vertical" ? "column" : layout.slideLayoutDirection === "Horizontal" ? "row" : "auto";
-  const chartHint = designHint("chartPrimary")?.value ?? (typeof layout.contentTypeChartPrimary === "string" ? layout.contentTypeChartPrimary.toLowerCase() : void 0);
+  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 rootSettings = chartPrimary ? { ...composition, mode: chartPrimary === "left" || chartPrimary === "right" ? "row" : "column", columns: void 0, weights: chartPrimary === "left" || chartPrimary === "top" ? [3, 2] : [2, 3] } : { ...composition, mode: composition.mode ?? directionMode ?? layoutDirectionMode };
+  const rootSettings = chartPrimary ? { ...composition, mode: chartPrimary === "left" || chartPrimary === "right" ? "row" : "column", columns: void 0, weights: chartPrimary === "left" || chartPrimary === "top" ? [3, 2] : [2, 3] } : { ...composition, mode: composition.mode ?? directionMode };
   if (chartPrimary) {
     const primary = pending[chartIndex], rest = pending.filter((_, index) => index !== chartIndex);
     const container = { field: "blocks", type: "group", value: rest.map((node) => node.payload), path, payload: {}, children: rest, composition: {}, synthetic: true };
@@ -4595,7 +5564,7 @@ function composeSlide(input, options = {}) {
   } : void 0;
   if (failures.length) throw new OPFCompositionError(failures, explanation);
   diagnostics.push(...slideImageDiagnostics, ...numberingDiagnostics);
-  return { width, height, contentBox, items, groups, flows, diagnostics, composition, ...furniture ? { furniture } : {}, ...slideImage ? { slideImage } : {}, ...logo ? { logo } : {}, ...rtl ? { direction: "rtl" } : {}, ...footnotes ? { footnotes } : {}, ...explanation ? { explanation } : {} };
+  return { width, height, contentBox, items, groups, flows, diagnostics, composition, design: hints, ...furniture ? { furniture } : {}, ...slideImage ? { slideImage } : {}, ...logo ? { logo } : {}, ...rtl ? { direction: "rtl" } : {}, ...footnotes ? { footnotes } : {}, ...explanation ? { explanation } : {} };
 }
 function resolveCanvasDimensions(input) {
   const presets = {
@@ -4604,6 +5573,9 @@ function resolveCanvasDimensions(input) {
     standard: [10, 7.5],
     "4:3": [10, 7.5],
     "16:10": [10, 6.25],
+    "1:1": [7.5, 7.5],
+    "4:5": [7.5, 9.375],
+    "9:16": [7.5, 40 / 3],
     letter: [11, 8.5],
     a4: [11.69, 8.27]
   };
@@ -4615,4 +5587,4 @@ function resolveCanvasDimensions(input) {
   return { width, height };
 }
 
-export { CAPTIONABLE_FIELDS, CAPTION_FONT_RATIO, CAPTION_MAX_RATIO, CHART_SERIES_MIN_DIFFERENCE, CHART_SERIES_MIN_LIGHTNESS_STEP, CITATION_MARKER_RAISE, CITATION_MARKER_SCALE, DEFAULT_CHART_LABEL_SEPARATOR, DEFAULT_FONT_SCHEME, DEFAULT_FURNITURE_DATE_FORMAT, DEFAULT_SLIDE_NUMBER_FORMAT, DEFAULT_VARIABLE_DATE_FORMAT, FONT_SIZE_GRID_PER_PX, FOOTNOTE_MAX_RATIO, MAX_COMPOSITION_DEPTH, MAX_NUMBERING_LEVELS, MAX_NUMBERING_VALUE, MAX_ROMAN_VALUE, NUMBERING_STYLES, NUMBERING_SUFFIXES, OPFCompositionError, OPFVariableError, PICTURE_BULLET_SCALE, VARIABLE_KINDS, annotationText, bareIdPattern, captionSettings, catalogIds, chartColorForFill, chartLabelText, chartNumber, chartNumberFixesByCell, chartOptionSupport, chartOptionTarget, chartPaletteForFill, citationMarkerText, coerceVariableValue, collectCitations, colorContrast, composeSlide, datasetDiagnostics, deprecatedCatalogIds, excelNumberFormat, fitList, fitRichText, fitText, formatChartLabelNumber, formatChartLabelPercent, formatDataNumber, formatFurnitureDate, formatListNumber, formatSlideNumber, formatVariableNumber, hasContentVariables, inlineChartData, inlineDatasets, inlineTableData, instantiateForValidation, intrinsicImageSize, isDatasetRef, isRecord, isTemplate, isXYChartType, layoutCaption, layoutCode, layoutFootnotes, layoutFurniture, layoutMetric, layoutQuote, layoutTable, layoutTimeline, listNumbers, listVariables, measureText, measureTextOutline, normalizeHexColor, numberFormatError, numberFormatFromExcel, numberingAtLevel, numberingFindings, numberingStyleDraws, paragraphDirection, paragraphDirectionAt, pathFor, physicalAlignment, placeTextLines, promotedRegionKeys, readingRows, referencesSlide, resolveCanvasDimensions, resolveChartData, resolveChartOptions, resolveColorRef, resolveFontFamilies, resolveFontSchemeReference, resolveLogo, resolveNumbering, resolveScriptFonts, resolveSlideDirection, resolveSocialProfile, resolveTableData, resolveTextStyle, resolveVariables, scriptFontRole, sliceNumberedItems, slideCitations, slideImageShape, snapFontSizeDown, snapFontSizeUp, suggestChartNumberFix, tableCellDisplayValue, tableGrid, tableRowBoundaries, textColorForFill, textWidthMeasurer, unusedDatasets, variableDeclarations, visitContentPayloads, visualReadingOrder, walkCitationRuns, wrapText };
+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, 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_FONT_SCHEME, DEFAULT_FURNITURE_DATE_FORMAT, DEFAULT_SLIDE_NUMBER_FORMAT, DEFAULT_VARIABLE_DATE_FORMAT, DESIGN_HINT_KEYS, FONT_SIZE_GRID_PER_PX, FOOTNOTE_MAX_RATIO, LAYOUT_BODY_KINDS, MAX_COMPOSITION_DEPTH, MAX_NUMBERING_LEVELS, MAX_NUMBERING_VALUE, 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, SURFACE_ALT_MIN_CONTRAST, SURFACE_ALT_MIX, TIMELINE_OUTLINE_MIN_CONTRAST, TIMELINE_STATUSES, TIMELINE_TEXT_MIN_CONTRAST, VARIABLE_KINDS, annotationText, bareIdPattern, captionSettings, chartColorForFill, chartHighlightColors, chartHighlightMarks, chartLabelText, chartNumber, chartNumberFixesByCell, chartOptionSupport, chartOptionTarget, chartPaletteForFill, citationMarkerText, codeHighlightBands, codeHighlightColors, codeHighlightLines, codeHighlightSlice, codeLineNumbers, codeLineRuns, codeSyntaxPalette, codeSyntaxPaletteForScheme, coerceVariableValue, collectCitations, colorContrast, composeSlide, datasetDiagnostics, defaultSlideBackground, fitList, fitRichText, fitText, formatChartLabelNumber, formatChartLabelPercent, formatDataNumber, formatFurnitureDate, formatListNumber, formatSlideNumber, formatVariableNumber, fromExcelNumberFormat, hasContentVariables, inlineChartData, inlineDatasets, inlineTableData, instantiateForValidation, intrinsicImageSize, isDarkColor, isDatasetRef, isRecord, isTemplate, isXYChartType, layoutCaption, layoutCode, layoutContent, layoutFootnotes, layoutFurniture, layoutMetric, layoutQuote, 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, resolveFontFamilies, resolveFontSchemeReference, resolveLogo, resolveNumbering, resolvePatternPreset, resolveScriptFonts, resolveSlideDirection, resolveSocialProfile, resolveTableData, resolveTextStyle, resolveVariables, scriptFontRole, sliceNumberedItems, slideCitations, slideImageShape, snapFontSizeDown, snapFontSizeUp, suggestChartNumberFix, surfaceAltColor, tableCellDisplayValue, tableGrid, tableRowBoundaries, textColorForFill, textWidthMeasurer, timelineMarkerShapes, timelineTextColor, toExcelNumberFormat, tokenizeCode, unusedDatasets, variableDeclarations, visitContentPayloads, visualReadingOrder, walkCitationRuns, wrapText };