pptx-react-viewer 2.16.10 → 2.17.0

package/dist/internals.d.ts

@@ -1640,7 +1640,28 @@ interface BulletInfo {
   autoNumType?: string;
   /** Auto-numbering start value. */
   autoNumStartAt?: number;
-  /** Zero-based paragraph index within the text body (for auto-numbering). */
+  /**
+   * Auto-numbering ORDINAL OFFSET: the zero-based distance of this paragraph
+   * within its own numbered list, such that
+   * `autoNumStartAt + paragraphIndex` is the ordinal to render. Despite the
+   * name it is NOT the paragraph's position in the text body; the two agree
+   * only for a list that starts at the first paragraph and is never
+   * interrupted.
+   *
+   * It has to be the offset rather than the raw position because every
+   * consumer that re-derives a marker from `BulletInfo` alone (the renderer's
+   * `resolveParagraphBullet`, the Markdown converter's `resolveListMarker`)
+   * computes `autoNumStartAt + paragraphIndex`. The load path resolves the
+   * real sequence itself, restarting the count after any paragraph that
+   * interrupts the list, and publishes the offset here so those consumers
+   * land on the same number. With the raw position they did not, and BOTH
+   * markers were painted ("3.1. Item"), because the paragraph builder drops
+   * the parsed marker segment only when the two strings agree.
+   *
+   * Runtime-only: derived at parse time and never serialized. OOXML has no
+   * counterpart (`a:buAutoNum` carries only `@type` and `@startAt`), so the
+   * writer neither reads nor emits it.
+   */
   paragraphIndex?: number;
   /** Bullet font family from `a:buFont`. */
   fontFamily?: string;
@@ -3935,6 +3956,11 @@ interface PptxTableCellStyle {
   italic?: boolean;
   underline?: boolean;
   color?: string;
+  /**
+   * Font family from the first run's `a:rPr/a:latin@typeface` (falling back to
+   * `a:ea` / `a:cs`). Per-run families live on {@link PptxTableCellTextRun}.
+   */
+  fontFamily?: string;
   /**
    * Raw XML colour-choice node preserved from `a:tc/a:txBody/.../a:rPr/a:solidFill`
    * for round-trip serialisation. Currently unused by the cell-level writer
@@ -4090,6 +4116,45 @@ interface PptxTableCell3D {
   /** Light rig direction (`a:lightRig@dir`, e.g. `tl`, `t`, `tr`). */
   lightRigDirection?: string;
 }
+/**
+ * One styled text run inside a table cell's `a:txBody`.
+ *
+ * `PptxTableCell.text` is a flat string and `PptxTableCell.style` describes
+ * only the FIRST run, so a cell mixing formats ("Revenue **grew 42%** last
+ * year") cannot be represented by those two alone. {@link PptxTableCell.runs}
+ * carries the full sequence, with paragraph and line breaks as marker entries
+ * so a renderer can walk it linearly.
+ *
+ * Structurally identical to `pptx-viewer-shared`'s `CellTextRun`, which every
+ * binding's table renderer already consumes.
+ *
+ * @example
+ * ```ts
+ * const runs: PptxTableCellTextRun[] = [
+ *   { text: "Revenue " },
+ *   { text: "grew 42%", bold: true, color: "#C00000" },
+ * ];
+ * // => satisfies PptxTableCellTextRun[]
+ * ```
+ */
+interface PptxTableCellTextRun {
+  /** Run text. Empty for the break markers below. */
+  text: string;
+  /** This entry starts a new paragraph (`a:p` boundary) rather than carrying text. */
+  isParagraphBreak?: boolean;
+  /** This entry is a soft line break (`a:br`) rather than carrying text. */
+  isLineBreak?: boolean;
+  bold?: boolean;
+  italic?: boolean;
+  underline?: boolean;
+  strikethrough?: boolean;
+  /** Resolved run colour as a CSS colour string. */
+  color?: string;
+  /** Run font size in points (`a:rPr@sz` / 100). */
+  fontSize?: number;
+  /** Run font family from `a:rPr/a:latin@typeface` (or `a:ea` / `a:cs`). */
+  fontFamily?: string;
+}
 /**
  * A single table cell with text content, optional style, and merge info.
  *
@@ -4106,6 +4171,15 @@ interface PptxTableCell3D {
 interface PptxTableCell {
   text: string;
   style?: PptxTableCellStyle;
+  /**
+   * Per-run formatting for the cell's text, when it has any beyond what
+   * {@link style} can express. Present only for cells whose `a:txBody`
+   * actually carries runs; renderers fall back to {@link text} when absent.
+   *
+   * Editing a cell's text invalidates these (the editor produces a plain
+   * string), so an edit path must clear them alongside setting `text`.
+   */
+  textRuns?: PptxTableCellTextRun[];
   /** Column span (defaults to 1). */
   gridSpan?: number;
   /** Row span (defaults to 1). */
@@ -4885,6 +4959,35 @@ interface UnknownPptxElement extends PptxElementBase {
 type PptxElement = TextPptxElement | ShapePptxElement | ConnectorPptxElement | ImagePptxElement | PicturePptxElement | TablePptxElement | ChartPptxElement | SmartArtPptxElement | OlePptxElement | MediaPptxElement | GroupPptxElement | InkPptxElement | ContentPartPptxElement | ZoomPptxElement | Model3DPptxElement | UnknownPptxElement;
 //#endregion
 //#region src/core/types/masters.d.ts
+/**
+ * A placeholder slot declared on a master or layout.
+ *
+ * The geometry fields are in CSS pixels (EMU / {@link EMU_PER_PX}) and are only
+ * present when the shape carried an explicit `a:xfrm`. Placeholders that
+ * inherit their frame from the master leave them undefined, so consumers that
+ * draw placeholder outlines (the layout gallery) must skip those entries
+ * rather than assume a zero-sized box at the origin.
+ *
+ * @example
+ * ```ts
+ * const frame: PptxPlaceholderFrame = { type: "body", idx: "1", x: 63, y: 130 };
+ * // => satisfies PptxPlaceholderFrame
+ * ```
+ */
+interface PptxPlaceholderFrame {
+  /** `p:ph/@type`, lower-cased by the parser; defaults to `body` when omitted. */
+  type: string;
+  /** `p:ph/@idx`, when present. */
+  idx?: string;
+  /** Left offset in CSS pixels, when the shape declares `a:off`. */
+  x?: number;
+  /** Top offset in CSS pixels, when the shape declares `a:off`. */
+  y?: number;
+  /** Width in CSS pixels, when the shape declares `a:ext`. */
+  width?: number;
+  /** Height in CSS pixels, when the shape declares `a:ext`. */
+  height?: number;
+}
 /**
  * Parsed notes master from `ppt/notesMasters/notesMaster1.xml`.
  *
@@ -4906,10 +5009,7 @@ interface PptxNotesMaster {
   /** Background image data URL. */
   backgroundImage?: string;
   /** Placeholder shapes found on the notes master. */
-  placeholders?: Array<{
-    type: string;
-    idx?: string;
-  }>;
+  placeholders?: PptxPlaceholderFrame[];
   /** Editable elements on the notes master (header, footer, date, page number, slide image, notes body). */
   elements?: PptxElement[];
   /** Header/footer flags from `<p:hf>` on the notes master (P-H3). */
@@ -4937,10 +5037,7 @@ interface PptxHandoutMaster {
   /** Background image data URL. */
   backgroundImage?: string;
   /** Placeholder shapes found on the handout master. */
-  placeholders?: Array<{
-    type: string;
-    idx?: string;
-  }>;
+  placeholders?: PptxPlaceholderFrame[];
   /** Editable elements on the handout master (header, footer, date, page number, slide placeholders). */
   elements?: PptxElement[];
   /** Number of slides per page for handout print layout (1, 2, 3, 4, 6, or 9). */
@@ -4988,10 +5085,7 @@ interface PptxSlideMaster {
   /** Layout paths associated with this master. */
   layoutPaths?: string[];
   /** Placeholder shapes on the master. */
-  placeholders?: Array<{
-    type: string;
-    idx?: string;
-  }>;
+  placeholders?: PptxPlaceholderFrame[];
   /** Parsed element shapes on the master slide (for master view rendering). */
   elements?: PptxElement[];
   /** Parsed slide layout objects associated with this master. */
@@ -5063,10 +5157,7 @@ interface PptxSlideLayout {
   /** Parsed element shapes on the layout. */
   elements?: PptxElement[];
   /** Placeholder shapes on the layout. */
-  placeholders?: Array<{
-    type: string;
-    idx?: string;
-  }>;
+  placeholders?: PptxPlaceholderFrame[];
   /** Matching name attribute for layout identification (`@matchingName`). */
   matchingName?: string;
   /** Whether the layout is marked as preserved (prevent deletion, `@preserve`). */
@@ -5080,6 +5171,42 @@ interface PptxSlideLayout {
   /** Header/footer flags from `<p:hf>` on this layout (P-H3). */
   headerFooter?: PptxHeaderFooterFlags;
 }
+/**
+ * Rendered content of a single layout, used to draw gallery thumbnails.
+ *
+ * Produced on demand rather than during load: materialising every layout's
+ * artwork (and decoding its images) up front costs a noticeable amount of time
+ * on decks with many masters, and most sessions never open the layout gallery
+ * at all.
+ *
+ * @example
+ * ```ts
+ * const preview: PptxLayoutPreview = {
+ *   path: "ppt/slideLayouts/slideLayout2.xml",
+ *   width: 960,
+ *   height: 540,
+ *   elements: [],
+ *   placeholders: [{ type: "title" }],
+ * };
+ * // => satisfies PptxLayoutPreview
+ * ```
+ */
+interface PptxLayoutPreview {
+  /** ZIP path of the layout this preview belongs to. */
+  path: string;
+  /** Slide width in CSS pixels, so a thumbnail can compute its own scale. */
+  width: number;
+  /** Slide height in CSS pixels. */
+  height: number;
+  /** Background resolved from the layout, falling back to its master's. */
+  backgroundColor?: string;
+  /** Background image data URL, when the layout or master declares one. */
+  backgroundImage?: string;
+  /** The layout's own artwork (pictures, shapes and static text). */
+  elements: PptxElement[];
+  /** Placeholder slots, drawn as outlined frames in the gallery. */
+  placeholders: PptxPlaceholderFrame[];
+}
 /**
  * A theme part available in the presentation package.
  *
@@ -7699,6 +7826,8 @@ interface IPptxHandlerRuntime {
   revokeBlobUrls(): void;
   getCompatibilityWarnings(): PptxCompatibilityWarning[];
   getLayoutOptions(): PptxLayoutOption[];
+  getLayoutPreview(layoutPath: string): Promise<PptxLayoutPreview | null>;
+  getLayoutPreviews(layoutPaths?: readonly string[]): Promise<PptxLayoutPreview[]>;
   createXmlBuilder(data: PptxData): PptxXmlBuilder;
   Builder(data: PptxData): PptxXmlBuilder;
   setTemplateBackground(path: string, backgroundColor: string | undefined): void;
@@ -7887,6 +8016,26 @@ declare class PptxHandlerCore {
    * @returns Array of {@link PptxLayoutOption} entries.
    */
   getLayoutOptions(): PptxLayoutOption[];
+  /**
+   * Build the artwork thumbnails backing the New Slide / Layout galleries.
+   *
+   * Parsing happens on first request and is memoised afterwards, so opening
+   * the gallery costs one pass over the layout parts and reopening it costs
+   * nothing. Callers that only need one entry should prefer
+   * {@link getLayoutPreview}.
+   *
+   * @param layoutPaths - Restrict the result to these layouts; defaults to
+   *   every layout in the presentation.
+   * @returns One {@link PptxLayoutPreview} per resolvable layout.
+   */
+  getLayoutPreviews(layoutPaths?: readonly string[]): Promise<PptxLayoutPreview[]>;
+  /**
+   * Build the artwork thumbnail for a single layout.
+   *
+   * @param layoutPath - Archive path of the `p:sldLayout` part.
+   * @returns The preview, or `null` when the presentation has no such layout.
+   */
+  getLayoutPreview(layoutPath: string): Promise<PptxLayoutPreview | null>;
   /**
    * Create a fluent XML builder scoped to the given presentation data.
    *
@@ -8900,6 +9049,34 @@ interface ElementClipboardPayload {
   element: PptxElement;
   isTemplate: boolean;
 }
+/** What the "Embed fonts in the file" toggle should look like and do. */
+interface FontEmbeddingDescriptor {
+  /** Distinct typeface names the loaded deck currently embeds. */
+  embeddedFamilies: string[];
+  /**
+   * Whether the toggle accepts input. False when the deck embeds nothing,
+   * because turning it on could not produce an embedded font.
+   */
+  interactive: boolean;
+  /**
+   * The position the toggle must START in so that it describes the file that
+   * would be written right now. A deck that arrived with embedded fonts keeps
+   * them on save, so the switch has to read "on" from the outset; the previous
+   * hardcoded `false` said the opposite of what save actually did.
+   */
+  initialEnabled: boolean;
+  /** Present only when `interactive` is false. */
+  disabledReasonKey?: string;
+}
+//#endregion
+//#region src/render/master-view.d.ts
+/** Which part the master view is currently pointed at. */
+interface MasterViewTarget {
+  tab: MasterViewTab;
+  masterIndex: number;
+  /** `null` selects the master itself rather than one of its layouts. */
+  layoutIndex: number | null;
+}
 //#endregion
 //#region src/render/virtualized-list.d.ts
 /** Framework-neutral virtual-list range used by every thumbnail sidebar. */
@@ -8915,6 +9092,51 @@ interface VirtualizedRange {
 }
 /** Compute the rendered item window for fixed-height virtual lists. */
 declare function computeVirtualRange(totalItems: number, itemHeight: number, scrollTop: number, viewportHeight: number, overscan?: number): VirtualizedRange;
+/**
+ * Why the deck is being serialised, which is a separate question from whether
+ * the user protected it.
+ *
+ * - `user-file` (the default): the bytes leave the viewer as a file. Save,
+ *   Save As, Export, the host-facing `getContent()`. Protection applies.
+ * - `recovery-snapshot`: the bytes exist only so the viewer can read them back.
+ *   The autosave crash-recovery snapshot in IndexedDB, and the internal
+ *   re-serialise-then-reload cycle behind "apply theme". Protection does NOT
+ *   apply: these are always written in the clear.
+ *
+ * ## Why a recovery snapshot must stay plaintext
+ *
+ * Nothing that reads a snapshot back has a password to give it.
+ * `readBackstageRecentFile`, `restoreSessionDeck` and the Version History
+ * panel's Restore all hand `record.data` straight to `PptxHandler.load()` with
+ * no `password` option, and an encrypted package refuses to open without one
+ * (`EncryptedFileError`). So an encrypted snapshot is not an inconvenience, it
+ * is unreadable: the moment the user turns on protection their crash-recovery
+ * data is silently destroyed, which is the exact opposite of what autosave is
+ * for.
+ *
+ * Encrypting it "properly" is not available either. Decrypting on recovery
+ * means the key has to outlive the crash the snapshot exists for, so it would
+ * have to sit in the same IndexedDB / localStorage as the snapshot itself,
+ * next to the ciphertext it unlocks. That is not a security boundary, it is
+ * theatre. Prompting the user instead only works if they remember the password
+ * of a deck they lost, which is precisely the moment they will not.
+ *
+ * ## The tradeoff this accepts (deliberately, not by omission)
+ *
+ * A password-protected deck DOES leave its content in cleartext at rest in the
+ * origin's IndexedDB. Anyone with the browser profile, or any script running on
+ * the origin, can read it. What limits the exposure: snapshots are scoped to
+ * the origin and profile, aged out by the store, and clearable from
+ * File > Account > Storage & Privacy (`clearLocalStorageData`). A user who
+ * cannot accept plaintext at rest should switch AutoSave off, which stops the
+ * snapshot being written at all.
+ *
+ * The rejected alternative was "skip autosave entirely while a password is
+ * set". It removes the plaintext, but it also removes crash recovery without
+ * telling anyone, so a crash loses the whole editing session. Losing data
+ * quietly is the failure mode we are fixing, not a fix for it.
+ */
+type DeckSavePurpose = 'user-file' | 'recovery-snapshot';
 //#endregion
 //#region src/render/toolbar-actions.d.ts
 /**
@@ -8970,6 +9192,15 @@ interface ViewerGeneralOptions {
   userName: string;
   userInitials: string;
   showStartScreen: boolean;
+  /**
+   * Lets the user hand a local font file to the viewer so decks authored
+   * with a font the browser lacks render with the real face.
+   *
+   * Off by default. The registration reads a file the user picks and adds it
+   * to the page's font set for the session, which is a capability a host
+   * embedding the viewer should opt into rather than inherit.
+   */
+  enableCustomFontUpload: boolean;
 }
 interface ViewerProofingOptions {
   autoCorrectTwoInitialCapitals: boolean;
@@ -9497,10 +9728,20 @@ interface ToolbarProps {
   onTransformTextCase: (mode: ChangeCaseMode) => void;
   isOverflowMenuOpen: boolean;
   onSetOverflowMenuOpen: (open: boolean) => void;
-  layoutOptions: Array<{
-    path: string;
-    name: string;
-  }>;
+  layoutOptions: PptxLayoutOption[];
+  /** `layoutPath` of the active slide, marking the current gallery tile. */
+  currentLayoutPath?: string;
+  /** Supplies gallery artwork; without it the menus stay name-only. */
+  loadLayoutPreviews?: () => Promise<PptxLayoutPreview[]>;
+  /** Theme major/minor latin faces, leading the font dropdown. */
+  themeFonts?: {
+    heading?: string;
+    body?: string;
+  };
+  /** Families the deck embeds, offered as their own dropdown group. */
+  embeddedFontFamilies?: readonly string[];
+  /** Families registered this session via File > Options > Fonts. */
+  customFontFamilies?: readonly string[];
   onInsertSlideFromLayout: (path: string, name?: string) => void;
   /** Re-map the active slide onto another of its master's layouts. */
   onApplyLayout?: (path: string) => void;
@@ -9552,6 +9793,22 @@ interface ToolbarProps {
   activeSlide?: PptxSlide;
   onTransitionChange: (updates: Partial<PptxSlideTransition>) => void;
   onApplyTransitionToAll: () => void;
+  /**
+   * Home > Slides > Reset: re-apply the active slide's own layout, restoring
+   * inherited placeholder geometry. Undeclared until now, which is why
+   * `SlidesGroup` bound `undefined` and the button did nothing.
+   */
+  onResetSlide?: () => void;
+  /** Home > Slides > Section: start a new section at the active slide. */
+  onAddSection?: () => void;
+  /** Home > Editing > Select > Select All (every element on the active slide). */
+  onSelectAll?: () => void;
+  /**
+   * Slide Show > Options: what the four checkboxes read, and how a tick is
+   * committed. See shared `ribbon-slide-show-options`.
+   */
+  presentationProperties?: PptxPresentationProperties;
+  onPresentationPropertiesChange?: (updates: Partial<PptxPresentationProperties>) => void;
   /** Host-supplied list of toolbar buttons/ribbon tabs to hide. See `PowerPointViewerProps.hiddenActions`. */
   hiddenActions?: readonly ToolbarActionId[];
   /** Whether the AI assistant is available (the host passed the `ai` prop). */
@@ -10192,6 +10449,18 @@ interface EditorHistoryInput {
   maxHistoryEntries?: number;
   hasActivePointerInteraction: () => boolean;
   pointerCommitNonce: number;
+  /**
+   * Raised whenever a local edit is committed, i.e. exactly when this hook
+   * learns the deck has diverged from what was last loaded or saved.
+   *
+   * This is what drives `state.isDirty`, and through it the status bar, the
+   * host's `onDirtyChange` (the demos hang their "* filename" title marker off
+   * it) and - critically - `useAutosave`, which short-circuits on a clean
+   * document. Before this existed, `isDirty` was raised only by a few
+   * master-view and document-property paths, so an element nudge, Home > New
+   * Slide or a notes edit left the flag false and crash recovery never ran.
+   */
+  onDirty?: () => void;
   setSlides: (slides: PptxSlide[]) => void;
   setCanvasSize: (size: CanvasSize) => void;
   setActiveSlideIndex: (index: number) => void;
@@ -11007,6 +11276,25 @@ interface UseLoadContentResult {
 declare function useLoadContent({ content, clearSelection, history, setSlides, setTemplateElementsBySlideId, mediaDataUrls, setCanvasSize, setHeaderFooter, setLayoutOptions, setSlideMasters, setTheme, setTableStyleMap, setThemeOptions, setCustomShows, setSections, setPresentationProperties, setNotesMaster, setHandoutMaster, setNotesCanvasSize, setCustomProperties, setTagCollections, setCoreProperties, setAppProperties, setEmbeddedFonts, setActiveSlideIndex, setHasMacros, setHasDigitalSignatures, setDigitalSignatureCount, setGuides, setLoading, setError, setIsDirty, setIsEncrypted, onContentApplied }: UseLoadContentInput): UseLoadContentResult;
 //#endregion
 //#region src/viewer/hooks/useElementOperations.d.ts
+/**
+ * View > Slide Master routing.
+ *
+ * The master view paints a part that is not in `slides`, so an edit made
+ * there has to be written back into the master / layout / notes / handout
+ * model instead. React previously keyed a pseudo-slide on the master's
+ * archive path and pushed edits into `templateElementsBySlideId`, where
+ * `buildSaveSlides` looks parts up by real slide id and so never found them:
+ * the change showed on screen and vanished on save.
+ */
+interface MasterViewRouting {
+  target: MasterViewTarget | null;
+  slideMasters: PptxSlideMaster[];
+  notesMaster: PptxNotesMaster | undefined;
+  handoutMaster: PptxHandoutMaster | undefined;
+  setSlideMasters: React.Dispatch<React.SetStateAction<PptxSlideMaster[]>>;
+  setNotesMaster: React.Dispatch<React.SetStateAction<PptxNotesMaster | undefined>>;
+  setHandoutMaster: React.Dispatch<React.SetStateAction<PptxHandoutMaster | undefined>>;
+}
 interface UseElementOperationsInput {
   slides: PptxSlide[];
   activeSlide: PptxSlide | undefined;
@@ -11017,6 +11305,8 @@ interface UseElementOperationsInput {
   editTemplateMode: boolean;
   /** Template (master/layout) elements for the active slide. */
   templateElements: PptxElement[];
+  /** Set while View > Slide Master is open; routes writes to the master part. */
+  masterView?: MasterViewRouting | undefined;
   history: EditorHistoryResult;
   setSlides: React.Dispatch<React.SetStateAction<PptxSlide[]>>;
   setTemplateElementsBySlideId: React.Dispatch<React.SetStateAction<Record<string, PptxElement[]>>>;
@@ -11610,6 +11900,12 @@ interface UseViewerDialogsInput {
   isDirty: boolean;
   /** Editor history instance (used for markDirty on settings changes). */
   history: EditorHistoryResult;
+  /**
+   * Typeface names the loaded deck embeds (`p:embeddedFontLst`). Decides
+   * whether the "Embed fonts" toggle can do anything, and which position it
+   * starts in.
+   */
+  embeddedFontFamilies?: readonly string[];
 }
 /**
  * Output shape of the {@link useViewerDialogs} hook.
@@ -11656,9 +11952,15 @@ interface ViewerDialogsResult {
   /** OMML data for the equation currently being edited, or null. */
   editingEquationOmml: Record<string, unknown> | null;
   setEditingEquationOmml: React.Dispatch<React.SetStateAction<Record<string, unknown> | null>>;
-  /** Whether font embedding is enabled for save. */
+  /**
+   * Whether the saved file will carry the deck's embedded fonts. Read by
+   * `useSerialize` via `embeddedFontSaveOptions`; false strips
+   * `p:embeddedFontLst` and the `.fntdata` parts.
+   */
   embedFontsEnabled: boolean;
   setEmbedFontsEnabled: React.Dispatch<React.SetStateAction<boolean>>;
+  /** Whether the toggle can do anything on this deck, and why not when it cannot. */
+  fontEmbedding: FontEmbeddingDescriptor;
   /** True when the container is narrower than 768px (triggers compact layout). */
   isNarrowViewport: boolean;
   /** Switches the viewer to master view mode, preserving the previous mode for restoration. */
@@ -11796,6 +12098,24 @@ interface UseSerializeInput {
   inlineEditingElementIdRef: React$1.MutableRefObject<string | null>;
   inlineEditingTextRef: React$1.MutableRefObject<string>;
   password?: string;
+  /**
+   * File > Fonts > "Embed fonts in the file". `false` passes
+   * `embeddedFontList: null`, which strips `p:embeddedFontLst`, the `/font`
+   * relationships and the `.fntdata` parts; `true` (the default) leaves core to
+   * re-embed whatever the deck arrived with. Before this the toggle reached no
+   * save call at all and the saved bytes were identical either way.
+   */
+  embedFonts?: boolean;
+  /**
+   * Why these bytes are being produced. Defaults to `'user-file'` (Save, Save
+   * As, Export, the imperative `getContent()`), which honours `password`.
+   * `'recovery-snapshot'` is for bytes the viewer reads back itself - the
+   * autosave snapshot and the re-serialise-then-reload cycle - and is always
+   * plaintext, because nothing on the way back in can supply the password.
+   * See `deck-save-encryption` in `pptx-viewer-shared` for the full rationale
+   * and the privacy tradeoff it accepts.
+   */
+  purpose?: DeckSavePurpose;
 }
 declare function useSerialize(input: UseSerializeInput): () => Promise<Uint8Array | null>;
 //#endregion
@@ -11899,6 +12219,12 @@ interface UseIOHandlersInput {
   };
   handlerRef: React$1.RefObject<PptxHandler | null>;
   serializeSlides: () => Promise<Uint8Array | null>;
+  /**
+   * Plaintext serialisation for bytes the viewer feeds straight back into its
+   * own loader. "Apply theme" does exactly that, and the loader has no password
+   * to offer, so it must never receive an encrypted package.
+   */
+  serializeForRecovery: () => Promise<Uint8Array | null>;
   setContent: React$1.Dispatch<React$1.SetStateAction<ArrayBuffer | Uint8Array | null>>;
   onContentChange: ((content: Uint8Array) => void) | undefined;
   password?: string;
@@ -11917,6 +12243,18 @@ interface UseContentLifecycleInput {
   filePath: string | undefined;
   /** AutoSave toggle state; when false the recovery autosave timer is off. */
   autosaveEnabled?: boolean;
+  /**
+   * AutoRecover cadence in seconds, from
+   * `resolveAutosaveIntervalSeconds(File > Options > Save)`. React was the only
+   * binding that never passed one (vanilla, svelte and angular all resolve it),
+   * so the option's number field moved and the timer kept its 120s default.
+   */
+  autosaveIntervalSeconds?: number;
+  /**
+   * File > Fonts > "Embed fonts in the file". Forwarded to `useSerialize`, so
+   * turning it off actually strips the embedded font data on the next save.
+   */
+  embedFonts?: boolean;
   slides: PptxSlide[];
   state: ViewerState;
   history: EditorHistoryResult;
@@ -11929,7 +12267,14 @@ interface UseContentLifecycleInput {
 }
 interface ContentLifecycleResult {
   handlerRef: React$1.RefObject<PptxHandler | null>;
+  /** Serialise for the user: honours "Encrypt with Password". */
   serializeSlides: () => Promise<Uint8Array | null>;
+  /**
+   * Serialise for bytes the viewer reads back itself (autosave snapshot,
+   * re-serialise-then-reload). Always plaintext, so recovery - which has no
+   * password to offer - can actually open them.
+   */
+  serializeForRecovery: () => Promise<Uint8Array | null>;
   autosaveStatus: AutosaveStatus;
 }
 declare function useContentLifecycle(input: UseContentLifecycleInput): ContentLifecycleResult;
@@ -11962,6 +12307,11 @@ interface UseViewerIntegrationInput {
   filePath: string | undefined;
   /** AutoSave toggle state from the title bar. */
   autosaveEnabled: boolean;
+  /**
+   * AutoRecover cadence in seconds, resolved from File > Options > Save.
+   * Optional: omitting it keeps `useAutosave`'s 120s default.
+   */
+  autosaveIntervalSeconds?: number;
   canEdit: boolean;
   mode: ViewerState['mode'];
   slides: PptxSlide[];
@@ -12101,6 +12451,14 @@ interface LayoutSwitchingResult {
   loadAvailableLayouts: () => Promise<void>;
   /** Apply a layout to the active slide by its archive path. */
   applyLayout: (layoutPath: string) => Promise<void>;
+  /**
+   * Build the artwork thumbnails the New Slide / Layout galleries draw.
+   *
+   * Deliberately a callback rather than state: parsing every layout is only
+   * worth doing once the user opens one of those menus, and core memoises the
+   * result so reopening costs nothing.
+   */
+  loadLayoutPreviews: () => Promise<PptxLayoutPreview[]>;
   /** The current slide's layout path (if known). */
   currentLayoutPath: string | undefined;
 }