@silurus/ooxml 0.70.2 → 0.72.0

package/dist/types/xlsx.d.ts

@@ -46,14 +46,23 @@ export declare interface BorderEdge {
 export declare interface Cell {
     col: number;
     row: number;
-    colRef: string;
     value: CellValue;
-    styleIndex: number;
+    /** Style index into the styles table. Omitted on the wire when `0` (the
+     *  common unstyled case), so read it as `styleIndex ?? 0`. */
+    styleIndex?: number;
     /** Raw `<f>` formula text (ECMA-376 §18.3.1.40), when present. The renderer
      *  uses this to recompute volatile functions (TODAY, NOW) at display time
      *  so the cached `<v>` — frozen when the file was last saved — doesn't
      *  show a stale date. */
     formula?: string;
+    /** Whether this cell displays its phonetic hint (furigana). The parser
+     *  resolves it as `cell/@ph ?? row/@ph ?? false` — the per-cell `<c ph>`
+     *  (ECMA-376 §18.3.1.4) wins when present (an explicit `ph="0"` overrides an
+     *  enabled row), otherwise the row-level `<row ph>` (§18.3.1.73) is inherited,
+     *  otherwise the schema default (false). Omitted on the wire when false, so
+     *  read as `showPhonetic ?? false`. A cell whose String Item carries `<rPh>`
+     *  runs still shows NO furigana unless the resolved value is true. */
+    showPhonetic?: boolean;
 }
 
 export declare interface CellAddress {
@@ -102,6 +111,15 @@ export declare type CellValue = {
     type: 'text';
     text: string;
     runs?: Run[];
+    /** ECMA-376 §18.4.6 phonetic runs (furigana) carried over from the
+     *  resolved String Item. Present for inline strings, and populated by
+     *  {@link resolveSharedStrings} for shared-string cells. Absent when the
+     *  string has no furigana. */
+    phoneticRuns?: PhoneticRun[];
+    /** ECMA-376 §18.4.3 phonetic display properties (font index / char set /
+     *  alignment) for the furigana above. Absent when the `<si>` had no
+     *  `<phoneticPr>`. */
+    phoneticPr?: PhoneticProperties;
 } | {
     type: 'number';
     number: number;
@@ -111,6 +129,14 @@ export declare type CellValue = {
 } | {
     type: 'error';
     error: string;
+}
+/** Shared-string reference into `ParsedWorkbook.sharedStrings` (ECMA-376
+*  §18.4.8). Resolved to `{ type: 'text', ... }` by the workbook before the
+*  renderer (or any other consumer) sees it, so downstream code never
+*  encounters this variant. */
+| {
+    type: 'shared';
+    si: number;
 };
 
 export declare interface CellXf {
@@ -223,6 +249,30 @@ export 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;
 }
 
 export declare interface ChartDataPointOverride {
@@ -233,6 +283,18 @@ export 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;
 }
 
 export declare interface ChartErrBars {
@@ -250,6 +312,74 @@ export 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" =
@@ -270,6 +400,14 @@ export declare interface ChartModel {
     title: string | null;
     categories: string[];
     series: ChartSeries[];
+    /**
+     * §21.2.2.227 `<c:varyColors val="1"/>` on a SINGLE-series bar/column chart:
+     * color each data point (bar) from the theme/palette sequence and list one
+     * legend entry per point, matching Office. Set by the shared parser ONLY for
+     * that non-pie, single-series case (pie/doughnut already vary by point via
+     * `chartType` + `dataPointColors`); absent/false otherwise.
+     */
+    varyColors?: boolean | null;
     /** Show data labels on bars / points / slices. */
     showDataLabels: boolean;
     /** Explicit Y-axis minimum (OOXML `<c:valAx><c:min>`). */
@@ -380,6 +518,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
@@ -454,6 +621,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 {
@@ -563,6 +887,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;
 }
 
 export declare interface ChartSeriesDataLabels {
@@ -577,6 +926,51 @@ export 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;
 }
 
 /**
@@ -584,7 +978,7 @@ export 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;
 
 export declare interface ConditionalFormat {
     sqref: CellRange_2[];
@@ -624,6 +1018,16 @@ export declare interface DefinedName {
     formula: string;
 }
 
+/** ECMA-376 §20.1.8.23 `<a:duotone>` image effect, resolved to its two endpoint
+ *  colours (mirrors the shared Rust `ooxml_common::blip::Duotone`). `clr1` is the
+ *  dark endpoint (luminance 0), `clr2` the light endpoint (luminance 1); both are
+ *  6-char uppercase hex WITHOUT a leading `#`, with per-colour transforms already
+ *  applied by the parser. */
+export declare interface Duotone {
+    clr1: string;
+    clr2: string;
+}
+
 export declare interface Dxf {
     font: CellFont | null;
     fill: CellFill | null;
@@ -638,6 +1042,47 @@ export declare interface Dxf {
 /** @deprecated Use `ChartErrBars` from @silurus/ooxml-core. */
 export declare type ErrBars = ChartErrBars;
 
+/**
+ * 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;
+}
+
 export declare interface GradientFillSpec {
     /** "linear" (default) or "path". */
     gradientType: string;
@@ -660,9 +1105,60 @@ export declare type HiddenSheetMode = 'show' | 'skip' | 'dim';
 export declare interface Hyperlink {
     col: number;
     row: number;
+    /** External target (ECMA-376 §18.3.1.47 `r:id`, resolved via worksheet rels).
+     *  `null` for a purely internal hyperlink. */
     url: string | null;
+    /** Internal target (§18.3.1.47 `location`): a defined name or a cell reference
+     *  such as `Sheet1!A1`. Present when the hyperlink navigates within the
+     *  workbook rather than to an external URL. */
+    location?: string | null;
+    /** Optional display text (§18.3.1.47 `display`). Not used for rendering. */
+    display?: string | null;
 }
 
+/**
+ * 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 anchored to a rectangle of cells (EMU offsets within the anchor cells).
  * 914400 EMU = 1 inch, 9525 EMU = 1 px @ 96 DPI.
@@ -711,6 +1207,15 @@ export declare interface ImageAnchor {
         r: number;
         b: number;
     };
+    /** ECMA-376 §20.1.8.6 `<a:alphaModFix@amt>` — the blip's overall opacity as a
+     *  fraction (0..1). Absent ⇒ opaque. The renderer sets `ctx.globalAlpha` so the
+     *  picture composites over the cells beneath it (e.g. a pink translucent photo
+     *  over a matching cell fill). */
+    alpha?: number;
+    /** ECMA-376 §20.1.8.23 `<a:duotone>` recolour effect. Absent (the common case)
+     *  ⇒ no effect. When present, the renderer remaps the image along the
+     *  `clr1`→`clr2` luminance ramp before drawing. */
+    duotone?: Duotone;
 }
 
 export declare interface LegendManualLayout {
@@ -760,6 +1265,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.
      *
@@ -829,6 +1363,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 '('). */
@@ -886,7 +1445,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';
@@ -929,6 +1504,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 {
@@ -952,6 +1536,73 @@ export declare interface NumFmt {
     formatCode: string;
 }
 
+/**
+ * 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;
+
+/** `<sheetPr><outlinePr>` flags (ECMA-376 §18.3.1.61). Both default to `true`. */
+export declare interface OutlinePr {
+    /** `true` (default) ⇒ a group's summary row sits *below* its detail rows;
+     *  `false` ⇒ above. */
+    summaryBelow: boolean;
+    /** `true` (default) ⇒ a group's summary column sits to the *right* of its
+     *  detail columns; `false` ⇒ to the left. */
+    summaryRight: boolean;
+}
+
 export declare interface ParsedWorkbook {
     workbook: Workbook;
     styles: Styles;
@@ -999,6 +1650,38 @@ export declare interface PathInfo {
     commands: PathCmd[];
 }
 
+/** ECMA-376 §18.18.56 ST_PhoneticAlignment — how the furigana is aligned over
+ *  the base text. Absent on {@link PhoneticProperties} defaults to `'left'`. */
+export declare type PhoneticAlignment = 'left' | 'center' | 'distributed' | 'noControl';
+
+/** ECMA-376 §18.4.3 `<phoneticPr>` — phonetic display properties. */
+export declare interface PhoneticProperties {
+    /** Zero-based index into `Styles.fonts` (§18.18.32 ST_FontId). Out of bounds
+     *  falls back to font 0 (§18.4.3). Drives the furigana font size / family. */
+    fontId: number;
+    /** §18.18.57 — absent means `'fullwidthKatakana'` (schema default). */
+    type?: PhoneticType;
+    /** §18.18.56 — absent means `'left'` (schema default). */
+    alignment?: PhoneticAlignment;
+}
+
+/** ECMA-376 §18.4.6 `<rPh sb=".." eb="..">` — one furigana run. `sb`/`eb` are
+ *  zero-based character offsets into the base text; the hint `text` is shown
+ *  over base characters `[sb, eb)`. */
+export declare interface PhoneticRun {
+    /** Zero-based start character offset into the base text (inclusive). */
+    sb: number;
+    /** Zero-based end character offset into the base text (exclusive). */
+    eb: number;
+    /** The phonetic hint text (e.g. the katakana reading). */
+    text: string;
+}
+
+/** ECMA-376 §18.18.57 ST_PhoneticType — the East-Asian character set the
+ *  furigana is displayed in. Absent on {@link PhoneticProperties} defaults to
+ *  `'fullwidthKatakana'` per the CT_PhoneticPr schema. */
+export declare type PhoneticType = 'fullwidthKatakana' | 'halfwidthKatakana' | 'Hiragana' | 'noConversion';
+
 export declare interface RenderViewportOptions {
     width?: number;
     height?: number;
@@ -1052,10 +1735,34 @@ export declare type ResolvedList = {
     formula: string;
 };
 
+/**
+ * Resolve every `{ type: 'shared', si }` cell in `ws` to a concrete
+ * `{ type: 'text', text, runs? }` by looking `si` up in the workbook
+ * `sharedStrings` table (ECMA-376 §18.4.8). Mutates cells in place and returns
+ * `ws` for chaining. Out-of-range / missing `si` resolves to empty text —
+ * matching the parser's historical fallback. Idempotent: a `Worksheet` with no
+ * `shared` cells is returned unchanged.
+ *
+ * This keeps the dedup win on the wire (each shared string ships ONCE in the
+ * workbook) while every downstream consumer — renderer, formula engine, number
+ * formatter, markdown — still sees fully-resolved cell text.
+ */
+export declare function resolveSharedStrings(ws: Worksheet, sharedStrings: SharedString[]): Worksheet;
+
 export declare interface Row {
     index: number;
     height: number | null;
     cells: Cell[];
+    /** Outline (grouping) depth 0-7 (ECMA-376 §18.3.1.73 `<row outlineLevel>`).
+     *  Omitted on the wire when `0` (ungrouped); read as `outlineLevel ?? 0`. */
+    outlineLevel?: number;
+    /** `<row collapsed>` (§18.3.1.73): `true` on a summary row whose
+     *  one-level-deeper detail rows are collapsed. Omitted when false. */
+    collapsed?: boolean;
+    /** `<row hidden>` (§18.3.1.73): `true` when the row is hidden — most often
+     *  because a collapsed outline hides its detail rows. Distinct from
+     *  `height === 0`. Omitted on the wire when false. */
+    hidden?: boolean;
 }
 
 export declare interface Run {
@@ -1113,6 +1820,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. */
@@ -1186,6 +1900,12 @@ export declare type ShapeGeom = {
         r: number;
         b: number;
     };
+    /** ECMA-376 §20.1.8.6 `<a:alphaModFix@amt>` opacity fraction (0..1) on the
+     *  leaf pic. Absent ⇒ opaque. Applied via `globalAlpha`. */
+    alpha?: number;
+    /** ECMA-376 §20.1.8.23 `<a:duotone>` recolour on the leaf pic. Absent ⇒
+     *  no effect. */
+    duotone?: Duotone;
 };
 
 export declare interface ShapeInfo {
@@ -1300,6 +2020,12 @@ export declare type ShapeTextRun = {
 export declare interface SharedString {
     text: string;
     runs?: Run[];
+    /** ECMA-376 §18.4.6 phonetic runs (furigana). Absent when the `<si>` has no
+     *  `<rPh>`. */
+    phoneticRuns?: PhoneticRun[];
+    /** ECMA-376 §18.4.3 phonetic display properties. Absent when the `<si>` has
+     *  no `<phoneticPr>`. */
+    phoneticPr?: PhoneticProperties;
 }
 
 export declare interface SheetMeta {
@@ -1460,11 +2186,51 @@ export declare interface ViewportRange {
 
 /** Serializable subset of RenderViewportOptions: drop the callback, the image
  *  cache, and the `fetchImage` loader (all non-cloneable; the worker owns its
- *  own cache and supplies its own in-worker fetchImage). */
-export declare type WireRenderViewportOptions = Omit<RenderViewportOptions, 'onTextRun' | 'loadedImages' | 'fetchImage'>;
+ *  own cache and supplies its own in-worker fetchImage). Extended with the
+ *  optional {@link WireSizeOverrides} so view-only size mutations reach the
+ *  worker's local sheet copy; absent (the common case) when nothing has been
+ *  resized or collapsed, keeping the wire payload unchanged. */
+export declare type WireRenderViewportOptions = Omit<RenderViewportOptions, 'onTextRun' | 'loadedImages' | 'fetchImage'> & {
+    sizeOverrides?: WireSizeOverrides;
+};
+
+/**
+ * View-only per-band size overrides for one sheet, carried with every worker
+ * `renderViewport` request. The render worker draws from its own worker-local
+ * parsed-sheet cache, so main-thread Worksheet mutations (outline
+ * collapse/expand via the size-0 hidden encoding, drag-to-resize #567) never
+ * reach it on their own — without this channel the gutter/overlays update but
+ * the grid bitmap stays stale.
+ *
+ * Semantics: keys are 1-based band indices; a number is the band's current
+ * `rowHeights` / `colWidths` model value, `null` means "no entry — fall back
+ * to the sheet default". The main thread accumulates every band the user has
+ * touched this session (entries are updated in place, never removed), so
+ * re-applying the full map is idempotent and converges the worker's cached
+ * sheet to the main model even across worker-side re-parses.
+ */
+export declare interface WireSizeOverrides {
+    rows?: Record<number, number | null>;
+    cols?: Record<number, number | null>;
+}
 
 export declare interface Workbook {
     sheets: SheetMeta[];
+    /** Workbook date system (`<workbookPr date1904>`, ECMA-376 §18.2.28).
+     *  `true` selects the 1904 date system (Mac-authored workbooks); serial
+     *  dates are resolved against the 1904 epoch (§18.17.4.1). Omitted from the
+     *  parser JSON when false (default 1900 date system). */
+    date1904?: boolean;
+    /** #773 partial degradation: a WORKBOOK-LEVEL degradation that leaves every
+     *  sheet openable. Set when a shared workbook part was PRESENT but corrupt —
+     *  most commonly `xl/sharedStrings.xml` (§18.4.9): a broken shared-string table
+     *  silently blanks every string cell across ALL sheets, so unlike a per-sheet
+     *  break it can't be attributed to one placeholder sheet. Tagged with the
+     *  offending part (e.g. `"xl/sharedStrings.xml: <detail>"`) so the loss is
+     *  surfaced instead of silent, while every sheet still renders its non-string
+     *  content. Absent (`undefined`) when every shared part read cleanly. Also set
+     *  (`"(zip container): <detail>"`) for a whole-container degradation (#774). */
+    parseError?: string;
 }
 
 export declare interface Worksheet {
@@ -1472,6 +2238,17 @@ export declare interface Worksheet {
     rows: Row[];
     colWidths: Record<number, number>;
     rowHeights: Record<number, number>;
+    /** Per-column outline (grouping) depth 0-7 (ECMA-376 §18.3.1.13
+     *  `<col outlineLevel>`), keyed by 1-based column index. Present only for
+     *  grouped columns; absent (⇒ level 0) on outline-free sheets. */
+    colOutlineLevels?: Record<number, number>;
+    /** Per-column `<col collapsed>` (§18.3.1.13): `true` on a summary column whose
+     *  one-level-deeper detail columns are collapsed. Only `true` entries. */
+    colCollapsed?: Record<number, boolean>;
+    /** Per-column `<col hidden>` (§18.3.1.13): `true` when the column is hidden
+     *  (e.g. a collapsed outline hides its detail columns). Distinct from
+     *  `colWidths[c] === 0`. Only `true` entries. */
+    colHidden?: Record<number, boolean>;
     defaultColWidth: number;
     defaultRowHeight: number;
     mergeCells: MergeCell[];
@@ -1494,6 +2271,11 @@ export declare interface Worksheet {
      *  grid so column A sits on the right (ECMA-376 §18.3.1.87
      *  `<sheetView rightToLeft>`). Defaults to false. */
     rightToLeft?: boolean;
+    /** Outline display flags from `<sheetPr><outlinePr>` (ECMA-376 §18.3.1.61).
+     *  Absent when the sheet declares no `<outlinePr>`; consumers apply the
+     *  schema defaults (`summaryBelow` / `summaryRight` both `true`). Decides
+     *  which side of a group the summary row/column (and its +/- toggle) sits. */
+    outlinePr?: OutlinePr;
     /** Sheet tab color (ECMA-376 §18.3.1.79). */
     tabColor?: string | null;
     /** AutoFilter header range (ECMA-376 §18.3.1.2). */
@@ -1537,6 +2319,17 @@ export declare interface Worksheet {
     defaultFontFamily?: string;
     /** Point size of the workbook's Normal-style font (`<fonts>[N].sz.val`). */
     defaultFontSize?: number;
+    /** Workbook date system (`<workbookPr date1904>`, ECMA-376 §18.2.28),
+     *  denormalized onto every worksheet by the parser so the cell formatter can
+     *  resolve serial dates (§18.17.4.1) without a workbook back-reference.
+     *  `true` = 1904 date system. Omitted (⇒ false) for the default 1900 system. */
+    date1904?: boolean;
+    /** RB7 partial degradation: set when THIS sheet's part could not be
+     *  read/parsed. The workbook still opens with the OTHER sheets intact; this one
+     *  is an empty placeholder (`rows` empty) whose `parseError` names the offending
+     *  part (e.g. `"xl/worksheets/sheet3.xml: <detail>"`). Absent (`undefined`) for
+     *  every healthy sheet. The renderer paints a visible error overlay. */
+    parseError?: string;
 }
 
 /**
@@ -1563,6 +2356,20 @@ export declare interface XlsxComment {
     text: string;
 }
 
+/** Where an xlsx match lives: the sheet, its name, and the cell (A1 + row/col). */
+export declare interface XlsxMatchLocation {
+    /** 0-based sheet index. */
+    sheet: number;
+    /** The sheet's display name. */
+    sheetName: string;
+    /** A1 cell reference, e.g. `"B7"`. */
+    ref: string;
+    /** 1-based row. */
+    row: number;
+    /** 1-based column. */
+    col: number;
+}
+
 /** Emitted once per cell that has text, with the cell's canvas-pixel bounds. */
 export declare interface XlsxTextRunInfo {
     text: string;
@@ -1578,13 +2385,53 @@ export declare interface XlsxTextRunInfo {
     col: number;
 }
 
-export declare class XlsxViewer {
+export declare class XlsxViewer implements ZoomableViewer {
     private wb;
     /** The single subtree root the constructor appended to the caller's
      *  container. destroy() removes it to return the container to its original
      *  (empty) state. */
     private wrapper;
     private canvas;
+    /** Region holding the outline gutters (top/left) and the inset {@link canvasArea}.
+     *  When the active sheet has no outlining the gutters collapse to 0 px and this
+     *  is a transparent pass-through, so an outline-free sheet lays out identically. */
+    private gridRegion;
+    /** Left gutter canvas: row group brackets + toggles (XL4). */
+    private rowGutter;
+    /** Top gutter canvas: column group brackets + toggles (XL4). */
+    private colGutter;
+    /** Top-left corner canvas: numbered level buttons (XL4). */
+    private cornerGutter;
+    /** Cached extents (unscaled CSS px) of the current sheet's gutters; both 0 for
+     *  an outline-free sheet. `w` insets {@link canvasArea} from the left, `h` from
+     *  the top. */
+    private gutter;
+    /** Per-axis outline layout (group brackets + toggles) for the current sheet,
+     *  recomputed on sheet switch and after each collapse/expand. `null` axis ⇒ no
+     *  outlining on that axis. */
+    private rowOutline;
+    private colOutline;
+    private rowOutlineBands;
+    private colOutlineBands;
+    /** Original row heights / column widths stashed the first time a band is
+     *  collapsed, so expanding restores a custom size rather than the default.
+     *  Keyed by band index; per current worksheet (cleared on sheet switch). */
+    private stashedRowHeights;
+    private stashedColWidths;
+    /**
+     * Per-sheet cumulative record of every view-only size mutation (outline
+     * collapse/expand, drag-to-resize #567), keyed by sheet index. Value = the
+     * band's current model size, or `null` when the model has no entry (default
+     * size). Serialized as {@link WireSizeOverrides} with every worker
+     * `renderViewport` so the worker's local sheet cache converges to the
+     * main-thread model — without it the worker keeps drawing the file's
+     * original sizes and the grid bitmap goes stale under the (up-to-date)
+     * gutter and overlays. Entries are updated in place and never removed
+     * (idempotent re-application); the whole store resets when a new workbook
+     * loads. Main mode never reads it (the main renderer draws from the mutated
+     * model directly).
+     */
+    private sizeOverrideStore;
     private canvasArea;
     private scrollHost;
     private spacer;
@@ -1608,6 +2455,26 @@ export declare class XlsxViewer {
      *  holds one context type for its lifetime, so this is obtained once and the
      *  main-mode 2d render path is never used on the same canvas. */
     private _bitmapCtx;
+    /** 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 workbook finishes loading it re-checks the
+     * live value and BAILS (destroying its own just-loaded workbook) 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 workbook (never installed, or installed then overwritten) then leaks
+     * its worker + pinned WASM allocation. The latch composes with SC20: the check
+     * runs AFTER the new workbook loads but BEFORE the field assignment and
+     * `previous?.destroy()`, so a superseded load never touches `this.wb` nor frees
+     * the current (newer) workbook. {@link destroy} also bumps it so a load in
+     * flight at teardown is treated as superseded and its workbook cleaned up.
+     */
+    private _loadGen;
     private resizeObserver;
     /**
      * Pending `requestAnimationFrame` handle for a coalesced re-render, or `null`
@@ -1646,13 +2513,27 @@ export declare class XlsxViewer {
      * strand the view at the sheet's far end once the host gains its real size.
      */
     private effectiveH;
+    /** Gesture-only pointer anchor for the NEXT `setScale`, in canvasArea-viewport
+     *  px (`{ x, y }` from the wheel event, relative to the grid'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, past the fixed
+     *  header + frozen-pane lead-in; consumed and cleared by `setScale`. `null` for
+     *  every non-gesture source (the public `setScale`, the +/- steppers, the zoom
+     *  slider, `fitWidth`/`fitPage`), which keep the historical START-anchored
+     *  (top-left) preservation so their behaviour is unchanged. */
+    private _pendingZoomAnchor;
     private anchorCell;
     private activeCell;
     private selectionMode;
     private isSelecting;
     private selectionOverlay;
+    /** IX2 — find-highlight overlay (matched-cell boxes). */
+    private findOverlay;
+    /** IX2 — find state (matches + active cursor). */
+    private _find;
     private keydownHandler;
     private pendingTap;
+    private pendingClick;
     private resizeDrag;
     /** DOM overlay element that shows the hovered cell's comment. Lives in
      *  canvasArea above the scrollHost; `pointer-events:none` so it never blocks
@@ -1660,6 +2541,11 @@ export declare class XlsxViewer {
     private commentPopup;
     /** `"row:col"` → comment for the current sheet, rebuilt on every showSheet. */
     private commentMap;
+    /** IX1 — `"row:col"` → hyperlink for the current sheet, rebuilt on every
+     *  showSheet. Keys mirror the renderer's `hyperlinkMap` (1-based row/col, the
+     *  first cell of a hyperlink `ref` range per the parser), so a `getCellAt`
+     *  {row,col} looks up directly. */
+    private hyperlinkMap;
     /** `"row:col"` of the cell whose popup is currently shown (or pending), so a
      *  pointermove within the same cell doesn't restart the show timer. */
     private commentPopupKey;
@@ -1681,17 +2567,80 @@ export declare class XlsxViewer {
      *  click; installed only while the panel is open. */
     private validationOutsideHandler;
     constructor(container: HTMLElement, opts?: XlsxViewerOptions);
+    /** Every non-empty cell of a sheet with its rendered display text (IX2 find
+     *  source). Reads the parsed worksheet model directly — no render — so search
+     *  covers the whole sheet, not just the on-screen viewport. */
+    private _collectSheetCells;
     /**
      * Load an XLSX from URL or ArrayBuffer and render the first sheet.
      *
-     * 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 `XlsxWorkbook.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 sheet 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>;
     /** The loaded workbook, or throws if {@link load} has not completed. */
     private get workbook();
     showSheet(index: number): Promise<void>;
+    /** Recompute the per-axis outline layout for `ws` and cache the band lists.
+     *  Both axes are `null` (gutters collapse to 0) when the sheet has no
+     *  outlining, so an outline-free sheet is untouched. */
+    private buildOutline;
+    /** Size and place the three gutter canvases (corner / col / row) from the
+     *  current outline, and inset {@link canvasArea} by the gutter extents. When
+     *  neither axis is grouped both extents are 0 and canvasArea covers the whole
+     *  region — pixel-identical to a viewer built before XL4. */
+    private layoutGutters;
+    /** Paint all visible gutter strips for the current scroll offset. Called at the
+     *  end of every grid render so the brackets track scroll / zoom exactly. */
+    private renderGutters;
+    /** Draw one axis's group brackets and +/- toggles into its gutter canvas,
+     *  aligned to the on-screen band positions via {@link getCellRect}. */
+    private paintAxisGutter;
+    /** Draw a small square +/- toggle centered at (cx, cy) in gutter-canvas CSS px. */
+    private drawToggleBox;
+    /** Draw one numbered level button centered at (cx, cy) in gutter-canvas CSS
+     *  px. Shared by the row bank (in the row gutter's top strip) and the column
+     *  bank (in the column gutter's left strip). */
+    private drawLevelButton;
+    /** Paint the corner (intersection of the two gutters) as plain background.
+     *  The numbered level banks live in each axis gutter's own header strip
+     *  (see paintAxisGutter), so the corner carries no interactive content. */
+    private paintCornerGutter;
+    /** Handle a click in a row/col gutter: hit-test the +/- toggles and toggle the
+     *  matching group's collapse state. */
+    private onGutterPointerDown;
+    /** Flip a single group's collapse state in the in-memory model, then rebuild
+     *  the outline + repaint. View-only: the file is never written. */
+    private applyGroupToggle;
+    /** Collapse/expand the whole sheet to `level` on one axis. */
+    private applyLevelButton;
+    /** Set a row/column hidden by mapping to the size-0 encoding the axis/renderer
+     *  already understand, stashing the original size so expand can restore it. */
+    private setBandHidden;
+    /** Record band `index`'s CURRENT model size (or `null` = no entry) in the
+     *  per-sheet override store. Called after every view-only size mutation —
+     *  outline hide/show above and drag-to-resize (#567) — so worker renders
+     *  converge to the main model. */
+    private recordSizeOverride;
+    /** The current sheet's override store serialized for the wire, or undefined
+     *  when nothing has been mutated (keeps the request payload unchanged). */
+    private wireSizeOverrides;
+    /** Update the `collapsed` flag on a band's model entry so the outline rebuild
+     *  reflects the new state. */
+    private setBandCollapsed;
+    /** Shared tail of a gutter interaction: invalidate the axis cache, rebuild the
+     *  outline (collapsed flags changed), refresh dependent geometry, re-render. */
+    private afterOutlineMutation;
+    /** Rebuild only the layout + band lists (not the stashes) after a collapse
+     *  state change, so the +/- glyphs and bracket set stay in sync. */
+    private buildOutlineLayoutOnly;
     /** True when the current sheet's grid is laid out right-to-left. */
     private get isRtl();
     /** Maximum horizontal scroll offset the native scroll host allows (≥ 0). */
@@ -1816,6 +2765,46 @@ export declare class XlsxViewer {
      *  whole range) to mirror Excel, which attaches the button to the active
      *  cell of the selection. */
     private maybeDrawValidationDropdown;
+    /**
+     * Redraw the find-highlight overlay: one translucent box per matched cell on
+     * the current sheet, the active match in a stronger colour. Uses the SAME
+     * `getCellRect` + `screenX` + header/frozen clamp the selection overlay uses,
+     * so a box lands exactly on the drawn cell at any scroll offset / zoom / RTL.
+     * Rebuilt on every render and scroll (cheap DOM geometry, no canvas paint).
+     */
+    private updateFindOverlay;
+    /**
+     * IX2 — find every occurrence of `query` across every sheet and highlight the
+     * matched cells. Returns every match in document order (sheet ascending, then
+     * row-major within a sheet), each tagged with its
+     * `{ sheet, sheetName, ref, row, col }`. A cell is the search unit: search
+     * runs over each cell's *rendered* display text (number formats, dates, rich
+     * text flattened), so a query matches what the grid shows. Case-insensitive by
+     * default; pass `{ caseSensitive: true }` for an exact match. An empty query
+     * clears the find.
+     */
+    findText(query: string, opts?: FindMatchesOptions): Promise<FindMatch<XlsxMatchLocation>[]>;
+    /**
+     * IX2 — move to the next match (wrap-around), switching sheets and scrolling
+     * the matched cell into view as needed, and highlight it as the active match.
+     * Returns the now-active match, or `null` when there are none. Call
+     * {@link findText} first.
+     */
+    findNext(): Promise<FindMatch<XlsxMatchLocation> | null>;
+    /** IX2 — move to the previous match (wrap-around). */
+    findPrev(): Promise<FindMatch<XlsxMatchLocation> | null>;
+    /** IX2 — clear all highlights and reset the find state. */
+    clearFind(): void;
+    private _activateMatch;
+    /**
+     * Scroll the grid so cell (row, col) is comfortably in view. Computes the
+     * cell's absolute logical offset from the axis metrics (the same the renderer
+     * uses) and nudges `scrollHost.scrollTop` / start-anchored horizontal scroll
+     * only when the cell is outside the scrollable viewport — an in-view cell is
+     * left where it is (Excel's find behaviour). Frozen cells are always visible,
+     * so they need no scroll.
+     */
+    private _scrollCellIntoView;
     /** Toggle the dropdown panel for the active cell's list validation. Called
      *  from pointerdown when the arrow rect is hit. Re-clicking the same arrow
      *  closes it. */
@@ -1843,6 +2832,37 @@ export declare class XlsxViewer {
      *  collision (Excel allows at most one note per cell, so this is moot in
      *  practice). */
     private buildCommentMap;
+    /** IX1 — index the current sheet's hyperlinks by `"row:col"` (1-based, first
+     *  cell of the `ref` range) so a clicked/hovered cell resolves in O(1). Keys
+     *  match the renderer's `hyperlinkMap` exactly (`${hl.row}:${hl.col}`). */
+    private buildHyperlinkMap;
+    /** IX1 — the hyperlink at a cell, or null. `getCellAt` returns 1-based
+     *  {row,col}, matching the parser/renderer keying.
+     *
+     *  Returns null unconditionally when `enableHyperlinks` is `false`: this is the
+     *  single gate that disables hyperlink interactivity. Both consumers — the
+     *  pointermove pointer-cursor affordance and the click dispatch
+     *  ({@link dispatchHyperlink}) — funnel through this hit-test, so a null result
+     *  means no cursor change, no default navigation, and no `onHyperlinkClick`. */
+    private hyperlinkAtCell;
+    /**
+     * IX1 — dispatch a click on a hyperlinked cell. Builds a
+     * {@link HyperlinkTarget} from the parsed hyperlink (external `url` wins over
+     * internal `location`, matching Excel: a `<hyperlink>` carrying both navigates
+     * to the external target) and routes it to the caller's `onHyperlinkClick`
+     * (which fully owns behaviour) or the built-in default. Returns true when a
+     * hyperlink was found and dispatched.
+     */
+    private dispatchHyperlink;
+    /**
+     * IX1 default handler for an internal `location` target (§18.3.1.47): a defined
+     * name or a cell ref like `Sheet1!A1`. Best-effort: if the part before `!`
+     * names a sheet in the workbook, switch to it. There is no scroll-to-cell
+     * primitive on this viewer, so the cell part is not yet honoured (switching the
+     * sheet already lands the user on the right surface). A bare defined name that
+     * does not resolve to a sheet is a documented no-op.
+     */
+    private navigateInternalHyperlink;
     /** Show the popup for the comment on `cell` after the hover dwell, anchored to
      *  the cell's current on-screen rect. No-op when the cell carries no comment.
      *  Re-hovering the same cell does not restart the timer. */
@@ -1877,10 +2897,46 @@ export declare class XlsxViewer {
     private zoomPosToScale;
     /** Inverse of {@link zoomPosToScale}: scale factor → slider position [0,100]. */
     private zoomScaleToPos;
-    /** Set the cell/header scale and re-lay-out the current sheet. Clamped to the
-     *  zoom bounds; keeps the slider thumb, percentage label and the row-header-
-     *  aligned tab-nav width in sync. */
+    /**
+     * IX9 {@link ZoomableViewer} — set the cell/header scale (`1` = 100%; the
+     * viewer's `cellScale`) and re-lay-out the current sheet. Clamped to the zoom
+     * bounds and snapped to whole percent; keeps the slider thumb, percentage label
+     * and the row-header-aligned tab-nav width in sync, and fires `onScaleChange`
+     * when the resolved scale actually changes.
+     */
     setScale(scale: number): void;
+    /** IX9 {@link ZoomableViewer} — the current zoom factor (`1` = 100%). This is
+     *  the viewer's `cellScale`; `1` before anything is set. */
+    getScale(): number;
+    /** IX9 {@link ZoomableViewer} — step up to the next rung of the shared zoom
+     *  ladder (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 the used data range's WIDTH to the canvas
+     * area. The "content" is the natural (100%) width of the row header plus the
+     * used columns; the container is `canvasArea.clientWidth`. A no-op (defers) when
+     * nothing is loaded or the container is unlaid-out. Routes through
+     * {@link setScale}, so the result is clamped/snapped and fires `onScaleChange`.
+     */
+    fitWidth(): void;
+    /**
+     * IX9 {@link ZoomableViewer} — fit the used data range's WIDTH AND HEIGHT inside
+     * the canvas area (header + used columns/rows), so the whole used range is
+     * visible without scrolling. Takes the tighter of the width- and height-fit
+     * factors. Defers when unloaded / unlaid-out; routes through {@link setScale}.
+     */
+    fitPage(): void;
+    /** Shared fit implementation for {@link fitWidth} / {@link fitPage}: derive the
+     *  natural (cs=1) content extent of the used data range, ask core's pure
+     *  {@link fitScale} for the factor, and apply it via {@link setScale}. */
+    private _fit;
+    /** Natural (unscaled, cs=1) CSS-px extent of a worksheet's used data range:
+     *  the row/column header plus every used column width / row height. Mirrors
+     *  {@link updateSpacerSize} at cs=1 (same used-range detection) so the fit
+     *  targets exactly the region the spacer/scroll extent covers. */
+    private _naturalContentExtent;
     private updateSpacerSize;
     /**
      * Coalesce a re-render into the next animation frame. Called from the
@@ -1896,6 +2952,11 @@ export declare class XlsxViewer {
      */
     private scheduleRender;
     private renderCurrentSheet;
+    /** 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`. */
+    private _reportRenderError;
+    private _renderCurrentSheet;
     private computeHeaderHighlight;
     get sheetNames(): string[];
     /** The underlying <canvas> element the grid is drawn on. */
@@ -1932,9 +2993,20 @@ export declare interface XlsxViewerOptions extends LoadOptions_2 {
      *  own zoom control). */
     showZoomSlider?: boolean;
     /** Lower/upper bounds for the zoom slider as scale factors. Default 0.1–4
-     *  (10%–400%, matching Excel's zoom range). */
+     *  (10%–400%, matching Excel's zoom range). Also the clamp range for the IX9
+     *  {@link ZoomableViewer} zoom contract ({@link XlsxViewer.setScale} etc.). */
     zoomMin?: number;
     zoomMax?: number;
+    /**
+     * IX9 — fires whenever the zoom factor actually changes (`1` = 100%), whatever
+     * the source: {@link XlsxViewer.setScale}, {@link XlsxViewer.zoomIn} /
+     * {@link XlsxViewer.zoomOut}, {@link XlsxViewer.fitWidth} /
+     * {@link XlsxViewer.fitPage}, the built-in zoom slider, the +/- buttons, or a
+     * Ctrl/⌘+wheel gesture. Named `onScaleChange` to match the docx/pptx viewers so
+     * all five share one notification shape. Not fired when a call resolves to the
+     * same (clamped/snapped) scale.
+     */
+    onScaleChange?: (scale: number) => void;
     onReady?: (sheetNames: string[]) => void;
     /**
      * Called when the active sheet changes, with the new sheet's zero-based
@@ -1948,6 +3020,23 @@ export declare interface XlsxViewerOptions extends LoadOptions_2 {
     onError?: (err: Error) => void;
     /** Called when the selected cell range changes. null means no selection. */
     onSelectionChange?: (selection: CellRange | null) => void;
+    /**
+     * IX1 (design decision — NOT user-confirmed, integrator may veto). Fires when a
+     * cell carrying a hyperlink (ECMA-376 §18.3.1.47) is clicked. Default when
+     * omitted: external → {@link openExternalHyperlink} (new tab, sanitised,
+     * noopener); internal (`location`) → navigate to the referenced sheet/cell
+     * when resolvable. When supplied, this callback fully owns the behaviour and
+     * receives the raw {@link HyperlinkTarget} verbatim (URL sanitisation is the
+     * default handler's job, so a blocked scheme still reaches a custom callback).
+     */
+    onHyperlinkClick?: (target: HyperlinkTarget) => void;
+    /** IX1 — master switch for hyperlink interactivity. Default `true`. When
+     *  `false`, the cell hit-test reports no hyperlink under any cell, so hyperlink
+     *  interactivity is disabled entirely: no pointer cursor over a link, no default
+     *  navigation (external new-tab / internal sheet jump), and `onHyperlinkClick`
+     *  is never called. Hyperlinked cells still render exactly as authored but are
+     *  inert. */
+    enableHyperlinks?: boolean;
     /**
      * Color of the cell-selection highlight. A single CSS color drives both the
      * selection rectangle's border (drawn in this color) and its fill (the same
@@ -2006,6 +3095,12 @@ export declare class XlsxWorkbook {
      *  `renderViewport` call reuses it — equations in shapes render when present,
      *  and are skipped (engine tree-shaken) when omitted. */
     private math;
+    /** Google-Fonts `FontFace` objects this workbook 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 workbook survives until both go). */
+    private googleFontFaces;
     private _mode;
     private constructor();
     /** Parse an XLSX from a URL or ArrayBuffer. */
@@ -2045,6 +3140,22 @@ export declare class XlsxWorkbook {
      * route-through-worker decision).
      */
     getImage(imagePath: string, mimeType: string): Promise<Blob>;
+    /**
+     * Project the workbook to GitHub-flavoured markdown: each sheet becomes a
+     * `## SheetName` section followed by a pipe table of its populated bounding
+     * box (fully-empty middle rows trimmed, ULP noise masked). Styling, charts,
+     * and drawings 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 wb = await XlsxWorkbook.load(buffer);
+     * const md = await wb.toMarkdown();
+     */
+    toMarkdown(): Promise<string>;
     /**
      * Resolve a `list`-type data-validation `formula1` (ECMA-376 §18.3.1.32) into
      * the set of allowed values to display, evaluated relative to `sheetIndex`
@@ -2061,6 +3172,24 @@ export declare class XlsxWorkbook {
      * Read-only: this only reads cell values for display; it never writes.
      */
     resolveValidationList(sheetIndex: number, formula1: string | undefined): Promise<ResolvedList>;
+    /**
+     * IX2 — the display string a cell shows on the grid, i.e. exactly what
+     * {@link renderViewport} would draw (number formats, dates, booleans, rich
+     * text flattened). Used by {@link XlsxViewer.findText} to search the *rendered*
+     * text rather than the raw stored value, so a search matches what the user
+     * sees. Threads the workbook styles + the sheet's date system through the
+     * shared {@link formatCellValue} (the same call the renderer and
+     * validation-list expansion use). Returns `''` before the workbook is loaded.
+     */
+    cellText(ws: Worksheet, cell: Cell): string;
+    /**
+     * Render a sheet viewport into `target`. Note: `opts.fetchImage` is ignored
+     * here — image bytes always come from this workbook's own archive through its
+     * stable per-instance loader, whose closure identity keys the shared decoded
+     * caches, the render-pass lease, and {@link destroy}'s cache drops. Callers
+     * needing a custom byte source should use the standalone
+     * `renderWorksheetViewport` orchestrator directly.
+     */
     renderViewport(target: HTMLCanvasElement | OffscreenCanvas, sheetIndex: number, viewport: ViewportRange, opts?: RenderViewportOptions): Promise<void>;
     /**
      * Render a sheet viewport and return it as an ImageBitmap (both modes; in
@@ -2080,4 +3209,90 @@ export declare class XlsxWorkbook {
     destroy(): void;
 }
 
+/**
+ * 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 { }