@silurus/ooxml 0.70.2 → 0.71.0

package/dist/types/pptx.d.ts

@@ -68,6 +68,21 @@ export declare interface BlipBullet {
     sizePct: number | null;
 }
 
+/**
+ * Populate a highlight overlay layer with a box per matched run-slice, grouped
+ * by shape frame (with the shape's rotation) so each box lands on the drawn
+ * glyphs.
+ *
+ * @param layer     the overlay div (cleared + re-sized here).
+ * @param runs      the slide's runs (same array the slide was rendered from).
+ * @param matches   the slide's matches (run-slices + active flag).
+ * @param cssWidth  rendered canvas CSS width (px, number).
+ * @param cssHeight rendered canvas CSS height (px, number).
+ * @param measureForFont returns a width-measurer primed with a run's font.
+ * @param colors    optional colour overrides.
+ */
+export declare function buildPptxHighlightLayer(layer: HTMLDivElement, runs: PptxTextRunInfo[], matches: PptxHighlightMatch[], cssWidth: number, cssHeight: number, measureForFont: (font: string) => (s: string) => number, colors?: PptxHighlightColors): void;
+
 /**
  * Build the transparent text-selection overlay for a rendered pptx slide. Unlike
  * docx (flat spans), pptx groups runs into one positioned `<div>` per shape frame
@@ -77,15 +92,25 @@ export declare interface BlipBullet {
  * shape div (`inShapeX`/`inShapeY`). Extracted verbatim from
  * `PptxViewer._buildTextLayer` so the pager (PptxViewer) and the continuous-scroll
  * viewer (PptxScrollViewer, WS4) share one implementation; public API for
- * integrators (design §10). MAIN render mode only — `onTextRun` cannot cross the
- * worker boundary.
+ * integrators (design §10). IX6 — usable in BOTH render modes: worker mode
+ * collects the same `PptxTextRunInfo[]` off-thread and ships it back beside the
+ * bitmap, so the overlay is built from identical geometry regardless of thread.
+ *
+ * IX1 — when a run carries a resolved `hyperlink` (from `<a:hlinkClick>`) and an
+ * `onHyperlinkClick` callback is supplied, its span becomes a click target
+ * (`cursor:pointer`, a `title` tooltip, and a `click` handler). A plain span
+ * (no hyperlink) is byte-identical to before. A JS click handler is used rather
+ * than an `<a href>` so the URL never bypasses the viewer's sanitisation.
  *
  * @param layer     the overlay div.
  * @param runs      per-run + per-shape geometry from `renderSlide({ onTextRun })`.
  * @param cssWidth  the rendered canvas's CSS width (px, number).
  * @param cssHeight the rendered canvas's CSS height (px, number).
+ * @param onHyperlinkClick called with the run's resolved {@link HyperlinkTarget}
+ *                         when a hyperlink span is clicked. Omit to leave links
+ *                         non-interactive (spans stay plain, selectable text).
  */
-export declare function buildPptxTextLayer(layer: HTMLDivElement, runs: PptxTextRunInfo[], cssWidth: number, cssHeight: number): void;
+export declare function buildPptxTextLayer(layer: HTMLDivElement, runs: PptxTextRunInfo[], cssWidth: number, cssHeight: number, onHyperlinkClick?: (target: HyperlinkTarget) => void): void;
 
 /**
  * PPTX bullet marker. The shared core {@link CoreBullet} union
@@ -136,6 +161,30 @@ declare interface ChartDataLabelOverride {
     fontSizeHpt?: number;
     /** `<a:defRPr b="1">` inside the per-idx rich text. */
     fontBold?: boolean;
+    /** Per-point callout box (`<c:dLbl><c:spPr>`, ECMA-376 §21.2.2.47/§21.2.2.197):
+     *  overrides the series-default box for this one slice. */
+    labelBox?: ChartLabelBox;
+    /**
+     * Per-point label-content flags (`<c:dLbl>` §21.2.2.47 carries the same
+     * show-flag group as the series `<c:dLbls>` §21.2.2.49: §21.2.2.189
+     * `<c:showVal>`, §21.2.2.177 `<c:showCatName>`, §21.2.2.180 `<c:showSerName>`,
+     * §21.2.2.187 `<c:showPercent>`). When present they OVERRIDE the series-level
+     * defaults for that one point (e.g. sample-14 slide-7's pie sets
+     * `showCatName=0 showPercent=1` per slice while the series default is
+     * `showCatName=1`, so each label is percent only). undefined = inherit the
+     * series default for that flag.
+     */
+    showVal?: boolean;
+    showCatName?: boolean;
+    showSerName?: boolean;
+    showPercent?: boolean;
+    /**
+     * `<c:dLbl><c:delete val="1"/>` (ECMA-376 §21.2.2.43) — the point's label is
+     * removed. Distinguishes a genuine delete from a `<c:dLbl>` that only carries
+     * style / flag overrides with no `<c:tx>` (both otherwise present as
+     * `text === ''`). true = skip the label; undefined/absent = not deleted.
+     */
+    deleted?: boolean;
 }
 
 declare interface ChartDataPointOverride {
@@ -146,6 +195,18 @@ declare interface ChartDataPointOverride {
     markerSize?: number;
     markerFill?: string;
     markerLine?: string;
+    /**
+     * `<c:dPt><c:explosion val>` (ECMA-376 §21.2.2.61) — the amount this
+     * pie/doughnut slice is moved out from the center. The schema type is
+     * `CT_UnsignedInt` (unbounded `xsd:unsignedInt`); the spec text only says
+     * "the amount the data point shall be moved from the center of the pie"
+     * and does not itself define units or a 0–100 range. We treat it as a
+     * de-facto percentage of the outer radius (0–100 typical), matching
+     * Office's UI (the Point Explosion slider caps at 100%) rather than a
+     * spec-mandated bound. undefined/absent = 0 (no explosion, flush with the
+     * ring). Only consulted by the pie/doughnut renderer.
+     */
+    explosion?: number;
 }
 
 /**
@@ -185,6 +246,74 @@ declare interface ChartErrBars {
     dash?: string;
 }
 
+/**
+ * One box-and-whisker series (chartEx `boxWhisker`, MS 2014 chartex ext). Each
+ * `<cx:series>` references its own raw sample points via `<cx:dataId>`; the
+ * parser groups them by category and threads the `<cx:layoutPr>` flags. The
+ * renderer derives the statistics.
+ */
+declare interface ChartexBoxSeries {
+    /** Series display name (`<cx:tx><cx:v>`). */
+    name: string;
+    /** Fill (hex, no '#') — theme accent cycled by series index. null = fall
+     *  back to the renderer palette. */
+    color?: string | null;
+    /** Raw sample values grouped by category (outer = category index parallel to
+     *  {@link ChartexBoxWhisker.categories}, inner = the points in that group). */
+    valuesByCategory: number[][];
+    /** `<cx:visibility meanMarker>` — draw the mean `×`. */
+    meanMarker: boolean;
+    /** `<cx:visibility meanLine>` — draw a mean connector line across categories. */
+    meanLine: boolean;
+    /** `<cx:visibility outliers>` — draw outlier points. */
+    showOutliers: boolean;
+    /** `<cx:visibility nonoutliers>` — draw the interior (non-outlier) sample
+     *  points as jittered dots on top of the box. Flag parsed; interior-dot
+     *  rendering is pending a fixture that enables it (every sample-24 series
+     *  ships `nonoutliers="0"`, so there is nothing to verify against yet). */
+    showNonoutliers: boolean;
+    /** `<cx:statistics quartileMethod>` — "exclusive" (Excel default) | "inclusive". */
+    quartileMethod: string;
+}
+
+/** A chartEx box-and-whisker chart: unique categories + one series per column. */
+declare interface ChartexBoxWhisker {
+    /** Unique category labels in first-seen order. */
+    categories: string[];
+    /** One entry per `<cx:series>`. */
+    series: ChartexBoxSeries[];
+}
+
+/** A chartEx sunburst: the flat rows the renderer folds into a ring tree. */
+declare interface ChartexSunburst {
+    rows: ChartexSunburstRow[];
+}
+
+/**
+ * One row of a chartEx `sunburst`: the branch→…→leaf label chain (empty
+ * trailing segments trimmed) and its size value.
+ */
+declare interface ChartexSunburstRow {
+    /** Label chain root→leaf. */
+    path: string[];
+    /** `<cx:numDim type="size">` value attaching to the deepest node in `path`. */
+    size: number;
+}
+
+/** Callout-box style for a pie/doughnut data label — the white (or themed)
+ *  rounded rectangle with a thin border Word draws around a `bestFit` label
+ *  placed outside its slice. From the label's `<c:spPr>` (§21.2.2.197). All
+ *  fields optional: absent → transparent / unbordered. Mirror of Rust
+ *  `ChartLabelBox`. */
+declare interface ChartLabelBox {
+    /** `<a:solidFill>` resolved hex (no `#`). Box background. */
+    fill?: string;
+    /** `<a:ln><a:solidFill>` resolved hex (no `#`). Border stroke. */
+    borderColor?: string;
+    /** `<a:ln w>` border width in EMU (12700 EMU = 1 pt). */
+    borderWidthEmu?: number;
+}
+
 /**
  * `<c:manualLayout>` block. Fractions are of the chart-space rect.
  * `xMode`/`yMode`: "edge" = absolute fraction from top-left, "factor" =
@@ -315,6 +444,35 @@ export declare interface ChartModel {
     valAxisTitleFontBold?: boolean | null;
     /** `<c:valAx><c:title>` run-prop color (hex without '#'). null = default. */
     valAxisTitleFontColor?: string | null;
+    /** `<c:catAx><c:txPr>…<a:latin typeface>` tick-label font. */
+    catAxisFontFace?: string | null;
+    /** `<c:valAx><c:txPr>…<a:latin typeface>` tick-label font. */
+    valAxisFontFace?: string | null;
+    /** `<c:catAx><c:title>…<a:latin typeface>` axis-title font. */
+    catAxisTitleFontFace?: string | null;
+    /** `<c:valAx><c:title>…<a:latin typeface>` axis-title font. */
+    valAxisTitleFontFace?: string | null;
+    /** `<c:dLbls><c:txPr>…<a:latin typeface>` data-label font. */
+    dataLabelFontFace?: string | null;
+    /** `<c:legend><c:txPr>…<a:latin typeface>` legend font. */
+    legendFontFace?: string | null;
+    /** `<c:legend><c:txPr>…<a:solidFill>` legend text color (hex without '#'). */
+    legendFontColor?: string | null;
+    /** `<c:legend><c:txPr>` legend font size (OOXML hundredths of a point). */
+    legendFontSizeHpt?: number | null;
+    /** `<c:legend><c:txPr>…defRPr@b` legend bold flag. */
+    legendFontBold?: boolean | null;
+    /**
+     * Theme font-scheme faces (`<a:fontScheme>`, ECMA-376 §20.1.4.2). Latin
+     * heading (majorFont) and body (minorFont) typefaces, used as the fallback
+     * for any chart text element whose own `<c:txPr>` supplies no `<a:latin>`.
+     * null when the theme is not threaded to the chart (then the renderer's
+     * built-in sans-serif remains, byte-stable). Axis titles / chart title use
+     * the major (heading) face; tick labels / data labels / legend use the
+     * minor (body) face — matching Office's default chart text styling.
+     */
+    themeMajorFontLatin?: string | null;
+    themeMinorFontLatin?: string | null;
     /** Explicit chart border color (hex without '#') from
      *  `<c:chartSpace><c:spPr><a:ln><a:solidFill><a:srgbClr>`. Only set when the
      *  XML explicitly declares a paintable line; null otherwise (no default
@@ -389,6 +547,163 @@ export declare interface ChartModel {
      * value axis (the common case). See {@link SecondaryValueAxis}.
      */
     secondaryValAxis?: SecondaryValueAxis | null;
+    /**
+     * `<c:date1904>` (ECMA-376 §21.2.2.38). When true the chart's serial
+     * date-times resolve against the 1904 date system (base 1904-01-01) instead
+     * of the default 1900 system. Threaded to the date formatters for date-axis
+     * category labels and value-axis tick labels. Omitted/false ⇒ 1900 system.
+     * Note: per §21.2.2.38 the element's `val` defaults to true when present but
+     * the attribute is omitted, so `<c:date1904/>` alone means date1904=true.
+     */
+    date1904?: boolean;
+    /**
+     * `<c:doughnutChart><c:holeSize val>` (ECMA-376 §21.2.2.60,
+     * `ST_HoleSizePercent` §21.2.3.55) — the doughnut hole diameter as a
+     * percentage 1–90 of the outer diameter. Ignored for pie (which has no
+     * hole). null/undefined = use the renderer's doughnut default when the
+     * element is absent. Note the ECMA `CT_HoleSize` schema default is 10%, but
+     * a real doughnut file always writes an explicit `<c:holeSize>` (Excel /
+     * PowerPoint emit 50–75%); the renderer falls back to 50% only for the
+     * pathological absent case.
+     */
+    holeSize?: number | null;
+    /**
+     * `<c:pieChart | doughnutChart><c:firstSliceAng val>` (ECMA-376 §21.2.2.52,
+     * `ST_FirstSliceAng` §21.2.3.15) — the angle in degrees (0–360, clockwise
+     * from the 12 o'clock position) at which the first slice begins.
+     * null/undefined = 0 (start at 12 o'clock), which matches the renderer's
+     * historical fixed −90° (canvas up) start.
+     */
+    firstSliceAngle?: number | null;
+    /**
+     * `<c:chartSpace><c:chart><c:dispBlanksAs val>` (ECMA-376 §21.2.2.42,
+     * `ST_DispBlanksAs` §21.2.3.10) — how blank (null) cells are plotted on
+     * line/area charts:
+     *   - "gap"  → leave a gap (break the line). The renderer's historical
+     *              behavior and the model default when the element is absent.
+     *   - "zero" → plot the blank as the value 0 (the point drops to the axis).
+     *   - "span" → skip the blank but connect its neighbours with a straight
+     *              line (bridge the gap).
+     * Note the XSD `@val` default is "zero" (applies when `<c:dispBlanksAs/>` is
+     * present but the attribute is omitted); when the ELEMENT is absent entirely
+     * Office falls back to "gap", which is what we model as the default. Only
+     * consulted for the line and area families. null/undefined = "gap".
+     */
+    dispBlanksAs?: string | null;
+    /**
+     * `<c:valAx><c:majorGridlines>` presence (ECMA-376 §21.2.2.100). `false` when
+     * the value axis exists but omits the element (Office suppresses value
+     * gridlines). null/undefined ⇒ the renderer's historical always-on value
+     * gridlines (byte-stable). `true` is redundant with the default but honored.
+     */
+    valAxisMajorGridlines?: boolean | null;
+    /**
+     * `<c:catAx><c:majorGridlines>` presence (§21.2.2.100). `true` turns on
+     * category-axis gridlines (Office omits them by default). null/undefined/false
+     * ⇒ no category gridlines (the historical default, byte-stable).
+     */
+    catAxisMajorGridlines?: boolean | null;
+    /**
+     * `<c:valAx><c:majorGridlines><c:spPr><a:ln><a:solidFill>` resolved gridline
+     * color (hex without `#`) — ECMA-376 §21.2.2.100. When set, the value-axis
+     * major gridlines are stroked in this color instead of the renderer's faint
+     * `#e0e0e0` default (e.g. sample-1 slide 5's `accent3` gridlines). null/absent
+     * ⇒ the historical default (byte-stable).
+     */
+    valAxisGridlineColor?: string | null;
+    /**
+     * `<c:valAx><c:majorGridlines><c:spPr><a:ln w>` gridline width in EMU. When
+     * set, the value-axis gridline stroke width is derived from this (floored so a
+     * hairline stays visible). null/absent ⇒ the renderer's 0.5 px default.
+     */
+    valAxisGridlineWidthEmu?: number | null;
+    /**
+     * `<c:catAx><c:majorGridlines><c:spPr><a:ln><a:solidFill>` resolved gridline
+     * color (hex without `#`). Only meaningful when {@link catAxisMajorGridlines}
+     * is on. null/absent ⇒ the faint default.
+     */
+    catAxisGridlineColor?: string | null;
+    /** `<c:catAx><c:majorGridlines><c:spPr><a:ln w>` gridline width in EMU. */
+    catAxisGridlineWidthEmu?: number | null;
+    /** `<c:valAx><c:minorGridlines>` presence (§21.2.2.109). Only drawn when a
+     *  minor step is resolvable (see {@link valAxisMinorUnit}). */
+    valAxisMinorGridlines?: boolean | null;
+    /**
+     * `<c:valAx><c:majorUnit val>` (§21.2.2.103) — explicit distance between major
+     * gridlines/ticks, overriding the Excel-style auto "nice" step. null/undefined
+     * ⇒ auto step (byte-stable).
+     */
+    valAxisMajorUnit?: number | null;
+    /** `<c:valAx><c:minorUnit val>` (§21.2.2.112) — explicit minor step. Drives
+     *  minor gridlines/ticks when present. null ⇒ no minor divisions. */
+    valAxisMinorUnit?: number | null;
+    /**
+     * `<c:valAx><c:scaling><c:logBase val>` (§21.2.2.98, `ST_LogBase` §21.2.3.25)
+     * — logarithmic value-axis base (>= 2). When set, values map to pixels in log
+     * space and gridlines fall on powers of the base. null/undefined ⇒ linear
+     * (byte-stable).
+     */
+    valAxisLogBase?: number | null;
+    /**
+     * `<c:valAx><c:scaling><c:orientation val>` (§21.2.2.130, `ST_Orientation`
+     * §21.2.3.30) — "minMax" (normal) | "maxMin" (reversed, so the value axis runs
+     * top→bottom max→min). null/undefined/"minMax" ⇒ normal (byte-stable).
+     */
+    valAxisOrientation?: 'minMax' | 'maxMin' | string | null;
+    /** `<c:catAx><c:scaling><c:orientation val>` — "maxMin" reverses the category
+     *  axis left↔right. null/"minMax" ⇒ normal. */
+    catAxisOrientation?: 'minMax' | 'maxMin' | string | null;
+    /**
+     * `<c:catAx><c:tickLblPos val>` (§21.2.2.207, `ST_TickLblPos` §21.2.3.47) —
+     * "nextTo" (default) | "low" | "high" | "none". "none" hides the category tick
+     * labels. null/undefined ⇒ nextTo (byte-stable).
+     */
+    catAxisTickLabelPos?: string | null;
+    /** `<c:valAx><c:tickLblPos val>` (§21.2.2.207). "none" hides value tick labels. */
+    valAxisTickLabelPos?: string | null;
+    /**
+     * `<c:catAx><c:txPr><a:bodyPr rot>` (DrawingML `ST_Angle`, 60000ths of a
+     * degree) — category tick-label rotation. e.g. -2700000 = -45°. null/undefined
+     * /0 ⇒ horizontal labels (byte-stable).
+     */
+    catAxisLabelRotation?: number | null;
+    /**
+     * `<c:stockChart><c:hiLowLines>` presence (ECMA-376 §21.2.2.60). When true
+     * the stock renderer draws a vertical line spanning each category's low↔high
+     * value. Only set for `chartType === "stock"`; null/undefined on every other
+     * chart type (byte-stable).
+     */
+    stockHiLowLines?: boolean | null;
+    /**
+     * `<c:hiLowLines><c:spPr><a:ln><a:solidFill>` resolved color (hex, no `#`).
+     * null = the renderer's default gray hi-lo line.
+     */
+    stockHiLowLineColor?: string | null;
+    /**
+     * `<c:stockChart><c:upDownBars>` presence (ECMA-376 §21.2.2.227). Parsed so a
+     * stock file carrying open-close up/down bars is recognized; the renderer does
+     * NOT yet draw them (tracked follow-up). null/undefined when absent.
+     */
+    stockUpDownBars?: boolean | null;
+    /**
+     * Structured box-and-whisker data (`chartType === 'boxWhisker'`). Present
+     * ONLY for boxWhisker charts; null/absent otherwise so the flat
+     * `categories`/`series` model the other chartEx renderers consume is
+     * untouched. The renderer computes quartiles / mean / whiskers / outliers.
+     */
+    chartexBox?: ChartexBoxWhisker | null;
+    /**
+     * Structured sunburst hierarchy (`chartType === 'sunburst'`). Present ONLY
+     * for sunburst charts; null/absent otherwise.
+     */
+    chartexSunburst?: ChartexSunburst | null;
+    /**
+     * Theme accent palette (`accent1..6`, hex without '#') for chartEx charts
+     * that color by branch/series index (boxWhisker series, sunburst branches).
+     * null/absent when the resolver supplies no default palette (pptx); the
+     * renderer then falls back to its own `CHART_PALETTE`.
+     */
+    chartexAccents?: string[] | null;
 }
 
 export declare interface ChartSeries {
@@ -498,6 +813,31 @@ export declare interface ChartSeries {
      * series.
      */
     bubbleSizes?: (number | null)[] | null;
+    /**
+     * `<c:ser><c:smooth val>` (ECMA-376 §21.2.2.194) — line/area series flag
+     * requesting a smoothed (spline) curve through the points instead of straight
+     * segments. Only consulted for the line and area families (scatter carries its
+     * smoothing in `ChartModel.scatterStyle`). null/undefined/false = straight
+     * polyline (the default; byte-stable for series that never set it).
+     */
+    smooth?: boolean | null;
+    /**
+     * `<c:ser><c:trendline>` per-series trendlines (ECMA-376 §21.2.2.211,
+     * `CT_Trendline`). A series can carry several (e.g. a linear fit + a moving
+     * average). null/undefined/empty = no trendline (the default; byte-stable for
+     * series that never declare one).
+     */
+    trendLines?: ChartTrendline[] | null;
+    /**
+     * `<c:ser><c:spPr><a:ln><a:noFill/>` (ECMA-376 §21.2.2.198 CT_ShapeProperties
+     * → DrawingML §20.1.2.2.24 CT_LineProperties). true when the series connecting
+     * line is explicitly turned OFF. For a scatter/line series this OVERRIDES the
+     * chart-group `<c:scatterStyle>` (§21.2.2.42) / line default — Excel and
+     * PowerPoint draw markers only (no connecting line) even when the group style
+     * is `lineMarker`. null/undefined = no explicit line-off, so the group default
+     * governs (byte-stable for series that carry a paintable line).
+     */
+    lineHidden?: boolean | null;
 }
 
 declare interface ChartSeriesDataLabels {
@@ -512,6 +852,51 @@ declare interface ChartSeriesDataLabels {
     fontBold?: boolean;
     /** Series-level font size for data labels (OOXML hundredths of a point). */
     fontSizeHpt?: number;
+    /** Series-default callout box (`<c:dLbls><c:spPr>`, ECMA-376 §21.2.2.49/
+     *  §21.2.2.197). When present the pie/doughnut renderer draws Word's boxed
+     *  callout layout (box + optional leader line) instead of plain text. */
+    labelBox?: ChartLabelBox;
+    /** `<c:dLbls><c:showLeaderLines val>` (§21.2.2.183) — draw leader lines from
+     *  a pulled-away label back to its slice. Default false. */
+    showLeaderLines?: boolean;
+    /** `<c:leaderLines><c:spPr><a:ln><a:solidFill>` (§21.2.2.92) resolved hex
+     *  (no `#`). undefined → renderer uses a neutral grey. */
+    leaderLineColor?: string;
+    /** `<c:leaderLines><c:spPr><a:ln w>` leader-line width in EMU. */
+    leaderLineWidthEmu?: number;
+}
+
+/**
+ * `<c:ser><c:trendline>` (ECMA-376 §21.2.2.211). A regression/smoothing curve
+ * fitted to the series' data points.
+ */
+declare interface ChartTrendline {
+    /**
+     * `<c:trendlineType val>` (§21.2.2.213, `ST_TrendlineType` §21.2.3.50):
+     * "linear" | "exp" | "log" | "power" | "poly" | "movingAvg". The renderer
+     * currently draws "linear" (least squares) and "movingAvg"; other types parse
+     * but are not yet plotted (tracked as a follow-up).
+     */
+    trendlineType: string;
+    /** `<c:order val>` — polynomial order (`poly`, default 2). */
+    order?: number | null;
+    /** `<c:period val>` — moving-average window (`movingAvg`, default 2). */
+    period?: number | null;
+    /** `<c:forward val>` — units to extend the line past the last point. */
+    forward?: number | null;
+    /** `<c:backward val>` — units to extend the line before the first point. */
+    backward?: number | null;
+    /** `<c:intercept val>` — forced y-intercept (linear/exp). null = free fit. */
+    intercept?: number | null;
+    /** `<c:dispRSqr val="1">` — show the R² value (label; not yet rendered). */
+    dispRSqr?: boolean | null;
+    /** `<c:dispEq val="1">` — show the fit equation (label; not yet rendered). */
+    dispEq?: boolean | null;
+    /** `<c:spPr><a:ln><a:solidFill>` trendline color (hex without '#'). null =
+     *  inherit the series color. */
+    lineColor?: string | null;
+    /** `<c:spPr><a:ln w>` trendline width in EMU. */
+    lineWidthEmu?: number | null;
 }
 
 /**
@@ -519,7 +904,7 @@ declare interface ChartSeriesDataLabels {
  * grouping (`Pct` = percent-stacked) so renderers do not need to inspect
  * separate `barDir`/`grouping` fields.
  */
-declare type ChartType = 'line' | 'stackedLine' | 'stackedLinePct' | 'clusteredBar' | 'clusteredBarH' | 'stackedBar' | 'stackedBarH' | 'stackedBarPct' | 'stackedBarHPct' | 'area' | 'stackedArea' | 'stackedAreaPct' | 'pie' | 'doughnut' | 'scatter' | 'bubble' | 'radar' | 'waterfall' | string;
+declare type ChartType = 'line' | 'stackedLine' | 'stackedLinePct' | 'clusteredBar' | 'clusteredBarH' | 'stackedBar' | 'stackedBarH' | 'stackedBarPct' | 'stackedBarHPct' | 'area' | 'stackedArea' | 'stackedAreaPct' | 'pie' | 'doughnut' | 'scatter' | 'bubble' | 'radar' | 'waterfall' | 'stock' | 'boxWhisker' | 'sunburst' | string;
 
 /**
  * Translucent overlay drawn over a finished slide so it reads faintly
@@ -535,6 +920,19 @@ export declare interface DimOptions {
     opacity: number;
 }
 
+/** A duotone effect resolved to its two endpoint colours. Both are 6-char
+ *  uppercase hex WITHOUT a leading `#` (the form the Rust parsers emit). `clr1`
+ *  is the dark endpoint (luminance 0), `clr2` the light endpoint (luminance 1),
+ *  matching the child order of `<a:duotone>` in §20.1.8.23. Any per-colour
+ *  transforms (lumMod/lumOff/tint/satMod/…) are already baked into these hexes
+ *  by the parser's colour-resolution machinery. */
+declare interface Duotone {
+    /** First `EG_ColorChoice` child — the dark endpoint. 6-char hex, no `#`. */
+    clr1: string;
+    /** Second `EG_ColorChoice` child — the light endpoint. 6-char hex, no `#`. */
+    clr2: string;
+}
+
 /**
  * An OMML equation embedded in a paragraph (ECMA-376 §22.1). Parsed into the
  * shared math AST and rendered by `@silurus/ooxml-core`'s math engine.
@@ -567,6 +965,47 @@ export declare interface FillRect {
     b?: number;
 }
 
+/**
+ * IX2 public find-result shape, shared by all three viewers.
+ *
+ * `findText` returns an ordered list of {@link FindMatch}. Every match carries
+ * its ordinal position (`matchIndex`, 0-based, document order — the same index
+ * `findNext` / `findPrev` cycle through), the matched `text`, and a
+ * format-specific `location`. The location is where the three formats
+ * legitimately differ — a docx match lives on a page, a pptx match on a slide,
+ * an xlsx match in a sheet cell — so `FindMatch` is generic over it rather than
+ * forcing an artificial common shape. Each viewer instantiates it with its own
+ * location type:
+ *
+ *   - `DocxViewer.findText` → `FindMatch<DocxMatchLocation>`  ({ page })
+ *   - `PptxViewer.findText` → `FindMatch<PptxMatchLocation>`  ({ slide })
+ *   - `XlsxViewer.findText` → `FindMatch<XlsxMatchLocation>`  ({ sheet, ref, … })
+ *
+ * The generic default is `unknown` so `FindMatch` can be referenced without a
+ * type argument (e.g. in generic UI code) while each viewer's return type stays
+ * precise.
+ */
+export declare interface FindMatch<Loc = unknown> {
+    /** 0-based ordinal among all matches, in document order. This is the index
+     *  `findNext`/`findPrev` make active, so a caller can correlate the array it
+     *  got from `findText` with the active-match reported by navigation. */
+    matchIndex: number;
+    /** The text that matched (the query as it appears in the document — its
+     *  original case, not the folded form used for case-insensitive matching). */
+    text: string;
+    /** Where the match is, in the format's own coordinates. */
+    location: Loc;
+}
+
+/** Options for {@link findMatches}. */
+export declare interface FindMatchesOptions {
+    /**
+     * Match case exactly. Default `false` (case-insensitive, like a browser's
+     * find-in-page). IX2 default — an integrator can pass `true`.
+     */
+    caseSensitive?: boolean;
+}
+
 /** ECMA-376 §20.1.8.17 (CT_GlowEffect) — coloured halo with blur radius. */
 export declare interface Glow {
     color: string;
@@ -592,6 +1031,49 @@ export declare interface GradientStop {
 /** How {@link PptxViewer} presents hidden slides (`<p:sld show="0">`). */
 export declare type HiddenSlideMode = 'show' | 'skip' | 'dim';
 
+/**
+ * Shared hyperlink model + URL sanitisation for docx / pptx / xlsx (IX1).
+ *
+ * All three formats carry the same two ECMA-376 concepts:
+ *   - an **external** hyperlink — an absolute URL resolved from a relationship
+ *     part target (`document.xml.rels` for docx §17.16.22, the slide rels for
+ *     pptx §21.1.2.3.5, the worksheet rels for xlsx §18.3.1.47), with
+ *     `TargetMode="External"`.
+ *   - an **internal** hyperlink — a jump within the document itself:
+ *     docx `w:anchor` -> a `<w:bookmarkStart w:name>` (§17.16.23), pptx
+ *     `action="ppaction://hlinksldjump"` -> a slide, xlsx `location` -> a defined
+ *     name or a `Sheet!A1` cell reference.
+ *
+ * The parsers (Rust, one per format) do the format-specific rels lookup and hand
+ * each run / shape / cell a {@link HyperlinkTarget}. Everything downstream — the
+ * text-layer overlay, the viewer default click behaviour, and any integrator
+ * callback — is format-agnostic and consumes this one shape. Keeping the type +
+ * the pure `sanitizeHyperlinkUrl` predicate here (not duplicated per package)
+ * follows the cross-package unification principle: a scheme-allowlist bug fixed
+ * once is fixed everywhere.
+ */
+/**
+ * A resolved hyperlink attached to a run, shape, or cell.
+ *
+ *   - `external` — `url` is the raw target as authored in the file. It is NOT
+ *     guaranteed safe; run it through {@link sanitizeHyperlinkUrl} before
+ *     navigating. It is kept verbatim here so an integrator can apply its own
+ *     policy (e.g. allow `file:` on a trusted intranet viewer).
+ *   - `internal` — `ref` is the in-document destination, verbatim from the file:
+ *       docx: the bookmark name (`w:anchor`).
+ *       pptx: the internal action (e.g. `ppaction://hlinksldjump`), with the
+ *             resolved 0-based `slideIndex` when the rels target names a slide.
+ *       xlsx: the `location` string (a defined name or `Sheet1!A1`).
+ */
+export declare type HyperlinkTarget = {
+    kind: 'external';
+    url: string;
+} | {
+    kind: 'internal';
+    ref: string;
+    slideIndex?: number;
+};
+
 /**
  * Image fill — ECMA-376 §20.1.8.14 (CT_BlipFillProperties). The embedded blip
  * is carried as a zip path + MIME; the renderer fetches the bytes on demand via
@@ -684,6 +1166,35 @@ declare interface LoadOptions_2 {
      * via `@font-face` in your application CSS.
      */
     useGoogleFonts?: boolean;
+    /**
+     * Password for an encrypted OOXML file ([MS-OFFCRYPTO] Agile Encryption).
+     *
+     * Password-protected Office documents are CFB (OLE2) containers, not ZIPs.
+     * When this is set and the input is Agile-encrypted, `load()` decrypts it on
+     * the main thread (via WebCrypto) and parses the recovered plaintext ZIP.
+     *
+     * Errors (thrown as {@link import('../errors/ooxml-error').OoxmlError}):
+     *   - no `password` on an encrypted file → code `'encrypted'`
+     *   - wrong `password`                   → code `'invalid-password'`
+     *   - a non-Agile scheme (Standard / Extensible / legacy) → code
+     *     `'unsupported-encryption'`
+     *
+     * Note: Agile Encryption uses a high password-hash spin count (commonly
+     * 100,000), so decryption of a protected file adds roughly a second of
+     * WebCrypto work before parsing begins.
+     *
+     * Security notes:
+     *   - This value is held as an ordinary JS `string` in memory for the
+     *     duration of key derivation. The library does not zero it, and does
+     *     not wrap it in a `SecureString`-equivalent — it becomes eligible for
+     *     garbage collection like any other string once nothing references it,
+     *     but no explicit wipe is performed. It is never logged or included in
+     *     thrown errors.
+     *   - Decryption recovers the plaintext but does not verify the file's HMAC
+     *     data-integrity tag ([MS-OFFCRYPTO] §2.3.4.14), so ciphertext tampering
+     *     is not detected — see "Security & Privacy" in the README.
+     */
+    password?: string;
     /**
      * Override the URL the parser worker fetches the WebAssembly module from.
      *
@@ -728,6 +1239,23 @@ declare interface LoadOptions_2 {
     math?: MathRenderer;
 }
 
+/**
+ * The slice of one run a match covers: the run's index in the original `runs[]`
+ * and the `[start, end)` character range within that run's own `text`. A match
+ * that straddles N runs yields N of these (the first sliced from its start
+ * offset to the run end, the last from 0 to its end offset, any middle run
+ * whole). The viewer measures each slice against that run's font to get a pixel
+ * rectangle.
+ */
+declare interface MatchRunSlice {
+    /** Index into the original `runs[]` handed to {@link buildTextIndex}. */
+    runIndex: number;
+    /** Start offset within `runs[runIndex].text` (inclusive). */
+    start: number;
+    /** End offset within `runs[runIndex].text` (exclusive). */
+    end: number;
+}
+
 /** Accent (`m:acc`), e.g. hat, bar, vector arrow over the base. */
 declare interface MathAccent {
     kind: 'accent';
@@ -750,6 +1278,31 @@ declare interface MathBar {
     base: MathNode[];
 }
 
+/** Border-box object (`m:borderBox`, §22.1.2.11): a border/strikes around the
+ *  base. Absent flags ⇒ a full rectangular box. */
+declare interface MathBorderBox {
+    kind: 'borderBox';
+    /** §22.1.2 hide* — when true the corresponding edge is NOT drawn. */
+    hideTop?: boolean;
+    hideBot?: boolean;
+    hideLeft?: boolean;
+    hideRight?: boolean;
+    /** §22.1.2 strike* — strikeBLTR = bottom-left→top-right, strikeTLBR =
+     *  top-left→bottom-right diagonal. */
+    strikeH?: boolean;
+    strikeV?: boolean;
+    strikeBltr?: boolean;
+    strikeTlbr?: boolean;
+    base: MathNode[];
+}
+
+/** Box object (`m:box`, §22.1.2.13): a logical grouping (operator emulator /
+ *  line-break control). Draws NO border — a transparent group around `base`. */
+declare interface MathBox {
+    kind: 'box';
+    base: MathNode[];
+}
+
 declare interface MathDelimiter {
     kind: 'delimiter';
     /** opening char (default '('). */
@@ -807,7 +1360,23 @@ declare interface MathNary {
     body: MathNode[];
 }
 
-declare type MathNode = MathRun | MathFraction | MathScript | MathNary | MathDelimiter | MathRadical | MathLimit | MathArray | MathGroupChr | MathBar | MathAccent | MathFunc | MathGroup;
+declare type MathNode = MathRun | MathFraction | MathScript | MathNary | MathDelimiter | MathRadical | MathLimit | MathArray | MathGroupChr | MathBar | MathAccent | MathFunc | MathGroup | MathPhant | MathSPre | MathBox | MathBorderBox;
+
+/** Phantom object (`m:phant`, §22.1.2.81): contributes the spacing of `base`
+ *  while optionally hiding it and/or zeroing individual dimensions. */
+declare interface MathPhant {
+    kind: 'phant';
+    /** §22.1.2.96 `m:show` — `false` hides the base (invisible but occupies space,
+     *  i.e. `<mphantom>`); `true` (default) shows it and the phant only tweaks
+     *  spacing. */
+    show: boolean;
+    /** §22.1.2 zeroWid / zeroAsc / zeroDesc — suppress width / ascent / descent so
+     *  the base takes no space along that axis. Omitted ⇒ false. */
+    zeroWid?: boolean;
+    zeroAsc?: boolean;
+    zeroDesc?: boolean;
+    base: MathNode[];
+}
 
 declare interface MathRadical {
     kind: 'radical';
@@ -850,6 +1419,15 @@ declare interface MathScript {
     sub?: MathNode[];
 }
 
+/** Pre-sub-superscript object (`m:sPre`, §22.1.2.99): sub + sup to the LEFT of
+ *  the base (e.g. ²₁A). */
+declare interface MathSPre {
+    kind: 'sPre';
+    sub: MathNode[];
+    sup: MathNode[];
+    base: MathNode[];
+}
+
 declare type MathStyle = 'roman' | 'italic' | 'bold' | 'boldItalic';
 
 declare interface MathSvg {
@@ -883,6 +1461,63 @@ export declare interface NoFill {
     fillType: 'none';
 }
 
+/**
+ * Typed error thrown by the docx / pptx / xlsx `load()` factories for failures
+ * that carry a stable, programmatic {@link OoxmlErrorCode} (e.g. a
+ * password-protected or legacy-binary file detected from its container magic).
+ *
+ * Note on workers: `instanceof OoxmlError` does not survive a structured-clone
+ * across the worker boundary. Detection that needs a typed error is therefore
+ * done on the main thread (before the worker is involved) so a genuine
+ * `OoxmlError` instance is thrown to the caller. Errors that must cross the
+ * worker boundary should carry the `code` string and be reconstructed on the
+ * main side.
+ */
+export declare class OoxmlError extends Error {
+    readonly code: OoxmlErrorCode;
+    constructor(code: OoxmlErrorCode, message: string);
+}
+
+/**
+ * Machine-readable code for a typed load-time failure.
+ *
+ * The container-level failures the `load()` factories detect on the main thread
+ * before handing bytes to the parser worker (see `sniffCfb` / `decryptOoxml`).
+ * This is the seed of the broader typed-error surface tracked as PD4 (OoxmlError
+ * typed errors). Add codes here rather than throwing bare `Error(string)`, so
+ * callers can `switch` on `err.code` instead of matching message text.
+ *
+ *   - `'encrypted'`             — password-protected, but no `password` was
+ *     supplied (pass `LoadOptions.password` to decrypt).
+ *   - `'invalid-password'`      — a `password` was supplied but did not match.
+ *   - `'unsupported-encryption'`— encrypted with a scheme other than Agile
+ *     (Standard / Extensible / a legacy binary encryptor), which this library
+ *     cannot decrypt (PD8 implements Agile only).
+ *   - `'legacy-binary-format'`  — a raw .doc / .xls / .ppt (not OOXML).
+ *   - `'not-ooxml'`             — a CFB of an unrecognised kind, or otherwise
+ *     not an OOXML ZIP.
+ */
+export declare type OoxmlErrorCode = 'encrypted' | 'invalid-password' | 'unsupported-encryption' | 'legacy-binary-format' | 'not-ooxml';
+
+/**
+ * The default action a viewer takes for an **external** hyperlink click when
+ * the integrator supplies no `onHyperlinkClick` handler: sanitise the URL and,
+ * if allowed, open it in a new tab with `noopener,noreferrer` so the opened page
+ * gets no `window.opener` handle back into this document. A blocked scheme is a
+ * silent no-op (returns `false`) — the click does nothing rather than navigate
+ * somewhere dangerous.
+ *
+ * Internal targets are intentionally NOT handled here: the in-document jump
+ * (page / slide / cell) is format-specific and lives in each viewer.
+ *
+ * Split out (not inlined in three viewers) so the "open in new tab, drop opener,
+ * refuse unsafe schemes" policy is defined once. `win` is injected for tests;
+ * defaults to the ambient `window`.
+ *
+ * @returns `true` if navigation was initiated, `false` if the URL was blocked.
+ */
+export declare function openExternalHyperlink(url: string, allowed?: readonly string[], win?: Pick<Window, 'open'> | undefined): boolean;
+
 /**
  * PPTX paragraph. Extends the shared core `Paragraph` with the PPTX-only
  * `eaLnBrk` flag that the pptx parser emits but the shared core model does not
@@ -1053,6 +1688,13 @@ export declare interface PictureElement {
     };
     /** a:blip > a:alphaModFix@amt as 0..1. Undefined = fully opaque. */
     alpha?: number;
+    /**
+     * ECMA-376 §20.1.8.23 `<a:duotone>` recolour, resolved to its two endpoint
+     * colours (through the slide theme). Undefined ⇒ no duotone. When present the
+     * renderer decodes the raster once, remaps it along the `clr1`→`clr2`
+     * luminance ramp, and caches the recoloured bitmap under a colour-suffixed key.
+     */
+    duotone?: Duotone;
     /**
      * `<p:spPr><a:custGeom>` clipping path. Same `PathCmd` model as
      * `ShapeElement.custGeom` (one entry per `<a:path>`; coords normalized
@@ -1095,6 +1737,21 @@ export declare interface PptxComment {
     text: string;
 }
 
+export declare interface PptxHighlightColors {
+    match?: string;
+    active?: string;
+}
+
+export declare interface PptxHighlightMatch {
+    slices: MatchRunSlice[];
+    active: boolean;
+}
+
+/** Where a pptx match lives: its 0-based slide index. */
+export declare interface PptxMatchLocation {
+    slide: number;
+}
+
 /**
  * Headless PPTX rendering engine.
  *
@@ -1116,15 +1773,24 @@ export declare class PptxPresentation {
     private _mode;
     private _presentation;
     private _meta;
+    /** Lazily-built `partName → slide index` map for internal hyperlink slide
+     *  jumps (IX-nav). Cleared on {@link destroy}; built on first
+     *  {@link getSlideIndexByPartName}/{@link resolveInternalTarget} from either
+     *  the parsed slides (main) or the worker meta's `partNames` (worker). */
+    private _slidePartIndex;
     private _mediaCache;
     private _imageCache;
+    /** Google-Fonts `FontFace` objects this deck preloaded into `document.fonts`
+     *  (main mode only — in worker mode the worker owns them and terminates with
+     *  its own FontFaceSet). Released in {@link destroy} so they do not leak into
+     *  the shared FontFaceSet for the lifetime of the SPA (deduped + refcounted in
+     *  core, so a web font shared with another open deck survives until both go). */
+    private _googleFontFaces;
     /** One stable closure per instance: the decoded-bitmap and SVG caches key on
      *  this identity to scope decodes per deck (so two open decks never swap
      *  images for a shared zip path like ppt/media/image1.png). Reusing the same
      *  reference across every render also lets those caches hit across slides. */
     private readonly _fetchImage;
-    private _workerReady;
-    private _workerReadyCallbacks;
     /** Opt-in OMML equation engine, injected once at {@link load}. Every
      *  `renderSlide` / `presentSlide` reuses it — equations render when present,
      *  and are skipped (engine tree-shaken) when omitted. */
@@ -1132,7 +1798,6 @@ export declare class PptxPresentation {
     private constructor();
     /** Parse a PPTX from URL or ArrayBuffer. */
     static load(source: string | ArrayBuffer, opts?: LoadOptions): Promise<PptxPresentation>;
-    private _waitForWorker;
     private _parse;
     /** Total number of slides in the loaded presentation. */
     get slideCount(): number;
@@ -1173,6 +1838,44 @@ export declare class PptxPresentation {
      * caller's policy (see {@link PptxViewer}'s `hiddenSlideMode` modes).
      */
     isHidden(slideIndex: number): boolean;
+    /** The per-slide `partName` array (`sldIdLst` order) from either the parsed
+     *  model (main) or the worker meta (worker). Backs the lazy part-index map. */
+    private _partNames;
+    /** Lazily build (and cache) the `partName → index` map. Nulled by
+     *  {@link destroy} so a reused reference never serves a stale deck's indices. */
+    private _partIndex;
+    /**
+     * Resolve a slide's OPC part name (e.g. `ppt/slides/slide3.xml`) to its
+     * 0-based index in `sldIdLst` order, or `undefined` when no slide has that
+     * part name. This is the map an internal hyperlink slide jump
+     * (`<a:hlinkClick action="ppaction://hlinksldjump" r:id>`, ECMA-376
+     * §21.1.2.3.5) resolves against: the click's rel Target names a slide part, and
+     * this turns it into the index a viewer can navigate to. Works in both `main`
+     * and `worker` mode (the part names ride along in the worker meta).
+     */
+    getSlideIndexByPartName(partName: string): number | undefined;
+    /**
+     * Resolve an internal hyperlink target string to a 0-based slide index, or
+     * `undefined` when it names no reachable slide. Handles both
+     * `<a:hlinkClick @action>` classes (§21.1.2.3.5):
+     *
+     *   - a **relative** show jump — `ppaction://hlinkshowjump?jump=firstslide |
+     *     lastslide | nextslide | previousslide` — resolved arithmetically from
+     *     `currentIndex` (clamped at the deck ends);
+     *   - a **specific** slide-part jump — `ppaction://hlinksldjump`, whose
+     *     resolved target is a slide-rel part name like `../slides/slide3.xml` —
+     *     resolved through {@link getSlideIndexByPartName}.
+     *
+     * `ref` is the internal reference a `HyperlinkTarget` of kind `'internal'`
+     * carries: the raw `ppaction://…` action string for a relative jump, or the
+     * resolved slide-part target string for a specific jump. A viewer's
+     * `onHyperlinkClick` default calls this with `ref` and the current slide, then
+     * navigates to the returned index.
+     *
+     * @param ref          the internal action/target string.
+     * @param currentIndex the 0-based slide the jump is relative to (default 0).
+     */
+    resolveInternalTarget(ref: string, currentIndex?: number): number | undefined;
     /** Render a slide onto the given canvas. */
     renderSlide(canvas: HTMLCanvasElement | OffscreenCanvas, slideIndex: number, opts?: RenderSlideOptions): Promise<void>;
     /**
@@ -1185,6 +1888,16 @@ export declare class PptxPresentation {
      * when done, or its backing memory is held until GC.
      */
     renderSlideToBitmap(slideIndex: number, opts?: RenderSlideToBitmapOptions): Promise<ImageBitmap>;
+    /**
+     * IX6 — collect a slide's text-run geometry (`PptxTextRunInfo[]`) without
+     * painting a visible canvas. Works in BOTH modes: worker mode renders the
+     * slide off-thread and ships only the runs (no bitmap transfer); main mode
+     * renders to a throwaway offscreen canvas. Used by the find controller to scan
+     * every slide for matches. Run geometry is in CSS px (independent of dpr) and
+     * dimming does not move glyphs, so only `width` is threaded — matching the
+     * historical main-mode `_collectSlideRuns`.
+     */
+    collectSlideRuns(slideIndex: number, width?: number): Promise<PptxTextRunInfo[]>;
     /**
      * Extract raw media bytes for a zip path referenced by {@link MediaElement}.
      * Results are cached by path for the lifetime of this instance.
@@ -1199,6 +1912,23 @@ export declare class PptxPresentation {
      * decoded lazily rather than inlined as base64 at parse time.
      */
     getImage(imagePath: string, mimeType: string): Promise<Blob>;
+    /**
+     * Project the presentation to GitHub-flavoured markdown: title slides become
+     * `#` headings, body shapes become nested bullets at each paragraph's `lvl`,
+     * tables become pipe tables, charts become summarised bullets, and speaker
+     * notes and comments are collated. Positioning, animations, images, and
+     * drawing detail are discarded — the projection is meant for AI ingestion and
+     * full-text search, not layout.
+     *
+     * Runs entirely in the worker off the archive opened at {@link load} (no
+     * re-copy of the file, no re-parse of the model on the main thread), so it
+     * works in BOTH `mode: 'main'` and `mode: 'worker'`.
+     *
+     * @example
+     * const pres = await PptxPresentation.load(buffer);
+     * const md = await pres.toMarkdown();
+     */
+    toMarkdown(): Promise<string>;
     /**
      * Render a slide and attach canvas-native playback controls for any
      * embedded audio/video. Returns a {@link PresentationHandle} that owns the
@@ -1210,7 +1940,7 @@ export declare class PptxPresentation {
     destroy(): void;
 }
 
-export declare class PptxScrollViewer {
+export declare class PptxScrollViewer implements ZoomableViewer {
     private _pres;
     private readonly _injected;
     private readonly _opts;
@@ -1234,6 +1964,18 @@ export declare class PptxScrollViewer {
      *  than a `_scale === 1` sentinel because a fit scale of exactly 1 is a valid
      *  established state (a 1× fit would otherwise be re-fit forever). */
     private _scaleEstablished;
+    /**
+     * IX9 F1 — a `setScale` factor requested BEFORE the base fit is established
+     * (pre-load, or a zero-width container), already clamped to
+     * `[zoomMin, zoomMax]`, or `null` when none is pending. The single-canvas
+     * viewers latch a pre-load `setScale` and honour it on the first render; the
+     * scroll viewers used to silently DROP it — the family-unified semantics are
+     * "latch and apply once the layout establishes". `relayout()` applies (and
+     * clears) this right after establishing the base, firing `onScaleChange` at
+     * application time; `getScale()` reports it while pending so the caller sees
+     * the same value a single-canvas viewer would show.
+     */
+    private _pendingScale;
     /** Live slots keyed by slide index. */
     private readonly _slots;
     /** Recyclable detached slots (canvas + textLayer reused across slides). */
@@ -1248,6 +1990,23 @@ export declare class PptxScrollViewer {
      *  reporting an error so a rejection that lands after teardown is swallowed
      *  rather than surfaced to a `onError` on a dead viewer. */
     private _destroyed;
+    /**
+     * Concurrent-load latch (generation token). Every self-loading `load()`
+     * increments this and captures the value; after its engine finishes loading it
+     * re-checks the live value and BAILS (destroying its own just-loaded engine) if
+     * a newer `load()` has since started. Without it, two overlapping
+     * `load(A)`/`load(B)` calls race the WASM parse / worker init, and whichever
+     * RESOLVES last wins the swap — even the stale `load(A)` resolving after
+     * `load(B)`; the loser's freshly created engine (never installed, or installed
+     * then overwritten) then leaks its worker + pinned WASM allocation. The latch
+     * composes with SC20: the check runs AFTER the new engine loads but BEFORE the
+     * field assignment, `previous?.destroy()`, and the recycle/relayout post-load
+     * work, so a superseded load never touches `this._pres` nor frees the current
+     * (newer) engine. Only the self-loading path uses it — the injected path throws
+     * up-front and never reaches here. `destroy()` also bumps it so a load in flight
+     * at teardown is treated as superseded and its engine cleaned up.
+     */
+    private _loadGen;
     /** Worker mode: slide indices whose bitmap render is currently dispatched to the
      *  engine. Coalesces a scroll storm — we never dispatch a second render for a
      *  slide whose first is still in flight — and lets us drop slides that scrolled
@@ -1278,11 +2037,14 @@ export declare class PptxScrollViewer {
      *  is host-agnostic. */
     private _settleTimer;
     private _wheelListener;
-    /** One-shot latch for the worker-mode text-selection warning. The overlay is a
-     *  main-mode-only feature: in worker mode the per-run `onTextRun` geometry
-     *  cannot cross the worker boundary, so an `enableTextSelection` overlay stays
-     *  empty. We warn once (parity with `PptxViewer`) rather than per slot. */
-    private _warnedNoTextSelection;
+    /** Gesture-only pointer anchor for the NEXT `setScale`, in scrollHost-viewport
+     *  px (`{ x, y }` from the wheel event, relative to the scroll host's top-left).
+     *  Set by the Ctrl/⌘+wheel handler right before it calls `setScale` so the zoom
+     *  pivots on the cursor ("zoom toward the pointer") in BOTH axes; consumed and
+     *  cleared by `setScale`. `null` for every non-gesture source (the public
+     *  `setScale`, the +/- steppers, `fitWidth`/`fitPage`, the resize re-fit), which
+     *  keep the historical viewport-TOP re-anchor so their behaviour is unchanged. */
+    private _pendingZoomAnchor;
     /** Observes the container so a width change re-fits the base scale. Disconnected
      *  in `destroy()`. */
     private _resizeObserver;
@@ -1358,6 +2120,12 @@ export declare class PptxScrollViewer {
      *  `_positionSlot` (the flush-left floor), and by `_syncSpacerWidth` (the spacer
      *  width). Resolved here (not stored) to mirror `_gap()`/`_pad()`. */
     private _padH;
+    /** Index of the slide whose slot spans content-offset `y` (largest `i` with
+     *  `offsets[i] <= y`), for the pointer-anchored zoom re-anchor. Mirrors the
+     *  `topIndex` search `computeVisibleRange` runs for the scrollTop, but for an
+     *  ARBITRARY content-y (the pointer, not the viewport top). Clamped into
+     *  `[0, n-1]`; a `y` below the first slide (inside the leading pad) yields 0. */
+    private _slideIndexAtOffset;
     private _range;
     private _syncSpacer;
     /** Horizontal scroll extent: the (uniform deck-wide) slide width plus both
@@ -1406,10 +2174,6 @@ export declare class PptxScrollViewer {
      * can pass for an old-epoch resolution). We gate them on the captured epoch.
      */
     private _renderSlot;
-    /** Warn once when an `enableTextSelection` overlay was requested but the render
-     *  mode is `worker` (so the overlay stays empty). Same wording as
-     *  `PptxViewer` — one warning per viewer, not per slot. */
-    private _maybeWarnNoTextSelection;
     /** Route an async render failure to `onError`, or `console.error` when none is
      *  set (so failures are never fully silent), and never after teardown. */
     private _reportRenderError;
@@ -1445,7 +2209,10 @@ export declare class PptxScrollViewer {
      * `[zoomMin ?? 0.1, zoomMax ?? 4]` (absolute bounds, XlsxViewer convention — NOT
      * multiples of the base fit; design §3 keeps the clamp in the viewer, not core),
      * then re-anchor VERTICALLY so the slide currently under the viewport top stays
-     * fixed. A no-op when nothing is loaded or when the clamped scale is unchanged.
+     * fixed. A no-op when the clamped scale is unchanged. Called BEFORE the deck is
+     * loaded / the base fit is established, the clamped factor is LATCHED (IX9 F1,
+     * family-unified with the single-canvas viewers) and applied by `relayout()`
+     * once the layout establishes — `onScaleChange` fires then.
      *
      * FLICKER-FREE (design §7): this does NOT re-render the visible slides inline.
      * It shows an immediate CSS preview (stretch the existing bitmaps, scale the
@@ -1466,6 +2233,39 @@ export declare class PptxScrollViewer {
      * can no longer return below the floor to the original base fit through this API.
      */
     setScale(scale: number): void;
+    /** IX9 {@link ZoomableViewer} — the current zoom factor, where `1` = 100% (a
+     *  slide at its natural EMU→px size). This is the viewer's absolute `_scale`
+     *  (`slideWidth/EMU_PER_PX × _scale` is the drawn width), so it reads `1` at
+     *  true 100% and, after the initial fit-to-width, the base fit factor. Before
+     *  the fit is established it reports a latched pre-load `setScale` (IX9 F1) if
+     *  one is pending — matching what a single-canvas viewer would show — else `1`. */
+    getScale(): number;
+    /** IX9 {@link ZoomableViewer} — step up to the next rung of the shared zoom
+     *  ladder above the current factor (clamped to `zoomMax` by {@link setScale}). */
+    zoomIn(): void;
+    /** IX9 {@link ZoomableViewer} — step down to the next lower ladder rung. */
+    zoomOut(): void;
+    /**
+     * IX9 {@link ZoomableViewer} — fit a slide's WIDTH to the container (the classic
+     * continuous-scroll "fit width"). Sets the scale to the width-fit base for the
+     * current container, then re-anchors + re-renders via {@link setScale}. Defers
+     * (no-op) while the container is unlaid-out. The `zoomMin`/`zoomMax` clamp still
+     * applies, so a fit below `zoomMin` pins to `zoomMin`.
+     */
+    fitWidth(): void;
+    /**
+     * IX9 {@link ZoomableViewer} — fit a WHOLE slide (width and height) inside the
+     * container so one slide is visible without scrolling; takes the tighter of the
+     * width/height fit. Uses the deck-wide (uniform) slide size. Defers while
+     * unlaid-out.
+     */
+    fitPage(): void;
+    /** Shared fit for {@link fitWidth}/{@link fitPage}: the width-fit factor is the
+     *  established base (`_baseScale`); the page-fit additionally bounds by the
+     *  container height against the (uniform) slide height. Applies via
+     *  {@link setScale} so the flicker-free re-anchor / settle path and
+     *  `onScaleChange` all run. */
+    private _fit;
     /**
      * CSS preview of the visible window at the current `_scale` (design §7
      * mechanism 1), WITHOUT re-rendering. Slots leaving the window recycle normally;
@@ -1492,12 +2292,11 @@ export declare class PptxScrollViewer {
     private _scheduleSettle;
     /** Full-resolution settle re-render of the visible window (design §7 mechanisms
      *  2+3). Re-renders each mounted slot at the current scale via the double-buffer
-     *  swap (main) / same-canvas transfer (worker). Main mode also rebuilds the text
-     *  overlay and clears its preview transform; in worker mode the overlay is
-     *  permanently empty (text selection is main-mode-only), so the transform is
-     *  inert there and is reset on recycle. Dispatched at the CURRENT epoch; the
-     *  existing epoch gate discards it if a later `setScale` supersedes it
-     *  mid-render. */
+     *  swap (main) / same-canvas transfer (worker). Both modes rebuild the text
+     *  overlay from the fresh render's run geometry (IX6 — worker mode collects the
+     *  runs off-thread via `_renderSlotBitmap`) and clear the preview transform.
+     *  Dispatched at the CURRENT epoch; the existing epoch gate discards it if a
+     *  later `setScale` supersedes it mid-render. */
     private _settleRender;
     /**
      * Settle-render one slot at the current scale (design §7 mechanism 3).
@@ -1539,6 +2338,22 @@ export declare class PptxScrollViewer {
     scrollToSlide(index: number, opts?: {
         behavior?: 'auto' | 'smooth';
     }): void;
+    /**
+     * IX1 hyperlink click dispatch (mirrors {@link PptxViewer._onHyperlinkClick}).
+     * When the integrator supplies `opts.onHyperlinkClick` it OWNS the click (no
+     * default). Otherwise: an external link opens in a new tab via the shared,
+     * scheme-sanitised {@link openExternalHyperlink}; an internal slide jump scrolls
+     * to the target slide via {@link scrollToSlide} once the action resolves to a
+     * slide index (a jump resolving to no reachable slide is a safe no-op).
+     */
+    private _onHyperlinkClick;
+    /** Populate an internal {@link HyperlinkTarget}'s `slideIndex` from its `ref`
+     *  via the engine's stamped part names. Relative `hlinkshowjump` verbs are
+     *  resolved against the slide currently at the viewport top
+     *  (`_range().topIndex`); a `../slides/slideN.xml` part target resolves through
+     *  the part-name map. An already-set index, an external target, and an
+     *  unresolvable ref all pass through unchanged (safe no-op). */
+    private _resolveInternalSlideIndex;
     /**
      * Re-fit the base scale on a container resize while PRESERVING the current zoom
      * multiplier (design §11), then re-anchor + re-render. A `ResizeObserver` fires
@@ -1572,6 +2387,8 @@ export declare class PptxScrollViewer {
     /* Excluded from this release type: baseScaleForTest */
     /* Excluded from this release type: renderEpochForTest */
     /* Excluded from this release type: resizeForTest */
+    /* Excluded from this release type: contentAtViewportYForTest */
+    /* Excluded from this release type: viewportYOfForTest */
     /**
      * Tear down the viewer: remove the DOM subtree and (only for a self-loaded
      * engine) destroy the engine. An injected engine is left intact — the caller
@@ -1624,9 +2441,10 @@ export declare interface PptxScrollViewerOptions extends Omit<RenderSlideOptions
     paddingRight?: number;
     /** Slides kept mounted beyond the viewport on each side. Default 1. */
     overscan?: number;
-    /** Per-slide transparent text-selection overlay. MAIN render mode only:
-     *  in worker mode `onTextRun` cannot cross the worker boundary, so the overlay
-     *  stays empty and the viewer logs one warning (design §11). */
+    /** Per-slide transparent text-selection overlay. IX6 — works in BOTH render
+     *  modes: in worker mode the per-run geometry is collected off-thread and
+     *  shipped back beside the slide bitmap, so the overlay is populated identically
+     *  to main mode (no more empty overlay / one-time warning). */
     enableTextSelection?: boolean;
     /** Minimum zoom scale — a DIMENSIONLESS multiplier over the 96-dpi natural
      *  slide size (10% = 0.1), matching `DocxScrollViewer`. Default 0.1. */
@@ -1670,6 +2488,12 @@ export declare interface PptxScrollViewerOptions extends Omit<RenderSlideOptions
      *  `computeVisibleRange` (the first slide intersecting the viewport top,
      *  EXCLUDING overscan). */
     onVisibleSlideChange?: (topIndex: number, total: number) => void;
+    /** IX9 — fires whenever the zoom factor actually changes (`1` = 100% = a slide
+     *  at its natural EMU→px size): from {@link PptxScrollViewer.setScale},
+     *  `zoomIn`/`zoomOut`, `fitWidth`/`fitPage`, a Ctrl/⌘+wheel gesture, or a
+     *  container-resize re-fit. Named `onScaleChange` to match the single-canvas
+     *  viewers so all five share one notification shape. */
+    onScaleChange?: (scale: number) => void;
     /** Error callback. When set, `load()` invokes it and resolves (otherwise the
      *  error is rethrown — shared viewer error contract). It ALSO fires for async
      *  per-slot render failures (both main `renderSlide` and worker
@@ -1677,6 +2501,17 @@ export declare interface PptxScrollViewerOptions extends Omit<RenderSlideOptions
      *  crashing the loop. Without an `onError`, render failures are logged via
      *  `console.error` so they are never fully silent. */
     onError?: (err: Error) => void;
+    /**
+     * IX1 (design decision — NOT user-confirmed, integrator may veto). Fires on a
+     * hyperlink click in any mounted slide's text overlay (requires
+     * {@link enableTextSelection}). Default when omitted: external →
+     * {@link openExternalHyperlink} (new tab, sanitised, noopener); internal
+     * slide-jump → {@link scrollToSlide} once the action resolves to a slide index
+     * via {@link PptxPresentation.resolveInternalTarget} (a jump that resolves to
+     * no reachable slide is a safe no-op). When provided, the viewer calls this
+     * instead and takes NO default action.
+     */
+    onHyperlinkClick?: (target: HyperlinkTarget) => void;
 }
 
 /** Information about a rendered text segment for building a transparent selection overlay. */
@@ -1709,6 +2544,14 @@ export declare interface PptxTextRunInfo {
      * `vert="vert270"` → -90). The CSS overlay must add this to `rotation`.
      */
     textBodyRotation?: number;
+    /**
+     * Resolved hyperlink target for this run (IX1), classified into the shared
+     * {@link HyperlinkTarget} shape. Present only for runs whose `<a:rPr>` carried
+     * an `<a:hlinkClick>`; the overlay makes such spans clickable. The glyph
+     * drawing (colour + underline) is unaffected — this is metadata for the
+     * transparent overlay only.
+     */
+    hyperlink?: HyperlinkTarget;
 }
 
 /**
@@ -1721,9 +2564,18 @@ export declare interface PptxTextRunInfo {
  *
  * For custom layouts (multi-canvas, thumbnails, scroll view) use PptxPresentation directly.
  */
-export declare class PptxViewer {
+export declare class PptxViewer implements ZoomableViewer {
     private readonly canvas;
     private readonly wrapper;
+    /**
+     * IX9 explicit zoom factor (`1` = 100% = the slide at its natural EMU→px
+     * width), or `null` when the caller has never invoked a zoom method. `null`
+     * preserves the pre-IX9 render path EXACTLY: the slide renders at `opts.width`
+     * (or `canvas.offsetWidth || 960` when unset), so default rendering is
+     * byte-identical. The first zoom call latches a number here, after which
+     * {@link _targetWidth} derives the render width from it.
+     */
+    private _scale;
     /** The canvas's DOM position BEFORE the constructor reparented it into
      *  {@link wrapper}, captured so {@link destroy} can return the caller-owned
      *  canvas to exactly where it was. `null` parent = canvas was passed
@@ -1734,6 +2586,13 @@ export declare class PptxViewer {
      *  (empty string if it was unset), restored on {@link destroy}. */
     private readonly _originalDisplay;
     private textLayer;
+    /** IX2 — the find-highlight overlay layer (always created, above the text
+     *  layer, `pointer-events:none`). */
+    private highlightLayer;
+    /** IX2 — find state (per-slide runs, matches, active cursor). */
+    private _find;
+    /** Private 2d context for measuring highlight text (own 1×1 canvas). */
+    private _measureCtx;
     private engine;
     private readonly opts;
     private currentSlide;
@@ -1744,14 +2603,39 @@ export declare class PptxViewer {
      *  render path. The media-playback path keeps a 2d context (via presentSlide),
      *  so this is obtained only when worker mode renders without media playback. */
     private _bitmapCtx;
-    private _warnedNoTextSelection;
+    /** Set by {@link destroy} (first line). Guards {@link _reportRenderError} so a
+     *  render rejection that lands AFTER teardown is swallowed rather than surfaced
+     *  to an `onError` / `console.error` on a dead viewer — parity with the scroll
+     *  viewers' `_destroyed` flag. */
+    private _destroyed;
+    /**
+     * Concurrent-load latch (generation token). Every {@link load} increments this
+     * and captures the value; after its engine finishes loading it re-checks the
+     * live value and BAILS (destroying its own just-loaded engine) if a newer
+     * `load()` has since started. Without it, two overlapping `load(A)`/`load(B)`
+     * calls race the WASM parse / worker init, and whichever RESOLVES last wins the
+     * swap — even the stale `load(A)` resolving after `load(B)`; the loser's freshly
+     * created engine (never installed, or installed then overwritten) then leaks its
+     * worker + pinned WASM allocation. The latch composes with SC20: the check runs
+     * AFTER the new engine loads but BEFORE the field assignment and
+     * `previous?.destroy()`, so a superseded load never touches `this.engine` nor
+     * frees the current (newer) engine. {@link destroy} also bumps it so a load in
+     * flight at teardown is treated as superseded and its engine cleaned up.
+     */
+    private _loadGen;
     constructor(canvas: HTMLCanvasElement, opts?: PptxViewerOptions);
     /**
      * Load a PPTX from URL or ArrayBuffer and render the first slide.
      *
-     * Error contract (shared by all three viewers): on failure, if an `onError`
-     * callback was provided it is invoked and `load` resolves normally; if not,
-     * the error is rethrown so it is never silently swallowed.
+     * Error contract (shared by all three viewers):
+     * - Parse/load failure (the underlying `PptxPresentation.load()` call itself
+     *   rejects): if an `onError` callback was provided it is invoked and `load`
+     *   resolves normally; if not, the error is rethrown so it is never silently
+     *   swallowed.
+     * - Render failure (the first slide fails to draw AFTER a successful
+     *   parse/load): routed to the shared `_reportRenderError` contract (`onError`
+     *   if provided, else `console.error` — never silent) and `load` still
+     *   RESOLVES, matching every subsequent navigation call.
      */
     load(source: string | ArrayBuffer): Promise<void>;
     /** Navigate to a specific slide (0-indexed). */
@@ -1784,8 +2668,115 @@ export declare class PptxViewer {
     getNotes(slideIndex: number): string | null;
     /** The underlying <canvas> element. */
     get canvasElement(): HTMLCanvasElement;
+    /** Natural (100%) CSS-px width of a slide — `slideWidth(EMU) / EMU_PER_PX`.
+     *  0 when nothing is loaded. The scale-1 reference every zoom factor
+     *  multiplies. */
+    private _naturalWidthPx;
+    /**
+     * The width (CSS px) the render paths draw the slide at, honouring the zoom
+     * state. `_scale === null` (no zoom method ever called) ⇒ the pre-IX9 value
+     * `opts.width ?? (canvas.offsetWidth || 960)` verbatim (byte-identical
+     * default). Once a factor latched ⇒ `naturalWidth × scale` (rounded), so the
+     * slide is exactly `scale ×` its natural size regardless of `opts.width`.
+     */
+    private _targetWidth;
+    /** IX9 {@link ZoomableViewer} — the current zoom factor (`1` = 100%). Before
+     *  any zoom method is called this is the EFFECTIVE scale implied by the render
+     *  width: `targetWidth / naturalWidth`, or `1` when nothing is loaded. */
+    getScale(): number;
+    private _zoomMin;
+    private _zoomMax;
+    /**
+     * IX9 {@link ZoomableViewer} — set the absolute zoom factor (`1` = 100% = the
+     * slide at its natural EMU→px width), clamped to `[zoomMin, zoomMax]`, and
+     * re-render the current slide at the new size. Fires `onScaleChange` when the
+     * clamped factor actually changes. Resolves once the re-render settles.
+     */
+    setScale(scale: number): Promise<void>;
+    /** IX9 {@link ZoomableViewer} — step up to the next rung of the shared zoom
+     *  ladder (clamped to `zoomMax`). */
+    zoomIn(): Promise<void>;
+    /** IX9 {@link ZoomableViewer} — step down to the next lower ladder rung. */
+    zoomOut(): Promise<void>;
+    /**
+     * IX9 {@link ZoomableViewer} — fit the current slide's WIDTH to the host
+     * container (the element the canvas lives in), then re-render. Defers (no-op)
+     * when nothing is loaded or the container is unlaid-out. Routes through
+     * {@link setScale}.
+     */
+    fitWidth(): Promise<void>;
+    /**
+     * IX9 {@link ZoomableViewer} — fit the WHOLE current slide (width and height)
+     * inside the container so it is fully visible; takes the tighter of the
+     * width/height fit. Defers when unloaded / unlaid-out.
+     */
+    fitPage(): Promise<void>;
+    /** Shared fit for {@link fitWidth}/{@link fitPage}: measure the natural slide
+     *  size + the container box, ask core's pure `fitScale`, apply via setScale. */
+    private _fit;
     private renderCurrentSlide;
+    /** Draw the find-highlight boxes for the current slide from its runs. */
+    private _buildHighlightLayer;
+    /** A width-measurer primed with `font`, backed by a private 1×1 canvas. */
+    private _measureForFont;
+    /** IX6 — collect a slide's runs for search without touching the visible
+     *  canvas. Delegates to `collectSlideRuns`, which works in BOTH modes (worker:
+     *  off-thread, ships only the runs; main: throwaway offscreen canvas). Used for
+     *  slides other than the one on screen. */
+    private _collectSlideRuns;
+    /**
+     * IX2 — find every occurrence of `query` across all slides and highlight them
+     * (a soft box per match on the highlight overlay). Returns every match in
+     * document order, each tagged with its `{ slide }` (0-based). Case-insensitive
+     * by default; pass `{ caseSensitive: true }` for an exact match.
+     *
+     * Scans all slides (each rendered once offscreen to read its text; the visible
+     * slide reuses its on-screen render). IX6 — works in BOTH `mode: 'main'` and
+     * `mode: 'worker'`: in worker mode each slide's run geometry is collected
+     * off-thread and shipped back, so find returns the same matches on the same
+     * code path. An empty query clears the find.
+     */
+    findText(query: string, opts?: FindMatchesOptions): Promise<FindMatch<PptxMatchLocation>[]>;
+    /**
+     * IX2 — move to the next match (wrap-around), navigating to its slide if
+     * needed, and draw it in the active-match colour. Returns the now-active
+     * match, or `null` when there are none. Call {@link findText} first.
+     */
+    findNext(): Promise<FindMatch<PptxMatchLocation> | null>;
+    /** IX2 — move to the previous match (wrap-around). */
+    findPrev(): Promise<FindMatch<PptxMatchLocation> | null>;
+    /** IX2 — clear all highlights and reset the find state. */
+    clearFind(): void;
+    private _activateMatch;
+    /** Rebuild the highlight overlay for the current slide from cached runs. */
+    private _redrawHighlights;
     private _buildTextLayer;
+    /**
+     * IX1/IX-nav hyperlink click dispatch. An internal target is first *enriched*
+     * with its resolved 0-based `slideIndex` (via
+     * {@link PptxPresentation.resolveInternalTarget}, relative to the current
+     * slide) so a jump verb / slide-part ref arrives already mapped — this is the
+     * field that was previously always `undefined`. When the integrator supplies
+     * `opts.onHyperlinkClick` it OWNS the (enriched) click and takes NO default
+     * action. Otherwise the viewer's default policy applies: an external link
+     * opens in a new tab via the shared, scheme-sanitised
+     * {@link openExternalHyperlink}; an internal slide jump navigates via
+     * {@link goToSlide} to the resolved index (a target that resolves to no
+     * reachable slide is a safe no-op).
+     */
+    private _onHyperlinkClick;
+    /** Populate an internal {@link HyperlinkTarget}'s `slideIndex` from its `ref`
+     *  (a `ppaction://hlinkshowjump?jump=…` verb resolved relative to the current
+     *  slide, or a `../slides/slideN.xml` part target resolved through the stamped
+     *  part-name map — no filename-suffix heuristic). Any already-set `slideIndex`
+     *  is kept; an external target and an unresolvable ref pass through unchanged so
+     *  the caller no-ops safely. */
+    private _resolveInternalSlideIndex;
+    /** PD14 render-error contract: route a render failure to `onError`, or
+     *  `console.error` when none is given (never fully silent), and never after
+     *  teardown. Mirrors the scroll viewers' `_reportRenderError` so all three
+     *  single-canvas viewers agree. */
+    private _reportRenderError;
     /**
      * Clean up the viewer and terminate the background worker.
      *
@@ -1803,6 +2794,17 @@ export declare interface PptxViewerOptions extends RenderOptions, LoadOptions {
     onSlideChange?: (index: number, total: number) => void;
     /** Called on parse or render errors */
     onError?: (err: Error) => void;
+    /** IX9 zoom contract ({@link ZoomableViewer}) — the clamp range for
+     *  {@link PptxViewer.setScale} / `zoomIn` / `zoomOut` / `fitWidth` / `fitPage`,
+     *  as user-facing zoom factors (`1` = 100% = the slide at its natural
+     *  EMU→px size). Defaults 0.1–4 (10%–400%), matching the other viewers. */
+    zoomMin?: number;
+    zoomMax?: number;
+    /** IX9 — fires whenever the zoom factor actually changes (`1` = 100%): from
+     *  {@link PptxViewer.setScale}, `zoomIn`/`zoomOut`, or `fitWidth`/`fitPage`.
+     *  Named `onScaleChange` to match the docx/xlsx viewers so all five share one
+     *  notification shape. */
+    onScaleChange?: (scale: number) => void;
     /**
      * Enable interactive audio/video playback. When true, slides are rendered
      * via {@link PptxPresentation.presentSlide} so media elements become
@@ -1834,6 +2836,17 @@ export declare interface PptxViewerOptions extends RenderOptions, LoadOptions {
      * in sync if {@link DimOptions} gains a field.
      */
     hiddenSlideDim?: Partial<DimOptions>;
+    /**
+     * IX1 (design decision — NOT user-confirmed, integrator may veto). Fires on a
+     * hyperlink click (a text run whose `<a:rPr>` carried an `<a:hlinkClick>`;
+     * requires {@link enableTextSelection} so the overlay spans exist). Default
+     * when omitted: external → {@link openExternalHyperlink} (new tab, sanitised,
+     * noopener); internal slide-jump → {@link goToSlide} once the action resolves
+     * to a slide index via {@link PptxPresentation.resolveInternalTarget} (a jump
+     * that resolves to no reachable slide is a safe no-op). When provided, the
+     * viewer calls this instead and takes NO default action.
+     */
+    onHyperlinkClick?: (target: HyperlinkTarget) => void;
 }
 
 export declare interface Presentation {
@@ -1949,6 +2962,14 @@ export declare interface RenderSlideToBitmapOptions {
     /* Excluded from this release type: skipMediaControls */
     /** Translucent overlay drawn over the finished slide (hidden-slide dimming). */
     dim?: DimOptions;
+    /**
+     * IX6 — receives the slide's text-run geometry (the same stream `renderSlide`
+     * emits in main mode). Stays main-thread (never crosses the wire); in worker
+     * mode the proxy invokes it with the runs the worker shipped back beside the
+     * bitmap, so a caller builds the selection / find overlay on the SAME code
+     * path in both modes.
+     */
+    onTextRun?: TextRunCallback;
 }
 
 /**
@@ -2004,6 +3025,13 @@ declare interface SecondaryValueAxis {
     lineHidden: boolean;
     /** `<c:majorTickMark>` — "cross" (default) | "out" | "in" | "none". */
     majorTickMark: string;
+    /**
+     * `<c:valAx><c:majorUnit val>` (§21.2.2.103) — explicit distance between
+     * major ticks/gridlines on THIS secondary axis, overriding the Excel-style
+     * auto "nice" step. null/undefined ⇒ auto step (byte-stable). Symmetric with
+     * {@link ChartModel.valAxisMajorUnit} on the primary axis.
+     */
+    majorUnit?: number | null;
     /** `<c:title>` run-prop font size (hpt). */
     titleFontSizeHpt?: number | null;
     /** `<c:title>` run-prop bold flag. */
@@ -2077,12 +3105,32 @@ export declare interface ShapeElement {
     /** `<a:sp3d>` 3D shape properties (ECMA-376 §20.1.5.12). Parsed but not
      *  rendered in Phase A. */
     sp3d?: Sp3d;
+    /** Shape-level hyperlink target resolved from `<p:cNvPr><a:hlinkClick @r:id>`
+     *  via slide _rels (ECMA-376 §21.1.2.3.5). For an external link this is the
+     *  URL; for an internal slide jump it is the resolved internal part name.
+     *  Undefined when the shape carries no hlinkClick. */
+    hyperlink?: string;
+    /** Raw `<a:hlinkClick @action>` (e.g. `"ppaction://hlinksldjump"`) when the
+     *  shape link is an internal PowerPoint action rather than an external URL.
+     *  Undefined when absent. */
+    hyperlinkAction?: string;
 }
 
 export declare interface Slide {
     index: number;
     /** 1-based slide number (index + 1); used to render slidenum fields */
     slideNumber: number;
+    /**
+     * The slide's normalized OPC part name (e.g. `ppt/slides/slide3.xml`),
+     * resolved through `presentation.xml.rels` in `sldIdLst` order (ECMA-376
+     * §19.3.1.42). An internal hyperlink slide jump
+     * (`<a:hlinkClick action="ppaction://hlinksldjump" r:id>`, §21.1.2.3.5)
+     * carries a rel Target that resolves to this same part name — so
+     * {@link PptxPresentation.getSlideIndexByPartName} can turn a click into a
+     * slide index. Absent (`undefined`) only for a slide whose part path was not
+     * recorded; healthy and broken slides both carry it.
+     */
+    partName?: string;
     background: Fill | null;
     elements: SlideElement[];
     /**
@@ -2106,6 +3154,14 @@ export declare interface Slide {
      * slide modes (read it via `PptxPresentation.isHidden`).
      */
     hidden?: boolean;
+    /**
+     * RB7 partial degradation: set when this slide's part could not be parsed. The
+     * deck still opens with the OTHER slides intact; this one is a placeholder
+     * (`elements` empty) whose `parseError` names the offending part (e.g.
+     * `"ppt/slides/slide3.xml: <detail>"`). Absent (`undefined`) for every healthy
+     * slide. The renderer paints a visible error box instead of slide content.
+     */
+    parseError?: string;
 }
 
 export declare type SlideElement = ShapeElement | PictureElement | TableElement | ChartElement | MediaElement;
@@ -2243,6 +3299,19 @@ export declare interface TextBody extends TextBody_2 {
      * omitted from JSON when false. Only meaningful when `numCol > 1`.
      */
     rtlCol?: boolean;
+    /**
+     * `<a:bodyPr><a:prstTxWarp>` (ECMA-376 §20.1.9.19) — WordArt text warp. When
+     * present the renderer maps each glyph through the named envelope
+     * (presetTextWarpDefinitions) instead of laying text out flat. Omitted from
+     * JSON when the body has no warp, so unwarped bodies are byte-identical.
+     */
+    textWarp?: {
+        /** The `prst` name, e.g. `"textArchUp"`, `"textWave1"`. */
+        preset: string;
+        /** `<a:avLst>` adjust values (adj1, adj2, …) in thousandths of a percent.
+         *  Omitted when the author supplied none (preset defaults apply). */
+        adj?: number[];
+    };
     /**
      * Narrow the inherited `paragraphs` to the PPTX `Paragraph` so consumers see
      * the PPTX-only `eaLnBrk` flag. PPTX `Paragraph extends CoreParagraph`, so
@@ -2375,10 +3444,19 @@ export declare interface TextRunData {
     /** Set for OOXML field runs (e.g. "slidenum"). When set, renderer replaces text with field value. */
     fieldType?: string;
     /**
-     * Hyperlink target URL resolved from rPr > a:hlinkClick @r:id via the slide's _rels.
-     * Undefined for runs without a hyperlink. ECMA-376 §21.1.2.3.5 (CT_Hyperlink).
+     * Hyperlink target resolved from rPr > a:hlinkClick @r:id via the slide's _rels.
+     * For an external link this is the URL; for an internal slide jump it is the
+     * resolved internal part name (e.g. "../slides/slide3.xml"). Undefined for runs
+     * without a hyperlink. ECMA-376 §21.1.2.3.5 (CT_Hyperlink).
      */
     hyperlink?: string;
+    /**
+     * Raw `<a:hlinkClick @action>` string (e.g. "ppaction://hlinksldjump") when
+     * present — its presence marks {@link hyperlink} as an INTERNAL PowerPoint
+     * action (slide jump / first / last …) rather than an external URL. Undefined
+     * when the hlinkClick has no @action. ECMA-376 §21.1.2.3.5. (IX1)
+     */
+    hyperlinkAction?: string;
     /**
      * Run-level drop shadow on glyphs (`<a:rPr><a:effectLst><a:outerShdw>`),
      * ECMA-376 §20.1.8.45. Independent of the shape-level shadow on `spPr`.
@@ -2428,4 +3506,90 @@ export declare interface TileInfo {
     algn: string;
 }
 
+/**
+ * IX9 — the shared zoom API contract for every viewer (DocxViewer, PptxViewer,
+ * DocxScrollViewer, PptxScrollViewer, XlsxViewer).
+ *
+ * This module owns ONLY the pure, DOM-free pieces of the contract: the type
+ * ({@link ZoomableViewer}), the discrete zoom-step ladder ({@link nextZoomStep} /
+ * {@link prevZoomStep}), the fit-to-content scale math ({@link fitScale}), and the
+ * range clamp ({@link clampScale}). Each viewer implements the interface with its
+ * own scale field and re-render path; this keeps ONE definition of "what a zoom
+ * factor means" and "what the +/- steps are" across all five, so a host can drive
+ * any viewer through the same six calls without special-casing the format.
+ *
+ * SCALE SEMANTICS (the contract): a scale of `1` means 100% — the content at its
+ * natural size (a docx page at `widthPt × PT_TO_PX`, a pptx slide at
+ * `slideWidth / EMU_PER_PX`, an xlsx grid at `cellScale` 1). `getScale()` and
+ * `setScale(n)` speak this user-facing factor for EVERY viewer.
+ *
+ * KNOWN FAMILY DIFFERENCE — the INITIAL scale right after load (deliberate,
+ * documented rather than papered over): the single-canvas viewers (DocxViewer /
+ * PptxViewer) and XlsxViewer start at `1` (or the effective factor implied by an
+ * explicit `width` option); the continuous-scroll viewers (DocxScrollViewer /
+ * PptxScrollViewer) AUTO-FIT to the container on first layout, so their
+ * `getScale()` right after load reports the fit-to-width BASE factor (≠ 1 unless
+ * the container happens to match the natural width). The unit is identical — only
+ * the starting point differs, because fit-to-width is the natural resting state
+ * of a continuous document viewer.
+ *
+ * PRE-LOAD `setScale` (family-unified, IX9 F1): a `setScale` called before the
+ * content is loaded / before the layout is established is LATCHED — never
+ * silently dropped — and applied once the viewer establishes its scale (the
+ * single-canvas viewers honour it on the first render; the scroll viewers apply
+ * it right after the base fit establishes, firing `onScaleChange` at application
+ * time). `getScale()` reports the latched factor while it is pending.
+ *
+ * API SHAPE (idiomatic default — the integrator MAY veto; see the IX9 PR): a
+ * six-method surface plus one change notification (`onScaleChange`). Deliberately
+ * NO new UI here — the contract is API only (design decision IX9 §4). Touch-pinch
+ * (IX8) is out of scope.
+ */
+/**
+ * The zoom contract every viewer satisfies. All scales are the user-facing factor
+ * where `1` = 100% (see the module note). `fitWidth`/`fitPage` are async because a
+ * fit re-renders at the new scale; the getters/steppers resolve synchronously.
+ */
+declare interface ZoomableViewer {
+    /** The current zoom factor (`1` = 100%). Never throws — returns the default
+     *  (`1`) before anything is loaded, or the latched pending factor when a
+     *  pre-load `setScale` is waiting to be applied (see the module note). */
+    getScale(): number;
+    /** Set the absolute zoom factor (`1` = 100%), clamped to the viewer's
+     *  `[zoomMin, zoomMax]`. Re-renders at the new scale and fires `onScaleChange`
+     *  when the clamped value actually changes. Called BEFORE the content is
+     *  loaded / the layout is established, the (clamped) factor is LATCHED and
+     *  applied once the viewer establishes its scale — family-unified semantics
+     *  (IX9 F1): never silently dropped by any viewer. */
+    setScale(scale: number): void | Promise<void>;
+    /** Step up to the next larger rung of the shared zoom ladder (25 %→400 %),
+     *  clamped to `zoomMax`. Equivalent to `setScale(nextZoomStep(getScale()))`. */
+    zoomIn(): void | Promise<void>;
+    /** Step down to the next smaller ladder rung, clamped to `zoomMin`. */
+    zoomOut(): void | Promise<void>;
+    /** Fit the content's WIDTH to the container (the common "fit width" / "fit
+     *  page width" verb). Sets the scale so one page/slide/sheet-column-run spans
+     *  the available width, then re-renders. Resolves once the fit render settles.
+     *
+     *  PERSISTENCE is viewer-implementation-dependent (deliberate, by family): the
+     *  single-canvas viewers (DocxViewer / PptxViewer) and XlsxViewer apply the fit
+     *  ONE-SHOT — they observe no container resizes, so a later resize does NOT
+     *  re-fit (call `fitWidth()` again after a layout change). The continuous-
+     *  scroll viewers (DocxScrollViewer / PptxScrollViewer) re-fit their width-fit
+     *  base on every container resize, so a `fitWidth()` there effectively
+     *  PERSISTS across resizes (the resize re-fit preserves the width-fit state). */
+    fitWidth(): void | Promise<void>;
+    /** Fit the WHOLE content (width AND height) inside the container, so an entire
+     *  page/slide is visible without scrolling. Sets the scale to the smaller of the
+     *  width- and height-fit factors, then re-renders.
+     *
+     *  PERSISTENCE is viewer-implementation-dependent, and — unlike `fitWidth` —
+     *  a page fit does NOT persist across container resizes on ANY viewer: the
+     *  single-canvas viewers and XlsxViewer observe no resizes at all (one-shot),
+     *  and the continuous-scroll viewers' resize handler re-applies the WIDTH fit
+     *  (preserving the zoom multiplier), not the page fit. Re-invoke `fitPage()`
+     *  after a layout change to re-fit. */
+    fitPage(): void | Promise<void>;
+}
+
 export { }