pptx-vanilla-viewer 3.0.0 → 3.1.0

package/dist/{transition-overlay-CcDuw_PK.d.ts → transition-overlay-DAd59XX1.d.ts}

@@ -11993,6 +11993,47 @@ interface CollaborationConfig {
 }
 /** A neutral CSS map (framework `CSSProperties` are structurally compatible). */
 type CssStyleMap = Record<string, string | number>;
+//#endregion
+//#region src/render/text-run-style.d.ts
+/** A plain CSS style map (keys are CSS properties; binding-agnostic). */
+type RunStyle = Record<string, string | number>;
+/** One script-tagged piece of a run's text, ready for a binding's nested span. */
+interface ScriptFontPiece {
+  text: string;
+  /**
+   * CSS for a nested span wrapping `text`, or `undefined` when this piece
+   * needs no span at all (its script's font equals the run's own, so plain
+   * text renders identically). When present it carries the `fontFamily`
+   * override plus the run's own decoration subset, repeated because
+   * `text-decoration-*` does not inherit into a nested span (see
+   * `nestedTextDecorationStyle`).
+   */
+  style?: RunStyle;
+}
+//#endregion
+//#region src/render/reflection.d.ts
+/**
+ * CSS `mask-image`/`-webkit-mask-image` value plus the raw `transform` for a
+ * mirrored reflection sibling. Every value is a ready-to-apply CSS string (or
+ * `'none'` sentinel avoided - fields are omitted when the browser default
+ * already matches), so a binding can spread this directly onto its own style
+ * object with no further per-framework logic.
+ */
+interface ReflectionWrapperStyle {
+  position: 'absolute';
+  left: string;
+  /** `calc(100% + <dist>px)`: sits `@dist` px below the source element's box. */
+  top: string;
+  width: string;
+  height: string;
+  /** Mirror (`scaleY(-1)`) composed with `@sx`/`@sy`/`@kx`/`@ky`/`@rot`. */
+  transform: string;
+  /** Anchor point for the transform above, from `@algn` (default `center top`). */
+  transformOrigin: string;
+  maskImage: string;
+  WebkitMaskImage: string;
+  pointerEvents: 'none';
+}
 /**
  * Reference to an interactive chart sub-part, carried by the primitives that
  * represent data marks (bars, dots, slices, series lines). Bindings use it to
@@ -12204,11 +12245,306 @@ interface ElementAnimationState {
 /** Edge / centre that {@link alignElements} can snap a selection to. */
 type AlignEdge = 'left' | 'centerH' | 'right' | 'top' | 'middle' | 'bottom';
 //#endregion
+//#region src/render/element-locks.d.ts
+/** A single on-canvas gesture a lock may forbid. */
+type ElementInteraction = 'select' | 'move' | 'resize' | 'rotate' | 'textEdit' | 'group' | 'changeAspect' | 'adjustHandle' | 'editPoints' | 'changeArrowheads' | 'changeShapeType' | 'crop' | 'drilldown';
+/**
+ * May `interaction` proceed on `element`?
+ *
+ * The single-question form of {@link resolveElementInteractivity}, for call
+ * sites that gate one gesture (a drag-start handler, a rotate commit) rather
+ * than rendering a whole overlay.
+ */
+declare function canInteractWithElement(element: PptxElement | null | undefined, interaction: ElementInteraction): boolean;
+//#endregion
 //#region src/render/slide-templates/slide-template-types.d.ts
 /** Discriminated id for every built-in slide template. */
 type SlideTemplateId = 'title' | 'titleAndContent' | 'sectionHeader' | 'agenda' | 'twoContent' | 'comparison' | 'quote' | 'timeline' | 'keyMetrics' | 'titleOnly' | 'blank' | 'closing';
 /** The unit system used for ruler display. */
 type RulerUnit = 'inches' | 'centimetres';
+/** Framework-neutral picture-bullet source, sizing, and accessible fallback. */
+interface PictureBulletMarker {
+  src?: string;
+  sizePx: number;
+  fallbackMarker: string;
+  accessibleLabel: string;
+  imageRelId?: string;
+}
+//#endregion
+//#region src/render/text-run-meta.d.ts
+/** A run's resolved hyperlink target. */
+interface RunHyperlink {
+  /**
+   * The URL to hand a click handler. For an internal `ppaction://hlinksldjump`
+   * the resolved slide index is appended as a `slideIndex` query parameter, so
+   * the target survives a callback whose only argument is the URL (see
+   * `parsePpactionUrl`, which reads it back off).
+   */
+  url: string;
+  /**
+   * A safe, renderable `href` for a plain `<a>`, or `undefined` when the target
+   * is an internal `ppaction://` action or fails the URL safety check. A
+   * binding with no click handler renders the run as text in that case, which
+   * is what every binding did for every link before this field existed.
+   */
+  href?: string;
+  /** `a:hlinkClick/@tooltip`, for the anchor's `title`. */
+  tooltip?: string;
+  /**
+   * `<a target>` for a real (non-`ppaction://`) hyperlink, from
+   * `a:hlinkClick/@tgtFrame` when authored, else `_blank` (every binding's
+   * pre-existing hardcoded default). Only meaningful alongside {@link href}.
+   */
+  target?: string;
+  /** `<a rel>` paired with {@link target} (see `resolveHyperlinkTargetAttrs`). */
+  rel?: string;
+  /** Resolved target slide for an internal slide jump. */
+  targetSlideIndex?: number;
+  /**
+   * True when the target came from `a:hlinkMouseOver` rather than
+   * `a:hlinkClick`: PowerPoint follows it on hover, not on click, so a binding
+   * that renders a plain anchor should not make it look clickable.
+   */
+  onHover?: boolean;
+}
+/** An inline equation run (`m:oMath`), rendered as MathML rather than text. */
+interface RunEquation {
+  /** The raw OMML node, for `convertOmmlToMathMl`. */
+  xml: Record<string, unknown>;
+  /** Display number for a numbered equation, without its parentheses. */
+  number?: string;
+}
+//#endregion
+//#region src/render/text-run-ruby.d.ts
+/** A run's phonetic guide, ready to render as `<rt>` above the base text. */
+interface RunRuby {
+  /** The annotation itself (`a:ruby/a:rt`), e.g. the furigana reading. */
+  text: string;
+  /** Inline style for the `<rt>` element (size, family, alignment, colour). */
+  style: RunStyle;
+}
+//#endregion
+//#region src/render/text-tab-run-build.d.ts
+/** One tabbed-line piece, ready to spread onto a binding's own span element. */
+interface TabbedRunPiece {
+  text: string;
+  /**
+   * CSS for the span that wraps `text`: inline-block layout, this run's own
+   * decoration repeated, and this piece's own PowerPoint advance-width
+   * correction as `letter-spacing` (see `buildTabbedLine`). The piece is
+   * nested inside the run's own span, and neither property inherits the way a
+   * caller would want: `text-decoration-*` does not inherit into a nested
+   * element at all (an ancestor's underline is drawn *through* its
+   * descendants, but each descendant still computes `none` of its own), so a
+   * caller passes the run's decoration subset (`nestedTextDecorationStyle`) to
+   * have it repeated here; `letter-spacing` DOES inherit, which is exactly why
+   * this piece sets it explicitly rather than only when non-zero - the run's
+   * container span carries its own (wrong, whole-text) correction that would
+   * otherwise leak in.
+   */
+  style: RunStyle;
+  /** CSS for the leader-fill span preceding this piece, or `undefined` when there is no gap to fill. */
+  leaderStyle?: RunStyle;
+  /** Leader glyphs sized to fill `leaderStyle`'s width. Present only alongside `leaderStyle`. */
+  leaderText?: string;
+  /**
+   * `a:rPr/@u="words"` per-word/gap sub-pieces of THIS tab piece's own text
+   * (see `splitWordsForUnderline`), present only when the run's underline is
+   * `words`. A tab-separated piece is otherwise rendered as a single span
+   * (`text` + `style`), which underlines it continuously - correct for a
+   * one-word piece, but wrong for a piece like `"Hello World"` between two tab
+   * stops, which needs a gap under the space. A binding renders one SIBLING
+   * span per entry IN PLACE OF the piece's single `text` span: each entry's
+   * `style` is the piece's own `style` (the same inline-block layout and
+   * advance-width correction, so the line measures exactly as before), with
+   * the underline stripped on a gap entry. They must be siblings, not spans
+   * nested inside the piece span: an ancestor's underline is drawn through
+   * every inline descendant, so a nested gap could not lose it. `text`/`style`
+   * stay the continuous-underline fallback for a binding that does not
+   * render this field.
+   */
+  words?: Array<{
+    text: string;
+    style: RunStyle;
+  }>;
+}
+/** One `\n`-split line of a run's tabbed text. */
+interface TabbedLineRun {
+  pieces: TabbedRunPiece[];
+}
+//#endregion
+//#region src/render/paragraph-types.d.ts
+/** A single rendered run within a paragraph. */
+interface ParagraphRun {
+  text: string;
+  style: RunStyle;
+  /**
+   * The run's hyperlink (`a:hlinkClick` / `a:hlinkMouseOver`), when it has one.
+   * A binding renders the run inside an `<a href>` when {@link RunHyperlink.href}
+   * is set, and routes {@link RunHyperlink.url} to its click handler otherwise
+   * (internal `ppaction://` slide jumps).
+   */
+  hyperlink?: RunHyperlink;
+  /**
+   * An inline equation (`m:oMath`) this run renders INSTEAD of `text`, which is
+   * empty for it. Emitted in the run sequence so the maths lands at its
+   * authored position between the runs around it.
+   */
+  equation?: RunEquation;
+  /**
+   * The run's phonetic guide (`a:ruby`: furigana, pinyin, bopomofo), when it
+   * has one. A binding renders `<ruby>{text}<rt style>{ruby.text}</rt></ruby>`;
+   * a run carrying one is never split per word, so the annotation appears once
+   * over the whole base run.
+   *
+   * Core parsed and saved ruby from the start, but `buildParagraphs` never read
+   * it, so the annotation rendered in React alone.
+   */
+  ruby?: RunRuby;
+  /**
+   * Index of the `textSegments` entry (of the override list when one was
+   * supplied) this run was built from.
+   *
+   * Shared splits one authored run into several per-word runs for PowerPoint's
+   * metric tracking, so this is many-to-one. It is the seam a binding uses to
+   * reach the facts the neutral model does not carry - React's find-match
+   * highlights, per-script font spans, tab stops and ruby all key off the
+   * originating segment - without regrouping the segments itself and drifting
+   * from the grouping here.
+   */
+  segmentIndex?: number;
+  /**
+   * Offset of this run's `text` within its segment's RENDERED text (after field
+   * substitution), so a caller holding per-segment character offsets can map
+   * them onto the split runs.
+   */
+  charStart?: number;
+  /**
+   * Per-script (`a:ea`/`a:cs`/`a:sym`) font-fallback pieces for this run's
+   * text, when a script it contains needs a font distinct from its own. A
+   * binding renders these as nested spans in place of `text` (see
+   * `text-script-fonts.ts`); absent for the common single-font case.
+   */
+  scriptRuns?: ScriptFontPiece[];
+  /**
+   * Measured tab-stop layout for this run's text, present when it contains an
+   * authored `\t` and the paragraph declares explicit tab stops. A binding
+   * renders these lines/pieces in place of `text`, honouring per-stop
+   * alignment and leader glyphs a plain CSS `tab-size` cannot express (see
+   * `text-tab-run-build.ts`). Absent for the common no-tab case.
+   */
+  tabLines?: TabbedLineRun[];
+  /**
+   * `a:rPr/@u="words"` word/gap pieces of a RUBY run's base text, present only
+   * when such a run's underline is `words` (the ordinary per-word split emits
+   * sibling runs instead; a tab piece carries its own `words`). Same shape as
+   * `scriptRuns` and rendered the same way, in place of `text`: a word entry
+   * carries the decoration for its own span, a gap entry is bare text. The
+   * run's own `style` has the underline stripped when this is set (see
+   * `paragraph-run-build.ts`).
+   */
+  underlineWordPieces?: ScriptFontPiece[];
+  /**
+   * `a:reflection` mirrored-sibling wrapper style for this run (the text-run
+   * counterpart of a shape/picture's `ComputedEffectStyle.reflection`), or
+   * `undefined` for the common no-reflection case. A binding renders a sibling
+   * node just below the run's own, painted with the same text, positioned and
+   * masked by this style - see `render/reflection.ts`'s
+   * `getTextReflectionWrapperStyle`.
+   */
+  reflection?: ReflectionWrapperStyle;
+}
+/** A rendered paragraph: runs plus resolved bullet + hanging-indent metadata. */
+interface RenderParagraph {
+  runs: ParagraphRun[];
+  /** Bullet glyph / number to render before the runs (or `undefined`). */
+  bulletMarker?: string;
+  /** Picture marker rendered before runs, or fallback metadata when unresolved. */
+  bulletPicture?: PictureBulletMarker;
+  /** Inline style for the bullet marker (font / size / colour). */
+  bulletStyle: RunStyle;
+  /** `margin-left` in px for the whole paragraph (hanging-indent layout). */
+  marginLeftPx?: number;
+  /** `text-indent` in px (first-line / hanging indent). */
+  textIndentPx?: number;
+  /**
+   * Per-paragraph `line-height` from this paragraph's own `a:pPr > a:lnSpc`.
+   * A unitless multiplier for proportional spacing (`a:spcPct`) or a `"<n>pt"`
+   * string for exact spacing (`a:spcPts`). Undefined when the paragraph does
+   * not override spacing (binding keeps the body-level line-height).
+   */
+  lineHeight?: number | string;
+  /** `margin-top` in px from this paragraph's `a:pPr > a:spcBef` (space before). */
+  spaceBeforePx?: number;
+  /** `margin-bottom` in px from this paragraph's `a:pPr > a:spcAft` (space after). */
+  spaceAfterPx?: number;
+  /**
+   * `font-size` in px to set on the paragraph element so its CSS line boxes
+   * are built from its OWN runs rather than the text body's default size.
+   * Undefined when the paragraph already matches the body default.
+   *
+   * See `resolveParagraphStrutFontSize` for why this is needed: without it a
+   * paragraph of small runs inside a larger-defaulting body is laid out on
+   * too-tall lines and overflows its shape.
+   */
+  strutFontSizePx?: number;
+  /**
+   * True when the paragraph has no runs and no bullet: an authored blank line
+   * (`<a:p><a:endParaRPr/></a:p>`).
+   *
+   * PowerPoint gives such a paragraph a full line box, which is how decks
+   * space a heading away from the bullet list under it. A binding must render
+   * something with height for it (a `<br>`), or the gap disappears and the
+   * block reads as one dense run of text (issue #131, slides 13-14).
+   */
+  isEmpty?: boolean;
+  /**
+   * Indices of this paragraph's segments in the rendered segment list (the
+   * override list when one was supplied), in authored order and INCLUDING the
+   * bullet-marker segment the runs drop.
+   *
+   * The seam a binding uses to reach paragraph facts the neutral model does not
+   * carry, without regrouping the segments itself and drifting from the
+   * grouping here - which is exactly how React ended up splitting on every
+   * `"\n"` and treating a soft `a:br` as a paragraph break.
+   */
+  segmentIndices: number[];
+  /**
+   * True when this paragraph resolves right-to-left (`a:pPr/@rtl`, or the text
+   * body's default). A binding that mirrors its hanging indent for RTL reads
+   * this; the direction itself is already in {@link paragraphStyle}.
+   */
+  rtl?: boolean;
+  /**
+   * Extra CSS for the paragraph box, beyond the margin / indent / spacing
+   * fields above: this paragraph's own `text-align` (`a:pPr/@algn`), its BiDi
+   * `direction`, and the kinsoku line-breaking rules (`@eaLnBrk`,
+   * `@latinLnBrk`, `@hangingPunct`). Absent when the paragraph overrides none
+   * of them, which is the common case.
+   *
+   * All three used to be resolved in React's private paragraph renderer only,
+   * so a deck that centred one paragraph of a left-aligned body, or set CJK
+   * break rules, rendered differently in the other four bindings.
+   */
+  paragraphStyle?: RunStyle;
+}
+//#endregion
+//#region src/render/inline-list-types.d.ts
+/** Current editor payload. Missing segments explicitly denotes plain-text fallback. */
+interface InlineTextEditSnapshot {
+  elementId: string;
+  text: string;
+  textSegments?: TextSegment[];
+}
+type InlineListReadResult = {
+  kind: 'supported';
+  snapshot: InlineTextEditSnapshot;
+  paragraphs: RenderParagraph[];
+} | {
+  kind: 'unsupported';
+  reason: string;
+  text: string;
+};
 //#endregion
 //#region src/render/inline-selection-utils.d.ts
 /** Describes which segments (and offsets within them) are selected. */
@@ -12257,6 +12593,217 @@ type TextAdvancedChanges = Partial<Pick<TextStyle, 'characterSpacing' | 'lineSpa
 //#endregion
 //#region src/render/text-case-transform.d.ts
 type ChangeCaseMode = 'sentence' | 'lower' | 'upper' | 'capitalize' | 'toggle';
+interface CollaborationShellState {
+  canEdit: boolean;
+  status: ConnectionStatus;
+  remoteUsers: readonly SanitizedPresence[];
+  connectedCount: number;
+}
+type CollaborationShellTranslate = (key: string, params?: Record<string, string | number>) => string;
+/**
+ * One-line, localised status for a custom shell's `role="status"` readout.
+ *
+ * Every binding's custom-shell demo renders this same string under the same
+ * `Collaboration status` label, so the framework-neutral e2e helper that
+ * waits for the shell to become editable (`waitForHostEditing`) reads every
+ * binding the same way. Three of five demos once phrased it differently and
+ * the helper silently skipped them; on vanilla, that let a peer double-click
+ * before its edit gate opened.
+ */
+declare function describeCollaborationShellState(state: Pick<CollaborationShellState, 'canEdit' | 'status' | 'connectedCount'>, translate: CollaborationShellTranslate): string;
+//#endregion
+//#region src/render/collaboration-text-codec.d.ts
+/**
+ * collaboration-text-codec.ts: TextSegment[] <-> Y.Text delta codec used by the
+ * collaboration sync layer. Split out of collaboration-sync.ts to keep both
+ * modules focused.
+ *
+ * Exports:
+ *  - DeltaOp / YTextLike: structural Yjs text interfaces (no yjs import)
+ *  - encodeTextBody: write TextSegment[] into a live YTextLike
+ *  - encodeSegmentsToDelta: pure simulation of the delta Y.Text would produce
+ *  - decodeDelta / decodeTextBody: delta -> TextSegment[]
+ *  - isYTextLike: runtime guard
+ */
+interface DeltaOp {
+  insert?: unknown;
+  attributes?: Record<string, unknown>;
+}
+interface YTextLike {
+  insert: (index: number, text: string, attrs?: Record<string, string>) => void;
+  toDelta: () => DeltaOp[];
+  toString: () => string;
+}
+//#endregion
+//#region src/render/collaboration-text-merge.d.ts
+/** Y.Text surface needed for in-place edits (delete/format on top of insert). */
+interface YTextEditableLike extends YTextLike {
+  delete: (index: number, length: number) => void;
+  format: (index: number, length: number, attributes: Record<string, string | null>) => void;
+}
+//#endregion
+//#region src/render/collaboration-text-positions.d.ts
+interface TextPositionCell {
+  index: number;
+  left?: TextPositionCell;
+  right?: TextPositionCell;
+}
+interface TrackedTextPosition {
+  /** Internal identity, shared by snapshots that observed the same character. */
+  readonly cell: TextPositionCell;
+  readonly association: number;
+}
+//#endregion
+//#region src/render/collaboration-text-session-delta.d.ts
+/** Browser edit range mapped to the editor's pre-input encoded coordinates. */
+interface LocalTextReplacement {
+  from: number;
+  to: number;
+}
+/** Desired UTF-16 units mapped to the editor's previously observed identities. */
+interface TextSessionCorrespondence {
+  readonly retainedIndices: readonly (number | null)[];
+  /** Old carriers for known paragraph attributes, independently of character identity. */
+  readonly paragraphSources?: readonly (number | null)[];
+}
+type LocalTextEdit = LocalTextReplacement | TextSessionCorrespondence;
+//#endregion
+//#region src/render/collaboration-text-session.d.ts
+/** Supplied by the binding's existing Yjs runtime, bound to this exact Y.Text. */
+interface TextSessionPositions<Position> {
+  capture: (index: number, association: number) => Position;
+  resolve: (position: Position) => number | null;
+  /** Synchronize tracked positions once per batch, including in-transaction writes. */
+  refresh?: () => boolean | void;
+  /** Release only resources created for this session. */
+  dispose?: () => void;
+}
+/** Opaque acknowledgement identity for an exact remote snapshot painted by an adapter. */
+interface CollaborationTextSnapshot {
+  readonly delta: readonly DeltaOp[];
+}
+interface CollaborationTextSession {
+  applyLocalDelta: (delta: readonly DeltaOp[], edit?: LocalTextEdit) => boolean;
+  readMerged: () => CollaborationTextSnapshot | undefined;
+  adoptMerged: (snapshot: CollaborationTextSnapshot) => boolean;
+  /** Capture an offset in the last painted/local draft, not the newer remote string. */
+  bookmark: (index: number, association: number) => () => number | null;
+  dispose: () => void;
+}
+//#endregion
+//#region src/render/collaboration-sync.d.ts
+interface YMapLike {
+  get: (key: string) => unknown;
+  set: (key: string, value: unknown) => void;
+  delete: (key: string) => void;
+  forEach: (cb: (value: unknown, key: string) => void) => void;
+}
+/** Shape of the Yjs transaction passed to (deep) observers. */
+interface YTransactionLike {
+  origin?: unknown;
+}
+type YDeepObserver = (events?: unknown, transaction?: YTransactionLike) => void;
+interface YArrayLike {
+  readonly length: number;
+  get: (index: number) => unknown;
+  push: (items: unknown[]) => void;
+  delete: (index: number, length?: number) => void;
+  insert: (index: number, items: unknown[]) => void;
+  toArray: () => unknown[];
+  observe: (handler: () => void) => void;
+  unobserve: (handler: () => void) => void;
+  observeDeep: (handler: YDeepObserver) => void;
+  unobserveDeep: (handler: YDeepObserver) => void;
+}
+interface YDocLike {
+  getMap: (name: string) => YMapLike;
+  getArray: (name: string) => YArrayLike;
+  transact: (fn: () => void, origin?: unknown) => void;
+}
+interface YjsFactories {
+  createMap: () => YMapLike;
+  createArray: () => YArrayLike;
+  createText: () => YTextLike;
+  /** Track character identities using the binding's existing Yjs runtime. */
+  createTextPositions?: (text: YTextEditableLike) => TextSessionPositions<TrackedTextPosition>;
+}
+//#endregion
+//#region src/render/collaboration-live-patch-target.d.ts
+/** Interim geometry for an element mid-gesture. All fields optional. */
+interface LiveGeometryPatch {
+  x?: number;
+  y?: number;
+  width?: number;
+  height?: number;
+  rotation?: number;
+}
+/** The element's pre-edit rich text, used to remap the interim plain text. */
+interface LiveTextSource {
+  textSegments?: TextSegment[];
+  textStyle?: TextStyle;
+}
+//#endregion
+//#region src/render/collaboration-text-target.d.ts
+interface CollaborationInlineSnapshot extends CollaborationTextSnapshot {
+  readonly inline: InlineTextEditSnapshot;
+}
+/** A mounted editor owns this handle, never the document or its provider. */
+interface CollaborationTextTarget extends CollaborationTextSession {
+  readMerged: () => CollaborationInlineSnapshot | undefined;
+  /** A bookmark follows character identity rather than a mutable numeric offset. */
+  bookmark: (index: number, association: number) => () => number | null;
+}
+interface CollaborationLivePatcher {
+  /** Bind a mounted native editor; its handle must be disposed on unmount. */
+  beginTextEdit?: (slideId: string | undefined, elementId: string, onChange?: () => void, ownsModel?: (element: PptxElement) => boolean) => CollaborationTextTarget | undefined;
+  /** Attach a live doc (or `null` to go dormant). Pending patches are dropped. */
+  configure: (doc: YDocLike | null, factories: YjsFactories | null,
+  /** Publish synchronously when the host may revoke write readiness at any time. */
+  immediate?: boolean) => void;
+  /** True when a doc + factories are attached, i.e. patches will be written. */
+  isActive: () => boolean;
+  /** Queue interim geometry for an element. */
+  patchGeometry: (slideId: string | undefined, elementId: string, geometry: LiveGeometryPatch) => void;
+  /** Queue interim text for an element (remapped over `source`'s segments). */
+  patchText: (slideId: string | undefined, elementId: string, text: string, source?: LiveTextSource) => void;
+  /** Write everything queued right now (call on gesture end / edit commit). */
+  flush: () => void;
+  /** Drop pending work, cancel timers and detach the doc. */
+  dispose: () => void;
+}
+//#endregion
+//#region src/render/collaboration-load-origin.d.ts
+/**
+ * Who asked for the deck that just finished loading, and what that means for a
+ * room that already holds slides.
+ *
+ * Every binding brackets its content-load with an adoption check: when a load
+ * lands while a collaboration session is up and the shared doc already has
+ * slides, the ROOM wins and the freshly parsed deck is thrown away. That rule
+ * exists for one case only - a late joiner whose bootstrap deck (the blank or
+ * sample deck the host mounted the viewer with) finishes parsing after the
+ * room's real slides arrived, which would otherwise clobber them with nothing
+ * left to repair it, since the doc itself never changed.
+ *
+ * Applied to EVERY load it also swallows the deck a user deliberately opens
+ * during a session. Joining a room and then opening a file left the viewer on
+ * the room's blank starter deck: the file parsed, was committed, and was
+ * immediately overwritten (reproduced in the vanilla demo - a 7-slide deck
+ * opened in a room settled back to the room's 1 slide, and the bigger the file
+ * the longer the window). Opening a file is an act of authorship, so it is
+ * published to the room instead.
+ *
+ * @module render/collaboration-load-origin
+ */
+/**
+ * Why a content load ran.
+ *
+ * - `bootstrap`: the deck the host handed the viewer at mount (`source`), or a
+ *   session restore. Nobody chose it during the session.
+ * - `user`: opened during the session - File > Open, a recent file, a dropped
+ *   file, or a host calling the load API.
+ */
+type CollabLoadOrigin = 'bootstrap' | 'user';
 //#endregion
 //#region src/render/slide-transition-types.d.ts
 /** Resolved CSS `animation` shorthands for the two transition layers. */
@@ -12855,6 +13402,19 @@ interface PrintSettings {
   scaleToFit?: boolean;
 }
 //#endregion
+//#region src/render/inline-text-commit.d.ts
+/**
+ * Reconcile a committed plain-text edit with an element's existing rich runs.
+ *
+ * Editor surfaces expose plain text, but the model still owns per-run styles,
+ * bullets, fields and paragraph properties. An unchanged blur is not an edit;
+ * a changed value is remapped onto the authored segments instead of flattening
+ * them.
+ */
+declare function buildInlineTextCommitPatch(element: PptxElement | undefined, text: string, snapshot?: InlineTextEditSnapshot): Partial<PptxElement> | undefined;
+/** Overlay a current rich list draft for serialization, without committing editor state. */
+declare function overlayInlineTextSnapshot(elements: readonly PptxElement[], snapshot?: InlineTextEditSnapshot, text?: string | undefined): readonly PptxElement[];
+//#endregion
 //#region src/render/slide-size-rescale.d.ts
 type SlideSizeRescaleMode = 'maximize' | 'ensureFit';
 type ReadOnlyRecommendationKind = 'modifyVerifier' | 'markedFinal' | null;
@@ -12985,5 +13545,5 @@ interface TransitionOverlayParams {
  */
 declare function playTransitionOverlay(params: TransitionOverlayParams): () => void;
 //#endregion
-export { RulerUnit as $, ShapeStyle as $n, PptxHandler as $t, INSTANT as A, PptxImageEffects as An, loadPresentationDeck as At, PPTX_OPEN_ACCEPT as B, PptxSmartArtData as Bn, resolveWheelSpokeCount as Bt, ElementUpdateOptions as C, PptxCustomShow as Cn, forgetSessionDeck as Ct, FieldSubstitutionContext as D, PptxEmbeddedFont as Dn, getSlideTransitionAnimations as Dt, ExternalCollaborationSnapshot as E, PptxElementAnimation as En, getSessionTabId as Et, MobileSheetKey as F, PptxPresentationProperties as Fn, resolveDirection as Ft, PresentationSnapshot as G, PptxTextStyleLevels as Gn, ViewerThemeColors as Gt, PowerPointViewerAPI as H, PptxTableCellStyle as Hn, savedPresentationFileName as Ht, ModifyPasswordCheckResult as I, PptxSection as In, resolveDirection8 as It, ReadOnlyRecommendation as J, PptxThemeColorScheme as Jn, defaultThemeColors as Jt, PrintSettings as K, PptxTheme as Kn, defaultCssVars as Kt, P14_TRANSITION_KEYFRAMES as L, PptxSlide as Ln, resolveOrientation as Lt, InsertChartKind as M, PptxModernCommentAuthor as Mn, parsePresentationSessionId as Mt, MasterViewCrudAction as N, PptxModifyVerifier as Nn, presentationBaseName as Nt, GradientState as O, PptxHandoutMaster as On, isLegacyBinaryPresentation as Ot, MasterViewCrudActionId as P, PptxNotesMaster as Pn, rememberSessionDeck as Pt, RibbonTransitionDraft as Q, PptxViewProperties as Qn, AccessibilityIssue as Qt, P14_TRANSITION_KEYFRAMES_2 as R, PptxSlideMaster as Rn, resolveSlideTransition as Rt, ElementUpdate as S, PptxCustomProperty as Sn, createImageElementFromFile as St, ExternalCollaborationSession as T, PptxElement as Tn, getP14TransitionAnimations as Tt, PresentationBlackout as U, PptxTableData as Un, ThemeCatalogEntry as Ut, PRESENTATION_OPEN_EXTENSIONS as V, PptxSmartArtNodeStyle as Vn, restoreSessionDeck as Vt, PresentationPointerTool as W, PptxTagCollection as Wn, ViewerTheme as Wt, ResolvedDirection as X, PptxThemeOption as Xn, vermilionDarkTheme as Xt, RemoteCursor as Y, PptxThemeFontScheme as Yn, themeToCssVars as Yt, ResolvedDirection8 as Z, PptxTransitionType as Zn, vermilionLightTheme as Zt, DEFAULT_MORPH_DURATION_MS as _, PptxChartData as _n, ViewerMode as _t, AnimationGroup as a, OleObjectType as an, TextStyle as ar, SessionDeck as at, ElementAnimationState as b, PptxCommentMention as bn, ViewportFitPadding as bt, CanvasSize as c, PptxAfterAnimationAction as cn, SlideSizeEmu as ct, CollaborationConfig as d, PptxAnimationRepeatMode as dn, SlideTransitionAnimations as dt, PptxSaveFormat as en, SmartArtColorScheme as er, RunProgramNotice as et, CollaborationRole as f, PptxAnimationSequence as fn, StrokeToInkElementOpts as ft, CssStyleMap as g, PptxAppProperties as gn, ViewerFontSource as gt, ConnectionStatus as h, PptxAnimationTrigger as hn, ToolbarActionId as ht, AlignEdge as i, MediaPptxElement as in, TextSegment as ir, SavedPresentationFormat as it, InlineTextSelection as j, PptxLayoutPreview as jn, loadSessionDeck as jt, Guide as k, PptxHeaderFooter as kn, isSupportedPresentationFile as kt, ChangeCaseMode as l, PptxAnimationDirection as ln, SlideSizeRescaleMode as lt, CompatibilityWarningToast as m, PptxAnimationTimingCurve as mn, TextAdvancedChanges as mt, playTransitionOverlay as n, ElementAction as nn, SmartArtLayoutType as nr, SLIDE_TRANSITION_KEYFRAMES_CSS as nt, AutosaveRecord as o, OlePptxElement as on, XmlObject as or, ShapePresetType as ot, CollaborationTransport as p, PptxAnimationTimelineAnchor as pn, TRANSITION_SPEED_DURATION_MS as pt, RANDOM_ELIGIBLE_TYPES as q, PptxThemeColorRef as qn, defaultRadius as qt, AccountAuthConfig as r, MasterViewTab as rn, TablePptxElement as rr, SanitizedPresence as rt, CINEMATIC_TRANSITION_KEYFRAMES as s, ParsedTableStyleMap as sn, ShareDefaults as st, TransitionOverlayParams as t, SvgExportOptions as tn, SmartArtLayout as tr, SLIDE_TRANSITION_KEYFRAMES as tt, ChartPartRef as u, PptxAnimationPreset as un, SlideTemplateId as ut, DEFAULT_TRANSITION_DURATION_MS as v, PptxComment as vn, ViewerQuickAccessOptions as vt, ExternalCollaborationAwareness as w, PptxData as wn, getCinematicTransitionAnimations as wt, ElementClipboardPayload as x, PptxCoreProperties as xn, WHEEL_SPOKE_COUNTS as xt, EASE as y, PptxCommentAuthor as yn, ViewportFitOptions as yt, P14_TRANSITION_KEYFRAMES_ALL as z, PptxSlideTransition as zn, resolveTransitionDurationMs as zt };
-//# sourceMappingURL=transition-overlay-CcDuw_PK.d.ts.map
+export { ReadOnlyRecommendation as $, PptxTableCellStyle as $n, ViewerTheme as $t, FieldSubstitutionContext as A, PptxCommentMention as An, describeCollaborationShellState as At, MobileSheetKey as B, PptxHeaderFooter as Bn, overlayInlineTextSnapshot as Bt, ElementAnimationState as C, PptxAnimationTimelineAnchor as Cn, ViewerQuickAccessOptions as Ct, ExternalCollaborationAwareness as D, PptxChartData as Dn, buildInlineTextCommitPatch as Dt, ElementUpdateOptions as E, PptxAppProperties as En, WHEEL_SPOKE_COUNTS as Et, InlineTextEditSnapshot as F, PptxData as Fn, getSlideTransitionAnimations as Ft, PPTX_OPEN_ACCEPT as G, PptxNotesMaster as Gn, resolveDirection8 as Gt, P14_TRANSITION_KEYFRAMES as H, PptxLayoutPreview as Hn, presentationBaseName as Ht, InlineTextSelection as I, PptxElement as In, isLegacyBinaryPresentation as It, PresentationBlackout as J, PptxSlide as Jn, resolveTransitionDurationMs as Jt, PRESENTATION_OPEN_EXTENSIONS as K, PptxPresentationProperties as Kn, resolveOrientation as Kt, InsertChartKind as L, PptxElementAnimation as Ln, isSupportedPresentationFile as Lt, Guide as M, PptxCoreProperties as Mn, getCinematicTransitionAnimations as Mt, INSTANT as N, PptxCustomProperty as Nn, getP14TransitionAnimations as Nt, ExternalCollaborationSession as O, PptxComment as On, canInteractWithElement as Ot, InlineListReadResult as P, PptxCustomShow as Pn, getSessionTabId as Pt, RANDOM_ELIGIBLE_TYPES as Q, PptxSmartArtNodeStyle as Qn, ThemeCatalogEntry as Qt, MasterViewCrudAction as R, PptxEmbeddedFont as Rn, loadPresentationDeck as Rt, EASE as S, PptxAnimationSequence as Sn, ViewerMode as St, ElementUpdate as T, PptxAnimationTrigger as Tn, ViewportFitPadding as Tt, P14_TRANSITION_KEYFRAMES_2 as U, PptxModernCommentAuthor as Un, rememberSessionDeck as Ut, ModifyPasswordCheckResult as V, PptxImageEffects as Vn, parsePresentationSessionId as Vt, P14_TRANSITION_KEYFRAMES_ALL as W, PptxModifyVerifier as Wn, resolveDirection as Wt, PresentationSnapshot as X, PptxSlideTransition as Xn, restoreSessionDeck as Xt, PresentationPointerTool as Y, PptxSlideMaster as Yn, resolveWheelSpokeCount as Yt, PrintSettings as Z, PptxSmartArtData as Zn, savedPresentationFileName as Zt, CompatibilityWarningToast as _, ParsedTableStyleMap as _n, XmlObject as _r, StrokeToInkElementOpts as _t, AnimationGroup as a, vermilionDarkTheme as an, PptxThemeColorScheme as ar, RunProgramNotice as at, DEFAULT_MORPH_DURATION_MS as b, PptxAnimationPreset as bn, ToolbarActionId as bt, CanvasSize as c, PptxHandler as cn, PptxTransitionType as cr, SanitizedPresence as ct, CollabLoadOrigin as d, SvgExportOptions as dn, SmartArtColorScheme as dr, ShapePresetType as dt, ViewerThemeColors as en, PptxTableData as er, RemoteCursor as et, CollaborationConfig as f, ElementAction as fn, SmartArtLayout as fr, ShareDefaults as ft, CollaborationTransport as g, OlePptxElement as gn, TextStyle as gr, SlideTransitionAnimations as gt, CollaborationShellState as h, OleObjectType as hn, TextSegment as hr, SlideTemplateId as ht, AlignEdge as i, themeToCssVars as in, PptxThemeColorRef as ir, RulerUnit as it, GradientState as j, PptxCompatibilityWarning as jn, forgetSessionDeck as jt, ExternalCollaborationSnapshot as k, PptxCommentAuthor as kn, createImageElementFromFile as kt, ChangeCaseMode as l, PptxHandlerSaveOptions as ln, PptxViewProperties as lr, SavedPresentationFormat as lt, CollaborationRole as m, MediaPptxElement as mn, TablePptxElement as mr, SlideSizeRescaleMode as mt, playTransitionOverlay as n, defaultRadius as nn, PptxTextStyleLevels as nr, ResolvedDirection8 as nt, AutosaveRecord as o, vermilionLightTheme as on, PptxThemeFontScheme as or, SLIDE_TRANSITION_KEYFRAMES as ot, CollaborationLivePatcher as p, MasterViewTab as pn, SmartArtLayoutType as pr, SlideSizeEmu as pt, PowerPointViewerAPI as q, PptxSection as qn, resolveSlideTransition as qt, AccountAuthConfig as r, defaultThemeColors as rn, PptxTheme as rr, RibbonTransitionDraft as rt, CINEMATIC_TRANSITION_KEYFRAMES as s, AccessibilityIssue as sn, PptxThemeOption as sr, SLIDE_TRANSITION_KEYFRAMES_CSS as st, TransitionOverlayParams as t, defaultCssVars as tn, PptxTagCollection as tr, ResolvedDirection as tt, ChartPartRef as u, PptxSaveFormat as un, ShapeStyle as ur, SessionDeck as ut, ConnectionStatus as v, PptxAfterAnimationAction as vn, TRANSITION_SPEED_DURATION_MS as vt, ElementClipboardPayload as w, PptxAnimationTimingCurve as wn, ViewportFitOptions as wt, DEFAULT_TRANSITION_DURATION_MS as x, PptxAnimationRepeatMode as xn, ViewerFontSource as xt, CssStyleMap as y, PptxAnimationDirection as yn, TextAdvancedChanges as yt, MasterViewCrudActionId as z, PptxHandoutMaster as zn, loadSessionDeck as zt };
+//# sourceMappingURL=transition-overlay-DAd59XX1.d.ts.map