pptx-svelte-viewer 2.18.0 → 2.20.0

package/dist/viewer/index.d.ts

@@ -183,11 +183,18 @@ interface XmlObject {
   [child: string]: XmlObject | XmlObject[] | string | undefined;
 }
 /**
- * Shape lock attributes from `p:cNvSpPr / a:spLocks`.
+ * Lock attributes from an element's non-visual properties node.
  *
  * When a flag is `true` the corresponding user interaction is disabled
  * in the editor (e.g. `noRotation` prevents free rotation of the shape).
  *
+ * One bag covers every family, but the families are NOT interchangeable in
+ * the file: `a:spLocks` (`CT_ShapeLocking`), `a:picLocks`, `a:cxnSpLocks`,
+ * `a:grpSpLocks` (`CT_GroupLocking`) and `a:graphicFrameLocks`
+ * (`CT_GraphicalObjectFrameLocking`) each declare their own attribute subset.
+ * `runtime/shape-lock-containers` holds that table and is what decides which
+ * of these fields may be written for a given element.
+ *
  * @example
  * ```ts
  * const locks: PptxShapeLocks = { noMove: true, noResize: true };
@@ -206,6 +213,14 @@ interface PptxShapeLocks {
   noAdjustHandles?: boolean;
   noChangeArrowheads?: boolean;
   noChangeShapeType?: boolean;
+  /**
+   * `a:graphicFrameLocks/@noDrilldown`: forbids selecting the individual
+   * parts inside a graphic frame (a chart series, a SmartArt node). Declared
+   * ONLY by `CT_GraphicalObjectFrameLocking`, so it is written for tables,
+   * charts, SmartArt, OLE objects and graphic-frame media, and never onto
+   * `a:spLocks` / `a:picLocks` / `a:cxnSpLocks` / `a:grpSpLocks`.
+   */
+  noDrilldown?: boolean;
   /**
    * Text-box flag from `p:cNvSpPr/@txBox`. Not a lock in the strict sense,
    * but it lives on the same non-visual-properties node as `a:spLocks`, so
@@ -1145,6 +1160,22 @@ interface ShapeStyle {
   fontRefIdx?: string;
   /** Raw XML colour child of `<a:fontRef>`. */
   fontRefColorXml?: XmlObject;
+  /**
+   * The fill `<a:fillRef>` resolved to, recorded ONLY when the shape's own
+   * `spPr` authored no fill at all, so the reference is what paints it.
+   *
+   * Its absence therefore means "the fill is the shape's own", and its
+   * presence plus an unchanged flat fill means "still purely inherited": see
+   * `authored-shape-style.ts`, the shape-scope twin of `TextStyle`'s
+   * `inheritedRunStyle`.
+   */
+  inheritedFillStyle?: ShapeStyle;
+  /**
+   * The outline `<a:lnRef>` resolved to, recorded before `spPr/a:ln` was
+   * layered on top. A property that still equals this baseline was never
+   * authored on the shape and must not be written back as if it were.
+   */
+  inheritedLineStyle?: ShapeStyle;
 }
 //#endregion
 //#region src/core/types/text.d.ts
@@ -1185,6 +1216,60 @@ interface ShapeStyle {
 interface TextStyle {
   /** Original `a:rPr` XML retained by projections that share the shape-text model. */
   runPropertiesXml?: XmlObject;
+  /**
+   * The properties this run's OWN `a:rPr` authored, and nothing else.
+   *
+   * A run style is assembled as
+   * `{...inheritedRunStyle, ...authoredRunStyle}`, so the flat style is a
+   * fully RESOLVED view: it cannot say whether `fontSize: 60` came from the
+   * run, from the shape's `a:lstStyle`, from the layout placeholder, from the
+   * master `p:txStyles` or from the theme. Omission is meaningful in OOXML
+   * (§21.1.2.3), so a writer that re-emits the resolved view converts every
+   * inherited value into an authored one and the deck stops being
+   * theme-driven after one save.
+   *
+   * This is the run-scope twin of {@link TextSegment.paragraphProperties},
+   * which is parsed strictly from the paragraph's own `a:pPr` for the same
+   * reason. Present only for runs that came from a parsed deck; absent for
+   * SDK-built text, where the flat style IS the only description and must be
+   * written out in full.
+   */
+  authoredRunStyle?: TextStyle;
+  /**
+   * The resolved inheritance baseline {@link authoredRunStyle} was layered
+   * on top of (shape `a:lstStyle` -> placeholder -> layout -> master
+   * `p:txStyles` -> theme -> `p:defaultTextStyle`).
+   *
+   * Kept alongside the authored half because the two answer different
+   * questions. The authored half says "the source pinned this"; the baseline
+   * says "this value is what inheritance already produces", which is how an
+   * EDIT is told apart from an inherited value: an editor mutates the flat
+   * style without knowing about either field, so a property that now differs
+   * from the baseline was either authored or edited and must be written,
+   * while one that still matches can be left to inherit.
+   *
+   * Holds a reference to the per-paragraph baseline object rather than a
+   * copy, so carrying it costs one pointer per run.
+   */
+  inheritedRunStyle?: TextStyle;
+  /**
+   * Snapshot of the ELEMENT-scope paragraph geometry (alignment, margins,
+   * indent, line and paragraph spacing, tab stops, rtl, line-break flags) as
+   * the load pipeline resolved it.
+   *
+   * Present only on an `element.textStyle` that came from a parsed deck, and
+   * populated only with the geometry keys. It exists so the save path can
+   * answer one question it otherwise cannot: has the user CHANGED the body's
+   * alignment or indent, or is the value simply what the shape's
+   * `a:lstStyle`, its layout placeholder and the master already produce?
+   * Element-level text panels (`textAdvancedPatch`, `alignPatch` and friends
+   * in `pptx-viewer-shared`) write `element.textStyle` and never touch
+   * `segment.paragraphProperties`, so a diff against this snapshot is the
+   * only way to tell an edit from an inheritance artefact.
+   *
+   * @see element-paragraph-geometry.ts
+   */
+  resolvedParagraphGeometry?: TextStyle;
   fontFamily?: string;
   fontSize?: number;
   /** When true, renderer should shrink text to fit the shape bounds. */
@@ -1849,6 +1934,15 @@ interface PptxElementBase {
   shapeId?: string;
   /** Element name from `cNvPr/@name`. Used for morph transition matching via the `!!` naming convention. */
   name?: string;
+  /**
+   * `p:nvSpPr/p:nvPr/p:ph/@type` (lower-cased) when the shape is a placeholder:
+   * `title`, `ctrtitle`, `body`, `subtitle`, `ftr`, `dt`, `sldnum`, ...
+   *
+   * Captured on load so consumers can tell a footer placeholder from a text box
+   * without re-walking `rawXml`. Absent on non-placeholder shapes and on
+   * SDK-created elements.
+   */
+  placeholderType?: string;
   x: number;
   y: number;
   width: number;
@@ -1909,6 +2003,19 @@ interface PptxTextProperties {
   }>;
   /** Placeholder prompt text inherited from layout/master (e.g. "Click to add title"). Shown as a greyed-out hint when the shape has no user-entered text. */
   promptText?: string;
+  /**
+   * The string {@link text} was INHERITED from, when this is a header / footer /
+   * date / slide-number placeholder whose own body the file leaves empty.
+   *
+   * PowerPoint keeps the footer string on the slide master and writes each
+   * slide's copy of the `ftr` placeholder empty, so the empty body means
+   * "render the master's footer here". Rendering needs the resolved string, but
+   * SAVING it into the slide would pin that slide to today's master text and
+   * silently detach it from the Header & Footer dialog. The save writer
+   * therefore leaves the authored empty body alone while `text` still equals
+   * this value, and writes a genuine per-slide override once it does not.
+   */
+  inheritedPlaceholderText?: string;
   /** Linked text box chain ID from `a:bodyPr > a:linkedTxbx/@id` or `a:txbx > a:linkedTxbx/@id`. Text overflows from one linked frame to the next. */
   linkedTxbxId?: number;
   /** Sequence number within a linked text box chain (0-based). */
@@ -2319,6 +2426,12 @@ interface PptxChartLineStyle {
 }
 /** Marker symbol types for line/scatter chart data points. */
 type PptxChartMarkerSymbol = 'circle' | 'dash' | 'diamond' | 'dot' | 'none' | 'picture' | 'plus' | 'square' | 'star' | 'triangle' | 'x' | 'auto';
+/**
+ * `ST_ScatterStyle` (ECMA-376 §21.2.3.40): how a scatter chart joins its points.
+ * `line`/`lineMarker` connect them with straight segments, `smooth`/
+ * `smoothMarker` with a bezier, `marker`/`none` not at all.
+ */
+type PptxChartScatterStyle = 'none' | 'line' | 'lineMarker' | 'marker' | 'smooth' | 'smoothMarker';
 /** Shape properties extracted from c:spPr for chart formatting. */
 interface PptxChartShapeProps {
   fillColor?: string;
@@ -2520,6 +2633,42 @@ interface PptxChartTreemapOptions {
 interface PptxChartSeries {
   name: string;
   values: number[];
+  /**
+   * Per-series x values from `c:ser/c:xVal` (scatter and bubble series only).
+   *
+   * Every `CT_ScatterSer` / `CT_BubbleSer` carries its OWN `c:xVal`, so two
+   * series in one scatter chart routinely plot against different x ranges (the
+   * normal case for measurement data). Reading the x values off the first
+   * series and reusing them everywhere plotted every series against series 1's
+   * x axis. Absent for category-axis chart kinds, where
+   * {@link PptxChartData.categories} is the x axis.
+   */
+  xValues?: number[];
+  /**
+   * Per-series bubble sizes from `c:ser/c:bubbleSize` (bubble series only),
+   * aligned index-for-index with {@link values}.
+   *
+   * `CT_BubbleSer` carries x, y AND size, so a one-series bubble chart is fully
+   * specified. Absent when the source omits `c:bubbleSize`.
+   */
+  bubbleSizes?: number[];
+  /**
+   * Series-level data-label content flags from `c:ser/c:dLbls`.
+   *
+   * PowerPoint writes the flags a user picks in "Format Data Labels" onto the
+   * SERIES, and leaves the chart-type-level `c:dLbls` all-zero, so reading only
+   * the chart-level group reports "show nothing" for a chart that visibly shows
+   * percentages. These override {@link PptxChartStyle.dataLabels}.
+   */
+  dataLabelOptions?: PptxChartDataLabelOptions;
+  /**
+   * Whether the series line is explicitly suppressed
+   * (`c:ser/c:spPr/a:ln/a:noFill`). Line-drawn kinds (line, scatter, radar)
+   * use this to decide whether to draw a connecting line at all; a marker-only
+   * scatter is authored as `scatterStyle="lineMarker"` PLUS this flag, never by
+   * changing the scatter style.
+   */
+  lineNoFill?: boolean;
   /**
    * Blank-value mask aligned index-for-index with {@link values}: `true` marks
    * a category whose numeric cache point (`c:numCache/c:pt`) was absent or
@@ -2863,6 +3012,17 @@ interface PptxChartData {
    * default), so only horizontal bar charts need to carry the field.
    */
   barDirection?: PptxChartBarDirection;
+  /**
+   * Scatter presentation mode (`c:scatterChart/c:scatterStyle/@val`).
+   *
+   * `lineMarker` (PowerPoint's own default for every scatter it writes) and
+   * `smoothMarker` draw a connecting line; `marker` and `none` do not. Whether
+   * the MARKERS appear is decided separately by `c:marker/c:symbol`, and
+   * whether the LINE appears is further gated by
+   * {@link PptxChartSeries.lineNoFill} - PowerPoint expresses "markers only" as
+   * `lineMarker` plus an `a:ln/a:noFill`, not as `marker`.
+   */
+  scatterStyle?: PptxChartScatterStyle;
   /**
    * Bar/column gap between category clusters as a percentage of bar width
    * (`c:gapWidth/@val`, 0 through 500). Absent uses the renderer default.
@@ -3016,6 +3176,53 @@ interface PptxChartData {
  * // => { brightness: 20, contrast: -10, grayscale: true } satisfies PptxImageEffects
  * ```
  */
+/**
+ * One `a14:foregroundMark` / `a14:backgroundMark` polyline hint recorded while
+ * the user painted over the picture in PowerPoint's "Remove Background" mode.
+ * Coordinates are 0..1 fractions of the image.
+ */
+interface PptxBackgroundRemovalMark {
+  x1: number;
+  y1: number;
+  x2: number;
+  y2: number;
+}
+/**
+ * PowerPoint "Remove Background" state (`a14:backgroundRemoval`).
+ *
+ * The four edges are the RETAINED rectangle as 0..1 fractions of the image
+ * (OOXML stores them as per-100000 relative units), and the mark lists are the
+ * segmentation hints the user painted.
+ *
+ * **This is edit-time metadata, not a render instruction.** PowerPoint bakes the
+ * removal into the bitmap referenced by the main `a:blip/@r:embed` and keeps the
+ * pristine original in `a14:imgLayer/@r:embed`. Verified against PowerPoint COM:
+ * a slide exported with and without this element is byte-identical. A renderer
+ * that clips to the retained rectangle would clip an image whose background has
+ * already been removed.
+ *
+ * @example
+ * ```ts
+ * const removal: PptxBackgroundRemoval = { top: 0.12, bottom: 0.88, left: 0.07, right: 0.93 };
+ * // => retains the middle of the image; the marks list stays empty
+ * ```
+ */
+interface PptxBackgroundRemoval {
+  /** Top edge of the retained rectangle (0..1 fraction of the image height). */
+  top: number;
+  /** Bottom edge of the retained rectangle (0..1 fraction of the image height). */
+  bottom: number;
+  /** Left edge of the retained rectangle (0..1 fraction of the image width). */
+  left: number;
+  /** Right edge of the retained rectangle (0..1 fraction of the image width). */
+  right: number;
+  /** Strokes marking regions the user forced to be foreground. */
+  foregroundMarks?: PptxBackgroundRemovalMark[];
+  /** Strokes marking regions the user forced to be background. */
+  backgroundMarks?: PptxBackgroundRemovalMark[];
+  /** Original effect XML, retained for lossless re-emission. */
+  rawXml?: XmlObject;
+}
 interface PptxImageEffects {
   /** Brightness adjustment (-100 to 100). */
   brightness?: number;
@@ -3039,8 +3246,38 @@ interface PptxImageEffects {
   };
   /** Artistic effect name (blur, pencilGrayscale, paintStrokes, etc.). */
   artisticEffect?: string;
-  /** Artistic effect radius/amount. */
+  /** Artistic effect radius/amount, normalised to 0..100. */
   artisticRadius?: number;
+  /**
+   * Every numeric attribute of the source `a14:artistic*` element, raw and
+   * un-normalised (`trans`, `pencilSize`, `crackSpacing`, …). The attribute set
+   * differs per effect, so this is the lossless companion to the single
+   * {@link PptxImageEffects.artisticRadius} number.
+   */
+  artisticParams?: Record<string, number>;
+  /**
+   * Name of the artistic effect ALREADY baked into the image data, which a
+   * renderer must not apply a second time. Set from the `a14` blip extension,
+   * which PowerPoint writes alongside a pre-rendered bitmap (see
+   * {@link PptxBackgroundRemoval}), and normally equal to
+   * {@link PptxImageEffects.artisticEffect}.
+   *
+   * It records the NAME rather than a boolean so that picking a different
+   * effect in this library's inspector (which patches `artisticEffect` alone)
+   * still renders: the two names then differ.
+   */
+  artisticPrerenderedEffect?: string;
+  /**
+   * PowerPoint "Remove Background" state (`a14:backgroundRemoval`). Edit-time
+   * metadata: the removal is already baked into the image data.
+   */
+  backgroundRemoval?: PptxBackgroundRemoval;
+  /**
+   * `a14:imgLayer/@r:embed` — relationship id of the PRISTINE original image
+   * the baked effects were derived from (PowerPoint stores it as an HD Photo
+   * `.wdp` part, which browsers cannot decode).
+   */
+  originalImageRelId?: string;
   /** Alpha modulation fixed: non-negative percentage (100 means unchanged opacity). */
   alphaModFix?: number;
   /** Original alpha modulation fixed node, including foreign attributes. */
@@ -4952,7 +5189,7 @@ interface UnknownPptxElement extends PptxElementBase {
 /**
  * A single element on a PPTX slide.
  *
- * This is a **discriminated union** — narrow on `element.type` to access
+ * This is a **discriminated union**: narrow on `element.type` to access
  * variant-specific properties like `imageData` (image/picture), `pathData`
  * (shape), or `textSegments` (text/shape).
  */
@@ -5695,6 +5932,54 @@ interface PptxEmbeddedFontList {
   rawXml?: XmlObject;
 }
 //#endregion
+//#region src/core/types/comment-mentions.d.ts
+/**
+ * A single `@`-mention inside a modern comment body.
+ *
+ * Offsets index into the comment's FLATTENED plain text: every `a:t` value
+ * below `p188:txBody` concatenated, with paragraphs joined by `\n`. That is the
+ * same string `PptxComment.text` carries, so an edit to `text` invalidates
+ * every offset after the edit point and the serializer re-bases them.
+ *
+ * The markup Office uses for a mention is `CT_Mention` (documented for the
+ * SpreadsheetML `2018/threadedcomments` part): `mentionpersonId`, `mentionId`,
+ * `startIndex` and `length`. The PowerPoint `2018/8/main` schema does not
+ * publish a mention element at all, so `rawXml` is retained and re-emitted
+ * attribute-for-attribute: a producer that spells the attributes differently
+ * still round-trips.
+ *
+ * @example
+ * ```ts
+ * const mention: PptxCommentMention = {
+ *   personId: "{2CB2E9D0-D392-EB21-5D46-FBA34C1295E6}",
+ *   authorName: "Bob Example",
+ *   startIndex: 3,
+ *   length: 11,
+ * };
+ * // => "Hi Bob Example can you check this".slice(3, 14) === "Bob Example"
+ * ```
+ */
+interface PptxCommentMention {
+  /** `mentionId`: GUID identifying this mention instance. */
+  id?: string;
+  /** `mentionpersonId`: the `p188:author` id of the mentioned person. */
+  personId: string;
+  /** Display name resolved from the author list at parse time, when known. */
+  authorName?: string;
+  /** Character offset of the mentioned span in the flattened plain text. */
+  startIndex: number;
+  /** Character length of the mentioned span. */
+  length: number;
+  /**
+   * `uri` of the `p188:ext` this mention list was read from. Undefined means
+   * the list is a direct child of `p188:cm`, which is where it is written for
+   * newly authored mentions.
+   */
+  containerUri?: string;
+  /** Original `p188:mention` node, retained for unknown-attribute preservation. */
+  rawXml?: XmlObject;
+}
+//#endregion
 //#region src/core/types/metadata.d.ts
 /**
  * A slide comment — may be a legacy positional comment or a modern
@@ -5741,6 +6026,8 @@ interface PptxComment {
   title?: string;
   /** Modern threaded comment support (p15:threadingInfo). */
   threadId?: string;
+  /** `@`-mentions, indexed into `text` (see {@link PptxCommentMention}). */
+  mentions?: PptxCommentMention[];
   /** Replies to this comment (for modern threaded comments). */
   replies?: PptxComment[];
   /** ID of the element this comment is associated with (if any). */
@@ -6260,7 +6547,7 @@ interface PptxTheme {
  * // => "morph" — one of 40+ transition effects
  * ```
  */
-type PptxTransitionType = 'none' | 'cut' | 'fade' | 'push' | 'wipe' | 'split' | 'randomBar' | 'blinds' | 'checker' | 'circle' | 'comb' | 'cover' | 'diamond' | 'dissolve' | 'plus' | 'pull' | 'random' | 'strips' | 'uncover' | 'wedge' | 'wheel' | 'zoom' | 'newsflash' | 'morph' | 'conveyor' | 'doors' | 'ferris' | 'flash' | 'flythrough' | 'gallery' | 'glitter' | 'honeycomb' | 'pan' | 'prism' | 'reveal' | 'ripple' | 'shred' | 'switch' | 'vortex' | 'warp' | 'wheelReverse' | 'window' | 'cube' | 'flip' | 'rotate' | 'orbit' | 'fallOver' | 'drape' | 'curtains' | 'wind' | 'prestige' | 'fracture' | 'crush' | 'peelOff' | 'pageCurlDouble' | 'pageCurlSingle' | 'airplane' | 'origami';
+type PptxTransitionType = 'none' | 'cut' | 'fade' | 'push' | 'wipe' | 'split' | 'randomBar' | 'blinds' | 'checker' | 'circle' | 'comb' | 'cover' | 'diamond' | 'dissolve' | 'plus' | 'pull' | 'random' | 'strips' | 'uncover' | 'wedge' | 'wheel' | 'zoom' | 'newsflash' | 'morph' | 'conveyor' | 'doors' | 'ferris' | 'flash' | 'flythrough' | 'gallery' | 'glitter' | 'honeycomb' | 'pan' | 'prism' | 'reveal' | 'ripple' | 'shred' | 'switch' | 'vortex' | 'warp' | 'wheelReverse' | 'window' | 'cube' | 'flip' | 'rotate' | 'box' | 'orbit' | 'fallOver' | 'drape' | 'curtains' | 'wind' | 'prestige' | 'fracture' | 'crush' | 'peelOff' | 'pageCurlDouble' | 'pageCurlSingle' | 'airplane' | 'origami';
 /** Split orientation from OOXML `@_orient`. */
 type PptxSplitOrientation = 'horz' | 'vert';
 /** Schema-defined `ST_TransitionSpeed` values. */
@@ -6555,6 +6842,18 @@ interface PptxSlideBackgroundPattern {
 interface PptxSlide {
   id: string;
   rId: string;
+  /**
+   * `p:sldIdLst/p:sldId/@id` (ST_SlideId, 256..2147483647): the numeric key
+   * that sections (`p14:sldIdLst/p14:sldId/@id`) and section/summary zooms
+   * name slides by.
+   *
+   * It lives in `presentation.xml`, NOT in the slide part, so it cannot be
+   * recovered from `rawXml`. Without it on the model, code that writes a
+   * section's membership has nothing correct to write and falls back to the
+   * slide NUMBER, which is 1-based and therefore never matches a real deck's
+   * ids: the section reloads with no slides in it.
+   */
+  slideId?: string;
   sourceSlideId?: string;
   /** Optional author-supplied slide name (set via `SlideBuilder.setName`). */
   name?: string;
@@ -6757,6 +7056,26 @@ interface PptxPresentationProperties {
   /** Kiosk auto-restart interval in milliseconds (from `p:kiosk/@restart`). Only meaningful when showType is "kiosk". */
   kioskRestartTime?: number;
 }
+/**
+ * Slide dimensions from `p:sldSz` (CT_SlideSize, ECMA-376 §19.2.1.39).
+ *
+ * @example
+ * ```ts
+ * const size: PptxSlideSize = { widthEmu: 9144000, heightEmu: 6858000, type: 'screen4x3' };
+ * // => satisfies PptxSlideSize
+ * ```
+ */
+interface PptxSlideSize {
+  /** `@cx` in EMU. Omitted or non-positive values leave the loaded width alone. */
+  widthEmu?: number;
+  /** `@cy` in EMU. Omitted or non-positive values leave the loaded height alone. */
+  heightEmu?: number;
+  /**
+   * `@type` (ST_SlideSizeType). The schema default is `custom`, which is
+   * why PowerPoint omits the attribute for a non-preset size.
+   */
+  type?: string;
+}
 /**
  * A named custom slide show (`p:custShowLst / p:custShow`).
  *
@@ -7771,6 +8090,19 @@ interface PptxHandlerSaveOptions {
   customerData?: PptxCustomerData[];
   /** Photo album metadata to save back to `p:photoAlbum`. */
   photoAlbum?: PptxPhotoAlbum;
+  /**
+   * Slide dimensions to write back to `p:sldSz`.
+   *
+   * Omitting the option preserves the load-time dimensions verbatim, which
+   * is why an edit made through a viewer's Slide Size control has to reach
+   * the save call: nothing else in the pipeline can observe it.
+   *
+   * PowerPoint derives `Presentation.PageSetup.SlideSize` from `@cx`/`@cy`
+   * alone (verified by COM: an A4-typed `p:sldSz` carrying 4:3 dimensions
+   * still reports `ppSlideSizeCustom`), so `type` is written for fidelity
+   * but the dimensions are what actually decide the reported preset.
+   */
+  slideSize?: PptxSlideSize;
   /** East Asian line-break settings to save back to `p:kinsoku`. */
   kinsoku?: PptxKinsoku | null;
   /** Write-protection verifier. Set to `null` to remove, `undefined` to preserve existing. */
@@ -8362,24 +8694,38 @@ declare class PptxHandlerCore {
     name?: string;
   }>>;
   /**
-   * Export selected slides as individual PPTX files.
+   * Export selected slides to a vector or raster format, keyed by slide index.
+   *
+   * **This does not produce PPTX files.** The previous version of this comment
+   * said each entry was "a standalone PPTX with only that slide", named the
+   * option `slideIndexes` (the real field is `slideIndices`), and wrote the
+   * bytes to `slide_N.pptx`. None of that was ever true: the runtime has
+   * always taken a `format` of `svg` / `png` / `pdf`. Per-slide PPTX
+   * extraction is a different operation and is not implemented here.
    *
-   * Each entry in the returned map is keyed by slide index and contains a
-   * standalone `Uint8Array` PPTX with only that slide.
+   * Only `svg` works without a host-supplied backend, and it works fully:
+   * the headless {@link SvgExporter} renders it with no DOM. `png` and `pdf`
+   * THROW, because this package carries no rasteriser; use a viewer binding's
+   * browser export pipeline, or override `exportSlides` on the runtime with
+   * your own backend.
    *
    * @param slides  - Full slide array.
-   * @param options - Export options (slide indexes, format, etc.).
-   * @returns A `Map<slideIndex, Uint8Array>` of exported files.
+   * @param options - Export options (`format`, `slideIndices`, `width`, ...).
+   * @returns A `Map<slideIndex, Uint8Array>` of exported files. Hidden slides
+   *   are omitted unless `options.includeHidden` is set, so the map can be
+   *   smaller than `options.slideIndices`.
+   * @throws {Error} when `options.format` is `png` or `pdf`.
    *
    * @example
    * ```ts
    * const exports = await handler.exportSlides(data.slides, {
-   *   slideIndexes: [0, 2],
+   *   format: 'svg',
+   *   slideIndices: [0, 2],
    * });
    * for (const [idx, bytes] of exports) {
-   *   await fs.writeFile(`slide_${idx}.pptx`, Buffer.from(bytes));
+   *   await fs.writeFile(`slide_${idx}.svg`, Buffer.from(bytes));
    * }
-   * // => Map<number, Uint8Array> — one standalone .pptx per exported slide
+   * // => Map<number, Uint8Array>: one SVG document per exported slide
    * ```
    */
   exportSlides(slides: PptxSlide[], options: PptxExportOptions): Promise<Map<number, Uint8Array>>;
@@ -8939,16 +9285,71 @@ interface FieldSubstitutionContext {
   /** Title text extracted from the first title placeholder on the slide. */
   slideTitle?: string;
 }
-/** Descriptor for the draggable adjustment handle (the amber diamond). */
+//#endregion
+//#region src/render/connector-endpoints.d.ts
+/** Which end of a connector a gesture is moving. */
+type ConnectorEndpointKind = 'start' | 'end';
+//#endregion
+//#region src/render/shape-adjustment-model.d.ts
+/**
+ * `shape-adjustment-model`: the vocabulary the adjust-handle modules share.
+ *
+ * The `a:ahLst` work is split three ways for the repo's file-size budget:
+ * `shape-adjustment-probe` measures the geometry, `shape-adjustment-handles`
+ * derives the handles from those measurements, and `shape-adjustment-solver`
+ * turns a pointer position back into guide values. All three need these types
+ * and the one rule that operates purely on them, so they live here and the
+ * dependency graph stays a DAG rather than a cycle.
+ *
+ * @module render/shape-adjustment-model
+ */
+/**
+ * How a pointer position becomes a guide value, captured once when the gesture
+ * starts so `pointermove` stays pure arithmetic.
+ */
+interface ShapeAdjustmentSolver {
+  /** `linear`: the handle slides. `angular`: it swings about {@link centerX}. */
+  kind: 'linear' | 'angular';
+  /** Handle position in element-local px at {@link startValue}. */
+  anchorX: number;
+  anchorY: number;
+  /** Element-local px the handle travels per ONE unit of guide value. */
+  dirX: number;
+  dirY: number;
+  /** Pivot for an angular handle (the shape centre). */
+  centerX: number;
+  centerY: number;
+  /** The guide value the anchor was measured at. */
+  startValue: number;
+  /** Guide-space bounds, taken from the preset's own `pin` clamp. */
+  min: number;
+  max: number;
+}
+/** One guide a handle drives. */
+interface AdjustmentAxisSolver {
+  key: string;
+  solver: ShapeAdjustmentSolver;
+}
+/** Descriptor for one draggable adjustment handle (the amber diamond). */
 interface ShapeAdjustmentHandleDescriptor {
+  /** The `a:avLst` guide name this handle writes (`adj`, `adj1`, ...). */
   key: string;
   /** Handle x offset in element-local px (origin = element top-left). */
   left: number;
   /** Handle y offset in element-local px. */
   top: number;
-  /** Current adjustment value (0–50000). */
+  /**
+   * Current adjustment value in GUIDE units, not a 0-1 fraction. Most presets
+   * range 0..50000 or 0..100000 and the angular ones run to 21,600,000.
+   */
   value: number;
   cursor: string;
+  /**
+   * How this handle's drag resolves, measured off the preset geometry: one
+   * entry per `a:avLst` guide it drives (callouts drive two). Absent only for
+   * a caller that built a descriptor by hand.
+   */
+  solvers?: AdjustmentAxisSolver[];
 }
 //#endregion
 //#region src/render/collaboration-presence.d.ts
@@ -9142,6 +9543,12 @@ interface ViewerFontSource {
   weight?: string | number;
   style?: 'normal' | 'italic';
 }
+interface SlideSizeEmu {
+  widthEmu: number;
+  heightEmu: number;
+  /** ST_SlideSizeType token, or `''` for a size with no preset. */
+  type: string;
+}
 /** The configuration emitted when a broadcast starts. */
 interface BroadcastConfig {
   roomId: string;
@@ -9259,6 +9666,93 @@ interface FontEmbeddingDescriptor {
 declare function zoomInPercent(percent: number): number;
 /** The percentage one zoom-out press moves to, clamped. */
 declare function zoomOutPercent(percent: number): number;
+//#endregion
+//#region src/render/autosave-policy.d.ts
+/**
+ * @fileoverview Who decides whether recovery autosave runs, and how often.
+ *
+ * ## The rule: the host prop is a ceiling, the toggle is a preference
+ *
+ * Two things can speak about autosave, and until now each binding invented its
+ * own answer for what happens when both do:
+ *
+ *  - the **host** passes an `autosave` prop. That is a POLICY: the embedder is
+ *    stating what its application permits.
+ *  - the **user** flips the title-bar AutoSave switch, or File > Options > Save
+ *    > AutoSave. That is a PREFERENCE, expressed inside whatever the host allows.
+ *
+ * A preference can never exceed a policy, so:
+ *
+ *  - `autosave={false}` turns recovery autosave OFF and takes the toggle away
+ *    (`toggleAvailable: false`). A user cannot switch on what the application
+ *    forbade, and a switch that silently does nothing is worse than no switch.
+ *  - `autosave={true}`, or the prop omitted entirely, PERMITS autosave. The
+ *    user's toggle then decides, and it defaults to on.
+ *
+ * The prop is therefore only load-bearing when it is `false`. That is
+ * deliberate: crash recovery that is off by default is crash recovery nobody
+ * has, and the shared options schema already declares `save.autoSave: true` as
+ * the user default, so any other prop default would contradict it. Vue, Svelte
+ * and Vanilla previously defaulted to `false` and React and Angular to `true`;
+ * `true` is the answer, and the three that defaulted off now write recovery
+ * snapshots for hosts that never opted in. Pass `autosave={false}` to opt out.
+ *
+ * Two further gates are not negotiable by anyone, because without them there is
+ * nothing to write or nowhere to write it: editing must be possible at all, and
+ * a `filePath` must be set to key the IndexedDB record.
+ *
+ * ## Cadence follows the same rule
+ *
+ * An explicit `autosaveIntervalMs` prop is a policy and is honoured as given.
+ * Otherwise the cadence is the user's own File > Options > Save > "Save
+ * AutoRecover information every N minutes" (default two minutes), which React
+ * and Angular already respected and the other three ignored.
+ *
+ * ## What the two engine shapes must agree on
+ *
+ * React and Angular POLL on a fixed interval; Vue, Svelte and Vanilla DEBOUNCE
+ * on the edit. Both are legitimate, but a plain debounce has a failure mode a
+ * poll does not: a user who keeps editing keeps re-arming the timer, so it can
+ * defer a snapshot forever, and at the two-minute cadence that is an entire
+ * session of lost work. {@link nextAutosaveDelayMs} caps the debounce so both
+ * shapes make the same promise:
+ *
+ *   **a snapshot lands no later than one interval after the first unsaved edit,
+ *   and no more often than once per interval.**
+ *
+ * @module render/autosave-policy
+ */
+/**
+ * Why autosave is not running. `autosave_toggle_off` and `no_file_path` are the
+ * codes the title bar has always understood; the other two are new and fall
+ * back to the generic message in bindings that do not map them.
+ */
+type AutosaveDisabledReason = 'autosave_host_off' | 'autosave_toggle_off' | 'no_file_path' | 'read_only';
+/** Everything a binding needs to render the recovery dialog, and nothing else. */
+interface AutosaveRecoveryPrompt {
+  /** IndexedDB key the snapshot is stored under (the deck's file path/name). */
+  readonly filePath: string;
+  /** When the snapshot was written (epoch ms). */
+  readonly timestamp: number;
+  /** Snapshot size in bytes. */
+  readonly size: number;
+  /** Whole minutes since it was written, floored at 0. */
+  readonly ageMinutes: number;
+  readonly titleKey: string;
+  readonly messageKey: string;
+  /** `size` is pre-formatted here because byte units are not translated. */
+  readonly messageParams: {
+    readonly file: string;
+    readonly size: string;
+  };
+  /** Relative age, reusing the existing autosave age keys. */
+  readonly ageKey: string;
+  readonly ageParams: {
+    readonly count: number;
+  };
+  readonly restoreKey: string;
+  readonly discardKey: string;
+}
 /**
  * Why the deck is being serialised, which is a separate question from whether
  * the user protected it.
@@ -9425,13 +9919,25 @@ interface ViewerProofingOptions {
   checkSpellingAsYouType: boolean;
   hideSpellingErrors: boolean;
 }
+/**
+ * File > Options > Save.
+ *
+ * Font embedding deliberately has NO entry here. It is owned by the File >
+ * Fonts panel, whose toggle is the one the save path reads (see
+ * `render/font-embedding`: `describeFontEmbedding` decides the toggle's start
+ * position and whether it can do anything at all, `embeddedFontSaveOptions`
+ * turns it into the `PptxHandler.save()` slice). This group used to carry a
+ * second `embedFonts` boolean, plus an `embedAllFontCharacters` companion, and
+ * neither was read by anything: the pane moved a switch that changed no saved
+ * byte, while the panel next door moved the real one. Two switches for one
+ * setting, one of them lying, is worse than one switch in a less
+ * PowerPoint-shaped place.
+ */
 interface ViewerSaveOptions {
   autoSave: boolean;
   autoRecoverIntervalMinutes: number;
   keepLastAutoRecoveredVersion: boolean;
   defaultExportFormat: DefaultExportFormat;
-  embedFonts: boolean;
-  embedAllFontCharacters: boolean;
   cacheRetentionDays: number;
   clearCacheOnClose: boolean;
 }
@@ -10168,13 +10674,28 @@ interface PowerPointViewerProps {
     /** Host override for the File > Open action. */
     onopenfile?: () => void;
     /**
-     * Enable debounced crash-recovery autosave. On each edit (when `editable`)
-     * the current slides are serialized to `.pptx` bytes and written to the
-     * shared IndexedDB recovery store (keyed by {@link filePath}), and
-     * `onautosave` is fired with the bytes. Requires `filePath`; without one the
-     * autosave indicator reads "disabled". This binding does not auto-restore on
-     * load; recovery is a host concern (see the re-exported `getAutosaveSnapshot`
-     * / `listAutosaveSnapshots` helpers). Default false.
+     * POLICY CEILING for crash-recovery autosave. Not a switch the host flips on
+     * the user's behalf: it states what this application permits, and the
+     * title-bar AutoSave toggle (and File > Options > Save > AutoSave) is the
+     * user's preference inside it.
+     *
+     *  - `false` turns autosave off AND renders the toggle off and inert; a user
+     *    cannot switch on what the application forbade.
+     *  - `true`, or omitted, PERMITS autosave and lets the toggle decide.
+     *
+     * While active, each edit serializes the current slides to `.pptx` bytes,
+     * writes them to the shared IndexedDB recovery store (keyed by
+     * {@link filePath}) and fires `onautosave`. A snapshot lands no later than
+     * one interval after the first unsaved edit, and no more often than once per
+     * interval. Requires `filePath`; without one the indicator reads "disabled".
+     *
+     * On the next load of the same `filePath` the viewer OFFERS the snapshot back
+     * in a "Recover unsaved changes?" dialog (Restore loads it in place, Discard
+     * deletes it), unless this prop is `false`. The store is also reachable
+     * directly through the re-exported `getAutosaveSnapshot` /
+     * `listAutosaveSnapshots` helpers.
+     *
+     * @default true
      */
     autosave?: boolean;
     /** Fired when the desktop title bar toggles AutoSave for this viewer instance. */
@@ -10184,7 +10705,16 @@ interface PowerPointViewerProps {
      * Autosave is inert until this is set.
      */
     filePath?: string;
-    /** Autosave debounce window in milliseconds. Default 2000. */
+    /**
+     * Autosave cadence in milliseconds: the debounce window, and the ceiling on
+     * how long an unbroken stream of edits may defer a snapshot.
+     *
+     * Optional, and a policy like {@link autosave}: pass it and it wins. Leave it
+     * out and the cadence is the user's own File > Options > Save > "Save
+     * AutoRecover information every N minutes", which defaults to two minutes.
+     *
+     * @default 120000 (Options > Save, "every 2 minutes")
+     */
     autosaveIntervalMs?: number;
     /** Fired with the serialized `.pptx` bytes after each successful autosave. */
     onautosave?: (bytes: Uint8Array) => void;
@@ -10310,6 +10840,8 @@ interface SlideCanvasProps {
     ontablecellcommit?: (elementId: string, rowIndex: number, cellIndex: number, text: string) => void;
     onsmartartnodecommit?: (elementId: string, nodeId: string, text: string) => void;
     onsmartartnodefill?: (elementId: string, nodeId: string, fill: string) => void;
+    /** See `ElementRendererProps.onchartpointcommit`. */
+    onchartpointcommit?: (elementId: string, chartData: PptxChartData) => void;
     /** Passed through to `SlideStage`; see {@link SlideStageProps.comments}. */
     comments?: readonly PptxComment[];
     /** Passed through to `SlideStage`; see {@link SlideStageProps.oncommentmarkerclick}. */
@@ -10414,6 +10946,13 @@ declare class ExportUiState {
  *  - Vue's debounce-on-edit trigger: an edit marks the document dirty and
  *    (re)arms a debounce timer instead of polling on a fixed interval.
  *
+ * The debounce is CAPPED by the shared `nextAutosaveDelayMs`, so it keeps the
+ * same promise React's and Angular's polling engines do: a snapshot lands no
+ * later than one interval after the FIRST unsaved edit, and no more often than
+ * once per interval. Without that cap a user who keeps typing keeps re-arming
+ * the timer, and at the two-minute AutoRecover cadence that is a whole session
+ * of work that never reaches the recovery store.
+ *
  * The controller registers its own edit-watching `$effect` in the constructor,
  * so the SFC only has to construct it once during setup and read its reactive
  * `status` / `isDirty` for the toolbar indicator.
@@ -10429,9 +10968,13 @@ declare class ExportUiState {
  */
 type AutosaveStatus = 'idle' | 'disabled' | 'saving' | 'saved' | 'error';
 interface AutosaveDeps {
-    /** Master on/off: host `autosave` prop AND editing allowed. */
+    /**
+     * Master on/off: the resolved activation (`resolveAutosaveActivation` in
+     * shared), which folds the host policy, the user's toggle, editability and
+     * the collaboration read-only veto into one answer.
+     */
     getEnabled: () => boolean;
-    /** Debounce window in milliseconds. */
+    /** Debounce window in milliseconds, and the ceiling on deferring a save. */
     getIntervalMs: () => number;
     /** IndexedDB record key (host `filePath`); autosave is disabled without one. */
     getFilePath: () => string | undefined;
@@ -10456,6 +10999,19 @@ interface AutosaveDeps {
      * a user edit), so the watcher clears dirty instead of arming a save.
      */
     getLoadCount: () => number;
+    /**
+     * Monotonic SEED counter, bumped in the same synchronous block that installs
+     * the loaded slides (`EditorState.seedNonce`).
+     *
+     * `getLoadCount` alone is not enough, because the loader bumps it in an
+     * earlier flush than the effect that copies its slides into the editor: this
+     * watcher ran once on the count change (old slides, so nothing to do) and
+     * then a second time on the slide reassignment, with the count already
+     * settled - indistinguishable from an edit. Merely OPENING a deck therefore
+     * marked it dirty and wrote a crash-recovery snapshot, so the next visit
+     * offered to recover unsaved changes that never existed.
+     */
+    getSeedNonce?: () => number;
     /** Host callback with the freshly-serialized bytes on each successful save. */
     onSaved?: (bytes: Uint8Array) => void;
 }
@@ -10870,6 +11426,17 @@ declare class EditorPresentationMetadata {
     presentationProperties: PptxPresentationProperties;
     customShows: PptxCustomShow[];
     constructor(host: PresentationMetadataHost);
+    /**
+     * Deep-copy a value that may be a rune PROXY.
+     *
+     * The dialogs build their edits in `$state`, so what reaches these setters is
+     * a reactive proxy, and `structuredClone` throws `DataCloneError` on one. The
+     * Header & Footer panel hit exactly that: "Apply to All" threw before it ever
+     * assigned, so setting a footer silently did nothing and the canvas kept the
+     * string the deck was loaded with. `$state.snapshot` is a pass-through for a
+     * plain object, so this is safe for every caller.
+     */
+    private static clone;
     set(headerFooter?: PptxHeaderFooter, presentationProperties?: PptxPresentationProperties, customShows?: PptxCustomShow[]): void;
     updatePresentationProperties(next: PptxPresentationProperties): void;
     updateHeaderFooter(next: PptxHeaderFooter): void;
@@ -11058,6 +11625,13 @@ declare class TableCellSelection {
 interface EditorStateDeps {
     getCurrent(): number;
     getHandler(): PptxHandler | null;
+    /**
+     * The `p:sldSz` a save should write, resolved from the viewer's EMU slide
+     * size and its pixel canvas by the shared `resolveSlideSizeSelection`.
+     * Optional so out-of-tree mounts (and the unit tests) can omit it, in which
+     * case core re-emits the load-time dimensions verbatim.
+     */
+    getSlideSize?: () => PptxSlideSize | undefined;
     onChange?: () => void;
 }
 declare class EditorState {
@@ -11112,6 +11686,20 @@ declare class EditorState {
     readonly tableCells: TableCellSelection;
     editable: boolean;
     dirty: boolean;
+    /**
+     * Monotonic counter bumped by {@link setSlides}, i.e. every time a freshly
+     * loaded deck is installed as the working document.
+     *
+     * It exists because the loader's own `loadCount` is bumped in an EARLIER
+     * flush than the one that writes these slides: the seeding effect
+     * (`viewer-effects.svelte.ts`) reacts to `loadCount`, so by the time it calls
+     * `setSlides` the autosave effect has already run once, seen the new count
+     * against the old slides, and settled. The slide reassignment that followed
+     * then looked exactly like a user edit, and merely OPENING a deck wrote a
+     * crash-recovery snapshot. This counter changes in the SAME synchronous block
+     * as the slides it describes, so the reseed can never be misread again.
+     */
+    seedNonce: number;
     editTemplateMode: boolean;
     interactionActive: boolean;
     clipboard: ElementClipboardPayload | null;
@@ -11155,6 +11743,13 @@ declare class EditorState {
     /** The loaded core handler, or null before a deck is open. Used by the
      *  Slides group for layout switching (`applyLayoutToSlide`). */
     getHandler(): PptxHandler | null;
+    /**
+     * The `p:sldSz` the next save should write, or undefined to leave the
+     * load-time dimensions alone. Slide size lives on the loader (it is not
+     * content the undo stack owns), so it reaches the save through this dep the
+     * same way the handler does.
+     */
+    getSlideSize(): PptxSlideSize | undefined;
     /** Adopt a freshly loaded deck as the working document (see `loadEditorDocument`). */
     setSlides(...args: LoadDocumentArgs): void;
     /** Adopt a remote (collaboration) snapshot; see `applyRemoteEditorSlides`. */
@@ -11310,6 +11905,11 @@ interface EditorControllerDeps {
     toggleShortcuts?(): void;
     /** Close the cheat sheet on Escape; true when it was open (Escape consumed). */
     closeShortcuts?(): boolean;
+    /**
+     * Open or close the find bar (Ctrl/Cmd+F). Like the cheat sheet, the panel is
+     * shell-owned UI state, so the controller only signals the intent.
+     */
+    toggleFind?(): void;
 }
 
 interface EditorMarqueeRect extends MarqueeRect {
@@ -11336,8 +11936,13 @@ interface SelectionInteractivity {
     resizable: boolean;
     /** Draw (and honour) the rotate stem + knob. */
     rotatable: boolean;
-    /** The amber adjustment diamond, or null when there is none to draw. */
-    adjust: ShapeAdjustmentHandleDescriptor | null;
+    /**
+     * The amber adjustment diamonds, one per `a:avLst` guide. Empty when there
+     * is none to draw; PowerPoint shows several on most presets (`quadArrow`
+     * three, `callout3` four), and offering only the first left the rest
+     * unreachable.
+     */
+    adjust: ShapeAdjustmentHandleDescriptor[];
 }
 
 declare class EditorController {
@@ -11346,6 +11951,8 @@ declare class EditorController {
     editingId: string | null;
     marquee: EditorMarqueeRect | null;
     constructor(editor: EditorState, deps: EditorControllerDeps);
+    /** The elements the pointer acts on (slide, or master/layout), for overlays. */
+    get activeElements(): PptxElement[];
     get overlayBox(): OverlayBox | null;
     /**
      * Which selection chrome the authored `a:spLocks` still permit, plus the
@@ -11365,7 +11972,16 @@ declare class EditorController {
     onStageContextMenu: (event: MouseEvent) => void;
     onHandlePointerDown: (handle: ResizeHandleId, event: PointerEvent) => void;
     onRotatePointerDown: (event: PointerEvent) => void;
-    onAdjustPointerDown: (event: PointerEvent) => void;
+    onAdjustPointerDown: (event: PointerEvent, descriptor: ShapeAdjustmentHandleDescriptor) => void;
+    /** Live connector-endpoint drag position in SLIDE px, or null when idle. */
+    connectorEndpointDrag: {
+        kind: ConnectorEndpointKind;
+        x: number;
+        y: number;
+    } | null;
+    /** The selected connector, when exactly one connector is selected. */
+    get selectedConnector(): PptxElement | null;
+    onConnectorEndpointPointerDown: (kind: ConnectorEndpointKind, event: PointerEvent) => void;
     onKeyDown: (event: KeyboardEvent) => void;
     /** Open the inline text editor over `id` when the element carries text. */
     enterInlineEdit(id: string): void;
@@ -11708,6 +12324,17 @@ declare class PresentationLoader {
     themeOptions: PptxThemeOption[];
     /** Slide canvas size in pixels. */
     canvasSize: CanvasSize;
+    /**
+     * The deck's `p:sldSz` in EMU, seeded from the parse and re-written by the
+     * inspector's Slide Size preset / orientation controls.
+     *
+     * Held alongside {@link canvasSize} rather than derived from it because the
+     * pixel size is lossy: Ledger is 12179300 EMU (1278.5px), so a round-trip
+     * through an integer pixel would move it 6350 EMU and cost the deck its
+     * `ppSlideSizeLedgerPaper` identity. `resolveSlideSizeSelection` decides
+     * which of the two wins at save time.
+     */
+    slideSize: SlideSizeEmu | undefined;
     /** Archive-path -> displayable URL map for media + poster frames. */
     mediaDataUrls: Map<string, string>;
     /** Presentation theme colours used to resolve scheme-based table styles. */
@@ -12168,6 +12795,53 @@ declare class PresenterSession {
     private getChannel;
 }
 
+/**
+ * autosave-recovery.svelte.ts: offer the crash-recovery snapshot back.
+ *
+ * This binding has always WRITTEN recovery snapshots (see `autosave.svelte.ts`)
+ * and never once offered one back, so the whole feature was invisible: the user
+ * lost a tab mid-edit, reopened the deck, and silently got the pre-crash work
+ * thrown away. Every decision (is it worth probing, is the snapshot fresh
+ * enough, has this tab already taken delivery of it, what should the prompt
+ * say) lives in `pptx-viewer-shared`'s `render/autosave-recovery` so all five
+ * bindings ask the same questions in the same order; this class is only the
+ * runes wiring plus the two actions.
+ *
+ * It registers its own probing `$effect` in the constructor, exactly like
+ * {@link AutosaveController}, so a caller only has to construct it during
+ * component initialisation and render `prompt` when it is non-null.
+ */
+interface AutosaveRecoveryDeps {
+    /** IndexedDB record key (host `filePath`). Nothing to look up without one. */
+    getFilePath: () => string | undefined;
+    /**
+     * Whether recovery snapshots are permitted at all, which is the HOST prop
+     * (`autosave !== false`) and not the user's toggle: someone who merely
+     * switched AutoSave off should still be offered the pre-crash snapshot that
+     * was written while it was on.
+     */
+    getAutosaveAllowed: () => boolean;
+    getLoading: () => boolean;
+    getError: () => string | null;
+    getSlideCount: () => number;
+    /** Monotonic load counter: the probe runs once per loaded deck. */
+    getLoadCount: () => number;
+    /** The loader's own load path, the same one the backstage recent list uses. */
+    load: (bytes: Uint8Array) => Promise<void> | void;
+}
+declare class AutosaveRecoveryController {
+    #private;
+    /** The prompt to render, or null when there is nothing to recover. */
+    prompt: AutosaveRecoveryPrompt | null;
+    constructor(deps: AutosaveRecoveryDeps);
+    /** Take the snapshot: mark it consumed, then load its bytes in place. */
+    restore(): Promise<void>;
+    /** Decline the snapshot: delete it, and never load it. */
+    discard(): Promise<void>;
+    /** Close the prompt without touching the stored snapshot. */
+    dismiss(): void;
+}
+
 /** One element ring to draw on the canvas: an explicit pick or a live-tool focus. */
 interface AiCanvasHighlight {
     slideIndex: number;
@@ -12299,10 +12973,12 @@ declare class ViewerOptionsState {
     /** Accessibility > "feedback with sound" cue for a completed action. */
     playFeedback(): void;
     /**
-     * Autosave debounce in ms: the host prop until the user picks a custom
-     * AutoRecover cadence in Options > Save, which then takes over.
+     * Options > Save > "Save AutoRecover information every N minutes", in
+     * seconds. The autosave cadence whenever the host passed no explicit
+     * `autosaveIntervalMs`; the host-vs-user precedence itself is decided by
+     * `resolveAutosaveIntervalMs` in shared, not re-invented here.
      */
-    autosaveDebounceMs(hostIntervalMs: number, defaultMinutes: number): number;
+    get autosaveIntervalSeconds(): number;
     /** Options > Save > "Delete cached files": drop all recovery snapshots. */
     clearCache(): Promise<void>;
     dispose(): void;
@@ -12321,6 +12997,48 @@ declare class CompareController {
     acceptAll(): void;
 }
 
+/** Which tool's colour palette is currently open, if any. */
+type PresentPaletteKey = 'pen' | 'highlighter';
+/** DOM getters {@link PresentToolbarChrome.attach} needs from the component. */
+interface PresentToolbarChromeTargets {
+    /**
+     * The positioned show surface the bar floats over. Used only for the
+     * bottom-trigger-zone fast path; a missing container still shows the bar on
+     * any movement, exactly as React's wrapper does.
+     */
+    getContainer: () => HTMLElement | null;
+    /** The bar itself, so a mousedown outside it can close an open palette. */
+    getToolbar: () => HTMLElement | null;
+}
+declare class PresentToolbarChrome {
+    #private;
+    /** Whether the bar is currently faded in and accepting pointer events. */
+    visible: boolean;
+    /** Milliseconds since the show started, refreshed once a second. */
+    elapsedMs: number;
+    /** The open colour palette, or `null` when both are closed. */
+    palette: PresentPaletteKey | null;
+    /**
+     * Wire the document listeners and the one-second tick. Returns a teardown,
+     * so a component can hand it straight to `$effect`.
+     */
+    attach(targets: PresentToolbarChromeTargets): () => void;
+    /** Pointer entered the bar: pin it open until the pointer leaves again. */
+    enter(): void;
+    /** Pointer left the bar: restart the auto-hide countdown. */
+    leave(): void;
+    /**
+     * PowerPoint's Ctrl+H: flip the show chrome. Deliberately the same `visible`
+     * flag auto-hide writes, and it re-arms the countdown when it reveals the bar,
+     * so the shortcut leaves the toolbar in a state the pointer can still govern.
+     */
+    toggleVisible(): void;
+    /** Open `key`'s palette, or close it when it is already the open one. */
+    togglePalette(key: PresentPaletteKey): void;
+    /** Close both palettes (after picking a colour or choosing a tool). */
+    closePalettes(): void;
+}
+
 type PresentationInkTool = 'none' | 'pen' | 'highlighter' | 'eraser' | 'laser';
 interface PresentationStroke {
     id: string;
@@ -12378,6 +13096,16 @@ declare class RehearseState {
 declare class ViewerParityUiState {
     readonly compare: CompareController;
     readonly annotations: PresentationAnnotations;
+    /**
+     * The show toolbar's fade/auto-hide state. It lives here, not inside
+     * `PresentationToolbar.svelte`, because PowerPoint's Ctrl+H toggles the show
+     * chrome from the keyboard handler, which is nowhere near that component: a
+     * second visibility flag over there would be overwritten by the next mouse
+     * move, so the shortcut and the countdown share this one.
+     */
+    readonly showChrome: PresentToolbarChrome;
+    /** PowerPoint's Ctrl+S "See All Slides" grid, over the running show. */
+    allSlidesOpen: boolean;
     readonly rehearse: RehearseState;
     setupSlideShowOpen: boolean;
     headerFooterOpen: boolean;
@@ -12427,8 +13155,13 @@ interface CreateViewerStateOptions {
     getSource: () => Uint8Array | ArrayBuffer | null | undefined;
     collaboration?: CollaborationConfig;
     shareDefaults?: ShareDefaultsInput;
-    /** Host `autosave` prop (post-effect value the caller keeps in sync). */
-    getAutosave: () => boolean;
+    /**
+     * Host `autosave` prop, verbatim. `undefined` means the host said nothing,
+     * which PERMITS autosave (the user's toggle then decides); only an explicit
+     * `false` vetoes it and makes the toggle inert. See
+     * `resolveAutosaveActivation` in `pptx-viewer-shared`.
+     */
+    getAutosave: () => boolean | undefined;
     autosaveIntervalMs?: number;
     getFilePath: () => string | undefined;
     getInitialSlide: () => number;
@@ -12492,6 +13225,8 @@ interface ViewerStateBag {
     readonly collab: CollaborationController;
     readonly dialogs: CollaborationDialogsState;
     readonly autosaveCtl: AutosaveController;
+    /** The "recover unsaved changes?" probe + prompt for the loaded deck. */
+    readonly autosaveRecovery: AutosaveRecoveryController;
     readonly presentation: PresentationController;
     readonly presenterSession: PresenterSession;
     readonly exportWiring: ExportWiring;
@@ -12527,8 +13262,17 @@ interface ViewerStateBag {
      * can flip it without waiting on the host.
      */
     editable: boolean;
-    /** Read-only: mutate via {@link setAutosaveEnabled}, which also fires `onautosavetoggle`. */
+    /**
+     * The EFFECTIVE title-bar AutoSave state: the user's preference, or false
+     * when the host vetoed autosave (the switch renders off and inert rather
+     * than pretending to work). Mutate via {@link setAutosaveEnabled}, which
+     * also fires `onautosavetoggle`.
+     */
     readonly autosaveEnabled: boolean;
+    /** False only when the host passed `autosave={false}`; the toggle is then inert. */
+    readonly autosaveToggleAvailable: boolean;
+    /** Why autosave is not running, for a host that wants to explain it. */
+    readonly autosaveDisabledReason: AutosaveDisabledReason | undefined;
     setAutosaveEnabled(enabled: boolean): void;
     presenterMode: boolean;
     /** `Date.now()` timestamp of the last `enterPresenterView()` call; the presenter view's elapsed-time display. */