pptx-svelte-viewer 1.4.0 → 2.1.0

package/dist/viewer/index.d.ts

@@ -1,4 +1,6 @@
+import * as svelte from 'svelte';
 import { Component } from 'svelte';
+import { LanguageModel, ChatTransport, UIMessage, ToolSet } from 'ai';
 
 //#region src/core/types/actions.d.ts
 /**
@@ -204,6 +206,13 @@ interface PptxShapeLocks {
   noAdjustHandles?: boolean;
   noChangeArrowheads?: boolean;
   noChangeShapeType?: 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
+   * it is captured here to round-trip through the model. When `true` the
+   * shape is a plain text box (no fill/line by default).
+   */
+  txBox?: boolean;
 }
 /**
  * A drawing guide parsed from OOXML extension lists.
@@ -793,6 +802,15 @@ interface ShapeStyle {
     r: number;
     b: number;
   };
+  /** Raw tileRect LTRB values (0..1 fractions, may be negative) from
+   *  `a:gradFill/a:tileRect`. Defines the rectangle the gradient tile occupies
+   *  before any flip/tiling is applied. */
+  fillGradientTileRect?: {
+    l: number;
+    t: number;
+    r: number;
+    b: number;
+  };
   /** Gradient tile flip mode (`a:gradFill/@flip`).
    *  `none` = no tiling flip (default), `x|y|xy` = mirror in the named axis. */
   fillGradientFlip?: 'none' | 'x' | 'y' | 'xy';
@@ -810,6 +828,20 @@ interface ShapeStyle {
    * round-trip serialisation. See {@link fillColorXml} for the rationale.
    */
   strokeColorXml?: XmlObject;
+  /**
+   * Kind of fill painted on the outline (`a:ln` child). Distinguishes a solid
+   * outline from a gradient/pattern/none outline so save can emit the correct
+   * single line fill instead of collapsing every outline to `a:solidFill`
+   * (which, alongside a preserved `a:gradFill`/`a:pattFill`, produces an
+   * invalid dual-fill `<a:ln>`).
+   */
+  strokeFillMode?: 'solid' | 'gradient' | 'pattern' | 'none';
+  /** Raw `a:ln/a:gradFill` XML preserved for round-trip when the outline is
+   *  gradient-filled. Re-emitted verbatim as the line's single fill on save. */
+  strokeGradientXml?: XmlObject;
+  /** Raw `a:ln/a:pattFill` XML preserved for round-trip when the outline is
+   *  pattern-filled. Re-emitted verbatim as the line's single fill on save. */
+  strokePatternXml?: XmlObject;
   strokeWidth?: number;
   strokeOpacity?: number;
   strokeDash?: StrokeDashType;
@@ -991,6 +1023,14 @@ interface ShapeStyle {
   };
   /** Fill overlay blend mode from effectDag `a:fillOverlay/@blend`. */
   dagFillOverlayBlend?: 'over' | 'mult' | 'screen' | 'darken' | 'lighten';
+  /**
+   * Fill overlay tint colour (hex `#RRGGBB`) from effectDag `a:fillOverlay`'s
+   * `a:solidFill`/`a:gradFill`. Painted as a blended overlay layer over the
+   * element; the blend mode comes from {@link dagFillOverlayBlend}.
+   */
+  dagFillOverlayColor?: string;
+  /** Fill overlay tint opacity (0-1), from the overlay fill colour's alpha. */
+  dagFillOverlayOpacity?: number;
   /** `<a:lnRef @idx>` — 1-based index into the theme's lnStyleLst. */
   lnRefIdx?: number;
   /** Raw XML colour child of `<a:lnRef>` (e.g. `<a:schemeClr>` with transforms). */
@@ -1118,6 +1158,13 @@ interface TextStyle {
   kerning?: number;
   /** Text highlight colour as hex string (`a:highlight`). */
   highlightColor?: string;
+  /**
+   * Raw colour-choice XML preserved from `a:highlight` so a themed highlight
+   * (`a:schemeClr` / `a:sysClr` / `a:prstClr`) re-emits with its original
+   * identity rather than being flattened to `<a:srgbClr/>` on save. On save we
+   * re-emit verbatim when the resolved {@link highlightColor} still matches.
+   */
+  highlightColorXml?: XmlObject;
   /** Text-level gradient fill CSS string (from `a:rPr > a:gradFill`). */
   textFillGradient?: string;
   /** Structured gradient stops for text fill round-trip serialization. */
@@ -1229,10 +1276,36 @@ interface TextStyle {
   eastAsiaFont?: string;
   /** Complex Script font family from `a:cs`. */
   complexScriptFont?: string;
+  /**
+   * Theme-font token (`+mj-lt` / `+mn-lt` / ...) authored on `a:latin`, when
+   * present. {@link fontFamily} holds the resolved concrete face for
+   * rendering; this preserves the token linkage so the writer re-emits the
+   * token rather than the flattened face (see #84).
+   */
+  latinFontThemeToken?: string;
+  /** Theme-font token authored on `a:ea` (e.g. `+mn-ea`), when present. */
+  eastAsiaFontThemeToken?: string;
+  /** Theme-font token authored on `a:cs` (e.g. `+mn-cs`), when present. */
+  complexScriptFontThemeToken?: string;
+  /**
+   * Automatic per-script fallback face resolved from the theme's
+   * `<a:font script="...">` overrides for a run whose text is dominantly
+   * CJK / Arabic / Hebrew / Thai (see #83). A rendering hint only: it is not
+   * serialised back on save, so it never disturbs the round-trip typefaces.
+   */
+  scriptFallbackFont?: string;
   /** Text language from `a:rPr/@lang`. */
   language?: string;
   /** Hyperlink mouse-over target from `a:hlinkMouseOver`. */
   hyperlinkMouseOver?: string;
+  /**
+   * Raw `a:snd` (embedded WAV audio) child of `a:hlinkClick`, preserved
+   * verbatim (carries `@r:embed` + `@name`). Round-tripped on save so the
+   * click sound survives instead of being dropped.
+   */
+  hyperlinkSoundXml?: XmlObject;
+  /** Raw `a:snd` child of `a:hlinkMouseOver`, preserved verbatim for round-trip. */
+  hyperlinkMouseOverSoundXml?: XmlObject;
   /** Hyperlink invalidUrl attribute (`a:hlinkClick/@invalidUrl`). */
   hyperlinkInvalidUrl?: string;
   /** Hyperlink target frame (`a:hlinkClick/@tgtFrame`). */
@@ -1576,6 +1649,15 @@ interface TextSegment {
    * on the first segment of a paragraph.
    */
   endParaRunProperties?: Record<string, unknown>;
+  /**
+   * Per-paragraph properties (alignment, spacing, margins, indent, tab stops,
+   * rtl) authored on this paragraph's own `a:pPr` (#69). Only meaningful on
+   * the first segment of a paragraph. When present, the writer emits these
+   * per paragraph instead of collapsing one shape-level pPr onto every
+   * paragraph. Only the paragraph-geometry keys of {@link TextStyle} are
+   * populated; unrelated fields fall back to the shape-level style.
+   */
+  paragraphProperties?: TextStyle;
   /**
    * Phonetic annotation text from `a:ruby > a:rt` (e.g. furigana, pinyin).
    * When present, the renderer should wrap the base text with an HTML `<ruby>` tag.
@@ -1881,6 +1963,75 @@ interface PptxChartProtection {
   rawXml?: XmlObject;
 }
 //#endregion
+//#region src/core/types/chart-user-shapes.d.ts
+/**
+ * Types for chart drawing-overlay shapes (`c:userShapes`).
+ *
+ * A chart's `c:userShapes` element carries an `r:id` that references a
+ * separate drawing part (`ppt/drawings/drawingN.xml`) whose root is a
+ * `c:userShapes` element populated with `cdr:relSizeAnchor` /
+ * `cdr:absSizeAnchor` wrappers around `sp` / `pic` / `cxnSp` shapes drawn on
+ * top of the chart plot. These interfaces describe the parsed, renderable
+ * overlay model. The raw reference is preserved separately on
+ * {@link PptxChartData.userShapesXml} for verbatim round-trip save; this model
+ * is render-only.
+ *
+ * @module pptx-types/chart-user-shapes
+ */
+/** A single paragraph of overlay-shape text with light formatting. */
+interface PptxChartUserShapeParagraph {
+  /** Joined run text of the paragraph. */
+  text: string;
+  /** Font size in points (`a:rPr/@sz` divided by 100), when present. */
+  fontSize?: number;
+  /** Whether the first run is bold (`a:rPr/@b`). */
+  bold?: boolean;
+  /** Whether the first run is italic (`a:rPr/@i`). */
+  italic?: boolean;
+  /** Resolved run colour hex (e.g. `"#FF0000"`), when present. */
+  color?: string;
+  /** Paragraph alignment (`a:pPr/@algn`): left / centre / right. */
+  align?: 'l' | 'ctr' | 'r';
+}
+/**
+ * A parsed chart-overlay shape positioned by a drawing anchor.
+ *
+ * Position is expressed as chart-relative fractions in {@link from}. For a
+ * `relSizeAnchor` the opposite corner is {@link to} (also fractional); for an
+ * `absSizeAnchor` the extent is {@link ext} in EMU.
+ */
+interface PptxChartUserShape {
+  /** Shape kind: text/preset shape, connector, or picture. */
+  kind: 'sp' | 'cxnSp' | 'pic';
+  /** Anchor kind that positioned the shape. */
+  anchor: 'rel' | 'abs';
+  /** Top-left corner as chart-relative fractions (0-1). */
+  from: {
+    x: number;
+    y: number;
+  };
+  /** Bottom-right corner as chart-relative fractions (0-1); relSizeAnchor only. */
+  to?: {
+    x: number;
+    y: number;
+  };
+  /** Extent in EMU (cx, cy); absSizeAnchor only. */
+  ext?: {
+    cx: number;
+    cy: number;
+  };
+  /** Preset geometry name (`a:prstGeom/@prst`), defaulting to `"rect"`. */
+  prst?: string;
+  /** Resolved solid-fill hex colour, when present. */
+  fill?: string;
+  /** Resolved line/stroke hex colour, when present. */
+  stroke?: string;
+  /** Line width in points (`a:ln/@w` divided by 12700), when present. */
+  strokeWidth?: number;
+  /** Text paragraphs of the shape's `txBody`, when present. */
+  paragraphs?: PptxChartUserShapeParagraph[];
+}
+//#endregion
 //#region src/core/types/chart.d.ts
 /**
  * Supported chart type discriminators.
@@ -2214,6 +2365,15 @@ interface PptxChartTreemapOptions {
 interface PptxChartSeries {
   name: string;
   values: number[];
+  /**
+   * 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
+   * empty, i.e. a genuine blank rather than a real `0`. Present only when the
+   * source series actually contains blanks; when set, blank slots in
+   * {@link values} carry `0` as a placeholder. Renderers honour
+   * `c:dispBlanksAs` (gap / zero / span) using this mask.
+   */
+  blanks?: boolean[];
   color?: string;
   trendlines?: PptxChartTrendline[];
   errBars?: PptxChartErrBars[];
@@ -2221,6 +2381,18 @@ interface PptxChartSeries {
   marker?: PptxChartMarker;
   dataLabels?: PptxChartDataLabel[];
   explosion?: number;
+  /**
+   * Series-level `c:invertIfNegative`: when true, bar/column data points with a
+   * negative value are drawn with an inverted (lightened) fill. A per-point
+   * `c:dPt/c:invertIfNegative` overrides this for that point. Absent when the
+   * source XML omits the flag.
+   */
+  invertIfNegative?: boolean;
+  /**
+   * Whether this line/scatter series is drawn with bezier smoothing
+   * (`c:ser/c:smooth/@val`). Absent when the source XML omits `c:smooth`.
+   */
+  smooth?: boolean;
   /** Axis ID this series is plotted against (links to PptxChartAxisFormatting.axisId). */
   axisId?: number;
   /**
@@ -2423,6 +2595,14 @@ interface PptxChartManualLayout {
   y?: number;
   width?: number;
   height?: number;
+  /**
+   * Raw `c:extLst` (CT_ExtensionList) of the `c:manualLayout`, captured
+   * verbatim so it round-trips through the typed model. Without this, a dirty
+   * write of an edited layout would drop the extension list (the manual node
+   * is rebuilt from the typed fields). Emitted as the trailing child, matching
+   * the CT_ManualLayout schema order.
+   */
+  ext?: XmlObject;
 }
 /**
  * Typed manual layouts for chart regions that accept `c:layout`.
@@ -2487,6 +2667,33 @@ interface PptxChartData {
   style?: PptxChartStyle;
   /** Grouping mode for bar/area/line charts: 'clustered' | 'stacked' | 'percentStacked' */
   grouping?: 'clustered' | 'stacked' | 'percentStacked';
+  /**
+   * Whether the first (or only) series varies its point colours
+   * (`c:varyColors/@val`). Pie/doughnut default this on; single-series
+   * bar/column honour it by giving each point a distinct palette colour.
+   * Absent when the source XML omits `c:varyColors`.
+   */
+  varyColors?: boolean;
+  /**
+   * Pie/doughnut start angle in degrees clockwise from 12 o'clock
+   * (`c:firstSliceAng/@val`, 0 through 360). Absent uses the default 0.
+   */
+  firstSliceAngle?: number;
+  /**
+   * Doughnut hole diameter as a percentage of the outer diameter
+   * (`c:holeSize/@val`, 10 through 90). Absent uses the renderer default.
+   */
+  doughnutHoleSize?: number;
+  /**
+   * Bar/column gap between category clusters as a percentage of bar width
+   * (`c:gapWidth/@val`, 0 through 500). Absent uses the renderer default.
+   */
+  barGapWidth?: number;
+  /**
+   * Clustered bar/column overlap between series within a category as a
+   * percentage (`c:overlap/@val`, -100 through 100). Absent uses 0.
+   */
+  barOverlap?: number;
   /** Internal: path to the chart XML part in the PPTX archive (for round-trip save). */
   chartPartPath?: string;
   /** Internal: relationship ID linking the graphic frame to the chart part. */
@@ -2587,6 +2794,15 @@ interface PptxChartData {
    * attempting to parse the nested drawing tree.
    */
   userShapesXml?: unknown;
+  /**
+   * Parsed, renderable drawing-overlay shapes resolved from the separate
+   * drawing part referenced by `c:userShapes/@r:id`
+   * (`ppt/drawings/drawingN.xml`). Each entry carries chart-relative anchor
+   * geometry plus light shape/text formatting so the viewer can render an
+   * overlay on top of the chart plot. Render-only: {@link userShapesXml}
+   * remains the source of truth for round-trip save.
+   */
+  userShapes?: PptxChartUserShape[];
   /**
    * Raw `c:pivotFmts` XML subtree preserved verbatim.
    *
@@ -3294,6 +3510,18 @@ interface PptxSmartArtColorTransform extends PptxSmartArtDefinitionMetadata {
   fillColors: string[];
   /** Ordered resolved line colors for rendering. */
   lineColors: string[];
+  /** Ordered resolved text-fill colors (primary styleLbl `txFillClrLst`). */
+  textFillColors?: string[];
+  /** Ordered resolved text-line colors (primary styleLbl `txLinClrLst`). */
+  textLineColors?: string[];
+  /** Ordered resolved effect colors (primary styleLbl `effectClrLst`). */
+  effectColors?: string[];
+  /** Ordered resolved text-effect colors (primary styleLbl `txEffectClrLst`). */
+  textEffectColors?: string[];
+  /** Fill-list span/cycle + hue-direction interpolation of the primary styleLbl. */
+  fillInterpolation?: PptxSmartArtColorListMetadata;
+  /** Line-list span/cycle + hue-direction interpolation of the primary styleLbl. */
+  lineInterpolation?: PptxSmartArtColorListMetadata;
   /** Ordered CT_CTStyleLabel metadata. */
   labels?: PptxSmartArtColorStyleLabel[];
 }
@@ -3414,6 +3642,40 @@ interface PptxSmartArtDrawingShape extends PptxCustomPathProperties {
   skewY?: number;
   /** Solid fill colour (hex). */
   fillColor?: string;
+  /**
+   * Gradient fill stops when the cached shape uses `a:gradFill`. Positions are
+   * 0..100 (percent). Renderers emit an SVG/CSS gradient instead of a flat box.
+   */
+  fillGradientStops?: Array<{
+    color: string;
+    position: number;
+    opacity?: number;
+  }>;
+  /** Gradient geometry type (`linear` for `a:lin`, `radial` for `a:path`). */
+  fillGradientType?: 'linear' | 'radial';
+  /** Linear gradient angle in degrees (0..360). */
+  fillGradientAngle?: number;
+  /** Pattern fill preset name from `a:pattFill/@prst` (e.g. "pct50", "cross"). */
+  fillPatternPreset?: string;
+  /** Pattern fill foreground colour (hex) from `a:pattFill/a:fgClr`. */
+  fillPatternForegroundColor?: string;
+  /** Pattern fill background colour (hex) from `a:pattFill/a:bgClr`. */
+  fillPatternBackgroundColor?: string;
+  /**
+   * Relationship id of a picture (blip) fill's embedded image, from
+   * `a:blipFill/a:blip/@r:embed`. The image bytes are resolved separately; see
+   * {@link fillImageUrl}.
+   */
+  fillBlipEmbedId?: string;
+  /**
+   * Resolved data-URI/URL for a picture (blip) fill, when the embedded image
+   * part could be resolved. Absent when only {@link fillBlipEmbedId} is known.
+   */
+  fillImageUrl?: string;
+  /** Whether the cached shape carries an outer-shadow effect (`a:effectLst`). */
+  hasShadow?: boolean;
+  /** Resolved outer-shadow colour (hex), when present. */
+  shadowColor?: string;
   /** Stroke colour (hex). */
   strokeColor?: string;
   /** Stroke width in points. */
@@ -3448,6 +3710,40 @@ interface PptxSmartArtChrome {
   /** Outline stroke width in points. */
   outlineWidth?: number;
 }
+/**
+ * Presentation layout variables from `dgm:prSet/dgm:presLayoutVars` (data model)
+ * or `dgm:varLst` (layout definition defaults).
+ *
+ * These drive how the DiagramML layout interpreter arranges points: flow
+ * direction, hierarchy branch style, org-chart mode, and child count limits.
+ * The fallback layout engine can consult them for direction/org-chart hints.
+ *
+ * @example
+ * ```ts
+ * const vars: PptxSmartArtPresLayoutVars = { direction: "rev", orgChart: true };
+ * // => satisfies PptxSmartArtPresLayoutVars
+ * ```
+ */
+interface PptxSmartArtPresLayoutVars {
+  /** Flow direction (`dgm:dir`): "norm" (default) or "rev" (reversed/RTL). */
+  direction?: 'norm' | 'rev';
+  /** Hierarchy branch style (`dgm:hierBranch`): std/init/l/r/hang. */
+  hierarchyBranch?: 'std' | 'init' | 'l' | 'r' | 'hang';
+  /** Org-chart mode enabled (`dgm:orgChart`). */
+  orgChart?: boolean;
+  /** Maximum children per node (`dgm:chMax`, -1 = unbounded). */
+  childMax?: number;
+  /** Preferred children per node (`dgm:chPref`, -1 = unbounded). */
+  childPreferred?: number;
+  /** Whether bullets are enabled (`dgm:bulletEnabled`). */
+  bulletEnabled?: boolean;
+  /** Animation-by-level setting (`dgm:animLvl`). */
+  animationLevel?: string;
+  /** Animate-one setting (`dgm:animOne`). */
+  animateOne?: string;
+  /** Allowed resize handles (`dgm:resizeHandles`). */
+  resizeHandles?: string;
+}
 /**
  * Complete parsed SmartArt data for a {@link SmartArtPptxElement}.
  *
@@ -3489,6 +3785,12 @@ interface PptxSmartArtData {
   quickStyle?: PptxSmartArtQuickStyle;
   /** Editable metadata from the related DiagramML layout definition. */
   layoutDefinition?: PptxSmartArtLayoutDefinition;
+  /**
+   * Presentation layout variables (direction, hierarchy branch, org-chart,
+   * child limits, bullets) from `dgm:presLayoutVars` / layout `dgm:varLst`.
+   * Consulted by the fallback layout engine for direction/org-chart hints.
+   */
+  presLayoutVars?: PptxSmartArtPresLayoutVars;
   /** Relationship ID for the diagram data part (for round-trip save). */
   dataRelId?: string;
   /** Relationship ID for the diagram layout part. */
@@ -3521,7 +3823,7 @@ interface PptxSmartArtData {
 /**
  * Per-cell visual style for a table cell.
  *
- * All fields are optional — unset values inherit from the table style.
+ * All fields are optional - unset values inherit from the table style.
  *
  * @example
  * ```ts
@@ -3649,6 +3951,52 @@ interface PptxTableCellStyle {
   patternFillForeground?: string;
   /** Pattern fill background colour. */
   patternFillBackground?: string;
+  /**
+   * Cell 3D bevel + lighting from `a:tcPr/a:cell3D` (CT_Cell3D,
+   * ECMA-376 §21.1.3.1). Rendered as a CSS bevel treatment.
+   */
+  cell3D?: PptxTableCell3D;
+  /**
+   * `a:tcPr/@anchorCtr` - centre the text block in the direction
+   * perpendicular to the text flow (horizontal centring for horizontal text).
+   */
+  anchorCtr?: boolean;
+  /**
+   * `a:tcPr/@horzOverflow` (ST_TextHorzOverflowType): `clip` clips text at
+   * the cell edge, `overflow` (the default) lets it spill.
+   */
+  horzOverflow?: 'clip' | 'overflow';
+}
+/**
+ * Cell 3D bevel + lighting parsed from `a:tcPr/a:cell3D` (CT_Cell3D).
+ *
+ * Only the fields needed to render a plausible bevel treatment are captured;
+ * verbatim round-trip of the full node is handled separately by the save path.
+ *
+ * @example
+ * ```ts
+ * const c3d: PptxTableCell3D = {
+ *   bevelWidth: 8,
+ *   bevelHeight: 8,
+ *   bevelPreset: 'circle',
+ *   material: 'plastic',
+ * };
+ * // => satisfies PptxTableCell3D
+ * ```
+ */
+interface PptxTableCell3D {
+  /** Bevel width in px (from `a:bevel@w`, EMU converted). */
+  bevelWidth?: number;
+  /** Bevel height in px (from `a:bevel@h`, EMU converted). */
+  bevelHeight?: number;
+  /** Bevel preset name (`a:bevel@prst`, e.g. `circle`, `relaxedInset`). */
+  bevelPreset?: string;
+  /** Preset material (`a:cell3D@prstMaterial`, e.g. `plastic`, `metal`). */
+  material?: string;
+  /** Light rig type (`a:lightRig@rig`, e.g. `threePt`, `soft`). */
+  lightRig?: string;
+  /** Light rig direction (`a:lightRig@dir`, e.g. `tl`, `t`, `tr`). */
+  lightRigDirection?: string;
 }
 /**
  * A single table cell with text content, optional style, and merge info.
@@ -3761,12 +4109,50 @@ interface PptxTableData {
  * ```
  */
 interface ParsedTableStyleFill {
-  /** Theme colour key (e.g. `accent1`, `dk1`). */
+  /**
+   * Theme colour key (e.g. `accent1`, `dk1`). Empty string when the fill is a
+   * non-scheme fill (explicit sRGB, gradient, pattern, or none) that carries
+   * no theme colour reference; the renderer then resolves {@link color},
+   * {@link gradient}, {@link pattern}, or {@link noFill} instead.
+   */
   schemeColor: string;
   /** Tint value (0-100 000). */
   tint?: number;
   /** Shade value (0-100 000). */
   shade?: number;
+  /** Explicit sRGB hex colour (e.g. `#FF8800`) from `a:srgbClr`. */
+  color?: string;
+  /** The fill was `a:noFill`: renders transparent and clears lower layers. */
+  noFill?: boolean;
+  /** Gradient fill parsed from `a:gradFill`. */
+  gradient?: ParsedTableStyleGradient;
+  /** Preset pattern fill parsed from `a:pattFill`. */
+  pattern?: ParsedTableStylePattern;
+}
+/** A single colour stop within a {@link ParsedTableStyleGradient}. */
+interface ParsedTableStyleGradientStop {
+  /** Stop position as a percentage (0-100). */
+  position: number;
+  /** Stop colour (scheme or explicit sRGB). */
+  fill: ParsedTableStyleFill;
+}
+/** A gradient fill parsed from a table style section's `a:gradFill`. */
+interface ParsedTableStyleGradient {
+  /** Ordered colour stops. */
+  stops: ParsedTableStyleGradientStop[];
+  /** Linear gradient angle in degrees (from `a:lin@ang`, 60000ths -> deg). */
+  angle?: number;
+  /** Gradient family: linear (`a:lin`) or radial (`a:path`). */
+  type: 'linear' | 'radial';
+}
+/** A preset pattern fill parsed from a table style section's `a:pattFill`. */
+interface ParsedTableStylePattern {
+  /** OOXML preset name (e.g. `ltDnDiag`) from `a:pattFill@prst`. */
+  preset: string;
+  /** Foreground colour (`a:fgClr`). */
+  foreground?: ParsedTableStyleFill;
+  /** Background colour (`a:bgClr`). */
+  background?: ParsedTableStyleFill;
 }
 /**
  * A single entry in the parsed table style map.
@@ -3793,12 +4179,67 @@ interface ParsedTableStyleText {
   bold?: boolean;
   /** Font italic. */
   italic?: boolean;
+  /** Font underline (from `a:tcTxStyle@u`, any value other than `none`). */
+  underline?: boolean;
   /** Font colour as theme scheme key. */
   fontSchemeColor?: string;
   /** Font colour tint (0-100 000). */
   fontTint?: number;
   /** Font colour shade (0-100 000). */
   fontShade?: number;
+  /** Explicit sRGB hex font colour (e.g. `#FF0000`) from `a:srgbClr`. */
+  fontColor?: string;
+  /** Typeface from `a:font@typeface` (latin font). */
+  fontFace?: string;
+  /** Font-collection index from `a:fontRef@idx` (`minor`, `major`, `none`). */
+  fontRefIdx?: string;
+}
+/**
+ * A single border side within a table style's `a:tcStyle/a:tcBdr`.
+ *
+ * Corresponds to one of `a:left`, `a:right`, `a:top`, `a:bottom`,
+ * `a:insideH`, `a:insideV`, `a:tl2br`, `a:bl2tr` (each a
+ * `CT_ThemeableLineStyle` wrapping an `a:ln`).
+ *
+ * @example
+ * ```ts
+ * const side: ParsedTableStyleBorder = {
+ *   width: 1,
+ *   dash: 'solid',
+ *   fill: { schemeColor: 'lt1' },
+ * };
+ * // => satisfies ParsedTableStyleBorder
+ * ```
+ */
+interface ParsedTableStyleBorder {
+  /** Line width in px (converted from the `a:ln@w` EMU value). */
+  width?: number;
+  /** OOXML `a:prstDash@val` (e.g. `solid`, `dash`, `sysDot`). */
+  dash?: string;
+  /** Border colour as a theme scheme fill (from `a:ln/a:solidFill/a:schemeClr`). */
+  fill?: ParsedTableStyleFill;
+  /** Explicit hex colour when the line used `a:srgbClr` (e.g. `#808080`). */
+  color?: string;
+  /** The line was `a:noFill` - an explicit "no border" that clears lower layers. */
+  noFill?: boolean;
+}
+/**
+ * The set of border sides parsed from a table style section's
+ * `a:tcStyle/a:tcBdr` element.
+ */
+interface ParsedTableStyleBorders {
+  left?: ParsedTableStyleBorder;
+  right?: ParsedTableStyleBorder;
+  top?: ParsedTableStyleBorder;
+  bottom?: ParsedTableStyleBorder;
+  /** Interior horizontal borders between rows in the region. */
+  insideH?: ParsedTableStyleBorder;
+  /** Interior vertical borders between columns in the region. */
+  insideV?: ParsedTableStyleBorder;
+  /** Top-left to bottom-right diagonal. */
+  tl2br?: ParsedTableStyleBorder;
+  /** Bottom-left to top-right diagonal. */
+  bl2tr?: ParsedTableStyleBorder;
 }
 /**
  * Table background style (CT_TableBackgroundStyle, ECMA-376 §21.1.3.7).
@@ -3834,6 +4275,24 @@ interface ParsedTableStyleEntry {
   swCellFill?: ParsedTableStyleFill;
   neCellFill?: ParsedTableStyleFill;
   nwCellFill?: ParsedTableStyleFill;
+  /**
+   * Per-role border styling from `a:tcStyle/a:tcBdr`. These supply the
+   * gridlines/edges a styled table inherits from its table style when the
+   * cells carry no explicit per-cell `a:lnX` overrides.
+   */
+  wholeTblBorders?: ParsedTableStyleBorders;
+  firstRowBorders?: ParsedTableStyleBorders;
+  lastRowBorders?: ParsedTableStyleBorders;
+  firstColBorders?: ParsedTableStyleBorders;
+  lastColBorders?: ParsedTableStyleBorders;
+  band1HBorders?: ParsedTableStyleBorders;
+  band2HBorders?: ParsedTableStyleBorders;
+  band1VBorders?: ParsedTableStyleBorders;
+  band2VBorders?: ParsedTableStyleBorders;
+  seCellBorders?: ParsedTableStyleBorders;
+  swCellBorders?: ParsedTableStyleBorders;
+  neCellBorders?: ParsedTableStyleBorders;
+  nwCellBorders?: ParsedTableStyleBorders;
   /** Per-role text styling from a:tcTxStyle. */
   wholeTblText?: ParsedTableStyleText;
   firstRowText?: ParsedTableStyleText;
@@ -4399,6 +4858,16 @@ interface PptxHandoutMaster {
   /** Colour map from `<p:clrMap>` (12 alias attributes). Applied at save time. */
   clrMap?: Record<string, string>;
 }
+/**
+ * Active tab within the master view sidebar.
+ *
+ * @example
+ * ```ts
+ * const tab: MasterViewTab = "slides";
+ * // => "slides" — one of: "slides" | "notes" | "handout"
+ * ```
+ */
+type MasterViewTab = 'slides' | 'notes' | 'handout';
 /**
  * Structured slide master data.
  *
@@ -4631,10 +5100,30 @@ interface PptxNativeAnimation {
   presetClass?: 'entr' | 'exit' | 'emph' | 'path';
   /** Effect preset sub-type identifier. */
   presetId?: number;
+  /**
+   * Effect preset direction/variant code from `p:cTn/@presetSubtype`
+   * (ECMA-376 CT_TLCommonTimeNodeData). For Fly In/Out this encodes the
+   * edge/corner the object travels from as a bitmask (1=top, 2=right,
+   * 4=bottom, 8=left; corners combine bits). Absent means the preset default.
+   */
+  presetSubtype?: number;
   /** Duration in milliseconds. */
   durationMs?: number;
   /** Delay in milliseconds. */
   delayMs?: number;
+  /**
+   * Acceleration fraction in the range 0..1, parsed from `p:cTn/@accel`
+   * (ST_PositiveFixedPercentage, stored as 1000ths of a percent). A non-zero
+   * value means the effect eases in (starts slow). Absent means no easing-in.
+   */
+  accel?: number;
+  /**
+   * Deceleration fraction in the range 0..1, parsed from `p:cTn/@decel`.
+   * A non-zero value means the effect eases out (ends slow). Absent means no
+   * easing-out. When both {@link accel} and {@link decel} are set, the effect
+   * eases in and out.
+   */
+  decel?: number;
   /** Trigger delay in milliseconds (for afterDelay). */
   triggerDelayMs?: number;
   /** SVG path string for motion path animations (`p:animMotion/@path`). */
@@ -4727,6 +5216,14 @@ interface PptxNativeAnimation {
    * that aren't OLE charts).
    */
   graphicBuild?: string;
+  /**
+   * OLE-embedded chart build attribute (`p:bldOleChart/@bld`) when this
+   * animation stages an OLE chart graphic frame. Values follow
+   * ST_TLOleChartBuildType: `allAtOnce`, `series`, `category`, `seriesEl`,
+   * `categoryEl`. Lets a staged-reveal renderer build the chart by series /
+   * category / element to match PowerPoint, rather than as one whole element.
+   */
+  oleChartBuild?: string;
   /** Schema-accurate `p:bldGraphic/p:bldAsOne|p:bldSub` representation. */
   graphicBuildProperties?: PptxGraphicBuild;
   /**
@@ -5216,6 +5713,18 @@ interface PptxAppProperties {
   template?: string;
   /** Hyperlink base URL. */
   hyperlinkBase?: string;
+  /** Document security bitmask (`<DocSecurity>`). */
+  docSecurity?: number;
+  /** Number of multimedia clips (`<MMClips>`). */
+  mmClips?: number;
+  /** Whether thumbnail images were scaled to fit (`<ScaleCrop>`). */
+  scaleCrop?: boolean;
+  /** Whether hyperlinks are current (`<LinksUpToDate>`). */
+  linksUpToDate?: boolean;
+  /** Whether the document is shared (`<SharedDoc>`). */
+  sharedDoc?: boolean;
+  /** Whether hyperlinks changed since last save (`<HyperlinksChanged>`). */
+  hyperlinksChanged?: boolean;
 }
 //#endregion
 //#region src/core/types/presentation-print-properties.d.ts
@@ -5506,7 +6015,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';
+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';
 /** Split orientation from OOXML `@_orient`. */
 type PptxSplitOrientation = 'horz' | 'vert';
 /** Schema-defined `ST_TransitionSpeed` values. */
@@ -5720,6 +6229,21 @@ interface PptxActiveXControl {
   name?: string;
   /** Shape ID this control is linked to (from @spid). */
   shapeId?: string;
+  /** X position (px) of the control's fallback picture, if present. */
+  x?: number;
+  /** Y position (px) of the control's fallback picture, if present. */
+  y?: number;
+  /** Width (px) of the control's fallback picture, if present. */
+  width?: number;
+  /** Height (px) of the control's fallback picture, if present. */
+  height?: number;
+  /**
+   * Relationship ID of the control's static fallback picture
+   * (`mc:AlternateContent > mc:Fallback > p:pic > p:blipFill > a:blip@r:embed`).
+   * Renderers resolve this to an image so a control shows its last static
+   * frame instead of a blank area (the live ActiveX cannot run in a viewer).
+   */
+  fallbackImageRelId?: string;
   /** Raw XML for round-trip preservation. */
   rawXml?: XmlObject;
 }
@@ -5846,6 +6370,13 @@ interface PptxSlide {
   customerData?: PptxCustomerData[];
   /** ActiveX control references from `p:controls` on this slide. */
   activeXControls?: PptxActiveXControl[];
+  /**
+   * Shapes parsed from a referenced legacy VML drawing part
+   * (`ppt/drawings/vmlDrawing*.vml`, linked via a `legacyDrawing`
+   * relationship). These are read-only render hints: the VML part itself is
+   * preserved verbatim on save, so this field is not re-serialized.
+   */
+  legacyVmlElements?: PptxElement[];
   /** Per-slide header/footer flags from `<p:hf>` (P-H3). */
   headerFooterFlags?: PptxHeaderFooterFlags;
   /** Server-backed slide synchronization metadata stored in a related OPC part. */
@@ -5954,12 +6485,6 @@ interface PptxPresentationProperties {
   showSubtitles?: boolean;
   /** Typed `p:prnPr` settings. Set to null during save to remove the element. */
   printProperties?: PptxPresentationPrintProperties | null;
-  /** @deprecated Use `printProperties.printWhat`; retained as a handout compatibility alias. */
-  printSlidesPerPage?: number;
-  /** @deprecated Use `printProperties.frameSlides`. */
-  printFrameSlides?: boolean;
-  /** @deprecated Use `printProperties.colorMode`. */
-  printColorMode?: 'clr' | 'gray' | 'bw';
   /** Most-recently-used colours from the presentation palette. */
   mruColors?: string[];
   /** Grid spacing in EMUs (cx, cy). Default is 914400 / 8 = 114300. */
@@ -7911,6 +8436,291 @@ interface CollaborationConfig {
    */
   writeBackDebounceMs?: number;
 }
+//#endregion
+//#region src/render/animation-authoring.d.ts
+/** One of the three animation buckets a preset can occupy on an element. */
+type AnimationGroup = 'entrance' | 'emphasis' | 'exit';
+/**
+ * Normalized staged-reveal mode for a chart graphic frame, derived from the
+ * OOXML `a:bldChart/@bld` (or `p:bldOleChart/@bld`) token:
+ *  - `asOne`      the whole chart appears at once (`allAtOnce`).
+ *  - `bySeries`   one data series is revealed per stage (`series`).
+ *  - `byCategory` one category is revealed per stage (`category`).
+ *  - `byElement`  one series/category ELEMENT is revealed per stage
+ *                 (`seriesElement` / `categoryElement`).
+ */
+type ChartBuildMode = 'asOne' | 'bySeries' | 'byCategory' | 'byElement';
+/**
+ * Normalized staged-reveal mode for a SmartArt diagram, derived from the OOXML
+ * `a:bldDgm/@bld` or `p:bldDgm/@bld` token:
+ *  - `asOne`        the whole diagram appears at once (`whole` / `allAtOnce`).
+ *  - `byOne`        one node is revealed per stage (`one`, and the assorted
+ *                   `depthBy*` / `breadthBy*` / directional traversals).
+ *  - `byLvl`        levels are revealed one element at a time (`lvlOne`).
+ *  - `byLvlAtOnce`  a whole level is revealed per stage (`lvlAtOnce`).
+ */
+type DiagramBuildMode = 'asOne' | 'byOne' | 'byLvl' | 'byLvlAtOnce';
+/**
+ * Playback-time staged-build state surfaced on {@link ElementAnimationState}.
+ * `progress` is the 0..1 fraction of the build revealed at the current playback
+ * time; a consumer maps it to its own item COUNT (see `revealedStageCount`).
+ */
+type ElementBuildState = {
+  kind: 'chart';
+  mode: ChartBuildMode;
+  progress: number;
+} | {
+  kind: 'diagram';
+  mode: DiagramBuildMode;
+  progress: number;
+};
+/** Snapshot of a single element's animation state at a point in the timeline. */
+interface ElementAnimationState {
+  /** Whether the element should be visible. */
+  visible: boolean;
+  /** CSS animation shorthand to apply (undefined = no active animation). */
+  cssAnimation: string | undefined;
+  /**
+   * Staged-build reveal state, present only when the active animation builds a
+   * chart or SmartArt diagram in stages (`p:bldChart` / `p:bldDgm`) rather than
+   * revealing the whole element at once. A staged renderer multiplies
+   * `build.progress` (0..1) by its own series / category / level COUNT to
+   * decide how many stages are revealed at the current playback time; see
+   * {@link import('./animation-build').revealedStageCount}. Absent for ordinary
+   * whole-element entrances, so existing renderers are unaffected.
+   */
+  build?: ElementBuildState;
+  /**
+   * True when an active `p:animClr` color animation targets this shape's fill.
+   * A vector renderer should then paint the fill with `fill: inherit` so the
+   * wrapper-level colour keyframes cascade to the SVG path. Absent/false means
+   * no active fill-colour animation.
+   */
+  animatesFill?: boolean;
+  /**
+   * True when an active `p:animClr` color animation targets this shape's
+   * stroke. A vector renderer should then paint the stroke with
+   * `stroke: inherit`. Absent/false means no active stroke-colour animation.
+   */
+  animatesStroke?: boolean;
+}
+//#endregion
+//#region src/render/element-align.d.ts
+/**
+ * Pure geometry helpers for the align / distribute editor operations.
+ *
+ * These functions operate over a list of slide elements (anything carrying the
+ * `{ id, x, y, width, height }` bounding-box fields of {@link PptxElement}) and
+ * return a `Map` keyed by element `id` describing the *new* position(s) for the
+ * elements that need to move. Elements that already sit on the target edge (or
+ * the two outer-most elements during distribution) are still included with
+ * their unchanged coordinate so callers can apply the whole map uniformly — the
+ * map only ever contains the axis that the operation touches.
+ *
+ * The helpers are deliberately framework-agnostic: no DOM, no Vue reactivity,
+ * no side effects. The host wires them into the editor by feeding the current
+ * selection in and applying the returned `Map` via its element-transform
+ * operation (one batched history entry per call).
+ */
+/** Edge / centre that {@link alignElements} can snap a selection to. */
+type AlignEdge = 'left' | 'centerH' | 'right' | 'top' | 'middle' | 'bottom';
+/** Axis along which {@link distributeElements} evenly spaces a selection. */
+type DistributeAxis = 'horizontal' | 'vertical';
+/** The eight resize handles, named by compass direction. */
+type ResizeHandleId = 'nw' | 'n' | 'ne' | 'e' | 'se' | 's' | 'sw' | 'w';
+/** A marquee drag described by its start and current corner (any order). */
+interface MarqueeRect {
+  startX: number;
+  startY: number;
+  currentX: number;
+  currentY: number;
+}
+/** Minimum section metadata needed to build sidebar groups. */
+interface SectionGroupDescriptor {
+  id: string;
+  name: string;
+  collapsed?: boolean;
+  color?: string;
+}
+/** A declared section paired with its slides, or the trailing ungrouped slides. */
+interface SectionSlideGroup<TSection extends SectionGroupDescriptor = PptxSection> {
+  section: TSection | undefined;
+  slides: PptxSlide[];
+  slideIndexes: number[];
+}
+/** A snap alignment line: `axis: 'v'` is a vertical line at x=`position`. */
+interface SnapLine {
+  axis: 'h' | 'v';
+  position: number;
+}
+//#endregion
+//#region src/render/collaboration-presence.d.ts
+/** Connection lifecycle states for the Yjs WebSocket provider. */
+type ConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'error';
+/** A single remote collaborator's cursor, in unscaled slide coordinates. */
+interface RemoteCursor {
+  /** Stable id for the remote client (awareness clientId or peer id). */
+  clientId: number | string;
+  /** Display name shown in the label chip. */
+  userName: string;
+  /** Cursor + chip colour (any CSS colour string). */
+  color: string;
+  /** Unscaled slide-space X coordinate (px). */
+  x: number;
+  /** Unscaled slide-space Y coordinate (px). */
+  y: number;
+  /** Optional ids of elements this user has selected. */
+  selectionIds?: string[];
+}
+/**
+ * Presence data for a remote collaborator, sanitised from the awareness
+ * protocol. Returned by {@link sanitizePresence}; coordinates are in unscaled
+ * slide pixels, clamped to the supplied canvas bounds.
+ */
+interface SanitizedPresence {
+  clientId: number;
+  userName: string;
+  userAvatar?: string;
+  userColor: string;
+  activeSlideIndex: number;
+  cursorX: number;
+  cursorY: number;
+  lastUpdated: string;
+  selectedElementId?: string;
+  role?: CollaborationRole;
+}
+//#endregion
+//#region src/render/collaboration-presence-publisher.d.ts
+/**
+ * Structural interface for the lazily-imported Yjs awareness surface. Every
+ * binding's live `y-protocols/awareness` `Awareness` instance satisfies this.
+ */
+interface AwarenessLike {
+  clientID?: number;
+  setLocalStateField: (field: string, value: unknown) => void;
+  getStates: () => Map<number, Record<string, unknown>>;
+  on: (event: string, cb: () => void) => void;
+  off?: (event: string, cb: () => void) => void;
+}
+//#endregion
+//#region src/render/collaboration-text-codec.d.ts
+/**
+ * collaboration-text-codec.ts: TextSegment[] <-> Y.Text delta codec used by the
+ * collaboration sync layer. Split out of collaboration-sync.ts to keep both
+ * modules focused.
+ *
+ * Exports:
+ *  - DeltaOp / YTextLike: structural Yjs text interfaces (no yjs import)
+ *  - encodeTextBody: write TextSegment[] into a live YTextLike
+ *  - encodeSegmentsToDelta: pure simulation of the delta Y.Text would produce
+ *  - decodeDelta / decodeTextBody: delta -> TextSegment[]
+ *  - isYTextLike: runtime guard
+ */
+interface DeltaOp {
+  insert?: unknown;
+  attributes?: Record<string, unknown>;
+}
+interface YTextLike {
+  insert: (index: number, text: string, attrs?: Record<string, string>) => void;
+  toDelta: () => DeltaOp[];
+  toString: () => string;
+}
+//#endregion
+//#region src/render/collaboration-sync.d.ts
+interface YMapLike {
+  get: (key: string) => unknown;
+  set: (key: string, value: unknown) => void;
+  delete: (key: string) => void;
+  forEach: (cb: (value: unknown, key: string) => void) => void;
+}
+/** Shape of the Yjs transaction passed to (deep) observers. */
+interface YTransactionLike {
+  origin?: unknown;
+}
+type YDeepObserver = (events?: unknown, transaction?: YTransactionLike) => void;
+interface YArrayLike {
+  readonly length: number;
+  get: (index: number) => unknown;
+  push: (items: unknown[]) => void;
+  delete: (index: number, length?: number) => void;
+  insert: (index: number, items: unknown[]) => void;
+  toArray: () => unknown[];
+  observe: (handler: () => void) => void;
+  unobserve: (handler: () => void) => void;
+  observeDeep: (handler: YDeepObserver) => void;
+  unobserveDeep: (handler: YDeepObserver) => void;
+}
+interface YDocLike {
+  getMap: (name: string) => YMapLike;
+  getArray: (name: string) => YArrayLike;
+  transact: (fn: () => void, origin?: unknown) => void;
+}
+interface YjsFactories {
+  createMap: () => YMapLike;
+  createArray: () => YArrayLike;
+  createText: () => YTextLike;
+}
+//#endregion
+//#region src/render/collaboration-live-patch-target.d.ts
+/** Interim geometry for an element mid-gesture. All fields optional. */
+interface LiveGeometryPatch {
+  x?: number;
+  y?: number;
+  width?: number;
+  height?: number;
+  rotation?: number;
+}
+/** The element's pre-edit rich text, used to remap the interim plain text. */
+interface LiveTextSource {
+  textSegments?: TextSegment[];
+  textStyle?: TextStyle;
+}
+interface CollaborationLivePatcher {
+  /** Attach a live doc (or `null` to go dormant). Pending patches are dropped. */
+  configure: (doc: YDocLike | null, factories: YjsFactories | null) => void;
+  /** True when a doc + factories are attached, i.e. patches will be written. */
+  isActive: () => boolean;
+  /** Queue interim geometry for an element. */
+  patchGeometry: (slideId: string | undefined, elementId: string, geometry: LiveGeometryPatch) => void;
+  /** Queue interim text for an element (remapped over `source`'s segments). */
+  patchText: (slideId: string | undefined, elementId: string, text: string, source?: LiveTextSource) => void;
+  /** Write everything queued right now (call on gesture end / edit commit). */
+  flush: () => void;
+  /** Drop pending work, cancel timers and detach the doc. */
+  dispose: () => void;
+}
+//#endregion
+//#region src/render/slide-compare.d.ts
+type SlideDiffStatus = 'added' | 'removed' | 'changed' | 'unchanged';
+type ElementChangeKind = 'added' | 'removed' | 'moved' | 'resized' | 'textChanged';
+interface ElementChange {
+  elementId: string;
+  label: string;
+  kind: ElementChangeKind;
+  description: string;
+}
+interface SlideDiff {
+  status: SlideDiffStatus;
+  /** Index in the base (current) presentation, or -1 for added slides. */
+  baseIndex: number;
+  /** Index in the compare (other) presentation, or -1 for removed slides. */
+  compareIndex: number;
+  /** The base slide data (undefined for added slides). */
+  baseSlide?: PptxSlide;
+  /** The compare slide data (undefined for removed slides). */
+  compareSlide?: PptxSlide;
+  /** Per-element changes when status is `changed`. */
+  changes: ElementChange[];
+}
+interface CompareResult {
+  diffs: SlideDiff[];
+  baseSlideCount: number;
+  compareSlideCount: number;
+  addedCount: number;
+  removedCount: number;
+  changedCount: number;
+  unchangedCount: number;
+}
 /**
  * A font supplied by the host application. The package never ships fonts:
  * applications provide a licensed URL, data URL, or blob URL for their users.
@@ -7922,6 +8732,105 @@ interface ViewerFontSource {
   weight?: string | number;
   style?: 'normal' | 'italic';
 }
+/** The configuration emitted when a broadcast starts. */
+interface BroadcastConfig {
+  roomId: string;
+  serverUrl: string;
+  /** Derived from serverUrl: empty server means peer-to-peer (webrtc). */
+  transport?: CollaborationTransport;
+}
+//#endregion
+//#region src/render/presentation-session-types.d.ts
+interface PresentationSnapshot {
+  slideIndex: number;
+  buildStep: number;
+  sequence: number;
+  blackout: 'none' | 'black' | 'white';
+  paused: boolean;
+  elapsedMs: number;
+  zoom?: PresentationZoomState;
+  pointer?: PresentationPointerState;
+  inkStrokes?: PresentationInkStroke[];
+  caption?: string;
+  subtitlesVisible?: boolean;
+}
+interface PresentationZoomState {
+  scale: number;
+  originX: number;
+  originY: number;
+}
+type PresentationPointerTool = 'none' | 'laser' | 'pen' | 'highlighter' | 'eraser';
+interface PresentationPointerState {
+  tool: PresentationPointerTool;
+  x: number;
+  y: number;
+  color: string;
+}
+interface PresentationInkPoint {
+  x: number;
+  y: number;
+}
+interface PresentationInkStroke {
+  id: string;
+  slideIndex: number;
+  tool: 'pen' | 'highlighter';
+  color: string;
+  width: number;
+  points: PresentationInkPoint[];
+}
+//#endregion
+//#region src/render/find-replace.d.ts
+/** Identifies a single match of the find query at segment-level precision. */
+interface FindResult {
+  /** Zero-based index of the slide in the slides array. */
+  slideIndex: number;
+  /** Id of the element that contains the match. */
+  elementId: string;
+  /** Zero-based index of the text segment within the element's `textSegments`. */
+  segmentIndex: number;
+  /** Character offset of the match start within the segment text. */
+  startOffset: number;
+  /** Number of characters matched (equals `query.length`). */
+  length: number;
+}
+//#endregion
+//#region src/render/ink-drawing.d.ts
+/** A 2D point in stage-local coordinates. */
+interface InkPoint {
+  x: number;
+  y: number;
+}
+//#endregion
+//#region src/render/mobile-chrome.d.ts
+/**
+ * Pure helper logic for mobile chrome state, shared by every binding.
+ *
+ * These helpers capture the sheet open/close state machine that governs which
+ * sheet is visible at any given time and which bottom-bar button appears active.
+ * Keeping this logic as pure functions makes it straightforward to test and
+ * trivial to adapt when each binding wires the components together.
+ */
+/** All mobile sheets that can be open at one time. */
+type MobileSheetKey = 'slides' | 'menu' | 'insert' | 'inspector' | 'comments' | 'notes' | null;
+/** In-memory clipboard payload stored when an element is copied or cut. */
+interface ElementClipboardPayload {
+  element: PptxElement;
+  isTemplate: boolean;
+}
+//#endregion
+//#region src/render/template-editing.d.ts
+type TemplateElementMap = Record<string, PptxElement[]>;
+//#endregion
+//#region src/render/viewer-preferences.d.ts
+/** Framework-neutral viewer preferences surfaced by Settings dialogs. */
+interface ViewerPreferences {
+  autoSave: boolean;
+  spellCheck: boolean;
+  showGrid: boolean;
+  showRulers: boolean;
+  snapToGrid: boolean;
+  reducedMotion: boolean;
+}
 /**
  * Optional hook point for hosts that want to wire a real sign-in flow into
  * File > Account. Disabled by default: the Account page renders nothing
@@ -7997,12 +8906,233 @@ interface PrintSettings {
 }
 
 //#endregion
-//#region src/i18n/locale-catalog.d.ts
-/** One selectable entry in the viewer chrome's built-in language picker (File > Options > Language). */
-interface LocaleCatalogEntry {
-  /** BCP-47-ish locale code, e.g. `'en'`, `'fr'`. Matches `pptx-viewer-locales`' exports. */
-  code: string;
-  /** English display name, used before a translation dictionary for the target locale is loaded. */
+//#region src/ai/change-animator.d.ts
+/** Host-tunable options for how AI edits are animated on the canvas. */
+interface AiChangeAnimationConfig {
+  /** Master switch. Default true. */
+  enabled?: boolean;
+  /** How long the motion + glow plays, in ms. Default 900. */
+  durationMs?: number;
+  /** Draw the pulsing glow highlight on changed elements. Default true. */
+  glow?: boolean;
+  /** Glide old->new bounds and cross-fade colours. Default true. */
+  tween?: boolean;
+  /** Accent colour (any CSS colour) for the glow/ghosts. Default a blue. */
+  color?: string;
+}
+//#endregion
+//#region src/ai/config.d.ts
+/** The UI message shape exchanged with the assistant. Alias of the SDK type. */
+type PptxAiUIMessage = UIMessage;
+/**
+ * Canonical name of every tool the assistant can call. Document tools mirror the
+ * `pptx-viewer-mcp` server exactly (they ARE the same functions, run against the
+ * live deck); the viewer-only tools (navigation, deck outline, element/notes
+ * readers, table merge) have no MCP counterpart.
+ */
+type PptxAiToolName = 'get_deck_overview' | 'get_slide' | 'get_element' | 'get_speaker_notes' | 'find_text' | 'get_theme' | 'go_to_slide' | 'select_elements' | 'merge_tables' | 'get_metadata' | 'get_layouts' | 'find_placeholders' | 'get_presentation_properties' | 'run_accessibility_check' | 'convert_to_markdown' | 'add_element' | 'update_element' | 'delete_elements' | 'arrange_elements' | 'clone_element' | 'set_element_animation' | 'group_elements' | 'ungroup_elements' | 'batch_update_elements' | 'update_element_style' | 'replace_geometry' | 'set_element_lock' | 'manage_hyperlinks' | 'replace_text' | 'manage_comments' | 'update_table_cells' | 'manage_table_structure' | 'create_chart' | 'update_chart' | 'add_chart_series' | 'remove_chart_series' | 'update_chart_series_data' | 'manage_smart_art' | 'apply_template' | 'add_slide' | 'duplicate_slide' | 'delete_slides' | 'reorder_slides' | 'update_slide_properties' | 'set_slide_transition' | 'apply_theme_preset' | 'update_theme_colors' | 'update_theme_fonts' | 'set_canvas_size' | 'update_metadata' | 'manage_sections' | 'update_presentation_properties' | 'apply_layout';
+type Resolvable<T> = T | (() => T | Promise<T>);
+/** How the assistant reaches a language model. */
+type PptxAiConnection =
+/**
+ * Post messages to a host backend route (recommended for production so the
+ * provider API key stays server-side). Maps to `DefaultChatTransport`.
+ */
+{
+  kind: 'endpoint';
+  api: string;
+  headers?: Resolvable<Record<string, string>>;
+  body?: Resolvable<Record<string, unknown>>;
+  credentials?: RequestCredentials;
+  fetch?: typeof globalThis.fetch;
+} |
+/**
+ * Run a language model in-process in the browser (bring-your-own key /
+ * local model). Maps to a `ToolLoopAgent` behind a `DirectChatTransport`.
+ */
+{
+  kind: 'model';
+  model: LanguageModel;
+  system?: string;
+  maxSteps?: number;
+} |
+/** Provide a fully-constructed transport (advanced / testing escape hatch). */
+{
+  kind: 'transport';
+  transport: ChatTransport<PptxAiUIMessage>;
+};
+/** How writes proposed by the assistant reach the document. */
+type PptxAiWritePolicy = 'stage' | 'approve' | 'auto';
+/** Which deck context is fed to the model with each turn. */
+type PptxAiContextStrategy = 'outline' | 'current-slide' | 'none';
+/** Optional per-session history persistence hooks. */
+interface PptxAiHistoryHooks {
+  load?(id: string): Promise<PptxAiUIMessage[]>;
+  save?(id: string, messages: PptxAiUIMessage[]): Promise<void>;
+}
+/** Complete host configuration for an AI chat session. */
+interface PptxAiConfig {
+  connection: PptxAiConnection;
+  /** Extra host instructions appended to the base system prompt. */
+  systemPromptExtras?: string;
+  tools?: {
+    /** Allowlist. When set, only these tools are exposed. */
+    enabled?: PptxAiToolName[];
+    /** Denylist, applied after `enabled`. */
+    disabled?: PptxAiToolName[];
+    /** Additional host-defined tools merged into the tool set. */
+    extra?: ToolSet;
+  };
+  /** Default `'stage'`. */
+  writePolicy?: PptxAiWritePolicy;
+  /** Default `'outline'`. */
+  contextStrategy?: PptxAiContextStrategy;
+  history?: PptxAiHistoryHooks;
+  /**
+   * How AI edits are animated on the canvas so the user can watch them land
+   * (glide old->new, fade/scale in-out, glow-pulse). Omit for the defaults;
+   * set `{ enabled: false }` to turn it off.
+   */
+  changeAnimation?: AiChangeAnimationConfig;
+  onError?(error: Error): void;
+}
+//#endregion
+//#region src/ai/bridge.d.ts
+/** Lightweight, model-friendly summary of the whole deck. */
+interface PptxAiDeckMeta {
+  /** Total number of slides. */
+  slideCount: number;
+  /** Zero-based index of the currently active slide. */
+  activeSlideIndex: number;
+  /** Deck title, when known (first slide title / core properties). */
+  title?: string;
+  /** Slide canvas width in CSS pixels. */
+  width: number;
+  /** Slide canvas height in CSS pixels. */
+  height: number;
+}
+/** Severity hint for {@link PptxAiBridge.notify}. */
+type PptxAiNotifyLevel = 'info' | 'success' | 'warning' | 'error';
+/**
+ * A target the user has scoped the assistant to: either a whole slide or a
+ * single element on a slide. Returned by {@link PptxAiBridge.getFocusedTargets}
+ * so the context builder can tell the model exactly what to focus on.
+ */
+type PptxAiFocusedTarget = {
+  kind: 'slide';
+  slideIndex: number;
+} | {
+  kind: 'element';
+  slideIndex: number;
+  elementId: string;
+};
+/**
+ * A pure updater over the deck's slides. It receives a deep clone of the
+ * current slides (mutation-safe) and returns the next slides array. The bridge
+ * commits the returned array as ONE history entry.
+ */
+type PptxAiSlidesUpdater = (slides: PptxSlide[]) => PptxSlide[];
+/**
+ * A pure updater over the whole parsed deck ({@link PptxData}). Mirrors the
+ * `pptx-viewer-mcp` tool model (data in, mutated data out) so presentation-level
+ * MCP tools (metadata, sections, canvas size, presentation properties, layouts)
+ * can be committed as ONE undoable history entry through {@link
+ * PptxAiBridge.applyDeckData}. Optional: bindings that only track slide/theme
+ * state can omit it, in which case those presentation-level tools report that
+ * they are unavailable in this viewer while every slide/theme tool still works.
+ */
+type PptxAiDataUpdater = (data: PptxData) => PptxData;
+/** Field-level updates for a single element, mirroring the MCP update vocab. */
+interface PptxAiElementUpdate {
+  x?: number;
+  y?: number;
+  width?: number;
+  height?: number;
+  rotation?: number;
+  opacity?: number;
+  hidden?: boolean;
+  flipHorizontal?: boolean;
+  flipVertical?: boolean;
+  text?: string;
+  fontSize?: number;
+  fontFamily?: string;
+  fontColor?: string;
+  bold?: boolean;
+  italic?: boolean;
+  underline?: boolean;
+  align?: 'left' | 'center' | 'right' | 'justify';
+  fillColor?: string;
+  strokeColor?: string;
+  strokeWidth?: number;
+}
+/**
+ * Implemented by each binding to expose its live editor to the AI core.
+ *
+ * Read methods must be cheap and synchronous. Write methods must route through
+ * the binding's editor-history layer so AI edits are undoable like manual ones.
+ */
+interface PptxAiBridge {
+  /** Return a summary of the whole deck. */
+  getDeckMeta(): PptxAiDeckMeta;
+  /** Return the deck's slides. Callers must not mutate the returned array. */
+  getSlides(): PptxSlide[];
+  /** Return the zero-based index of the active slide. */
+  getActiveSlideIndex(): number;
+  /** Return the resolved presentation theme, when available. */
+  getTheme(): PptxTheme | undefined;
+  /** Return the underlying core handler, when the binding exposes one. */
+  getHandler(): PptxHandler | undefined;
+  /** Navigate the viewer to a slide by zero-based index. */
+  goToSlide(index: number): void;
+  /** Select the given elements on a slide (empty array clears selection). */
+  selectElements(slideIndex: number, elementIds: string[]): void;
+  /**
+   * Apply a slides updater as a single, atomic, undoable history entry. The
+   * binding is responsible for cloning current slides before calling
+   * `updater` and for installing the result.
+   */
+  applySlidesUpdate(updater: PptxAiSlidesUpdater, label: string): void;
+  /** Apply field updates to one element as a single history entry. */
+  updateElement(slideIndex: number, elementId: string, updates: PptxAiElementUpdate): void;
+  /** Apply partial theme updates as a single history entry. */
+  applyTheme(updates: Partial<PptxTheme>): void;
+  /**
+   * Return the full parsed {@link PptxData} for the open deck, with the live
+   * (edited) slides and theme overlaid. Enables `pptx-viewer-mcp` tools that
+   * read presentation-level state (metadata, sections, layouts, presentation
+   * properties). Optional: when absent, the AI core synthesises a minimal
+   * PptxData from slides + dimensions, which is enough for every slide/theme
+   * tool but not for presentation-level reads.
+   */
+  getDeckData?(): PptxData | undefined;
+  /**
+   * Commit a whole-deck {@link PptxData} mutation as one undoable history entry.
+   * Used to apply presentation-level MCP tool results (metadata, sections,
+   * canvas size, presentation properties, layouts). Optional: when absent,
+   * those tools report they are not supported in this viewer; slide/theme tools
+   * are unaffected (they route through {@link PptxAiBridge.applySlidesUpdate}
+   * and {@link PptxAiBridge.applyTheme}).
+   */
+  applyDeckData?(updater: PptxAiDataUpdater, label: string): void;
+  /**
+   * Return the slides / elements the user has scoped the assistant to, if any.
+   * When present and non-empty, the context builder tells the model to focus on
+   * exactly these targets. Optional so existing bridges satisfy the contract
+   * without change; a bridge that does not implement it behaves as before (no
+   * focus scoping).
+   */
+  getFocusedTargets?(): PptxAiFocusedTarget[];
+  /** Surface a transient message in the host UI (toast / status line). */
+  notify?(message: string, level?: PptxAiNotifyLevel): void;
+}
+
+//#endregion
+//#region src/i18n/locale-catalog.d.ts
+/** One selectable entry in the viewer chrome's built-in language picker (File > Options > Language). */
+interface LocaleCatalogEntry {
+  /** BCP-47-ish locale code, e.g. `'en'`, `'fr'`. Matches `pptx-viewer-locales`' exports. */
+  code: string;
+  /** English display name, used before a translation dictionary for the target locale is loaded. */
   label: string;
   /** The locale's own name for itself, e.g. `'Français'` for `fr`. */
   nativeLabel: string;
@@ -8059,6 +9189,12 @@ interface ExportGifOptions {
  */
 /** Options for the print flow: any subset of the shared print settings. */
 type PrintOptions = Partial<PrintSettings>;
+/**
+ * Render a complete HTML document into a print surface and trigger printing.
+ * Returns `false` when the surface could not be opened (e.g. a custom
+ * `window.open`-based opener hit a popup blocker).
+ */
+type OpenPrintWindow = (htmlDocument: string) => boolean;
 
 /**
  * Video (WebM) export driven by the shared `video-plan` maths: segment timing
@@ -8089,6 +9225,9 @@ interface ExportVideoOptions {
     signal?: AbortSignal;
 }
 
+/** Rasterise the slide at `index` to an `HTMLCanvasElement`. Injected so the
+ * controller stays DOM-capture-free and unit-testable. */
+type RasterizeSlide = (index: number) => Promise<HTMLCanvasElement>;
 /** Per-slide progress callback: `(currentSlideIndex, totalSlides)`. */
 type ExportProgress = (current: number, total: number) => void;
 /** Options for the multi-slide PDF export (progress + cooperative cancel). */
@@ -8098,6 +9237,77 @@ interface ExportPdfOptions {
     /** Abort the export early; the loop checks this between slides. */
     signal?: AbortSignal;
 }
+interface ExportControllerDeps {
+    /** Live slide count; read fresh on every call. */
+    getSlideCount(): number;
+    /** Active slide index (0-based); the PNG export's default target. */
+    getCurrent(): number;
+    /** Live slide canvas size (px), for the PDF page size. */
+    getCanvasSize(): CanvasSize;
+    /** Live slide list (print needs slide notes/titles, not just the count). */
+    getSlides(): PptxSlide[];
+    rasterizeSlide: RasterizeSlide;
+    /** Print-surface opener override; see `export-print.ts` for the default. */
+    openPrintWindow?: OpenPrintWindow;
+    /** Base file name (without extension) for downloads. Defaults to `presentation`. */
+    fileName?: string;
+}
+/**
+ * Export controller (runes class): render slides to PNG / PDF / animated GIF /
+ * WebM video, plus the print flow. Started as a Svelte port of Vue's
+ * `useExport` composable (`packages/vue/src/viewer/composables/useExport.ts`)
+ * and now also covers React's `useExportHandlers` GIF/video surface (via
+ * `export-gif.ts` / `export-video.ts`) and Vue's `usePrint`
+ * (`export-print.ts`), reshaped as a `$state`-backed class to match this
+ * package's runes-class convention (see `EditorState` in
+ * `../editor/editor-state.svelte.ts`) rather than Vue `Ref`s.
+ *
+ * Rasterisation is delegated to the injected `rasterizeSlide` (the host owns
+ * the off-screen `SlideStage` mount + `html2canvas-pro`, see
+ * `rasterize-slide.ts`). `jspdf` is loaded lazily so it stays out of the main
+ * bundle.
+ */
+declare class ExportController {
+    #private;
+    /** True while an export is running (disable UI / show a spinner). */
+    exporting: boolean;
+    constructor(deps: ExportControllerDeps);
+    /** Export a single slide as a PNG download. Defaults to the current slide. */
+    exportSlidePng(index?: number): Promise<void>;
+    /** Copy a slide to the system clipboard as a PNG image. */
+    copySlideAsImage(index?: number): Promise<void>;
+    /** Export every slide as a multi-page PDF download (one slide per page). */
+    exportPdf(options?: ExportPdfOptions): Promise<void>;
+    /**
+     * Export every slide as an animated GIF download. Frame delays come from
+     * the shared `planGifFrames` plan (default duration + per-slide overrides);
+     * see `export-gif.ts`. Supports progress + AbortSignal like `exportPdf`.
+     */
+    exportGif(options?: ExportGifOptions): Promise<void>;
+    /**
+     * Export every slide as a WebM video download (MediaRecorder over a canvas
+     * capture stream, timing from the shared `planVideoSegments` plan); see
+     * `export-video.ts`. Supports progress + AbortSignal like `exportPdf`.
+     */
+    exportVideo(options?: ExportVideoOptions): Promise<void>;
+    /**
+     * Assemble the shared print document for the given (partial) settings and
+     * open it in the print surface (hidden iframe by default; see
+     * `export-print.ts` for the popup-blocker caveats of custom openers).
+     * Resolves `true` when the print surface opened.
+     */
+    print(options?: PrintOptions): Promise<boolean>;
+}
+
+/** Translate `key`, interpolating `{{name}}` placeholders from `params`. */
+type Translator = (key: string, params?: Record<string, string | number>) => string;
+
+interface ExportWiring {
+    /** The reactive PNG/PDF export controller (`exporting` drives a spinner). */
+    controller: ExportController;
+    /** Tear down the off-screen capture stage (component destroy). */
+    destroy(): void;
+}
 
 type SvgExportSingleSlideOptions = SvgExportOptions;
 type SvgExportAllOptions = SvgExportOptions;
@@ -8112,6 +9322,16 @@ declare function exportAllSlidesToSvg(data: PptxData, options?: SvgExportAllOpti
 /** Export the selected presentation slides as SVG Blobs. */
 declare function exportAllSlidesToSvgBlobs(data: PptxData, options?: SvgExportAllOptions): Blob[];
 
+/** The imperative export API exposed on the `PowerPointViewer` instance. */
+interface ExportingApi {
+    exportSlidePng(index?: number): Promise<void>;
+    copySlideAsImage(index?: number): Promise<void>;
+    exportPdf(options?: ExportPdfOptions): Promise<void>;
+    exportGif(options?: ExportGifOptions): Promise<void>;
+    exportVideo(options?: ExportVideoOptions): Promise<void>;
+    print(options?: PrintOptions): Promise<boolean>;
+}
+
 /** Payload for the `onload` callback. */
 interface ViewerLoadDetail {
     /** Number of slides in the loaded presentation. */
@@ -8198,11 +9418,11 @@ interface PowerPointViewerProps {
      */
     showNotes?: boolean;
     /**
-     * Opt in to the experimental Three.js (WebGL) SmartArt renderer for
-     * `smartArt` elements, in place of the default SVG renderer. Requires the
-     * optional `three` peer dependency; when it is unavailable, or a diagram
-     * has no renderable nodes, or the WebGL mount fails, the SVG renderer is
-     * used automatically. Default false.
+     * Opt in to the Three.js (WebGL) SmartArt renderer for `smartArt` elements,
+     * in place of the default SVG renderer. Requires the optional `three` peer
+     * dependency; when it is unavailable, or a diagram has no renderable nodes,
+     * or the WebGL mount fails, the SVG renderer is used automatically. Default
+     * false.
      */
     smartArt3D?: boolean;
     /**
@@ -8291,6 +9511,15 @@ interface PowerPointViewerProps {
         userName?: string;
         serverUrl?: string;
     };
+    /**
+     * Optional AI assistant configuration. When provided, a Sparkles toggle
+     * appears in the ribbon's command row and opens a right-side chat panel that
+     * can read the open deck and propose edits through the viewer's undo history.
+     * The panel (and the optional `@ai-sdk/svelte` + `ai` peers it needs) is
+     * lazily loaded only when first opened; leaving this undefined ships no AI UI
+     * and never pulls the SDK. See `pptx-viewer-shared/ai`'s `PptxAiConfig`.
+     */
+    ai?: PptxAiConfig;
 }
 /**
  * Imperative editing API exposed on the `<PowerPointViewer>` component
@@ -8366,6 +9595,1012 @@ interface PowerPointViewerApi extends PowerPointViewerAPI {
  */
 declare const PowerPointViewer: Component<PowerPointViewerProps, PowerPointViewerApi>;
 
+/**
+ * Shared value types for the Svelte editing layer.
+ */
+/** Box geometry in element (unscaled slide) px. */
+interface OverlayBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation: number;
+}
+
+interface EditorControllerDeps {
+    getScale(): number;
+    getCurrent(): number;
+    getPresenting(): boolean;
+    getStageRoot(): Element | null;
+    getHolderEl(): HTMLElement | null;
+    onCursorMove?(x: number, y: number): void;
+    onContextMenu?(x: number, y: number): void;
+    getSnapToGrid?(): boolean;
+    getSnapToShape?(): boolean;
+    getGuides?(): readonly {
+        axis: 'h' | 'v';
+        position: number;
+    }[];
+    /**
+     * Transform inline-editor text at commit time (File > Options > Proofing
+     * AutoCorrect); identity when unset.
+     */
+    transformCommittedText?(text: string): string;
+    /**
+     * Collaboration live-preview channel. Inline text only reaches the slides
+     * state on commit, so peers saw nothing while a peer typed; each keystroke is
+     * published through this instead. Omit outside a collaborative viewer.
+     */
+    getLivePatcher?(): CollaborationLivePatcher | undefined;
+    /** The slide the inline-edited element belongs to (live-preview lookup). */
+    getActiveSlide?(): PptxSlide | undefined;
+}
+
+/**
+ * Pure, immutable slide-array mutations for the Svelte editor.
+ *
+ * Mirrors the vanilla binding's `editor-mutations` (in turn the Vue binding's
+ * `useEditorOperations` commit helpers), minus the reactivity: every function
+ * takes the current `PptxSlide[]` and returns a brand-new array (untouched
+ * slides are reused by reference so the render layer can cheaply detect
+ * changes). All cloning defers to the core helpers (`cloneSlide`,
+ * `cloneElement`, `duplicateElement`); nothing is mutated in place.
+ */
+/** Geometry patch applied by drag / resize / rotate / nudge. */
+interface ElementBoxPatch {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation: number;
+}
+
+interface EditorMarqueeRect extends MarqueeRect {
+    additive: boolean;
+}
+
+/**
+ * Element-animation actions for the ribbon's Animations tab, split out of
+ * `EditorState` to keep it under the repo's 300-LOC budget.
+ *
+ * Animation data lives on the SLIDE (`PptxSlide.animations`, keyed by
+ * `elementId`), not on the element itself, matching how the presentation
+ * playback state machine reads it (`buildClickGroups` in
+ * `presentation/animation-playback.svelte.ts`). Both actions target the
+ * currently selected element and route through the shared
+ * `animation-authoring.ts` "coarse group preset" model (`applyAnimationPreset`
+ * / `removeElementAnimation`), the same one the Vue/vanilla ribbons use:
+ * applying a preset sets one of entrance/emphasis/exit without touching the
+ * others; remove drops the whole entry. Both mutations go through
+ * `EditorState.commitSlides`, so they are history-integrated (undoable).
+ */
+declare class EditorAnimationController {
+    #private;
+    constructor(editor: EditorState);
+    addAnimation(group: AnimationGroup, preset: PptxAnimationPreset): void;
+    removeAnimation(): void;
+}
+
+/**
+ * The Home tab's multi-select-aware Arrange group (align / distribute /
+ * flip / group / ungroup), split out of `EditorState` to keep it under the
+ * repo's 300-LOC budget. Reads `editor.selection.ids` (the ordered
+ * multi-selection) rather than just the primary id, matching React's
+ * `selectedElementIds` semantics.
+ */
+declare class EditorArrangeController {
+    #private;
+    constructor(editor: EditorState);
+    /** Align every selected element to `edge` (needs >= 2 selected). */
+    alignSelected(edge: AlignEdge): void;
+    /** Distribute the selected elements evenly along `axis` (needs >= 3 selected). */
+    distributeSelected(axis: DistributeAxis): void;
+    /** Flip every selected element across `axis`. */
+    flipSelected(axis: 'horizontal' | 'vertical'): void;
+    /** Group the selected elements (needs >= 2 selected). Selects the new group. */
+    groupSelected(): void;
+    /** Ungroup the primary selected group element. Selects the ungrouped children. */
+    ungroupSelected(): void;
+}
+
+/**
+ * Slide-background actions for the ribbon's Design tab "Format Background"
+ * panel, split out of `EditorState` to keep it under the repo's 300-LOC
+ * budget (mirrors `EditorSlidesController` / `EditorArrangeController`).
+ *
+ * Solid-colour fill only (matches the docked panel's scope: a single colour
+ * input); clearing removes every background field so the slide falls back to
+ * its layout/master background. Both mutations route through
+ * `EditorState.commitSlides`, so they are history-integrated (undoable) like
+ * every other ribbon mutation.
+ */
+declare class EditorBackgroundController {
+    #private;
+    constructor(editor: EditorState);
+    /** Set the current slide's background to a solid colour. */
+    setSlideBackgroundColor(color: string): void;
+    /** Clear every background field on the current slide (fall back to layout/master). */
+    clearSlideBackground(): void;
+}
+
+/**
+ * Ctrl+C/X/V and the Home tab's Clipboard group, split out of `EditorState`
+ * to keep it under the repo's 300-LOC budget. Operates entirely through
+ * `EditorState`'s public surface (`slides`, `selection`, `currentSlideIndex`,
+ * `commitSlides`), the same contract a component would use.
+ */
+declare class EditorClipboardController {
+    #private;
+    constructor(editor: EditorState);
+    /** Copy the primary selected element to the clipboard (works read-only, like React). */
+    copySelected(): void;
+    /** Copy the primary selected element then delete it (with history). */
+    cutSelected(): void;
+    /** Paste the clipboard payload onto the current slide (fresh id, offset, selects it). */
+    pasteClipboard(): string | null;
+}
+
+/**
+ * Z-order (paint-order) reordering for the Svelte editor.
+ *
+ * The array-level primitives (`bringToFront`, `sendToBack`, `bringForward`,
+ * `sendBackward`) are the shared, framework-agnostic operations from
+ * `pptx-viewer-shared` (`render/element-operations`), where array index 0 is
+ * the back and the last index is the front. This module only lifts them to the
+ * slide-array shape the editor state stores, reusing the same immutable
+ * `mapSlideElements` helper as the other mutations.
+ */
+/** Which way to move the selected element through the paint-order stack. */
+type ZOrderDirection = 'front' | 'back' | 'forward' | 'backward';
+
+/** History-integrated element and notes mutations for {@link EditorState}. */
+declare class EditorElementController {
+    #private;
+    constructor(editor: EditorState);
+    resetNudge(): void;
+    patchGeometry(id: string, box: ElementBoxPatch): void;
+    deleteSelected(): void;
+    duplicateSelected(): string | null;
+    applyElementPatch(id: string, patch: Partial<PptxElement>): void;
+    patchSelected(patch: Partial<PptxElement>): void;
+    insertElement(element: PptxElement): string | null;
+    reorderSelected(direction: ZOrderDirection): void;
+    nudgeSelected(dx: number, dy: number): void;
+    commitInlineText(id: string, text: string): void;
+    commitNotes(notes: string, notesSegments?: TextSegment[]): void;
+}
+
+/** Existing-equation edit state with history-integrated OMML replacement. */
+declare class EditorEquationController {
+    private readonly editor;
+    editingId: string | null;
+    constructor(editor: EditorState);
+    open(id: string): boolean;
+    get omml(): Record<string, unknown> | null;
+    apply(omml: Record<string, unknown>): void;
+    close(): void;
+}
+
+/** One-shot Format Painter state and history-integrated application. */
+declare class EditorFormatPainterController {
+    #private;
+    private readonly editor;
+    constructor(editor: EditorState);
+    get active(): boolean;
+    get enabled(): boolean;
+    toggle(): void;
+    applyTo(id: string): boolean;
+    cancel(): void;
+}
+
+/**
+ * The ribbon Draw tab's active tool. `'select'` means "not drawing": the
+ * stage's normal selection/drag/resize gestures own the pointer, matching
+ * React's `DrawingTool` / Angular's `DrawTool` conventions (minus `freeform`,
+ * out of scope for this wave; see the Draw tab's JSDoc).
+ */
+type InkDrawTool = 'select' | 'pen' | 'highlighter' | 'eraser';
+/**
+ * EditorInkController: the ribbon Draw tab's tool/colour/width state plus the
+ * pure element-factory / erase mutations, split out of `EditorState` to keep
+ * it under the repo's 300-LOC budget (mirrors `EditorArrangeController` /
+ * `EditorBackgroundController`). Instantiated as `EditorState.inkOps`.
+ *
+ * The actual pointer-event lifecycle (accumulating a stroke's points, driving
+ * the live preview) lives in `editor-ink-gesture.ts`, owned by
+ * `EditorController`; this class only holds the tool/colour/width state the
+ * gesture controller reads and the two mutations it calls into
+ * ({@link commitStroke}, {@link eraseElementAt}), both of which route through
+ * `EditorState` so they participate in undo/redo like every other edit.
+ */
+declare class EditorInkController {
+    #private;
+    /** The active draw tool. `'select'` hands the stage back to normal editing gestures. */
+    tool: InkDrawTool;
+    /** Stroke colour for new pen/highlighter strokes. */
+    color: string;
+    /** Stroke width (px, element space) for new pen/highlighter strokes. */
+    width: number;
+    /** SVG path `d` for the in-progress stroke's live preview, or `''` when idle. */
+    livePathD: string;
+    constructor(editor: EditorState);
+    /** True whenever a tool other than `select` is active: the stage hands pointer gestures to ink drawing. */
+    get isDrawing(): boolean;
+    /**
+     * Switch the active tool. Clears the current selection when entering a draw
+     * tool so the selection overlay's resize/rotate handles (which own their
+     * own `pointerdown` and would otherwise race a drawing gesture over the
+     * same screen area) are not rendered while drawing.
+     */
+    setTool(tool: InkDrawTool): void;
+    setColor(color: string): void;
+    setWidth(width: number): void;
+    /** Update the live preview path while a pen/highlighter stroke is in progress. */
+    previewStroke(points: readonly InkPoint[]): void;
+    /**
+     * Finalise the in-progress stroke into a new `ink` element (undoable via
+     * `EditorState.insertElement`), or discard it silently when too short (a
+     * plain tap) or the tool changed mid-gesture.
+     */
+    commitStroke(points: readonly InkPoint[]): void;
+    /**
+     * Hit-test `ink` elements on the current slide at `point` (topmost first)
+     * and delete the first match, with history. No-op when nothing is hit.
+     */
+    eraseElementAt(point: InkPoint): void;
+}
+
+interface MasterViewTarget {
+    tab: MasterViewTab;
+    masterIndex: number;
+    layoutIndex: number | null;
+}
+/** Routes the active editing layer into a parsed slide master or layout. */
+declare class EditorMasterController {
+    private readonly editor;
+    constructor(editor: EditorState);
+    enter(masterIndex?: number, layoutIndex?: number | null): void;
+    enterTab(tab: MasterViewTab): void;
+    exit(): void;
+    activeElements(): PptxElement[] | null;
+    replace(elements: PptxElement[]): boolean;
+    cloneMasters(): PptxSlideMaster[];
+    cloneNotesMaster(): PptxNotesMaster | undefined;
+    cloneHandoutMaster(): PptxHandoutMaster | undefined;
+    setHandoutSlidesPerPage(slidesPerPage: number): void;
+    setBackgroundColor(backgroundColor: string): void;
+}
+
+interface PresentationMetadataHost {
+    readonly editable: boolean;
+    pushHistory(): void;
+    commitChange(): void;
+}
+/** Owns presentation-level metadata and its undoable editor mutations. */
+declare class EditorPresentationMetadata {
+    private readonly host;
+    headerFooter: PptxHeaderFooter;
+    presentationProperties: PptxPresentationProperties;
+    customShows: PptxCustomShow[];
+    constructor(host: PresentationMetadataHost);
+    set(headerFooter?: PptxHeaderFooter, presentationProperties?: PptxPresentationProperties, customShows?: PptxCustomShow[]): void;
+    updatePresentationProperties(next: PptxPresentationProperties): void;
+    updateHeaderFooter(next: PptxHeaderFooter): void;
+    updateCustomShows(next: PptxCustomShow[]): void;
+    private commit;
+}
+
+/** History-aware section CRUD and grouping for the Svelte editor. */
+declare class EditorSectionController {
+    private readonly editor;
+    constructor(editor: EditorState);
+    get groups(): SectionSlideGroup<PptxSection>[];
+    add(name: string, afterSlideIndex?: number): string | null;
+    rename(sectionId: string, name: string): void;
+    delete(sectionId: string): void;
+    moveUp(sectionId: string): void;
+    moveDown(sectionId: string): void;
+    moveSlides(slideIndexes: number[], targetSectionId: string): void;
+    toggle(sectionId: string): void;
+    private commit;
+}
+
+/**
+ * EditorSelection: the reactive multi-element selection for the Svelte editor.
+ *
+ * Holds an ordered list of selected element ids; the LAST id is the primary
+ * selection (the one the overlay handles, gestures, and inline editing act
+ * on), matching the React binding's `selectedElementIds` + primary convention.
+ * Plain clicks call {@link set} (single selection), shift/ctrl clicks call
+ * {@link toggle} (additive), and mutations that invalidate ids call
+ * {@link prune}.
+ */
+declare class EditorSelection {
+    #private;
+    /** All selected ids in selection order (primary last). */
+    get ids(): readonly string[];
+    /** The primary selected id (last selected), or null when empty. */
+    get primary(): string | null;
+    /** Number of selected elements. */
+    get size(): number;
+    /** True when `id` is part of the selection. */
+    has(id: string): boolean;
+    /** Replace the selection with a single id (or clear it with `null`). */
+    set(id: string | null): void;
+    /** Replace the selection with an explicit id list (primary = last). */
+    setAll(ids: readonly string[]): void;
+    /** Additive (shift/ctrl-click) toggle: add `id`, or remove it when present. */
+    toggle(id: string): void;
+    /** Clear the selection. */
+    clear(): void;
+    /** Drop ids that no longer resolve to an element (after remote/undo edits). */
+    prune(exists: (id: string) => boolean): void;
+}
+
+/**
+ * The Home tab's Slides group (new / duplicate / delete slide), split out of
+ * `EditorState` to keep it under the repo's 300-LOC budget. Every method
+ * returns the new active slide index (or `null` on a no-op) so the caller
+ * (the Slides group, via the host's slide-navigation callback) can move the
+ * viewer to it; `EditorState` itself has no concept of "the active slide"
+ * beyond the `getCurrent` dependency it already reads for element ops.
+ */
+declare class EditorSlidesController {
+    #private;
+    constructor(editor: EditorState);
+    /** Insert a blank slide after the current one. Returns its new index, or null when not editable. */
+    insertSlideAfterCurrent(): number | null;
+    /** Duplicate the current slide. Returns its new index, or null when not editable. */
+    duplicateCurrentSlide(): number | null;
+    /** Delete the current slide. Returns the new active index, or null (not editable / only slide). */
+    deleteCurrentSlide(): number | null;
+    /**
+     * The layouts available for the current slide (its master's layouts),
+     * resolved via the core `getAvailableLayoutsForSlide` API. Empty when no
+     * deck is loaded. Backs the Home tab's Layout dropdown (React parity).
+     */
+    availableLayouts(): Promise<PptxLayoutOption[]>;
+    /** Re-map the current slide onto `layoutPath`. Returns its index, or null when not editable. */
+    applyLayout(layoutPath: string): Promise<number | null>;
+    /**
+     * Reset the current slide by re-applying its own layout, restoring inherited
+     * placeholder geometry/formatting (React's Home > Reset). Returns the slide
+     * index, or null when the slide has no known layout path.
+     */
+    resetSlide(): Promise<number | null>;
+    /** Move an arbitrary thumbnail slide. Returns the selected target index on success. */
+    moveSlide(fromIndex: number, toIndex: number): number | null;
+}
+
+/** Active-layer routing for normal slide content versus inherited template elements. */
+declare class EditorTemplateController {
+    #private;
+    constructor(editor: EditorState);
+    activeElements(): PptxElement[];
+    renderedSlides(): PptxSlide[];
+    replace(elements: PptxElement[]): void;
+    commit(elements: PptxElement[]): void;
+}
+
+/**
+ * Slide-transition actions for the ribbon's Transitions tab, split out of
+ * `EditorState` to keep it under the repo's 300-LOC budget. Playback already
+ * reads `PptxSlide.transition` (see `presentation/presentation-controller.svelte.ts`),
+ * so this only needs to write that same field, routed through
+ * `EditorState.commitSlides` so it is history-integrated (undoable).
+ *
+ * `applyTransition` covers both the preset gallery buttons and the duration
+ * input (the tab re-applies the currently-selected preset whenever the
+ * duration changes), plus the "Apply to All Slides" checkbox: when
+ * `applyToAll` is true every slide gets the same fresh `{ type, durationMs }`
+ * transition; otherwise only the current slide is patched, preserving any
+ * advanced fields (direction, sound, ...) it already carried.
+ */
+declare class EditorTransitionController {
+    #private;
+    constructor(editor: EditorState);
+    applyTransition(type: PptxTransitionType, durationMs: number, applyToAll: boolean): void;
+}
+
+interface EditorStateDeps {
+    getCurrent(): number;
+    getHandler(): PptxHandler | null;
+    onChange?: () => void;
+}
+declare class EditorState {
+    #private;
+    slides: PptxSlide[];
+    templateElementsBySlideId: TemplateElementMap;
+    slideMasters: PptxSlideMaster[];
+    notesMaster: PptxNotesMaster | undefined;
+    handoutMaster: PptxHandoutMaster | undefined;
+    sections: PptxSection[];
+    readonly presentationMetadata: EditorPresentationMetadata;
+    coreProperties: PptxCoreProperties | undefined;
+    appProperties: PptxAppProperties | undefined;
+    customProperties: PptxCustomProperty[];
+    masterViewTarget: MasterViewTarget | null;
+    readonly selection: EditorSelection;
+    editable: boolean;
+    dirty: boolean;
+    editTemplateMode: boolean;
+    interactionActive: boolean;
+    clipboard: ElementClipboardPayload | null;
+    readonly clipboardOps: EditorClipboardController;
+    readonly elementOps: EditorElementController;
+    readonly templateOps: EditorTemplateController;
+    readonly slidesOps: EditorSlidesController;
+    readonly sectionOps: EditorSectionController;
+    readonly arrangeOps: EditorArrangeController;
+    readonly backgroundOps: EditorBackgroundController;
+    readonly transitionOps: EditorTransitionController;
+    readonly animationOps: EditorAnimationController;
+    readonly inkOps: EditorInkController;
+    readonly masterOps: EditorMasterController;
+    readonly formatPainter: EditorFormatPainterController;
+    readonly equationOps: EditorEquationController;
+    constructor(deps: EditorStateDeps);
+    get canUndo(): boolean;
+    get headerFooter(): PptxHeaderFooter;
+    get presentationProperties(): PptxPresentationProperties;
+    get customShows(): PptxCustomShow[];
+    get canRedo(): boolean;
+    get selectedElementId(): string | null;
+    get selectedElement(): PptxElement | undefined;
+    get selectedElements(): PptxElement[];
+    get activeElements(): PptxElement[];
+    get renderedSlides(): PptxSlide[];
+    get hasClipboard(): boolean;
+    get currentSlideIndex(): number;
+    /** The loaded core handler, or null before a deck is open. Used by the
+     *  Slides group for layout switching (`applyLayoutToSlide`). */
+    getHandler(): PptxHandler | null;
+    setSlides(slides: PptxSlide[], slideMasters?: PptxSlideMaster[], notesMaster?: PptxNotesMaster, handoutMaster?: PptxHandoutMaster, sections?: PptxSection[], coreProperties?: PptxCoreProperties, appProperties?: PptxAppProperties, customProperties?: PptxCustomProperty[], headerFooter?: PptxHeaderFooter, presentationProperties?: PptxPresentationProperties, customShows?: PptxCustomShow[]): void;
+    /**
+     * Replace the working slides with a remote (collaboration) snapshot without
+     * recording an undo step or touching the dirty flag: the granular reconcile
+     * already merged the peer's change, and treating an incoming remote edit as
+     * a local mutation would both pollute the undo stack and re-broadcast it.
+     *
+     * Selection is preserved when the selected element still exists so a remote
+     * edit does not yank the local user's selection out from under them. Local
+     * undo history is intentionally kept (see the collaboration module JSDoc):
+     * shared defines no collaborative-undo semantics, so, matching React/Vue,
+     * local undo may fight a concurrent remote edit.
+     */
+    applyRemoteSlides(slides: PptxSlide[]): void;
+    reset(): void;
+    select(id: string | null): void;
+    isElementInteractive(id: string): boolean;
+    setTemplateEditing(enabled: boolean): void;
+    /**
+     * Apply the File > Options "maximum number of undos" value. Recreates the
+     * history stack when the depth changes (PowerPoint likewise applies the new
+     * maximum going forward; existing entries are dropped).
+     */
+    setHistoryDepth(depth: number): void;
+    pushHistory(): void;
+    commitChange(): void;
+    /** Patch geometry without history for live gesture preview frames. */
+    patchGeometry: (id: string, box: ElementBoxPatch) => void;
+    replaceActiveElements(elements: PptxElement[]): void;
+    /** Commit a replacement active element collection as one undo step. */
+    commitActiveElements(elements: PptxElement[]): void;
+    /**
+     * Replace the whole slide array with history (the generic multi-slide
+     * mutation entry point: slide add/duplicate/delete, arrange group ops,
+     * and find/replace all route through this so every change is a single
+     * undoable step). No-op when not editable.
+     */
+    commitSlides(next: PptxSlide[]): void;
+    deleteSelected: () => void;
+    duplicateSelected: () => string | null;
+    applyElementPatch: (id: string, patch: Partial<PptxElement>) => void;
+    patchSelected: (patch: Partial<PptxElement>) => void;
+    insertElement: (element: PptxElement) => string | null;
+    reorderSelected: (direction: ZOrderDirection) => void;
+    nudgeSelected: (dx: number, dy: number) => void;
+    commitInlineText: (id: string, text: string) => void;
+    commitNotes: (notes: string, notesSegments?: TextSegment[]) => void;
+    updateDocumentProperties(core: PptxCoreProperties, app: PptxAppProperties, custom: PptxCustomProperty[]): void;
+    undo(): void;
+    redo(): void;
+    save(format?: PptxSaveFormat): Promise<Uint8Array>;
+}
+
+declare class EditorController {
+    #private;
+    snapLines: readonly SnapLine[];
+    editingId: string | null;
+    marquee: EditorMarqueeRect | null;
+    constructor(editor: EditorState, deps: EditorControllerDeps);
+    get overlayBox(): OverlayBox | null;
+    get editing(): boolean;
+    get selectionCount(): number;
+    get editingElement(): PptxElement | undefined;
+    /** True when editing owns the keyboard (a selection or inline edit is live). */
+    capturesKeyboard(): boolean;
+    onStagePointerDown: (event: PointerEvent) => void;
+    onStagePointerMove: (event: PointerEvent) => void;
+    onStageDblClick: (event: MouseEvent) => void;
+    /** Select the right-clicked element and expose the edit context menu. */
+    onStageContextMenu: (event: MouseEvent) => void;
+    onHandlePointerDown: (handle: ResizeHandleId, event: PointerEvent) => void;
+    onRotatePointerDown: (event: PointerEvent) => void;
+    onKeyDown: (event: KeyboardEvent) => void;
+    /** Open the inline text editor over `id` when the element carries text. */
+    enterInlineEdit(id: string): void;
+    /**
+     * Mirror the in-progress inline text to collaborators. Touches no editor
+     * state or history: the commit path stays the single source of truth.
+     */
+    previewInline(id: string, text: string): void;
+    /** Commit the inline editor's text onto the element and close it. */
+    commitInline(id: string, text: string): void;
+    /** Close the inline editor without further mutation. */
+    closeInline(): void;
+    /** Tear down window listeners (component destroy). */
+    destroy(): void;
+}
+
+/**
+ * ExportUiState: reactive state behind the toolbar `ExportMenu` and the
+ * `ExportProgressModal`. Svelte port of Vue's `useExportProgress` composable:
+ * it owns the modal state (open / title / progress / status), the
+ * `AbortController` the export loops check between slides, and wraps each
+ * multi-slide export (PDF / GIF / WebM) in a `begin -> run -> end` envelope.
+ * All percentage maths + status labels come from `pptx-viewer-shared`
+ * (`export-progress.ts`) so every binding shows identical progress.
+ *
+ * PNG (single slide, fast) and print (opens its own surface) run without the
+ * modal; the menu trigger still disables via {@link exporting} while they run.
+ */
+interface ExportUiDeps {
+    controller: ExportController;
+    getTranslator(): Translator;
+    /**
+     * Fired after an export completes successfully (Options > Accessibility
+     * "feedback with sound" hook); not called on abort or failure.
+     */
+    onComplete?(): void;
+}
+declare class ExportUiState {
+    #private;
+    /** Whether the progress modal is visible. */
+    open: boolean;
+    /** Modal heading (e.g. "Export as PDF"). */
+    title: string;
+    /** Current progress, 0-100. */
+    progress: number;
+    /** Status line under the bar (e.g. "Rendering slide 3 of 10..."). */
+    status: string;
+    constructor(deps: ExportUiDeps);
+    /** True while any export runs (disables the menu trigger). */
+    get exporting(): boolean;
+    /** Export the current slide as PNG (no modal; quick single capture). */
+    runPng(): void;
+    /** Copy the current slide to the system image clipboard. */
+    runCopyImage(): void;
+    /** Run the PDF export with the progress modal wired. */
+    runPdf(): Promise<void>;
+    /** Run the animated-GIF export with the progress modal wired. */
+    runGif(): Promise<void>;
+    /** Run the WebM video export with the progress modal wired. */
+    runVideo(): Promise<void>;
+    /** Run the print flow (no modal; the print surface takes over). */
+    runPrint(options?: PrintOptions): void;
+    /** Cancel the in-flight export (aborts the loop, closes the modal). */
+    cancel(): void;
+}
+
+/**
+ * autosave.svelte.ts: debounced crash-recovery autosave for the Svelte viewer.
+ *
+ * A runes port that fuses the two shared semantics the other bindings use:
+ *  - React's persistence target: each successful save writes the serialized
+ *    `.pptx` bytes to the shared IndexedDB recovery store
+ *    (`saveAutosaveSnapshot`, keyed by `filePath`), so a host can offer
+ *    restore-on-load with `getAutosaveSnapshot` / `listAutosaveSnapshots`
+ *    (both re-exported from this package). This binding does NOT auto-restore;
+ *    matching React/Vue, recovery is a host concern.
+ *  - 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 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.
+ */
+/**
+ * Autosave status, surfaced for the toolbar status pill.
+ *
+ *  - `idle`     : nothing has been saved yet (or no edits since mount).
+ *  - `disabled` : autosave is inactive (off, not editable, or no file path).
+ *  - `saving`   : a save is currently in flight.
+ *  - `saved`    : the most recent save succeeded.
+ *  - `error`    : the most recent save threw.
+ */
+type AutosaveStatus = 'idle' | 'disabled' | 'saving' | 'saved' | 'error';
+interface AutosaveDeps {
+    /** Master on/off: host `autosave` prop AND editing allowed. */
+    getEnabled: () => boolean;
+    /** Debounce window in milliseconds. */
+    getIntervalMs: () => number;
+    /** IndexedDB record key (host `filePath`); autosave is disabled without one. */
+    getFilePath: () => string | undefined;
+    /** The current editable slides (watched for edits). */
+    getSlides: () => PptxSlide[];
+    getSlideMasters?: () => PptxSlideMaster[];
+    getNotesMaster?: () => PptxNotesMaster | undefined;
+    getHandoutMaster?: () => PptxHandoutMaster | undefined;
+    getSections?: () => PptxSection[];
+    /** The live core handler used to serialize slides to `.pptx` bytes. */
+    getHandler: () => PptxHandler | null;
+    /**
+     * Monotonic load counter: a change means a fresh presentation was seeded (not
+     * a user edit), so the watcher clears dirty instead of arming a save.
+     */
+    getLoadCount: () => number;
+    /** Host callback with the freshly-serialized bytes on each successful save. */
+    onSaved?: (bytes: Uint8Array) => void;
+}
+declare class AutosaveController {
+    #private;
+    /** Current autosave lifecycle status (reactive). */
+    status: AutosaveStatus;
+    /** Whether there are unsaved edits pending (reactive). */
+    isDirty: boolean;
+    /** Epoch ms of the last successful save, or null (reactive). */
+    lastSavedAt: number | null;
+    constructor(deps: AutosaveDeps);
+    /** Force an immediate save, bypassing the debounce window. */
+    save(): Promise<void>;
+}
+
+interface SlideCanvasProps {
+    slide: PptxSlide | undefined;
+    canvasSize: CanvasSize;
+    mediaDataUrls: Map<string, string>;
+    /** Effective scale (fit-to-viewport x user zoom), pre-computed by the host. */
+    scale: number;
+    /** True only on the live presentation stage; see `SlideStageProps.presenting`. */
+    presenting?: boolean;
+    /** True while in-place editing is available; gates the pointer handlers and the editing cursor/class. */
+    editingActive?: boolean;
+    editTemplateMode?: boolean;
+    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;
+    /** Reports the stage-holder node to the host on mount/teardown (editing hit-surface, export capture anchor). */
+    onstageholder?: (el: HTMLDivElement | null) => void;
+    onstagepointerdown?: (event: PointerEvent) => void;
+    onstagepointermove?: (event: PointerEvent) => void;
+    onstagedblclick?: (event: MouseEvent) => void;
+    onstagecontextmenu?: (event: MouseEvent) => void;
+    /** Fired on any stage click; the host wires this to advance presentation playback. */
+    onstageclick?: (event: MouseEvent) => void;
+    /**
+     * True while the AI panel is picking an element: the next element click(s)
+     * become the assistant's focus (highlighted) instead of selecting / editing.
+     */
+    aiPickMode?: boolean;
+    /**
+     * True while a running AI tool is active: the stage marks itself
+     * `data-pptx-ai-active` so element colour changes tween while the assistant
+     * works (see AiFocusHighlightOverlay's tween rule).
+     */
+    aiActive?: boolean;
+    /** Route a picked canvas element to the AI focus (pick mode only). */
+    onaipickelement?: (elementId: string) => void;
+    /**
+     * Overlay content layered above the slide (selection/editor layer, ink
+     * drawing, alignment guides, presentation annotations, collaboration
+     * cursors, transition overlay, ...). Rendered inside the same
+     * fixed-size, scaled stage-holder as the slide itself. Kept out of this
+     * component's own props (rather than a fixed list of overlay slots) so it
+     * stays free of the live editor/controller instances those overlays need.
+     */
+    children?: svelte.Snippet;
+}
+interface ViewerToolbarProps {
+    /** Active slide (0-based). */
+    current: number;
+    total: number;
+    /** Currently-effective zoom percent (rounded). */
+    zoomPercent: number;
+    isFullscreen: boolean;
+    onprev: () => void;
+    onnext: () => void;
+    onzoomin: () => void;
+    onzoomout: () => void;
+    onzoomfit: () => void;
+    onfullscreen: () => void;
+    /** Whether the Notes toggle button is shown (host has a notes panel). */
+    showNotes?: boolean;
+    /** Whether the notes panel is currently expanded (drives the pressed state). */
+    notesExpanded?: boolean;
+    onnotestoggle?: () => void;
+    /** Show the editing action group (Undo / Redo / Save). Default false. */
+    editable?: boolean;
+    /** Whether an undo step is available (drives the Undo button's disabled state). */
+    canUndo?: boolean;
+    /** Whether a redo step is available (drives the Redo button's disabled state). */
+    canRedo?: boolean;
+    /** Whether there are unsaved edits (drives the Save button's emphasis). */
+    dirty?: boolean;
+    onundo?: () => void;
+    onredo?: () => void;
+    onsave?: () => void;
+    ondownload?: () => void;
+    /**
+     * Autosave lifecycle status; when set (host opted into `autosave`) a small
+     * status pill renders in the editing group. Omit to hide the pill entirely.
+     */
+    autosaveStatus?: AutosaveStatus;
+    /** Whether there are unsaved autosave edits (drives the pill's "dirty" tone). */
+    autosaveDirty?: boolean;
+    /**
+     * Export menu state (PNG / PDF / GIF / video / print). When set, the
+     * toolbar renders the `ExportMenu` dropdown in its right-hand group,
+     * matching the export affordance the React/Vue/Angular chrome exposes.
+     * Omit to hide the menu (e.g. while no presentation is loaded).
+     */
+    exportUi?: ExportUiState;
+    /** Opens the Share (collaboration) dialog. Omit to hide the button. */
+    onshare?: () => void;
+    /** Opens the Broadcast dialog. Omit to hide the button. */
+    onbroadcast?: () => void;
+    /** Whether a collaboration session is currently active (highlights the Share button). */
+    collabActive?: boolean;
+    /** Toolbar buttons to hide; see `PowerPointViewerProps.hiddenActions`. Default undefined: nothing hidden. */
+    hiddenActions?: ToolbarActionId[];
+}
+
+/**
+ * Reactive Find & Replace panel state for the Home tab's Editing group.
+ * Wraps the shared, framework-agnostic `render/find-replace` functions
+ * (pure slide-array search/replace); this class owns only the panel's UI
+ * state (query, current match, open/closed) and routes every replace through
+ * the host's history-tracked commit so undo/redo cover it.
+ */
+interface FindReplaceDeps {
+    getSlides(): readonly PptxSlide[];
+    /** Commit a fully-replaced slide array (pushes history, marks dirty). */
+    commitSlides(next: PptxSlide[]): void;
+    /** Called with the match's slide/element so the host can navigate to it. */
+    onNavigate?(slideIndex: number, elementId: string): void;
+}
+declare class FindReplaceState {
+    #private;
+    open: boolean;
+    query: string;
+    replacement: string;
+    matchCase: boolean;
+    results: FindResult[];
+    index: number;
+    constructor(deps: FindReplaceDeps);
+    get hasResults(): boolean;
+    get matchCount(): number;
+    toggle(): void;
+    close(): void;
+    /** Re-run the search from the current query/matchCase and jump to the first match. */
+    search(): void;
+    next(): void;
+    prev(): void;
+    /** Replace the current match, then refresh the result set. */
+    replaceCurrent(): void;
+    /** Replace every match of the current query, then refresh the result set. */
+    replaceAll(): void;
+}
+
+/**
+ * ChromeUiState: reactive open/collapsed state for the editing chrome's side
+ * panels, mirroring React's `useViewerState` flags (`isSidebarCollapsed`,
+ * `isInspectorPaneOpen`, `inspectorTab`). Owned by `PowerPointViewer` and
+ * threaded to both the ribbon's primary row (the toggle buttons) and
+ * `ViewerBody` (which gates the thumbnail rail and inspector pane on it).
+ */
+/** The inspector pane's tab strip, matching React's `InspectorTab`. */
+type InspectorTabId = 'elements' | 'properties' | 'comments';
+declare class ChromeUiState {
+    /** Left thumbnail rail visibility (React: `isSidebarCollapsed`). */
+    sidebarCollapsed: boolean;
+    /** Right inspector pane visibility (React: `isInspectorPaneOpen`). */
+    inspectorOpen: boolean;
+    /** Active inspector tab (React defaults to Properties). */
+    inspectorTab: InspectorTabId;
+    toggleSidebar(): void;
+    toggleInspector(): void;
+    setInspectorTab(tab: InspectorTabId): void;
+    /** Comments toolbar button: toggle the inspector's Comments tab. */
+    toggleComments(): void;
+    /** True when the inspector is showing the Comments tab. */
+    get commentsOpen(): boolean;
+}
+
+/**
+ * Prop contracts for the ribbon shell and its tabs. Kept in a plain `.ts`
+ * module per repo convention: SFCs stay thin presentation, types live in
+ * lintable TypeScript files.
+ */
+interface RibbonProps {
+    fileName?: string;
+    /** History-tracked editor state; Home/Insert tab groups read/write it directly. */
+    editor: EditorState;
+    /** Reactive Find & Replace panel state, owned by the host so it can navigate the viewer. */
+    findReplace: FindReplaceState;
+    /** Slide canvas size (px); the Insert tab centres new charts/media/SmartArt/etc. on it. */
+    canvasSize: CanvasSize;
+    /** Read-only deck: the full ribbon still renders (React parity) but a
+        read-only badge shows in the primary row and edits are inert. */
+    readOnly?: boolean;
+    /** Compact nav row (always visible): active slide (0-based) / total. */
+    current: number;
+    total: number;
+    onprev: () => void;
+    onnext: () => void;
+    /** Move the viewer to a specific slide index (the Home tab's Slides group). */
+    onnavigateslide: (index: number) => void;
+    /** Primary row: undo/redo/save/download + autosave pill. */
+    canUndo: boolean;
+    canRedo: boolean;
+    dirty: boolean;
+    onundo: () => void;
+    onredo: () => void;
+    onsave: () => void;
+    ondownload: () => void;
+    ondownloadppsx: () => void;
+    ondownloadpptm: () => void;
+    onpackage: () => void;
+    onversionhistory: () => void;
+    hasMacros: boolean;
+    embeddedFontNames: string[];
+    hasDigitalSignatures: boolean;
+    digitalSignatureCount: number;
+    isPasswordProtected: boolean;
+    autosaveStatus?: AutosaveStatus;
+    autosaveDirty?: boolean;
+    /** Collaboration entry points: Share on the tab row, broadcast in the Present dropdown (React parity). */
+    onshare?: () => void;
+    onbroadcast?: () => void;
+    collabActive?: boolean;
+    /** Side-panel (slides rail / inspector) open state + toggles for the primary row. */
+    chromeUi?: ChromeUiState;
+    /** Whether live subtitles are currently enabled (Present dropdown checkmark). */
+    subtitlesEnabled?: boolean;
+    /** Toggle the AI assistant panel. Only wired when the viewer's `ai` prop is set. */
+    onai?: () => void;
+    /** Whether the AI assistant panel is currently open (primary-row toggle state). */
+    aiActive?: boolean;
+    /** Toolbar buttons/ribbon tabs to hide; see `PowerPointViewerProps.hiddenActions`. */
+    hiddenActions?: ToolbarActionId[];
+    /** Slide Show tab actions: enter presentation from slide 0 or the current slide. */
+    onfrombeginning: () => void;
+    onfromcurrent: () => void;
+    onpresenter: () => void;
+    onsetupslideshow: () => void;
+    onheaderfooter: () => void;
+    oncompare: () => void;
+    onshortcuts: () => void;
+    onsettings: () => void;
+    onprintsettings: () => void;
+    onrehearse: () => void;
+    onrecordfrombeginning: () => void;
+    onrecordfromcurrent: () => void;
+    onsubtitles: () => void;
+    oncustomshows: () => void;
+    onselectionpane: () => void;
+    onslidesorter: () => void;
+    preferences: ViewerPreferences;
+    onpreferenceschange: (preferences: ViewerPreferences) => void;
+    showGuides: boolean;
+    onshowguideschange: (show: boolean) => void;
+    snapToShape: boolean;
+    onsnapToShapechange: (enabled: boolean) => void;
+    onaddguide: (axis: 'h' | 'v') => void;
+    /** Review tab: presentation-wide accessibility audit and issue navigation. */
+    slides: readonly PptxSlide[];
+    onnavigatetoissue: (slideIndex: number, elementId?: string) => void;
+    /** View tab: zoom / fullscreen / notes toggle. */
+    zoomPercent: number;
+    onzoomin: () => void;
+    onzoomout: () => void;
+    onzoomfit: () => void;
+    isFullscreen: boolean;
+    onfullscreen: () => void;
+    showNotes?: boolean;
+    notesExpanded?: boolean;
+    onnotestoggle?: () => void;
+    /** Opens the dedicated slide-master and layout navigation workspace. */
+    onentermasterview?: () => void;
+    /** File tab: export menu (PNG / PDF / GIF / video / print). */
+    exportUi?: ExportUiState;
+    onopenfile?: () => void;
+    onopenrecent?: (key: string) => void;
+    /**
+     * Design tab: the current effective viewer-chrome theme (for highlighting
+     * the active swatch) and the setter its gallery calls to switch presets.
+     */
+    theme: ViewerTheme | undefined;
+    onsettheme: (theme: ViewerTheme | undefined) => void;
+    /** File tab > Account: disabled-by-default sign-in hook point. */
+    accountAuth?: AccountAuthConfig;
+}
+
+/**
+ * Explicitly-typed public exports of the standalone view components.
+ *
+ * Same rationale as `PowerPointViewer` in `../component.ts`: `svelte-check`
+ * types `.svelte` imports precisely, but the plain TypeScript pass that emits
+ * the published declaration files resolves `.svelte` modules through a loose
+ * ambient shim (`src/shims-svelte.d.ts`), and the post-build Rollup
+ * declaration bundling cannot resolve a raw `.svelte` specifier at all (no
+ * `.svelte.d.ts` is emitted, which broke the library build on CI). Re-export
+ * through annotated constants so the published `.d.ts` is fully typed and
+ * free of `.svelte` specifiers.
+ */
+declare const Ribbon: Component<RibbonProps>;
+declare const ViewerToolbar: Component<ViewerToolbarProps>;
+declare const SlideCanvas: Component<SlideCanvasProps>;
+
+/** Live editor accessors the bridge closes over (all read from viewer runes). */
+interface SvelteAiBridgeDeps {
+    /** The editable slides array (the single source of truth the AI mutates). */
+    getSlides(): PptxSlide[];
+    /** Zero-based index of the active slide. */
+    getActiveSlideIndex(): number;
+    /** Slide canvas size in CSS pixels. */
+    getCanvasSize(): {
+        width: number;
+        height: number;
+    };
+    /** The resolved presentation theme, when available. */
+    getTheme(): PptxTheme | undefined;
+    /** The loaded core handler, or null before a deck is open. */
+    getHandler(): PptxHandler | null;
+    /** Optional display file name, used as a friendly deck title. */
+    getFileName(): string | undefined;
+    /** Navigate the viewer to a slide by zero-based index. */
+    goToSlide(index: number): void;
+    /** Select elements on a slide (navigates first when off-slide). */
+    selectElements(slideIndex: number, elementIds: string[]): void;
+    /**
+     * Install a new slides array as ONE undoable history entry. The
+     * implementation is responsible for ensuring the editor is editable (so the
+     * commit is not silently dropped) before recording the step.
+     */
+    commitSlides(next: PptxSlide[], label: string): void;
+    /** Apply partial theme updates (colour/font scheme) and re-render. */
+    applyTheme(updates: Partial<PptxTheme>): void;
+    /** Optional host notification sink (status line / toast / console). */
+    notify?(message: string, level?: PptxAiNotifyLevel): void;
+    /** Deck sections (editor-tracked, undoable). */
+    getSections(): PptxSection[];
+    /** Deck-wide slide-show / print settings (editor-tracked, undoable). */
+    getPresentationProperties(): PptxPresentationProperties;
+    /** Document core properties (Title / Author / ...), when present. */
+    getCoreProperties(): PptxCoreProperties | undefined;
+    /** Application properties (Company / Application), when present. */
+    getAppProperties(): PptxAppProperties | undefined;
+    /** Custom document-property list (editor-tracked, undoable). */
+    getCustomProperties(): PptxCustomProperty[];
+    /** Resize the slide canvas (loader value + editor history entry). */
+    setCanvasSize(size: {
+        width: number;
+        height: number;
+    }): void;
+    /** Replace the section list. */
+    setSections(sections: PptxSection[]): void;
+    /** Replace the deck-wide presentation properties. */
+    setPresentationProperties(props: PptxPresentationProperties): void;
+    /**
+     * Replace the document properties as one unit. Svelte's editor commits
+     * core / app / custom together, so the bridge fans all three through here.
+     */
+    setDocumentProperties(core: PptxCoreProperties, app: PptxAppProperties, custom: PptxCustomProperty[]): void;
+}
+/** Build the AI bridge that exposes the live Svelte viewer to the AI core. */
+declare function createSvelteAiBridge(deps: SvelteAiBridgeDeps): PptxAiBridge;
+
 /**
  * Pure slide-navigation and zoom-step helpers for the Svelte viewer.
  * Kept framework-free so they are trivially unit-testable.
@@ -8483,5 +10718,564 @@ declare class ViewerState {
     handleNavigationKey(key: string): boolean;
 }
 
-export { PowerPointViewer, PresentationLoader, ViewerState, clampSlideIndex, exportAllSlidesToSvg, exportAllSlidesToSvgBlobs, exportSlideAsSvg, exportSlideToSvg, exportSlideToSvgBlob, fitScale, resolveNavigationKey, zoomInPercent, zoomOutPercent };
-export type { CanvasSize, ExportGifOptions, ExportPdfOptions, ExportVideoOptions, NavigationAction, PowerPointViewerApi, PowerPointViewerProps, PrintOptions, SvgExportAllOptions, SvgExportSingleSlideOptions, ViewerLoadDetail, ViewerTheme };
+/** A transport-agnostic view of a live Yjs provider. */
+interface CollabProviderHandle {
+    /** The provider's awareness instance (local/remote presence). */
+    awareness: AwarenessLike;
+    /**
+     * Subscribe to connection-status changes. The callback receives whether the
+     * transport currently reports a connection. Only meaningful for websocket;
+     * webrtc callers rely on {@link connectedNow} instead.
+     */
+    onStatus: (cb: (connected: boolean) => void) => void;
+    /** Whether the transport reports a connection immediately after creation. */
+    connectedNow: boolean;
+    /**
+     * Subscribe to the provider's initial-document-sync confirmation. Websocket
+     * fires reliably once the server sync completes; webrtc only fires when a
+     * peer syncs with us (a lone fresh-room peer never receives one, so callers
+     * pair this with a grace timer, see the shared createSyncGate).
+     */
+    onSynced: (cb: () => void) => void;
+    /** Whether the provider already reports its initial sync as complete. */
+    syncedNow: boolean;
+    /** Tear the provider down (disconnect + destroy). */
+    destroy: () => void;
+}
+
+/** A fully-wired collaboration session: the doc, its factories, and transport. */
+interface CollabSession {
+    /** The live Y.Doc (structural view used by the shared reconcile helpers). */
+    ydoc: YDocLike;
+    /** Factories the shared reconcile helpers use to build Y.Map/Array/Text. */
+    factories: YjsFactories;
+    /** The normalised transport provider handle. */
+    provider: CollabProviderHandle;
+    /** Tear down the provider and destroy the doc. */
+    destroy: () => void;
+}
+/**
+ * Build a live session for the given transport + config. Injectable so tests
+ * can substitute an in-memory fake (see `collaboration.svelte.ts`).
+ */
+type CollabSessionFactory = (transport: CollaborationTransport, config: CollaborationConfig) => Promise<CollabSession>;
+
+interface CollaborationDeps {
+    /** Read the current local slides (broadcast granularly on change). */
+    getSlides: () => PptxSlide[];
+    /** Apply a remote peer's slide snapshot into the editable slides. */
+    applyRemoteSlides: (slides: PptxSlide[]) => void;
+    /** Live host `collaboration` config; watched to auto start/stop a session. */
+    getConfig: () => CollaborationConfig | undefined;
+    /** Return the loaded source bytes for elected-writer (role 'owner') write-back. */
+    getSourceBytes?: () => Uint8Array | null;
+    /** Slide canvas width/height (unscaled px), used to clamp incoming cursor coordinates. */
+    getCanvasWidth?: () => number | undefined;
+    getCanvasHeight?: () => number | undefined;
+    /** Fired when a session starts (host observability). */
+    onStart?: (config: CollaborationConfig) => void;
+    /** Fired when a session stops (host observability). */
+    onStop?: () => void;
+    /** Session factory seam (defaults to the real yjs + transport wiring). */
+    createSession?: CollabSessionFactory;
+}
+
+/**
+ * The collaboration controller. Construct it once during component setup: it
+ * registers the two effects (auto start/stop from the config, granular publish
+ * of local edits) itself, so no further wiring is needed in the SFC.
+ */
+declare class CollaborationController {
+    #private;
+    /** Live connection status (reactive). */
+    status: ConnectionStatus;
+    /** Interim Y.Doc channel for in-flight inline text (dormant when stopped). */
+    readonly livePatcher: CollaborationLivePatcher;
+    constructor(deps: CollaborationDeps);
+    /** Whether a session is live (reactive). */
+    get active(): boolean;
+    /** Read-only participant (session live with the `viewer` role) - cannot select/drag/mutate. */
+    get readOnly(): boolean;
+    /** Remote cursors on the current slide (reactive). */
+    get cursors(): RemoteCursor[];
+    /** Remote collaborators in the session (reactive). */
+    get remotePresences(): SanitizedPresence[];
+    /** Followed peer's client id, or null when free (reactive). */
+    get followedClientId(): number | null;
+    /** Publish a cursor move (slide-space px); no-op when no session is active. */
+    setCursor(x: number, y: number, activeSlideIndex?: number): void;
+    /** Publish the local selection; no-op when no session is active. */
+    setSelection(selectedElementId: string | undefined, activeSlideIndex?: number): void;
+    /** Publish the local active-slide index (drives peer follow-along). */
+    setActiveSlide(index: number): void;
+    /** Follow the given peer's active slide, or `null` to stop following. */
+    followUser(clientId: number | null): void;
+    /**
+     * Re-adopt the shared doc's slides after a local content load committed a
+     * parsed deck to viewer state (see `adoptDocSlidesAfterLoad`). The load
+     * pipeline calls this synchronously right after it applies, i.e. before the
+     * publish effect can flush the freshly loaded slides into the doc, so a
+     * late joiner's bootstrap deck never clobbers the room's synced content.
+     */
+    adoptDocAfterLoad(): void;
+    /** Start (or restart) a session with the given config (dialog-driven). */
+    start(config: CollaborationConfig): Promise<void>;
+    stop(): void;
+}
+
+/** Prefilled values for the Share dialog's form (Broadcast reuses `serverUrl`). */
+interface ShareDefaultsInput {
+    roomId?: string;
+    userName?: string;
+    serverUrl?: string;
+}
+declare class CollaborationDialogsState {
+    #private;
+    shareOpen: boolean;
+    broadcastOpen: boolean;
+    constructor(collab: CollaborationController, getShareDefaults: () => ShareDefaultsInput | undefined);
+    /** Number of connected participants (including the local user), when active. */
+    get connectedCount(): number;
+    /** The shareable follow link for the current (or last) broadcast, once known. */
+    get broadcastViewerUrl(): string | undefined;
+    openShare(): void;
+    openBroadcast(): void;
+    readonly onShareStart: (config: CollaborationConfig) => void;
+    readonly onShareStop: () => void;
+    readonly onBroadcastStart: (config: BroadcastConfig) => void;
+    readonly onBroadcastStop: () => void;
+    /**
+     * Retry the active session after a connection error: prefers the host's
+     * live `collaboration` prop, falling back to whatever config either dialog
+     * last started (since a dialog-started session has no corresponding prop).
+     */
+    retry(propConfig: CollaborationConfig | undefined): void;
+}
+
+/** The imperative editing API exposed on the `PowerPointViewer` instance. */
+interface EditingApi {
+    undo(): void;
+    redo(): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    deleteSelected(): void;
+    getSelectedElementId(): string | null;
+    save(format?: PptxSaveFormat): Promise<Uint8Array>;
+    downloadAs(format: PptxSaveFormat, fileName?: string): Promise<void>;
+    downloadPptx(fileName?: string): Promise<void>;
+    packageForSharing(fileName?: string): Promise<void>;
+}
+
+/**
+ * `AnimationPlayback`: native-timing (`p:timing`) animation playback for the
+ * Svelte binding's presentation mode, driven by the shared, framework-agnostic
+ * {@link PresentationAnimationController}. The runes analogue of the Vue
+ * `useAnimationPlayback` composable, kept out of the SFC so it is unit-testable.
+ *
+ * This replaces the older preset (`PptxElementAnimation`) click-group model for
+ * the slide show: the controller builds a timeline engine from the slide's
+ * `nativeAnimations` (expanding staged text builds), which can represent native
+ * staged chart / SmartArt builds (`p:bldChart` / `p:bldDgm`) and colour
+ * animations (`p:animClr`) that the preset model could not. It mirrors the Vue /
+ * React bindings.
+ *
+ * The class owns the reactive per-element state map, the keyframes CSS, and the
+ * interactive / hover trigger-shape id sets; the controller stays pure. The
+ * clock (timers, requestAnimationFrame) + DOM effects live in
+ * {@link module:presentation/animation-playback-helpers}.
+ *
+ * NOTE: the editor / inspector animation PREVIEW still uses the older shared
+ * `buildClickGroups` model (see `AnimationsTab` / `editor-animation-controller`);
+ * this class is only the running slide show.
+ */
+interface AnimationPlaybackDeps {
+    /** The current slide to build the native-animation timeline for. */
+    getSlide(): PptxSlide | undefined;
+    /** Presentation-level switch parsed from `p:showPr`. */
+    getShowWithAnimation?(): boolean | undefined;
+    /** Host-provided action-sound player (resolves + plays embedded sounds). */
+    onPlayActionSound?: (soundPath: string) => void;
+    /** Root element to scope media-command (`p:cmd`) target lookups to. */
+    frameRoot?: () => HTMLElement | null;
+}
+declare class AnimationPlayback {
+    #private;
+    constructor(deps: AnimationPlaybackDeps);
+    /** Reactive per-element native-animation state (visibility, build, colour). */
+    get elementStates(): Map<string, ElementAnimationState>;
+    /** The per-slide `@keyframes` CSS to inject once per slide. */
+    get keyframesCss(): string;
+    /** Shape ids that trigger an interactive (`onShapeClick`) sequence. */
+    get interactiveTriggerShapeIds(): ReadonlySet<string>;
+    /** Shape ids that trigger a hover (`onHover`) sequence. */
+    get hoverTriggerShapeIds(): ReadonlySet<string>;
+    /** True once every main-timeline click-group has been revealed. */
+    get isComplete(): boolean;
+    /** Clear all pending timers + the in-flight staged-build RAF. */
+    clearTimers(): void;
+    /**
+     * Rebuild the controller for the current slide and replay from the start. The
+     * controller builds the timeline engine (expanding text-build animations) and
+     * derives keyframes CSS, trigger-shape ids, and the tracked element id list.
+     */
+    reset(): void;
+    /**
+     * Reveal the next click-group. Returns `true` if a group was revealed, `false`
+     * when playback is complete or animations are disabled (so the caller can fall
+     * through to slide navigation).
+     */
+    advance(): boolean;
+    /** Play an interactive shape's sequence; `true` when it triggered one. */
+    handleInteractiveShapeClick(shapeId: string): boolean;
+    /** Play a hover shape's sequence; `true` when it triggered one. */
+    handleHoverStart(shapeId: string): boolean;
+    /** Reset a hover shape's sequence so the next hover replays it. */
+    handleHoverEnd(shapeId: string): void;
+}
+
+/**
+ * `PresentationController`: the runes state machine wiring the Svelte viewer's
+ * fullscreen (presentation) mode to the framework-agnostic animation and
+ * slide-transition helpers in `pptx-viewer-shared`.
+ *
+ * It owns:
+ *  - an {@link AnimationPlayback} for the current slide's click-stepped element
+ *    builds, and
+ *  - the transient slide-transition state (outgoing + incoming slide + the
+ *    resolved transition) rendered by `PresentationTransitionOverlay`.
+ *
+ * `advance()` implements the on-click contract: reveal the next animation build
+ * first, and only advance the slide once the slide's builds are exhausted.
+ * `onSlideChange` / `start` / `stop` are driven from a `$effect` in the viewer
+ * (see `usePresentationEffects`) as the fullscreen flag and current slide move.
+ *
+ * Matches the Vue binding's presentation-mode behaviour (its parity bar):
+ * click-stepped element animations, CSS-driven slide transitions on every slide
+ * change, entrance elements hidden until revealed. Since the native-timing
+ * migration it also drives staged chart / SmartArt builds (`p:bldChart` /
+ * `p:bldDgm`), `p:animClr` colour animations, withPrevious / afterPrevious
+ * auto-advance, and interactive / hover trigger sequences. Still no presenter
+ * view (React-only).
+ */
+interface TransitionState {
+    /** The outgoing (previous) slide, rendered in the exit layer. */
+    outgoing: PptxSlide | undefined;
+    /** The incoming (new) slide, rendered in the entrance layer. */
+    incoming: PptxSlide | undefined;
+    /** The incoming slide's transition (drives the CSS animation shorthands). */
+    transition: PptxSlideTransition;
+}
+interface PresentationControllerDeps {
+    /** The live, editable slide array (single source of truth). */
+    getSlides(): PptxSlide[];
+    /** The active slide index (0-based). */
+    getCurrentIndex(): number;
+    /** Navigate to a slide index (clamped by the caller's viewer state). */
+    navigate(index: number): void;
+    /** Presentation-level switch parsed from `p:showPr`. */
+    getShowWithAnimation?(): boolean | undefined;
+    /** Host-provided action-sound player (resolves + plays embedded sounds). */
+    onPlayActionSound?: (soundPath: string) => void;
+    /** The live presentation stage root, to scope media-command lookups to. */
+    getFrameRoot?(): HTMLElement | null;
+}
+declare class PresentationController {
+    #private;
+    readonly playback: AnimationPlayback;
+    constructor(deps: PresentationControllerDeps);
+    /** The active slide-transition overlay state, or `null` when none is playing. */
+    get transition(): TransitionState | null;
+    /** Reactive per-element native-animation state (visibility, build, colour). */
+    get elementStates(): Map<string, ElementAnimationState>;
+    /** The per-slide native-animation `@keyframes` CSS to inject. */
+    get keyframesCss(): string;
+    /** Shape ids that trigger an interactive (`onShapeClick`) sequence. */
+    get interactiveTriggerShapeIds(): ReadonlySet<string>;
+    /** Shape ids that trigger a hover (`onHover`) sequence. */
+    get hoverTriggerShapeIds(): ReadonlySet<string>;
+    /** Play an interactive shape's sequence; `true` when it triggered one. */
+    handleInteractiveShapeClick(shapeId: string): boolean;
+    /** Play a hover shape's sequence; `true` when it triggered one. */
+    handleHoverStart(shapeId: string): boolean;
+    /** Reset a hover shape's sequence so the next hover replays it. */
+    handleHoverEnd(shapeId: string): void;
+    /**
+     * The on-click advance contract: reveal the next element-animation build if
+     * one remains, otherwise advance to the next slide.
+     *
+     * `fromClick` marks a click/tap/swipe on the slide, which is PowerPoint's
+     * "on mouse click" advance: it still steps the remaining animation builds,
+     * but once they are exhausted it advances the slide only when the current
+     * slide's transition allows it (advanceOnClick !== false). Keyboard and the
+     * on-screen next button pass `fromClick = false` and are never gated.
+     */
+    advance(fromClick?: boolean): void;
+    /** Entering presentation: seed builds for the current slide, drop any overlay. */
+    start(): void;
+    /** Leaving presentation: clear timers, reset builds, drop any overlay. */
+    stop(): void;
+    /**
+     * The presented slide changed: reset the new slide's builds and, when the
+     * incoming slide carries a real transition, play it over the frame.
+     */
+    onSlideChange(previousIndex: number, nextIndex: number): void;
+    /** The transition overlay finished its animation: drop it. */
+    endTransition(): void;
+}
+
+interface PresenterSessionOptions {
+    getSource: () => Uint8Array | ArrayBuffer | null | undefined;
+    getSlideIndex: () => number;
+    onAudienceSlide: (index: number) => void;
+    onAudienceExit: () => void;
+}
+declare class PresenterSession {
+    private readonly options;
+    audienceOpen: boolean;
+    snapshot: PresentationSnapshot;
+    readonly audienceSessionId: string | null;
+    readonly isAudience: boolean;
+    private channel;
+    private audienceWindow;
+    private presenterSessionId;
+    private sequence;
+    constructor(options: PresenterSessionOptions);
+    connect(): void;
+    openAudience(): boolean;
+    sync(slideIndex?: number): void;
+    updateSnapshot(patch: Partial<PresentationSnapshot>): void;
+    closeAudience(): void;
+    dispose(): void;
+    private getChannel;
+}
+
+declare class CompareController {
+    #private;
+    result: CompareResult | null;
+    open: boolean;
+    accepted: Set<number>;
+    rejected: Set<number>;
+    constructor(editor: EditorState);
+    chooseFile(): Promise<void>;
+    accept(index: number): void;
+    reject(index: number): void;
+    acceptAll(): void;
+}
+
+type PresentationInkTool = 'none' | 'pen' | 'highlighter' | 'eraser' | 'laser';
+interface PresentationStroke {
+    id: string;
+    points: InkPoint[];
+    color: string;
+    width: number;
+    tool: 'pen' | 'highlighter';
+}
+declare class PresentationAnnotations {
+    #private;
+    tool: PresentationInkTool;
+    color: string;
+    current: PresentationStroke | null;
+    bySlide: Map<number, PresentationStroke[]>;
+    laser: InkPoint | null;
+    get count(): number;
+    get slideCount(): number;
+    strokes(index: number): PresentationStroke[];
+    pointerDown(index: number, point: InkPoint): void;
+    pointerMove(index: number, point: InkPoint): void;
+    pointerUp(index: number): void;
+    erase(index: number, point: InkPoint): void;
+    clear(): void;
+    keep(editor: EditorState): void;
+}
+
+declare class RehearseState {
+    #private;
+    active: boolean;
+    paused: boolean;
+    summaryOpen: boolean;
+    times: Map<number, number>;
+    current: number;
+    elapsedMs: number;
+    start(index: number): void;
+    tick(): void;
+    move(index: number): void;
+    togglePause(): void;
+    finish(): void;
+    record(): void;
+    save(editor: EditorState): void;
+    discard(): void;
+    get totalMs(): number;
+}
+
+/** Reactive state for the optional parity dialogs and presentation tools. */
+declare class ViewerParityUiState {
+    readonly compare: CompareController;
+    readonly annotations: PresentationAnnotations;
+    readonly rehearse: RehearseState;
+    setupSlideShowOpen: boolean;
+    headerFooterOpen: boolean;
+    settingsOpen: boolean;
+    shortcutsOpen: boolean;
+    keepAnnotationsOpen: boolean;
+    printSettingsOpen: boolean;
+    subtitlesEnabled: boolean;
+    customShowsOpen: boolean;
+    selectionPaneOpen: boolean;
+    slideSorterOpen: boolean;
+    showGuides: boolean;
+    snapToShape: boolean;
+    guides: {
+        axis: "h" | "v";
+        position: number;
+    }[];
+    preferences: ViewerPreferences;
+    constructor(editor: EditorState);
+    syncAutosave(enabled: boolean): void;
+    updatePreferences(next: ViewerPreferences, onAutosaveChange: (enabled: boolean) => void): void;
+}
+
+/**
+ * Options accepted by {@link createViewerState}. Mirrors the subset of
+ * `PowerPointViewerProps` the extracted construction block (formerly
+ * inlined at the top of `PowerPointViewer.svelte`'s `<script>`) closes
+ * over, plus getter callbacks for the handful of DOM-bound values
+ * (`bind:this` / `bind:clientWidth` targets) that must stay owned by
+ * whichever component renders the actual markup.
+ */
+interface CreateViewerStateOptions {
+    getSource: () => Uint8Array | ArrayBuffer | null | undefined;
+    collaboration?: CollaborationConfig;
+    shareDefaults?: ShareDefaultsInput;
+    /** Host `autosave` prop (post-effect value the caller keeps in sync). */
+    getAutosave: () => boolean;
+    autosaveIntervalMs?: number;
+    getFilePath: () => string | undefined;
+    getInitialSlide: () => number;
+    /** Already locale-bound translator; propagated to descendants via context. */
+    t: Translator;
+    getSmartArt3D: () => boolean;
+    /** Whether in-place editing is enabled (host `editable` prop, post-effect value). */
+    getEditable: () => boolean;
+    onload?: (detail: ViewerLoadDetail) => void;
+    onerror?: (message: string) => void;
+    onslidechange?: (index: number) => void;
+    onnotesupdate?: (notes: string) => void;
+    onchange?: () => void;
+    ondirtychange?: (dirty: boolean) => void;
+    oncontentchange?: (content: Uint8Array) => void;
+    onmodechange?: (mode: ViewerMode) => void;
+    onzoomchange?: (zoom: number) => void;
+    onselectionchange?: (elementIds: string[]) => void;
+    onslidecountchange?: (count: number) => void;
+    onautosave?: (bytes: Uint8Array) => void;
+    /** Fired when the host toggles AutoSave (title bar / Settings dialog). */
+    onautosavetoggle?: (enabled: boolean) => void;
+    onstartcollaboration?: (config: CollaborationConfig) => void;
+    onstopcollaboration?: () => void;
+    /** DOM-bound getters, supplied by the component that owns the markup. */
+    getStageHolderEl: () => HTMLDivElement | undefined;
+    getRootEl: () => HTMLDivElement | undefined;
+    getViewportWidth: () => number;
+    getViewportHeight: () => number;
+    /** Master/layout workspace zoom, assigned by `MasterViewBody`. */
+    getMasterScale: () => number;
+}
+/**
+ * Everything the ribbon, toolbar, and canvas need, returned from
+ * {@link createViewerState}. Reactive/derived fields are exposed as
+ * getters (some paired with setters for the plain local UI flags) so reads
+ * anywhere, not just inside an `$effect`, stay live.
+ */
+interface ViewerStateBag {
+    readonly loader: PresentationLoader;
+    readonly viewer: ViewerState;
+    readonly editor: EditorState;
+    readonly controller: EditorController;
+    readonly parityUi: ViewerParityUiState;
+    readonly chromeUi: ChromeUiState;
+    readonly findReplace: FindReplaceState;
+    readonly collab: CollaborationController;
+    readonly dialogs: CollaborationDialogsState;
+    readonly autosaveCtl: AutosaveController;
+    readonly presentation: PresentationController;
+    readonly presenterSession: PresenterSession;
+    readonly exportWiring: ExportWiring;
+    readonly exportUi: ExportUiState;
+    readonly t: Translator;
+    /** Imperative undo/redo/save/download API, matching `PowerPointViewerApi`'s editing subset. */
+    readonly editingApi: EditingApi;
+    /** Imperative PNG/PDF/GIF/video/print API, matching `PowerPointViewerApi`'s export subset. */
+    readonly exportingApi: ExportingApi;
+    /** Effective scale (fit-to-viewport x user zoom), matching the main canvas. */
+    readonly scale: number;
+    /** User-facing zoom percent (rounded, never below 1). */
+    readonly effectivePercent: number;
+    readonly displaySlides: EditorState['renderedSlides'];
+    readonly activeSlide: EditorState['renderedSlides'][number] | undefined;
+    readonly chromeVisible: boolean;
+    /** True when in-place editing is actually available (editable, not presenting, not read-only). */
+    readonly editingActive: boolean;
+    /** True once the ribbon (vs. the compact `ViewerToolbar`) should be shown. */
+    readonly showRibbon: boolean;
+    readonly viewerMode: ViewerMode;
+    /** True while the autosave debounce/write cycle is armed. */
+    readonly autosaveActive: boolean;
+    /** Read-only: mutate via {@link setAutosaveEnabled}, which also fires `onautosavetoggle`. */
+    readonly autosaveEnabled: boolean;
+    setAutosaveEnabled(enabled: boolean): void;
+    presenterMode: boolean;
+    /** `Date.now()` timestamp of the last `enterPresenterView()` call; the presenter view's elapsed-time display. */
+    readonly presenterStartedAt: number;
+    stageContextMenu: {
+        x: number;
+        y: number;
+    } | null;
+    readonly activeMobileSheet: MobileSheetKey;
+    setActiveMobileSheet(next: MobileSheetKey): void;
+    readonly notesExpanded: boolean;
+    versionHistoryOpen: boolean;
+    readonly signatureWarningOpen: boolean;
+    enterPresenterView(): void;
+    closeSignatureWarning(): void;
+    onNotesToggle(): void;
+    onNotesCommit(notes: string, segments?: TextSegment[]): void;
+    onFullscreenToggle(): void;
+    onFullscreenChange(): void;
+    onKeydown(event: KeyboardEvent): void;
+    downloadPptx(fileName?: string): Promise<void>;
+    downloadAs(format: PptxSaveFormat, fileName?: string): Promise<void>;
+    /** Tear down every constructed controller (call from the host's `onDestroy`). */
+    destroy(): void;
+}
+
+/**
+ * Builds every reactive controller the ribbon, toolbar, and slide canvas
+ * need: the runes port of `PowerPointViewer.svelte`'s own construction block
+ * (originally inlined at the top of its `<script>`), extracted so a host can
+ * compose its own viewer shell out of `Ribbon` / `ViewerToolbar` / the state
+ * classes without pulling in the whole `PowerPointViewer` component.
+ *
+ * MUST be called synchronously from a `.svelte` component's own script body
+ * (top level, not inside a callback or after an `await`): it registers
+ * `onMount` / `onDestroy` hooks and Svelte context (`setContext`) via
+ * `provideTranslator` / `provideSmartArt3D` / `provideRenderContext` /
+ * `provideZoomNavigation` (inside the editor-ui cluster) / `provideInspectorDeck`,
+ * all of which require an active component-initialisation context. Svelte's
+ * lifecycle context stays active for the whole synchronous execution of a
+ * component's script, not just its top-level statements, so calling this
+ * from a component's script works exactly like inlining the same code would.
+ *
+ * Construction is split across a few `create-viewer-state-*.svelte.ts`
+ * helpers purely to stay under the repo's file-size budget; the ORDER those
+ * helpers are invoked in below mirrors the original inline code (later
+ * clusters close over earlier ones), with one deliberate reordering: the
+ * collaboration cluster is now built right after `editor` (it doesn't need
+ * the editing-chrome cluster), which lets `controller` close over the real
+ * `collab.setCursor` instead of a forward reference.
+ *
+ * Call the returned `destroy()` from the host component's own `onDestroy`.
+ */
+declare function createViewerState(options: CreateViewerStateOptions): ViewerStateBag;
+
+export { PowerPointViewer, PresentationLoader, Ribbon, SlideCanvas, ViewerState, ViewerToolbar, clampSlideIndex, createSvelteAiBridge, createViewerState, exportAllSlidesToSvg, exportAllSlidesToSvgBlobs, exportSlideAsSvg, exportSlideToSvg, exportSlideToSvgBlob, fitScale, resolveNavigationKey, zoomInPercent, zoomOutPercent };
+export type { CanvasSize, CreateViewerStateOptions, ExportGifOptions, ExportPdfOptions, ExportVideoOptions, NavigationAction, PowerPointViewerApi, PowerPointViewerProps, PptxAiBridge, PptxAiConfig, PptxAiConnection, PptxAiContextStrategy, PptxAiToolName, PptxAiUIMessage, PptxAiWritePolicy, PrintOptions, RibbonProps, SlideCanvasProps, SvelteAiBridgeDeps, SvgExportAllOptions, SvgExportSingleSlideOptions, ViewerLoadDetail, ViewerStateBag, ViewerTheme, ViewerToolbarProps };