pptx-svelte-viewer 2.17.8 → 2.18.0

package/dist/viewer/index.d.ts

@@ -1640,7 +1640,28 @@ interface BulletInfo {
   autoNumType?: string;
   /** Auto-numbering start value. */
   autoNumStartAt?: number;
-  /** Zero-based paragraph index within the text body (for auto-numbering). */
+  /**
+   * Auto-numbering ORDINAL OFFSET: the zero-based distance of this paragraph
+   * within its own numbered list, such that
+   * `autoNumStartAt + paragraphIndex` is the ordinal to render. Despite the
+   * name it is NOT the paragraph's position in the text body; the two agree
+   * only for a list that starts at the first paragraph and is never
+   * interrupted.
+   *
+   * It has to be the offset rather than the raw position because every
+   * consumer that re-derives a marker from `BulletInfo` alone (the renderer's
+   * `resolveParagraphBullet`, the Markdown converter's `resolveListMarker`)
+   * computes `autoNumStartAt + paragraphIndex`. The load path resolves the
+   * real sequence itself, restarting the count after any paragraph that
+   * interrupts the list, and publishes the offset here so those consumers
+   * land on the same number. With the raw position they did not, and BOTH
+   * markers were painted ("3.1. Item"), because the paragraph builder drops
+   * the parsed marker segment only when the two strings agree.
+   *
+   * Runtime-only: derived at parse time and never serialized. OOXML has no
+   * counterpart (`a:buAutoNum` carries only `@type` and `@startAt`), so the
+   * writer neither reads nor emits it.
+   */
   paragraphIndex?: number;
   /** Bullet font family from `a:buFont`. */
   fontFamily?: string;
@@ -3935,6 +3956,11 @@ interface PptxTableCellStyle {
   italic?: boolean;
   underline?: boolean;
   color?: string;
+  /**
+   * Font family from the first run's `a:rPr/a:latin@typeface` (falling back to
+   * `a:ea` / `a:cs`). Per-run families live on {@link PptxTableCellTextRun}.
+   */
+  fontFamily?: string;
   /**
    * Raw XML colour-choice node preserved from `a:tc/a:txBody/.../a:rPr/a:solidFill`
    * for round-trip serialisation. Currently unused by the cell-level writer
@@ -4090,6 +4116,45 @@ interface PptxTableCell3D {
   /** Light rig direction (`a:lightRig@dir`, e.g. `tl`, `t`, `tr`). */
   lightRigDirection?: string;
 }
+/**
+ * One styled text run inside a table cell's `a:txBody`.
+ *
+ * `PptxTableCell.text` is a flat string and `PptxTableCell.style` describes
+ * only the FIRST run, so a cell mixing formats ("Revenue **grew 42%** last
+ * year") cannot be represented by those two alone. {@link PptxTableCell.runs}
+ * carries the full sequence, with paragraph and line breaks as marker entries
+ * so a renderer can walk it linearly.
+ *
+ * Structurally identical to `pptx-viewer-shared`'s `CellTextRun`, which every
+ * binding's table renderer already consumes.
+ *
+ * @example
+ * ```ts
+ * const runs: PptxTableCellTextRun[] = [
+ *   { text: "Revenue " },
+ *   { text: "grew 42%", bold: true, color: "#C00000" },
+ * ];
+ * // => satisfies PptxTableCellTextRun[]
+ * ```
+ */
+interface PptxTableCellTextRun {
+  /** Run text. Empty for the break markers below. */
+  text: string;
+  /** This entry starts a new paragraph (`a:p` boundary) rather than carrying text. */
+  isParagraphBreak?: boolean;
+  /** This entry is a soft line break (`a:br`) rather than carrying text. */
+  isLineBreak?: boolean;
+  bold?: boolean;
+  italic?: boolean;
+  underline?: boolean;
+  strikethrough?: boolean;
+  /** Resolved run colour as a CSS colour string. */
+  color?: string;
+  /** Run font size in points (`a:rPr@sz` / 100). */
+  fontSize?: number;
+  /** Run font family from `a:rPr/a:latin@typeface` (or `a:ea` / `a:cs`). */
+  fontFamily?: string;
+}
 /**
  * A single table cell with text content, optional style, and merge info.
  *
@@ -4106,6 +4171,15 @@ interface PptxTableCell3D {
 interface PptxTableCell {
   text: string;
   style?: PptxTableCellStyle;
+  /**
+   * Per-run formatting for the cell's text, when it has any beyond what
+   * {@link style} can express. Present only for cells whose `a:txBody`
+   * actually carries runs; renderers fall back to {@link text} when absent.
+   *
+   * Editing a cell's text invalidates these (the editor produces a plain
+   * string), so an edit path must clear them alongside setting `text`.
+   */
+  textRuns?: PptxTableCellTextRun[];
   /** Column span (defaults to 1). */
   gridSpan?: number;
   /** Row span (defaults to 1). */
@@ -4885,6 +4959,35 @@ interface UnknownPptxElement extends PptxElementBase {
 type PptxElement = TextPptxElement | ShapePptxElement | ConnectorPptxElement | ImagePptxElement | PicturePptxElement | TablePptxElement | ChartPptxElement | SmartArtPptxElement | OlePptxElement | MediaPptxElement | GroupPptxElement | InkPptxElement | ContentPartPptxElement | ZoomPptxElement | Model3DPptxElement | UnknownPptxElement;
 //#endregion
 //#region src/core/types/masters.d.ts
+/**
+ * A placeholder slot declared on a master or layout.
+ *
+ * The geometry fields are in CSS pixels (EMU / {@link EMU_PER_PX}) and are only
+ * present when the shape carried an explicit `a:xfrm`. Placeholders that
+ * inherit their frame from the master leave them undefined, so consumers that
+ * draw placeholder outlines (the layout gallery) must skip those entries
+ * rather than assume a zero-sized box at the origin.
+ *
+ * @example
+ * ```ts
+ * const frame: PptxPlaceholderFrame = { type: "body", idx: "1", x: 63, y: 130 };
+ * // => satisfies PptxPlaceholderFrame
+ * ```
+ */
+interface PptxPlaceholderFrame {
+  /** `p:ph/@type`, lower-cased by the parser; defaults to `body` when omitted. */
+  type: string;
+  /** `p:ph/@idx`, when present. */
+  idx?: string;
+  /** Left offset in CSS pixels, when the shape declares `a:off`. */
+  x?: number;
+  /** Top offset in CSS pixels, when the shape declares `a:off`. */
+  y?: number;
+  /** Width in CSS pixels, when the shape declares `a:ext`. */
+  width?: number;
+  /** Height in CSS pixels, when the shape declares `a:ext`. */
+  height?: number;
+}
 /**
  * Parsed notes master from `ppt/notesMasters/notesMaster1.xml`.
  *
@@ -4906,10 +5009,7 @@ interface PptxNotesMaster {
   /** Background image data URL. */
   backgroundImage?: string;
   /** Placeholder shapes found on the notes master. */
-  placeholders?: Array<{
-    type: string;
-    idx?: string;
-  }>;
+  placeholders?: PptxPlaceholderFrame[];
   /** Editable elements on the notes master (header, footer, date, page number, slide image, notes body). */
   elements?: PptxElement[];
   /** Header/footer flags from `<p:hf>` on the notes master (P-H3). */
@@ -4937,10 +5037,7 @@ interface PptxHandoutMaster {
   /** Background image data URL. */
   backgroundImage?: string;
   /** Placeholder shapes found on the handout master. */
-  placeholders?: Array<{
-    type: string;
-    idx?: string;
-  }>;
+  placeholders?: PptxPlaceholderFrame[];
   /** Editable elements on the handout master (header, footer, date, page number, slide placeholders). */
   elements?: PptxElement[];
   /** Number of slides per page for handout print layout (1, 2, 3, 4, 6, or 9). */
@@ -4988,10 +5085,7 @@ interface PptxSlideMaster {
   /** Layout paths associated with this master. */
   layoutPaths?: string[];
   /** Placeholder shapes on the master. */
-  placeholders?: Array<{
-    type: string;
-    idx?: string;
-  }>;
+  placeholders?: PptxPlaceholderFrame[];
   /** Parsed element shapes on the master slide (for master view rendering). */
   elements?: PptxElement[];
   /** Parsed slide layout objects associated with this master. */
@@ -5063,10 +5157,7 @@ interface PptxSlideLayout {
   /** Parsed element shapes on the layout. */
   elements?: PptxElement[];
   /** Placeholder shapes on the layout. */
-  placeholders?: Array<{
-    type: string;
-    idx?: string;
-  }>;
+  placeholders?: PptxPlaceholderFrame[];
   /** Matching name attribute for layout identification (`@matchingName`). */
   matchingName?: string;
   /** Whether the layout is marked as preserved (prevent deletion, `@preserve`). */
@@ -5080,6 +5171,42 @@ interface PptxSlideLayout {
   /** Header/footer flags from `<p:hf>` on this layout (P-H3). */
   headerFooter?: PptxHeaderFooterFlags;
 }
+/**
+ * Rendered content of a single layout, used to draw gallery thumbnails.
+ *
+ * Produced on demand rather than during load: materialising every layout's
+ * artwork (and decoding its images) up front costs a noticeable amount of time
+ * on decks with many masters, and most sessions never open the layout gallery
+ * at all.
+ *
+ * @example
+ * ```ts
+ * const preview: PptxLayoutPreview = {
+ *   path: "ppt/slideLayouts/slideLayout2.xml",
+ *   width: 960,
+ *   height: 540,
+ *   elements: [],
+ *   placeholders: [{ type: "title" }],
+ * };
+ * // => satisfies PptxLayoutPreview
+ * ```
+ */
+interface PptxLayoutPreview {
+  /** ZIP path of the layout this preview belongs to. */
+  path: string;
+  /** Slide width in CSS pixels, so a thumbnail can compute its own scale. */
+  width: number;
+  /** Slide height in CSS pixels. */
+  height: number;
+  /** Background resolved from the layout, falling back to its master's. */
+  backgroundColor?: string;
+  /** Background image data URL, when the layout or master declares one. */
+  backgroundImage?: string;
+  /** The layout's own artwork (pictures, shapes and static text). */
+  elements: PptxElement[];
+  /** Placeholder slots, drawn as outlined frames in the gallery. */
+  placeholders: PptxPlaceholderFrame[];
+}
 /**
  * A theme part available in the presentation package.
  *
@@ -7699,6 +7826,8 @@ interface IPptxHandlerRuntime {
   revokeBlobUrls(): void;
   getCompatibilityWarnings(): PptxCompatibilityWarning[];
   getLayoutOptions(): PptxLayoutOption[];
+  getLayoutPreview(layoutPath: string): Promise<PptxLayoutPreview | null>;
+  getLayoutPreviews(layoutPaths?: readonly string[]): Promise<PptxLayoutPreview[]>;
   createXmlBuilder(data: PptxData): PptxXmlBuilder;
   Builder(data: PptxData): PptxXmlBuilder;
   setTemplateBackground(path: string, backgroundColor: string | undefined): void;
@@ -7887,6 +8016,26 @@ declare class PptxHandlerCore {
    * @returns Array of {@link PptxLayoutOption} entries.
    */
   getLayoutOptions(): PptxLayoutOption[];
+  /**
+   * Build the artwork thumbnails backing the New Slide / Layout galleries.
+   *
+   * Parsing happens on first request and is memoised afterwards, so opening
+   * the gallery costs one pass over the layout parts and reopening it costs
+   * nothing. Callers that only need one entry should prefer
+   * {@link getLayoutPreview}.
+   *
+   * @param layoutPaths - Restrict the result to these layouts; defaults to
+   *   every layout in the presentation.
+   * @returns One {@link PptxLayoutPreview} per resolvable layout.
+   */
+  getLayoutPreviews(layoutPaths?: readonly string[]): Promise<PptxLayoutPreview[]>;
+  /**
+   * Build the artwork thumbnail for a single layout.
+   *
+   * @param layoutPath - Archive path of the `p:sldLayout` part.
+   * @returns The preview, or `null` when the presentation has no such layout.
+   */
+  getLayoutPreview(layoutPath: string): Promise<PptxLayoutPreview | null>;
   /**
    * Create a fluent XML builder scoped to the given presentation data.
    *
@@ -8670,6 +8819,20 @@ interface ElementAnimationState {
   animatesStroke?: boolean;
 }
 //#endregion
+//#region src/render/table-merge.d.ts
+/** A cell coordinate within a table (0-based). */
+interface CellCoord {
+  row: number;
+  col: number;
+}
+/** The bounding rectangle of a cell selection (inclusive end coordinates). */
+interface CellRect {
+  startRow: number;
+  startCol: number;
+  endRow: number;
+  endCol: number;
+}
+//#endregion
 //#region src/render/element-align.d.ts
 /**
  * Pure geometry helpers for the align / distribute editor operations.
@@ -8776,6 +8939,17 @@ interface FieldSubstitutionContext {
   /** Title text extracted from the first title placeholder on the slide. */
   slideTitle?: string;
 }
+/** Descriptor for the draggable adjustment handle (the amber diamond). */
+interface ShapeAdjustmentHandleDescriptor {
+  key: string;
+  /** Handle x offset in element-local px (origin = element top-left). */
+  left: number;
+  /** Handle y offset in element-local px. */
+  top: number;
+  /** Current adjustment value (0–50000). */
+  value: number;
+  cursor: string;
+}
 //#endregion
 //#region src/render/collaboration-presence.d.ts
 /** Connection lifecycle states for the Yjs WebSocket provider. */
@@ -8944,6 +9118,19 @@ interface CompareResult {
   changedCount: number;
   unchangedCount: number;
 }
+/** Everything the Transitions tab's controls currently say. */
+interface RibbonTransitionDraft {
+  /** The highlighted gallery entry. */
+  type: PptxTransitionType;
+  /** Duration field, in seconds. */
+  durationSec: number;
+  /** Advance Slide > On Mouse Click. */
+  advanceOnClick: boolean;
+  /** Advance Slide > After (whether the timed advance is armed at all). */
+  advanceAfter: boolean;
+  /** Advance Slide > After, as the `mm:ss.hh` text the field holds. */
+  advanceAfterText: string;
+}
 /**
  * A font supplied by the host application. The package never ships fonts:
  * applications provide a licensed URL, data URL, or blob URL for their users.
@@ -9049,10 +9236,89 @@ interface ElementClipboardPayload {
 //#endregion
 //#region src/render/template-editing.d.ts
 type TemplateElementMap = Record<string, PptxElement[]>;
+/** What the "Embed fonts in the file" toggle should look like and do. */
+interface FontEmbeddingDescriptor {
+  /** Distinct typeface names the loaded deck currently embeds. */
+  embeddedFamilies: string[];
+  /**
+   * Whether the toggle accepts input. False when the deck embeds nothing,
+   * because turning it on could not produce an embedded font.
+   */
+  interactive: boolean;
+  /**
+   * The position the toggle must START in so that it describes the file that
+   * would be written right now. A deck that arrived with embedded fonts keeps
+   * them on save, so the switch has to read "on" from the outset; the previous
+   * hardcoded `false` said the opposite of what save actually did.
+   */
+  initialEnabled: boolean;
+  /** Present only when `interactive` is false. */
+  disabledReasonKey?: string;
+}
 /** The percentage one zoom-in press moves to, clamped. */
 declare function zoomInPercent(percent: number): number;
 /** The percentage one zoom-out press moves to, clamped. */
 declare function zoomOutPercent(percent: number): number;
+/**
+ * Why the deck is being serialised, which is a separate question from whether
+ * the user protected it.
+ *
+ * - `user-file` (the default): the bytes leave the viewer as a file. Save,
+ *   Save As, Export, the host-facing `getContent()`. Protection applies.
+ * - `recovery-snapshot`: the bytes exist only so the viewer can read them back.
+ *   The autosave crash-recovery snapshot in IndexedDB, and the internal
+ *   re-serialise-then-reload cycle behind "apply theme". Protection does NOT
+ *   apply: these are always written in the clear.
+ *
+ * ## Why a recovery snapshot must stay plaintext
+ *
+ * Nothing that reads a snapshot back has a password to give it.
+ * `readBackstageRecentFile`, `restoreSessionDeck` and the Version History
+ * panel's Restore all hand `record.data` straight to `PptxHandler.load()` with
+ * no `password` option, and an encrypted package refuses to open without one
+ * (`EncryptedFileError`). So an encrypted snapshot is not an inconvenience, it
+ * is unreadable: the moment the user turns on protection their crash-recovery
+ * data is silently destroyed, which is the exact opposite of what autosave is
+ * for.
+ *
+ * Encrypting it "properly" is not available either. Decrypting on recovery
+ * means the key has to outlive the crash the snapshot exists for, so it would
+ * have to sit in the same IndexedDB / localStorage as the snapshot itself,
+ * next to the ciphertext it unlocks. That is not a security boundary, it is
+ * theatre. Prompting the user instead only works if they remember the password
+ * of a deck they lost, which is precisely the moment they will not.
+ *
+ * ## The tradeoff this accepts (deliberately, not by omission)
+ *
+ * A password-protected deck DOES leave its content in cleartext at rest in the
+ * origin's IndexedDB. Anyone with the browser profile, or any script running on
+ * the origin, can read it. What limits the exposure: snapshots are scoped to
+ * the origin and profile, aged out by the store, and clearable from
+ * File > Account > Storage & Privacy (`clearLocalStorageData`). A user who
+ * cannot accept plaintext at rest should switch AutoSave off, which stops the
+ * snapshot being written at all.
+ *
+ * The rejected alternative was "skip autosave entirely while a password is
+ * set". It removes the plaintext, but it also removes crash recovery without
+ * telling anyone, so a crash loses the whole editing session. Losing data
+ * quietly is the failure mode we are fixing, not a fix for it.
+ */
+type DeckSavePurpose = 'user-file' | 'recovery-snapshot';
+/**
+ * What the Protect-Presentation UI knows at save time. `password` is the secret
+ * the dialog captured; `passwordProtected` is the separate "is protected" flag
+ * some bindings track for the badge. When the flag is explicitly `false` the
+ * deck saves in the clear even if a stale secret is still around, so removing
+ * a password can never leave the next save encrypted.
+ *
+ * `purpose` defaults to `'user-file'`; see {@link DeckSavePurpose} for why
+ * `'recovery-snapshot'` overrides the password.
+ */
+interface DeckSaveIntent {
+  password?: string | null;
+  passwordProtected?: boolean;
+  purpose?: DeckSavePurpose;
+}
 //#endregion
 //#region src/render/viewer-preferences.d.ts
 /** Framework-neutral viewer preferences surfaced by Settings dialogs. */
@@ -9134,6 +9400,15 @@ interface ViewerGeneralOptions {
   userName: string;
   userInitials: string;
   showStartScreen: boolean;
+  /**
+   * Lets the user hand a local font file to the viewer so decks authored
+   * with a font the browser lacks render with the real face.
+   *
+   * Off by default. The registration reads a file the user picks and adds it
+   * to the page's font set for the session, which is a capability a host
+   * embedding the viewer should opt into rather than inherit.
+   */
+  enableCustomFontUpload: boolean;
 }
 interface ViewerProofingOptions {
   autoCorrectTwoInitialCapitals: boolean;
@@ -10168,6 +10443,14 @@ interface AutosaveDeps {
     getSections?: () => PptxSection[];
     /** The live core handler used to serialize slides to `.pptx` bytes. */
     getHandler: () => PptxHandler | null;
+    /**
+     * The Protect-Presentation state, forwarded to the shared save decision.
+     * Optional, and deliberately inert: a recovery snapshot is written in the
+     * clear whatever it says (see `deck-save-encryption` in
+     * `pptx-viewer-shared`). It is threaded through so the snapshot path uses
+     * the same one decision function as every real save.
+     */
+    getSaveIntent?: () => DeckSaveIntent;
     /**
      * Monotonic load counter: a change means a fresh presentation was seeded (not
      * a user edit), so the watcher clears dirty instead of arming a save.
@@ -10564,6 +10847,8 @@ declare class EditorMasterController {
     enter(masterIndex?: number, layoutIndex?: number | null): void;
     enterTab(tab: MasterViewTab): void;
     exit(): void;
+    /** The document shape the shared master-view rules operate on. */
+    private document;
     activeElements(): PptxElement[] | null;
     replace(elements: PptxElement[]): boolean;
     cloneMasters(): PptxSlideMaster[];
@@ -10661,6 +10946,13 @@ declare class EditorSlidesController {
      * deck is loaded. Backs the Home tab's Layout dropdown (React parity).
      */
     availableLayouts(): Promise<PptxLayoutOption[]>;
+    /**
+     * Artwork thumbnails for the New Slide / Layout galleries, keyed by path.
+     *
+     * A method rather than state: parsing every layout part is only worth doing
+     * once a gallery is opened, and core memoises the result.
+     */
+    layoutPreviews(): Promise<ReadonlyMap<string, PptxLayoutPreview>>;
     /** Re-map the current slide onto `layoutPath`. Returns its index, or null when not editable. */
     applyLayout(layoutPath: string): Promise<number | null>;
     /**
@@ -10701,6 +10993,66 @@ declare class EditorTransitionController {
     #private;
     constructor(editor: EditorState);
     applyTransition(type: PptxTransitionType, durationMs: number, applyToAll: boolean): void;
+    /**
+     * Commit the Transitions tab's whole draft (preset + duration + the Advance
+     * Slide modifiers) in one undoable step.
+     *
+     * The draft, and what it means for a slide's `p:transition`, is decided in
+     * `pptx-viewer-shared` (`ribbon-transitions`) so every binding writes the
+     * same fields; this only routes the result through `commitSlides`. Unlike
+     * `applyTransition`'s apply-to-all, the draft is MERGED onto each target so a
+     * slide keeps its authored direction / spokes / sound.
+     */
+    applyRibbonDraft(draft: RibbonTransitionDraft, applyToAll: boolean): void;
+}
+
+/**
+ * The block of table cells the user has marquee'd on the canvas.
+ *
+ * Svelte shipped without this model at all: `context-menu-dispatch` hard-coded
+ * `hasMultiCellSelection: false`, so PowerPoint's "Merge Cells" could never be
+ * offered and a user could only ever merge one cell rightwards or downwards.
+ *
+ * None of the rectangle math lives here. `computeSelectionRect` in
+ * `pptx-viewer-shared` owns it, and it is merge-AWARE: dragging across a cell
+ * that already spans expands the rectangle to cover the whole span, so the
+ * highlighted block is always a real rectangle in model coordinates. (The
+ * vanilla binding carries a private `rectangle()` helper that ignores spans;
+ * that is a bug, not a second model, and is deliberately not copied.)
+ *
+ * @module editor/table-cell-selection
+ */
+/** A click on a `<td>`, in model (unmerged) coordinates. */
+interface TableCellPoint {
+    rowIndex: number;
+    columnIndex: number;
+}
+declare class TableCellSelection {
+    /** The table element the range belongs to, or null when there is none. */
+    elementId: string | null;
+    /** Where the range started (the un-shifted click). */
+    anchor: CellCoord | null;
+    /** The current rectangle, already expanded over any merged cells it meets. */
+    rect: CellRect | null;
+    /** Every cell in the current range, row-major. Empty when there is none. */
+    get cells(): CellCoord[];
+    /** True once the range covers a block, i.e. once merging becomes possible. */
+    get hasBlock(): boolean;
+    /** The range on `elementId`, or an empty array when it belongs elsewhere. */
+    cellsFor(elementId: string | null | undefined): CellCoord[];
+    /** Is this cell of this element inside the highlighted block? */
+    contains(elementId: string, row: number, col: number): boolean;
+    /** A plain click: the range collapses to the clicked cell, which anchors it. */
+    begin(elementId: string, cell: TableCellPoint, tableData: PptxTableData): void;
+    /**
+     * A Shift-click: stretch anchor -> cell into a rectangle. Falls back to
+     * anchoring when there is no anchor yet (or it belongs to another table), so
+     * a Shift-click is never a no-op.
+     */
+    extend(elementId: string, cell: TableCellPoint, tableData: PptxTableData): void;
+    clear(): void;
+    /** Drop the range when the element selection has moved off its table. */
+    syncElement(selectedElementId: string | null): void;
 }
 
 interface EditorStateDeps {
@@ -10726,13 +11078,52 @@ declare class EditorState {
      * carried through the undo snapshot and re-emitted on save.
      */
     tagCollections: PptxTagCollection[];
+    /**
+     * The deck's active theme, kept here so the Home tab's font dropdown can
+     * lead with the theme fonts. Set by the viewer once a deck is loaded;
+     * deliberately outside {@link EditorSnapshot} because it is not content the
+     * undo stack owns.
+     */
+    theme: PptxTheme | undefined;
+    /**
+     * Families the deck embeds, offered as their own font-dropdown group. Write
+     * through {@link adoptEmbeddedFontFamilies} so {@link embedFonts} is reseeded
+     * with them.
+     */
+    embeddedFontFamilies: readonly string[];
+    /**
+     * File > Fonts > "Embed fonts in the file". Session state like
+     * {@link savePassword}, not document content, so undo never restores it.
+     * Seeded from the loaded deck (see {@link adoptEmbeddedFontFamilies}): a deck
+     * that arrived with embedded fonts keeps them on save, so the switch has to
+     * start "on" or turning it off would be the only way to describe what save
+     * already does. Read by `saveEditorDocument`.
+     */
+    embedFonts: boolean;
+    /**
+     * Families the user registered from a local font file this session
+     * (File > Options > Fonts, off by default). Session state, never persisted:
+     * the font binary is the user's, not ours to store.
+     */
+    customFontFamilies: readonly string[];
     masterViewTarget: MasterViewTarget | null;
     readonly selection: EditorSelection;
+    /** The block of table cells marquee'd inside the selected table, if any. */
+    readonly tableCells: TableCellSelection;
     editable: boolean;
     dirty: boolean;
     editTemplateMode: boolean;
     interactionActive: boolean;
     clipboard: ElementClipboardPayload | null;
+    /**
+     * File ▸ Info ▸ Protect Presentation state. Deliberately NOT part of
+     * {@link EditorSnapshot}: the secret is session state, not document content,
+     * so undo must never restore or clear it. {@link saveIntent} feeds it to the
+     * shared `planDeckSave`, which routes a protected save through
+     * `saveEncrypted` (an OLE2 container) instead of `save` (a plain ZIP).
+     */
+    passwordProtected: boolean;
+    savePassword: string | null;
     /** Undo/redo stack; the `canUndo` / `canRedo` getters below mirror it. */
     readonly history: EditorHistoryState;
     readonly clipboardOps: EditorClipboardController;
@@ -10770,6 +11161,15 @@ declare class EditorState {
     applyRemoteSlides(slides: PptxSlide[]): void;
     reset(): void;
     select(id: string | null): void;
+    /** The element with `id` on the surface the pointer acts on, or undefined. */
+    elementById(id: string): PptxElement | undefined;
+    /**
+     * May the pointer act on `id` at all? Two gates, both of which must pass:
+     * the template rule (an inherited master/layout node is inert unless
+     * edit-template mode is on) and the element's own authored `a:spLocks`. The
+     * lock half was missing entirely, which is why a `noSelect` shape from a
+     * real deck was as selectable and draggable as any other.
+     */
     isElementInteractive(id: string): boolean;
     setTemplateEditing(enabled: boolean): void;
     /** Apply the File > Options "maximum number of undos" value. */
@@ -10790,6 +11190,21 @@ declare class EditorState {
     commitSlides(next: PptxSlide[]): void;
     /** A deep clone of the whole editable document (one undo entry, or save input). */
     snapshot(): EditorSnapshot;
+    /**
+     * Adopt the families a freshly loaded deck embeds, and reseed
+     * {@link embedFonts} to the position that describes the file save would write
+     * right now. Deliberately not an undo step: the parsed font list is not a
+     * user edit.
+     */
+    adoptEmbeddedFontFamilies(families: readonly string[]): void;
+    /** How File > Fonts should render its toggle for the loaded deck. */
+    get fontEmbedding(): FontEmbeddingDescriptor;
+    /** The Protect-Presentation state every save path hands to `planDeckSave`. */
+    saveIntent(): DeckSaveIntent;
+    /** File ▸ Info ▸ Protect Presentation: arm password encryption for saves. */
+    setSavePassword(password: string): void;
+    /** File ▸ Info ▸ Protect Presentation: back to saving in the clear. */
+    clearSavePassword(): void;
     deleteSelected: () => void;
     duplicateSelected: () => string | null;
     applyElementPatch: (id: string, patch: Partial<PptxElement>) => void;
@@ -10901,6 +11316,30 @@ interface EditorMarqueeRect extends MarqueeRect {
     additive: boolean;
 }
 
+/**
+ * What the selection overlay is allowed to offer, given the authored
+ * `a:spLocks` on the selected element(s).
+ *
+ * The lock composition itself is NOT decided here: `canInteractWithElement` in
+ * `pptx-viewer-shared` is the one decision function all five bindings consult,
+ * and this module only folds its per-element verdict into the collective one an
+ * overlay drawn around N elements needs. Keeping it in a plain `.ts` module
+ * (rather than inside `EditorController` or the overlay SFC) keeps both of
+ * those within the repo's file-size budget and makes the rule unit-testable
+ * without a component mount.
+ *
+ * @module editor/editor-selection-interactivity
+ */
+/** The chrome the overlay may draw for the current selection. */
+interface SelectionInteractivity {
+    /** Draw (and honour) the eight resize handles. */
+    resizable: boolean;
+    /** Draw (and honour) the rotate stem + knob. */
+    rotatable: boolean;
+    /** The amber adjustment diamond, or null when there is none to draw. */
+    adjust: ShapeAdjustmentHandleDescriptor | null;
+}
+
 declare class EditorController {
     #private;
     snapLines: readonly SnapLine[];
@@ -10908,6 +11347,12 @@ declare class EditorController {
     marquee: EditorMarqueeRect | null;
     constructor(editor: EditorState, deps: EditorControllerDeps);
     get overlayBox(): OverlayBox | null;
+    /**
+     * Which selection chrome the authored `a:spLocks` still permit, plus the
+     * shape-adjustment descriptor. The overlay only ever sees an `OverlayBox`,
+     * so the element-level verdict is computed here and passed down as a prop.
+     */
+    get interactivity(): SelectionInteractivity;
     get editing(): boolean;
     get selectionCount(): number;
     get editingElement(): PptxElement | undefined;
@@ -10920,6 +11365,7 @@ declare class EditorController {
     onStageContextMenu: (event: MouseEvent) => void;
     onHandlePointerDown: (handle: ResizeHandleId, event: PointerEvent) => void;
     onRotatePointerDown: (event: PointerEvent) => void;
+    onAdjustPointerDown: (event: PointerEvent) => void;
     onKeyDown: (event: KeyboardEvent) => void;
     /** Open the inline text editor over `id` when the element carries text. */
     enterInlineEdit(id: string): void;

package/dist/viewer/index.js

@@ -1,4 +1,4 @@
-import { A as e, O as a, a as s, c as t, ct as i, d as l, f as S, g as n, i as v, k as o, l as d, n as b, o as c, r as g, s as p, st as x, t as w, u as T } from "../export-DxMXX_It.js";
+import { A as e, O as a, a as s, c as t, ct as i, d as l, f as S, g as n, i as v, k as o, l as d, n as b, o as c, r as g, s as p, st as x, t as w, u as T } from "../export-DbSAFc8m.js";
 var m = e, A = o, P = a;
 export {
   w as PowerPointViewer,