@openpresentation/opf-editor 0.12.1 → 0.14.2

package/dist/svelte.js

@@ -52,7 +52,7 @@ export function opfCatalogSelect(node, params) {
     replaceOptions(node, getCatalogOptions(catalogKind, {
       catalogs: nextParams.catalogs,
       catalogSources: nextParams.catalogSources,
-      presentation: nextParams.presentation ?? editor.document
+      presentation: nextParams.presentation ?? editor.presentation
     }));
 
     const sync = () => {

package/dist/switches.d.ts

@@ -2,7 +2,7 @@ import type { ConvertOptions } from "@openpresentation/opf/convert";
 import type { EditorChange, EditorSession, JsonPatchOperation } from "./index.js";
 
 /** The schema's DimensionPreset values: the values of the slide-sizes switch. */
-export declare const SLIDE_SIZE_PRESETS: readonly ["16:9", "4:3", "16:10", "letter", "a4", "widescreen", "standard"];
+export declare const SLIDE_SIZE_PRESETS: readonly ["16:9", "4:3", "16:10", "1:1", "4:5", "9:16", "letter", "a4", "widescreen", "standard"];
 export type SlideSizePreset = (typeof SLIDE_SIZE_PRESETS)[number];
 
 /** Every switchable dimension: the 14 pptx.gallery dimensions, then `slide-sizes` and `purposes`. */
@@ -36,9 +36,9 @@ export interface DimensionSwitchOptions {
   /** Extra caller-loaded catalog records by kind. */
   catalogs?: Record<string, unknown>;
   catalogSources?: Record<string, unknown>;
-  /** themes: also write the theme's color scheme, font scheme, background and dimensions to the deck design (default true). */
+  /** themes: also write the theme's color scheme, font scheme and background (and, for the deck, dimensions) to the design (default true). A slide's design cannot set dimensions. */
   bundle?: boolean;
-  /** Deck-scope design switches (and slide-sizes): remove slide-level values that would hide the switch. */
+  /** Deck-scope design switches: remove slide-level values that would hide the switch. */
   clearSlideOverrides?: boolean;
   /** socials: which document field holds the handle (default "speaker") and, for an array, which entry (default 0). */
   owner?: "speaker" | "organization";
@@ -66,7 +66,7 @@ export interface PreparedDimensionSwitch {
   dimension: SwitchDimension;
   scope: "deck" | "slide" | "block";
   slideIndex?: number;
-  document: unknown;
+  presentation: unknown;
   patches: JsonPatchOperation[];
   changed: boolean;
   /** Slides whose own design hides a deck-level switch. */
@@ -75,8 +75,8 @@ export interface PreparedDimensionSwitch {
   loss?: string[];
 }
 
-export interface DimensionSwitchChange extends Omit<EditorChange, "document" | "patches"> {
-  document: unknown;
+export interface DimensionSwitchChange extends Omit<EditorChange, "presentation" | "patches"> {
+  presentation: unknown;
   patches: JsonPatchOperation[];
   dimension: SwitchDimension;
   scope: "deck" | "slide" | "block";
@@ -87,7 +87,7 @@ export interface DimensionSwitchChange extends Omit<EditorChange, "document" | "
 }
 
 /** Compute and validate the patch for one dimension without changing any session. */
-export declare function prepareDimensionSwitch(document: unknown, dimension: SwitchDimension, value: DimensionSwitchValue, options?: DimensionSwitchOptions): PreparedDimensionSwitch;
+export declare function prepareDimensionSwitch(presentation: unknown, dimension: SwitchDimension, value: DimensionSwitchValue, options?: DimensionSwitchOptions): PreparedDimensionSwitch;
 /** Apply one dimension switch to a session as a single undoable transaction. */
 export declare function switchDimension(editor: EditorSession, dimension: SwitchDimension, value: DimensionSwitchValue, options?: DimensionSwitchOptions): DimensionSwitchChange;
 
@@ -101,9 +101,9 @@ export interface CompatibleChartType extends SwitchOption {
   current: boolean;
 }
 /** Values a picker can offer for a catalog-backed dimension (document inline records, caller catalogs, then the bundled catalog, without duplicates); `blocks` lists the content kinds and `slide-sizes` the presets (labelled with their inches). `purposes` lists the catalog; any other goal text is also a valid switch value. */
-export declare function listSwitchOptions(document: unknown, dimension: SwitchDimension, options?: Pick<DimensionSwitchOptions, "catalogs" | "catalogSources">): SwitchOption[];
+export declare function listSwitchOptions(presentation: unknown, dimension: SwitchDimension, options?: Pick<DimensionSwitchOptions, "catalogs" | "catalogSources">): SwitchOption[];
 /** Chart types the chart's inline data can use as it is (data-shape compatibility, not an engine-support claim). `path` or `slideIndex` picks the chart. */
-export declare function compatibleChartTypes(document: unknown, options?: Pick<DimensionSwitchOptions, "slideIndex" | "path" | "catalogs" | "catalogSources">): CompatibleChartType[];
+export declare function compatibleChartTypes(presentation: unknown, options?: Pick<DimensionSwitchOptions, "slideIndex" | "path" | "catalogs" | "catalogSources">): CompatibleChartType[];
 /** The value a dimension currently has: `{ value, scope }`, with the catalog id for catalog dimensions. `slide-sizes` reads the deck's design.dimensions, else its theme's (a preset string, or the object for a custom size); `purposes` reads the goal text or Purpose id. */
-export declare function currentSwitchValue(document: unknown, dimension: SwitchDimension, options?: Pick<DimensionSwitchOptions, "slideIndex" | "path" | "owner" | "index">): { value: unknown; scope: "deck" | "slide" | "block" };
+export declare function currentSwitchValue(presentation: unknown, dimension: SwitchDimension, options?: Pick<DimensionSwitchOptions, "slideIndex" | "path" | "owner" | "index">): { value: unknown; scope: "deck" | "slide" | "block" };
 export { blockConversionTargets } from "./block-convert.js";

package/dist/switches.js

@@ -2,30 +2,26 @@
 // dimension that turns "switch this dimension to X" into a validated JSON Patch, and applies
 // it to an editor session as one undoable transaction. The preview recomposes and the PPTX
 // export follows from the same document, so no dimension needs a special refresh path.
-import * as core from "@openpresentation/opf";
-import { catalogSchemaNames, catalogs as bundledCatalogs, schemas } from "@openpresentation/opf";
-import {
-  OPFEditorError,
-  createValuePatch,
-  applyJsonPatch,
-  getValueAtPath,
-  opfPathToJsonPointer,
-  splitOpfPath,
-  validateOpfDocument,
-} from "./index.js";
+import { catalogSchemaNames, catalogs as bundledCatalogs, isXYChartType, resolveChartData, schemas } from "@openpresentation/opf";
+import { chartOptionTarget } from "@openpresentation/opf/composition";
+import { OPFEditorError, createValuePatch, applyJsonPatch, getValueAtPath, opfPathToJsonPointer, splitOpfPath } from "./index.js";
 import { createContentBlock, prepareBlockReplace } from "./blocks.js";
 import { checkedDocument, designPatches, fail, same } from "./edit-helpers.js";
 import { populateLayoutPlaceholders } from "./layout-placeholders.js";
 import { blockConversionTargets, prepareBlockConversion } from "./block-convert.js";
+import { checkFormat } from "./checks.js";
 
-/** The schema's DimensionPreset values (RR-41), the values of the slide-sizes switch. */
-export const SLIDE_SIZE_PRESETS = Object.freeze(["16:9", "4:3", "16:10", "letter", "a4", "widescreen", "standard"]);
+/** The schema's DimensionPreset values (RR-41, FA-13: with the social-feed ratios), the values of the slide-sizes switch. */
+export const SLIDE_SIZE_PRESETS = Object.freeze(["16:9", "4:3", "16:10", "1:1", "4:5", "9:16", "letter", "a4", "widescreen", "standard"]);
 
 // Slide size in inches per preset, as core's resolveCanvasDimensions composes it (for picker labels).
 const SLIDE_SIZE_LABELS = Object.freeze({
   "16:9": "16:9 (13.33 x 7.5 in)",
   "4:3": "4:3 (10 x 7.5 in)",
   "16:10": "16:10 (10 x 6.25 in)",
+  "1:1": "1:1 square (7.5 x 7.5 in)",
+  "4:5": "4:5 portrait (7.5 x 9.375 in)",
+  "9:16": "9:16 portrait (7.5 x 13.33 in)",
   letter: "Letter (11 x 8.5 in)",
   a4: "A4 (11.69 x 8.27 in)",
   widescreen: "Widescreen (13.33 x 7.5 in)",
@@ -90,55 +86,55 @@ function recordList(source) {
 
 // Inline document records first (they override), then caller-loaded records, then the
 // bundled catalog. Unlike getCatalogRecords, an inline catalog never hides bundled ids.
-function findCatalogRecord(document, kind, id, options) {
+function findCatalogRecord(presentation, kind, id, options) {
   return (
-    recordList(document.catalogs?.[kind]).find((record) => record.id === id) ??
+    recordList(presentation.catalogs?.[kind]).find((record) => record.id === id) ??
     recordList(options.catalogs?.[kind] ?? options.catalogSources?.[kind]).find((record) => record.id === id) ??
     (options.record?.id === id ? options.record : undefined) ??
     bundledCatalogs[kind]?.find((record) => record.id === id)
   );
 }
 
-function requireCatalogId(document, dimension, id, options) {
+function requireCatalogId(presentation, dimension, id, options) {
   const kind = CATALOG_KIND[dimension];
   if (typeof id !== "string" || id.length === 0)
     throw fail("invalid-catalog-id", `Switch ${dimension} to a non-empty catalog id.`, { dimension, id });
-  const record = findCatalogRecord(document, kind, id, options);
+  const record = findCatalogRecord(presentation, kind, id, options);
   if (!record) throw fail("unknown-catalog-id", `Unknown ${kind} catalog ID: ${id}.`, { dimension, catalogKind: kind, id });
   return record;
 }
 
 // A gallery item supplies its own record; add it inline in the same transaction when the
 // document and the bundled catalog do not already define the id.
-function catalogRecordPatches(document, dimension, options) {
+function catalogRecordPatches(presentation, dimension, options) {
   const record = options.record;
   if (!record) return [];
   const kind = CATALOG_KIND[dimension];
-  if (recordList(document.catalogs?.[kind]).some((entry) => entry.id === record.id) || bundledCatalogs[kind]?.some((entry) => entry.id === record.id)) return [];
+  if (recordList(presentation.catalogs?.[kind]).some((entry) => entry.id === record.id) || bundledCatalogs[kind]?.some((entry) => entry.id === record.id)) return [];
   const value = { $schema: schemas[catalogSchemaNames[kind]].$id, ...record };
-  if (!document.catalogs || typeof document.catalogs !== "object") return [{ op: "add", path: "/catalogs", value: { [kind]: { records: [value] } } }];
-  if (!document.catalogs[kind] || typeof document.catalogs[kind] !== "object")
+  if (!presentation.catalogs || typeof presentation.catalogs !== "object") return [{ op: "add", path: "/catalogs", value: { [kind]: { records: [value] } } }];
+  if (!presentation.catalogs[kind] || typeof presentation.catalogs[kind] !== "object")
     return [{ op: "add", path: `/catalogs/${kind}`, value: { records: [value] } }];
-  if (!Array.isArray(document.catalogs[kind].records)) return [{ op: "add", path: `/catalogs/${kind}/records`, value: [value] }];
+  if (!Array.isArray(presentation.catalogs[kind].records)) return [{ op: "add", path: `/catalogs/${kind}/records`, value: [value] }];
   return [{ op: "add", path: `/catalogs/${kind}/records/-`, value }];
 }
 
-function slideAt(document, slideIndex, what = "this switch") {
-  if (!Number.isInteger(slideIndex) || !document.slides?.[slideIndex])
+function slideAt(presentation, slideIndex, what = "this switch") {
+  if (!Number.isInteger(slideIndex) || !presentation.slides?.[slideIndex])
     throw fail("slide-index-out-of-range", `Choose an existing slide for ${what}.`, { slideIndex });
-  return document.slides[slideIndex];
+  return presentation.slides[slideIndex];
 }
 
-function rootPatch(document, field, value) {
-  return same(document[field], value) ? [] : createValuePatch(document, [field], value);
+function rootPatch(presentation, field, value) {
+  return same(presentation[field], value) ? [] : createValuePatch(presentation, [field], value);
 }
 
 // A deck-level switch does nothing for a slide that carries its own value for that key.
-function shadowedSlides(document, keys) {
-  return (document.slides ?? []).flatMap((slide, index) => (keys.some((key) => slide?.design?.[key] !== undefined) ? [index] : []));
+function shadowedSlides(presentation, keys) {
+  return (presentation.slides ?? []).flatMap((slide, index) => (keys.some((key) => slide?.design?.[key] !== undefined) ? [index] : []));
 }
 
-function findChartOwner(document, slideIndex) {
+function findChartOwner(presentation, slideIndex) {
   const visit = (node, path, depth) => {
     if (!node || typeof node !== "object" || Array.isArray(node) || depth > 32) return undefined;
     if (node.chart && typeof node.chart === "object") return path;
@@ -154,23 +150,23 @@ function findChartOwner(document, slideIndex) {
     }
     return undefined;
   };
-  return visit(document.slides[slideIndex], ["slides", String(slideIndex)], 0);
+  return visit(presentation.slides[slideIndex], ["slides", String(slideIndex)], 0);
 }
 
-function socialsPatches(document, value, options) {
+function socialsPatches(presentation, value, options) {
   const owner = options.owner ?? "speaker";
   if (!["speaker", "organization"].includes(owner)) throw fail("invalid-switch-value", "Socials owner must be 'speaker' or 'organization'.", { owner });
   if (!value || typeof value !== "object" || typeof value.platform !== "string" || typeof value.handle !== "string" || !value.handle)
     throw fail("invalid-switch-value", "Switch socials to { platform, handle } with a non-empty handle.", { value });
-  requireCatalogId(document, "socials", value.platform, options);
-  const host = document[owner];
+  requireCatalogId(presentation, "socials", value.platform, options);
+  const host = presentation[owner];
   const index = Array.isArray(host) ? (options.index ?? 0) : undefined;
   const target = Array.isArray(host) ? host[index] : host;
   if (!target || typeof target !== "object")
     throw fail("missing-owner", `Add the ${owner} to the document before setting their socials.`, { owner });
   const base = Array.isArray(host) ? [owner, String(index)] : [owner];
   const socials = target.socials;
-  const patches = catalogRecordPatches(document, "socials", options);
+  const patches = catalogRecordPatches(presentation, "socials", options);
   if (!socials || typeof socials !== "object") return [...patches, { op: "add", path: opfPathToJsonPointer([...base, "socials"]), value: { [value.platform]: value.handle } }];
   if (socials[value.platform] === value.handle) return patches;
   return [...patches, { op: Object.hasOwn(socials, value.platform) ? "replace" : "add", path: opfPathToJsonPointer([...base, "socials", value.platform]), value: value.handle }];
@@ -189,16 +185,16 @@ function blockValue(value, options) {
  * Compute the patch that switches one dimension, without touching any session. The candidate
  * document is validated; an invalid result throws unless the input was already invalid.
  */
-export function prepareDimensionSwitch(document, dimension, value, options = {}) {
+export function prepareDimensionSwitch(presentation, dimension, value, options = {}) {
   if (!SWITCH_DIMENSIONS.includes(dimension))
     throw fail("unknown-dimension", `Unknown dimension: ${dimension}. Use one of ${SWITCH_DIMENSIONS.join(", ")}.`, { dimension });
-  if (!document || typeof document !== "object") throw fail("invalid-input", "Switch requires an OPF document object.");
+  if (!presentation || typeof presentation !== "object") throw fail("invalid-input", "Switch requires an OPF document object.");
   if (options.record) {
     const ids = dimension === "audiences" ? [value].flat() : dimension === "socials" ? [value?.platform] : [value];
     if (!CATALOG_KIND[dimension] || !ids.includes(options.record.id))
       throw fail("record-id-mismatch", `The supplied record id must equal a switched ${dimension} id.`, { dimension, id: options.record.id });
   }
-  const before = validateOpfDocument(document);
+  const before = checkFormat(presentation);
   const scopeIndex = options.slideIndex;
   let patches = [];
   let scope = "deck";
@@ -210,28 +206,24 @@ export function prepareDimensionSwitch(document, dimension, value, options = {})
     // A preset string; a custom size (design.dimensions as an object with inches) is replaced by it.
     if (!SLIDE_SIZE_PRESETS.includes(value)) throw fail("invalid-switch-value", `Switch slide-sizes to one of ${SLIDE_SIZE_PRESETS.join(", ")}.`, { value });
     if (scopeIndex !== undefined) throw fail("deck-scope-only", "A presentation has one slide size: switch slide-sizes for the deck, without slideIndex.", { slideIndex: scopeIndex });
-    const own = document.design?.dimensions;
+    const own = presentation.design?.dimensions;
     // {preset} alone is the same size as the bare preset string.
     const sameSize = own && typeof own === "object" && !Array.isArray(own) && own.preset === value && Object.keys(own).length === 1;
-    patches = sameSize ? [] : designPatches(document, [], { dimensions: value });
-    shadowed = shadowedSlides(document, ["dimensions"]);
-    if (options.clearSlideOverrides) {
-      for (const index of shadowed) patches.push({ op: "remove", path: opfPathToJsonPointer(["slides", String(index), "design", "dimensions"]) });
-      shadowed = [];
-    }
+    // A slide's design cannot set dimensions (FA-07), so no slide can shadow the deck's size.
+    patches = sameSize ? [] : designPatches(presentation, [], { dimensions: value });
   } else if (dimension === "purposes") {
     // A catalog id, free-form goal text (no id check: any goal is valid) or an inline Purpose object; the schema validates it.
     if (typeof value !== "string" && !(value && typeof value === "object" && !Array.isArray(value)))
       throw fail("invalid-switch-value", "Switch purposes to a catalog id, a goal string or a purpose object.", { value });
     if (typeof value === "string" && value.length === 0) throw fail("invalid-switch-value", "Switch purposes to a non-empty goal.", { value });
-    patches = [...catalogRecordPatches(document, dimension, options), ...rootPatch(document, "purpose", value)];
+    patches = [...catalogRecordPatches(presentation, dimension, options), ...rootPatch(presentation, "purpose", value)];
   } else if (dimension === "layouts") {
     slideIndex = scopeIndex;
-    slideAt(document, slideIndex, "a layout switch");
+    slideAt(presentation, slideIndex, "a layout switch");
     scope = "slide";
-    const record = requireCatalogId(document, dimension, value, options);
-    patches = catalogRecordPatches(document, dimension, options);
-    const withRecord = patches.length ? applyJsonPatch(document, patches) : document;
+    const record = requireCatalogId(presentation, dimension, value, options);
+    patches = catalogRecordPatches(presentation, dimension, options);
+    const withRecord = patches.length ? applyJsonPatch(presentation, patches) : presentation;
     if (withRecord.slides[slideIndex].layout !== value) {
       const layoutOps = createValuePatch(withRecord, ["slides", String(slideIndex), "layout"], value);
       const swapped = applyJsonPatch(withRecord, layoutOps);
@@ -244,64 +236,65 @@ export function prepareDimensionSwitch(document, dimension, value, options = {})
     }
   } else if (dimension === "charts") {
     slideIndex = scopeIndex;
-    slideAt(document, slideIndex, "a chart switch");
+    slideAt(presentation, slideIndex, "a chart switch");
     scope = "slide";
-    requireCatalogId(document, dimension, value, options);
-    const owner = options.path ? splitOpfPath(options.path) : findChartOwner(document, slideIndex);
+    requireCatalogId(presentation, dimension, value, options);
+    const owner = options.path ? splitOpfPath(options.path) : findChartOwner(presentation, slideIndex);
     if (options.path && (owner[0] !== "slides" || owner[1] !== String(slideIndex)))
       throw fail("path-slide-mismatch", "options.path is not on the slide named by options.slideIndex.", { slideIndex, path: options.path });
-    const chart = owner && getValueAtPath(document, [...owner, "chart"]);
+    const chart = owner && getValueAtPath(presentation, [...owner, "chart"]);
     if (!chart || typeof chart !== "object") throw fail("chart-not-found", "This slide has no chart to switch. Insert a chart block first.", { slideIndex, path: options.path });
-    patches = [...catalogRecordPatches(document, dimension, options), ...(chart.type === value ? [] : [...createValuePatch(document, [...owner, "chart", "type"], value), ...staleMappingPatches(document, owner, chart, value)])];
+    patches = [...catalogRecordPatches(presentation, dimension, options), ...(chart.type === value ? [] : [...createValuePatch(presentation, [...owner, "chart", "type"], value), ...staleMappingPatches(presentation, owner, chart, value), ...staleComboPatches(presentation, owner, chart, value)])];
   } else if (dimension === "blocks") {
     if (options.path === undefined) throw fail("missing-path", "Choose the block to replace with options.path.");
     // convert: true moves the block's own text into the new kind (block-convert.js) instead of replacing it.
     if (options.convert) {
       if (typeof value !== "string") throw fail("invalid-switch-value", "Convert a block to a content kind name.", { value });
-      const conversion = prepareBlockConversion(document, options.path, value, options.conversion);
+      const conversion = prepareBlockConversion(presentation, options.path, value, options.conversion);
       patches = conversion.changed ? conversion.patches : [];
       conversionLoss = conversion.loss;
     } else {
       const block = blockValue(value, options);
-      const change = prepareBlockReplace(document, options.path, block);
+      const change = prepareBlockReplace(presentation, options.path, block);
       patches = change.changed ? change.patches : [];
     }
     const parts = splitOpfPath(options.path);
     if (parts[0] === "slides") slideIndex = Number(parts[1]);
     scope = "block";
   } else if (dimension === "socials") {
-    patches = socialsPatches(document, value, options);
+    patches = socialsPatches(presentation, value, options);
   } else if (ROOT_FIELD[dimension]) {
     const field = ROOT_FIELD[dimension];
     let next = value;
     if (dimension === "audiences") {
       next = Array.isArray(value) ? value : [value];
       if (!next.length) throw fail("invalid-catalog-id", "Switch audiences to at least one catalog id.", { value });
-      for (const id of next) requireCatalogId(document, dimension, id, options);
-    } else requireCatalogId(document, dimension, value, options);
-    patches = [...catalogRecordPatches(document, dimension, options), ...rootPatch(document, field, next)];
+      for (const id of next) requireCatalogId(presentation, dimension, id, options);
+    } else requireCatalogId(presentation, dimension, value, options);
+    patches = [...catalogRecordPatches(presentation, dimension, options), ...rootPatch(presentation, field, next)];
   } else {
     // Design dimensions: deck scope by default, or one slide with options.slideIndex.
     let entries;
     if (dimension === "themes") {
-      const record = requireCatalogId(document, dimension, value, options);
+      const record = requireCatalogId(presentation, dimension, value, options);
       entries = { theme: value };
       if (options.bundle !== false) {
         // The gallery's theme snippet writes the whole bundle, so an explicit deck choice
         // does not keep the previous theme's fonts, colors or background.
-        for (const key of ["colorScheme", "fontScheme", "background", "dimensions"]) if (record[key] !== undefined) entries[key] = record[key];
+        // A slide's design cannot set dimensions (a PPTX has one slide size), so only a deck-scope switch writes the theme's.
+        for (const key of ["colorScheme", "fontScheme", "background", ...(scopeIndex === undefined ? ["dimensions"] : [])]) if (record[key] !== undefined) entries[key] = record[key];
       }
-      patches = catalogRecordPatches(document, dimension, options);
+      patches = catalogRecordPatches(presentation, dimension, options);
     } else if (dimension === "color-schemes" || dimension === "font-schemes") {
-      requireCatalogId(document, dimension, value, options);
+      requireCatalogId(presentation, dimension, value, options);
       entries = { [DESIGN_KEYS[dimension][0]]: value };
       if (dimension === "font-schemes") {
         // An accent font is its own choice, not part of the scheme being left: it stays (in the object form).
-        const scopeBase = scopeIndex !== undefined && document.slides?.[scopeIndex] ? ["slides", String(scopeIndex)] : [];
-        const own = getValueAtPath(document, [...scopeBase, "design", "fontScheme"]);
+        const scopeBase = scopeIndex !== undefined && presentation.slides?.[scopeIndex] ? ["slides", String(scopeIndex)] : [];
+        const own = getValueAtPath(presentation, [...scopeBase, "design", "fontScheme"]);
         if (own && typeof own === "object" && own.accent !== undefined) entries.fontScheme = { id: value, accent: structuredClone(own.accent) };
       }
-      patches = catalogRecordPatches(document, dimension, options);
+      patches = catalogRecordPatches(presentation, dimension, options);
     } else {
       // A background is an object or a shorthand string (theme slot or hex color); the schema
       // validates the candidate document, so a string that is neither is rejected below.
@@ -318,29 +311,29 @@ export function prepareDimensionSwitch(document, dimension, value, options = {})
     }
     let base = [];
     if (scopeIndex !== undefined) {
-      slideAt(document, scopeIndex, `a ${dimension} switch`);
+      slideAt(presentation, scopeIndex, `a ${dimension} switch`);
       base = ["slides", String(scopeIndex)];
       scope = "slide";
       slideIndex = scopeIndex;
     }
-    patches = [...patches, ...designPatches(document, base, entries)];
+    patches = [...patches, ...designPatches(presentation, base, entries)];
     if (scope === "deck") {
       const keys = Object.entries(entries).filter(([, entry]) => entry !== undefined).map(([key]) => key);
-      shadowed = shadowedSlides(document, keys);
+      shadowed = shadowedSlides(presentation, keys);
       if (options.clearSlideOverrides)
         for (const index of shadowed)
           for (const key of keys)
-            if (document.slides[index].design?.[key] !== undefined) patches.push({ op: "remove", path: opfPathToJsonPointer(["slides", String(index), "design", key]) });
+            if (presentation.slides[index].design?.[key] !== undefined) patches.push({ op: "remove", path: opfPathToJsonPointer(["slides", String(index), "design", key]) });
       if (options.clearSlideOverrides) shadowed = [];
     }
   }
 
-  const next = checkedDocument(document, patches, before);
+  const next = checkedDocument(presentation, patches, before);
   return {
     dimension,
     scope,
     ...(slideIndex !== undefined ? { slideIndex } : {}),
-    document: structuredClone(next),
+    presentation: structuredClone(next),
     patches,
     changed: patches.length > 0,
     shadowed,
@@ -357,17 +350,17 @@ export function switchDimension(editor, dimension, value, options = {}) {
   if (!editor || typeof editor.applyPatch !== "function" || typeof editor.subscribe !== "function")
     throw fail("invalid-editor", "Expected an editor session created by createEditorSession.");
   const { meta, ...switchOptions } = options;
-  const prepared = prepareDimensionSwitch(editor.document, dimension, value, switchOptions);
-  const { document, patches, ...summary } = prepared;
-  void document;
-  if (!prepared.changed) return { ...summary, document: editor.document, patches: [], inversePatches: [], validation: editor.validation };
+  const prepared = prepareDimensionSwitch(editor.presentation, dimension, value, switchOptions);
+  const { presentation, patches, ...summary } = prepared;
+  void presentation;
+  if (!prepared.changed) return { ...summary, presentation: editor.presentation, patches: [], inversePatches: [], validation: editor.validation };
   const change = editor.applyPatch(patches, { ...meta, source: meta?.source ?? "dimension-switch", dimension, scope: prepared.scope });
   return { ...change, ...summary };
 }
 
 // --- options for pickers and current values ---------------------------------------------------
 
-const labelOf = (record) => record.label ?? record.name ?? record.id;
+const labelOf = (record) => record.name ?? record.id;
 
 /**
  * The values a picker can offer for a catalog-backed dimension, in document order: the document's
@@ -375,14 +368,14 @@ const labelOf = (record) => record.label ?? record.name ?? record.id;
  * without duplicates. `blocks` lists the content kinds. `charts` lists every chart type; use
  * `compatibleChartTypes` to narrow it to the types the chart's data can use.
  */
-export function listSwitchOptions(document, dimension, options = {}) {
+export function listSwitchOptions(presentation, dimension, options = {}) {
   if (dimension === "blocks") return BLOCK_KINDS.map((kind) => ({ id: kind, label: kind[0].toUpperCase() + kind.slice(1) }));
   if (dimension === "slide-sizes") return SLIDE_SIZE_PRESETS.map((preset) => ({ id: preset, label: SLIDE_SIZE_LABELS[preset] }));
   const kind = CATALOG_KIND[dimension];
   if (!kind) return [];
   const seen = new Set();
   const out = [];
-  for (const source of [document?.catalogs?.[kind], options.catalogs?.[kind] ?? options.catalogSources?.[kind], bundledCatalogs[kind]])
+  for (const source of [presentation?.catalogs?.[kind], options.catalogs?.[kind] ?? options.catalogSources?.[kind], bundledCatalogs[kind]])
     for (const record of recordList(source)) {
       if (seen.has(record.id)) continue;
       seen.add(record.id);
@@ -393,27 +386,38 @@ export function listSwitchOptions(document, dimension, options = {}) {
 
 const SINGLE_SERIES_ONLY = new Set(["pieChart", "doughnutChart", "funnelChart", "treemapChart", "waterfallChart"]);
 const MULTI_SERIES_CAPABLE = new Set(["barChart", "lineChart", "areaChart", "radarChart"]);
+const STACKED_GROUPINGS = new Set(["stacked", "percentStacked"]);
 const DISTRIBUTION_ELEMENTS = new Set(["histogramChart", "boxWhiskerChart", "mapChart"]);
 
 // RR-54: `mapping.x` names the X column of an XY chart; a type without an X axis ignores it (core warns chart-mapping-adapted). Switching to such a
 // type removes it, and the whole mapping when nothing else is left, so the document does not keep a warning it cannot act on.
-function staleMappingPatches(document, owner, chart, type) {
+function staleMappingPatches(presentation, owner, chart, type) {
   const mapping = chart.mapping;
   if (!mapping || typeof mapping !== "object" || Array.isArray(mapping) || mapping.x === undefined) return [];
-  if (typeof core.isXYChartType !== "function" || core.isXYChartType(type)) return [];
+  if (isXYChartType(type)) return [];
   const { x: _x, ...rest } = mapping;
   const parts = [...owner, "chart", "mapping"];
-  return Object.keys(rest).length ? createValuePatch(document, parts, rest) : [{ op: "remove", path: opfPathToJsonPointer(parts) }];
+  return Object.keys(rest).length ? createValuePatch(presentation, parts, rest) : [{ op: "remove", path: opfPathToJsonPointer(parts) }];
 }
 
-function chartDataShape(chart, document) {
+// FA-15: `line`, `secondaryAxis` and the secondary axis title belong to combo charts; any other type ignores them (core warns
+// chart-option-adapted). Switching away from combo removes them, and an `axisTitles` left empty.
+function staleComboPatches(presentation, owner, chart, type) {
+  if (chartOptionTarget(type)?.kind === "combo") return [];
+  const parts = [...owner, "chart"];
+  const patches = ["line", "secondaryAxis"].filter((key) => chart[key] !== undefined).map((key) => ({ op: "remove", path: opfPathToJsonPointer([...parts, key]) }));
+  const titles = chart.axisTitles;
+  if (titles && typeof titles === "object" && !Array.isArray(titles) && titles.secondary !== undefined) {
+    const { secondary: _secondary, ...rest } = titles;
+    patches.push(Object.keys(rest).length ? { op: "remove", path: opfPathToJsonPointer([...parts, "axisTitles", "secondary"]) } : { op: "remove", path: opfPathToJsonPointer([...parts, "axisTitles"]) });
+  }
+  return patches;
+}
+
+function chartDataShape(chart, presentation) {
   // RR-54: inline data, a dataset reference and a series mapping all resolve to the columns the renderers read: the first column labels
   // the categories and every further column is a series.
-  if (typeof core.resolveChartData !== "function") {
-    const data = chart?.data;
-    return data && Array.isArray(data.columns) && Array.isArray(data.rows) ? { series: Math.max(0, data.columns.length - 1), categories: data.rows.length } : undefined;
-  }
-  const resolved = core.resolveChartData(chart, document);
+  const resolved = resolveChartData(chart, presentation);
   if (!resolved.ok) return undefined;
   return { series: Math.max(0, resolved.columns.length - 1), categories: resolved.rows.length };
 }
@@ -422,25 +426,34 @@ function chartDataShape(chart, document) {
  * Chart types the chart's inline data can use as it is, from the chartTypes catalog: simple,
  * non-geographic, non-distribution types whose series count fits the data (the first column labels
  * the categories and each further column is a series; a type with N series needs exactly N value
- * columns; column, bar, line, area and radar take any number). Data that is read from
+ * columns, except that a stacked or percent-stacked type and a combination such as combo take N or more;
+ * column, bar, line, area and radar take any number). Data that is read from
  * an external source returns every simple type. This is data-shape compatibility, not a claim that
  * an engine draws the type. `path` or `slideIndex` picks the chart (default: the slide's first).
  * Each entry has `current: true` for the chart's present type, which is always listed.
  */
-export function compatibleChartTypes(document, options = {}) {
+export function compatibleChartTypes(presentation, options = {}) {
   const slideIndex = options.slideIndex ?? 0;
-  const owner = options.path ? splitOpfPath(options.path) : document.slides?.[slideIndex] ? findChartOwner(document, slideIndex) : undefined;
-  const chart = owner && getValueAtPath(document, [...owner, "chart"]);
+  const owner = options.path ? splitOpfPath(options.path) : presentation.slides?.[slideIndex] ? findChartOwner(presentation, slideIndex) : undefined;
+  const chart = owner && getValueAtPath(presentation, [...owner, "chart"]);
   if (!chart || typeof chart !== "object") return [];
-  const shape = chartDataShape(chart, document);
+  const shape = chartDataShape(chart, presentation);
   const result = [];
-  for (const option of listSwitchOptions(document, "charts", options)) {
+  for (const option of listSwitchOptions(presentation, "charts", options)) {
     const record = option.record;
     const element = record.mappings?.openxml?.element;
     const current = option.id === chart.type;
-    const simple = record.complexity === "simple" && record.mappings?.openxml?.composition !== "mixed" && !DISTRIBUTION_ELEMENTS.has(element);
+    const simple = record.complexity === "simple" && !DISTRIBUTION_ELEMENTS.has(element);
+    // A combination (composition "mixed", the FA-15 combo chart) needs at least its series count, like a stacked type.
+    const atLeast = STACKED_GROUPINGS.has(record.mappings?.openxml?.grouping) || record.mappings?.openxml?.composition === "mixed";
     const seriesOk =
-      !shape || !record.series || (record.series > 1 ? record.series === shape.series : shape.series === 1 || (MULTI_SERIES_CAPABLE.has(element) && !SINGLE_SERIES_ONLY.has(element)));
+      !shape ||
+      !record.series ||
+      (record.series > 1
+        ? atLeast
+          ? shape.series >= record.series
+          : record.series === shape.series
+        : shape.series === 1 || (MULTI_SERIES_CAPABLE.has(element) && !SINGLE_SERIES_ONLY.has(element)));
     if (current || (simple && seriesOk)) result.push({ id: option.id, label: option.label, current, record });
   }
   return result;
@@ -452,43 +465,40 @@ export function compatibleChartTypes(document, options = {}) {
  * dimension is unset. Catalog dimensions return the catalog id even when the document holds an
  * inline object.
  */
-export function currentSwitchValue(document, dimension, options = {}) {
+export function currentSwitchValue(presentation, dimension, options = {}) {
   const idOf = (reference) => (reference && typeof reference === "object" && !Array.isArray(reference) ? reference.id : reference);
   const design = (key) => {
-    const slide = options.slideIndex !== undefined ? document.slides?.[options.slideIndex]?.design?.[key] : undefined;
+    const slide = options.slideIndex !== undefined ? presentation.slides?.[options.slideIndex]?.design?.[key] : undefined;
     if (slide !== undefined) return { value: slide, scope: "slide" };
-    return document.design?.[key] === undefined ? { scope: "deck" } : { value: document.design[key], scope: "deck" };
+    return presentation.design?.[key] === undefined ? { scope: "deck" } : { value: presentation.design[key], scope: "deck" };
   };
-  if (dimension === "layouts") return { value: document.slides?.[options.slideIndex]?.layout, scope: "slide" };
+  if (dimension === "layouts") return { value: presentation.slides?.[options.slideIndex]?.layout, scope: "slide" };
   if (dimension === "charts") {
-    const owner = options.path ? splitOpfPath(options.path) : findChartOwner(document, options.slideIndex ?? 0);
-    return { value: owner ? getValueAtPath(document, [...owner, "chart", "type"]) : undefined, scope: "slide" };
+    const owner = options.path ? splitOpfPath(options.path) : findChartOwner(presentation, options.slideIndex ?? 0);
+    return { value: owner ? getValueAtPath(presentation, [...owner, "chart", "type"]) : undefined, scope: "slide" };
   }
   if (dimension === "blocks") return { value: undefined, scope: "block" };
   if (dimension === "slide-sizes") {
     // The size the deck composes at: its own design.dimensions, else the theme's; a {preset} object reads as its preset.
     // A custom size (inches without a preset) reads as the object itself. Unset reads as undefined (composed as widescreen).
-    const own = design("dimensions");
-    let size = own.value;
-    let scope = own.scope;
+    let size = presentation.design?.dimensions;
     if (size === undefined) {
-      const themeId = idOf(design("theme").value);
-      size = themeId ? findCatalogRecord(document, "themes", themeId, {})?.dimensions : undefined;
-      scope = "deck";
+      const themeId = idOf(presentation.design?.theme);
+      size = themeId ? findCatalogRecord(presentation, "themes", themeId, {})?.dimensions : undefined;
     }
-    return { value: size && typeof size === "object" && !Array.isArray(size) && Object.keys(size).length === 1 && size.preset ? size.preset : size, scope };
+    return { value: size && typeof size === "object" && !Array.isArray(size) && Object.keys(size).length === 1 && size.preset ? size.preset : size, scope: "deck" };
   }
   if (dimension === "purposes") {
     // A catalog id or goal text reads as itself, a Purpose object as its id (else the object).
-    const purpose = document.purpose;
+    const purpose = presentation.purpose;
     return { value: purpose && typeof purpose === "object" && !Array.isArray(purpose) ? (purpose.id ?? purpose) : purpose, scope: "deck" };
   }
   if (dimension === "socials") {
-    const host = document[options.owner ?? "speaker"];
+    const host = presentation[options.owner ?? "speaker"];
     const target = Array.isArray(host) ? host[options.index ?? 0] : host;
     return { value: target?.socials, scope: "deck" };
   }
-  if (ROOT_FIELD[dimension]) return { value: document[ROOT_FIELD[dimension]], scope: "deck" };
+  if (ROOT_FIELD[dimension]) return { value: presentation[ROOT_FIELD[dimension]], scope: "deck" };
   if (dimension === "color-schemes") return { ...design("colorScheme"), value: idOf(design("colorScheme").value) };
   if (dimension === "font-schemes") return { ...design("fontScheme"), value: idOf(design("fontScheme").value) };
   if (dimension === "themes") return { ...design("theme"), value: idOf(design("theme").value) };