@shbernal/ts-pptx 4.0.1 → 4.2.0

package/dist/{presentation-types-8jLQHI4M.d.ts → presentation-types-BgnZR-0a.d.ts}

@@ -1,10 +1,9 @@
-import { Sn as ThemeColorSlot, sn as ColorMapToken, t as CustomPropertyValue } from "./pres-C6qgOFAa.js";
-import { t as EmbeddedFont } from "./embedded-fonts-DarT9aoa.js";
-import { a as Part, i as Relationships, n as OpcPackage, o as Element, t as OpcInput } from "./package-J49Ck6S2.js";
-//#region src/read/oxml/theme.d.ts
+import { t as EmbeddedFont } from "./embedded-fonts-U7HIIhPO.js";
+import { a as Part, i as Relationships, n as OpcPackage, o as Element, t as OpcInput } from "./package-CANBWuSm.js";
+import { hn as ColorMapToken, jn as ThemeColorSlot, t as CustomPropertyValue } from "./pres-BkEkUAEM.js";
 /**
  * The colour-resolution context: the two maps that turn a DrawingML colour
- * reference into a literal hex — the effective colour map (token → `clrScheme`
+ * reference into a literal hex: the effective colour map (token → `clrScheme`
  * slot, honouring any slide `clrMapOvr`) and the resolved colour scheme (slot →
  * 6-hex RGB). Shared by the read-model colour getters and `ThemeContext`.
  */
@@ -17,7 +16,7 @@ interface ColorContext {
  * {@link ColorContext} maps, the live `a:fmtScheme` for style-matrix resolution, and the roots
  * of the inheritance chain a placeholder reads through.
  *
- * Every root here is **read-only** — nothing in this module or in `placeholder-inherit.ts`
+ * Every root here is **read-only**: nothing in this module or in `placeholder-inherit.ts`
  * mutates one. The import-time flatten pass extends this with the one field it needs to write
  * from (see `FlattenContext` in `read/api/ops/flatten.ts`).
  */
@@ -49,18 +48,18 @@ interface ThemeContext extends ColorContext {
    * context it is absent, so the slide placeholder chain (layout/master
    * `a:lstStyle` → `p:txStyles`) is unaffected. It is the notes analogue of the
    * master `p:txStyles` category style, keyed by level rather than placeholder
-   * type. Read-only — never mutated.
+   * type. Read-only, never mutated.
    */
   notesStyle?: Element | null;
   /**
    * The presentation's `p:defaultTextStyle` (a `CT_TextListStyle` from
-   * `presentation.xml`), keyed by level — PowerPoint's lowest-priority text
+   * `presentation.xml`), keyed by level: PowerPoint's lowest-priority text
    * fallback, applying to any run (placeholder or not) that resolves nothing
    * above it. Only ever set on a *slide* context (see `resolveSlideColorContext`);
    * absent on notes/master/layout contexts, so their chains are unaffected. A table
    * cell's text is read against a copy that holds the slide master's `p:otherStyle`
    * here instead, the tier PowerPoint resolves cell text through (`TableCell.textFrame`).
-   * Read-only — never mutated.
+   * Read-only, never mutated.
    */
   defaultTextStyle?: Element | null;
   /**
@@ -71,7 +70,7 @@ interface ThemeContext extends ColorContext {
    * The lookup is a full subtree scan, and reading one run's five inherited properties used
    * to perform ten of them: each property walks the tier chain, and each tier walk scans a
    * layout and a master. The answer depends only on the roots and the `(type, idx)` asked
-   * for, and the roots on a context never change — so it is computed once per context.
+   * for, and the roots on a context never change, so it is computed once per context.
    *
    * The memo lives here rather than in a module-level cache keyed by the root element
    * because that is what scopes it correctly: a context is built per `Slide`/`TemplatePart`
@@ -81,8 +80,6 @@ interface ThemeContext extends ColorContext {
    */
   placeholderMemo?: Map<string, Element | null>;
 }
-//#endregion
-//#region src/read/oxml/color-transform.d.ts
 /** A colour-transform modifier in its read-model form: tag local-name + raw `@val`. */
 interface ColorTransform {
   name: string;
@@ -96,15 +93,13 @@ interface EffectiveColor {
 /**
  * Apply an ordered list of DrawingML colour transforms to a base sRGB hex,
  * returning the effective sRGB hex (and opacity, when an `alpha*` modifier set
- * it). Pure: no DOM, no theme lookup — the caller has already resolved the base
+ * it). Pure: no DOM, no theme lookup; the caller has already resolved the base
  * colour and extracted each modifier's `{ name, value }`.
  *
  * An unparseable base hex is returned unchanged (with no transforms applied); an
  * unparseable/`null` modifier value is skipped.
  */
 declare function applyColorTransforms(baseHex: string, transforms: ColorTransform[]): EffectiveColor;
-//#endregion
-//#region src/read/api/theme-context.d.ts
 /** Identifies a placeholder by its `p:ph` `type`/`idx` for inheritance lookups. */
 interface PlaceholderRef {
   type: string | null;
@@ -125,7 +120,7 @@ interface ResolvedFrame {
  *
  * `hex` is the **base** token colour and `transforms` reports the colour-transform
  * children (`lumMod`/`lumOff`/`shade`/`tint`/`alpha`/…) in document order as
- * `{ name, value }` pairs — both kept for traceability and for the
+ * `{ name, value }` pairs, both kept for traceability and for the
  * `theme: 'preserve'` flatten path that re-emits the transforms verbatim.
  *
  * `effectiveHex` is the colour a renderer actually paints: `hex` with its
@@ -141,8 +136,8 @@ interface ResolvedColor {
 }
 /**
  * Resolve a DrawingML colour *element* (every `a:EG_ColorChoice` member except
- * `a:scrgbClr` — see `read/oxml/theme.ts`) against `ctx` into a full
- * {@link ResolvedColor} — base hex, raw transform list,
+ * `a:scrgbClr`; see `read/oxml/theme.ts`) against `ctx` into a full
+ * {@link ResolvedColor}: base hex, raw transform list,
  * and the `effectiveHex`/`alpha` after applying those transforms. `null` when the
  * element cannot be made literal (unmapped token, or a colour model we do not
  * resolve). Shared by the solid-fill and gradient-stop colour reads.
@@ -186,39 +181,6 @@ interface StyleFontRef {
   /** The face named by `a:fontRef/@idx` (`major`→`+mj-lt`, `minor`→`+mn-lt`) resolved through the theme `fontScheme`, or `null` for `idx="none"` / an unresolvable token. */
   face: string | null;
 }
-//#endregion
-//#region src/read/api/gradient.d.ts
-/** One stop of a gradient fill (`a:gsLst/a:gs`), as read from a shape. */
-interface GradientStop {
-  /** Stop offset along the gradient, 0–1 (from `@pos`, thousandths of a percent), or `null` if unset. */
-  position: number | null;
-  /**
-   * The stop's colour, as written and resolved against the slide theme. Its `resolved.effectiveHex` is
-   * the rendered colour and `resolved.alpha` the stop's opacity, when an `alpha*` transform set one.
-   */
-  colorRef: ColorRef;
-}
-/**
- * A gradient fill (`a:gradFill`), as read from a container — the stops plus the
- * geometry that a bare stop list omits. `linear` gradients carry an
- * {@link GradientFill.angleDeg} (the `a:lin/@ang` direction); `radial`/`path`
- * gradients carry a {@link GradientFill.path} shape (`a:path/@path`, e.g.
- * `circle`). The angle is in **OOXML degrees** (clockwise from 3 o'clock), the
- * same convention the write-side `GradientFillProps.angle` expects, so it
- * round-trips directly.
- */
-interface GradientFill {
-  /** `linear` (`a:lin`) or `path` (`a:path`, i.e. radial/rectangular). `null` when neither child is present. */
-  kind: 'linear' | 'path' | null;
-  /** Linear direction in OOXML degrees (clockwise from 3 o'clock), or `null` for a path gradient / when unset. */
-  angleDeg: number | null;
-  /** Path-gradient shape (`a:path/@path`: `circle`/`rect`/`shape`), or `null` for a linear gradient. */
-  path: string | null;
-  /** The gradient stops in document order. */
-  stops: GradientStop[];
-}
-//#endregion
-//#region src/read/api/picture-fill.d.ts
 /** A rectangle expressed as per-edge fractions (`a:srcRect`/`a:fillRect`), `0.1` = 10 %. */
 interface FillRect {
   left: number;
@@ -248,7 +210,7 @@ interface PictureFillTile {
 /**
  * A picture (image) fill (`a:blipFill`) read from a fill-bearing container. The
  * image itself is {@link relId} / {@link partName}; the rest is the geometry a
- * faithful replica needs — {@link mode} (`stretch` or `tile`), the source crop
+ * faithful replica needs: {@link mode} (`stretch` or `tile`), the source crop
  * {@link srcRect}, the destination inset {@link fillRect}, and {@link tile}.
  *
  * Rect fields follow the read API's fraction convention (see
@@ -276,10 +238,50 @@ interface PictureFill {
   /** Whether the fill rotates with its shape (`@rotWithShape`), or `null` when unset. */
   rotWithShape: boolean | null;
 }
-//#endregion
-//#region src/read/api/pattern-fill.d.ts
+/** One stop of a gradient fill (`a:gsLst/a:gs`), as read from a shape. */
+interface GradientStop {
+  /** Stop offset along the gradient, 0–1 (from `@pos`, thousandths of a percent), or `null` if unset. */
+  position: number | null;
+  /**
+   * The stop's colour, as written and resolved against the slide theme. Its `resolved.effectiveHex` is
+   * the rendered colour and `resolved.alpha` the stop's opacity, when an `alpha*` transform set one.
+   */
+  colorRef: ColorRef;
+}
+/**
+ * A gradient fill (`a:gradFill`), as read from a container: the stops plus the
+ * geometry that a bare stop list omits. `linear` gradients carry an
+ * {@link GradientFill.angleDeg} (the `a:lin/@ang` direction); `radial`/`path`
+ * gradients carry a {@link GradientFill.path} shape (`a:path/@path`, e.g.
+ * `circle`). The angle is in **OOXML degrees** (clockwise from 3 o'clock), the
+ * same convention the write-side `GradientFillProps.angle` expects, so it
+ * round-trips directly.
+ */
+interface GradientFill {
+  /** `linear` (`a:lin`) or `path` (`a:path`, i.e. radial/rectangular). `null` when neither child is present. */
+  kind: 'linear' | 'path' | null;
+  /** Linear direction in OOXML degrees (clockwise from 3 o'clock), or `null` for a path gradient / when unset. */
+  angleDeg: number | null;
+  /** Path-gradient shape (`a:path/@path`: `circle`/`rect`/`shape`), or `null` for a linear gradient. */
+  path: string | null;
+  /** The gradient stops in document order. */
+  stops: GradientStop[];
+  /**
+   * Whether the fill rotates with the shape (`a:gradFill/@rotWithShape`), or `null` when the
+   * attribute is absent.
+   */
+  rotateWithShape: boolean | null;
+  /** Whether a linear gradient's angle scales with the fill region (`a:lin/@scaled`), or `null` when unset. */
+  scaled: boolean | null;
+  /**
+   * A path gradient's focus rectangle (`a:path/a:fillToRect`) as per-edge fractions inset from the
+   * fill box, or `null` when absent. Equal insets centre the focus; the write side's radial
+   * `center: { x, y }` writes `left = x`, `top = y`, `right = 1 - x`, `bottom = 1 - y`.
+   */
+  focusRect: FillRect | null;
+}
 /**
- * A pattern fill (`a:pattFill`) — a two-colour preset hatch. The write-side
+ * A pattern fill (`a:pattFill`): a two-colour preset hatch. The write-side
  * `fill: { type: 'pattern', pattern: { preset, fgColor, bgColor } }` emits the same element,
  * so the {@link preset} name and both colours round-trip.
  */
@@ -291,8 +293,6 @@ interface PatternFill {
   /** Background colour (`a:bgClr`); every field is `null` when the pattern states none. */
   background: ColorRef;
 }
-//#endregion
-//#region src/read/api/slide-background.d.ts
 /** Where a slide's effective background comes from in the slide → layout → master chain. */
 type BackgroundSource = 'slide' | 'layout' | 'master';
 /**
@@ -301,8 +301,8 @@ type BackgroundSource = 'slide' | 'layout' | 'master';
  * top-level variants add {@link BackgroundSource}, and it is what a `themeRef`'s
  * `SlideBackground.resolvedFill` carries.
  *
- * The `image` variant keeps `relId`/`partName` at the top level — the fields
- * callers already read — and adds the full {@link PictureFill} (stretch/tile
+ * The `image` variant keeps `relId`/`partName` at the top level (the fields
+ * callers already read) and adds the full {@link PictureFill} (stretch/tile
  * geometry, crop, alpha) under `picture`.
  */
 type BackgroundFill = {
@@ -326,7 +326,7 @@ type BackgroundFill = {
  * `type`. Every variant carries {@link BackgroundSource}. `solid`/`gradient`/`pattern`/`image`
  * are what the writer authors and round-trip faithfully; `themeRef` is read-only
  * (imported decks) and `none` is an explicit `a:noFill`. A `themeRef`
- * keeps its raw `idx` for fidelity and also exposes `resolvedFill` — the concrete
+ * keeps its raw `idx` for fidelity and also exposes `resolvedFill`, the concrete
  * fill that `idx` resolves to through the slide theme's `fmtScheme` (`null` when the
  * theme/entry cannot be resolved).
  */
@@ -357,8 +357,6 @@ type SlideBackground = {
   type: 'none';
   source: BackgroundSource;
 };
-//#endregion
-//#region src/read/api/shapes/oxml.d.ts
 /**
  * Where a shape kind's paint is written: its properties element (`p:spPr` / `p:grpSpPr`), created
  * in document order on demand, and for each paint the schema successors that paint's element is
@@ -370,8 +368,6 @@ interface PaintSurface {
   fill: readonly string[] | null;
   line: readonly string[] | null;
 }
-//#endregion
-//#region src/read/api/shapes/types.d.ts
 /** Discriminator for the concrete `Shape` subclass. */
 type ShapeType = 'autoShape' | 'picture' | 'connector' | 'graphicFrame' | 'group';
 /** One end of a connector/line (`a:ln/a:headEnd` or `a:tailEnd`), as read from a shape. */
@@ -392,7 +388,7 @@ interface LineEnds {
  * One bound end of a connector (`p:nvCxnSpPr/p:cNvCxnSpPr/a:stCxn` or `a:endCxn`),
  * as read. A connector authored with `startShape`/`endShape` attaches each end to
  * a shape by that shape's `p:cNvPr/@id` plus a connection-site index; an unbound
- * end (the writer emits a bare `p:cNvCxnSpPr`) reports no site at all — see
+ * end (the writer emits a bare `p:cNvCxnSpPr`) reports no site at all; see
  * {@link Connector.startConnection}. This is the read counterpart of the write
  * API's `startShape`/`startShapeIdx` split, which binds by `objectName` and
  * resolves the name → id at serialize time.
@@ -404,7 +400,7 @@ interface ConnectionSite {
   siteIndex: number;
   /**
    * The bound shape resolved to a read-model shape via {@link Slide.shapeByIdDeep},
-   * which descends into groups — so a connector bound to a shape nested in a group
+   * which descends into groups, so a connector bound to a shape nested in a group
    * resolves the same as one bound to a top-level shape. `null` only when no shape
    * anywhere on the slide carries that id (a genuinely dangling binding), which is
    * faithful degradation and does not throw.
@@ -429,11 +425,16 @@ interface OuterShadow {
   offsetPt?: number;
   /** Offset direction in degrees, clockwise from 3 o'clock (`@dir` ÷ 60000), or `undefined` when unset. */
   angleDeg?: number;
+  /**
+   * Whether the shadow rotates with the shape (`@rotWithShape`), or `undefined` when unset. Only an
+   * outer shadow has the attribute.
+   */
+  rotateWithShape?: boolean;
 }
 /**
  * A shape's inner shadow (`spPr/a:effectLst/a:innerShdw`), resolved against the
- * slide theme. Identical fields to {@link OuterShadow} — CT_InnerShadowEffect
- * carries the same `blurRad`/`dist`/`dir` + colour — but a distinct type so a
+ * slide theme. Identical fields to {@link OuterShadow} (CT_InnerShadowEffect
+ * carries the same `blurRad`/`dist`/`dir` + colour), but a distinct type so a
  * consumer can tell an inset shadow from a drop shadow. Distances in points,
  * direction in degrees, matching the write-side `shadow: { type: 'inner' }`.
  */
@@ -451,7 +452,7 @@ interface InnerShadow {
   angleDeg?: number;
 }
 /**
- * A shape's glow effect (`spPr/a:effectLst/a:glow`) — a coloured halo — resolved
+ * A shape's glow effect (`spPr/a:effectLst/a:glow`), a coloured halo, resolved
  * against the slide theme. The write-side `glow` option is a text glow: it writes
  * `a:glow` into each run's `a:rPr/a:effectLst`, which this does not read.
  */
@@ -465,10 +466,10 @@ interface Glow {
   radiusPt?: number;
 }
 /**
- * A shape's reflection effect (`spPr/a:effectLst/a:reflection`) — a mirrored fade
+ * A shape's reflection effect (`spPr/a:effectLst/a:reflection`): a mirrored fade
  * beneath the shape. This library's writer authors none, so this is a **read-only**
  * surface: a consumer that finds one should carry the part verbatim rather than
- * regenerate it. Only the attributes a faithful replica needs are decoded —
+ * regenerate it. Only the attributes a faithful replica needs are decoded:
  * distances in points (÷ 12700), directions in degrees (÷ 60000), and the start/end
  * alpha and position pairs as 0–1 fractions (the `1000`ths-of-a-percent source
  * ÷ 100000). All fields are optional; an attribute absent from the source is omitted.
@@ -492,7 +493,7 @@ interface Reflection {
   fadeAngleDeg?: number;
 }
 /**
- * A shape's soft-edge effect (`spPr/a:effectLst/a:softEdge`) — a feathered border.
+ * A shape's soft-edge effect (`spPr/a:effectLst/a:softEdge`): a feathered border.
  * Like {@link Reflection}, the writer authors none, so carry it verbatim. `@rad`
  * (the feather radius) ÷ 12700 → points.
  */
@@ -510,38 +511,90 @@ interface SoftEdge {
  * must be scaled by the consumer against the shape's box. `arcTo` angles are in
  * **degrees** (the raw `60000`ths-of-a-degree values divided by 60000), matching
  * the write DSL's degree input.
+ *
+ * Any of them may instead be the name of a guide whose value it takes (`ST_AdjCoordinate` /
+ * `ST_AdjAngle`): one of the geometry's own {@link CustomGeometry.guides}, or a built-in such as
+ * `w`, `hc` or `cd4`. A name is returned as written, never resolved.
  */
 type GeometryCommand = {
   cmd: 'moveTo';
-  x: number;
-  y: number;
+  x: GeometryCoordinate;
+  y: GeometryCoordinate;
 } | {
   cmd: 'lnTo';
-  x: number;
-  y: number;
+  x: GeometryCoordinate;
+  y: GeometryCoordinate;
 } | {
   cmd: 'cubicBezTo';
-  x1: number;
-  y1: number;
-  x2: number;
-  y2: number;
-  x: number;
-  y: number;
+  x1: GeometryCoordinate;
+  y1: GeometryCoordinate;
+  x2: GeometryCoordinate;
+  y2: GeometryCoordinate;
+  x: GeometryCoordinate;
+  y: GeometryCoordinate;
 } | {
   cmd: 'quadBezTo';
-  x1: number;
-  y1: number;
-  x: number;
-  y: number;
+  x1: GeometryCoordinate;
+  y1: GeometryCoordinate;
+  x: GeometryCoordinate;
+  y: GeometryCoordinate;
 } | {
   cmd: 'arcTo';
-  wR: number;
-  hR: number;
-  stAng: number;
-  swAng: number;
+  wR: GeometryCoordinate;
+  hR: GeometryCoordinate;
+  stAng: GeometryCoordinate;
+  swAng: GeometryCoordinate;
 } | {
   cmd: 'close';
 };
+/**
+ * A custom-geometry coordinate (`ST_AdjCoordinate`): a number in the shape's own EMU space, or the
+ * name of a guide whose value it takes.
+ */
+type GeometryCoordinate = number | string;
+/** One guide formula of a custom geometry (`a:gd`). */
+interface CustomGeometryGuide {
+  /** The guide's name (`@name`), which positions and other formulas refer to. */
+  name: string;
+  /** The formula (`@fmla`) as written: an operation and its arguments, such as PowerPoint's multiply-divide of a site against the shape width. */
+  formula: string;
+}
+/**
+ * One adjust handle of a custom geometry: an XY handle (`a:ahXY`) bound to guides along each axis,
+ * or a polar one (`a:ahPolar`) bound along its radius and angle. Every bound is `null` when unset.
+ */
+type CustomGeometryAdjustHandle = {
+  kind: 'xy';
+  /** The handle's position (`a:pos`). */
+  x: GeometryCoordinate | null;
+  y: GeometryCoordinate | null;
+  gdRefX: string | null;
+  minX: GeometryCoordinate | null;
+  maxX: GeometryCoordinate | null;
+  gdRefY: string | null;
+  minY: GeometryCoordinate | null;
+  maxY: GeometryCoordinate | null;
+} | {
+  kind: 'polar';
+  /** The handle's position (`a:pos`). */
+  x: GeometryCoordinate | null;
+  y: GeometryCoordinate | null;
+  gdRefR: string | null;
+  minR: GeometryCoordinate | null;
+  maxR: GeometryCoordinate | null;
+  gdRefAng: string | null;
+  /** The angle bounds in degrees (the 60000ths source ÷ 60000), or `null`. */
+  minAngDeg: number | null;
+  maxAngDeg: number | null;
+};
+/** One connection site of a custom geometry (`a:cxn`): where a connector can attach. */
+interface CustomGeometryConnectionSite {
+  /** The angle a connector arrives at, in degrees (`@ang` ÷ 60000), or `null` when it names a guide. */
+  angleDeg: number | null;
+  /** The site's position (`a:pos`). */
+  x: GeometryCoordinate | null;
+  y: GeometryCoordinate | null;
+}
 /** One `<a:path>` of a custom geometry, with its path-unit viewport and render attrs. */
 interface CustomGeometryPath {
   /** Path-unit width (`a:path/@w`); the `x` denominator for this path's coords. Default `0`. */
@@ -552,7 +605,7 @@ interface CustomGeometryPath {
   fill: string;
   /** Whether the path is stroked (`a:path/@stroke`). Default `true`. */
   stroke: boolean;
-  /** The path's segments in document order — order *is* the geometry. */
+  /** The path's segments in document order; order *is* the geometry. */
   commands: GeometryCommand[];
 }
 /**
@@ -565,6 +618,12 @@ interface CustomGeometryPath {
  */
 interface CustomGeometry {
   paths: CustomGeometryPath[];
+  /** The guide formulas (`a:gdLst/a:gd`), in document order; empty when there are none. */
+  guides: CustomGeometryGuide[];
+  /** The adjust handles (`a:ahLst`), in document order; empty when there are none. */
+  adjustHandles: CustomGeometryAdjustHandle[];
+  /** The connection sites (`a:cxnLst/a:cxn`), in document order; empty when there are none. */
+  connectionSites: CustomGeometryConnectionSite[];
 }
 /** A shape's resolved position and size in slide-absolute EMU. */
 interface AbsoluteFrame {
@@ -582,12 +641,12 @@ interface AbsoluteFrame {
 /**
  * Why {@link Shape.absoluteFrame} could not resolve a frame.
  *
- * - `no-own-transform` — the shape states no `a:xfrm` of its own, or an incomplete
+ * - `no-own-transform`: the shape states no `a:xfrm` of its own, or an incomplete
  *   one: typically a placeholder inheriting its box from the layout. Nothing is
  *   wrong with the deck; the read model reports what the shape itself states.
- * - `group-transform-missing` — an enclosing `p:grpSp` states no complete
+ * - `group-transform-missing`: an enclosing `p:grpSp` states no complete
  *   `a:off`/`a:ext` **and** `a:chOff`/`a:chExt` pair, so its child space is unknown.
- * - `group-transform-degenerate` — an enclosing group's `a:chExt` is zero on an
+ * - `group-transform-degenerate`: an enclosing group's `a:chExt` is zero on an
  *   axis, so the child-space ratio the mapping divides by is undefined.
  *
  * A missing group transform outranks a degenerate one wherever the two meet in
@@ -597,7 +656,7 @@ interface AbsoluteFrame {
 type AbsoluteFrameFailure = 'no-own-transform' | 'group-transform-missing' | 'group-transform-degenerate';
 /**
  * A group shape's own child coordinate space (`p:grpSpPr/a:xfrm/a:chOff` and
- * `a:chExt`) in EMU — the space its children's `a:off`/`a:ext` are authored in.
+ * `a:chExt`) in EMU: the space its children's `a:off`/`a:ext` are authored in.
  *
  * Named after the OOXML attributes rather than in the `left`/`top`/`width`/
  * `height` vocabulary the rest of the read model uses, because this is not a
@@ -639,8 +698,32 @@ type Recolor = {
   kind: 'alphaModFix';
   amount: number;
 };
-//#endregion
-//#region src/read/api/hyperlink.d.ts
+/**
+ * The audio or video a picture plays, as {@link Picture.media} reads it. PowerPoint authors
+ * embedded media as a `p:pic` whose blip is the poster frame and whose `p:nvPr` carries an
+ * `a:audioFile` or `a:videoFile`, bound to the media part twice: by the element's `r:link` and by
+ * the `p14:media` extension's `r:embed`.
+ */
+interface PictureMedia {
+  /** `audio` for `a:audioFile`, `video` for `a:videoFile`. */
+  kind: 'audio' | 'video';
+  /**
+   * Absolute partname of the media in the package: the `p14:media` `r:embed`, else the element's
+   * own `r:link` when it targets a part. `null` for linked or online media, whose target is
+   * outside the package ({@link link}).
+   */
+  partName: string | null;
+  /** The media part's content type, or `null` when there is no part. */
+  contentType: string | null;
+  /** The external target of linked or online media (an `r:link` with `TargetMode="External"`), or `null`. */
+  link: string | null;
+  /**
+   * How many times the media plays, from the media node the slide's `p:timing` aims at this picture
+   * (`p:cMediaNode/p:cTn/@repeatCount`, in thousandths): `'indefinite'` loops until stopped, and
+   * `null` states none, which plays once.
+   */
+  repeatCount: number | 'indefinite' | null;
+}
 /**
  * A click hyperlink (`a:hlinkClick`), on a run or on a shape. A URL link carries an external
  * {@link url}; a slide jump carries the internal {@link targetPartName} (the linked slide's part)
@@ -658,8 +741,6 @@ interface Hyperlink {
   /** The relationship id (`@r:id`) backing the link, or `null` when the link is action-only. */
   relId: string | null;
 }
-//#endregion
-//#region src/read/api/table-style-resolve.d.ts
 /**
  * The `a:tblPr` condition flags that gate which style parts apply to a table.
  * `firstRow`/`bandRow` are the ones PowerPoint turns on by default; the rest are
@@ -705,8 +786,6 @@ interface TableCellTextStyle {
   /** `@i`, read the same way as {@link bold}. */
   italic: boolean | null;
 }
-//#endregion
-//#region src/read/api/text/run.d.ts
 /**
  * What a text body is read against, handed from a {@link TextFrame} to each paragraph and run: the
  * part an edit marks dirty, the theme the `resolved*` getters resolve against, the relationships
@@ -718,8 +797,8 @@ interface TextContext {
   /** The theme the text resolves against: the colour maps, `fontScheme`, and the layout and master roots. */
   ctx: ThemeContext;
   /**
-   * The owning part's relationships, or `null` for text read without them — a SmartArt drawing's
-   * cached text — whose run hyperlinks then report their raw `@r:id`, `@action` and `@tooltip`.
+   * The owning part's relationships, or `null` for text read without them (a SmartArt drawing's
+   * cached text), whose run hyperlinks then report their raw `@r:id`, `@action` and `@tooltip`.
    */
   rels: Relationships | null;
   /**
@@ -759,7 +838,7 @@ interface InheritedRunProps {
 /**
  * A paragraph's line spacing (`a:pPr/a:lnSpc`), in whichever of the two OOXML
  * forms the file uses: an exact point height (`a:spcPts`) or a percentage of the
- * single-line height (`a:spcPct` — e.g. `percent: 150` for 1.5× spacing).
+ * single-line height (`a:spcPct`, e.g. `percent: 150` for 1.5× spacing).
  */
 type LineSpacing = {
   type: 'points';
@@ -770,7 +849,7 @@ type LineSpacing = {
 };
 /**
  * The bullet's own font, size and colour (`a:buFont` / `a:buSzPct` / `a:buSzPts` /
- * `a:buClr`) — the properties that style the glyph or number itself rather than
+ * `a:buClr`): the properties that style the glyph or number itself rather than
  * the text after it. Every field is `null` when the paragraph leaves it to be
  * inherited from the list style.
  *
@@ -778,7 +857,7 @@ type LineSpacing = {
  * are carried alongside each kind rather than inside it.
  */
 interface BulletStyle {
-  /** `a:buFont/@typeface` — the face the glyph is drawn in (a symbol font such as `Wingdings`), or `null`. */
+  /** `a:buFont/@typeface`: the face the glyph is drawn in (a symbol font such as `Wingdings`), or `null`. */
   font: string | null;
   /** `a:buSzPct/@val` as a percentage of the run size (e.g. `80`; the raw attribute is thousandths of a percent), or `null`. */
   sizePct: number | null;
@@ -792,11 +871,11 @@ interface BulletStyle {
  * children. Discriminated on `kind`, which is one of the four mutually
  * exclusive choices the schema allows:
  *
- * - `'none'`    — `a:buNone`, the bullet explicitly suppressed. Carries no style,
- *                 because there is no glyph to style.
- * - `'char'`    — `a:buChar`, a literal glyph.
- * - `'autoNum'` — `a:buAutoNum`, an auto-numbered list.
- * - `'picture'` — `a:buBlip`, an image used as the glyph.
+ * - `'none'`: `a:buNone`, the bullet explicitly suppressed. Carries no style,
+ *   because there is no glyph to style.
+ * - `'char'`: `a:buChar`, a literal glyph.
+ * - `'autoNum'`: `a:buAutoNum`, an auto-numbered list.
+ * - `'picture'`: `a:buBlip`, an image used as the glyph.
  *
  * A paragraph that names none of them inherits its bullet from the list style and
  * reports `null` rather than a member of this union.
@@ -805,7 +884,7 @@ type BulletDetail = {
   kind: 'none';
 } | ({
   kind: 'char';
-  /** The glyph itself (`a:buChar/@char`) — a bare character, never a tagged string. */
+  /** The glyph itself (`a:buChar/@char`): a bare character, never a tagged string. */
   char: string;
 } & BulletStyle) | ({
   kind: 'autoNum';
@@ -826,6 +905,28 @@ type BulletDetail = {
    */
   imagePartName: string | null;
 } & BulletStyle);
+/** One tab stop of a paragraph (`a:pPr/a:tabLst/a:tab`). */
+interface TabStop {
+  /** Position from the paragraph's left edge in points (`@pos` ÷ 12700), or `null` when unset. */
+  positionPt: number | null;
+  /** Alignment token (`@algn`: `l` | `ctr` | `r` | `dec`), or `null` when unset (the schema default is `l`). */
+  alignment: string | null;
+}
+/** A run's text outline (`a:rPr/a:ln`): the stroke drawn around each glyph. */
+interface RunOutline {
+  /** Stroke width in points (`@w` ÷ 12700), or `null` when unset. */
+  widthPt: number | null;
+  /**
+   * `true` for an explicit no-outline (`a:ln/a:noFill`), which PowerPoint writes on ordinary text
+   * to say the glyphs are not stroked.
+   */
+  noFill: boolean;
+  /**
+   * The stroke's solid colour (`a:ln/a:solidFill`), as written and resolved against the slide theme.
+   * Every field is `null` when the outline has no solid fill (`a:noFill`, a gradient, or none).
+   */
+  colorRef: ColorRef;
+}
 /** One text run (`a:r`): a span of text with uniform character formatting. */
 declare class Run {
   #private;
@@ -855,7 +956,7 @@ declare class Run {
    * its runs; nothing in it is resolved until a run asks.
    */
   inherited: InheritedRunProps | null);
-  /** The run's text (`a:t`), verbatim — whitespace is not normalized. */
+  /** The run's text (`a:t`), verbatim; whitespace is not normalized. */
   get text(): string;
   set text(value: string);
   /** Font size in points (`a:rPr/@sz` is hundredths of a point), or `null` if unset. */
@@ -874,7 +975,7 @@ declare class Run {
   /**
    * Strikethrough token (`a:rPr/@strike`: `noStrike` | `sngStrike` |
    * `dblStrike`), or `null` when unset (inherited from the style). Surfaced as
-   * the raw token — `sngStrike` is the writer's single-strike value.
+   * the raw token; `sngStrike` is the writer's single-strike value.
    */
   get strike(): string | null;
   /**
@@ -888,8 +989,8 @@ declare class Run {
    * `30`), negative for subscript (`-40`), or `null` when unset. Reported as the
    * percentage (`@baseline` ÷ 1000).
    *
-   * `@baseline` is `a:ST_Percentage`, a union that also admits `"62.5%"` — the only form the
-   * Strict profile has — so it is read through `parsePercentPoints` rather than as a bare number.
+   * `@baseline` is `a:ST_Percentage`, a union that also admits `"62.5%"` (the only form the
+   * Strict profile has), so it is read through `parsePercentPoints` rather than as a bare number.
    */
   get baselinePct(): number | null;
   /**
@@ -898,6 +999,12 @@ declare class Run {
    * the write-side `charSpacing` option.
    */
   get charSpacingPt(): number | null;
+  /**
+   * Kerning threshold in points (`a:rPr/@kern`, authored in hundredths of a point), or `null`
+   * when unset: text at this font size or larger is pair-kerned, and `0` means kerning is off.
+   * PowerPoint's own default is `12`. The read counterpart of the write-side `kerning` option.
+   */
+  get kerningPt(): number | null;
   /**
    * The run's highlight colour (`a:rPr/a:highlight`), resolved to a literal hex
    * through the owning slide's theme, or `null` when the run has no highlight or
@@ -914,6 +1021,45 @@ declare class Run {
    * `@r:id`/`@action`/`@tooltip` are reported (the target stays `null`).
    */
   get hyperlink(): Hyperlink | null;
+  /**
+   * The run's language tag (`a:rPr/@lang`, e.g. `fr-FR`), or `null` when unset. Decides spelling,
+   * hyphenation and font fallback. The read counterpart of the write-side `lang` option.
+   */
+  get language(): string | null;
+  /**
+   * The run's own glow (`a:rPr/a:effectLst/a:glow`), resolved against the slide theme, or `null`.
+   * The read counterpart of the write-side text `glow` option; a shape's glow is `Shape.glow`.
+   */
+  get glow(): Glow | null;
+  /**
+   * The run's own outer shadow (`a:rPr/a:effectLst/a:outerShdw`), resolved against the slide
+   * theme, or `null`. The read counterpart of a run's `shadow` option and of a table cell's,
+   * which writes it on every run of the cell; a shape's shadow is `Shape.shadow`.
+   */
+  get shadow(): OuterShadow | null;
+  /**
+   * The run's own inner shadow (`a:rPr/a:effectLst/a:innerShdw`), resolved against the slide
+   * theme, or `null`. What a run's `shadow: { type: 'inner' }` writes.
+   */
+  get innerShadow(): InnerShadow | null;
+  /** The run's text outline (`a:rPr/a:ln`), or `null` when it has none. The read counterpart of `outline`. */
+  get outline(): RunOutline | null;
+  /**
+   * The underline's own colour (`a:rPr/a:uFill/a:solidFill`), as written and resolved, or `null`
+   * when the underline follows the text colour. The read counterpart of `underline.color`.
+   */
+  get underlineColor(): ColorRef | null;
+  /**
+   * The East Asian typeface (`a:rPr/a:ea/@typeface`), or `null` when unset. {@link fontName} is the
+   * Latin slot. The read counterpart of the write-side `fontFaceEA` option.
+   */
+  get eastAsianFontName(): string | null;
+  /**
+   * How many line breaks (`a:br`) sit directly before this run in its paragraph, with no run or
+   * field between them. A soft break is not a run, so without this the runs on either side of one
+   * read as plain neighbours. The read counterpart of the write-side `softBreakBefore` option.
+   */
+  get breaksBefore(): number;
   /** Latin typeface name (`a:rPr/a:latin/@typeface`), or `null` when unset. */
   get fontName(): string | null;
   set fontName(value: string | null);
@@ -928,7 +1074,7 @@ declare class Run {
    * The colour this run effectively renders, resolved against the owning slide's
    * theme to a literal hex. It is the run's own solid fill
    * ({@link color}/{@link schemeColor}) when set; otherwise the shape's
-   * `p:style/a:fontRef` colour, then — for a run inside a placeholder — the colour
+   * `p:style/a:fontRef` colour, then (for a run inside a placeholder) the colour
    * it inherits from the placeholder/list-style chain (layout → master placeholder
    * `a:lstStyle` → master `p:txStyles`), then the presentation's
    * `p:defaultTextStyle`. `null` when the run sets no colour and inherits none, or the
@@ -936,8 +1082,11 @@ declare class Run {
    * `null` too when the run's own fill is not a solid colour (`a:noFill`, a gradient):
    * the run decides its own colour then, and the one it would otherwise inherit is not
    * what it paints in, the rule `Shape.resolvedFill` and `TableCell.resolvedFill` follow.
-   * The returned {@link ResolvedColor} carries `effectiveHex` — the base colour with
-   * its child transforms (`lumMod`/`shade`/…) applied — for the final rendered colour.
+   * A run with a click hyperlink (`a:hlinkClick`) and no fill of its own is painted in the
+   * theme's `hlink` colour instead, resolved through the slide's colour map, unless the link
+   * carries the 2018 `ahyp:hlinkClr val="tx"` extension, which asks for the text colour above.
+   * The returned {@link ResolvedColor} carries `effectiveHex`, the base colour with
+   * its child transforms (`lumMod`/`shade`/…) applied, for the final rendered colour.
    */
   get resolvedColor(): ResolvedColor | null;
   /**
@@ -945,20 +1094,21 @@ declare class Run {
    * ({@link fontSizePt}) when set; otherwise, for a run inside a placeholder, the
    * size it inherits from the placeholder/list-style chain (paragraph `a:defRPr` →
    * slide `a:lstStyle` → layout → master placeholder `a:lstStyle` → master
-   * `p:txStyles`). `null` when the run sets no size and inherits none — the
+   * `p:txStyles`). `null` when the run sets no size and inherits none. This is the
    * resolved counterpart of {@link fontSizePt}, which reports only the run's own value.
    */
   get resolvedSizePt(): number | null;
   /**
    * The typeface this run effectively renders, resolved to a literal face name. It
    * is the run's own `a:latin` ({@link fontName}) when set; otherwise the face named
-   * by the shape's `p:style/a:fontRef` (`idx` → theme major/minor font), then — for a
-   * run inside a placeholder — the face it inherits from the placeholder/list-style
+   * by the shape's `p:style/a:fontRef` (`idx` → theme major/minor font), then (for a
+   * run inside a placeholder) the face it inherits from the placeholder/list-style
    * chain, then the presentation's `p:defaultTextStyle`. A `+mj-*`/`+mn-*`
-   * major/minor theme-font token — on the run itself or reached through the chain —
+   * major/minor theme-font token, on the run itself or reached through the chain,
    * is resolved through the theme `fontScheme` to its concrete face. `null` when the
-   * run names no face and inherits none, or a token cannot be resolved — the resolved
-   * counterpart of {@link fontName}, which reports the raw `@typeface` (possibly a token).
+   * run names no face and inherits none, or a token cannot be resolved. This is the
+   * resolved counterpart of {@link fontName}, which reports the raw `@typeface` (possibly a
+   * token).
    */
   get resolvedFontFace(): string | null;
   /**
@@ -966,7 +1116,7 @@ declare class Run {
    * ({@link bold}) when set; otherwise, for a run inside a placeholder, the bold
    * state it inherits from the placeholder/list-style chain (paragraph `a:defRPr` →
    * slide `a:lstStyle` → layout → master placeholder `a:lstStyle` → master
-   * `p:txStyles`). `null` when the run sets no `@b` and inherits none — the
+   * `p:txStyles`). `null` when the run sets no `@b` and inherits none. This is the
    * resolved counterpart of {@link bold}, which reports only the run's own value.
    */
   get resolvedBold(): boolean | null;
@@ -975,7 +1125,7 @@ declare class Run {
    * ({@link italic}) when set; otherwise, for a run inside a placeholder, the italic
    * state it inherits from the placeholder/list-style chain (paragraph `a:defRPr` →
    * slide `a:lstStyle` → layout → master placeholder `a:lstStyle` → master
-   * `p:txStyles`). `null` when the run sets no `@i` and inherits none — the
+   * `p:txStyles`). `null` when the run sets no `@i` and inherits none. This is the
    * resolved counterpart of {@link italic}, and the twin of {@link resolvedBold}:
    * `@b` and `@i` are siblings a master text style states together, so a deck that
    * can be authored with an inherited italic can be read back with one.
@@ -986,8 +1136,36 @@ declare class Run {
   /** Mark the owning part dirty so `save()` reserializes it. Call after mutating {@link element_}. */
   markDirty(): void;
 }
-//#endregion
-//#region src/read/api/text/paragraph.d.ts
+/**
+ * One text field (`a:fld`): text PowerPoint computes as it renders, such as a slide number
+ * (`slidenum`) or a date (`datetime1`). A field carries the same `a:rPr` a run does, so it reads
+ * and resolves its formatting like one. {@link text} is the rendering PowerPoint last cached,
+ * which it recomputes on open.
+ */
+declare class Field extends Run {
+  /** How many of the paragraph's {@link Paragraph.runs} come before it, which places it among them. */
+  readonly runIndex: number;
+  constructor(element: Element, context: TextContext, inherited: InheritedRunProps | null,
+  /** How many of the paragraph's {@link Paragraph.runs} come before it, which places it among them. */
+  runIndex: number);
+  /** The field type (`@type`), such as `slidenum` or `datetime1`, or `null` when unset. */
+  get type(): string | null;
+}
+/**
+ * One OMML equation in a paragraph (an `a14:m` element), in the form `TextProps.math` and `inline`
+ * take back.
+ */
+interface Equation {
+  /**
+   * The equation's OMML as written: an `m:oMathPara` for a display equation, an `m:oMath` for an
+   * inline one. It declares every namespace it uses, PowerPoint's `a:` run properties included.
+   */
+  omml: string;
+  /** Whether the equation flows between the paragraph's runs (a bare `m:oMath`) rather than standing as a display block (`m:oMathPara`). */
+  inline: boolean;
+  /** How many of the paragraph's {@link Paragraph.runs} come before it, which places it among them. */
+  runIndex: number;
+}
 /** One paragraph (`a:p`) of a text frame. */
 declare class Paragraph {
   #private;
@@ -1007,8 +1185,24 @@ declare class Paragraph {
    * runs inherit through. Read only when {@link TextContext.inherit} is set.
    */
   slideLstStyle: Element | null);
-  /** The runs (`a:r`) in document order. Fields (`a:fld`) and breaks are not runs; see `text`. */
+  /** The runs (`a:r`) in document order. Fields (`a:fld`) are not runs (see {@link fields}), nor are breaks. */
   get runs(): Run[];
+  /**
+   * The OMML equations (`a14:m`) in document order. An equation is neither a run nor part of
+   * {@link text}; each says how many runs precede it, so an inline one keeps its place.
+   */
+  get equations(): Equation[];
+  /**
+   * The fields (`a:fld`) in document order, each read like a run; see {@link Field}. Each says how
+   * many runs precede it, so a field between runs keeps its place.
+   */
+  get fields(): Field[];
+  /**
+   * The language of the paragraph's end mark (`a:endParaRPr/@lang`, e.g. `fr-FR`), or `null` when
+   * unset. It is what text typed at the end of the paragraph, or into an empty one, is spelled in.
+   * The write side states it from the text's `lang` option.
+   */
+  get endLanguage(): string | null;
   /** Indent level (`a:pPr/@lvl`), 0 when unset. */
   get level(): number;
   /**
@@ -1035,7 +1229,41 @@ declare class Paragraph {
   /** First-line indent in points (`a:pPr/@indent` is EMU; negative for a hanging indent), or `null` when unset. */
   get indentPt(): number | null;
   /**
-   * This paragraph's bullet — its kind, and for a drawn bullet the glyph, the
+   * The alignment the paragraph renders with: its own, else the first its level inherits through
+   * the text body's `a:lstStyle`, the placeholder's layout and master list styles, the master's
+   * `p:txStyles` and the presentation's `p:defaultTextStyle`, the chain {@link Run.resolvedSizePt}
+   * walks. `null` when nothing in the chain states one (PowerPoint then aligns left).
+   */
+  get resolvedAlign(): string | null;
+  /** The left margin in points the paragraph renders with, resolved as {@link resolvedAlign} is. */
+  get resolvedMarginLeftPt(): number | null;
+  /** The first-line indent in points the paragraph renders with, resolved as {@link resolvedAlign} is. */
+  get resolvedIndentPt(): number | null;
+  /** The line spacing the paragraph renders with, resolved as {@link resolvedAlign} is. */
+  get resolvedLineSpacing(): LineSpacing | null;
+  /** The space before the paragraph in points, resolved as {@link resolvedAlign} is. */
+  get resolvedSpaceBeforePt(): number | null;
+  /** The space after the paragraph in points, resolved as {@link resolvedAlign} is. */
+  get resolvedSpaceAfterPt(): number | null;
+  /**
+   * The bullet the paragraph renders with: its own {@link bulletDetail}, else the first bullet its
+   * level inherits, resolved as {@link resolvedAlign} is. A picture bullet from an inherited tier
+   * reads with `imagePartName: null`, its image being a relationship of the layout or master.
+   * `null` when nothing in the chain names one.
+   */
+  get resolvedBulletDetail(): BulletDetail | null;
+  /**
+   * Right-to-left paragraph direction (`a:pPr/@rtl`), or `null` when unset (left to right). The
+   * read counterpart of the write-side `rtlMode` option.
+   */
+  get rtl(): boolean | null;
+  /**
+   * The paragraph's own tab stops (`a:pPr/a:tabLst/a:tab`) in document order, or `null` when it
+   * states no tab list and inherits one. The read counterpart of the write-side `tabStops` option.
+   */
+  get tabStops(): TabStop[] | null;
+  /**
+   * This paragraph's bullet: its kind, and for a drawn bullet the glyph, the
    * numbering start, and the bullet's own font/size/colour. `null` when the
    * paragraph names no bullet at all and inherits one from the list style.
    *
@@ -1043,7 +1271,7 @@ declare class Paragraph {
    * previous `bullet` accessor reported `'none'` / `'char:•'` /
    * `'autoNum:arabicPeriod'`, and that shape is ambiguous when the glyph is
    * itself a colon; worse, it reads as a bare glyph, which is exactly how the
-   * script converter first consumed it — `'none'.codePointAt(0)` put a literal
+   * script converter first consumed it: `'none'.codePointAt(0)` put a literal
    * `n` bullet on every converted deck, silently. See {@link BulletDetail}.
    */
   get bulletDetail(): BulletDetail | null;
@@ -1055,7 +1283,7 @@ declare class Paragraph {
   /**
    * Replace **this paragraph's** content with a single run, preserving the character
    * formatting (`a:rPr`) of its first existing run and leaving its `a:pPr` (level,
-   * alignment, bullet) alone. Sibling paragraphs are untouched — the difference from
+   * alignment, bullet) alone. Sibling paragraphs are untouched. That is the difference from
    * {@link TextFrame.text}, which collapses the whole body to one paragraph.
    */
   set text(value: string);
@@ -1064,13 +1292,10 @@ declare class Paragraph {
   /** Mark the owning part dirty so `save()` reserializes it. Call after mutating {@link element_}. */
   markDirty(): void;
 }
-/** A shape's text frame (`p:txBody`): an ordered list of paragraphs. */
-//#endregion
-//#region src/read/api/text/frame.d.ts
 /**
  * A text frame's body properties (`a:bodyPr`), as read from a shape. Carries the
- * inset/anchor/vertical-text settings that govern where text sits inside its box
- * — the difference between a label that clears a left rail and one that overlaps
+ * inset/anchor/vertical-text settings that govern where text sits inside its box:
+ * the difference between a label that clears a left rail and one that overlaps
  * it. Only **explicitly set** attributes are reported; an absent inset means the
  * PowerPoint default (`lIns`/`rIns` = 0.1", `tIns`/`bIns` = 0.05").
  */
@@ -1088,35 +1313,66 @@ interface BodyProperties {
     top?: number;
     bottom?: number;
   };
+  /** Number of text columns (`@numCol`), or `null` when unset (one column). The write side's `columns`. */
+  columns: number | null;
+  /** Space between columns in points (`@spcCol` ÷ 12700), or `null` when unset. The write side's `columnSpacing`. */
+  columnSpacingPt: number | null;
+  /** Preset WordArt warp (`a:prstTxWarp/@prst`, e.g. `textArchUp`), or `null` when none. The write side's `textWarp`. */
+  textWarp: string | null;
+}
+/**
+ * The character defaults a frame's own list style states for one level
+ * (`a:lstStyle/a:lvlNpPr/a:defRPr`). Each field is `null` when that `a:defRPr` does not state it.
+ */
+interface ListStyleDefaults {
+  /** `@sz` in points, or `null`. */
+  fontSizePt: number | null;
+  /** `a:latin/@typeface`, as written (a `+mj-lt` token stays a token), or `null`. */
+  fontName: string | null;
+  /** `@b`, or `null`. */
+  bold: boolean | null;
+  /** `@i`, or `null`. */
+  italic: boolean | null;
+  /** The `a:solidFill` colour, or `null` when the level states no solid fill. */
+  colorRef: ColorRef | null;
 }
 /**
  * A text frame's vertical-autofit mode, read from its `a:bodyPr` autofit child:
- * - `'none'`       — `a:noAutofit`, or no autofit child at all (the box has a fixed
- *                    size and text can overflow); write-side `fit: 'none'`.
- * - `'normAutofit'`— `a:normAutofit` (shrink text to fit); write-side `fit: 'shrink'`.
- * - `'spAutoFit'`  — `a:spAutoFit` (resize the shape to fit text); write-side `fit: 'resize'`.
+ * - `'none'`: `a:noAutofit`, or no autofit child at all (the box has a fixed
+ *   size and text can overflow); write-side `fit: 'none'`.
+ * - `'normAutofit'`: `a:normAutofit` (shrink text to fit); write-side `fit: 'shrink'`.
+ * - `'spAutoFit'`: `a:spAutoFit` (resize the shape to fit text); write-side `fit: 'resize'`.
  */
 type AutofitMode = 'none' | 'normAutofit' | 'spAutoFit';
 declare class TextFrame {
   #private;
   private readonly txBody;
   /**
-   * What the frame is read against — its part, the theme, the part's relationships and the
-   * inheritance its runs fall back through — handed on to each {@link Paragraph} and {@link Run}.
+   * What the frame is read against (its part, the theme, the part's relationships and the
+   * inheritance its runs fall back through), handed on to each {@link Paragraph} and {@link Run}.
    */
   private readonly context;
   constructor(txBody: Element,
   /**
-   * What the frame is read against — its part, the theme, the part's relationships and the
-   * inheritance its runs fall back through — handed on to each {@link Paragraph} and {@link Run}.
+   * What the frame is read against (its part, the theme, the part's relationships and the
+   * inheritance its runs fall back through), handed on to each {@link Paragraph} and {@link Run}.
    */
   context: TextContext);
   /** Paragraphs (`a:p`) in document order. */
   get paragraphs(): Paragraph[];
+  /**
+   * The character defaults this frame's own list style states for paragraphs at `level`
+   * (0-based): `a:lstStyle/a:lvlNpPr/a:defRPr`, else `a:defPPr/a:defRPr`. `null` when the frame
+   * has no list style or it states no defaults for that level.
+   *
+   * Only the frame's own tier. What a run inherits through it, and through a placeholder's
+   * layout and master, is the run's `resolved*` reads.
+   */
+  listStyleDefaults(level?: number): ListStyleDefaults | null;
   /**
    * The frame's body properties (`a:bodyPr`: insets, anchor, vertical text), or
    * `null` when there is no `a:bodyPr`. Only explicitly-set insets are reported
-   * (a missing side is the PowerPoint default — see {@link BodyProperties}).
+   * (a missing side is the PowerPoint default; see {@link BodyProperties}).
    */
   get bodyProperties(): BodyProperties | null;
   /**
@@ -1125,14 +1381,14 @@ declare class TextFrame {
    * layout → master placeholder `a:bodyPr`. `null` when nothing in the chain sets
    * one (PowerPoint then defaults to top). Unlike {@link bodyProperties}'s
    * `anchor` (own attribute only), this surfaces the inherited anchor a
-   * placeholder title relies on — the difference between a top- and
+   * placeholder title relies on: the difference between a top- and
    * centre-anchored title that own-attribute reads alone cannot see.
    */
   get resolvedAnchor(): string | null;
   /**
    * The frame's vertical-autofit mode (`a:bodyPr` autofit child), or `null` when
-   * there is no `a:bodyPr`. A `bodyPr` with no autofit child — or an explicit
-   * `a:noAutofit` — reads `'none'`. See {@link AutofitMode}. This is the deep-model
+   * there is no `a:bodyPr`. A `bodyPr` with no autofit child, or an explicit
+   * `a:noAutofit`, reads `'none'`. See {@link AutofitMode}. This is the deep-model
    * counterpart of `inspectPptx`'s per-shape `autofit`; unlike the shallow surface
    * it hangs off the navigable text frame.
    */
@@ -1140,8 +1396,8 @@ declare class TextFrame {
   /**
    * The baked shrink scale of a `normAutofit` frame as a percent (62.5 = 62.5%),
    * or `null` when the frame has no `a:normAutofit` or bakes no scale. A bare
-   * `<a:normAutofit/>` (write-side `fit: 'shrink'`) carries no scale — PowerPoint
-   * computes it on edit and draws at 100% until then — so it too reads `null`; an
+   * `<a:normAutofit/>` (write-side `fit: 'shrink'`) carries no scale (PowerPoint
+   * computes it on edit and draws at 100% until then), so it too reads `null`; an
    * explicit scale comes from `fit: { type: 'shrink', fontScale }`.
    */
   get autofitFontScale(): number | null;
@@ -1165,8 +1421,6 @@ declare class TextFrame {
   /** Mark the owning part dirty so `save()` reserializes it. Call after mutating {@link element_}. */
   markDirty(): void;
 }
-//#endregion
-//#region src/read/api/shapes/host.d.ts
 /** The part-level surface a {@link Shape} resolves against. */
 interface ShapeHost {
   /** The OPC part holding the shape tree (`p:sld` / `p:sldLayout` / `p:sldMaster`). */
@@ -1175,28 +1429,26 @@ interface ShapeHost {
   readonly partName: string;
   /** The package the host belongs to, for reaching a referenced part (image, chart, …). */
   readonly opc: OpcPackage;
-  /** {@link part}'s relationships — image embeds, hyperlinks, chart references. */
+  /** {@link part}'s relationships: image embeds, hyperlinks, chart references. */
   readonly relationships: Relationships;
   /** The host's resolved colour/font context, backing every `resolved*` getter. */
   themeContext(): ThemeContext;
-  /** The shape anywhere in this host's tree with the given drawing id, or `undefined`. */
-  shapeByIdDeep(id: number): AnyShape | undefined;
+  /** The shape anywhere in this host's tree with the given drawing id, or `undefined` (always, for `null`). */
+  shapeByIdDeep(id: number | null): AnyShape | undefined;
 }
-//#endregion
-//#region src/read/api/shapes/base.d.ts
-/** Common base for every shape in a shape tree — a slide's, a layout's, or a master's. */
+/** Common base for every shape in a shape tree: a slide's, a layout's, or a master's. */
 declare abstract class Shape {
   #private;
   protected readonly element: Element;
   /**
-   * The part that owns this shape's tree — a `Slide`, a `SlideLayout`, or a
+   * The part that owns this shape's tree: a `Slide`, a `SlideLayout`, or a
    * `SlideMaster`. Narrow it with `instanceof` when you need the concrete class;
    * {@link ShapeHost.partName} tells the tiers apart without one.
    */
   readonly host: ShapeHost;
   constructor(element: Element,
   /**
-   * The part that owns this shape's tree — a `Slide`, a `SlideLayout`, or a
+   * The part that owns this shape's tree: a `Slide`, a `SlideLayout`, or a
    * `SlideMaster`. Narrow it with `instanceof` when you need the concrete class;
    * {@link ShapeHost.partName} tells the tiers apart without one.
    */
@@ -1239,11 +1491,18 @@ declare abstract class Shape {
   /**
    * Whether the shape is explicitly hidden (`p:cNvPr/@hidden="1"`); `false` when
    * the attribute is unset. A hidden shape stays in the slide XML but is not
-   * rendered — decks use it as a fallback layer (e.g. a duotone-recolour source
+   * rendered. Decks use it as a fallback layer (e.g. a duotone-recolour source
    * sitting behind the visible icon), so a faithful reader must distinguish it
    * from the drawn shapes.
    */
   get hidden(): boolean;
+  /**
+   * The shape's lock flags: the attributes of the locking element under its non-visual drawing
+   * properties (`a:spLocks`, `a:picLocks`, `a:cxnSpLocks`, `a:graphicFrameLocks` or
+   * `a:grpSpLocks`), each as the boolean it states, keyed by attribute name (`noMove`, `noGrp`, …).
+   * `null` when the shape has no locking element. The read counterpart of `objectLock`.
+   */
+  get locks(): Record<string, boolean> | null;
   /**
    * The shape's alt-text description (`p:cNvPr/@descr`), or `null` when unset.
    * This is the accessibility primitive a screen reader announces; an audit or
@@ -1266,7 +1525,7 @@ declare abstract class Shape {
   /**
    * Whether the shape is flagged **decorative** (`p:cNvPr/a:extLst/a:ext`
    * uri `{C183D7F6-…}` / `adec:decorative@val`), PowerPoint's "Mark as
-   * decorative" — a purely visual element assistive tech should skip. `false`
+   * decorative": a purely visual element assistive tech should skip. `false`
    * when the extension is absent. A decorative shape typically has no
    * {@link description}; the two are alternatives, not companions.
    */
@@ -1300,8 +1559,8 @@ declare abstract class Shape {
   get resolvedFrame(): ResolvedFrame | null;
   /**
    * Clockwise rotation in degrees (`a:xfrm/@rot` ÷ 60000), or `null` when the
-   * shape has no own transform. A present xfrm with no `@rot` reads as `0`, so
-   * — mirroring {@link left}/{@link top}/{@link width}/{@link height} — `null`
+   * shape has no own transform. A present xfrm with no `@rot` reads as `0`, so,
+   * mirroring {@link left}/{@link top}/{@link width}/{@link height}, `null`
    * ("inherits layout geometry") stays distinct from `0` ("has a transform, not
    * rotated"). The value is faithful to the XML and not normalised to a signed
    * range, so a `@rot` past 360° (e.g. a negative angle stored as `19216344`)
@@ -1338,7 +1597,7 @@ declare abstract class Shape {
    * equal the shape's own transform values.
    *
    * `null` when the shape (or any enclosing group) has no own transform, or a
-   * group's `a:chExt` is degenerate (zero) — there is then no resolvable frame.
+   * group's `a:chExt` is degenerate (zero). There is then no resolvable frame.
    * {@link absoluteFrameFailure} says which of those it was.
    *
    * A rotated shape's returned `left`/`top` remain PowerPoint's unrotated
@@ -1350,7 +1609,7 @@ declare abstract class Shape {
    * Why {@link absoluteFrame} is `null`, or `null` when it resolved.
    *
    * `absoluteFrame` reports one `null` for three different situations, and only a
-   * caller that wants to *report* the unresolvable shape needs them apart — an
+   * caller that wants to *report* the unresolvable shape needs them apart: an
    * inherited placeholder box is ordinary, a group with no usable `a:xfrm` is not.
    * The distinction is not recoverable from the `null`, and re-deriving it means
    * walking the same ancestry a second time, so it is named here instead. See
@@ -1379,19 +1638,19 @@ declare abstract class Shape {
   get fillSchemeColor(): string | null;
   set fillSchemeColor(value: string | null);
   /**
-   * `true` when the shape sets an explicit no-fill (`spPr/a:noFill`) — a
+   * `true` when the shape sets an explicit no-fill (`spPr/a:noFill`): a
    * deliberately transparent surface. The fill-side counterpart of
    * {@link lineNoFill}, and the only accessor that separates it from a shape
    * carrying no fill child at all (one inheriting through `p:style/a:fillRef`):
-   * every other fill accessor — {@link fillColor}, {@link fillSchemeColor},
+   * every other fill accessor ({@link fillColor}, {@link fillSchemeColor},
    * {@link resolvedFill}, {@link gradientFill}, {@link patternFill},
-   * {@link pictureFill} — reports `null` for both. The two paint completely
+   * {@link pictureFill}) reports `null` for both. The two paint completely
    * differently, so a consumer that cannot tell them apart paints a transparent
    * shape in the theme's accent colour.
    */
   get fillNoFill(): boolean;
   /**
-   * Set an explicit `<a:noFill/>` on the shape — a transparent surface. This is
+   * Set an explicit `<a:noFill/>` on the shape: a transparent surface. This is
    * distinct from clearing the fill (`fillColor = null`), which removes the
    * `a:solidFill` and lets the fill inherit from the shape's style/placeholder.
    * Read it back with {@link fillNoFill}.
@@ -1408,12 +1667,12 @@ declare abstract class Shape {
   /**
    * The line/border dash style (`spPr/a:ln/a:prstDash/@val`), e.g. `'dash'`,
    * `'lgDashDot'`, `'sysDot'`, or `null` when the line is solid/unset. A faithful
-   * replica of dashed dividers and dashed card borders needs this — it is
+   * replica of dashed dividers and dashed card borders needs this: it is
    * otherwise invisible in {@link lineColor}/{@link lineWidthPt} alone.
    */
   get lineDash(): string | null;
   /**
-   * `true` when the shape sets an explicit no-line (`spPr/a:ln/a:noFill`) — a
+   * `true` when the shape sets an explicit no-line (`spPr/a:ln/a:noFill`): a
    * deliberately border-less shape. Distinct from simply having no `a:ln`
    * (an inherited line), which {@link resolvedLine} cannot tell apart: both
    * report `null`. A replica that relies on a shadow instead of a border needs
@@ -1421,8 +1680,18 @@ declare abstract class Shape {
    */
   get lineNoFill(): boolean;
   /**
-   * The line end cap (`spPr/a:ln/@cap`) as the raw OOXML token — `'flat'`,
-   * `'rnd'` (round) or `'sq'` (square) — or `null` when unset (PowerPoint's
+   * Whether the shape states an outline of its **own** (`spPr/a:ln`), however little it holds.
+   *
+   * The line accessors all report `null` both for a shape with no `a:ln` and for one whose `a:ln`
+   * is empty, and the two are different statements to a writer: an empty `<a:ln/>` says "take the
+   * whole outline from `p:style` or the placeholder", which is what PowerPoint writes on its own
+   * placeholders, and `addShape` writes it for `line: { type: 'inherit' }`. A copy that has to
+   * reproduce the outline rather than describe it needs to know which one it has.
+   */
+  get hasOwnLine(): boolean;
+  /**
+   * The line end cap (`spPr/a:ln/@cap`) as the raw OOXML token, `'flat'`,
+   * `'rnd'` (round) or `'sq'` (square), or `null` when unset (PowerPoint's
    * default is `flat`). The write API authors this attribute through
    * `ShapeLineProps.cap`, so without the accessor a deck this library produced
    * could not be read back without losing it.
@@ -1434,8 +1703,8 @@ declare abstract class Shape {
    */
   get lineCap(): string | null;
   /**
-   * The line alignment (`spPr/a:ln/@algn`) as the raw OOXML token — `'ctr'`
-   * (centred on the shape's outline) or `'in'` (inset, drawn wholly inside it) —
+   * The line alignment (`spPr/a:ln/@algn`) as the raw OOXML token, `'ctr'`
+   * (centred on the shape's outline) or `'in'` (inset, drawn wholly inside it),
    * or `null` when unset. It shifts a thick outline by half its width, so it
    * changes where the border sits relative to the fill.
    */
@@ -1453,7 +1722,7 @@ declare abstract class Shape {
    * shape uses preset geometry / none. The faithful, multi-path counterpart of
    * {@link presetGeometry}: each `a:path` keeps its own path-unit viewport
    * (`w`/`h`) and ordered {@link GeometryCommand}s. Coordinates are raw path-unit
-   * integers, not EMU — pair the path `w`/`h` with the shape's box size to map
+   * integers, not EMU. Pair the path `w`/`h` with the shape's box size to map
    * them into slide space.
    *
    * Not an auto-shape-only property either: a picture clipped to a freeform (what
@@ -1479,7 +1748,7 @@ declare abstract class Shape {
    * The shape's gradient fill with its geometry (`spPr/a:gradFill`), or `null`
    * when the fill is not a gradient. Unlike {@link gradientStops} (stops only),
    * this also carries the linear {@link GradientFill.angleDeg} or the
-   * {@link GradientFill.path} shape — the geometry a faithful replica needs and
+   * {@link GradientFill.path} shape: the geometry a faithful replica needs and
    * which the bare stop list omits.
    */
   get gradientFill(): GradientFill | null;
@@ -1487,11 +1756,17 @@ declare abstract class Shape {
    * The shape's line/border **gradient** stroke (`spPr/a:ln/a:gradFill`), or
    * `null` when the line is a solid, absent, or inherited border (see
    * {@link resolvedLine}). The line counterpart of {@link gradientFill}: a
-   * gradient-stroked connector — common for faded process arrows in styled decks
-   * — otherwise surfaces only its {@link lineWidthPt}, dropping the colour
+   * gradient-stroked connector (common for faded process arrows in styled decks)
+   * otherwise surfaces only its {@link lineWidthPt}, dropping the colour
    * entirely, so a replica cannot reproduce the stroke.
    */
   get lineGradient(): GradientFill | null;
+  /**
+   * The shape's line/border **pattern** stroke (`spPr/a:ln/a:pattFill`), or `null` when the line
+   * is not a pattern. The line counterpart of {@link patternFill}, and what the write side's
+   * `line.pattern` writes.
+   */
+  get linePatternFill(): PatternFill | null;
   /**
    * The shape's line/connector arrowheads (`a:ln/a:headEnd` + `a:tailEnd`), or
    * `null` when neither end carries one. Essential for replicating connectors,
@@ -1521,7 +1796,7 @@ declare abstract class Shape {
   /**
    * The shape's reflection (`spPr/a:effectLst/a:reflection`), or `null` when it has
    * none. Read-only: this library authors no reflection, so a replica should carry
-   * the part rather than regenerate it — see {@link Reflection}.
+   * the part rather than regenerate it (see {@link Reflection}).
    */
   get reflection(): Reflection | null;
   /**
@@ -1532,7 +1807,7 @@ declare abstract class Shape {
   /**
    * The shape's pattern (hatch) fill (`spPr/a:pattFill`), or `null` when the fill
    * is not a pattern. Surfaces the {@link PatternFill.preset} name and both
-   * colours resolved against the host's theme — the pattern counterpart of
+   * colours resolved against the host's theme: the pattern counterpart of
    * {@link resolvedFill}, which reports `null` for a non-solid fill and so drops a
    * hatched surface entirely.
    */
@@ -1540,8 +1815,8 @@ declare abstract class Shape {
   /**
    * The shape's picture (image) fill (`spPr/a:blipFill`), or `null` when the fill
    * is not a picture. The image-fill counterpart of {@link patternFill}: a shape
-   * whose *surface* is an image is not a {@link Picture} — it is an autoShape with
-   * a blip fill — and {@link resolvedFill} reports `null` for one, so without this
+   * whose *surface* is an image is not a {@link Picture} (it is an autoShape with
+   * a blip fill), and {@link resolvedFill} reports `null` for one, so without this
    * an image-filled shape reads as unfilled. Carries the embedded image
    * ({@link PictureFill.relId}/{@link PictureFill.partName}) plus the stretch/tile
    * geometry.
@@ -1549,11 +1824,11 @@ declare abstract class Shape {
   get pictureFill(): PictureFill | null;
   /**
    * The shape's solid fill resolved against the host's theme
-   * ({@link Slide.themeContext}) to a literal hex — the resolved counterpart of
+   * ({@link Slide.themeContext}) to a literal hex: the resolved counterpart of
    * {@link fillColor}/{@link fillSchemeColor}, which report the raw reference.
    * `null` when the shape has no `a:solidFill` (a gradient/none/inherited fill)
    * or the colour cannot be made literal. The returned {@link ResolvedColor}
-   * carries the base `hex` and raw transforms, and `effectiveHex` — the base with
+   * carries the base `hex` and raw transforms, and `effectiveHex`, the base with
    * its colour transforms (`lumMod`/`shade`/…) applied (read that for the final
    * rendered colour).
    *
@@ -1564,7 +1839,7 @@ declare abstract class Shape {
   get resolvedFill(): ResolvedColor | null;
   /**
    * The shape's line/border solid fill resolved against the host's theme to a
-   * literal hex — the resolved counterpart of {@link lineColor}/{@link lineSchemeColor}.
+   * literal hex: the resolved counterpart of {@link lineColor}/{@link lineSchemeColor}.
    * `null` when the shape has no `a:ln/a:solidFill` or it cannot be made literal.
    * Like {@link resolvedFill}, the result carries `effectiveHex` (the base colour
    * with its transforms applied) for the final rendered colour.
@@ -1591,8 +1866,12 @@ declare abstract class Shape {
   set text(value: string);
   /**
    * This shape's placeholder identity (`p:ph` `type`/`idx`), or `null` when it is
-   * not a placeholder. Only `p:sp` shapes can be placeholders, so the base
-   * implementation always returns `null`; {@link AutoShape} overrides it.
+   * not a placeholder. `idx` defaults to `'0'` when the attribute is absent, as
+   * PowerPoint does. A text placeholder is a `p:sp`; a filled picture, table or chart
+   * placeholder is a `p:pic` or `p:graphicFrame` carrying the same `p:ph`, which is what
+   * inserting a picture into a picture placeholder produces. This used to be `null` for
+   * every shape but a `p:sp` (#111). Use {@link Slide.placeholder} to find a text
+   * placeholder by type.
    */
   get placeholder(): PlaceholderRef | null;
   /**
@@ -1607,22 +1886,12 @@ declare abstract class Shape {
   /** Escape hatch: the underlying shape element. After mutating it call {@link markDirty}, or `save()` writes the original bytes. */
   get element_(): Element;
 }
-//#endregion
-//#region src/read/api/shapes/autoshape.d.ts
 /** An auto shape, text box, or placeholder (`p:sp`). The only kind that holds text. */
 declare class AutoShape extends Shape {
   readonly shapeType: 'autoShape';
   get hasTextFrame(): boolean;
   get textFrame(): TextFrame | null;
-  /**
-   * This shape's placeholder identity (`p:ph` `type`/`idx`), or `null` when it is
-   * not a placeholder. `idx` defaults to `'0'` when the attribute is absent, as
-   * PowerPoint does. Use {@link Slide.placeholder} to find a placeholder by type.
-   */
-  get placeholder(): PlaceholderRef | null;
 }
-//#endregion
-//#region src/read/api/shapes/picture.d.ts
 /** A picture (`p:pic`). */
 declare class Picture extends Shape {
   #private;
@@ -1649,7 +1918,7 @@ declare class Picture extends Shape {
    * Microsoft SVG blip extension (`a:blip/a:extLst/a:ext/asvg:svgBlip/@r:embed`),
    * or `null` when the picture has no SVG. PowerPoint usually pairs this with a
    * raster fallback in `a:blip/@r:embed` ({@link imageRelId}), but some exporters
-   * emit an SVG-only blip where `imageRelId` is absent and only this resolves —
+   * emit an SVG-only blip where `imageRelId` is absent and only this resolves,
    * so a reader that wants the real drawn art must consult both.
    */
   get svgRelId(): string | null;
@@ -1657,19 +1926,19 @@ declare class Picture extends Shape {
   get svgPartName(): string | null;
   /**
    * Which drawable media this picture carries:
-   * - `'raster'` — only a raster blip (`a:blip/@r:embed`);
-   * - `'svg'` — only a vector blip (`asvg:svgBlip/@r:embed`, no raster). This
+   * - `'raster'`: only a raster blip (`a:blip/@r:embed`);
+   * - `'svg'`: only a vector blip (`asvg:svgBlip/@r:embed`, no raster). This
    *   is what PowerPoint's *Insert → Icons* and a plain SVG insert produce;
-   * - `'both'` — a raster fallback *and* an SVG (PowerPoint's usual pairing);
-   * - `'none'` — a `p:pic` with no embedded blip at all (e.g. a linked image).
+   * - `'both'`: a raster fallback *and* an SVG (PowerPoint's usual pairing);
+   * - `'none'`: a `p:pic` with no embedded blip at all (e.g. a linked image).
    *
-   * Lets a caller distinguish an SVG-only picture — where {@link imagePartName}
-   * is legitimately `null` — from a genuinely empty one, without two null checks.
+   * Lets a caller distinguish an SVG-only picture (where {@link imagePartName}
+   * is legitimately `null`) from a genuinely empty one, without two null checks.
    */
   get mediaKind(): 'raster' | 'svg' | 'both' | 'none';
   /**
    * Absolute partname of whichever part actually carries this picture's drawn
-   * data — the raster part when present, otherwise the SVG part — or `null`
+   * data (the raster part when present, otherwise the SVG part), or `null`
    * when the picture embeds neither. Use this when you just want "the bytes
    * this picture shows"; prefer {@link imagePartName} / {@link svgPartName}
    * (and {@link mediaKind}) when you need to know *which* kind it is. An
@@ -1677,9 +1946,14 @@ declare class Picture extends Shape {
    * `null`.
    */
   get mediaPartName(): string | null;
+  /**
+   * The audio or video this picture plays (`p:nvPr/a:audioFile` or `a:videoFile`), or `null` for a
+   * still picture. Its blip ({@link imagePartName}) is then the poster frame. See {@link PictureMedia}.
+   */
+  get media(): PictureMedia | null;
   /**
    * The picture's crop as fractions of the *source image*, read from
-   * `p:blipFill/a:srcRect` — `{ left, top, right, bottom }`, each the amount
+   * `p:blipFill/a:srcRect` as `{ left, top, right, bottom }`, each the amount
    * trimmed off that edge (so `0.1` = 10 % cropped away, an uncropped edge is
    * `0`). `null` when there is no `a:srcRect` at all; an explicit
    * `{0,0,0,0}` crop still reports zeros, since its presence is meaningful.
@@ -1693,13 +1967,20 @@ declare class Picture extends Shape {
    * `null` when the blip carries none. Recognises the effects a faithful reader
    * needs to reproduce a recoloured image: `a:duotone` (the two-stop icon-tint
    * trick), `a:clrChange`, `a:grayscl`, `a:biLevel`, and `a:alphaModFix`; the
-   * first such effect in document order wins. Colours mirror the
+   * first such effect in document order wins, and {@link recolors} lists them all. Colours mirror the
    * {@link GradientStop} split (`color`/`schemeColor`/`presetColor`) so theme
    * tokens resolve through {@link Slide.themeContext}. `threshold`/`amount` are
    * 0–1 fractions. {@link hidden} (the duotone fallback-layer trick) reports the
    * *visibility* of a recolour source; this reports the *tint* itself.
    */
   get recolor(): Recolor | null;
+  /**
+   * Every blip effect {@link recolor} recognises, in document order: the first is
+   * {@link recolor}. They combine (a picture can be faded with `a:alphaModFix` and
+   * recoloured too, which is how the write API emits `transparency` beside a
+   * recolour), and {@link recolor} alone reported only the first of them.
+   */
+  get recolors(): Recolor[];
   /**
    * Replace this picture's image with new bytes. Mints a fresh media part under
    * `/ppt/media/`, registers its content type, wires an `image` relationship
@@ -1714,7 +1995,7 @@ declare class Picture extends Shape {
    *
    * `fit` controls the picture's `a:srcRect` crop against its current frame
    * extent (`a:xfrm/a:ext`):
-   * - omitted (default): geometry and crop are left untouched — the caller owns
+   * - omitted (default): geometry and crop are left untouched; the caller owns
    *   sizing. Note an inherited `a:srcRect` was tuned to the *previous* image's
    *   aspect ratio, so swapping in an image of a different ratio reuses a crop
    *   that no longer fits and the result looks stretched; pass `fit` to refit.
@@ -1732,8 +2013,6 @@ declare class Picture extends Shape {
     fit?: 'cover' | 'contain' | 'stretch';
   }): void;
 }
-//#endregion
-//#region src/read/api/shapes/connector.d.ts
 /** A connector / line (`p:cxnSp`). */
 declare class Connector extends Shape {
   #private;
@@ -1751,8 +2030,6 @@ declare class Connector extends Shape {
    */
   get endConnection(): ConnectionSite | null;
 }
-//#endregion
-//#region src/read/api/chart.d.ts
 /** A chart axis number format (`c:numFmt`). */
 interface AxisNumberFormat {
   /** The format mask (`@formatCode`), e.g. `"General"`, `"0.0%"`. */
@@ -1766,6 +2043,36 @@ interface ChartLegend {
   position: string | null;
   /** Whether the legend overlays the plot area (`c:overlay/@val`). */
   overlay: boolean | null;
+  /** The legend text's formatting (`c:txPr`), or `null` when it states none. */
+  textStyle: ChartTextStyle | null;
+  /** The legend's manual layout, or `null` when it is placed automatically. */
+  layout: ChartManualLayout | null;
+}
+/**
+ * The formatting of a block of chart text: a `c:txPr` (a legend's, an axis' labels', data labels')
+ * or a title's `c:rich`. Read off the block's `a:bodyPr` and its first paragraph: the paragraph's
+ * `a:pPr` and `a:defRPr`, and in a title, the first run's `a:rPr` over them. Every field is `null`
+ * where the block states nothing.
+ */
+interface ChartTextStyle {
+  /** Size in points (`@sz`). */
+  sizePt: number | null;
+  /** Bold (`@b`). */
+  bold: boolean | null;
+  /** Italic (`@i`). */
+  italic: boolean | null;
+  /** Underline style (`@u`, e.g. `sng`, `none`). */
+  underline: string | null;
+  /** The solid colour, unresolved: a chart part is read without a theme. */
+  color: ColorRef | null;
+  /** Whether {@link color} carries a transform (`a:lumMod`, …) that only a theme can apply. */
+  colorTransformed: boolean;
+  /** The Latin typeface (`a:latin/@typeface`), a theme token such as `+mn-lt` included. */
+  fontName: string | null;
+  /** Rotation in degrees (`a:bodyPr/@rot` / 60000), or `null` when unstated or outside -90 to 90. */
+  rotationDeg: number | null;
+  /** Paragraph alignment (`a:pPr/@algn`: `l`, `ctr`, `r`, …). */
+  align: string | null;
 }
 /** Data-label settings (`c:dLbls`), read from a plot group or from one series. */
 interface ChartDataLabels {
@@ -1787,6 +2094,74 @@ interface ChartDataLabels {
   position: string | null;
   /** Label number format (`c:numFmt`), or `null` when absent. */
   numberFormat: AxisNumberFormat | null;
+  /** The labels' text formatting (`c:txPr`), or `null` when the block states none. */
+  textStyle: ChartTextStyle | null;
+  /** The labels' background fill (`c:spPr`), or `null` when it states none. */
+  fill: ChartFill | null;
+  /** The leader lines' stroke (`c:leaderLines/c:spPr/a:ln`), or `null` when they state none. */
+  leaderLines: ChartLine | null;
+}
+/** One stretch of a data label's own text: a run, or a field PowerPoint fills in (`a:fld`). */
+interface ChartLabelRun {
+  /** The text, which for a field is what it showed when the chart was saved. */
+  text: string;
+  /** The field type (`a:fld/@type`: `XVALUE`, `YVALUE`, `CELLRANGE`, …), or `null` for a plain run. */
+  field: string | null;
+}
+/** A data label that states its own text (`c:dLbl` with `c:tx/c:rich`), as a scatter's custom labels do. */
+interface ChartPointLabel {
+  /** The index of the point it labels (`c:idx`). */
+  index: number;
+  /** Its runs and fields, in order, across its paragraphs. */
+  runs: ChartLabelRun[];
+}
+/** The 3-D view of a chart (`c:chart/c:view3D`). Every field is `null` when the element leaves it unstated. */
+interface ChartView3D {
+  /** Tilt in degrees (`c:rotX`), -90 to 90. */
+  rotX: number | null;
+  /** Turn in degrees (`c:rotY`), 0 to 360. */
+  rotY: number | null;
+  /** Field of view (`c:perspective`), 0 to 240, twice the angle in degrees. */
+  perspective: number | null;
+  /** Whether the axes stay at right angles (`c:rAngAx`), which turns perspective off. */
+  rightAngleAxes: boolean | null;
+}
+/** A series' data-point marker (`c:ser/c:marker`). */
+interface ChartMarker {
+  /** The marker shape (`c:symbol`, `ST_MarkerStyle`: `circle`, `diamond`, `none`, …), or `null` when unstated. */
+  symbol: string | null;
+  /** The marker size in points (`c:size`), 2 to 72, or `null` when unstated. */
+  size: number | null;
+  /** The marker's solid fill, as {@link ChartSeries.fill} reads a series'. */
+  fill: ChartFill | null;
+  /** The marker's outline, as {@link ChartSeries.line} reads a series'. */
+  line: ChartLine | null;
+}
+/** One data point a series formats on its own (`c:ser/c:dPt`). */
+interface ChartDataPoint {
+  /** The point's index in the series (`c:idx`). */
+  index: number;
+  /** Whether a negative bar at this point paints inverted (`c:invertIfNegative`), or `null` when unstated. */
+  invertIfNegative: boolean | null;
+  /** The point's solid fill, as {@link ChartSeries.fill} reads a series'. */
+  fill: ChartFill | null;
+  /** The point's pattern fill (`a:pattFill`), or `null`. */
+  patternFill: PatternFill | null;
+  /** The point's outline, as {@link ChartSeries.line} reads a series'. */
+  line: ChartLine | null;
+}
+/** A chart's data table (`c:plotArea/c:dTable`), the grid of values drawn under the plot. */
+interface ChartDataTable {
+  /** Horizontal cell borders (`c:showHorzBorder`), or `null` when unstated. */
+  showHorizontalBorder: boolean | null;
+  /** Vertical cell borders (`c:showVertBorder`), or `null` when unstated. */
+  showVerticalBorder: boolean | null;
+  /** The outline around the table (`c:showOutline`), or `null` when unstated. */
+  showOutline: boolean | null;
+  /** The legend keys beside each series' row (`c:showKeys`), or `null` when unstated. */
+  showKeys: boolean | null;
+  /** The table text's size in points (`c:txPr`'s first `a:defRPr/@sz`), or `null` when unstated. */
+  fontSizePt: number | null;
 }
 /** A series' solid fill (`c:ser/c:spPr`). */
 interface ChartFill {
@@ -1797,6 +2172,54 @@ interface ChartFill {
   colorRef: ColorRef;
   /** Whether the fill is explicitly suppressed (`a:noFill`). */
   noFill: boolean;
+  /** The opacity of the solid colour, 0 to 1 (its `a:alpha`), or `null` when it states none. */
+  alpha: number | null;
+}
+/**
+ * A manual layout (`c:layout/c:manualLayout`): where an element sits, as fractions of the chart.
+ * Every field is `null` where the layout leaves it automatic.
+ */
+interface ChartManualLayout {
+  /** What the box bounds (`c:layoutTarget`): `inner` (the plot alone) or `outer` (with its labels). */
+  target: string | null;
+  /** How `x` reads (`c:xMode`): `edge` (from the chart's left edge) or `factor` (an offset). */
+  xMode: string | null;
+  /** How `y` reads (`c:yMode`). */
+  yMode: string | null;
+  x: number | null;
+  y: number | null;
+  w: number | null;
+  h: number | null;
+}
+/**
+ * The fill, border and manual layout of a chart surface: the chart area (`c:chartSpace/c:spPr`) or
+ * the plot area (`c:plotArea`). The fill accessors are the ones a slide shape has, read the same way.
+ */
+interface ChartAreaFormat {
+  /** Whether the area is explicitly unfilled (`a:noFill`). */
+  fillNoFill: boolean;
+  /**
+   * Whether the area states a fill of its own: any fill choice, `a:noFill` included. `false` when
+   * it states none and inherits its fill from the chart style.
+   */
+  hasOwnFill: boolean;
+  /** A literal solid fill colour (`a:srgbClr`), or `null`. */
+  fillColor: string | null;
+  /** A theme solid fill colour (`a:schemeClr`), or `null`. */
+  fillSchemeColor: string | null;
+  /**
+   * The solid fill resolved without a theme: a literal colour with its transforms applied, its
+   * `alpha` included; `null` for a scheme colour or a non-solid fill.
+   */
+  resolvedFill: ResolvedColor | null;
+  gradientFill: GradientFill | null;
+  patternFill: PatternFill | null;
+  /** A picture fill (`a:blipFill`), its image resolved through the chart part's relationships. */
+  pictureFill: PictureFill | null;
+  /** The area's border (`a:ln`), or `null` when it states none. */
+  border: ChartLine | null;
+  /** The area's manual layout; always `null` for the chart area, which fills the frame. */
+  layout: ChartManualLayout | null;
 }
 /** A series' line/stroke (`c:ser/c:spPr/a:ln`). */
 interface ChartLine {
@@ -1808,15 +2231,46 @@ interface ChartLine {
   colorRef: ColorRef;
   /** Whether the line is explicitly suppressed (`a:noFill`). */
   noFill: boolean;
+  /** The line end cap (`@cap`) as its raw token (`flat`, `rnd`, `sq`), or `null` when unset. */
+  cap: string | null;
+  /** The opacity of the stroke's colour, 0 to 1 (its `a:alpha`), or `null` when it states none. */
+  alpha: number | null;
+  /**
+   * Whether the stroke's colour carries a transform besides `a:alpha` (`a:lumMod`, `a:shade`, …).
+   * A chart part is read without a theme, so {@link colorRef} does not apply it: PowerPoint's
+   * default axis line, `tx1` lightened to a grey, reads as the bare `tx1` token.
+   */
+  colorTransformed: boolean;
+}
+/** The display units of a value axis (`c:dispUnits`). */
+interface ChartDisplayUnits {
+  /** A built-in unit (`c:builtInUnit`: `hundreds`, `thousands`, …, `trillions`), or `null`. */
+  builtIn: string | null;
+  /** A custom divisor (`c:custUnit`), or `null`. */
+  custom: number | null;
+  /** Whether the unit is labelled on the axis (`c:dispUnitsLbl`). */
+  showLabel: boolean;
 }
 /** A chart graphic-frame's chart, backed by its chart part. */
 declare class Chart {
   #private;
   /** The chart's OPC part (`/ppt/charts/chartN.xml`). */
   readonly part: Part;
+  /** The chart part's relationships, which resolve a picture fill's image; `null` leaves it unresolved. */
+  private readonly rels;
   constructor(
   /** The chart's OPC part (`/ppt/charts/chartN.xml`). */
-  part: Part);
+  part: Part,
+  /** The chart part's relationships, which resolve a picture fill's image; `null` leaves it unresolved. */
+  rels?: Relationships | null);
+  /** The chart area's fill and border (`c:chartSpace/c:spPr`), or `null` when it states none. */
+  get chartArea(): ChartAreaFormat | null;
+  /** Whether the chart area's corners are rounded (`c:roundedCorners`), or `null` when unstated. */
+  get roundedCorners(): boolean | null;
+  /** The plot area's fill, border and manual layout, or `null` when the chart has no plot area. */
+  get plotArea(): ChartAreaFormat | null;
+  /** The title's manual layout (`c:title/c:layout`), or `null` when it is placed automatically. */
+  get titleLayout(): ChartManualLayout | null;
   /** Partname of the chart part. */
   get partName(): string;
   /**
@@ -1840,6 +2294,13 @@ declare class Chart {
   get valueAxis(): ChartAxis | null;
   /** The legend (`c:chart/c:legend`) position + overlay, or `null` when hidden. */
   get legend(): ChartLegend | null;
+  /** The chart title's formatting (`c:title/c:tx/c:rich`), or `null` when the chart has no rich title. */
+  get titleStyle(): ChartTextStyle | null;
+  /**
+   * The language the chart's text is tagged with: `c:lang`, which PowerPoint writes, else the first
+   * paragraph end's `@lang` in the part, where `addChart` writes its `lang`. `null` when neither says.
+   */
+  get language(): string | null;
   /**
    * The chart-level data-label settings, read from the first plot group's
    * aggregate `c:dLbls` (the group-wide block after the series). `null` when the
@@ -1851,6 +2312,23 @@ declare class Chart {
    * {@link ChartSeries.dataLabels}.
    */
   get dataLabels(): ChartDataLabels | null;
+  /** The data table under the plot (`c:plotArea/c:dTable`), or `null` when the chart draws none. */
+  get dataTable(): ChartDataTable | null;
+  /**
+   * The key/value annotations `addChart`'s `metadata` option writes: the pptx-ts extension on
+   * `c:chartSpace/c:extLst` (uri `{094A432E-1F6C-499B-95B8-B57DC9536949}`). `null` when the chart
+   * carries no such extension; an extension with no item reads as an empty map.
+   */
+  get metadata(): Record<string, string> | null;
+  /**
+   * The plot groups (`c:barChart`, `c:lineChart`, …) of the plot area, in document order, each
+   * with what it sets on all its series and the series it plots. A combo chart has several.
+   */
+  get plotGroups(): ChartPlotGroup[];
+  /** The 3-D view (`c:chart/c:view3D`), or `null` when the chart states none. */
+  get view3D(): ChartView3D | null;
+  /** How blank cells plot (`c:chart/c:dispBlanksAs`): `gap`, `zero` or `span`, or `null` when unstated. */
+  get displayBlanksAs(): string | null;
   /** The data series (`c:ser`) across all chart groups, in document order. */
   get series(): ChartSeries[];
   /**
@@ -1865,6 +2343,60 @@ declare class Chart {
   /** Mark the chart part dirty so `save()` reserializes it. Call after mutating {@link element_}. */
   markDirty(): void;
 }
+/**
+ * One plot group of a chart's plot area (`c:barChart`, `c:lineChart`, `c:pieChart`, …): the series
+ * it plots and what it sets on all of them. Each accessor reads `null` (or `false` for an element
+ * that is either there or not) where the group does not state it, including on a plot type whose
+ * schema has no such element.
+ */
+declare class ChartPlotGroup {
+  #private;
+  private readonly group;
+  /** The owning chart's OPC part, so {@link markDirty} can reach it from {@link element_}. */
+  private readonly part;
+  constructor(group: Element,
+  /** The owning chart's OPC part, so {@link markDirty} can reach it from {@link element_}. */
+  part: Part);
+  /** The plot type, the element's local name less `Chart`: `bar`, `line`, `bar3D`, `doughnut`, … */
+  get type(): string;
+  /** The series this group plots (`c:ser`), in document order. */
+  get series(): ChartSeries[];
+  /**
+   * The ids of the axes this group plots against (`c:axId`), as {@link ChartAxis.id} reads them: a
+   * combo's group on the secondary axes names the secondary pair. Empty for a pie or a doughnut.
+   */
+  get axisIds(): number[];
+  /** A bar group's direction (`c:barDir`): `bar` (horizontal) or `col` (vertical). */
+  get barDirection(): string | null;
+  /** How the series stack (`c:grouping`): `clustered`, `stacked`, `percentStacked` or `standard`. */
+  get grouping(): string | null;
+  /** The gap between bar clusters as a percentage of a bar's width (`c:gapWidth`). */
+  get gapWidthPct(): number | null;
+  /** How far bars in a cluster overlap, -100 to 100 percent (`c:overlap`). */
+  get overlapPct(): number | null;
+  /** Whether stacked bars are joined by series lines (`c:serLines`). */
+  get seriesLines(): boolean;
+  /** The series lines' stroke (`c:serLines/c:spPr/a:ln`), or `null` when they state none. */
+  get seriesLinesLine(): ChartLine | null;
+  /** The depth gap of a 3-D bar group, as a percentage (`c:gapDepth`). */
+  get gapDepthPct(): number | null;
+  /** The group-wide 3-D bar shape (`c:shape`); a series can state its own ({@link ChartSeries.shape}). */
+  get shape(): string | null;
+  /** The angle of a pie's first slice, 0 to 360 degrees (`c:firstSliceAng`). */
+  get firstSliceAngle(): number | null;
+  /** A doughnut's hole, 10 to 90 percent of its size (`c:holeSize`). */
+  get holeSizePct(): number | null;
+  /** A radar's style (`c:radarStyle`): `standard`, `marker` or `filled`. */
+  get radarStyle(): string | null;
+  /** Whether a surface is drawn as a wireframe (`c:wireframe`). */
+  get wireframe(): boolean | null;
+  /** Whether a line or stock group draws up/down bars (`c:upDownBars`). */
+  get upDownBars(): boolean;
+  /** Escape hatch: the underlying plot-group element. After mutating it call {@link markDirty}, or `save()` writes the original bytes. */
+  get element_(): Element;
+  /** Mark the owning chart part dirty so `save()` reserializes it. Call after mutating {@link element_}. */
+  markDirty(): void;
+}
 /**
  * One axis (`c:catAx`/`c:valAx`/`c:dateAx`/`c:serAx`) of a chart's plot area.
  * All four share the scaling/delete/position/tickmark structure; `kind`
@@ -1912,6 +2444,32 @@ declare class ChartAxis {
   get majorUnit(): number | null;
   /** Minor unit (`c:minorUnit/@val`), or `null` when auto. */
   get minorUnit(): number | null;
+  /** The tick labels' text formatting and rotation (`c:txPr`), or `null` when the axis states none. */
+  get labelStyle(): ChartTextStyle | null;
+  /** The axis title's formatting (`c:title/c:tx/c:rich`), or `null` when it has no rich title. */
+  get titleStyle(): ChartTextStyle | null;
+  /** Where this axis crosses the other one, as a value on it (`c:crossesAt`), or `null`. */
+  get crossesAt(): number | null;
+  /** Where this axis crosses the other one, as a rule (`c:crosses`: `autoZero`, `max`, `min`), or `null`. */
+  get crosses(): string | null;
+  /** Whether a value axis crosses between categories or on them (`c:crossBetween`: `between`, `midCat`). */
+  get crossBetween(): string | null;
+  /** A value axis' display units (`c:dispUnits`), or `null` when it shows plain values. */
+  get displayUnits(): ChartDisplayUnits | null;
+  /** How many categories pass between two labels (`c:tickLblSkip`), or `null` when automatic. */
+  get labelSkip(): number | null;
+  /** Whether a category axis flattens a multi-level category list (`c:noMultiLvlLbl`), or `null` when unstated. */
+  get noMultiLevelLabels(): boolean | null;
+  /** A date axis' base unit (`c:baseTimeUnit`: `days`, `months`, `years`), or `null`. */
+  get baseTimeUnit(): string | null;
+  /** A date axis' major unit scale (`c:majorTimeUnit`), or `null`. */
+  get majorTimeUnit(): string | null;
+  /** A date axis' minor unit scale (`c:minorTimeUnit`), or `null`. */
+  get minorTimeUnit(): string | null;
+  /** The axis line's own stroke (`c:spPr/a:ln`), or `null` when it states none. */
+  get line(): ChartLine | null;
+  /** The major gridlines' stroke (`c:majorGridlines/c:spPr/a:ln`), or `null` when they state none. */
+  get majorGridlinesLine(): ChartLine | null;
   /** Escape hatch: the underlying axis element. After mutating it call {@link markDirty}, or `save()` writes the original bytes. */
   get element_(): Element;
   /** Mark the owning chart part dirty so `save()` reserializes it. Call after mutating {@link element_}. */
@@ -1932,7 +2490,7 @@ declare class ChartSeries {
    */
   get fill(): ChartFill | null;
   /**
-   * Series line/stroke (`c:spPr/a:ln`) — width, dash, colour. `null` when the
+   * Series line/stroke (`c:spPr/a:ln`): width, dash, colour. `null` when the
    * series `c:spPr` has no `a:ln` (bar/area fills carry no line by default).
    */
   get line(): ChartLine | null;
@@ -1963,6 +2521,12 @@ declare class ChartSeries {
   get xLabels(): (string | null)[] | null;
   /** Cached Y values of a scatter or bubble series (`c:yVal`); non-numeric or missing points are `null`. */
   get yValues(): (number | null)[];
+  /**
+   * The number format the series' values are cached in (`c:numCache/c:formatCode` under `c:val`, or
+   * under `c:yVal` on a scatter or bubble series), or `null` when the cache states none. PowerPoint
+   * paints a source-linked data label and a data table in it.
+   */
+  get valueFormatCode(): string | null;
   /** Cached bubble sizes of a bubble series (`c:bubbleSize`); non-numeric or missing points are `null`. */
   get bubbleSizes(): (number | null)[];
   /**
@@ -1983,14 +2547,38 @@ declare class ChartSeries {
    * none. This is where a pie's labels are: see {@link Chart.dataLabels}.
    */
   get dataLabels(): ChartDataLabels | null;
+  /**
+   * The series' labels that state their own text (`c:ser/c:dLbls/c:dLbl` with `c:tx/c:rich`), in
+   * document order. A label that only formats or deletes its point has no text and is left out.
+   */
+  get customLabels(): ChartPointLabel[];
+  /** The series' gradient fill (`c:spPr/a:gradFill`), or `null`. */
+  get gradientFill(): GradientFill | null;
+  /** The series' pattern fill (`c:spPr/a:pattFill`), or `null`. */
+  get patternFill(): PatternFill | null;
+  /** The series' outer shadow (`c:spPr/a:effectLst/a:outerShdw`), or `null`. */
+  get shadow(): OuterShadow | null;
+  /** The series' inner shadow (`c:spPr/a:effectLst/a:innerShdw`), or `null`. */
+  get innerShadow(): InnerShadow | null;
+  /** Whether a line or scatter series is smoothed (`c:smooth`), or `null` when unstated. */
+  get smooth(): boolean | null;
+  /** The series' data-point marker (`c:marker`), or `null` when it states none. */
+  get marker(): ChartMarker | null;
+  /**
+   * The points this series formats on its own (`c:dPt`), in document order: a bar's per-point
+   * colours, a pie's slice colours. A `c:dPt` with no `c:idx` is left out.
+   */
+  get dataPoints(): ChartDataPoint[];
+  /** Whether a bar series paints a negative bar inverted (`c:invertIfNegative`), or `null` when unstated. */
+  get invertIfNegative(): boolean | null;
+  /** A 3-D bar series' own shape (`c:shape`: `box`, `cylinder`, `cone`, …), or `null` when unstated. */
+  get shape(): string | null;
   /** Escape hatch: the underlying `c:ser` element. After mutating it call {@link markDirty}, or `save()` writes the original bytes. */
   get element_(): Element;
   /** Mark the owning chart part dirty so `save()` reserializes it. Call after mutating {@link element_}. */
   markDirty(): void;
 }
-//#endregion
-//#region src/read/api/chartex.d.ts
-/** A chartEx legend (`cx:legend`) — a leaf element carrying position/alignment attributes. */
+/** A chartEx legend (`cx:legend`): a leaf element carrying position/alignment attributes. */
 interface ChartExLegend {
   /** Legend position (`@pos`): `t`/`b`/`l`/`r`. */
   position: string | null;
@@ -2021,7 +2609,7 @@ declare class ChartEx {
   /** Partname of the chartEx chart part. */
   get partName(): string;
   /**
-   * The `cx:series/@layoutId` tokens in plot-area document order — the raw chartEx
+   * The `cx:series/@layoutId` tokens in plot-area document order: the raw chartEx
    * layout names (`waterfall`, `funnel`, `treemap`, `sunburst`, `boxWhisker`,
    * `regionMap`, or `clusteredColumn`/`paretoLine` for histogram & pareto). This is
    * the OOXML truth: a histogram and a pareto both surface as `clusteredColumn`, so
@@ -2074,7 +2662,7 @@ declare class ChartExSeries {
   /** Cached numeric values (`cx:numDim`); non-numeric or missing points are `null`. */
   get values(): (number | null)[];
   /**
-   * Cached category labels (`cx:strDim`'s leaf `cx:lvl` — the first level, which
+   * Cached category labels (`cx:strDim`'s leaf `cx:lvl`, the first level, which
    * the writer emits leaf-first). Empty when the data block carries no `cx:strDim`.
    */
   get categories(): (string | null)[];
@@ -2119,27 +2707,25 @@ declare class ChartExAxis {
   /** Mark the owning chartEx part dirty so `save()` reserializes it. Call after mutating {@link element_}. */
   markDirty(): void;
 }
-//#endregion
-//#region src/read/api/diagram.d.ts
 /**
- * `ST_PtType` — what a `dgm:pt` is.
+ * `ST_PtType`: what a `dgm:pt` is.
  *
- * - `node` — a user-authored node, and the default when `@type` is absent.
- * - `asst` — an assistant node (an org chart's off-branch box); user content too.
- * - `doc` — the data model's single root; carries the layout/style/colour preset ids.
- * - `pres` — generated by the layout engine to position a node; never user content.
- * - `parTrans` / `sibTrans` — the two transition points of an edge, which a few layouts
+ * - `node`: a user-authored node, and the default when `@type` is absent.
+ * - `asst`: an assistant node (an org chart's off-branch box); user content too.
+ * - `doc`: the data model's single root; carries the layout/style/colour preset ids.
+ * - `pres`: generated by the layout engine to position a node; never user content.
+ * - `parTrans` / `sibTrans`: the two transition points of an edge, which a few layouts
  *   (arrow processes, org-chart branches) let the user type a label into.
  */
 type DiagramPointType = 'node' | 'asst' | 'doc' | 'pres' | 'parTrans' | 'sibTrans';
 /**
- * `ST_CxnType` — what a `dgm:cxn` asserts. `parOf` (the default) is the parent/child edge of
+ * `ST_CxnType`: what a `dgm:cxn` asserts. `parOf` (the default) is the parent/child edge of
  * the user's tree; `presOf` and `presParOf` bind a node to the generated `pres` point that
  * draws it, and are the layout engine's bookkeeping rather than structure.
  */
 type DiagramConnectionType = 'parOf' | 'presOf' | 'presParOf' | 'unknownRelationship';
 /**
- * One edge of a diagram's data model (`dgm:cxn`) — an attribute-only element, so it reads as
+ * One edge of a diagram's data model (`dgm:cxn`): an attribute-only element, so it reads as
  * plain data rather than as a proxy.
  *
  * The ids are `ST_ModelId` GUIDs matching a {@link DiagramPoint.modelId}. `parOf` edges are
@@ -2151,9 +2737,9 @@ interface DiagramConnection {
   modelId: string | null;
   /** What the edge asserts (`@type`); `parOf` when absent, its schema default. */
   type: DiagramConnectionType;
-  /** The `@srcId` end — the parent, for a `parOf` edge. */
+  /** The `@srcId` end: the parent, for a `parOf` edge. */
   sourceId: string | null;
-  /** The `@destId` end — the child, for a `parOf` edge. */
+  /** The `@destId` end: the child, for a `parOf` edge. */
   destinationId: string | null;
   /** The child's index among its siblings (`@srcOrd`). */
   sourceOrder: number | null;
@@ -2167,14 +2753,14 @@ interface DiagramConnection {
   presentationId: string | null;
 }
 /**
- * Where a point's text is drawn in the fallback drawing part — the second copy of every
+ * Where a point's text is drawn in the fallback drawing part: the second copy of every
  * string a diagram carries, and the only one a renderer without a SmartArt layout engine
  * paints. See {@link DiagramPoint.drawnShape} for how a point reaches it.
  */
 interface DiagramDrawnShape {
   /** The drawing part (`/ppt/diagrams/drawing{N}.xml`) the shape lives in. */
   readonly part: Part;
-  /** The `pres` point this shape draws (`dsp:sp/@modelId`) — never the authored point's own id. */
+  /** The `pres` point this shape draws (`dsp:sp/@modelId`), never the authored point's own id. */
   readonly modelId: string;
   /** Which paragraph of {@link textFrame} carries this point's text (the `presOf` edge's `@destOrd`). */
   readonly paragraphIndex: number;
@@ -2182,7 +2768,7 @@ interface DiagramDrawnShape {
    * The shape's `dsp:txBody`, bound to the **drawing** part rather than the data part, so
    * an edit made through it marks the part that actually changed.
    *
-   * One shape commonly draws several points — three of them in `mixed.pptx` — so writing
+   * One shape commonly draws several points (three of them in `mixed.pptx`), so writing
    * `textFrame.text` here would delete the siblings' text. Replace paragraph
    * {@link paragraphIndex} instead, which is what {@link DiagramPoint.text}'s setter does.
    */
@@ -2194,7 +2780,7 @@ interface DiagramDrawnShape {
  * The node → drawn-shape index of one diagram: the `presOf` edges of the data model and the
  * `dsp:sp` elements of the drawing part, both keyed for lookup.
  *
- * Built once per {@link Diagram}, and only when a point is actually asked what draws it — the
+ * Built once per {@link Diagram}, and only when a point is actually asked what draws it. The
  * drawing part is a second XML DOM and a consumer reading node text should not pay to parse
  * it. The consequence of that memo: a consumer who *adds* or *removes* shapes in the drawing
  * part through the escape hatches must re-reach the diagram to see them here.
@@ -2222,8 +2808,8 @@ declare class DrawingIndex {
    * Resolve one authored point to the `pres` point that presents it and to the drawn
    * paragraph carrying its text.
    *
-   * A point commonly has **several** `presOf` arms — an org-chart node's box and the
-   * connector beneath it are two presentations of one node — so the arm is chosen by what it
+   * A point commonly has **several** `presOf` arms (an org-chart node's box and the
+   * connector beneath it are two presentations of one node), so the arm is chosen by what it
    * reaches rather than by its `@srcOrd`: the first, in `@srcOrd` order, whose `pres` point
    * draws a `dsp:sp` that has a `dsp:txBody`. That selector produced a unique hit for all 90
    * authored points measured across five layout families, and it degrades to "no arm" rather
@@ -2259,7 +2845,7 @@ declare class DiagramPoint {
    */
   get connectionId(): string | null;
   /**
-   * Whether this point is an unfilled prompt (`dgm:prSet/@phldr`) — a node PowerPoint draws
+   * Whether this point is an unfilled prompt (`dgm:prSet/@phldr`): a node PowerPoint draws
    * with a grey placeholder string and treats as empty. Excluded from {@link Diagram.text}:
    * a layout that stores its prompt in `dgm:t` would otherwise extract as content.
    */
@@ -2272,14 +2858,14 @@ declare class DiagramPoint {
    * `resolved*` getters all apply.
    *
    * **Writing through this edits the data model only**, and leaves the drawing cache
-   * holding the old string — which is what PowerPoint-less renderers draw. It is the escape
+   * holding the old string, which is what PowerPoint-less renderers draw. It is the escape
    * hatch for run-level formatting, so it does exactly what it is told and nothing more;
    * {@link text}'s setter is the path that mirrors.
    */
   get textFrame(): TextFrame | null;
   /**
    * The generated `pres` point that presents this one (`dgm:cxn[@type="presOf"]/@destId`),
-   * or `null` when nothing presents it — the normal state of an unlabelled transition point.
+   * or `null` when nothing presents it (the normal state of an unlabelled transition point).
    *
    * Where a point has several `presOf` arms the one named here is the arm that draws text;
    * see {@link drawnShape}, which resolves both.
@@ -2291,7 +2877,7 @@ declare class DiagramPoint {
    *
    * The mapping runs through the `pres` point rather than directly: a `dsp:sp/@modelId` is
    * always a `pres` point's id, so a lookup keyed on the authored point's own id finds
-   * nothing at all. It is many-to-one in both directions — one shape draws several points
+   * nothing at all. It is many-to-one in both directions: one shape draws several points
    * (`@destOrd` says which paragraph is whose, and it can contradict document order), and
    * one point has several presentations, of which at most one holds text.
    *
@@ -2321,7 +2907,7 @@ declare class DiagramPoint {
    * Two things it deliberately does not do. It does **not** recompute geometry: the drawn
    * shape keeps its cached position and size, so a much longer string overflows its box in
    * those same renderers until PowerPoint re-lays the diagram out. And it does not *create*
-   * a place to draw text — a transition point whose layout has no label slot has no
+   * a place to draw text. A transition point whose layout has no label slot has no
    * `dsp:sp`, and PowerPoint strips text put on one, so the honest outcome is the
    * diagnostic. Like every other `text` setter here it collapses the point to one run,
    * keeping the first run's `a:rPr`; use {@link textFrame} for run-level work.
@@ -2331,7 +2917,7 @@ declare class DiagramPoint {
   get element_(): Element;
 }
 /**
- * One user-authored point in its place in the diagram's tree — a `node` or an `asst`, never a
+ * One user-authored point in its place in the diagram's tree: a `node` or an `asst`, never a
  * generated `pres` point or a transition label. See {@link Diagram.nodes}.
  */
 declare class DiagramNode {
@@ -2359,7 +2945,7 @@ declare class Diagram {
   /** The frame's `dgm:relIds`, which names the other three parts by relationship id. */
   private readonly relIds;
   private readonly opc;
-  /** Relationships of the part holding the frame — what `dgm:relIds` resolves against. */
+  /** Relationships of the part holding the frame, which is what `dgm:relIds` resolves against. */
   private readonly frameRelationships;
   private readonly themeContext;
   constructor(
@@ -2367,12 +2953,12 @@ declare class Diagram {
   part: Part,
   /** The frame's `dgm:relIds`, which names the other three parts by relationship id. */
   relIds: Element, opc: OpcPackage,
-  /** Relationships of the part holding the frame — what `dgm:relIds` resolves against. */
+  /** Relationships of the part holding the frame, which is what `dgm:relIds` resolves against. */
   frameRelationships: Relationships, themeContext: ThemeContext);
   /** Partname of the diagram data part. */
   get partName(): string;
   /**
-   * Every point (`dgm:ptLst/dgm:pt`) in document order, unfiltered — generated `pres`
+   * Every point (`dgm:ptLst/dgm:pt`) in document order, unfiltered, with generated `pres`
    * points and the `doc` root included. Filter on {@link DiagramPoint.type} for the user's
    * nodes; {@link text} is the shortcut for the common case, {@link nodes} the structured one.
    *
@@ -2382,8 +2968,8 @@ declare class Diagram {
    */
   get points(): DiagramPoint[];
   /**
-   * The authored tree — every `node` and `asst` point in its place, roots in `@srcOrd`
-   * order — as a view over {@link points} and {@link connections} rather than a replacement
+   * The authored tree (every `node` and `asst` point in its place, roots in `@srcOrd`
+   * order) as a view over {@link points} and {@link connections} rather than a replacement
    * for either.
    *
    * A root is a content point whose `parOf` parent is not itself content, which in a
@@ -2395,14 +2981,15 @@ declare class Diagram {
    */
   get nodes(): DiagramNode[];
   /**
-   * The point with this `@modelId`, or `null` — the lookup every connection getter implies,
-   * since a `DiagramConnection` names its ends by id and nothing else resolves them.
+   * The point with this `@modelId`, or `null`. This is the lookup every connection getter implies,
+   * since a `DiagramConnection` names its ends by id and nothing else resolves them. Takes
+   * `null`, as a connection end with no id reads, and misses on it.
    */
-  point(modelId: string): DiagramPoint | null;
+  point(modelId: string | null): DiagramPoint | null;
   /** Every edge (`dgm:cxnLst/dgm:cxn`) in document order. */
   get connections(): DiagramConnection[];
   /**
-   * The diagram's text in document order, blocks joined by `\n` — the counterpart to
+   * The diagram's text in document order, blocks joined by `\n`: the counterpart to
    * `TextFrame.text` for a construct that has no single text body.
    *
    * Contributing points are the ones a user can type into: everything except the generated
@@ -2439,8 +3026,6 @@ declare class Diagram {
   /** Mark the diagram data part dirty so `save()` reserializes it. Call after mutating {@link element_}. */
   markDirty(): void;
 }
-//#endregion
-//#region src/read/api/table-edit.d.ts
 /** The four edges plus the two diagonals, keyed as {@link TableCellEdge} names them. */
 declare const EDGE_QNAMES: {
   readonly left: 'a:lnL';
@@ -2452,10 +3037,8 @@ declare const EDGE_QNAMES: {
 };
 /** Which border of a cell an edit addresses. */
 type TableCellEdge = keyof typeof EDGE_QNAMES;
-//#endregion
-//#region src/read/api/table-cell.d.ts
 /**
- * One border as {@link TableCell.setBorder} takes it — the write-side mirror of
+ * One border as {@link TableCell.setBorder} takes it: the write-side mirror of
  * {@link CellBorder}, which is what reading one gives back.
  *
  * Deliberately not `CellBorder` itself: that type reports every field, `null` included, so
@@ -2471,7 +3054,7 @@ interface TableCellBorderEdit {
   color?: string;
   /** Theme colour token (e.g. `accent1`); preferred over {@link color} when both are set. */
   schemeColor?: string;
-  /** Write an explicit `a:noFill` — a deliberately suppressed edge, not an absent one. */
+  /** Write an explicit `a:noFill`: a deliberately suppressed edge, not an absent one. */
   noFill?: boolean;
 }
 /**
@@ -2491,7 +3074,7 @@ interface TableCellStyleContext {
  * One edge border of a table cell (`a:tcPr/a:lnL|lnR|lnT|lnB|lnTlToBr|lnBlToTr`).
  * Mirrors the `a:ln`-style decode used for shape strokes: {@link widthPt} from
  * `@w` (EMU → points), {@link dash} from `a:prstDash/@val`, and the stroke colour as a
- * {@link ColorRef} — the cell-border counterpart of a shape's line accessors.
+ * {@link ColorRef}. This is the cell-border counterpart of a shape's line accessors.
  */
 interface CellBorder {
   /** Border width in points (`@w` is EMU; 12700 EMU = 1pt), or `null` when unset. */
@@ -2505,8 +3088,14 @@ interface CellBorder {
    * theme: a `lumMod`-darkened accent carried forward as a literal hex stops tracking its theme.
    */
   colorRef: ColorRef;
-  /** `true` when the edge is an explicit no-border (`a:noFill`) — a deliberately suppressed side. */
+  /** `true` when the edge is an explicit no-border (`a:noFill`): a deliberately suppressed side. */
   noFill: boolean;
+  /**
+   * The line end cap (`@cap`) as the raw OOXML token (`flat`, `rnd`, `sq`), or `null` when unset.
+   * PowerPoint writes `flat` on every edge it draws; the write side's `BorderProps.cap` is the
+   * same attribute.
+   */
+  cap: string | null;
 }
 /**
  * A table cell's six possible borders, keyed by edge. Each side is `null` when the
@@ -2605,7 +3194,7 @@ declare class TableCell {
    */
   setVerticalText(value: string | null): void;
   /**
-   * Set (or clear) `a:tcPr/@horzOverflow` — what a single glyph too wide for the cell does.
+   * Set (or clear) `a:tcPr/@horzOverflow`: what a single glyph too wide for the cell does.
    * `null` removes the attribute; so does `'clip'` in effect, since it is the schema
    * default, but the attribute is still written as asked.
    * @throws {InvalidOptionError} when the value is outside `ST_TextHorzOverflowType`
@@ -2622,7 +3211,7 @@ declare class TableCell {
    *
    * Partial: only the sides named are touched, so `{ left: 0 }` flushes the text left and
    * leaves the other three alone. A side given as `null` has its attribute removed, which
-   * returns it to the schema default (91440 EMU left/right, 45720 top/bottom) — not to
+   * returns it to the schema default (91440 EMU left/right, 45720 top/bottom), not to
    * zero. Pass `{}` to change nothing.
    * @throws {InvalidOptionError} when a value is not a finite number
    */
@@ -2633,7 +3222,7 @@ declare class TableCell {
     bottom?: number | null;
   }): void;
   /**
-   * Set (or clear) one of the cell's six borders — the four edges and the two diagonals.
+   * Set (or clear) one of the cell's six borders: the four edges and the two diagonals.
    *
    * `null` removes the element entirely, which is "inherit", and is a different thing from
    * `{ noFill: true }`, which writes an explicit no-border and suppresses whatever would
@@ -2652,7 +3241,7 @@ declare class TableCell {
    * `null` removes the `a:solidFill` and lets the cell inherit from the table style again.
    * That is not the same as {@link noFill}, which writes an explicit `a:noFill` and so
    * suppresses the inherited shading. Any competing fill choice (`a:gradFill`,
-   * `a:blipFill`, …) is dropped first — `EG_FillProperties` admits one.
+   * `a:blipFill`, …) is dropped first, since `EG_FillProperties` admits one.
    * @throws {InvalidOptionError} when `color` is not a 6-digit hex string
    */
   setFillColor(color: string | null): void;
@@ -2663,30 +3252,30 @@ declare class TableCell {
    */
   setFillSchemeColor(token: string | null): void;
   /**
-   * Write an explicit `<a:noFill/>` on the cell — a transparent cell that shows the table
+   * Write an explicit `<a:noFill/>` on the cell: a transparent cell that shows the table
    * background (or the slide) through. Distinct from `setFillColor(null)`, which removes
    * the fill and lets the table style's shading apply again.
    */
   noFill(): void;
   /**
    * The cell's solid fill resolved against the table's theme colour context to a
-   * literal hex — the table-cell counterpart of
+   * literal hex. It is the table-cell counterpart of
    * {@link AutoShape.resolvedFill}. The cell's own
    * `a:tcPr/a:solidFill` wins; when the cell defines none, this falls back to the
    * table **style** graph (the `firstRow`/banded/`wholeTbl` shading the
-   * `a:tableStyleId` supplies — see {@link Table.resolvedStyle}), so a styled cell
+   * `a:tableStyleId` supplies; see {@link Table.resolvedStyle}), so a styled cell
    * with an empty `a:tcPr` reports the colour PowerPoint actually renders rather
    * than `null`.
    *
    * A cell that carries *some other* fill choice (`a:blipFill`/`a:gradFill`/
    * `a:pattFill`/`a:noFill`) overrides the style graph in PowerPoint, so this
-   * reports `null` for one rather than falling through to the inherited shading —
+   * reports `null` for one rather than falling through to the inherited shading,
    * the same guard {@link AutoShape.resolvedFill} applies to
    * the style matrix. Read {@link pictureFill} for an image-filled cell. Also
    * `null` when neither source yields a solid colour (an
    * unmapped token, an explicit style `a:noFill`). The returned
    * {@link ResolvedColor} carries `effectiveHex` (the base colour with its
-   * `lumMod`/`lumOff`/… transforms applied) — read that for the final colour.
+   * `lumMod`/`lumOff`/… transforms applied); read that for the final colour.
    */
   get resolvedFill(): ResolvedColor | null;
   /**
@@ -2694,7 +3283,7 @@ declare class TableCell {
    * child), as opposed to inheriting one from the table style's header/banding rules.
    *
    * This is the flag that disambiguates {@link resolvedFill}, which deliberately reports
-   * either — it answers "what colour does this cell render as", and both sources are valid
+   * either: it answers "what colour does this cell render as", and both sources are valid
    * answers to that. Anything that has to reproduce the cell rather than describe it needs
    * to know which: baking an inherited banding colour into a copy makes the copy look right
    * until someone changes its table style, and then nothing moves. `false` for a cell whose
@@ -2702,20 +3291,20 @@ declare class TableCell {
    */
   get hasOwnFill(): boolean;
   /**
-   * `true` when the cell sets an explicit no-fill (`a:tcPr/a:noFill`) — a deliberately
+   * `true` when the cell sets an explicit no-fill (`a:tcPr/a:noFill`): a deliberately
    * transparent cell showing the table background (or the slide) through. The cell-side
    * counterpart of {@link AutoShape.fillNoFill}, and what
    * {@link noFill} writes.
    *
    * {@link hasOwnFill} is not this question: it is `true` for *any* `EG_FillProperties`
    * child, so on its own it cannot separate a suppressed fill from a gradient or an image
-   * one — and every colour accessor ({@link resolvedFill}, {@link fillSchemeColor})
+   * one, and every colour accessor ({@link resolvedFill}, {@link fillSchemeColor})
    * reports `null` for a no-fill cell exactly as it does for a
    * cell that inherits its shading from the table style. Deriving it as "has a fill of its
    * own, and no accessor recognises it" instead of reading it has two failure modes: it
    * folds `a:grpFill` in with `a:noFill`, and its meaning changes silently the day a
-   * further fill kind gets an accessor. The two paint completely differently — an
-   * inherited banding colour versus nothing at all — so a consumer that cannot tell them
+   * further fill kind gets an accessor. The two paint completely differently (an
+   * inherited banding colour versus nothing at all), so a consumer that cannot tell them
    * apart paints a transparent cell in the style's shading.
    */
   get fillNoFill(): boolean;
@@ -2753,7 +3342,7 @@ declare class TableCell {
    * `null` when the cell defines none. Each present edge decodes to a
    * {@link CellBorder} (width / dash / resolved colour + its raw token and transform
    * list / suppressed flag);
-   * absent edges are `null`. Cell borders are the biggest visible table gap — a
+   * absent edges are `null`. Cell borders are the biggest visible table gap: a
    * replica built only from geometry and fill draws every cell edge-to-edge with
    * no rule, so this surfaces the per-side stroke the writer's `border` option emits.
    */
@@ -2770,7 +3359,7 @@ declare class TableCell {
   get anchor(): string | null;
   /**
    * Whether the cell's whole text **block** is centred horizontally within it
-   * (`a:tcPr/@anchorCtr`). `false` when unset — that is the schema default, and it is
+   * (`a:tcPr/@anchorCtr`). `false` when unset; that is the schema default, and it is
    * what PowerPoint writes nothing for.
    *
    * Distinct from a paragraph's `align`, which decides where each *line* sits inside the
@@ -2790,19 +3379,19 @@ declare class TableCell {
    *
    * This is what {@link headerIds} references: a data cell names the header cells that
    * govern it by their `@id`, which is how a complex table tells a screen reader what a
-   * value means. Unrelated to the shape-level `p:cNvPr/@id` — it is an `xs:string` scoped
+   * value means. Unrelated to the shape-level `p:cNvPr/@id`: it is an `xs:string` scoped
    * to the table, not a slide-wide numeric id.
    *
    * **PowerPoint does not write this and strips it on save**, so it will read `null` on
    * any deck PowerPoint has saved, however it was produced. It is surfaced for decks from
-   * other producers. There is deliberately no write-API counterpart — see
+   * other producers. There is deliberately no write-API counterpart; see
    * `test/read/fixtures/authoring/probe-table-cell-a11y-and-3d.ps1` for the measurement.
    */
   get id(): string | null;
   /**
    * The `@id`s of the header cells that govern this cell
    * (`a:tcPr/a:headers/a:header/@val`), in document order. Empty when the cell declares no
-   * header association — which is the common case, since only a complex table needs one.
+   * header association, which is the common case, since only a complex table needs one.
    *
    * Carries the same caveat as {@link id}: PowerPoint strips `a:headers` on save, so this
    * is empty on any PowerPoint-saved deck. `Table.firstRowHeader` (`a:tblPr/@firstRow`) is
@@ -2812,7 +3401,7 @@ declare class TableCell {
   /**
    * How the cell treats a glyph too wide for its text width (`a:tcPr/@horzOverflow`):
    * `'clip'` cuts it at the cell edge, `'overflow'` lets it draw past. `null` when unset
-   * (PowerPoint clips). Not a wrap flag — cell text always wraps to the column width.
+   * (PowerPoint clips). Not a wrap flag: cell text always wraps to the column width.
    */
   get horzOverflow(): string | null;
   /**
@@ -2836,8 +3425,6 @@ declare class TableCell {
   /** Mark the owning part dirty so `save()` reserializes it. Call after mutating {@link element_}. */
   markDirty(): void;
 }
-//#endregion
-//#region src/read/api/table-row.d.ts
 /** One table row (`a:tr`). */
 declare class TableRow {
   private readonly tr;
@@ -2868,8 +3455,6 @@ declare class TableRow {
   /** Mark the owning part dirty so `save()` reserializes it. Call after mutating {@link element_}. */
   markDirty(): void;
 }
-//#endregion
-//#region src/read/api/table.d.ts
 /** A table: a grid of rows and cells inside a graphic frame. */
 declare class Table {
   #private;
@@ -2895,7 +3480,7 @@ declare class Table {
    * from the deck's `tableStyles.xml`, or `null` when the table names no
    * `a:tableStyleId`, the deck has no `tableStyles.xml`, or the id is a built-in
    * `[MS-OE376]` style the deck does not materialise. This is what supplies the
-   * banded-row / header shading a cell with no own fill inherits — read the
+   * banded-row / header shading a cell with no own fill inherits. Read the
    * resolved per-cell colour off {@link TableCell.resolvedFill}.
    *
    * Resolved afresh on every read, not through the per-instance memo the cells share, so an
@@ -2914,7 +3499,7 @@ declare class Table {
    * `{5940675A-B579-460E-94D1-54222C63F5DA}`, or `null` when the table carries no
    * `a:tableStyleId`. This is the reference into `ppt/tableStyles.xml` (or a
    * built-in `[MS-OE376]` style) that supplies the banded-row / header shading the
-   * `firstRow`/`bandRow` flags activate — without it a replica loses the whole
+   * `firstRow`/`bandRow` flags activate. Without it a replica loses the whole
    * table style, so it is the read counterpart of the writer's `tableStyle` option.
    */
   get styleId(): string | null;
@@ -2925,7 +3510,7 @@ declare class Table {
    * This is the table-level counterpart of {@link TableCell.resolvedFill}, and it is a
    * genuinely different thing from a cell fill: a `a:tblPr` fill sits *behind* the grid, so
    * a cell with no fill of its own shows it through. Reports `null` for a non-solid choice
-   * (`a:blipFill`/`a:gradFill`/`a:pattFill`/`a:noFill`) — read {@link pictureFill} for an
+   * (`a:blipFill`/`a:gradFill`/`a:pattFill`/`a:noFill`); read {@link pictureFill} for an
    * image background.
    */
   get resolvedFill(): ResolvedColor | null;
@@ -2975,6 +3560,11 @@ declare class Table {
   get firstColumnHeader(): boolean;
   /** Whether the last column is emphasised (`a:tblPr/@lastCol`), from `addTable`'s `hasLastColumn`. */
   get lastColumnFooter(): boolean;
+  /**
+   * Whether the table reads right to left (`a:tblPr/@rtl`), from `addTable`'s `rtl`: its columns
+   * run from the right edge, so column 0 is the rightmost.
+   */
+  get rtl(): boolean;
   /**
    * The cell at `(rowIndex, columnIndex)` (both zero-based), or `null` when out
    * of range. Column index counts `a:tc` elements in the row, so a cell that
@@ -2996,7 +3586,7 @@ declare class Table {
    * Remove the row at `index`, with its content.
    *
    * A cell in the row that *continues* a vertical merge shortens that merge. A cell that
-   * *starts* one hands the region to its first continuation, which becomes the new origin —
+   * *starts* one hands the region to its first continuation, which becomes the new origin:
    * the merged region survives one row shorter, and only the removed row's own text is lost.
    * @throws {InvalidOptionError} when `index` is out of range
    */
@@ -3026,7 +3616,7 @@ declare class Table {
    * never rendered.
    *
    * A rectangle that cuts through an existing merge is **rejected**, not silently widened
-   * to fit — the caller asked for a specific region, and quietly producing a different one
+   * to fit. The caller asked for a specific region, and quietly producing a different one
    * is how a layout ends up wrong with nothing to point at. Unmerge first.
    * @throws {InvalidOptionError} when an index is out of range, the range covers one cell,
    *   or it partially overlaps an existing merge
@@ -3044,9 +3634,7 @@ declare class Table {
   /** Mark the owning part dirty so `save()` reserializes it. Call after mutating {@link element_}. */
   markDirty(): void;
 }
-//#endregion
-//#region src/read/api/shapes/graphic-frame.d.ts
-/** A graphic frame (`p:graphicFrame`) — host for tables, charts and SmartArt diagrams. */
+/** A graphic frame (`p:graphicFrame`), the host for tables, charts and SmartArt diagrams. */
 declare class GraphicFrame extends Shape {
   #private;
   readonly shapeType: 'graphicFrame';
@@ -3068,7 +3656,7 @@ declare class GraphicFrame extends Shape {
    */
   get hasDiagram(): boolean;
   /**
-   * The `a:graphicData/@uri` verbatim — the namespace naming what this frame hosts, or
+   * The `a:graphicData/@uri` verbatim: the namespace naming what this frame hosts, or
    * `null` when the frame carries no `a:graphicData`.
    *
    * Every `has*` predicate is a comparison against this, so a frame whose URI matches none
@@ -3094,10 +3682,8 @@ declare class GraphicFrame extends Shape {
    */
   get diagram(): Diagram | null;
 }
-//#endregion
-//#region src/read/api/shapes.d.ts
 /**
- * A group shape (`p:grpSp`) — contains nested shapes.
+ * A group shape (`p:grpSp`), which contains nested shapes.
  *
  * It is the one kind defined here rather than under `./shapes/`: its `shapes` getter recurses
  * through `buildShapes` below, so putting it in a sibling module would make the dispatch and the
@@ -3116,7 +3702,7 @@ declare class GroupShape extends Shape {
    * element is incomplete.
    *
    * Most consumers should not need this: {@link Shape.absoluteFrame} already
-   * composes the whole ancestor chain — child space, group flips and rotations —
+   * composes the whole ancestor chain (child space, group flips and rotations),
    * and doing that arithmetic per consumer is how a shape in a nested group ends
    * up subtly displaced. It is here for a *replica* consumer rather than a
    * *paint* one: rebuilding this group and its children as OOXML needs the
@@ -3132,24 +3718,22 @@ declare class GroupShape extends Shape {
  * {@link Shape.shapeType} literal. The read API (`Slide.shapes`,
  * `Slide.shapeById`, `GroupShape.shapes`, `Presentation.importShape`, …) returns
  * this rather than the abstract {@link Shape} base, so a consumer can narrow to a
- * subtype by its discriminant and reach the subtype-only members — e.g.
+ * subtype by its discriminant and reach the subtype-only members, e.g.
  * `if (shape.shapeType === 'graphicFrame') shape.chart` or, equivalently, the
  * {@link isGraphicFrame} guard. The abstract {@link Shape} base is still exported
  * for the "common members only" case and for `instanceof` checks.
  */
 type AnyShape = AutoShape | Picture | Connector | GraphicFrame | GroupShape;
-/** Narrow a shape to an {@link AutoShape} (`p:sp` — auto shape, text box, or placeholder). */
+/** Narrow a shape to an {@link AutoShape} (`p:sp`: auto shape, text box, or placeholder). */
 declare function isAutoShape(shape: Shape): shape is AutoShape;
 /** Narrow a shape to a {@link Picture} (`p:pic`). */
 declare function isPicture(shape: Shape): shape is Picture;
 /** Narrow a shape to a {@link Connector} (`p:cxnSp`). */
 declare function isConnector(shape: Shape): shape is Connector;
-/** Narrow a shape to a {@link GraphicFrame} (`p:graphicFrame` — table/chart host). */
+/** Narrow a shape to a {@link GraphicFrame} (`p:graphicFrame`, the table/chart host). */
 declare function isGraphicFrame(shape: Shape): shape is GraphicFrame;
 /** Narrow a shape to a {@link GroupShape} (`p:grpSp`). */
 declare function isGroupShape(shape: Shape): shape is GroupShape;
-//#endregion
-//#region src/read/api/chrome.d.ts
 /**
  * One theme font family (`a:majorFont` or `a:minorFont`): the primary Latin face
  * plus the East-Asian and complex-script faces. Each is `null` when the theme
@@ -3157,20 +3741,20 @@ declare function isGroupShape(shape: Shape): shape is GroupShape;
  * per-script `<a:font>` fallback list is not decoded here.
  */
 interface ThemeFontFace {
-  /** `<a:latin@typeface>` — the primary face (e.g. `Calibri Light`), or `null` when empty. */
+  /** `<a:latin@typeface>`: the primary face (e.g. `Calibri Light`), or `null` when empty. */
   latin: string | null;
-  /** `<a:ea@typeface>` — the East-Asian face, or `null` when empty. */
+  /** `<a:ea@typeface>`: the East-Asian face, or `null` when empty. */
   ea: string | null;
-  /** `<a:cs@typeface>` — the complex-script face, or `null` when empty. */
+  /** `<a:cs@typeface>`: the complex-script face, or `null` when empty. */
   cs: string | null;
 }
 /** A theme's `a:fontScheme`: its name plus the major (heading) and minor (body) font families. */
 interface ThemeFontScheme {
   /** `<a:fontScheme@name>` (e.g. `Office`), or `null` when unnamed. */
   name: string | null;
-  /** The `a:majorFont` family — the heading (`+mj-*`) fonts. */
+  /** The `a:majorFont` family: the heading (`+mj-*`) fonts. */
   major: ThemeFontFace;
-  /** The `a:minorFont` family — the body (`+mn-*`) fonts. */
+  /** The `a:minorFont` family: the body (`+mn-*`) fonts. */
   minor: ThemeFontFace;
 }
 /**
@@ -3214,7 +3798,7 @@ declare class Theme {
   markDirty(): void;
 }
 /**
- * One placeholder shape (`p:sp` with a `p:ph`) of a slide master or slide layout —
+ * One placeholder shape (`p:sp` with a `p:ph`) of a slide master or slide layout:
  * the definition a slide's placeholder of the same `type`/`idx` inherits geometry
  * and text style from. Geometry getters read the placeholder's *own* `a:xfrm`,
  * which a master/layout placeholder carries explicitly (so it round-trips, unlike a
@@ -3230,7 +3814,7 @@ declare class Theme {
 declare class Placeholder {
   /** The placeholder's `p:sp`. `protected` so {@link NotesPlaceholder} can read it. */
   protected readonly sp: Element;
-  /** The part the `p:sp` lives in — a master, a layout, or a notes slide. */
+  /** The part the `p:sp` lives in: a master, a layout, or a notes slide. */
   protected readonly host: ShapeHost;
   /**
    * The same `p:sp` as an {@link AutoShape}. Identity, geometry and the text frame are
@@ -3242,14 +3826,14 @@ declare class Placeholder {
    * `xfrm()` + `emuFrom`; and,
    * the one that showed, the text frame was built with **no** inheritance context, so
    * `Run.resolvedSizePt`, `resolvedFontFace`, `resolvedColor` and `resolvedBold` resolved
-   * through `SlideMaster.shapes` and came back `null` through `SlideMaster.placeholders` —
+   * through `SlideMaster.shapes` and came back `null` through `SlideMaster.placeholders`:
    * two views of one element disagreeing about the same run.
    */
   protected readonly shape: AutoShape;
   constructor(
   /** The placeholder's `p:sp`. `protected` so {@link NotesPlaceholder} can read it. */
   sp: Element,
-  /** The part the `p:sp` lives in — a master, a layout, or a notes slide. */
+  /** The part the `p:sp` lives in: a master, a layout, or a notes slide. */
   host: ShapeHost);
   /** Placeholder type (`p:ph/@type`: `title` | `body` | `sldNum` | …), or `null` when absent (a body placeholder). */
   get type(): string | null;
@@ -3286,7 +3870,7 @@ declare class Placeholder {
   markDirty(): void;
 }
 /**
- * The shared body of a slide master and a slide layout — the two template tiers a slide
+ * The shared body of a slide master and a slide layout, the two template tiers a slide
  * inherits from.
  *
  * Both are an OPC part holding a `p:cSld` with a shape tree and a resolvable theme context, and
@@ -3304,7 +3888,7 @@ declare class Placeholder {
  *
  * `Slide` deliberately does not extend this. It is a shape host too, but it is constructed from
  * a `Presentation` rather than an `OpcPackage`, reaches its relationships through that, and
- * reports an unnamed slide as `null` where a template tier reports `''` — three differences in
+ * reports an unnamed slide as `null` where a template tier reports `''`. That is three differences in
  * the same handful of members, which is more contortion than the sharing is worth.
  */
 declare abstract class TemplatePart implements ShapeHost {
@@ -3325,14 +3909,14 @@ declare abstract class TemplatePart implements ShapeHost {
   /** The authoring name (`p:cSld/@name`), or `''` when unnamed. */
   get name(): string;
   /**
-   * Every shape in this tier's `p:cSld/p:spTree`, in document order — the same `AnyShape`
+   * Every shape in this tier's `p:cSld/p:spTree`, in document order: the same `AnyShape`
    * union `Slide.shapes` returns, so shape-walking code applies unchanged.
    *
    * {@link placeholders} is the filtered view of the same tree.
    */
   get shapes(): AnyShape[];
-  /** The shape anywhere in this tier's tree with the given drawing id, or `undefined`. */
-  shapeByIdDeep(id: number): AnyShape | undefined;
+  /** The shape anywhere in this tier's tree with the given drawing id, or `undefined` (always, for `null`). */
+  shapeByIdDeep(id: number | null): AnyShape | undefined;
   /** This tier's placeholder shapes (`p:sp` carrying a `p:ph`), in document order. */
   get placeholders(): Placeholder[];
   /** This tier's colour/font context, resolved once and cached. Backs each {@link Placeholder}'s text frame. */
@@ -3375,23 +3959,23 @@ declare class SlideMaster extends TemplatePart {
   get layouts(): SlideLayout[];
   /**
    * The master's *own* background (`p:cSld/p:bg`), decoded, or `null` when it defines
-   * none. Scoped to the master's own element — a slide's *effective* background,
+   * none. Scoped to the master's own element. A slide's *effective* background,
    * resolved through the slide → layout → master chain, is `Slide.background`.
    */
   get background(): SlideBackground | null;
-  /** A master's context is its own `p:clrMap` plus its theme — no walk beyond this part. */
+  /** A master's context is its own `p:clrMap` plus its theme; no walk beyond this part. */
   protected resolveThemeContext(): ThemeContext;
 }
 /**
- * A deck's slide layout (`slideLayoutN.xml`) as a modeled object — the gallery entry
+ * A deck's slide layout (`slideLayoutN.xml`) as a modeled object: the gallery entry
  * a slide binds to. Exposes its {@link name}, its {@link type} (import-only; the
  * writer authors none), its {@link master} (and, through it, the {@link theme}), its
  * `shapes` and the `placeholders` subset of them, and its own {@link background}.
  * Reachable from `Slide.layout` and {@link SlideMaster.layouts}.
  *
  * The write API authors non-placeholder shapes into a layout: every
- * `defineSlideMaster({ objects })` member that is not a `placeholder` — a `rect`, a
- * `line`, an `image`, a `chart`, a `text` box — lands in this tier's tree.
+ * `defineSlideMaster({ objects })` member that is not a `placeholder` (a `rect`, a
+ * `line`, an `image`, a `chart`, a `text` box) lands in this tier's tree.
  */
 declare class SlideLayout extends TemplatePart {
   /**
@@ -3403,7 +3987,7 @@ declare class SlideLayout extends TemplatePart {
   /**
    * Whether this layout draws the master's non-placeholder shapes
    * (`p:sldLayout/@showMasterSp`). `xsd:boolean` defaulting to `true`, so an absent
-   * attribute means shown — the layout-tier counterpart of `Slide.showMasterSp`,
+   * attribute means shown. This is the layout-tier counterpart of `Slide.showMasterSp`,
    * and the one PowerPoint actually writes on a section-divider or full-bleed
    * layout. A renderer resolving what to paint under a slide's own shapes has to
    * consult both: the slide's flag, then its layout's.
@@ -3415,7 +3999,7 @@ declare class SlideLayout extends TemplatePart {
   get theme(): Theme | null;
   /**
    * The layout's *own* background (`p:cSld/p:bg`), decoded, or `null` when it defines
-   * none. A layout usually authors one — an explicit fill (`p:bgPr`) or a
+   * none. A layout usually authors one: an explicit fill (`p:bgPr`) or a
    * theme-indexed reference (`p:bgRef`). The slide's *effective* background is
    * `Slide.background`.
    */
@@ -3423,8 +4007,6 @@ declare class SlideLayout extends TemplatePart {
   /** A layout's context is walked layout → master → theme, which is why it is not the master's. */
   protected resolveThemeContext(): ThemeContext;
 }
-//#endregion
-//#region src/read/api/notes.d.ts
 /**
  * One placeholder shape (`p:sp`) of a notes slide. A notes slide holds a fixed set:
  * the slide thumbnail (`type="sldImg"`), the notes body (`type="body"`), and the
@@ -3432,8 +4014,8 @@ declare class SlideLayout extends TemplatePart {
  * `a:xfrm` and are `null` when it inherits geometry from the notesMaster (the case
  * on an authored deck, whose `sldImg`/`sldNum` carry an empty `p:spPr`).
  *
- * A notes placeholder IS a {@link Placeholder} — identity, geometry and the escape hatch are
- * the same twelve members read off the same `p:sp`, down to `p:ph` being found the same way —
+ * A notes placeholder IS a {@link Placeholder}. Identity, geometry and the escape hatch are
+ * the same twelve members read off the same `p:sp`, down to `p:ph` being found the same way,
  * so it extends one rather than repeating it. Two things are its own: the flattened
  * {@link text} convenience, and a {@link textFrame} that threads the notesMaster inheritance
  * context onto the body frame.
@@ -3445,14 +4027,14 @@ declare class NotesPlaceholder extends Placeholder {
    * runs round-trip a slide's authored notes; the `sldNum` placeholder's frame
    * holds the slide-number `a:fld`, whose value surfaces through `TextFrame.text`.
    *
-   * Overrides {@link Placeholder.textFrame} for the inheritance context alone — see below.
+   * Overrides {@link Placeholder.textFrame} for the inheritance context alone (see below).
    */
   get textFrame(): TextFrame | null;
   /** The placeholder's flattened text (paragraphs joined by `\n`), or `''` when it has no text body. */
   get text(): string;
 }
 /**
- * A slide's speaker-notes slide (`notesSlideN.xml`) as a modeled object — the deep
+ * A slide's speaker-notes slide (`notesSlideN.xml`) as a modeled object: the deep
  * companion to {@link Slide.notesText}. Exposes the notes
  * shape tree as {@link NotesPlaceholder}s ({@link body}/{@link slideImage}/
  * {@link slideNumber}) plus the body {@link textFrame} the older getters flatten.
@@ -3473,19 +4055,19 @@ declare class NotesSlide implements ShapeHost {
   part: Part);
   /** Partname of the notes slide part. */
   get partName(): string;
-  /** The notes part's own relationships — a notes hyperlink resolves through these. */
+  /** The notes part's own relationships; a notes hyperlink resolves through these. */
   get relationships(): Relationships;
   /**
    * The notes shape tree as full shapes, in document order.
    *
    * A notes slide holds nothing but its three placeholders, so {@link placeholders} is the
-   * view to read. This one exists because a notes slide is a {@link ShapeHost} — which is
+   * view to read. This one exists because a notes slide is a {@link ShapeHost}, which is
    * what lets a {@link NotesPlaceholder} be the same {@link AutoShape} view of its `p:sp`
    * that a master or layout placeholder is, rather than a second reading of one.
    */
   get shapes(): AnyShape[];
-  /** The shape anywhere in the notes tree with the given drawing id, or `undefined`. */
-  shapeByIdDeep(id: number): AnyShape | undefined;
+  /** The shape anywhere in the notes tree with the given drawing id, or `undefined` (always, for `null`). */
+  shapeByIdDeep(id: number | null): AnyShape | undefined;
   /**
    * The notes theme context, resolved through the notesMaster → `theme2.xml` chain
    * and cached. Backs {@link NotesPlaceholder.textFrame}'s `Run.resolvedColor`.
@@ -3504,8 +4086,6 @@ declare class NotesSlide implements ShapeHost {
   /** The notes body text flattened (paragraphs joined by `\n`), or `''` when the body is empty/absent. */
   get text(): string;
 }
-//#endregion
-//#region src/read/api/comments.d.ts
 /** One entry of the deck-wide comment-author registry (`p:cmAuthor`). */
 interface CommentAuthor {
   /** Author id (`@id`), referenced by each comment's `@authorId`. */
@@ -3540,7 +4120,7 @@ interface Comment {
 }
 /** One entry of the modern deck-wide author registry (`p188:author`). */
 interface ModernCommentAuthor {
-  /** Author id (`@id`) — a GUID string like `{E8A64ABA-…}`, referenced by each comment's `@authorId`. */
+  /** Author id (`@id`): a GUID string like `{E8A64ABA-…}`, referenced by each comment's `@authorId`. */
   id: string | null;
   /** Display name (`@name`). */
   name: string;
@@ -3574,9 +4154,7 @@ interface ModernComment {
 }
 /** Which comment schema a deck carries. `'none'` when it has neither part. */
 type CommentSchema = 'legacy' | 'modern' | 'none';
-//#endregion
-//#region src/read/api/tags.d.ts
-/** One programmatic tag (`p:tag`) — a name/value string pair. */
+/** One programmatic tag (`p:tag`): a name/value string pair. */
 interface Tag {
   /** The tag's `@name`. */
   name: string;
@@ -3591,9 +4169,7 @@ interface Tag {
  * `p:custDataLst`, so it is robust to element ordering in the owner.
  */
 declare function readTagsForPart(opc: OpcPackage, ownerPartName: string): Tag[];
-//#endregion
-//#region src/read/api/transition.d.ts
-/** `ST_TransitionSpeed` — the coarse speed bucket (`spd`), default `fast`. */
+/** `ST_TransitionSpeed`: the coarse speed bucket (`spd`), default `fast`. */
 type TransitionSpeed = 'slow' | 'med' | 'fast';
 /** Decoded slide transition (`p:transition`), as returned by {@link Slide.transition}. */
 interface TransitionInfo {
@@ -3664,8 +4240,41 @@ interface TransitionInput {
    */
   sound?: TransitionSoundInfo | null;
 }
-//#endregion
-//#region src/read/api/slide.d.ts
+/** Which time-node sequence a {@link BuildEffect} plays in. */
+type BuildSequence = 'main' | 'interactive' | 'other';
+/**
+ * One preset effect in a slide's `p:timing`, as {@link Slide.animations} reads it: a time node with a
+ * `presetClass`, the shape it targets, and how and when it starts.
+ */
+interface BuildEffect {
+  /**
+   * The sequence the effect plays in: `main` for the slide's click-through build (`nodeType="mainSeq"`),
+   * `interactive` for one a click on a shape triggers (`interactiveSeq`), `other` for anywhere else.
+   */
+  sequence: BuildSequence;
+  /** `@presetClass`: `entr`, `emph`, `exit`, `path`, `verb` or `mediacall`. */
+  presetClass: string;
+  /** `@presetID`, or `null` when it states none. */
+  presetId: number | null;
+  /** `@presetSubtype`, or `null` when it states none. */
+  presetSubtype: number | null;
+  /**
+   * How the effect starts (`@nodeType`): `clickEffect` is `onClick`, `withEffect` is `withPrevious`,
+   * `afterEffect` is `afterPrevious`, and anything else is `null`.
+   */
+  trigger: 'onClick' | 'withPrevious' | 'afterPrevious' | null;
+  /** The longest `@dur` among the effect's behaviours, in milliseconds, or `null` when none states one. */
+  durationMs: number | null;
+  /**
+   * The delay of the step the effect sits in, from the click that starts it (`p:cond/@delay` on the
+   * effect's parent time node), in milliseconds, or `null` when it is not a number.
+   */
+  delayMs: number | null;
+  /** The target shape's `p:cNvPr` id (the first `p:spTgt/@spid` under the effect), or `null`. */
+  shapeId: number | null;
+  /** Whether the effect targets a range of the shape's text (`p:spTgt/p:txEl`) rather than the whole shape. */
+  textRange: boolean;
+}
 /** Options for {@link Slide.addTextBox}. Geometry is in EMU. */
 interface AddTextBoxOptions {
   /** Left edge in EMU (`a:off/@x`). */
@@ -3742,8 +4351,8 @@ declare class Slide implements ShapeHost {
    * `fmtScheme` + `fontScheme`, plus the layout/master roots), walked once from
    * slide → layout → master → theme and cached on this proxy. Backs the read-model
    * resolved getters ({@link Shape.resolvedFill}, `Run.resolvedColor`,
-   * `Run.resolvedSizePt`, `Run.resolvedFontFace`) so a `schemeClr` token — including
-   * one delivered through a shape's `p:style` `fillRef`/`lnRef` — resolves to a
+   * `Run.resolvedSizePt`, `Run.resolvedFontFace`) so a `schemeClr` token (including
+   * one delivered through a shape's `p:style` `fillRef`/`lnRef`) resolves to a
    * literal hex, and a placeholder run's inherited size/typeface (a `+mj-*`/`+mn-*`
    * font token included) resolves to a literal value. The maps/roots are empty when
    * the theme chain is incomplete, in which case tokens simply stay unresolved.
@@ -3768,7 +4377,7 @@ declare class Slide implements ShapeHost {
   /**
    * Whether this slide draws the master's non-placeholder shapes
    * (`p:sld/@showMasterSp`). `xsd:boolean` defaulting to `true`, so an absent
-   * attribute means shown — the same shape as {@link hidden}.
+   * attribute means shown, the same shape as {@link hidden}.
    *
    * This is the switch that decides whether {@link SlideMaster.shapes} belongs on
    * *this* slide. A slide the author gave a full-bleed image or a section divider
@@ -3789,7 +4398,7 @@ declare class Slide implements ShapeHost {
    * Set or clear the slide's show transition. Assigning `null` removes it.
    * Writing a transition with `durationMs` emits the `mc:AlternateContent` form
    * (a `p14` Choice carrying `p14:dur` plus a base `mc:Fallback`); otherwise the
-   * bare `<p:transition>` is written. The node is inserted at its schema slot —
+   * bare `<p:transition>` is written. The node is inserted at its schema slot,
    * after `p:clrMapOvr`, before `p:timing`/`p:extLst`. Marks the slide part dirty.
    *
    * The new transition is built from the current one before that is removed: it keeps the sound
@@ -3804,6 +4413,12 @@ declare class Slide implements ShapeHost {
    * see `animationSpids`.
    */
   get hasAnimations(): boolean;
+  /**
+   * The slide's build effects: every time node in its `p:timing` with a `presetClass`, in document
+   * order, with the sequence it plays in, its preset, trigger, duration, step delay and target shape
+   * id. `[]` when the slide has no timing. Read-only: see {@link BuildEffect}.
+   */
+  get animations(): BuildEffect[];
   /**
    * @internal The sorted, de-duplicated set of shape ids (`spid`) referenced by
    * the slide's animations (`<p:spTgt spid>` and `<p:bldP spid>`). Exposed for the
@@ -3825,20 +4440,20 @@ declare class Slide implements ShapeHost {
   /**
    * Flatten the slide's build animations: remove the `<p:timing>` block so the
    * slide renders and edits as its final static state, with every shape shown at
-   * once. Gated like {@link hasAnimations} — a `<p:timing>` that is purely a media
+   * once. Gated like {@link hasAnimations}: a `<p:timing>` that is purely a media
    * loop (no `<p:bldP>` or `presetID`) is preserved so media playback survives.
    * Marks the slide part dirty and returns `true` only when a timing block was
    * removed.
    *
    * This removes click-through staging only; it does not delete shapes. If a slide
    * animated alternating states over the same region, the flattened render shows
-   * them all at once — keep that distinct from removing staged/duplicate shapes.
+   * them all at once. Keep that distinct from removing staged/duplicate shapes.
    */
   flattenAnimations(): boolean;
   /** Top-level shapes in the slide's shape tree, in document order. */
   get shapes(): AnyShape[];
   /**
-   * All text on the slide, flattened in document order — the read-model
+   * All text on the slide, flattened in document order: the read-model
    * counterpart to {@link TextFrame.text} one level up. Every text-bearing shape
    * contributes its text, recursing into groups ({@link GroupShape}) and reading
    * table cells ({@link GraphicFrame.table}) and SmartArt node text
@@ -3858,12 +4473,12 @@ declare class Slide implements ShapeHost {
    */
   get text(): string;
   /**
-   * The slide's speaker-note text — the companion to {@link text} for the notes
+   * The slide's speaker-note text, the companion to {@link text} for the notes
    * that {@link text} deliberately excludes. Delegates to {@link notesSlide}: finds
    * the notes body placeholder (`p:ph` `type="body"`) and flattens its text frame
    * the same way {@link TextFrame.text} does (paragraphs joined by `\n`).
    *
-   * Returns `null` when the slide has **no notes slide part at all** — distinct
+   * Returns `null` when the slide has **no notes slide part at all**, distinct
    * from `''`, which means a notes slide exists but its body is empty (PowerPoint
    * often attaches an empty notes slide to every slide). Only the body placeholder
    * is read; the slide-thumbnail (`sldImg`) and slide-number (`sldNum`)
@@ -3871,14 +4486,14 @@ declare class Slide implements ShapeHost {
    */
   get notesText(): string | null;
   /**
-   * The slide's speaker-note body as a navigable {@link TextFrame} — the rich
+   * The slide's speaker-note body as a navigable {@link TextFrame}: the rich
    * companion to {@link notesText}, which flattens the same body to a plain string.
    * Walk `paragraphs → runs` to recover per-run formatting (bold/italic/underline,
    * colour, size, face) and any notes hyperlink that {@link notesText} discards.
    *
    * `null` when the slide has **no notes slide part** (the same boundary
    * {@link notesText} returns `null` at), and also when a notes part exists but
-   * carries no body-placeholder text frame — there is then no frame to hand back
+   * carries no body-placeholder text frame; there is then no frame to hand back
    * (whereas {@link notesText} reports `''` for that empty-body case). Convenience
    * for `notesSlide.textFrame`; see {@link notesSlide} for the whole modeled notes
    * slide (its `sldImg`/`sldNum` placeholders and their geometry).
@@ -3888,9 +4503,9 @@ declare class Slide implements ShapeHost {
    * The slide's speaker-notes slide (`notesSlideN.xml`) as a modeled
    * {@link NotesSlide}, or `null` when the slide has no notes slide part. Beyond the
    * body text {@link notesText}/{@link notesTextFrame} surface, this exposes the
-   * notes slide's three placeholders — the slide thumbnail (`slideImage`), the notes
-   * body, and the slide-number field (`slideNumber`) — each with its geometry and
-   * (where present) a navigable text frame.
+   * notes slide's three placeholders, each with its geometry and (where present) a
+   * navigable text frame: the slide thumbnail (`slideImage`), the notes body, and the
+   * slide-number field (`slideNumber`).
    *
    * The writer authors all three placeholders but leaves `sldImg`/`sldNum` with an
    * empty `p:spPr`, so on an authored deck their geometry reads `null` while an
@@ -3934,14 +4549,14 @@ declare class Slide implements ShapeHost {
    * carries its body text, `created` timestamp, marker position (EMU), its author
    * resolved through the deck-wide {@link Presentation.modernCommentAuthors}
    * registry (`@authorId` GUID → name/initials), and its reply thread nested under
-   * `replies`. Read-only — the writer authors the legacy schema; see
+   * `replies`. Read-only: the writer authors the legacy schema; see
    * {@link Presentation.commentSchema} to tell which schema a deck uses.
    */
   get modernComments(): ModernComment[];
   /**
    * The slide's programmatic tags (`p:custDataLst/p:tags` on the slide part,
    * resolved to `ppt/tags/tagN.xml`) as `{ name, val }` string pairs, `[]` when it
-   * has none. Host/add-in metadata with no visible rendering and no writer —
+   * has none. Host/add-in metadata with no visible rendering and no writer:
    * read-only, preserved byte-for-byte on round-trip. Deck-level tags are
    * {@link Presentation.tags}.
    */
@@ -3949,7 +4564,7 @@ declare class Slide implements ShapeHost {
   /**
    * The slide's effective background (`p:cSld/p:bg`), decoded into a typed
    * {@link SlideBackground}. Resolved through the inheritance chain: the slide's
-   * own `p:bg` wins; failing that the slideLayout's, then the slideMaster's — the
+   * own `p:bg` wins; failing that the slideLayout's, then the slideMaster's. The
    * result's `source` records which supplied it. `null` when nothing in the chain
    * defines a background.
    *
@@ -3967,16 +4582,19 @@ declare class Slide implements ShapeHost {
    * `slide.slideNumber`, or added to a master defined with `slideNumber`; its geometry and run formatting
    * read off the returned {@link AutoShape} the same as any placeholder.
    *
-   * Scoped to the slide's *own* shape tree — a slide number inherited purely from
+   * Scoped to the slide's *own* shape tree: a slide number inherited purely from
    * the master's `p:hf`/placeholder (with no shape on the slide) is a master-level
    * concern this getter does not resolve.
    */
   get slideNumberPlaceholder(): AutoShape | null;
-  /** The first top-level shape with the given drawing id (`p:cNvPr/@id`), or `undefined`. */
-  shapeById(id: number): AnyShape | undefined;
+  /**
+   * The first top-level shape with the given drawing id (`p:cNvPr/@id`), or `undefined`. Takes
+   * `null`, as a shape's `id` reads when its `p:cNvPr` has no `@id`, and misses on it.
+   */
+  shapeById(id: number | null): AnyShape | undefined;
   /**
    * The first shape *anywhere* in the slide's shape tree with the given drawing id
-   * (`p:cNvPr/@id`), descending into groups — unlike {@link shapeById}, which scans
+   * (`p:cNvPr/@id`), descending into groups, unlike {@link shapeById}, which scans
    * only top-level shapes. Walked pre-order (a group is visited before its children),
    * matching how the writer allocates ids. `undefined` when no shape carries that id.
    *
@@ -3985,14 +4603,15 @@ declare class Slide implements ShapeHost {
    * resolution ({@link Connector.startConnection}), which must
    * resolve a binding into a group that top-level {@link shapeById} cannot see.
    */
-  shapeByIdDeep(id: number): AnyShape | undefined;
+  shapeByIdDeep(id: number | null): AnyShape | undefined;
   /** The first top-level shape with the given name (`p:cNvPr/@name`), or `undefined`. */
   shapeByName(name: string): AnyShape | undefined;
   /**
    * The first placeholder of the given type (`p:ph/@type`, e.g. `title`,
    * `ctrTitle`, `subTitle`, `body`), optionally narrowed by `idx`. Returns
-   * `undefined` when none match. Only `p:sp` shapes can be placeholders, so the
-   * result is an {@link AutoShape}.
+   * `undefined` when none match. Only {@link AutoShape}s are searched: a filled
+   * picture, table or chart placeholder is not found here, though its own
+   * `placeholder` getter still reads it.
    */
   placeholder(type: string, idx?: string): AutoShape | undefined;
   /**
@@ -4017,7 +4636,7 @@ declare class Slide implements ShapeHost {
      * afterwards through {@link notesTextFrame}.
      *
      * The counterpart to the read side's `notesText`/`notesTextFrame`/`notesSlide`
-     * getters, and the way to annotate a slide that has **no notes part at all** —
+     * getters, and the way to annotate a slide that has **no notes part at all**:
      * the state an `importSlide` without `{ importNotes: true }` leaves behind, and
      * the one a `notesTextFrame` edit cannot reach because there is no frame to
      * hand back. Calling it on a slide that already has notes replaces the body
@@ -4048,8 +4667,6 @@ declare class Slide implements ShapeHost {
    */
   nextShapeId(): number;
 }
-//#endregion
-//#region src/read/api/document-properties.d.ts
 /**
  * Decoded `docProps/core.xml`. Every field is optional (present only when the
  * element is). `created`/`modified`/`lastPrinted` are kept as the **raw W3CDTF
@@ -4083,7 +4700,7 @@ interface CoreProperties {
   lastPrinted?: string;
 }
 /**
- * Decoded `docProps/app.xml` — the *extended* properties, which are the producer's own
+ * Decoded `docProps/app.xml`: the *extended* properties, which are the producer's own
  * account of the deck rather than the author's metadata. Every field is optional (present
  * only when the element is).
  *
@@ -4094,14 +4711,14 @@ interface CoreProperties {
  * true, and `company` is the one this library's write API can set.
  */
 interface ExtendedProperties {
-  /** `<Application>` — the producing application, e.g. `Microsoft Office PowerPoint`. */
+  /** `<Application>`: the producing application, e.g. `Microsoft Office PowerPoint`. */
   application?: string;
-  /** `<AppVersion>` — that application's version, in its own `major.minor` spelling (`16.0000`). */
+  /** `<AppVersion>`: that application's version, in its own `major.minor` spelling (`16.0000`). */
   appVersion?: string;
   /** `<Company>` (the write-side `pptx.company`). */
   company?: string;
   /**
-   * `<TitlesOfParts>` — the flat `vt:lpstr` vector naming the deck's fonts, themes and slide
+   * `<TitlesOfParts>`: the flat `vt:lpstr` vector naming the deck's fonts, themes and slide
    * titles in one list. It is the vector as written, NOT split by section: `<HeadingPairs>`
    * holds the counts that partition it, and this library does not read them, so the caller
    * that wants the slide titles alone has to pair the two itself.
@@ -4145,20 +4762,16 @@ declare function readExtendedProperties(opc: OpcPackage): ExtendedProperties;
  * `firstChild`/`getElements` helpers.
  */
 declare function readCustomProperties(opc: OpcPackage): CustomProperty[];
-//#endregion
-//#region src/read/api/ops/deck-target.d.ts
 /** The destination deck: just the package and its main part. `Presentation` satisfies it. */
 interface DeckTarget {
   readonly opc: OpcPackage;
   readonly presentationPart: Part;
 }
-//#endregion
-//#region src/read/api/ops/part-copy.d.ts
 /**
  * One import in progress: where parts are going, where they are coming from, and
  * what has already come across.
  *
- * `source` and `registry` are one fact, not two — a registry maps partnames *of
+ * `source` and `registry` are one fact, not two: a registry maps partnames *of
  * that package*, so pairing it with any other package silently returns partnames
  * for parts that were never copied. Holding them in a single value makes the
  * pairing a type invariant rather than a call-site convention; mint one with
@@ -4178,7 +4791,7 @@ interface ImportContext {
    * gets its own part even when the registry already holds a copy of it, which is
    * what lets one source page be imported more than once.
    *
-   * Both import entry points set it — {@link Presentation.importSlides} for the
+   * Both import entry points set it: {@link Presentation.importSlides} for the
    * whole batch, {@link copySlidePart} for the single page of one
    * {@link Presentation.importSlide}. For the batch it carries a second meaning:
    * `slide → slide` relationships resolve only within the set, so an imported page
@@ -4189,7 +4802,7 @@ interface ImportContext {
    * as an output, and a map to *many* destinations would make every jump link
    * ambiguous. A batch asked for the same page N times therefore runs the
    * traversal N times, each round naming that page's Nth reserved partname and the
-   * other pages' first — see `importSlides` step 3.
+   * other pages' first (see `importSlides` step 3).
    */
   readonly selection?: SelectionPlan;
   /**
@@ -4231,7 +4844,7 @@ interface PlannedRel {
  * it would throw, found before anything in the destination moves.
  *
  * This is what lets a refused import leave the deck byte-identical. The copy changes the deck as it
- * goes — parts added, a master registered in `presentation.xml`, a layout linked into its master —
+ * goes (parts added, a master registered in `presentation.xml`, a layout linked into its master),
  * so a failure it met halfway would leave all of that behind. An import therefore runs the same
  * traversal twice: first with a plan in its context, which throws what the copy would and writes
  * nothing, then for real. The dry run used to be a separate walk of the source, transcribed from the
@@ -4242,8 +4855,8 @@ interface PlannedRel {
  * A plan stands in for the destination package as a {@link CopyTarget}. It hands out the partnames
  * the copy will be given, keeps its own copy of each source's registry so a part it planned is found
  * again as the copy would find it, and remembers the notes master it would install in a deck that has
- * none. Destination bookkeeping that adds no part — registering a master, linking a layout into it —
- * is not recorded.
+ * none. Destination bookkeeping that adds no part, such as registering a master or linking a layout
+ * into it, is not recorded.
  */
 declare class CopyPlan implements CopyTarget {
   #private;
@@ -4269,12 +4882,8 @@ declare class CopyPlan implements CopyTarget {
   addPart(partName: string, contentType: string): void;
   relationshipsFor(from: string): Pick<Relationships, 'add' | 'addWithId'>;
 }
-//#endregion
-//#region src/read/api/ops/rescale.d.ts
 /** How an import's rescale maps the source canvas onto the destination's. */
 type RescaleMode = 'fit' | 'stretch';
-//#endregion
-//#region src/read/api/presentation.d.ts
 declare class Presentation {
   #private;
   readonly opc: OpcPackage;
@@ -4318,7 +4927,7 @@ declare class Presentation {
   /**
    * The deck's embedded font families (`p:embeddedFontLst` in `presentation.xml`),
    * `[]` when it embeds none. Each entry names the typeface and resolves every
-   * embedded face's `r:id` to the absolute partname of its `.fntdata` binary — the
+   * embedded face's `r:id` to the absolute partname of its `.fntdata` binary: the
    * read counterpart to the write-side `pptx.embedFont` / `importSlide({ embedFonts })`
    * carry. An entry whose `p:font` has no `@typeface`, or a face whose `r:id` is
    * missing or dangling, is skipped (faithful degradation, no throw). Read-only.
@@ -4337,7 +4946,7 @@ declare class Presentation {
    * `ppt/authors.xml`), `[]` when the deck carries no modern comments. Unlike the
    * legacy {@link commentAuthors}, each entry is keyed by a GUID `id` (plus
    * `userId`/`providerId`); each slide's {@link Slide.modernComments} resolves its
-   * `@authorId` against this list. Read-only — the writer emits legacy comments.
+   * `@authorId` against this list. Read-only: the writer emits legacy comments.
    */
   get modernCommentAuthors(): ModernCommentAuthor[];
   /**
@@ -4361,7 +4970,7 @@ declare class Presentation {
    * The deck's extended document properties (`docProps/app.xml`): the producing
    * application and its version, the company, and the flat `TitlesOfParts` vector.
    * `{}` when the deck carries no extended-properties part. The read counterpart of
-   * the write-side `pptx.company` setter — the only one of the four this library
+   * the write-side `pptx.company` setter, the only one of the four this library
    * writes from a caller's value; the other three it states about itself.
    *
    * A deliberate subset of the part: see {@link ExtendedProperties} for why the
@@ -4379,7 +4988,7 @@ declare class Presentation {
    * The deck-level programmatic tags (`p:custDataLst/p:tags` on `presentation.xml`,
    * resolved to `ppt/tags/tagN.xml`) as `{ name, val }` string pairs, `[]` when the
    * deck carries none. These are add-in/host metadata with no visible rendering and
-   * no writer — read-only, preserved byte-for-byte on round-trip. Per-slide tags are
+   * no writer. They are read-only, preserved byte-for-byte on round-trip. Per-slide tags are
    * {@link Slide.tags}.
    */
   get tags(): Tag[];
@@ -4396,7 +5005,7 @@ declare class Presentation {
    * charts, SmartArt diagrams and OLE embeddings, each with the subtree under it
    * (a chart's embedded workbook comes along; the image inside its user-shapes
    * drawing stays shared). PowerPoint refuses to open a deck where two slides
-   * resolve to one chart or diagram, so this is not tidiness — see
+   * resolve to one chart or diagram, so this is not tidiness; see
    * `page-owned.ts` for the rule and the evidence behind it.
    */
   cloneSlide(index: number, options?: {
@@ -4407,7 +5016,7 @@ declare class Presentation {
    * `p:sldId` entry and the presentation→slide relationship are dropped, the slide
    * part and its `.rels` are deleted, and any part the slide *privately* owned
    * (its notes slide, slide-only media, charts/embeddings) that no remaining part
-   * references is pruned too — recursively. Shared deck chrome (layout, master,
+   * references is pruned too, recursively. Shared deck chrome (layout, master,
    * theme, …) is never pruned, so the deck stays renderable; removing every slide
    * leaves a valid master/layout-only package (a template shell). The slide also
    * leaves every custom show and section it was in, which stay even when that
@@ -4421,9 +5030,9 @@ declare class Presentation {
    * Append a copy of `source.slides[index]` to this presentation and return it.
    *
    * Unlike {@link cloneSlide} (same-deck duplicate), this copies a slide across
-   * a package boundary: it brings the connected sub-graph the slide depends on —
-   * its `slideLayout` → `slideMaster` → `theme`, plus any media, charts, and
-   * embeddings — into this package under fresh partnames, rewriting every
+   * a package boundary: it brings the connected sub-graph the slide depends on
+   * (its `slideLayout` → `slideMaster` → `theme`, plus any media, charts, and
+   * embeddings) into this package under fresh partnames, rewriting every
    * partname, relationship id, and content-type registration so the result is a
    * self-consistent OPC package. Parts of this (target) package that are not
    * touched stay byte-identical, matching `cloneSlide`'s fidelity contract.
@@ -4431,7 +5040,7 @@ declare class Presentation {
    * Only the layout(s) actually used by imported slides are copied; the imported
    * master's `p:sldLayoutIdLst` is pruned to exactly those, mirroring how
    * PowerPoint's "Reuse Slides" brings a slide across. Parts shared by repeated
-   * imports from the same source deck are copied once and reused — every part
+   * imports from the same source deck are copied once and reused: every part
    * except the page itself. Importing the same source slide twice yields two
    * independent copies over one shared layout/master/theme, which is what lets a
    * deck show one page twice (verbatim, then edited).
@@ -4440,7 +5049,7 @@ declare class Presentation {
    * into the slide XML and the slide is bound to this deck's existing
    * master/layout; with `{ theme: 'restyle' }` the slide is bound to this deck's
    * master/layout with its theme references left symbolic, so it re-brands to the
-   * destination palette — see {@link ImportSlideOptions}.
+   * destination palette. See {@link ImportSlideOptions}.
    *
    * By default the source slide size must equal this presentation's. Pass
    * `{ rescale: 'fit' | 'stretch' }` to rescale the imported geometry onto this
@@ -4457,7 +5066,7 @@ declare class Presentation {
    * Import selected pages from one or more loaded source presentations as one
    * batch. Each imported page lands at its `outputIndex` in the complete
    * destination slide list after the batch, and the returned array is parallel
-   * to `requests` — `result[i]` is the page `requests[i]` asked for, whatever
+   * to `requests`: `result[i]` is the page `requests[i]` asked for, whatever
    * order the output positions were given in.
    *
    * Everything is checked before a single byte of this deck moves: every request
@@ -4470,13 +5079,13 @@ declare class Presentation {
    * The batch also decides what a `slide → slide` link means: an internal link
    * on a selected page must target another **selected** page (or one this deck
    * already contains via an earlier import from that source), and is rewritten
-   * to the fresh partname — importing page 3 of 10 does not drag pages 1–2
+   * to the fresh partname. Importing page 3 of 10 does not drag pages 1–2
    * across as dependencies, and never strands the link. This mirrors
    * `appendSlides`' `import/unresolved-slide-link`, which the write side already
    * enforces for generator decks.
    *
    * One request is one output page, so naming the same source page in several
-   * requests is how you ask for several independent copies of it — the page part
+   * requests is how you ask for several independent copies of it; the page part
    * is the one thing an import never shares, exactly as in {@link importSlide}.
    * Everything under it (layout, master, theme, media) is still copied once and
    * shared. Where such a page is the target of a `slide → slide` link, the link
@@ -4487,7 +5096,7 @@ declare class Presentation {
    * Speaker notes travel per request: `{ importNotes: true }` carries that page's
    * `notesSlide` part across, wired to the new page and bound to a single
    * `notesMaster` under the same 0..1 rule {@link importSlide} and
-   * {@link appendSlides} follow — the destination's own master wins when it has
+   * {@link appendSlides} follow: the destination's own master wins when it has
    * one. Notes are part of the up-front dry run too, so a batch that would fail
    * carrying them is refused with the deck still byte-identical. A page named in
    * several requests gets its own copy of its notes each time, as of everything
@@ -4512,9 +5121,9 @@ declare class Presentation {
   importSlides(requests: readonly ImportSlidesRequest[]): Slide[];
   /**
    * Graft slide master(s) from another open package into this one and return what
-   * was copied. Unlike {@link importSlide} — which brings a master across only as
+   * was copied. Unlike {@link importSlide}, which brings a master across only as
    * the dependency of an imported *slide* and prunes it to the one layout that
-   * slide uses — this copies a master together with its **whole** layout family
+   * slide uses, this copies a master together with its **whole** layout family
    * and attaches it to no slide: the master and its layouts land in this deck's
    * layout gallery (PowerPoint's *Insert ▸ New Slide* / *Layout* picker) without
    * changing any existing slide.
@@ -4544,7 +5153,7 @@ declare class Presentation {
   importSlideMasters(source: Presentation, options?: ImportSlideMastersOptions): ImportedSlideMaster[];
   /**
    * The deck's slide masters, in `p:sldMasterIdLst` order, as modeled
-   * {@link SlideMaster}s — the typed read model over the shared chrome (each
+   * {@link SlideMaster}s: the typed read model over the shared chrome (each
    * master's colour map, theme, placeholders, and the layouts built on it). Walk
    * `pres.masters()[i].layouts` for the rich layout model, or use {@link layouts}
    * for the flat {@link LayoutHandle} gallery {@link appendSlides} binds to.
@@ -4552,7 +5161,7 @@ declare class Presentation {
    */
   masters(): SlideMaster[];
   /**
-   * The deck's slide layouts, in master then layout order — the gallery a new
+   * The deck's slide layouts, in master then layout order: the gallery a new
    * slide can bind to. Each {@link LayoutHandle} addresses one layout for
    * {@link appendSlides}; the `name` is its `p:cSld@name`. Read-only enumeration:
    * it copies nothing and leaves the package byte-identical.
@@ -4561,12 +5170,12 @@ declare class Presentation {
   /**
    * Append generator-produced slides onto this deck, binding each to an existing
    * layout, and return the new {@link Slide}s. This is the hybrid
-   * "generate-onto-existing" path: the deck's masters, layouts, theme — and every
-   * other untouched part — stay **byte-identical** (only `presentation.xml`, its
+   * "generate-onto-existing" path: the deck's masters, layouts, theme, and every
+   * other untouched part stay **byte-identical** (only `presentation.xml`, its
    * `.rels`, `[Content_Types].xml`, and the freshly-added slide/media parts
    * change), because the existing chrome is never regenerated.
    *
-   * `source` is any slide producer (a `TsPptx` instance); its authored slides
+   * `source` is any slide producer (a `PptxTs` instance); its authored slides
    * are serialized via {@link SlideSource.extractSlides} and spliced in under
    * fresh partnames, with each slide's `slideLayout` relationship pointed at the
    * layout named by `options.layout` and its image/hyperlink relationships rebuilt
@@ -4576,13 +5185,13 @@ declare class Presentation {
    * Charts and internal slide-to-slide hyperlinks are carried across: chart parts
    * (chart XML + `.rels` + embedded workbook) are injected under fresh names, and a
    * `slide:N` link is repointed at the Nth appended slide's new partname. A chartEx
-   * (Office 2016 — waterfall, funnel, treemap, ...) chart carries too, as its own
+   * (Office 2016: waterfall, funnel, treemap, ...) chart carries too, as its own
    * `chartEx{N}.xml` part behind the MS chartEx rel, with the style and color-style
    * sidecars PowerPoint requires alongside it.
    *
    * The generator's presentation-level embedded fonts (`pptx.embedFont`) are also
    * carried into this deck and merged into its `p:embeddedFontLst`, de-duped by
-   * typeface + face slot — so author-side embedded fonts survive the append onto a
+   * typeface + face slot, so author-side embedded fonts survive the append onto a
    * template that may itself already embed fonts.
    *
    * Embedded audio/video is carried too: the media part backs the ECMA audio/video rel
@@ -4593,22 +5202,26 @@ declare class Presentation {
    * Speaker notes ride across too: a slide authored with `addNotes` gets a `notesSlide`
    * part wired back to it, with its hyperlink rels preserved. A notes slide must bind to
    * a notes master, and a template commonly has none, so the generator's is installed
-   * (with the theme its `.rels` needs) — but only when this deck has none of its own, so
+   * (with the theme its `.rels` needs), but only when this deck has none of its own, so
    * an existing notes master and its styling always win.
    *
+   * Review comments (`addComment`) ride across as a comments part per slide. Their
+   * authors merge into this deck's `commentAuthors.xml` by name and initials: an author
+   * the deck already has keeps its id and continues its numbering, and a new one is added.
+   *
    * Limitations:
    * - An internal link to a source slide outside the appended batch throws (its
    *   target has no counterpart in the destination).
    * - Appended slides are concrete absolute-positioned content with no placeholder
    *   inheritance from the bound layout; the binding governs theme/`clrMap`
    *   resolution and the "based on" link, not placeholder geometry. Author with
-   *   concrete colours — any `schemeClr` re-resolves against the destination theme.
+   *   concrete colours: any `schemeClr` re-resolves against the destination theme.
    * - Source and destination slide sizes must match (no geometry rescale).
    */
   appendSlides(source: SlideSource, options: AppendSlidesOptions): Promise<Slide[]>;
   /**
-   * Copy one shape — an autoshape, picture, table/chart graphic frame, connector,
-   * or group — from `source.shapes[shapeIndex]` onto `target`, returning the new
+   * Copy one shape (an autoshape, picture, table/chart graphic frame, connector,
+   * or group) from `source.shapes[shapeIndex]` onto `target`, returning the new
    * {@link Shape}. `target` must be a slide of *this* presentation; `source` may
    * belong to any open presentation.
    *
@@ -4619,7 +5232,7 @@ declare class Presentation {
    * so they cannot collide with the host. With `theme: 'preserve'` (default) the
    * shape's theme references are baked to literals against the *source* theme so it
    * renders the same on a foreign host; `restyle` leaves them symbolic to re-brand;
-   * `copy` brings the XML across untouched — see {@link ImportShapeOptions}.
+   * `copy` brings the XML across untouched. See {@link ImportShapeOptions}.
    *
    * Differing slide sizes need `{ rescale }` (see {@link ImportShapeOptions.rescale});
    * a lifted `preserve` placeholder is baked self-contained and demoted to a plain
@@ -4645,7 +5258,7 @@ declare class Presentation {
   insertSlidePart(newPart: Part, at?: number): Slide;
   /**
    * @internal The parts whose geometry a rescale has already rewritten, and in which mode.
-   * Exposed for `presentation-imports.ts` as a live map the callee adds to — the memo is what
+   * Exposed for `presentation-imports.ts` as a live map the callee adds to. The memo is what
    * makes a layout or master shared across repeated imports from one source scale exactly
    * once, so like the copy registry it has to outlive the call that fills it.
    */
@@ -4653,7 +5266,7 @@ declare class Presentation {
   /**
    * @internal Open an import out of `source`: this deck as the destination, paired with
    * the copy registry for that package (created on first use). The registry is held on
-   * the class rather than in the context because it must outlive any one call — that is
+   * the class rather than in the context because it must outlive any one call: that is
    * what makes a second import from the same source reuse the layout, master, theme, and
    * media it already copied instead of duplicating them, and it is why the import bodies
    * in `presentation-imports.ts` call back here rather than carrying it with them.
@@ -4662,8 +5275,6 @@ declare class Presentation {
   /** Re-emit the package; untouched parts stay byte-identical (see `OpcPackage.save`). */
   save(): Promise<Uint8Array>;
 }
-//#endregion
-//#region src/read/api/presentation-types.d.ts
 /** Slide dimensions, in both EMU (the OOXML unit) and inches. */
 interface SlideSize {
   widthEmu: number;
@@ -4679,7 +5290,7 @@ interface SlideSize {
  * pull their bytes without hand-parsing the presentation part or its rels.
  */
 interface EmbeddedFontInfo {
-  /** `p:font/@typeface` — the family name PowerPoint binds the embed to. */
+  /** `p:font/@typeface`: the family name PowerPoint binds the embed to. */
   typeface: string;
   /** `p:font/@panose`, or `null` when the entry declares none. */
   panose: string | null;
@@ -4701,7 +5312,7 @@ interface ImportSlideOptions {
    * - `'copy'` (default): bring the slide's own `slideLayout → slideMaster →
    *   theme` subgraph across, so the slide renders byte-for-byte as authored.
    *   A deck stitched from N sources then carries N themes/masters.
-   * - `'preserve'`: *flatten then attach* — bake the source theme's colours and
+   * - `'preserve'`: *flatten then attach*. Bake the source theme's colours and
    *   style-matrix fills into the slide XML (so its pixels do not change), then
    *   bind it to this deck's existing master/layout instead of importing the
    *   source theme. The result is a single-theme file whose imported slides are
@@ -4720,7 +5331,7 @@ interface ImportSlideOptions {
    *   master `preserve` deliberately drops. Set {@link carryMasterGraphics} to
    *   bake them onto the slide instead.
    * - `'restyle'`: re-brand to *this* deck. Rebind the slide to this deck's
-   *   master/layout exactly like `preserve` but **skip the flatten** — leave every
+   *   master/layout exactly like `preserve` but **skip the flatten**: leave every
    *   `a:schemeClr`, style-matrix ref (`fillRef`/`lnRef`/`effectRef`/`fontRef`),
    *   and `p:bg` `bgRef` symbolic so they re-resolve against the *destination*
    *   theme. The slide keeps its geometry, text, and structure but adopts this
@@ -4732,7 +5343,7 @@ interface ImportSlideOptions {
    *   Anything the source authored as a literal `a:srgbClr` has no theme reference
    *   to re-resolve and stays exactly that colour, so a slide with a baked literal
    *   palette re-brands little or nothing. Use `restyle` for slides built against
-   *   theme colours/style matrices, not hardcoded RGB — or set {@link remapLiterals}
+   *   theme colours/style matrices, not hardcoded RGB, or set {@link remapLiterals}
    *   to force-remap literals and copy table styles. Re-brand is inherently a
    *   visual change (a source `accent1` light-on-dark can invert against a dark
    *   destination `accent1`), so its output needs visual QA. A restyled table
@@ -4746,11 +5357,11 @@ interface ImportSlideOptions {
    * slides whose palette is partly hardcoded. When `true` it does two things the
    * plain re-brand cannot:
    *
-   * - **Literal colours** — every literal `a:srgbClr` equal to a *source*-theme
+   * - **Literal colours**: every literal `a:srgbClr` equal to a *source*-theme
    *   `clrScheme` slot is rewritten back to a symbolic `a:schemeClr` (routed through
    *   the source `clrMap`), so it re-resolves against this deck's theme instead of
    *   staying its authored RGB. A literal matching no source slot is left untouched.
-   * - **Table styles** — any `@tableStyleId` the slide references is copied from the
+   * - **Table styles**: any `@tableStyleId` the slide references is copied from the
    *   source `tableStyles.xml` into this deck's (same id, idempotent, leaving an id
    *   the destination already defines alone), so a restyled table keeps its style
    *   instead of falling back. The copied definition is itself symbolic, so it
@@ -4763,13 +5374,13 @@ interface ImportSlideOptions {
   /**
    * `preserve`/`restyle` modes only. When `true`, bake the source
    * `slideLayout`/`slideMaster` shape-tree decorations (everything on those shape
-   * trees *except* placeholders — logos, accent curves, footers drawn as shapes)
+   * trees *except* placeholders: logos, accent curves, footers drawn as shapes)
    * onto the imported slide, behind its own content, so master/layout branding
    * survives the rebind to this deck's master. Their media are copied across.
    *
    * Under `preserve` the carried decorations' theme references are flattened like
    * the slide's own content; under `restyle` they are left symbolic and so
-   * re-brand to the destination palette along with the slide — note a carried
+   * re-brand to the destination palette along with the slide. Note that a carried
    * source logo could recolour unexpectedly under a different palette.
    *
    * Off by default: it raises fidelity for cover/closer/divider slides at the
@@ -4780,7 +5391,7 @@ interface ImportSlideOptions {
   carryMasterGraphics?: boolean;
   /**
    * Zero-based insert position in `p:sldIdLst` (deck order). `0` makes the
-   * imported slide first; an `at` past the current slide count — or omitting it —
+   * imported slide first; an `at` past the current slide count, or omitting it,
    * appends. Use it to place brand bookends (cover at `0`, closer appended)
    * around generator-authored interior slides regardless of import order.
    */
@@ -4788,14 +5399,14 @@ interface ImportSlideOptions {
   /**
    * Carry the *source deck's* embedded fonts (`p:embeddedFontLst` in its
    * `presentation.xml`) into this deck, so an imported slide that renders with an
-   * embedded face keeps it on machines that lack the font. Off by default —
+   * embedded face keeps it on machines that lack the font. Off by default:
    * fonts live on the presentation, not the slide, so they are only worth copying
    * when you want the embed to travel.
    *
    * The font binary parts are copied under fresh `/ppt/fonts/` names (deduped via
    * the per-source copy registry, so repeated imports copy each face once), the
    * `application/x-fontdata` Default is added, and entries are merged into this
-   * deck's `p:embeddedFontLst` — de-duplicated by `typeface` + face slot, so a
+   * deck's `p:embeddedFontLst`, de-duplicated by `typeface` + face slot, so a
    * face this deck already embeds is reused rather than duplicated. The carry is a
    * whole-deck operation (it copies *all* the source's embedded fonts, not just the
    * faces this one slide uses), since the source list does not record which slide
@@ -4815,7 +5426,7 @@ interface ImportSlideOptions {
    *   distorts shapes and cannot faithfully reposition rotated shapes. Matches
    *   "Maximize".
    *
-   * Only *geometry* is rescaled — every top-level shape/group/graphicFrame
+   * Only *geometry* is rescaled: every top-level shape/group/graphicFrame
    * transform (`a:off`/`a:ext`) and table grid (`a:gridCol@w`, `a:tr@h`). Font
    * sizes, line widths, and other absolute sizes are left as authored, so heavy
    * down-scaling can leave text overflowing its (now smaller) box. In `copy` mode
@@ -4855,12 +5466,12 @@ interface ImportShapeOptions {
    *   neither re-resolves against the host's placeholder of the same type/idx nor
    *   collides with it. The safe default for composing across decks.
    * - `'restyle'`: leave the shape's theme references symbolic so it re-brands to
-   *   the host theme. Only *symbolic* colours re-brand — literal `a:srgbClr` the
+   *   the host theme. Only *symbolic* colours re-brand; literal `a:srgbClr` the
    *   source baked in stays put (same limitation as `importSlide` restyle).
    * - `'copy'`: bring the shape's XML across untouched; only sane when the host
    *   already shares the source theme.
    *
-   * Unlike a slide import this never runs the slide-scoped background passes — a
+   * Unlike a slide import this never runs the slide-scoped background passes: a
    * background belongs to a slide, not to a composed shape.
    */
   theme?: 'preserve' | 'restyle' | 'copy';
@@ -4884,13 +5495,13 @@ interface ImportShapeOptions {
    * shape's geometry onto this deck's canvas instead (mirrors
    * {@link ImportSlideOptions.rescale}, scoped to one shape):
    *
-   * - `'fit'` (or `true`): uniform scale by `min(sx, sy)`, slack centered — the
+   * - `'fit'` (or `true`): uniform scale by `min(sx, sy)`, slack centered. The
    *   shape keeps its aspect ratio (circles stay circles, rotations hold) and
    *   lands at the position it would occupy on a centered copy of the source
    *   canvas. Matches PowerPoint's "Ensure Fit".
    * - `'stretch'`: independent per-axis scale; distorts. Matches "Maximize".
    *
-   * Only *geometry* is rescaled — the shape/group/graphicFrame transform
+   * Only *geometry* is rescaled: the shape/group/graphicFrame transform
    * (`a:off`/`a:ext`) and any table grid (`a:gridCol@w`, `a:tr@h`). Font sizes,
    * line widths, and other absolute sizes are left as authored, so heavy
    * down-scaling can leave text overflowing its (now smaller) box. Explicit
@@ -4905,7 +5516,7 @@ interface ImportShapeOptions {
    * click-group(s) and `<p:bldP>` are copied into the destination `p:timing`
    * (created if absent), their `spid` references remapped to the shape's new id and
    * their `<p:cTn>` ids renumbered to stay collision-free, and appended after any
-   * existing build — mirroring how PowerPoint merges a pasted shape's animation
+   * existing build, mirroring how PowerPoint merges a pasted shape's animation
    * (see the `import-animation-merge` oracle). @default false
    */
   carryAnimation?: boolean;
@@ -4934,7 +5545,7 @@ interface ImportSlideMastersOptions {
   /**
    * Require the source and destination slide sizes to match (default `true`).
    * A grafted master is shipped into the layout gallery, not applied to existing
-   * slides — but a layout authored at a different canvas size shows up mis-scaled
+   * slides, but a layout authored at a different canvas size shows up mis-scaled
    * in that gallery, so the guard is on by default. Pass `false` to graft anyway.
    */
   requireEqualSize?: boolean;
@@ -4942,15 +5553,15 @@ interface ImportSlideMastersOptions {
    * Carry the *source deck's* embedded fonts (`p:embeddedFontLst` in its
    * `presentation.xml`) into this deck, so a slide later bound to a grafted layout
    * keeps that layout's embedded faces on machines that lack the font locally.
-   * Off by default — fonts live on the presentation, not the master, and copying
-   * them can add megabytes — so they are only worth carrying when you want the
+   * Off by default. Fonts live on the presentation, not the master, and copying
+   * them can add megabytes, so they are only worth carrying when you want the
    * embed to travel with the gallery.
    *
    * Semantics are identical to {@link ImportSlideOptions.embedFonts}: binaries are
    * copied under fresh `/ppt/fonts/` names (deduped via the per-source copy
    * registry, so a re-call carries each face once), the `application/x-fontdata`
    * Default is added, and entries merge into this deck's `p:embeddedFontLst`
-   * de-duplicated by `typeface` + face slot. The carry is a whole-deck operation —
+   * de-duplicated by `typeface` + face slot. The carry is a whole-deck operation:
    * it copies *all* the source's embedded fonts, not only the faces the grafted
    * masters use, since the source list does not record which face belongs to which
    * master.
@@ -4964,16 +5575,16 @@ interface ImportSlideMastersOptions {
    * only adding new ones, so it is opt-in like {@link embedFonts}.
    *
    * Without it a grafted master's layouts arrive but its table styling does not, and
-   * a new table falls back to whatever default this deck carries — for a generated
+   * a new table falls back to whatever default this deck carries: for a generated
    * deck, a stub whose default is the standard *Medium Style 2 - Accent 1*. The
    * mismatch is visible: the same table renders in a different accent than it would
    * in the source deck.
    *
    * Styles union by `styleId` (a style this deck already defines wins, so a re-call
-   * is idempotent), while `a:tblStyleLst@def` — the default table style — is
+   * is idempotent), while `a:tblStyleLst@def` (the default table style) is
    * **source-wins**. Carrying the styles without the `def` would not fix the
    * mismatch: the standard default GUID is one most templates *also* define, so the
-   * default would still resolve to the wrong style. The carry is whole-deck — it
+   * default would still resolve to the wrong style. The carry is whole-deck: it
    * copies *all* the source's table styles, not only those the grafted masters use,
    * since `tableStyles.xml` does not record which style belongs to which master.
    * @default false
@@ -4985,7 +5596,7 @@ interface ImportSlideMastersOptions {
    * leads is a statement about what the deck *is*, so it is the caller's call rather
    * than a side effect of grafting.
    *
-   * `p:sldMasterIdLst` order is not part of theme resolution — a slide resolves
+   * `p:sldMasterIdLst` order is not part of theme resolution: a slide resolves
    * through its own layout's master, so this changes no existing slide's appearance.
    * What it changes is the deck's identity in PowerPoint's UI: the list's first entry
    * becomes `Designs(1)`, which is the theme the Design tab shows and the one
@@ -5017,7 +5628,7 @@ interface LayoutHandle {
  * One authored slide, extracted from a generator for injection into an existing
  * package. The slide body XML references its media/hyperlinks by relationship id
  * only, so {@link Presentation.appendSlides} preserves each `rId` and only
- * repoints its target — see {@link SlideSource}.
+ * repoints its target (see {@link SlideSource}).
  */
 interface ExtractedSlide {
   /** Standalone `<p:sld>` part body (XML declaration + namespaces included). */
@@ -5047,26 +5658,52 @@ interface ExtractedSlide {
   }>;
   /**
    * Embedded audio/video the body references. Each item is one media binary backed
-   * by two rels sharing a Target — the ECMA `audio`/`video` rel (`mediaRid`) and the
-   * MS-2007 `media` rel (`msMediaRid`) — plus a separate preview image rel
+   * by two rels sharing a Target, the ECMA `audio`/`video` rel (`mediaRid`) and the
+   * MS-2007 `media` rel (`msMediaRid`), plus a separate preview image rel
    * (`previewRid`). {@link Presentation.appendSlides} reproduces this rel graph.
    */
   avMedia: AvMediaItem[];
   /**
    * Online (external-link) video the body references. Each item is two *external*
-   * rels sharing one link Target — the ECMA `video` rel (`mediaRid`) and the MS-2007
-   * `media` rel (`msMediaRid`) — with **no** media binary part. The poster frame is a
+   * rels sharing one link Target, the ECMA `video` rel (`mediaRid`) and the MS-2007
+   * `media` rel (`msMediaRid`), with **no** media binary part. The poster frame is a
    * normal image rel carried by {@link media}. {@link Presentation.appendSlides}
    * wires the two external rels without reserving a media part or content type.
    */
   onlineMedia: OnlineMediaItem[];
   /**
    * The slide's speaker notes, or `undefined` when it has none. Carried as a ready
-   * `<p:notes>` part body plus its external hyperlink rels;
+   * `<p:notes>` part body plus its hyperlink and slide-link rels;
    * {@link Presentation.appendSlides} creates the notes part, wires it to the appended
    * slide, and binds it to a notes master (see {@link ExtractedSlides.notesMaster}).
    */
   notes?: ExtractedNotes;
+  /**
+   * The transition's start sound (`p:sndAc/p:stSnd/p:snd`), or `undefined` when the slide has
+   * none. One audio part behind an `audio` rel, keyed by the `rId` the body's `p:snd r:embed`
+   * uses. {@link Presentation.appendSlides} adds the part and the rel.
+   */
+  transitionSound?: {
+    rId: number;
+    bytes: Uint8Array;
+    extn: string;
+    contentType: string;
+  };
+  /**
+   * The slide's legacy review comments, as `addComment` stored them (`x`/`y` in inches), or
+   * `undefined` when it has none. Nothing in {@link xml} names them: they live in a comments part
+   * of their own, under authors in the deck-wide `commentAuthors.xml`.
+   * {@link Presentation.appendSlides} creates the part and merges the authors into the
+   * destination's registry.
+   */
+  comments?: Array<{
+    author: string;
+    initials: string;
+    text: string;
+    x: number;
+    y: number;
+    date?: string;
+  }>;
 }
 /** One slide's speaker notes, extracted for {@link Presentation.appendSlides}. */
 interface ExtractedNotes {
@@ -5075,21 +5712,29 @@ interface ExtractedNotes {
   /**
    * External hyperlink rels the notes body references, keyed by the `rId` used in
    * {@link xml}. Notes rels reserve `rId1` for the notes master and `rId2` for the
-   * slide, so these start at `rId3`. Notes support external `url` links only.
+   * slide, so these start at `rId3`.
    */
   hyperlinks: Array<{
     rId: number;
     target: string;
   }>;
+  /**
+   * Jumps from a notes run to another slide, as {@link ExtractedSlide.slideLinks} holds them for the
+   * body. Their ids share the numbering of {@link hyperlinks}. Absent means none.
+   */
+  slideLinks?: Array<{
+    rId: number;
+    sourceSlideNumber: number;
+  }>;
 }
 /**
  * One chart extracted for {@link Presentation.appendSlides}, keyed by the `rId` the slide
  * body uses to reference it.
  *
  * A classic (2007, `c:chartSpace`) chart is one part plus its embedded workbook. A chartEx
- * (Office 2016 — waterfall, funnel, treemap, ...) chart is a different part in a different
+ * (Office 2016: waterfall, funnel, treemap, ...) chart is a different part in a different
  * namespace, reached through a different relationship type, and PowerPoint reports it as
- * corrupt without its two style sidecars — so {@link chartEx} carries them and its presence
+ * corrupt without its two style sidecars, so {@link chartEx} carries them and its presence
  * is what tells the two shapes apart.
  */
 interface ExtractedChart {
@@ -5099,10 +5744,17 @@ interface ExtractedChart {
   chartXml: string;
   /** The chart's embedded `.xlsx` workbook, the data source PowerPoint opens on edit. */
   embeddingBytes: Uint8Array;
+  /** The pictures a chart or plot area's picture fill paints, keyed by the `rId` used in {@link chartXml}. */
+  pictures?: Array<{
+    rId: number;
+    bytes: Uint8Array;
+    extn: string;
+    contentType: string;
+  }>;
   /**
    * Present only for a chartEx chart, and then always with both sidecars. A chartEx part
    * *requires* a chart-style and a color-style part or PowerPoint reports the deck as
-   * corrupt (`0x80070570`) — schema-valid but unopenable — so these are not optional and
+   * corrupt (`0x80070570`), schema-valid but unopenable, so these are not optional and
    * {@link Presentation.appendSlides} injects them alongside the chart part.
    */
   chartEx?: {
@@ -5159,10 +5811,10 @@ interface ExtractedSlides {
    * A notes master to fall back on, present only when at least one slide carries notes.
    *
    * A notes slide must bind to a notes master, and a destination template often has
-   * none — a deck authored without speaker notes carries no `notesMaster` part. So the
+   * none: a deck authored without speaker notes carries no `notesMaster` part. So the
    * generator's own notes master rides along, and {@link Presentation.appendSlides}
    * installs it (with its theme) **only** when the destination has none. When the
-   * destination already has one, it wins and this is discarded — matching the
+   * destination already has one, it wins and this is discarded, matching the
    * `importNotes` policy, where the destination's notes styling also wins.
    */
   notesMaster?: {
@@ -5171,7 +5823,7 @@ interface ExtractedSlides {
   };
 }
 /**
- * Structural view of a slide producer (a `TsPptx` instance satisfies this).
+ * Structural view of a slide producer (a `PptxTs` instance satisfies this).
  * Kept structural so the read subsystem never imports the generator at runtime.
  */
 interface SlideSource {
@@ -5208,7 +5860,7 @@ interface ImportSlidesRequest {
    * the slide copy drops the `notesSlide` relationship, so the imported page
    * arrives without notes.
    *
-   * Per request rather than per batch because a stitch mixes sources — the
+   * Per request rather than per batch because a stitch mixes sources: the
    * notes of a library's cover page are worth carrying where a scratch deck's
    * are not. The deck-wide half of the policy is not per request: a
    * presentation holds at most one `notesMaster`, so the destination's own is
@@ -5254,6 +5906,5 @@ interface FromTemplateOptions {
    */
   keepTemplateContentType?: boolean;
 }
-//#endregion
-export { isGroupShape as $, ConnectionSite as $t, TransitionInput as A, EffectiveColor as An, Connector as At, NotesPlaceholder as B, BulletStyle as Bt, readCoreProperties as C, PlaceholderRef as Cn, Chart as Ct, AddTextBoxOptions as D, readColorRef as Dn, ChartLegend as Dt, AddPictureOptions as E, StyleFontRef as En, ChartFill as Et, Comment as F, AutofitMode as Ft, Theme as G, TextInheritance as Gt, Placeholder as H, LineSpacing as Ht, CommentAuthor as I, BodyProperties as It, AnyShape as J, TableConditionFlags as Jt, ThemeFontFace as K, ResolvedTableStyle as Kt, CommentSchema as L, TextFrame as Lt, TransitionSpeed as M, ColorContext as Mn, AutoShape as Mt, Tag as N, ThemeContext as Nn, Shape as Nt, Slide as O, resolveColorElement as On, ChartLine as Ot, readTagsForPart as P, ShapeHost as Pt, isGraphicFrame as Q, ChildFrame as Qt, ModernComment as R, Paragraph as Rt, ExtendedProperties as S, GeometrySource as Sn, AxisNumberFormat as St, readExtendedProperties as T, ResolvedFrame as Tn, ChartDataLabels as Tt, SlideLayout as U, Run as Ut, NotesSlide as V, InheritedRunProps as Vt, SlideMaster as W, TextContext as Wt, isAutoShape as X, AbsoluteFrame as Xt, GroupShape as Y, Hyperlink as Yt, isConnector as Z, AbsoluteFrameFailure as Zt, SlideSize as _, PictureFill as _n, ChartEx as _t, ExtractedChart as a, LineEnd as an, CellBorders as at, CoreProperties as b, GradientStop as bn, ChartExLegend as bt, ExtractedSlides as c, Recolor as cn, TableCellBorderEdit as ct, ImportSlideMastersOptions as d, SoftEdge as dn, DiagramConnection as dt, CustomGeometry as en, isPicture as et, ImportSlideOptions as f, BackgroundFill as fn, DiagramConnectionType as ft, OnlineMediaItem as g, FillRect as gn, DiagramPointType as gt, LayoutHandle as h, PatternFill as hn, DiagramPoint as ht, EmbeddedFontInfo as i, InnerShadow as in, CellBorder as it, TransitionSoundInfo as j, applyColorTransforms as jn, Picture as jt, TransitionInfo as k, ColorTransform as kn, ChartSeries as kt, FromTemplateOptions as l, Reflection as ln, TableCellEdge as lt, ImportedSlideMaster as m, SlideBackground as mn, DiagramNode as mt, AvMediaItem as n, GeometryCommand as nn, Table as nt, ExtractedNotes as o, LineEnds as on, CellThreeD as ot, ImportSlidesRequest as p, BackgroundSource as pn, DiagramDrawnShape as pt, ThemeFontScheme as q, TableCellTextStyle as qt, EmbeddedFontFaceInfo as r, Glow as rn, TableRow as rt, ExtractedSlide as s, OuterShadow as sn, TableCell as st, AppendSlidesOptions as t, CustomGeometryPath as tn, GraphicFrame as tt, ImportShapeOptions as u, ShapeType as un, Diagram as ut, SlideSource as v, PictureFillTile as vn, ChartExAxis as vt, readCustomProperties as w, ResolvedColor as wn, ChartAxis as wt, CustomProperty as x, ColorRef as xn, ChartExSeries as xt, Presentation as y, GradientFill as yn, ChartExDataLabels as yt, ModernCommentAuthor as z, BulletDetail as zt };
-//# sourceMappingURL=presentation-types-8jLQHI4M.d.ts.map
+export { isConnector as $, EffectiveColor as $n, Paragraph as $t, BuildSequence as A, PictureMedia as An, ChartDataTable as At, ModernComment as B, GradientStop as Bn, ChartSeries as Bt, readCoreProperties as C, GeometryCommand as Cn, ChartExSeries as Ct, AddTextBoxOptions as D, LineEnd as Dn, ChartAxis as Dt, AddPictureOptions as E, InnerShadow as En, ChartAreaFormat as Et, Tag as F, BackgroundFill as Fn, ChartLine as Ft, SlideLayout as G, GeometrySource as Gn, AutoShape as Gt, NotesPlaceholder as H, PictureFill as Hn, ChartView3D as Ht, readTagsForPart as I, BackgroundSource as In, ChartManualLayout as It, ThemeFontFace as J, ResolvedFrame as Jn, AutofitMode as Jt, SlideMaster as K, PlaceholderRef as Kn, Shape as Kt, Comment as L, SlideBackground as Ln, ChartMarker as Lt, TransitionInput as M, Reflection as Mn, ChartFill as Mt, TransitionSoundInfo as N, ShapeType as Nn, ChartLabelRun as Nt, Slide as O, LineEnds as On, ChartDataLabels as Ot, TransitionSpeed as P, SoftEdge as Pn, ChartLegend as Pt, isAutoShape as Q, ColorTransform as Qn, Equation as Qt, CommentAuthor as R, PatternFill as Rn, ChartPlotGroup as Rt, ExtendedProperties as S, CustomGeometryPath as Sn, ChartExLegend as St, readExtendedProperties as T, Glow as Tn, Chart as Tt, NotesSlide as U, PictureFillTile as Un, Connector as Ut, ModernCommentAuthor as V, FillRect as Vn, ChartTextStyle as Vt, Placeholder as W, ColorRef as Wn, Picture as Wt, AnyShape as X, readColorRef as Xn, ListStyleDefaults as Xt, ThemeFontScheme as Y, StyleFontRef as Yn, BodyProperties as Yt, GroupShape as Z, resolveColorElement as Zn, TextFrame as Zt, SlideSize as _, ConnectionSite as _n, DiagramPoint as _t, ExtractedChart as a, Run as an, TableRow as at, CoreProperties as b, CustomGeometryConnectionSite as bn, ChartExAxis as bt, ExtractedSlides as c, TextContext as cn, CellThreeD as ct, ImportSlideMastersOptions as d, TableCellTextStyle as dn, TableCellEdge as dt, BulletDetail as en, applyColorTransforms as er, isGraphicFrame as et, ImportSlideOptions as f, TableConditionFlags as fn, Diagram as ft, OnlineMediaItem as g, ChildFrame as gn, DiagramNode as gt, LayoutHandle as h, AbsoluteFrameFailure as hn, DiagramDrawnShape as ht, EmbeddedFontInfo as i, LineSpacing as in, Table as it, TransitionInfo as j, Recolor as jn, ChartDisplayUnits as jt, BuildEffect as k, OuterShadow as kn, ChartDataPoint as kt, FromTemplateOptions as l, TextInheritance as ln, TableCell as lt, ImportedSlideMaster as m, AbsoluteFrame as mn, DiagramConnectionType as mt, AvMediaItem as n, Field as nn, ThemeContext as nr, isPicture as nt, ExtractedNotes as o, RunOutline as on, CellBorder as ot, ImportSlidesRequest as p, Hyperlink as pn, DiagramConnection as pt, Theme as q, ResolvedColor as qn, ShapeHost as qt, EmbeddedFontFaceInfo as r, InheritedRunProps as rn, GraphicFrame as rt, ExtractedSlide as s, TabStop as sn, CellBorders as st, AppendSlidesOptions as t, BulletStyle as tn, ColorContext as tr, isGroupShape as tt, ImportShapeOptions as u, ResolvedTableStyle as un, TableCellBorderEdit as ut, SlideSource as v, CustomGeometry as vn, DiagramPointType as vt, readCustomProperties as w, GeometryCoordinate as wn, AxisNumberFormat as wt, CustomProperty as x, CustomGeometryGuide as xn, ChartExDataLabels as xt, Presentation as y, CustomGeometryAdjustHandle as yn, ChartEx as yt, CommentSchema as z, GradientFill as zn, ChartPointLabel as zt };
+//# sourceMappingURL=presentation-types-BgnZR-0a.d.ts.map