@openpresentation/opf-editor 0.12.1 → 0.14.2

package/dist/design-options.js

@@ -3,8 +3,9 @@
 // by default or on one slide with `slideIndex`, exactly like the dimension switches. Every
 // function has a `prepare…` form that returns the patch without touching a session, and a
 // session form that commits it with `meta.source: "design-option"`.
-import { getValueAtPath, opfPathToJsonPointer, validateOpfDocument } from "./index.js";
+import { getValueAtPath, opfPathToJsonPointer } from "./index.js";
 import { checkedDocument, designPatches, fail, same } from "./edit-helpers.js";
+import { checkFormat } from "./checks.js";
 
 /** The `design.logo` variant slots of a LogoSet, in schema order. */
 export const LOGO_VARIANTS = Object.freeze([
@@ -23,8 +24,8 @@ export const LOGO_VARIANTS = Object.freeze([
 ]);
 export const HEADER_FOOTER_ZONES = Object.freeze(["left", "center", "right"]);
 // Flag fields of a header/footer zone: false is stored as "absent" (so is a `date` of false).
-const ZONE_FLAGS = ["logo", "slideNumber", "organization", "socials", "section"];
-export const ZONE_FIELDS = Object.freeze(["logo", "text", "image", "slideNumber", "slideNumberFormat", "date", "dateFormat", "organization", "socials", "section"]);
+const ZONE_FLAGS = ["logo", "slideNumber", "organization", "speaker", "socials", "section"];
+export const ZONE_FIELDS = Object.freeze(["logo", "text", "image", "slideNumber", "slideNumberFormat", "date", "dateFormat", "organization", "speaker", "socials", "section"]);
 /** Date tokens a `dateFormat` understands (English names, independent of the host locale). */
 export const DATE_FORMAT_TOKENS = Object.freeze(["yyyy", "yy", "MMMM", "MMM", "MM", "M", "dd", "d", "EEEE", "EEE"]);
 const ISO_DATE = /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/;
@@ -32,7 +33,7 @@ const ISO_DATE = /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/;
 // Friendly validation of one zone field before the schema sees it.
 function checkZoneField(key, value) {
   const bad = (message) => fail("invalid-design-value", message, { field: key, value });
-  if (["logo", "slideNumber", "organization", "socials", "section"].includes(key) && typeof value !== "boolean") throw bad(`${key} is true or false.`);
+  if (ZONE_FLAGS.includes(key) && typeof value !== "boolean") throw bad(`${key} is true or false.`);
   if (key === "text" && typeof value !== "string") throw bad("Text is a string.");
   if (key === "image" && typeof value !== "string" && !isObject(value)) throw bad("An image is a source, an asset reference or an asset object.");
   if (key === "slideNumberFormat" && (typeof value !== "string" || !value.includes("{current}"))) throw bad("The slide number format must contain {current}, for example Page {current} of {total}.");
@@ -62,7 +63,7 @@ export const DESIGN_OPTIONS = Object.freeze([
   { id: "chartPrimary", label: "Primary chart position", type: "enum", values: ENUMS.chartPrimary, scopes: ["deck", "slide"], path: "design.chartPrimary" },
   { id: "listBullet", label: "List bullets", type: "enum", values: ENUMS.listBullet, scopes: ["deck", "slide"], path: "design.listBullet" },
   { id: "contentBox", label: "Content box", type: "boolean", scopes: ["deck", "slide"], path: "design.contentBox" },
-  { id: "accentFont", label: "Accent font", type: "font", scopes: ["deck", "slide"], path: "design.fontScheme.accent.family" },
+  { id: "accentFont", label: "Accent font", type: "font", scopes: ["deck", "slide"], path: "design.fontScheme.accent" },
   { id: "logo", label: "Logo", type: "logo", scopes: ["deck", "slide"], path: "design.logo" },
   { id: "organizationLogo", label: "Organization logo", type: "organization-logo", scopes: ["deck"], path: "organization.logo" },
   { id: "watermark", label: "Watermark", type: "watermark", scopes: ["deck", "slide"], path: "design.watermark" },
@@ -72,27 +73,32 @@ const BY_ID = Object.fromEntries(DESIGN_OPTIONS.map((option) => [option.id, opti
 
 const isObject = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
 
-function scopeOf(document, option, options) {
+function scopeOf(presentation, option, options) {
   const index = options.slideIndex;
   if (index === undefined) return { scope: "deck", base: [] };
   if (!BY_ID[option]?.scopes.includes("slide")) throw fail("invalid-scope", `${BY_ID[option]?.label ?? option} applies to the whole presentation, not one slide.`, { option });
-  if (!Number.isInteger(index) || !document.slides?.[index]) throw fail("slide-index-out-of-range", "Choose an existing slide for this option.", { slideIndex: index });
+  if (!Number.isInteger(index) || !presentation.slides?.[index]) throw fail("slide-index-out-of-range", "Choose an existing slide for this option.", { slideIndex: index });
   return { scope: "slide", base: ["slides", String(index)], slideIndex: index };
 }
 
-function ownDesign(document, base) {
-  const design = getValueAtPath(document, base.length ? [...base, "design"] : ["design"]);
+function ownDesign(presentation, base) {
+  const design = getValueAtPath(presentation, base.length ? [...base, "design"] : ["design"]);
   return isObject(design) ? design : {};
 }
 
-function primaryOrganization(document) {
-  const list = Array.isArray(document.organization) ? document.organization : document.organization ? [document.organization] : [];
+function primaryOrganization(presentation) {
+  const list = Array.isArray(presentation.organization) ? presentation.organization : presentation.organization ? [presentation.organization] : [];
   return list.find((entry) => entry?.role === "primary") ?? list[0];
 }
 
+function firstSpeaker(presentation) {
+  const list = Array.isArray(presentation.speaker) ? presentation.speaker : presentation.speaker ? [presentation.speaker] : [];
+  return list[0];
+}
+
 /** Whether a logo resolves for the slide: slide design, then deck design, then the primary organization. */
-export function hasResolvableLogo(document, slideIndex) {
-  return Boolean(document.slides?.[slideIndex]?.design?.logo ?? document.design?.logo ?? primaryOrganization(document)?.logo);
+export function hasResolvableLogo(presentation, slideIndex) {
+  return Boolean(presentation.slides?.[slideIndex]?.design?.logo ?? presentation.design?.logo ?? primaryOrganization(presentation)?.logo);
 }
 
 /**
@@ -100,21 +106,23 @@ export function hasResolvableLogo(document, slideIndex) {
  * footer zone with `logo: true`, or picture bullets. The renderers fall back to a glyph or report
  * unresolved content; the editor surfaces it before export.
  */
-export function designWarnings(document, slideIndex = 0) {
-  const slide = document.slides?.[slideIndex];
-  const design = { ...document.design, ...slide?.design };
+export function designWarnings(presentation, slideIndex = 0) {
+  const slide = presentation.slides?.[slideIndex];
+  const design = { ...presentation.design, ...slide?.design };
   const warnings = [];
-  const hasLogo = hasResolvableLogo(document, slideIndex);
+  const hasLogo = hasResolvableLogo(presentation, slideIndex);
   for (const which of ["header", "footer"])
     for (const zone of HEADER_FOOTER_ZONES)
       if (!hasLogo && isObject(design[which]) && design[which][zone]?.logo === true)
         warnings.push({ code: "unresolved-logo", path: `design.${which}.${zone}.logo`, message: `The ${which} ${zone} zone shows the logo, but no logo is set. Add a logo or an organization logo.` });
-  const organization = primaryOrganization(document);
+  const organization = primaryOrganization(presentation);
   for (const which of ["header", "footer"])
     for (const zone of HEADER_FOOTER_ZONES) {
       const item = isObject(design[which]) ? design[which][zone] : undefined;
       if (item?.organization === true && !organization)
         warnings.push({ code: "unresolved-content", path: `design.${which}.${zone}.organization`, message: `The ${which} ${zone} zone shows the organization, but the presentation has none.` });
+      if (item?.speaker === true && !firstSpeaker(presentation)?.name)
+        warnings.push({ code: "unresolved-content", path: `design.${which}.${zone}.speaker`, message: `The ${which} ${zone} zone shows the speaker, but the presentation has no named speaker.` });
       if (item?.socials === true && !organization?.socials)
         warnings.push({ code: "unresolved-content", path: `design.${which}.${zone}.socials`, message: `The ${which} ${zone} zone shows social profiles, but the organization has none.` });
     }
@@ -123,17 +131,17 @@ export function designWarnings(document, slideIndex = 0) {
   return warnings;
 }
 
-function shadowed(document, keys) {
-  return (document.slides ?? []).flatMap((slide, index) => (keys.some((key) => slide?.design?.[key] !== undefined) ? [index] : []));
+function shadowed(presentation, keys) {
+  return (presentation.slides ?? []).flatMap((slide, index) => (keys.some((key) => slide?.design?.[key] !== undefined) ? [index] : []));
 }
 
-function finish(document, patches, extra) {
-  const before = validateOpfDocument(document);
-  const next = checkedDocument(document, patches, before);
+function finish(presentation, patches, extra) {
+  const before = checkFormat(presentation);
+  const next = checkedDocument(presentation, patches, before);
   const slideIndex = extra.slideIndex;
   return {
     ...extra,
-    document: structuredClone(next),
+    presentation: structuredClone(next),
     patches,
     changed: patches.length > 0,
     warnings: designWarnings(next, slideIndex ?? 0),
@@ -145,16 +153,20 @@ function finish(document, patches, extra) {
 function mergedWatermark(existing, value) {
   if (value === null || value === false) return value;
   if (typeof value === "string") return value;
-  if (!isObject(value)) throw fail("invalid-design-value", "A watermark is false, an image source or { src, opacity }.", { value });
+  if (!isObject(value)) throw fail("invalid-design-value", "A watermark is false, an image source, { src, opacity } or { text, opacity }.", { value });
   const base = typeof existing === "string" ? { src: existing } : isObject(existing) ? { ...existing } : {};
   const merged = { ...base };
   for (const [key, entry] of Object.entries(value)) {
     if (entry === null || entry === undefined) delete merged[key];
     else merged[key] = entry;
   }
+  // FA-13: a watermark is an image (src) or a text stamp (text), never both: the field set last replaces the other.
+  if (value.text !== undefined && value.text !== null && value.src === undefined) delete merged.src;
+  else if (value.src !== undefined && value.src !== null && value.text === undefined) delete merged.text;
+  if (merged.text !== undefined && (typeof merged.text !== "string" || !merged.text.trim())) throw fail("invalid-design-value", "Watermark text is a non-empty string.", { value });
   if (merged.opacity !== undefined && (typeof merged.opacity !== "number" || merged.opacity < 0 || merged.opacity > 1))
     throw fail("invalid-design-value", "Watermark opacity is a number from 0 to 1.", { value });
-  if (merged.src === undefined && Object.keys(merged).length) throw fail("invalid-design-value", "Choose the watermark image before setting its opacity.", { value });
+  if (merged.src === undefined && merged.text === undefined && Object.keys(merged).length) throw fail("invalid-design-value", "Choose the watermark image before setting its opacity (or give it text instead).", { value });
   if (Object.keys(merged).length === 1 && typeof merged.src === "string") return merged.src;
   if (!Object.keys(merged).length) return null;
   if (merged.opacity === undefined) throw fail("invalid-design-value", "Set an opacity from 0 to 1 for the watermark.", { value });
@@ -177,17 +189,17 @@ function mergedSlideImage(existing, value) {
   return merged;
 }
 
-function fontSchemeWithAccent(document, base, family) {
+function fontSchemeWithAccent(presentation, base, family) {
   // The slide's own font scheme, else the deck's: an object form is kept with its overrides.
-  const own = ownDesign(document, base).fontScheme;
-  const inherited = base.length ? document.design?.fontScheme : undefined;
+  const own = ownDesign(presentation, base).fontScheme;
+  const inherited = base.length ? presentation.design?.fontScheme : undefined;
   const source = own !== undefined ? own : inherited;
   const object = typeof source === "string" ? { id: source } : isObject(source) ? structuredClone(source) : {};
   if (family === null) {
     delete object.accent;
   } else {
     if (typeof family !== "string" || !family.trim()) throw fail("invalid-design-value", "Accent font is a non-empty family name, or null to clear it.", { value: family });
-    object.accent = { ...(isObject(object.accent) ? object.accent : {}), family: family.trim() };
+    object.accent = family.trim();
   }
   const keys = Object.keys(object);
   if (!keys.length) return null;
@@ -217,17 +229,17 @@ function collapseLogo(set) {
  * remove slide-level values that hide it) and `index` (organizationLogo with several
  * organizations).
  */
-export function prepareDesignOption(document, option, value, options = {}) {
+export function prepareDesignOption(presentation, option, value, options = {}) {
   const descriptor = BY_ID[option];
   if (!descriptor) throw fail("unknown-design-option", `Unknown design option: ${option}. Use one of ${DESIGN_OPTIONS.map((entry) => entry.id).join(", ")}.`, { option });
-  if (!isObject(document)) throw fail("invalid-input", "Design options need an OPF document object.");
+  if (!isObject(presentation)) throw fail("invalid-input", "Design options need an OPF document object.");
   if (value === undefined) throw fail("invalid-design-value", "Pass a value, or null to remove the option.", { option });
-  const { scope, base, slideIndex } = scopeOf(document, option, options);
+  const { scope, base, slideIndex } = scopeOf(presentation, option, options);
   let patches = [];
   let keys = [];
 
   if (descriptor.type === "organization-logo") {
-    const organization = document.organization;
+    const organization = presentation.organization;
     const index = options.index ?? 0;
     const owner = Array.isArray(organization) ? organization[index] : organization;
     if (!isObject(owner)) throw fail("missing-owner", "Add an organization to the document before setting its logo.", { option });
@@ -245,38 +257,38 @@ export function prepareDesignOption(document, option, value, options = {}) {
       if (value !== null && typeof value !== "boolean") throw fail("invalid-design-value", `${descriptor.label} is true or false.`, { option, value });
       entries = { [option]: value };
     } else if (descriptor.type === "font") {
-      entries = { fontScheme: fontSchemeWithAccent(document, base, value) };
+      entries = { fontScheme: fontSchemeWithAccent(presentation, base, value) };
     } else if (descriptor.type === "logo") {
       if (value !== null && typeof value !== "string" && !isObject(value)) throw fail("invalid-design-value", "A logo is an image source, an asset object or a set of logo variants.", { option });
       entries = { logo: value };
     } else if (descriptor.type === "watermark") {
-      const existing = ownDesign(document, base).watermark;
+      const existing = ownDesign(presentation, base).watermark;
       entries = { watermark: mergedWatermark(existing, value) };
     } else {
-      const existing = ownDesign(document, base).slideImage;
+      const existing = ownDesign(presentation, base).slideImage;
       entries = { slideImage: mergedSlideImage(existing, value) };
     }
     keys = Object.keys(entries);
-    patches = designPatches(document, base, entries);
+    patches = designPatches(presentation, base, entries);
   }
 
   let shadowedSlides = [];
   if (scope === "deck" && keys.length) {
-    shadowedSlides = shadowed(document, keys);
+    shadowedSlides = shadowed(presentation, keys);
     if (options.clearSlideOverrides) {
       for (const index of shadowedSlides)
         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]) });
       shadowedSlides = [];
     }
   }
-  return finish(document, patches, { option, scope, ...(slideIndex !== undefined ? { slideIndex } : {}), shadowed: shadowedSlides });
+  return finish(presentation, patches, { option, scope, ...(slideIndex !== undefined ? { slideIndex } : {}), shadowed: shadowedSlides });
 }
 
 function apply(editor, prepared, meta = {}) {
-  const { document, patches, ...summary } = prepared;
-  void document;
-  if (!prepared.changed) return { ...summary, document: editor.document, patches: [], inversePatches: [], validation: editor.validation };
+  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 ?? "design-option", option: prepared.option, scope: prepared.scope });
   return { ...change, ...summary };
 }
@@ -289,30 +301,30 @@ function checkEditor(editor) {
 export function setDesignOption(editor, option, value, options = {}) {
   checkEditor(editor);
   const { meta, ...rest } = options;
-  return apply(editor, prepareDesignOption(editor.document, option, value, rest), meta);
+  return apply(editor, prepareDesignOption(editor.presentation, option, value, rest), meta);
 }
 
 /**
  * Read one design option for a panel: `{ value, scope, inherited }` where `scope` is "slide" when the
  * slide's own design sets it, "deck" when the deck does, and "default" when neither does.
- * `accentFont` reads the family; `organizationLogo` reads the organization.
+ * `accentFont` reads the family name; `organizationLogo` reads the organization.
  */
-export function getDesignOption(document, option, options = {}) {
+export function getDesignOption(presentation, option, options = {}) {
   const descriptor = BY_ID[option];
   if (!descriptor) throw fail("unknown-design-option", `Unknown design option: ${option}.`, { option });
   if (descriptor.type === "organization-logo") {
-    const organization = document.organization;
+    const organization = presentation.organization;
     const owner = Array.isArray(organization) ? organization[options.index ?? 0] : organization;
     return { value: owner?.logo, scope: owner?.logo === undefined ? "default" : "deck", inherited: false };
   }
   const key = descriptor.type === "font" ? "fontScheme" : option;
   const pick = (design) => {
     const value = design?.[key];
-    return descriptor.type === "font" ? (isObject(value) ? value.accent?.family : undefined) : value;
+    return descriptor.type === "font" ? (isObject(value) ? value.accent : undefined) : value;
   };
-  const slideValue = options.slideIndex === undefined ? undefined : pick(document.slides?.[options.slideIndex]?.design);
+  const slideValue = options.slideIndex === undefined ? undefined : pick(presentation.slides?.[options.slideIndex]?.design);
   if (slideValue !== undefined) return { value: slideValue, scope: "slide", inherited: false };
-  const deckValue = pick(document.design);
+  const deckValue = pick(presentation.design);
   if (deckValue !== undefined) return { value: deckValue, scope: "deck", inherited: options.slideIndex !== undefined };
   return { value: undefined, scope: "default", inherited: false };
 }
@@ -324,26 +336,26 @@ export function getDesignOption(document, option, options = {}) {
  * variant of `design.logo`. A single default logo stays a bare source; adding a second variant turns
  * it into a LogoSet, and clearing back to the default collapses it again.
  */
-export function prepareLogoVariant(document, variant, source, options = {}) {
+export function prepareLogoVariant(presentation, variant, source, options = {}) {
   if (!LOGO_VARIANTS.includes(variant)) throw fail("invalid-design-value", `Logo variant is one of ${LOGO_VARIANTS.join(", ")}.`, { variant });
   if (source !== null && typeof source !== "string" && !isObject(source)) throw fail("invalid-design-value", "A logo variant is an image source, an asset object, or null to clear it.", { variant });
   if (typeof source === "string" && !source.trim()) throw fail("invalid-design-value", "Enter an image source or asset reference, or clear the variant.", { variant });
-  const { scope, base, slideIndex } = scopeOf(document, "logo", options);
-  const set = logoSetOf(ownDesign(document, base).logo);
+  const { scope, base, slideIndex } = scopeOf(presentation, "logo", options);
+  const set = logoSetOf(ownDesign(presentation, base).logo);
   if (source === null) delete set[variant];
   else set[variant] = typeof source === "string" ? source.trim() : source;
-  const patches = designPatches(document, base, { logo: collapseLogo(set) });
-  return finish(document, patches, { option: "logo", variant, scope, ...(slideIndex !== undefined ? { slideIndex } : {}), shadowed: [] });
+  const patches = designPatches(presentation, base, { logo: collapseLogo(set) });
+  return finish(presentation, patches, { option: "logo", variant, scope, ...(slideIndex !== undefined ? { slideIndex } : {}), shadowed: [] });
 }
 /** Set or clear one logo variant as a single undoable transaction. */
 export function setLogoVariant(editor, variant, source, options = {}) {
   checkEditor(editor);
   const { meta, ...rest } = options;
-  return apply(editor, prepareLogoVariant(editor.document, variant, source, rest), meta);
+  return apply(editor, prepareLogoVariant(editor.presentation, variant, source, rest), meta);
 }
 /** The variants `design.logo` sets at a scope: `{ variant: source }`, a bare logo reported as `default`. */
-export function readLogoVariants(document, options = {}) {
-  const own = options.slideIndex === undefined ? document.design?.logo : document.slides?.[options.slideIndex]?.design?.logo;
+export function readLogoVariants(presentation, options = {}) {
+  const own = options.slideIndex === undefined ? presentation.design?.logo : presentation.slides?.[options.slideIndex]?.design?.logo;
   return logoSetOf(own);
 }
 
@@ -351,7 +363,7 @@ export function readLogoVariants(document, options = {}) {
 
 /**
  * Compute the patch that edits one header or footer zone. `fields` merges into the zone (logo, text,
- * image, slideNumber, slideNumberFormat, date, dateFormat, organization, socials, section); `null`,
+ * image, slideNumber, slideNumberFormat, date, dateFormat, organization, speaker, socials, section); `null`,
  * `false` for a flag, or an empty string removes a field. A zone left empty is removed, then an empty
  * header or footer, so a slide never carries `{}`. A slide's own header or footer replaces the deck's
  * whole one, so the first edit on a slide that has none of its own starts from a copy of the deck's
@@ -359,15 +371,15 @@ export function readLogoVariants(document, options = {}) {
  * inheriting it again. Setting a field on a suppressed (`false`) header replaces the suppression.
  * `logo: true` reports a warning when no logo resolves.
  */
-export function prepareHeaderFooterZone(document, which, zone, fields, options = {}) {
+export function prepareHeaderFooterZone(presentation, which, zone, fields, options = {}) {
   if (!["header", "footer"].includes(which)) throw fail("invalid-design-value", "Choose header or footer.", { which });
   if (!HEADER_FOOTER_ZONES.includes(zone)) throw fail("invalid-design-value", `Zone is one of ${HEADER_FOOTER_ZONES.join(", ")}.`, { zone });
   if (!isObject(fields)) throw fail("invalid-design-value", "Pass the zone fields to change.", { fields });
   const unknown = Object.keys(fields).filter((key) => !ZONE_FIELDS.includes(key));
   if (unknown.length) throw fail("invalid-design-value", `Unknown header/footer field: ${unknown[0]}.`, { fields });
-  const { scope, base, slideIndex } = scopeOf(document, "logo", options);
-  const own = ownDesign(document, base)[which];
-  const inherited = base.length ? document.design?.[which] : undefined;
+  const { scope, base, slideIndex } = scopeOf(presentation, "logo", options);
+  const own = ownDesign(presentation, base)[which];
+  const inherited = base.length ? presentation.design?.[which] : undefined;
   const current = own !== undefined ? own : inherited;
   const container = isObject(current) ? structuredClone(current) : {};
   const item = isObject(container[zone]) ? container[zone] : {};
@@ -386,27 +398,27 @@ export function prepareHeaderFooterZone(document, which, zone, fields, options =
   let next = Object.keys(container).length ? container : null;
   // Emptied: a deck value that would show through again is hidden explicitly; a suppressed header stays suppressed.
   if (next === null && (own === false || isObject(inherited))) next = false;
-  const patches = designPatches(document, base, { [which]: next });
-  return finish(document, patches, { option: which, zone, scope, ...(slideIndex !== undefined ? { slideIndex } : {}), shadowed: [] });
+  const patches = designPatches(presentation, base, { [which]: next });
+  return finish(presentation, patches, { option: which, zone, scope, ...(slideIndex !== undefined ? { slideIndex } : {}), shadowed: [] });
 }
 /** Edit one header or footer zone as a single undoable transaction. */
 export function setHeaderFooterZone(editor, which, zone, fields, options = {}) {
   checkEditor(editor);
   const { meta, ...rest } = options;
-  return apply(editor, prepareHeaderFooterZone(editor.document, which, zone, fields, rest), meta);
+  return apply(editor, prepareHeaderFooterZone(editor.presentation, which, zone, fields, rest), meta);
 }
 /**
  * One header or footer zone's fields as they apply at a scope: the slide's own header (or footer) when it
  * has one, else the deck's (`{}` when absent or suppressed). `headerFooterState` says which.
  */
-export function readHeaderFooterZone(document, which, zone, options = {}) {
-  const own = options.slideIndex === undefined ? undefined : document.slides?.[options.slideIndex]?.design?.[which];
-  const effective = own !== undefined ? own : document.design?.[which];
+export function readHeaderFooterZone(presentation, which, zone, options = {}) {
+  const own = options.slideIndex === undefined ? undefined : presentation.slides?.[options.slideIndex]?.design?.[which];
+  const effective = own !== undefined ? own : presentation.design?.[which];
   return isObject(effective) && isObject(effective[zone]) ? structuredClone(effective[zone]) : {};
 }
 /** `{ own, inherited, hidden }` for a header or footer at a scope: whether the scope sets it itself, shows the deck's, or hides it with `false`. */
-export function headerFooterState(document, which, options = {}) {
-  const own = options.slideIndex === undefined ? document.design?.[which] : document.slides?.[options.slideIndex]?.design?.[which];
-  const inherited = options.slideIndex !== undefined && own === undefined && document.design?.[which] !== undefined;
-  return { own: own !== undefined, inherited, hidden: (own !== undefined ? own : options.slideIndex !== undefined ? document.design?.[which] : undefined) === false };
+export function headerFooterState(presentation, which, options = {}) {
+  const own = options.slideIndex === undefined ? presentation.design?.[which] : presentation.slides?.[options.slideIndex]?.design?.[which];
+  const inherited = options.slideIndex !== undefined && own === undefined && presentation.design?.[which] !== undefined;
+  return { own: own !== undefined, inherited, hidden: (own !== undefined ? own : options.slideIndex !== undefined ? presentation.design?.[which] : undefined) === false };
 }

package/dist/edit-helpers.js

@@ -1,6 +1,7 @@
 // Helpers shared by the dimension switches, the design options, the block conversions and the
 // table options: the error constructor, structural equality and the design-key patch rules.
-import { OPFEditorError, applyJsonPatch, getValueAtPath, opfPathToJsonPointer, validateOpfDocument } from "./index.js";
+import { OPFEditorError, applyJsonPatch, getValueAtPath, opfPathToJsonPointer } from "./index.js";
+import { firstErrorMessage, errorFindings, checkFormat } from "./checks.js";
 
 export function fail(code, message, details) {
   return new OPFEditorError(code, message, details);
@@ -19,8 +20,8 @@ export function same(a, b) {
 }
 
 // Set (value) or remove (null) design keys at deck or slide scope.
-export function designPatches(document, base, entries) {
-  const design = getValueAtPath(document, base.length ? [...base, "design"] : ["design"]);
+export function designPatches(presentation, base, entries) {
+  const design = getValueAtPath(presentation, base.length ? [...base, "design"] : ["design"]);
   const at = (key) => opfPathToJsonPointer([...base, "design", key]);
   const set = Object.entries(entries).filter(([, value]) => value !== undefined && value !== null);
   if (!design || typeof design !== "object" || Array.isArray(design))
@@ -41,12 +42,12 @@ export function designPatches(document, base, entries) {
  * Validate a candidate patch the way every switch does: the result must be valid OPF unless the
  * input document was already invalid (then nothing new may be reported as the cause).
  */
-export function checkedDocument(document, patches, before) {
-  const next = patches.length ? applyJsonPatch(document, patches) : document;
+export function checkedDocument(presentation, patches, before) {
+  const next = patches.length ? applyJsonPatch(presentation, patches) : presentation;
   if (patches.length) {
-    const validation = validateOpfDocument(next);
+    const validation = checkFormat(next);
     if (!validation.valid && before.valid)
-      throw fail("invalid-opf-edit", validation.errors[0]?.message ?? "This change produces an invalid document.", { issues: validation.errors, patches });
+      throw fail("invalid-opf-edit", firstErrorMessage(validation, "This change produces an invalid document."), { issues: errorFindings(validation), patches });
   }
   return next;
 }

package/dist/exact-source.js

@@ -228,11 +228,11 @@ function typingSignature(previous, ops) {
 /**
  * Change only the affected values. Keeps authored indentation, escaping and all unrelated
  * metadata/content byte-for-byte, including across canvas Escape, Undo and Redo.
- * Throws when `source` is not valid JSON. The result always parses to `document`; if an
+ * Throws when `source` is not valid JSON. The result always parses to `presentation`; if an
  * in-place edit cannot achieve that (for example the source repeats an object key), the whole
  * document is written as indented JSON instead.
  */
-export function updateJsonSource(source, document, memory = sharedMemory) {
+export function updateJsonSource(source, presentation, memory = sharedMemory) {
   const previous = JSON.parse(source);
   const previousKey = JSON.stringify(previous);
   memory.limited = source.length > MAX_EXACT_SOURCE_LENGTH;
@@ -243,9 +243,9 @@ export function updateJsonSource(source, document, memory = sharedMemory) {
     memory.last = null;
   }
   const ops = [];
-  diff(previous, document, [], ops);
+  diff(previous, presentation, [], ops);
   if (!ops.length) return source;
-  const key = JSON.stringify(document);
+  const key = JSON.stringify(presentation);
   const remembered = recall(memory, key);
   if (remembered !== undefined && equalOutside(source, remembered, maskPaths(ops))) {
     memory.last = null;
@@ -306,7 +306,7 @@ export function updateJsonSource(source, document, memory = sharedMemory) {
     valid = JSON.stringify(parsed) === key || canonical(parsed) === canonical(JSON.parse(key));
   } catch { /* Fall back below. */ }
   if (!valid) {
-    result = JSON.stringify(document, null, indent).replaceAll("\n", eol);
+    result = JSON.stringify(presentation, null, indent).replaceAll("\n", eol);
     if (/\n$/.test(source)) result += eol;
   }
 

package/dist/export.d.ts

@@ -1,5 +1,5 @@
 import type { RenderSvgOptions } from "@openpresentation/opf-render";
-import type { FontGate } from "./canvas.js";
+import type { EditorFonts } from "./canvas.js";
 
 export type ExportFormat = "pdf" | "png" | "svg";
 export declare const EXPORT_FORMATS: Readonly<Record<ExportFormat, { extension: string; type: string; label: string }>>;
@@ -44,12 +44,10 @@ export interface ExportOptions {
   pdfMode?: "vector" | "raster";
   /** PNG pixel density (and the raster PDF's), 1 to 4; default 2. */
   scale?: number;
-  /** The options the host draws its preview with (`textMeasurement`, `catalogs`, ...). */
+  /** The options the host draws its preview with (`catalogs`, `date`, ...); the fonts go in `fonts`. */
   renderOptions?: RenderSvgOptions;
-  /** A font gate: the faces the deck needs load before anything is drawn. */
-  fonts?: Pick<FontGate, "pending" | "ensure">;
-  /** The browser font registry; its faces are what gets embedded. */
-  registry?: object;
+  /** The renderer's fonts handle (`loadFonts()`): it measures the text, loads the faces the deck needs before anything is drawn, and its registry's faces are what gets embedded. */
+  fonts?: EditorFonts;
   /** Faces to embed instead of the registry's. */
   embeddedFonts?: Array<Record<string, unknown>>;
   /** PDF document properties beyond the title and subject taken from the deck. */
@@ -71,7 +69,7 @@ export interface ExportResult {
   slides: number[];
 }
 /**
- * Draw the deck with the renderer the preview uses and convert it. Rejects with an error whose `code` is `export-aborted`, `export-no-slides`,
+ * Draw the deck with the renderer the preview uses and convert it. Rejects with an error whose `code` is `export-aborted`, `export-fonts-unlicensed` (the license rule left the PDF converter no face for some text), `export-no-slides`,
  * `export-format`, `export-unavailable` (PDF and PNG need the renderer's `export-browser` entry), `fonts-unavailable` or a renderer code.
  */
 export declare function exportDeck(deck: unknown, options: ExportOptions): Promise<ExportResult>;

package/dist/export.js

@@ -1,13 +1,14 @@
 // RR-23: download a deck as PDF, PNG or SVG from the editor, next to the PowerPoint export. Everything runs in the page:
-// the slides are drawn by the same renderer the preview uses (`renderSvgDeck`, with the editor's own text measurement), so
-// a download is the preview, not a second layout. Fonts are the registry's: the faces the document needs load through the
-// font gate first, and only faces the registry holds (bundled or hash-pinned, permissively licensed) are embedded, as
+// the slides are drawn by the same renderer the preview uses (`renderSvg`, with the fonts handle's text measurement), so
+// a download is the preview, not a second layout. Fonts are the renderer's fonts handle's: the faces the document needs load through
+// the handle first, and only faces its registry holds (bundled or hash-pinned, permissively licensed) are embedded, as
 // @font-face data in each SVG and as subsets in the PDF. No system font is read and nothing is fetched at export time.
 //
-//   const result = await exportDeck(editor.document, { format: "pdf", renderOptions, fonts: gate, registry, signal, onProgress });
+//   const result = await exportDeck(editor.presentation, { format: "pdf", fonts, renderOptions, signal, onProgress });
 //   // result.download is { name, type, bytes }: one PDF, one PNG or SVG, or a ZIP of the slides.
 
-import { renderSvgDeck } from "@openpresentation/opf-render/svg";
+import { renderSvg } from "@openpresentation/opf-render/svg";
+import { fontGate } from "./font-gate.js";
 import { createZip } from "./zip.js";
 
 export const EXPORT_FORMATS = Object.freeze({
@@ -69,6 +70,19 @@ function exportError(code, message, cause) {
   return error;
 }
 
+// The faces a PDF may embed: the same permissive-license list as the SVG (`embeddableFonts`), as the bytes the converter reads. The fonts
+// handle itself is never given to `svgToPdf`: it would embed every face the registry holds, whatever its license.
+function pdfFontData(faces) {
+  return faces.map((face) => {
+    const text = String(face.dataUrl ?? "");
+    const base64 = text.slice(text.indexOf(",") + 1);
+    const binary = atob(base64);
+    const data = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) data[index] = binary.charCodeAt(index);
+    return { family: face.family, data };
+  });
+}
+
 const fontLabel = (face) => `${face.family} ${face.weight}${face.italic ? " italic" : ""}`;
 
 function slideOf(path) {
@@ -110,12 +124,17 @@ async function loadConverters(options) {
  * - `slides`: "current" (with `slideIndex`), "all" (default; hidden slides only with `includeHidden`) or an array of slide numbers.
  * - `pdfMode`: "vector" (default: selectable text, vector shapes) or "raster" (each slide an image).
  * - `scale`: PNG pixel density, 1 to 4 (default 2); also the raster PDF's density.
- * - `renderOptions`: the render options the host draws with (`textMeasurement`, `catalogs`, ...), the same as its preview.
- * - `fonts`: a font gate (`createFontGate`); the faces the deck needs load before anything is drawn.
- * - `registry`: the browser font registry; its faces are what gets embedded.
+ * - `renderOptions`: the render options the host draws with (`catalogs`, `date`, ...), the same as its preview.
+ * - `fonts`: the renderer's fonts handle (`loadFonts()` from `@openpresentation/opf-render/fonts-browser`), the one the preview uses. Its
+ *   `textMeasurement` lays the slides out, the faces the deck needs load through its `ensure` before anything is drawn, and its registry's
+ *   faces are what gets embedded: the SVG carries the faces its slides draw, and the PDF embeds the registry's faces (script faces included).
+ *   Both apply the same license rule (OFL-1.1, Apache-2.0, MIT or UFL-1.0): a face whose license text names none of them is left out of the SVG
+ *   and the PDF and reported once as `export-font-license`. Text that needed it is drawn with another face the registry holds and
+ *   reported by the converter (`pdf-font-substituted`, `pdf-glyph-missing`); when no face is left at all the PDF rejects with
+ *   `export-fonts-unlicensed` (the converter's error is its `cause`).
  * - `signal`, `onProgress({ stage, done, total, message })`, `onDiagnostic(diagnostic)`.
  * Resolves `{ download, files, diagnostics, slides }`. Rejects with an error whose `code` is `export-aborted`,
- * `export-no-slides`, `export-unavailable`, `fonts-unavailable` or a renderer code.
+ * `export-fonts-unlicensed`, `export-no-slides`, `export-unavailable`, `fonts-unavailable` or a renderer code.
  */
 export async function exportDeck(deck, options = {}) {
   const format = EXPORT_FORMATS[options.format];
@@ -133,20 +152,22 @@ export async function exportDeck(deck, options = {}) {
   const renderOptions = options.renderOptions ?? {};
 
   check();
-  if (options.fonts?.pending?.(deck, renderOptions)?.length) {
+  const gate = fontGate(options.fonts);
+  if (gate?.pending(deck, renderOptions).length) {
     progress("fonts", 0, 1, "Loading fonts…");
-    try { await options.fonts.ensure(deck, { signal, renderOptions }); }
+    try { await gate.ensure(deck, { signal, renderOptions }); }
     catch (error) { if (signal?.aborted) throw exportError("export-aborted", "The export was cancelled."); throw error; }
   }
   check();
   const converters = format.extension === "svg" ? null : await loadConverters(options);
 
-  const embeddedFonts = options.embeddedFonts ?? embeddableFonts(options.registry, (face) => note({ code: "export-font-license", severity: "warning", message: `${fontLabel(face)} is not embedded: its license is not one of OFL-1.1, Apache-2.0, MIT or UFL-1.0.`, family: face.family }));
+  const dropped = [];
+  const embeddedFonts = options.embeddedFonts ?? embeddableFonts(options.fonts?.registry, (face) => { dropped.push(face); note({ code: "export-font-license", severity: "warning", message: `${fontLabel(face)} is not embedded: its license is not one of OFL-1.1, Apache-2.0, MIT or UFL-1.0.`, family: face.family }); });
   progress("render", 0, indexes.length, "Drawing slides…");
   await yieldToHost();
-  const rendered = renderSvgDeck(deck, {
+  const rendered = renderSvg(deck, {
     ...renderOptions,
-    embeddedFonts,
+    fonts: { textMeasurement: options.fonts?.textMeasurement, embeddedFonts },
     // The PDF reports problems by element path; the SVG and PNG are the plain drawing.
     trace: format.extension === "pdf",
     onDiagnostic: (diagnostic) => {
@@ -186,12 +207,17 @@ export async function exportDeck(deck, options = {}) {
         scale,
         metadata,
         signal,
+        fontData: pdfFontData(embeddedFonts),
         ...(options.fallbackFamily ? { defaultFontFamily: options.fallbackFamily } : {}),
         onDiagnostic: (diagnostic) => { const described = describeDiagnostic(diagnostic, "pdf"); if (keep(described)) note(described); },
         onProgress: ({ page, pages }) => progress("convert", page, pages, `Page ${page} of ${pages}`),
       });
     } catch (error) {
       if (signal?.aborted) throw exportError("export-aborted", "The export was cancelled.");
+      // The license rule can leave the converter with no face for some text (every face of a family was dropped): say why, not only what.
+      if (dropped.length && /font face/i.test(String(error?.message))) {
+        throw exportError("export-fonts-unlicensed", `The PDF could not be written: ${dropped.map(fontLabel).join(", ")} ${dropped.length === 1 ? "is" : "are"} not embedded because the license is not one of OFL-1.1, Apache-2.0, MIT or UFL-1.0, and no other face is available. ${error.message}`, error);
+      }
       throw error;
     }
     files = [{ name: exportFileName(deck, "pdf"), type: format.type, bytes }];