@openpresentation/opf-editor 0.15.0 → 0.16.0

package/README.md

@@ -2,6 +2,25 @@
 
 Unfinished prepared shaping work is preserved in the [September 15 roadmap](docs/roadmap-shaping-20260915.md); it is not part of the published runtime.
 
+## Using the editor with opf-render 0.16: what to install (RR-63, unreleased)
+
+`@openpresentation/opf-render` is an optional peer of the editor, and from render 0.16 its heavy pieces are optional peers too, so install only what you use. The editor itself draws with `@openpresentation/opf-render/svg` and loads fonts with `/fonts-browser`, which need nothing else. Add:
+
+| You use | Also install |
+| --- | --- |
+| The canvas, the preview, SVG downloads in a browser (the host serves its own font files) | nothing |
+| `loadFonts` from `/fonts-node` (a server, a test, a build script such as `npm run build:playground`) | the font packages of the pack: `@expo-google-fonts/roboto` and `roboto-mono` for `base`; also `arimo`, `caladea`, `cousine`, `gelasio`, `tinos` and `noto-sans` for `office`; a script face (`scripts: 'auto'`) needs its `@expo-google-fonts/noto-*` package. A missing one fails with `font-resource-unavailable` and names it |
+| `svgToPng` / `svgToPdf` from the Node entries (`/png`, `/pdf`) | `@resvg/resvg-js` (and `sharp`, `pdf-lib` as the renderer's README says); a missing one fails with `converter-missing` |
+| `exportDeck` PDF (vector), PNG, SVG | nothing: the browser entry `@openpresentation/opf-render/export-browser` imports no converter |
+| `exportDeck` raster PDF (`pdfMode: "raster"`) | `pdf-lib`, imported by the page and passed as the `pdfLib` option (`import * as pdfLib from "pdf-lib"`); without it the export rejects with `converter-missing` |
+
+```js
+const pdfLib = await import("pdf-lib");
+await exportDeck(editor.presentation, { format: "pdf", pdfMode: "raster", pdfLib, fonts });
+```
+
+The playground imports `pdf-lib` for you when its raster PDF choice is used.
+
 ## OPF 0.15: catalogs from the host, backgrounds and image blocks (FA-23)
 
 The release after 0.14.2 moves the editor onto core 0.15 (a breaking, clean spec: no migration). See `changes/fa-23-opf-0-15.md`.
@@ -24,7 +43,7 @@ The release after 0.14.2 moves the editor onto core 0.15 (a breaking, clean spec
 - **Editing a catalog's record forks it.** An edit of a layout, theme, colour scheme or font scheme embedded under `catalogs.default` or a named group (from a panel, Properties, Source or any `applyPatch`) moves it into `catalogs.custom` as `<id>-custom` (or the id in `meta.forkIds["<group>:<kind>:<id>"]`), rewrites every reference to it and drops the original, in the same undo step. The change and the session event carry `forked` and a `notice` ("… is now this presentation's own; it no longer receives catalog updates"); approved catalog updates and `moveToCustom` change records in place (`meta.catalogRecordEdit: "in-place"`). `moveToCustom(editor, { group, kind, id }, { id })` is the explicit form, offered for `opf/catalog-record-not-in-source`.
 - **Backgrounds** take the flat image form `{ type: "image", src, alt, fit, focus, opacity, recolor, overlay }` (fits `cover`, `contain`, `stretch`, `tile`) and the image-source shorthand, on the deck and on a slide. **Image blocks** carry their own fit, focus, treatments and placement (`/image-options`, the panel's `image` section): a full-bleed photo is a background, a picture beside the content is a placed image block. `design.imageFit` is the default fit of image blocks.
 
-The release after 0.12.1 (RR-55) moves the editor onto core 0.14, renderer 0.14 and PPTX 0.14, which ship together: core's one `validate` and `Finding` format, `resolveSlideContext`, and the renderer's `loadFonts()` handle as the `fonts` option of the canvas, the export and `composeSlide`/`paginateSlide`. See `changes/rr-55-short-verb-api.md` for what was renamed or removed (the font gate, `validateOpfDocument`, `resolveSlideFonts`, `runAudit`, the `*Available` checks). Version 0.11.2 adds the slide-size and purpose switches (additive; same requirements as 0.11.0). Version 0.11.0 requires `@openpresentation/opf` ^0.12.0 (composed font sizes on PowerPoint's 0.01 pt grid, hanging wrap whitespace, promoted regions in reading order, right-to-left decks composed mirrored; install it with renderer 0.12.0 and PPTX 0.12.0 so the canvas, preview and export resolve the same core) and ships the new entry points listed in the changelog. Version 0.10.6 changes no editor source: it requires `@openpresentation/opf` ^0.11.4 (the design fields compose, cover tag and subtitle follow the title alignment, picture bullets and furniture images change geometry; install it with renderer 0.11.9 and PPTX 0.11.7 so the canvas, preview and export resolve the same core). Version 0.10.5 changes no editor source: its playground example loads its base faces through the renderer's `extraLazyFonts` (renderer 0.11.7 or later; the editor package itself runs with the optional peer ^0.11.0 as before). Version 0.10.4 changes no editor behavior: it requires `@openpresentation/opf` ^0.11.3 (the 70 legacy gallery layout ids and their geometry; install it with renderer 0.11.6 and PPTX 0.11.4 so the canvas, preview and export resolve the same core). Version 0.10.3 passes the host's render options (`catalogs`) through the font gate to the registry, so layouts and font schemes that only the host's catalogs know load their faces, and asks the script and vendored-face loaders separately; it keeps the 0.10.2 requirements and gates nothing new on renderers before 0.11.5. Version 0.10.2 adds pointer caret entry on the canvas (one click puts the caret where you click; new `textEntry` option; keyboard entry still selects all) and keeps the 0.10.1 and 0.10.0 requirements. Version 0.10.1 adds the opt-in font gate (`createFontGate`, FF-41) and keeps the 0.10.0 requirements; develop and test it against renderer 0.11.2 and PPTX 0.11.1. Version 0.10.0 requires `@openpresentation/opf` ^0.11.2, renderer ^0.11.0, and PPTX ^0.11.0 (install them together so cover centering resolves the same core everywhere; renderer 0.11.0 also activates the playground's automatic script fonts and lazy Intos fonts). Version 0.9.0 required `@openpresentation/opf` ^0.11.1, renderer ^0.10.0, and PPTX ^0.10.0. Composition and slide transfer fall back to the shared `aptos` font scheme and report unknown scheme ids through `onDiagnostic`; gallery apply keeps every font-scheme role.
+Editor 0.15.0 uses core `^0.15.1` and the optional renderer peer `^0.15.0`. Install renderer and PPTX 0.15 together for the coordinated canvas and export workflow. The shared APIs are core's `validate`, `Finding`, `resolveSlideContext` and the catalog helpers above, and the renderer's `loadFonts()` handle passed as `fonts` to the canvas, export, composition and pagination. Historical version changes are recorded in `CHANGELOG.md`.
 
 Version 0.8.0 required `@openpresentation/opf` ^0.11.0, renderer ^0.9.0, and PPTX ^0.9.0. Named ColorRefs (scheme slots, roles, and `var:<id>`) paint through the published renderer and hex-resolve on export. Payload ids share the slide id namespace for pagination and transfer. Native `schemeClr`, theme write, and `p:hf` remain out of scope.
 
@@ -398,6 +417,8 @@ setTableCellStyle(editor, "slides.4.blocks.1.table", [{ section: "header", colum
 
 Styles use scheme roles, so they follow the color scheme, and the renderers keep the text readable on any fill. A style sets the header fill (`theme`, `plain`, `accent`), banded rows and borders (`theme`, `none`, `horizontal`, `grid`); named presets are `theme`, `banded`, `grid`, `minimal` and `open`, and `theme` removes a previous style. A style owns only the fill and border fields of a cell: text color, alignment, padding, values and merges are kept. Merging never hides text: covered cells that hold text refuse with `merge-would-lose-content` unless you pass `join: true`, which joins the words into the anchor with a space and keeps run formatting. Other refusals are `merge-overlap` (the region crosses another merge), `invalid-table-span` (outside the table, or a header cell spanning into the body) and `table-cell-covered`. Splitting leaves the formerly covered cells as empty text. `parseTableCellPath` maps a canvas selection to a table and cell, and `describeTableCell` and `readTableStyle` read the current state.
 
+Table alt text (FA-27): `setTableAlt(editor, tablePath, { alt: "North America leads EMEA in Q4." })` writes the table's text alternative (`Table.alt`) as one undoable patch, like a chart's. `alt` is trimmed and an empty string or `null` removes it; `{ decorative: true }` writes the empty alt (decorative, and it wins over `alt`) and `{ decorative: false }` removes an empty alt. It works on a table that shows a shared dataset too, since the alt belongs to the table and not to its data. `readTableAlt(table)` gives `{ alt, decorative }` for a form and `prepareTableAlt` is the headless patch. The table section of the design controls has an "Alt text" field and a "Decorative (no alt text)" box, and find and replace searches `table.alt`. `validate` does not ask for a table alt, so the field is optional.
+
 ## Slide management (RR-21)
 
 `@openpresentation/opf-editor/slides` adds, duplicates, deletes, reorders, hides and sections slides. Every function has a `prepare…` form that returns the JSON Patch for a document without touching a session (`{ presentation, patches, changed, selection }`), and an apply form that commits it as ONE validated, undoable change, so a single Undo restores the deck exactly and the preview, thumbnails and PPTX export follow from the document. An operation that changes nothing commits nothing (`changed: false`).
@@ -595,7 +616,7 @@ import { exportDeck } from "@openpresentation/opf-editor/export";
 const result = await exportDeck(editor.presentation, {
   format: "pdf",              // "pdf" | "png" | "svg"
   slides: "all",              // or "current" with slideIndex, or [slide numbers]; hidden slides only with includeHidden
-  pdfMode: "vector",          // or "raster" (an image per slide); PNG and raster density: scale 1 to 4
+  pdfMode: "vector",          // or "raster" (an image per slide; also pass pdfLib: import * as pdfLib from "pdf-lib"); PNG and raster density: scale 1 to 4
   fonts,                      // the renderer's fonts handle (loadFonts): measures, loads the faces the deck needs, supplies the faces to embed
   renderOptions,              // catalogs, date, ...
   signal, onProgress, onDiagnostic,
@@ -609,7 +630,11 @@ const result = await exportDeck(editor.presentation, {
 - **Names.** `exportFileName(deck, ext, suffix)` uses the deck's `filename` (a trailing .pptx/.pdf/.png/.svg dropped), else the slugified `name`, else `presentation`; slides are `name-01.png`, archives `name-png.zip`.
 - **Progress and cancel.** `onProgress({ stage, done, total, message })` reports fonts, drawing, per-page conversion and packing; an aborted `signal` rejects with `export-aborted` between pages and slides.
 - **Diagnostics.** `describeDiagnostic` normalises renderer and converter notes into `{ code, severity, message, slide? }`: `pdf-font-substituted`, `pdf-glyph-missing`, `pdf-raster-fallback` and the renderer's own are `warning`; `pdf-font-embedded` is `info`.
-- PDF and PNG need `@openpresentation/opf-render` with its `export-browser` entry (RR-23, opf-render#105); without it they reject with `export-unavailable` and SVG still works. Verified in Chromium; Safari and Firefox are not exercised in CI. The playground bundle grows by the PDF writer, fontkit shaping and the bidi algorithm.
+- PDF and PNG need `@openpresentation/opf-render` with its `export-browser` entry (RR-23, opf-render#105); without it they reject with `export-unavailable` and SVG still works. The entry imports no PDF library (opf-render 0.16): the vector PDF, PNG and SVG need nothing else, and `pdfMode: "raster"` needs the `pdfLib` option. Verified in Chromium; Safari and Firefox are not exercised in CI. The playground bundle grows by the PDF writer, fontkit shaping and the bidi algorithm.
+
+Catalog controls initialize an absent deck or slide `design` for known theme, color-scheme and font-scheme fields as one validated transaction. Undo removes a newly created parent; existing design fields are retained. DOM, React and Svelte catalog controls accept `onError(error)` and emit a bubbling `opferror` event on rejected edits, restore the committed selection and expose native validity feedback. General `editor.set` and JSON Patch require existing parents.
+
+Optional downloads can be deferred until requested: dynamically import `@openpresentation/opf-editor/export` inside the download handler. For a PowerPoint download, dynamically import `@openpresentation/opf-pptx` inside that handler too; the `/export` helper covers PDF, PNG and SVG. This defers conversion code, while canvas rendering and font measurement still have their own startup costs.
 
 ## Optional React Bindings
 
@@ -657,7 +682,7 @@ Public npm package publication is handled by `.github/workflows/release.yml` thr
 
 The current checkout uses `@openpresentation/opf/composition` for portable geometry. Slides can select `auto`, `row`, `column`, or `grid`, set weighted tracks, and request path-specific overflow diagnostics. See the sibling OPF repo's `docs/dynamic-composition.md` for the complete contract.
 
-Version 0.11.0 requires `@openpresentation/opf@^0.12.0` and the optional renderer peer `@openpresentation/opf-render@^0.12.0`, with development and coordinated playground export on renderer 0.12.0 and `@openpresentation/opf-pptx@^0.12.0`; 0.10.6 requires `@openpresentation/opf@^0.11.4`; 0.10.5 and 0.10.4 require ^0.11.3 (0.10.3 and earlier: ^0.11.2). The optional renderer peer requires `@openpresentation/opf-render@^0.11.0` (the font gate gates nothing on a registry without the lazy loaders). Development and coordinated playground export use renderer 0.11.9 (design fields, picture bullets; 0.11.8 tag colour; the playground example needs 0.11.7 for `extraLazyFonts`; 0.11.6 chart label rotation; 0.11.5 face-level lazy fonts; the gate passes render options, which older renderers ignore) and `@openpresentation/opf-pptx@^0.11.7`. Clean registry installs support the composition APIs without sibling checkouts. For coordinated source development, build OPF and run `node scripts/link-ecosystem.mjs` there; `pnpm test:ecosystem` verifies shared geometry and import/export behavior.
+The current editor requires core `^0.15.1`; canvas rendering uses the optional renderer peer `^0.15.0`, and playground PPTX import/export uses `@openpresentation/opf-pptx@^0.15.0`. Clean registry installs support composition without sibling checkouts. For coordinated source development, build OPF and run `node scripts/link-ecosystem.mjs` there; `pnpm test:ecosystem` verifies shared geometry and import/export behavior.
 
 ## Local interactive demo
 
@@ -669,7 +694,7 @@ Nested content groups expose their bounds through `editor.composeSlide(index).gr
 
 `editor.paginateSlide(index, {minFontSize:24})` splits a crowded draft into ordinary OPF slides as one undoable transaction. It returns the change and source mappings; failed pagination leaves the document unchanged. The playground’s Split overflow action demonstrates the workflow.
 
-`composeSlide(index, { fonts })` and `paginateSlide(index, { fonts })` accept the same fonts handle as preview and export. The local playground now uses bundled, embedded fonts and reports substitutions. The font a user selects (for example Calibri or Aptos) is the source of truth and stays in the document; because license-restricted (proprietary) fonts are never bundled, the canvas draws an open look-alike (a metric-compatible one such as Carlito for Calibri where it exists, a visual-only fallback for Aptos today) and the substitution report says so. Release caveat: the published editor depends on opf-pptx `^0.9.0`, which resolves 0.9.1 and still writes the substitute into the PPTX; selected-name export arrives with the next opf-pptx release. See the [OPF font policy](https://github.com/OpenPresentation/opf/blob/main/docs/font-fidelity.md#font-policy-ff-31).
+`composeSlide(index, { fonts })` and `paginateSlide(index, { fonts })` accept the same fonts handle as preview and export. The local playground now uses bundled, embedded fonts and reports substitutions. The font a user selects (for example Calibri or Aptos) is the source of truth and stays in the document; because license-restricted (proprietary) fonts are never bundled, the canvas draws an open look-alike (a metric-compatible one such as Carlito for Calibri where it exists, the metric-compatible Intos family for Aptos) and the substitution report says so. Since 0.14, PPTX export names the selected font, while preview substitutions remain visible in the font report. See the [OPF font policy](https://github.com/OpenPresentation/opf/blob/main/docs/font-fidelity.md#font-policy-ff-31).
 
 
 ## Copy, paste, and gallery imports
@@ -680,7 +705,7 @@ The `/galleries` export provides `loadOpfGallery` and `loadOpfGalleryItem`, acce
 
 The playground includes Copy OPF and Import dialogs with paste, file/drop, gallery search, and URL tabs. Files accept OPF JSON and PowerPoint `.pptx` up to 20 MB. PPTX conversion runs locally using `@openpresentation/opf-pptx`; review the converted preview and diagnostics before inserting slides or opening a presentation. Applying an import is one undoable edit. Custom registries persist in local storage; defaults are configured in `examples/galleries.json`. Copy permissions may require using the Select all fallback. Pasting within text fields keeps normal text editing. Cmd/Ctrl+Shift+C opens copying and Cmd/Ctrl+O opens file import.
 
-The **PowerPoint** button commits the current canvas draft and prepares an editable `.pptx` download from that snapshot, using the preview's text measurements. Conversion diagnostics remain visible in the download dialog. Missing/remote images require an explicit host resolver or embedded data; export does not silently fetch them or omit them. Save OPF separately to retain the complete original source. With an opf-pptx that includes FF-31 (after 0.9.1), the download names the font the user selected, never the preview look-alike, so PowerPoint shows that font when it is installed or available as a Microsoft 365 cloud font; opf-pptx 0.9.1, which the published editor resolves today, still writes the substitute. The download does not embed font binaries, and license-restricted (proprietary) fonts are never embedded. Arbitrary native positions and unsupported PowerPoint features can change during reimport.
+The **PowerPoint** button commits the current canvas draft and prepares an editable `.pptx` download from that snapshot, using the preview's text measurements. Conversion diagnostics remain visible in the download dialog. Missing/remote images require an explicit host resolver or embedded data; export does not silently fetch them or omit them. Save OPF separately to retain the complete original source. Since 0.14, PPTX export names the font the user selected, so PowerPoint uses it when installed or available as a Microsoft 365 cloud font. The download does not embed font binaries, and license-restricted (proprietary) fonts are never embedded. Arbitrary native positions and unsupported PowerPoint features can change during reimport.
 
 Run `npm ci`, `npm run build:playground`, then serve `artifacts/playground` with a local static server. This example uses the published core/render/PPTX packages and this checkout's editor source; it does not require an account, AI provider or paid service. `npm run test:playground` builds and executes a real browser flow (local Edge on Windows, installed Chromium in CI): author JSON, inline edit, export a native merged table, validate/reimport the actual downloaded file, undo/redo, save OPF and reject malformed input without changing the document. It is browser behavior evidence, not a claim of native PowerPoint raster equivalence.
 
@@ -716,6 +741,8 @@ The canvas can show draggable, keyboard-accessible dividers for root and nested
 
 ### Move complete blocks
 
+When the slide's layout record has placeholder groups (FA-26, `{ "type": "group", "composition", "placeholders" }`), Arrange also outlines every slot of the record at its cell (`geometry.slots`): groups, filled regions and labelled empty regions. The slots belong to the record, so they are shown, not edited; the slide's content in them keeps its own selection and handles. Layout pickers and the JSON field menu describe such a record as `title, column (text, text), chart` and compare layouts by their leaf regions.
+
 Arrange mode also shows numbered block handles. Drag to reorder siblings, use arrow keys for earlier/later, or click a handle to choose an existing destination group/slide and insertion position. The move preserves the whole block, including rich text, table/chart data, and nested groups. Each move is validated, preflighted by the renderer, and undoable. Parent weights stay with layout positions; moves that leave an empty container or create a containment cycle are rejected.
 
 Agents can import `prepareBlockMove` and `listBlockContainers` from `@openpresentation/opf-editor/layout`. The prepared result includes a full candidate document, guarded atomic patches, the new block path, and a changed flag. Destination indexes refer to the pre-removal document. Use `canvas.openBlockMenu(path)` for the corresponding browser controls.

package/dist/canvas.js

@@ -23,7 +23,7 @@ import { createRichTextInput } from "./rich-text-input.js";
 import { textInputOffsetAtPoint } from "./text-pointer.js";
 import { createRichTextToolbar } from "./rich-text-toolbar.js";
 import { createImageCropper } from "./image-cropper.js";
-import { FONTS_PENDING, fontGate, fontsPendingError, previewFonts, whenFontsReady } from "./font-gate.js";
+import { FONTS_PENDING, fontGate, fontsPendingError, whenFontsReady } from "./font-gate.js";
 import { checkFormat, firstErrorMessage } from "./checks.js";
 export { getEditableFields } from "./canvas-fields.js";
 export { whenFontsReady, FONTS_PENDING, FONTS_UNAVAILABLE } from "./font-gate.js";
@@ -75,7 +75,9 @@ export function createCanvasEditor(container, options = {}) {
   const handle = options.fonts, fonts = fontGate(handle);
   // The renderer draws with the session's registered catalogs (plus any `renderOptions.catalogs`): the same list core resolves with.
   const resolveOptions = () => ({ ...renderOptions, catalogs: mergeCatalogs(editor.catalogs, renderOptions.catalogs) });
-  const drawOptions = (extra) => ({ ...resolveOptions(), fonts: previewFonts(handle), ...extra });
+  // RR-61: the handle measures, and the canvas embeds no face: the browser handle already added its faces to the page, so
+  // `@font-face` data would repeat megabytes of base64 in every redraw. Exports keep the default and carry the faces they draw.
+  const drawOptions = (extra) => ({ ...resolveOptions(), fonts: handle, embedFonts: false, ...extra });
   let slideIndex = options.slideIndex ?? 0,
     // RR-32: the canvas edits the document as authored, so a template's {{tokens}} stay visible and an inline edit never
     // overwrites one with its resolved text. The Fill template panel previews the resolved deck. Pass `variables` to override.
@@ -256,6 +258,9 @@ export function createCanvasEditor(container, options = {}) {
     const svg = preview.querySelector("svg");
     svg.setAttribute("role", "group");
     svg.setAttribute("aria-label", "Editable slide");
+    // FA-30: the renderer labels its slide root a "slide" group named by the title; the canvas is named for editing instead, so it drops
+    // the roledescription rather than announce "Editable slide, slide".
+    svg.removeAttribute("aria-roledescription");
     svg.removeAttribute("aria-labelledby");
     const geometry = resolvePresentation(presentation, drawOptions()).slides[
       slideIndex
@@ -286,6 +291,13 @@ export function createCanvasEditor(container, options = {}) {
         continue;
       seen.add(path);
       node.setAttribute("data-canvas-target", "");
+      // FA-30: the renderer hides decorative drawing and a picture or chart with an empty alt (aria-hidden), and names a chart with
+      // alt as an image group. An editing target is focusable, so neither it nor a group around it may be hidden or presentational:
+      // an ancestor image group (the chart's alt) stays named but becomes a plain group so the targets inside it are reachable.
+      for (let up = node; up && up !== svg; up = up.parentNode) {
+        up.removeAttribute("aria-hidden");
+        if (up !== node && up.getAttribute("role") === "img") up.setAttribute("role", "group");
+      }
       node.setAttribute("role", "button");
       node.setAttribute("tabindex", "0");
       node.setAttribute(

package/dist/catalog-control.js

@@ -0,0 +1,21 @@
+// Framework-neutral event handling: rejected edits restore the committed value
+// and reach the host callback and a bubbling opferror event.
+export function commitCatalogControl(node, onError, sync, commit) {
+  try {
+    commit();
+    node.setCustomValidity?.("");
+    node.removeAttribute?.("aria-invalid");
+    node.removeAttribute?.("data-opf-error");
+    return true;
+  } catch (error) {
+    sync();
+    node.setCustomValidity?.(error.message);
+    node.setAttribute?.("aria-invalid", "true");
+    node.setAttribute?.("data-opf-error", error.message);
+    onError?.(error);
+    const Event = node.ownerDocument?.defaultView?.CustomEvent;
+    if (Event) node.dispatchEvent?.(new Event("opferror", { detail: error, bubbles: true }));
+    node.reportValidity?.();
+    return false;
+  }
+}

package/dist/design-controls.js

@@ -36,7 +36,7 @@ import {
 import { createContentControls } from "./content-controls.js";
 import { IMAGE_EDGES, IMAGE_FITS, IMAGE_SHAPES, readImageTreatments, setImageTreatment } from "./image-options.js";
 import { applyCatalogUpdate, catalogRecordAt, checkCatalogUpdates, mergeCatalogs, moveToCustom, referenceFindings } from "./catalogs.js";
-import { describeTableCell, mergeTableCells, parseTableCellPath, readTableStyle, setTableCellStyle, setTableStyle, splitTableCell } from "./table-options.js";
+import { describeTableCell, mergeTableCells, parseTableCellPath, readTableAlt, readTableStyle, setTableAlt, setTableCellStyle, setTableStyle, splitTableCell } from "./table-options.js";
 
 /** The sections a panel can show. `selection` and `table` follow the current selection; the rest follow the deck or the current slide. */
 export const DESIGN_CONTROL_SECTIONS = Object.freeze(["look", "background", "header-footer", "brand", "layout-options", "info", "selection", "image", "table", "slide-content", "catalog"]);
@@ -1158,8 +1158,19 @@ export function createDesignControls(container, options = {}) {
     const align = selectField("cell-align", "Cell text alignment", { empty: "Default", onChange: (value) => run(() => setTableCellStyle(editor, dynamic.tablePath, dynamic.cell, { align: value === "" ? null : value }), "Cell alignment changed.") });
     align.setOptions(["left", "center", "right"].map((value) => ({ value, label: titleCase(value) })));
     const cellBox = h("div", { class: "opf-dc-cell" }, cellLabel, columns.wrap, rows.wrap, join.wrap, h("div", { class: "opf-dc-actions" }, merge, split), fill.wrap, align.wrap);
-    body.append(summary, headerStyle.wrap, banding.wrap, borders.wrap, resetStyle, cellBox);
-    dynamic.table = { details, summary, headerStyle, banding, borders, cellBox, cellLabel, columns, rows, merge, split, fill, align, join };
+    // FA-27: the table's text alternative, like a chart's. It belongs to the table, so a dataset-backed table has it too.
+    const alt = textField("table-alt", "Alt text", {
+      help: "What the table shows: its point and the key numbers, not \"a table\". Optional, because a screen reader reads a table cell by cell. Press Enter to apply.",
+      placeholder: "What the table shows",
+      onCommit: (value) => run(() => setTableAlt(editor, dynamic.tablePath, { alt: value }), "Table alt text changed."),
+    });
+    alt.input.setAttribute("aria-label", "Table alt text");
+    const decorative = checkField("table-decorative", "Decorative (no alt text)", {
+      onChange: (checked) => run(() => setTableAlt(editor, dynamic.tablePath, { decorative: checked }), checked ? "Table marked decorative." : "The table is no longer decorative."),
+    });
+    const styleControls = [headerStyle.wrap, banding.wrap, borders.wrap, resetStyle, cellBox];
+    body.append(summary, alt.wrap, decorative.wrap, ...styleControls);
+    dynamic.table = { details, summary, alt, decorative, styleControls, headerStyle, banding, borders, cellBox, cellLabel, columns, rows, merge, split, fill, align, join };
   }
 
   // --- sync -----------------------------------------------------------------------------------------
@@ -1210,12 +1221,21 @@ export function createDesignControls(container, options = {}) {
       const tablePath = parsed?.tablePath ?? (content?.key === "table" ? `${blockPath}.table` : undefined);
       dynamic.tablePath = tablePath;
       dynamic.cell = parsed?.cell;
-      // A table that shows a shared dataset (RR-54) has no cell styles or merges: the table panel is for inline tables.
+      // A table that shows a shared dataset (RR-54) has no cell styles or merges: the style and merge controls are for inline tables.
+      // Its alt text (FA-27) belongs to the table and not to the data, so the panel still opens for it.
       const tableValue = tablePath ? editor.get(tablePath) : undefined;
-      tableUi.details.hidden = !tablePath || !Array.isArray(tableValue?.rows);
+      const inline = Array.isArray(tableValue?.rows);
+      tableUi.details.hidden = !tablePath || !(inline || typeof tableValue?.dataset === "string");
       if (tablePath && !tableUi.details.hidden) {
-        const table = tableValue;
         tableUi.summary.textContent = `Table (${tablePath})`;
+        const textAlternative = readTableAlt(tableValue);
+        tableUi.alt.set(textAlternative.alt);
+        tableUi.alt.input.disabled = textAlternative.decorative;
+        tableUi.decorative.set(textAlternative.decorative);
+        for (const node of tableUi.styleControls) node.hidden = !inline;
+      }
+      if (tablePath && !tableUi.details.hidden && inline) {
+        const table = tableValue;
         const style = readTableStyle(document_, tablePath);
         dynamic.tableStyle = style.preset === "custom" ? { header: "theme", banding: false, borders: "theme" } : { header: style.header, banding: style.banding, borders: style.borders };
         tableUi.headerStyle.set(style.header);

package/dist/export.d.ts

@@ -42,6 +42,11 @@ export interface ExportOptions {
   includeHidden?: boolean;
   /** "vector" (default): selectable text and vector shapes; "raster": an image per slide. */
   pdfMode?: "vector" | "raster";
+  /**
+   * Raster PDF only: the pdf-lib module (`import * as pdfLib from "pdf-lib"`). The renderer's `export-browser` entry imports no PDF library (opf-render 0.16), so the host passes it;
+   * without it a `pdfMode: "raster"` PDF rejects with the renderer's `converter-missing`. Vector PDF, PNG and SVG need no option.
+   */
+  pdfLib?: { PDFDocument: { create(options?: { updateMetadata?: boolean }): Promise<any> } };
   /** PNG pixel density (and the raster PDF's), 1 to 4; default 2. */
   scale?: number;
   /** The options the host draws its preview with (`catalogs`, `date`, ...); the fonts go in `fonts`. */
@@ -72,6 +77,6 @@ export interface ExportResult {
 }
 /**
  * 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-format`, `export-unavailable` (PDF and PNG need the renderer's `export-browser` entry), `fonts-unavailable` or a renderer code (`converter-missing` for a raster PDF without `pdfLib`).
  */
 export declare function exportDeck(deck: unknown, options: ExportOptions): Promise<ExportResult>;

package/dist/export.js

@@ -124,6 +124,9 @@ async function loadConverters(options) {
  * - `format`: "pdf", "png" or "svg" (required).
  * - `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).
+ * - `pdfLib`: for `pdfMode: "raster"` only, the pdf-lib module (`import * as pdfLib from "pdf-lib"`). The renderer's `export-browser` entry imports no PDF library (RR-63, opf-render 0.16),
+ *   so a host that offers the raster PDF imports pdf-lib itself; without it a raster PDF rejects with the renderer's `converter-missing` (its `details.install` names the package).
+ *   Vector PDF, PNG and SVG need no option.
  * - `scale`: PNG pixel density, 1 to 4 (default 2); also the raster PDF's density.
  * - `renderOptions`: the render options the host draws with (`catalogs`, `date`, ...), the same as its preview.
  * - `catalogs`: the host's registered catalogs (`Catalog[]`, merged with `renderOptions.catalogs`). The deck is embedded first (core's
@@ -137,7 +140,7 @@ async function loadConverters(options) {
  *   `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-fonts-unlicensed`, `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 (`converter-missing` for a raster PDF without `pdfLib`).
  */
 export async function exportDeck(input, options = {}) {
   const format = EXPORT_FORMATS[options.format];
@@ -213,6 +216,8 @@ export async function exportDeck(input, options = {}) {
         metadata,
         signal,
         fontData: pdfFontData(embeddedFonts),
+        // RR-63: the renderer's browser entry imports no pdf-lib; raster mode takes the module the host imported.
+        ...(options.pdfMode === "raster" && options.pdfLib ? { pdfLib: options.pdfLib } : {}),
         ...(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}`),

package/dist/find-replace.js

@@ -107,6 +107,7 @@ function payloadFields(fields, state, base, payload, prefix = "") {
     }));
   }
   if (isObject(payload.chart)) field(fields, state, at("chart", "alt"), payload.chart.alt, `${prefix}Chart alt text`, "alt");
+  if (isObject(payload.table)) field(fields, state, at("table", "alt"), payload.table.alt, `${prefix}Table alt text`, "alt");
   const table = payload.table;
   if (isObject(table)) {
     if (Array.isArray(table.columns)) table.columns.forEach((cell, c) => (isObject(cell) && !("value" in cell) ? field(fields, state, at("table", "columns", String(c), "name"), cell.name, `${prefix}Table header ${c + 1}`, "table") : cellFields(fields, state, at("table", "columns", String(c)), cell, `${prefix}Table header ${c + 1}`)));

package/dist/font-gate.js

@@ -13,17 +13,6 @@ export const FONTS_UNAVAILABLE = "fonts-unavailable";
 
 const GATE = Symbol("opf-editor.fontGate");
 
-/**
- * The fonts a preview draws with: the handle's text measurement and nothing else. A full handle also lists `embeddedFonts`, which
- * the renderer writes into every SVG it returns (an export needs that, so the SVG carries its faces); a preview inside a page
- * that already loaded the faces would repeat megabytes of base64 in every canvas, thumbnail and panel preview. The measurement
- * is read from the handle at each use, so faces it loads later still measure.
- */
-export function previewFonts(fonts) {
-  if (!fonts || typeof fonts !== "object") return undefined;
-  return { get textMeasurement() { return fonts.textMeasurement; } };
-}
-
 /**
  * The gate over a fonts handle: the two calls the canvas and the export need, with the editor's error contract.
  *

package/dist/index.d.ts

@@ -162,6 +162,7 @@ export interface CatalogSelectOptions extends CatalogOptionsInput {
   path: string;
   catalogKind: string;
   label?: string;
+  onError?: (error: Error) => void;
   document?: { createElement(tagName: string): any };
 }
 

package/dist/index.js

@@ -1,3 +1,4 @@
+import { commitCatalogControl } from "./catalog-control.js";
 import { paginateSlide } from "@openpresentation/opf/pagination";
 import { OPFPatchError, applyPatch as applyCorePatch, applyPatchWithInverse, formatPointer, invertPatch, jsonEqual, parsePointer, readPointer } from "@openpresentation/opf/patch";
 import { collectReservedPresentationIds } from "./presentation-ids.js";
@@ -523,8 +524,19 @@ export function setCatalogId(editor, path, catalogKind, id, meta = {}) {
   const current = editor.get(path);
   const value = catalogReferenceValue(current, catalogId);
   const { catalogs: _catalogs, presentation: _presentation, ...commitMeta } = meta;
-  return editor.set(path, value, {
+  // Only documented design references may initialize their optional design parent.
+  // Ordinary set/applyPatch retain RFC 6902's existing-parent requirement.
+  const segments = splitOpfPath(path);
+  const designField = { themes: "theme", colorSchemes: "colorScheme", fontSchemes: "fontScheme" }[catalogKind];
+  const deckDesign = segments.length === 2 && segments[0] === "design";
+  const slideDesign = segments.length === 4 && segments[0] === "slides" && /^(0|[1-9][0-9]*)$/.test(segments[1]) && segments[2] === "design" && editor.get(segments.slice(0, 2));
+  const parent = segments.slice(0, -1);
+  const patches = designField === segments.at(-1) && (deckDesign || slideDesign) && !hasValueAtPath(editor.presentation, parent)
+    ? [{ op: "add", path: opfPathToJsonPointer(parent), value: { [designField]: value } }]
+    : createValuePatch(editor.presentation, path, value);
+  return editor.applyPatch(patches, {
     ...commitMeta,
+    rejectInvalid: true,
     catalogKind,
     catalogId,
     source: commitMeta.source ?? "catalog-control"
@@ -589,13 +601,13 @@ export function createCatalogSelect(editor, options) {
     const current = editor.get(path);
     select.value = typeof current === "object" && current ? current.id : current ?? "";
   };
-  const onChange = () => {
-    setCatalogId(editor, path, catalogKind, select.value, {
+  const onChange = () => commitCatalogControl(select, options?.onError, updateValue, () => {
+    return setCatalogId(editor, path, catalogKind, select.value, {
       catalogs: options?.catalogs,
       presentation: options?.presentation,
       source: "catalog-select"
     });
-  };
+  });
   const unsubscribe = editor.subscribe(updateValue);
 
   select.addEventListener?.("change", onChange);

package/dist/json-options.js

@@ -2,7 +2,7 @@ import { checkFormat, firstErrorMessage } from "./checks.js";
 import { listCatalogRecords } from "./catalogs.js";
 import { schemaAtPath, schemaVariants } from "./schema.js";
 import { applyEdits, findNodeAtLocation, findNodeAtOffset, getNodePath, modify, parseTree } from "jsonc-parser";
-import { populateLayoutPlaceholders } from "./layout-placeholders.js";
+import { layoutSlotSummary, layoutSlotTypes, populateLayoutPlaceholders } from "./layout-placeholders.js";
 // The catalog kind a field references (OPF 0.15: every content kind is `id` or `name:id`), read from where the field sits.
 const ROOT_REFERENCES = { narrative: "narratives", audience: "audiences", purpose: "purposes", tone: "tones" };
 const DESIGN_REFERENCES = { theme: "themes", colorScheme: "colorSchemes", fontScheme: "fontSchemes" };
@@ -21,10 +21,9 @@ function catalogAtPath(path) {
 }
 // Compare declared placeholders, including multiplicity. This describes a layout
 // contract, not a claim that arbitrary slide content will render without overflow.
+// FA-26: a record's placeholder groups compare by their leaf regions, the slots its content fills.
 function layoutTypes(record) {
-    if (!Array.isArray(record?.placeholders))
-        return undefined;
-    return record.placeholders.map(p => p.type).sort();
+    return layoutSlotTypes(record)?.sort();
 }
 function placeholderSummary(types) {
     if (!types)
@@ -57,8 +56,10 @@ function describeOptions(choices, records, current, catalog) {
         if (catalog !== "layouts")
             continue;
         const types = layoutTypes(option.value === current ? currentRecord : records.get(String(option.value)));
-        option.placeholderTypes = records.get(String(option.value))?.placeholders?.map(placeholder => placeholder.type);
-        option.placeholders = placeholderSummary(types);
+        const record = records.get(String(option.value));
+        option.placeholderTypes = layoutSlotTypes(record);
+        // A record with placeholder groups also shows how its slots nest.
+        option.placeholders = placeholderSummary(types) + (record?.placeholders?.some?.(entry => entry?.type === "group") ? ` · ${layoutSlotSummary(record)}` : "");
         const same = types && currentTypes && signature(types) === signature(currentTypes);
         const equivalent = types && currentTypes && signature(compatible(types)) === signature(compatible(currentTypes));
         const sameKinds = types && currentTypes && signature([...new Set(compatible(types))]) === signature([...new Set(compatible(currentTypes))]);

package/dist/layout-handles.js

@@ -60,6 +60,19 @@ export function createLayoutHandles(root, options) {
     lastGeometry=geometry;
     layer.replaceChildren();
     if(!enabled||options.isTextEditing())return;
+    // FA-26: the slots of a layout record with placeholder groups, drawn under the handles while arranging: each group and
+    // region as a dashed outline at its cell, deeper groups inset, an empty region labelled with its kind. They are the
+    // record's, not the document's, so they are not editable here; the content in a slot keeps its own selection.
+    for(const slot of geometry.slots??[]){
+      const node=doc.createElement('div');
+      node.dataset.layoutSlot=slot.path;node.dataset.layoutSlotType=slot.type;node.setAttribute('aria-hidden','true');
+      const group=slot.type==='group',empty=!group&&!slot.content;
+      node.title=group?`Layout group (${slot.path})`:`${empty?'Empty ':''}${slot.type} slot (${slot.path})`;
+      const inset=group?Math.min(4,slot.depth*2):0;
+      node.style.cssText=`position:absolute;pointer-events:none;box-sizing:border-box;left:calc(${slot.box.x/geometry.width*100}% + ${inset}px);top:calc(${slot.box.y/geometry.height*100}% + ${inset}px);width:calc(${slot.box.width/geometry.width*100}% - ${2*inset}px);height:calc(${slot.box.height/geometry.height*100}% - ${2*inset}px);border:1px dashed ${group?'#8170d5':'#8a78d7aa'};border-radius:4px;${empty?'background:#8a78d714;':''}`;
+      if(empty){const label=doc.createElement('span');label.textContent=`Empty ${slot.type} slot`;label.style.cssText='position:absolute;left:6px;top:4px;font:11px system-ui;color:#675394';node.append(label);}
+      layer.append(node);
+    }
     for(const flow of geometry.flows??[]){
       const {axis,size,tracks}=trackData(flow);
       if(tracks.length<2||tracks.length>12||flow.itemCount!==flow.slotCount)continue;

package/dist/layout-placeholders.js

@@ -1,5 +1,20 @@
+import {layoutLeaves,layoutStructure} from '@openpresentation/opf/composition';
 import {listBlockContainers,prepareBlockInsert} from './blocks.js';
 
+/**
+ * The slot kinds a layout record declares, in reading order: its headings and the leaf regions of its placeholder groups
+ * (FA-26), the kinds a slide's flat content fills. Undefined when the record states no placeholders.
+ */
+export function layoutSlotTypes(record){
+  if(!Array.isArray(record?.placeholders))return undefined;
+  try{return layoutLeaves(record).map(leaf=>leaf.type);}catch{return record.placeholders.filter(entry=>entry?.type!=='group').map(entry=>entry?.type);}
+}
+/** A one-line description of a record's slots, nested groups in parentheses: `title, column (text, text), chart`. */
+export function layoutSlotSummary(record){
+  if(!Array.isArray(record?.placeholders))return '';
+  try{return layoutStructure(record);}catch{return layoutSlotTypes(record).join(', ');}
+}
+
 const payloadFields=['text','items','bullets','image','video','chart','table','code','metric','quote','timeline'];
 const headingFields=new Set(['title','subtitle','tag']);
 const fields={text:'text',list:'items',image:'image',video:'video',chart:'chart',table:'table',code:'code',metric:'metric',quote:'quote',timeline:'timeline'};

package/dist/react.d.ts

@@ -14,6 +14,7 @@ export interface OPFCatalogSelectProps {
   path: string;
   catalogKind: string;
   label?: string;
+  onError?: (error: Error) => void;
   catalogOptions?: CatalogOption[];
   selectProps?: Record<string, unknown>;
   [key: string]: unknown;

package/dist/react.js

@@ -1,3 +1,4 @@
+import { commitCatalogControl } from "./catalog-control.js";
 import {
   getCatalogOptions,
   getValueAtPath,
@@ -56,6 +57,7 @@ export function createOPFReactComponents(React) {
     catalogKind,
     label,
     catalogOptions,
+    onError,
     selectProps = {},
     ...props
   }) {
@@ -78,7 +80,9 @@ export function createOPFReactComponents(React) {
           selectProps.onChange?.(event);
           props.onChange?.(event);
           if (!event.defaultPrevented) {
-            setCatalogId(editor, path, catalogKind, event.currentTarget.value, { source: "react-catalog-select" });
+            const node = event.currentTarget;
+            commitCatalogControl(node, onError, () => { node.value = currentId ?? ""; }, () =>
+              setCatalogId(editor, path, catalogKind, node.value, { source: "react-catalog-select" }));
           }
         }
       },

package/dist/slide-manager.js

@@ -7,6 +7,7 @@ import {
   addSection, addSlide, duplicateSlides, hasSections, listSections, moveSection, moveSlides, moveSlidesBy, removeSection, removeSlides, renameSection, setHidden, setSection, slideTitle,
 } from "./slides.js";
 import { listSwitchOptions } from "./switches.js";
+import { layoutSlotSummary } from "./layout-placeholders.js";
 
 let instances = 0;
 const SVG_NS = "http://www.w3.org/2000/svg";
@@ -503,7 +504,8 @@ export function createSlideManager(container, options) {
     };
     const describe = () => {
       const choice = choices.find((entry) => entry.id === select.value);
-      const slots = Array.isArray(choice?.record?.placeholders) ? choice.record.placeholders.map((slot) => slot.type).join(", ") : "";
+      // FA-26: nested placeholder groups show with their mode, for example `title, column (text, text), chart`.
+      const slots = layoutSlotSummary(choice?.record);
       detail.textContent = choice ? `${choice.record?.description ?? ""}${slots ? ` Slots: ${slots}.` : choice.record?.placeholders ? " An empty slide." : ""}`.trim() : "No layout matches.";
     };
     const form = el("form", { method: "dialog" },

package/dist/svelte.d.ts

@@ -11,6 +11,7 @@ export interface OPFCatalogSelectActionParams extends CatalogOptionsInput {
   path: string;
   catalogKind: string;
   label?: string;
+  onError?: (error: Error) => void;
 }
 
 export interface OPFTraceActionParams extends SvgTraceBindingOptions {

package/dist/svelte.js

@@ -1,3 +1,4 @@
+import { commitCatalogControl } from "./catalog-control.js";
 import {
   createSvgTraceBinding,
   getCatalogOptions,
@@ -59,11 +60,11 @@ export function opfCatalogSelect(node, params) {
       const value = editor.get(path);
       node.value = value && typeof value === "object" ? value.id : value ?? "";
     };
-    const onChange = () => setCatalogId(editor, path, catalogKind, node.value, {
+    const onChange = () => commitCatalogControl(node, nextParams.onError, sync, () => setCatalogId(editor, path, catalogKind, node.value, {
       catalogs: nextParams.catalogs,
       presentation: nextParams.presentation,
       source: "svelte-catalog-select"
-    });
+    }));
     const unsubscribe = editor.subscribe(sync);
 
     node.addEventListener?.("change", onChange);

package/dist/switches.js

@@ -13,7 +13,7 @@ import { chartOptionTarget } from "@openpresentation/opf/composition";
 import { 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 { layoutSlotTypes, populateLayoutPlaceholders } from "./layout-placeholders.js";
 import { blockConversionTargets, prepareBlockConversion } from "./block-convert.js";
 import { checkFormat } from "./checks.js";
 import { listCatalogRecords, mergeCatalogs } from "./catalogs.js";
@@ -273,7 +273,8 @@ export function prepareDimensionSwitch(presentation, dimension, value, options =
     if (withRecord.slides[slideIndex].layout !== choice.reference) {
       const layoutOps = createValuePatch(withRecord, ["slides", String(slideIndex), "layout"], choice.reference);
       const swapped = applyJsonPatch(withRecord, layoutOps);
-      const types = Array.isArray(record.placeholders) ? record.placeholders.map((placeholder) => placeholder.type) : undefined;
+      // FA-26: a record's placeholder groups contribute their leaf regions, in reading order.
+      const types = layoutSlotTypes(record);
       // Add the blank payloads the layout declares, as the JSON editor's layout choice does.
       const populated = types ? populateLayoutPlaceholders(swapped, slideIndex, types) : swapped;
       patches = same(populated.slides[slideIndex], swapped.slides[slideIndex])

package/dist/table-options.d.ts

@@ -37,7 +37,7 @@ export interface TableCellState extends TableCellAddress {
   rows: number;
 }
 export interface PreparedTableChange {
-  action: "merge" | "split" | "style" | "table-style";
+  action: "merge" | "split" | "style" | "table-style" | "table-alt";
   tablePath: string;
   presentation: unknown;
   patches: JsonPatchOperation[];
@@ -72,6 +72,11 @@ export declare function mergeTableCells(editor: EditorSession, tablePath: string
 export declare function splitTableCell(editor: EditorSession, tablePath: string, cell: TableCellAddress, meta?: Record<string, unknown>): TableChange;
 export declare function setTableCellStyle(editor: EditorSession, tablePath: string, cells: TableCellAddress | TableCellAddress[], style: Record<string, unknown> | null, meta?: Record<string, unknown>): TableChange;
 export declare function setTableStyle(editor: EditorSession, tablePath: string, preset: keyof typeof TABLE_STYLE_PRESETS | Partial<TableStyle>, meta?: Record<string, unknown>): TableChange;
+/** FA-27: the table's text alternative as form state: `alt` (empty when absent or decorative) and `decorative` (the empty alt). */
+export declare function readTableAlt(table: unknown): { alt: string; decorative: boolean };
+/** FA-27: change the table's text alternative. `alt` is trimmed and an empty string or null removes it; `decorative: true` writes the empty alt and wins over `alt`; `decorative: false` removes an empty alt. Works on inline and dataset-backed tables. */
+export declare function prepareTableAlt(presentation: unknown, tablePath: string, change: { alt?: string | null; decorative?: boolean }): PreparedTableChange;
+export declare function setTableAlt(editor: EditorSession, tablePath: string, change: { alt?: string | null; decorative?: boolean }, meta?: Record<string, unknown>): TableChange;
 /** {@link readTableStyle} for a table object. */
 export declare function readTableStyleOfTable(table: unknown): (TableStyle | { header: "custom"; banding: "custom"; borders: "custom" }) & { preset: keyof typeof TABLE_STYLE_PRESETS | "custom" };
 /** Apply a table style to a table object in place (the structure operations use it to keep banding, header fill and borders correct). */

package/dist/table-options.js

@@ -394,6 +394,44 @@ export function readTableStyleOfTable(table) {
 // Table structure (RR-24): insert, delete, move and sort rows and columns, the header row, cell values.
 export * from "./table-structure.js";
 
+// --- text alternative (FA-27) -----------------------------------------------------------------
+
+/**
+ * The table's text alternative as form state, like a chart's: `alt` is the text (empty when absent or decorative) and `decorative`
+ * is the empty alt, a reviewed choice and not a missing one.
+ */
+export function readTableAlt(table) {
+  return { alt: typeof table?.alt === "string" ? table.alt : "", decorative: table?.alt === "" };
+}
+
+/**
+ * Compute the patch that changes the table's text alternative. `change` is `{ alt?, decorative? }`: `alt` is trimmed and an empty string
+ * or `null` removes it, `decorative: true` writes the empty alt (and wins over `alt`), `decorative: false` removes an empty alt. It works
+ * on an inline table and on a table that shows a shared dataset, because `alt` belongs to the table and not to its data. The document
+ * is not modified.
+ */
+export function prepareTableAlt(presentation, tablePath, change) {
+  const before = checkFormat(presentation);
+  const parts = splitOpfPath(tablePath);
+  const table = getValueAtPath(presentation, parts);
+  if (!isObject(table) || (!Array.isArray(table.rows) && typeof table.dataset !== "string")) throw fail("table-not-found", "Choose a table (a path ending in .table).", { tablePath });
+  if (!isObject(change)) throw fail("invalid-table-option", "A table alt change is { alt?, decorative? }.", { change });
+  let wanted;
+  if (change.decorative === true) wanted = "";
+  else if (change.alt !== undefined) wanted = typeof change.alt === "string" && change.alt.trim() ? change.alt.trim() : undefined;
+  else if (change.decorative === false && table.alt === "") wanted = undefined;
+  else wanted = table.alt;
+  const pointer = opfPathToJsonPointer([...parts, "alt"]);
+  const present = Object.hasOwn(table, "alt");
+  const patches = [];
+  if (wanted === undefined) {
+    if (present) patches.push({ op: "remove", path: pointer });
+  } else if (!present) patches.push({ op: "add", path: pointer, value: wanted });
+  else if (table.alt !== wanted) patches.push({ op: "replace", path: pointer, value: wanted });
+  const next = checkedDocument(presentation, patches, before);
+  return { action: "table-alt", tablePath: parts.join("."), changed: patches.length > 0, patches, presentation: clone(next) };
+}
+
 // --- session forms ----------------------------------------------------------------------------
 
 function commit(editor, prepared, meta = {}) {
@@ -423,6 +461,11 @@ export function setTableCellStyle(editor, tablePath, cells, style, meta = {}) {
   checkEditor(editor);
   return commit(editor, prepareTableCellStyle(editor.presentation, tablePath, cells, style), meta);
 }
+/** Change the table's text alternative as one undoable transaction. See {@link prepareTableAlt}. */
+export function setTableAlt(editor, tablePath, change, meta = {}) {
+  checkEditor(editor);
+  return commit(editor, prepareTableAlt(editor.presentation, tablePath, change), meta);
+}
 /** Apply a table style as one undoable transaction. See {@link prepareTableStyle}. */
 export function setTableStyle(editor, tablePath, preset, meta = {}) {
   checkEditor(editor);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpresentation/opf-editor",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "Embeddable local OPF editor primitives built on the deterministic renderer.",
   "license": "MIT",
   "type": "module",
@@ -226,6 +226,7 @@
     "test:code-browser": "node test/code-browser.mjs",
     "test:selection-browser": "node test/selection-browser.mjs",
     "test:click-entry-browser": "node test/click-entry-browser.mjs",
+    "test:canvas-a11y-browser": "node test/canvas-a11y-browser.mjs",
     "test:metric-browser": "node test/metric-browser.mjs",
     "test:rich-input-browser": "node test/rich-input-browser.mjs",
     "test:json": "npm run build && node test/json-source.mjs && node test/json-options.mjs",
@@ -257,11 +258,11 @@
     "@codemirror/state": "6.7.6",
     "@codemirror/view": "6.43.13",
     "@lezer/highlight": "1.2.4",
-    "@openpresentation/opf": "^0.15.1",
+    "@openpresentation/opf": "^0.16.0",
     "jsonc-parser": "3.3.1"
   },
   "peerDependencies": {
-    "@openpresentation/opf-render": "^0.15.0"
+    "@openpresentation/opf-render": "^0.16.0"
   },
   "peerDependenciesMeta": {
     "@openpresentation/opf-render": {
@@ -269,6 +270,12 @@
     }
   },
   "devDependencies": {
+    "@expo-google-fonts/arimo": "0.4.3",
+    "@expo-google-fonts/caladea": "0.4.2",
+    "@expo-google-fonts/cousine": "0.4.3",
+    "@expo-google-fonts/gelasio": "0.4.1",
+    "@expo-google-fonts/noto-color-emoji": "0.4.6",
+    "@expo-google-fonts/noto-emoji": "0.4.7",
     "@expo-google-fonts/noto-naskh-arabic": "0.4.5",
     "@expo-google-fonts/noto-nastaliq-urdu": "0.4.2",
     "@expo-google-fonts/noto-sans": "0.4.2",
@@ -303,15 +310,17 @@
     "@expo-google-fonts/noto-sans-thai": "0.4.2",
     "@expo-google-fonts/noto-serif-hebrew": "0.4.2",
     "@expo-google-fonts/noto-serif-tibetan": "0.4.2",
-    "@openpresentation/opf-pptx": "^0.15.0",
-    "@openpresentation/opf-render": "^0.15.0",
+    "@expo-google-fonts/roboto": "0.4.3",
+    "@expo-google-fonts/roboto-mono": "0.4.2",
+    "@expo-google-fonts/stix-two-math": "0.4.0",
+    "@expo-google-fonts/tinos": "0.4.2",
+    "@openpresentation/opf-pptx": "^0.16.0",
+    "@openpresentation/opf-render": "^0.16.0",
     "axe-core": "4.13.0",
     "esbuild": "0.28.2",
     "jszip": "3.10.2",
+    "pdf-lib": "1.17.1",
     "pdfjs-dist": "6.3.289",
-    "playwright": "1.63.0",
-    "@expo-google-fonts/noto-color-emoji": "0.4.6",
-    "@expo-google-fonts/noto-emoji": "0.4.7",
-    "@expo-google-fonts/stix-two-math": "0.4.0"
+    "playwright": "1.63.0"
   }
 }