fika-editor 3.0.1 → 3.0.2

package/dist/types/components/Button.d.ts

@@ -13,5 +13,6 @@ export type IButtonProps = {
     'data-tooltip'?: string;
     'data-export-format'?: string;
     'data-editor-insert'?: string;
+    'data-align'?: string;
 };
-export default function Button({ checked, disabled, type, size, first, last, onClick, children, style, className, 'data-tooltip': dataTooltip, 'data-export-format': dataExportFormat, 'data-editor-insert': dataEditorInsert, }: IButtonProps): import("react").JSX.Element;
+export default function Button({ checked, disabled, type, size, first, last, onClick, children, style, className, 'data-tooltip': dataTooltip, 'data-export-format': dataExportFormat, 'data-editor-insert': dataEditorInsert, 'data-align': dataAlign, }: IButtonProps): import("react").JSX.Element;

package/dist/types/components/ColorSwatches.d.ts

@@ -13,9 +13,10 @@ export type IColorSwatchesProps = {
     className?: string;
     style?: CSSProperties;
     'data-tooltip'?: string;
+    'data-swatches'?: string;
     onUpdateModelValue?: (value: string) => void;
 };
 export declare const HIGHLIGHT_SWATCHES: string[];
-declare function ColorSwatches({ modelValue, extraColors, includeTheme, includeNeutrals, allowNone, noneValue, allowCustom, wrap, customTitle, noneTitle, className, style, 'data-tooltip': dataTooltip, onUpdateModelValue, }: IColorSwatchesProps): import("react").JSX.Element;
+declare function ColorSwatches({ modelValue, extraColors, includeTheme, includeNeutrals, allowNone, noneValue, allowCustom, wrap, customTitle, noneTitle, className, style, 'data-tooltip': dataTooltip, 'data-swatches': dataSwatches, onUpdateModelValue, }: IColorSwatchesProps): import("react").JSX.Element;
 declare const _default: import("react").MemoExoticComponent<typeof ColorSwatches>;
 export default _default;

package/dist/types/components/Draggable.d.ts

@@ -1,28 +1,33 @@
 import { type MouseEventHandler, type ReactNode } from 'react';
 import type { ThumbnailVirtualizerApi } from '../views/Editor/Thumbnails/useThumbnailVirtualizer';
+import { type OverlayPaint } from './draggableLayout';
 type ItemRender = (args: {
     element: any;
     index: number;
 }) => ReactNode;
+type OverlayRender = (paint: OverlayPaint) => ReactNode;
 type VirtualizerApi = ThumbnailVirtualizerApi;
-export default function Draggable({ modelValue, list, itemKey, item, children, className, onEnd, onUpdateModelValue, onContextMenu, disabled, handle, scrollRef, virtualItems, virtualizer, totalSize, }: {
+/** Drag ghost for slide rails: the live slide DOM at thumb size. */
+export declare const slideDragOverlay: OverlayRender;
+export default function Draggable({ modelValue, list, itemKey, item, children, className, onEnd, onUpdateModelValue, onContextMenu, disabled, handle, scrollRef, virtualItems, virtualizer, totalSize, overlayRender, }: {
     modelValue?: any[];
     list?: any[];
     itemKey?: string | ((item: any) => string);
     item?: ItemRender;
     children?: ReactNode;
     className?: string;
-    disabled?: boolean;
-    handle?: string;
-    onContextMenu?: MouseEventHandler<HTMLDivElement>;
     onEnd?: (event: {
         oldIndex: number;
         newIndex: number;
     }) => void;
     onUpdateModelValue?: (next: any[]) => void;
+    onContextMenu?: MouseEventHandler<HTMLDivElement>;
+    disabled?: boolean;
+    handle?: string;
     scrollRef?: VirtualizerApi['scrollRef'];
     virtualItems?: VirtualizerApi['virtualItems'];
     virtualizer?: VirtualizerApi['virtualizer'];
     totalSize?: number;
+    overlayRender?: OverlayRender;
 }): import("react").JSX.Element;
 export {};

package/dist/types/configs/animation.d.ts

@@ -259,6 +259,8 @@ interface SlideAnimation {
     label: string;
     value: TurningMode;
 }
+/** Default slide-to-slide transition when a slide has no turningMode (PowerPoint-style: none). */
+export declare const DEFAULT_TURNING_MODE: TurningMode;
 /** Locale-free slide transition values. Resolve labels via getSlideAnimations(). */
 export declare const SLIDE_ANIMATIONS: {
     value: TurningMode;

package/dist/types/configs/font.d.ts

@@ -19,8 +19,6 @@ export interface FontOption {
     label: string;
     value: string;
 }
-/** CJK faces that used to ship with extras builds; strip them from templates. */
-export declare const EASTERN_EXTRAS_FONT_VALUES: string[];
 /** @deprecated Use FONT_VALUES — kept for loadGoogleFonts preset detection */
 export declare const FONTS: FontOption[];
 export declare function getFonts(): FontOption[];

package/dist/types/configs/templates.d.ts

@@ -8,12 +8,8 @@ export interface TemplatePayload {
     theme?: Partial<SlideTheme>;
 }
 export type TemplatePayloadLoader = () => Promise<TemplatePayload | Slide[]>;
-export interface TemplateNormalizationConfig {
-    stripFontFamilies: string[];
-}
 export declare const setCustomTemplateLoaders: (loaders?: Record<string, TemplatePayloadLoader>) => void;
 export declare const listCustomTemplateIds: () => string[];
 export declare const isKnownTemplateId: (id: string) => any;
 export declare const loadConfiguredTemplate: (id: string) => Promise<Slide[] | TemplatePayload>;
-export declare const TEMPLATE_NORMALIZATION_CONFIG: TemplateNormalizationConfig;
-export declare const normalizeTemplatePayload: (payload: TemplatePayload | Slide[], LL: TranslationFunctions, config?: TemplateNormalizationConfig) => TemplatePayload;
+export declare const normalizeTemplatePayload: (payload: TemplatePayload | Slide[], LL: TranslationFunctions) => TemplatePayload;

package/dist/types/embed/agentic/templates.d.ts

@@ -1,4 +1,4 @@
-import { type TemplatePayload } from '../../configs/templates';
+import { type TemplatePayload, type TemplatePayloadLoader } from '../../configs/templates';
 import type { Slide, SlideTheme, SlideType } from '../../types/slides';
 export interface FikaTemplateSummary {
     id: string;
@@ -20,6 +20,7 @@ export interface FikaTemplateSlidesCatalogResult {
     slideCount: number;
     byType: FikaTemplateSlidesCatalog;
 }
+export declare function registerTemplateLoaders(loaders?: Record<string, TemplatePayloadLoader>): void;
 export declare function listTemplateCatalog(): FikaTemplateSummary[];
 export declare function loadTemplatePayload(templateId: string): Promise<TemplatePayload>;
 export declare function buildTemplateSlidesCatalog(templateId: string): Promise<FikaTemplateSlidesCatalogResult>;

package/dist/types/embed/agentic/types.d.ts

@@ -743,7 +743,7 @@ export interface FikaAgentTextApi {
     }): Promise<FikaCommandResult<PPTTextElement>>;
 }
 export interface FikaAgentShapesApi {
-    presets(categoryKey?: ShapeCategoryKey): FikaShapePreset[];
+    presets(categoryKey?: ShapeCategoryKey | 'rect'): FikaShapePreset[];
     get(elementId: string, slideId?: string): PPTShapeElement | null;
     create(input?: FikaCreateShapeInput, meta?: FikaCommandMeta): Promise<FikaCommandResult<PPTShapeElement>>;
     patch(elementId: string, patch: FikaShapePatch, meta?: FikaCommandMeta & {
@@ -855,6 +855,7 @@ export interface FikaAgentChartsApi {
     }): Promise<FikaCommandResult<PPTChartElement>>;
     addSeries(elementId: string, series: number[], meta?: FikaCommandMeta & {
         slideId?: string;
+        legend?: string;
     }): Promise<FikaCommandResult<PPTChartElement>>;
     deleteSeries(elementId: string, index: number, meta?: FikaCommandMeta & {
         slideId?: string;
@@ -1255,6 +1256,7 @@ export interface FikaCommandPayloadMap {
     'slides.applyBackground': {
         background: SlideBackground;
         slideIds?: string[];
+        slideId?: string | string[];
     };
     'slides.applyBackgroundToAll': {
         background: SlideBackground;
@@ -1364,10 +1366,12 @@ export interface FikaCommandPayloadMap {
     };
     'elements.lock': {
         elementId: string | string[];
+        slideId?: string;
         locked?: boolean;
     };
     'elements.unlock': {
         elementId: string | string[];
+        slideId?: string;
     };
     'elements.hide': {
         elementId: string | string[];
@@ -1451,6 +1455,48 @@ export interface FikaCommandPayloadMap {
         slideId?: string;
         direction?: FikaLineDirectionInput;
     };
+    'shapes.presets': {
+        categoryKey?: ShapeCategoryKey | 'rect';
+    } | undefined;
+    'shapes.create': FikaCreateShapeInput | undefined;
+    'shapes.patch': {
+        elementId: string;
+        slideId?: string;
+        patch: FikaShapePatch;
+    };
+    'shapes.update': {
+        elementId: string;
+        slideId?: string;
+        patch: FikaShapePatch;
+    };
+    'shapes.setPath': {
+        elementId: string;
+        slideId?: string;
+        path: string;
+        viewBox?: PPTShapeElement['viewBox'];
+        fixedRatio?: boolean;
+    };
+    'shapes.setFormula': {
+        elementId: string;
+        slideId?: string;
+        pathFormula: PPTShapeElement['pathFormula'];
+        keypoints?: number[];
+    };
+    'shapes.setFill': {
+        elementId: string;
+        slideId?: string;
+        fill: FikaShapeFillInput;
+    };
+    'shapes.setOutline': {
+        elementId: string;
+        slideId?: string;
+        outline?: FikaShapePatch['outline'];
+    };
+    'shapes.setText': {
+        elementId: string;
+        slideId?: string;
+        text?: Partial<ShapeText>;
+    };
     'animations.list': {
         slideId?: string;
         elementId?: string;
@@ -1580,6 +1626,7 @@ export interface FikaCommandPayloadMap {
         elementId: string;
         slideId?: string;
         series: number[];
+        legend?: string;
     };
     'charts.deleteSeries': {
         elementId: string;
@@ -1912,6 +1959,15 @@ export interface FikaCommandResultDataMap {
     'lines.setStyle': PPTLineElement;
     'lines.setArrowheads': PPTLineElement;
     'lines.setDirection': PPTLineElement;
+    'shapes.presets': FikaShapePreset[];
+    'shapes.create': PPTShapeElement;
+    'shapes.patch': PPTShapeElement;
+    'shapes.update': PPTShapeElement;
+    'shapes.setPath': PPTShapeElement;
+    'shapes.setFormula': PPTShapeElement;
+    'shapes.setFill': PPTShapeElement;
+    'shapes.setOutline': PPTShapeElement;
+    'shapes.setText': PPTShapeElement;
     'animations.list': PPTAnimation[];
     'animations.catalog': FikaAnimationCatalog;
     'animations.sequence': FikaAnimationSequenceStep[];

package/dist/types/hooks/useScreening.d.ts

@@ -1,8 +1,10 @@
+import { enterScreening, enterScreeningFromStart, exitScreening } from '../utils/screening';
 import { prefetchScreen } from '../views/Screen/lazy';
+export { beginScreening, enterScreening, enterScreeningFromStart, exitScreening } from '../utils/screening';
 export default _default;
 declare function _default(): {
-    enterScreening: () => void;
-    enterScreeningFromStart: () => void;
-    exitScreening: () => void;
+    enterScreening: typeof enterScreening;
+    enterScreeningFromStart: typeof enterScreeningFromStart;
+    exitScreening: typeof exitScreening;
     prefetchScreen: typeof prefetchScreen;
 };

package/dist/types/i18n/i18n-types.d.ts

@@ -3036,11 +3036,11 @@ export type NamespaceEditorTranslation = {
     };
     slideAnimation: {
         /**
-         * A​p​p​l​y​ ​t​o​ ​a​l​l​ ​s​l​i​d​e​s
+         * U​s​e​ ​o​n​ ​e​v​e​r​y​ ​s​l​i​d​e
          */
         applyToAll: string;
         /**
-         * A​p​p​l​i​e​d​ ​t​o​ ​a​l​l​ ​s​l​i​d​e​s
+         * O​n​ ​e​v​e​r​y​ ​s​l​i​d​e
          */
         appliedToAll: string;
     };
@@ -8185,11 +8185,11 @@ export type TranslationFunctions = {
         };
         slideAnimation: {
             /**
-             * Apply to all slides
+             * Use on every slide
              */
             applyToAll: () => LocalizedString;
             /**
-             * Applied to all slides
+             * On every slide
              */
             appliedToAll: () => LocalizedString;
         };

package/dist/types/store/index.d.ts

@@ -1,5 +1,5 @@
 import { useMainStore, selectHandleElement, selectActiveElementList } from './main';
-import { useSlidesStore, selectCurrentSlide, selectCurrentSlideAnimations, selectFormatedAnimations, selectSlideId, selectElementById, selectIsEmptySlide } from './slides';
+import { useSlidesStore, selectCurrentSlide, selectSlideById, selectCurrentSlideAnimations, selectFormatedAnimations, selectSlideId, selectElementById, selectIsEmptySlide } from './slides';
 import { useSnapshotStore, selectCanUndo, selectCanRedo } from './snapshot';
 import { useKeyboardStore, selectCtrlOrShiftKeyActive, syncPointerModifiers } from './keyboard';
 import { useScreenStore } from './screen';
@@ -7,4 +7,4 @@ import { useImportConfirmStore } from './importConfirm';
 export declare const useActiveElementList: () => import("../embed").PPTElement[];
 export declare const useCurrentSlideAnimations: () => import("../embed").PPTAnimation[];
 export declare const useFormatedAnimations: () => import("./slides").FormatedAnimation[];
-export { useMainStore, selectHandleElement, selectActiveElementList, useSlidesStore, selectCurrentSlide, selectIsEmptySlide, selectCurrentSlideAnimations, selectFormatedAnimations, selectSlideId, selectElementById, useSnapshotStore, selectCanUndo, selectCanRedo, useKeyboardStore, selectCtrlOrShiftKeyActive, syncPointerModifiers, useScreenStore, useImportConfirmStore, };
+export { useMainStore, selectHandleElement, selectActiveElementList, useSlidesStore, selectCurrentSlide, selectSlideById, selectIsEmptySlide, selectCurrentSlideAnimations, selectFormatedAnimations, selectSlideId, selectElementById, useSnapshotStore, selectCanUndo, selectCanRedo, useKeyboardStore, selectCtrlOrShiftKeyActive, syncPointerModifiers, useScreenStore, useImportConfirmStore, };

package/dist/types/store/slides.d.ts

@@ -1,4 +1,9 @@
 import type { Slide, SlideTheme, PPTElement, PPTAnimation, SlideTemplate, ImportedSlideTemplate } from '../types/slides';
+export type AddSlideOptions = {
+    index?: number;
+    select?: boolean;
+    keepSectionTag?: boolean;
+};
 export declare function buildDefaultTemplates(): SlideTemplate[];
 interface RemovePropData {
     id: string;
@@ -34,10 +39,11 @@ export interface SlidesActions {
     setTemplates: (templates: SlideTemplate[]) => void;
     addImportedTemplate: (template: ImportedSlideTemplate) => void;
     replaceSlide: (slide: Slide, slideId?: string) => void;
-    addSlide: (slide: Slide | Slide[]) => void;
+    addSlide: (slide: Slide | Slide[], options?: AddSlideOptions) => void;
     updateSlide: (props: Partial<Slide>, slideId?: string) => void;
     removeSlideProps: (data: RemovePropData) => void;
     deleteSlide: (slideId: string | string[]) => void;
+    moveSlide: (fromIndex: number, toIndex: number) => void;
     reorderSlides: (oldIndex: number, newIndex: number) => void;
     updateSlideIndex: (index: number) => void;
     addElement: (element: PPTElement | PPTElement[]) => void;
@@ -47,6 +53,13 @@ export interface SlidesActions {
 }
 export type SlidesStore = SlidesState & SlidesActions;
 export declare const selectCurrentSlide: (state: SlidesState) => Slide;
+/**
+ * Slide by id — the owning slide for a rendered slide tree. Contrast and
+ * placeholder painting must resolve against THIS slide, not the editor's
+ * current one, or off-screen renders (thumbnail captures, presenter preview)
+ * inherit the wrong background/elements.
+ */
+export declare const selectSlideById: (state: SlidesState, slideId: string | undefined) => Slide;
 export declare const selectIsEmptySlide: (state: SlidesState) => boolean;
 export declare const selectSlideId: (state: SlidesState) => string;
 export declare const selectElementById: (id: string) => (state: SlidesState) => PPTElement | undefined;
@@ -1658,10 +1671,11 @@ export declare const useSlidesStore: import("zustand").UseBoundStore<Omit<import
         setTemplates: (templates: SlideTemplate[]) => void;
         addImportedTemplate: (template: ImportedSlideTemplate) => void;
         replaceSlide: (slide: Slide, slideId?: string) => void;
-        addSlide: (slide: Slide | Slide[]) => void;
+        addSlide: (slide: Slide | Slide[], options?: AddSlideOptions) => void;
         updateSlide: (props: Partial<Slide>, slideId?: string) => void;
         removeSlideProps: (data: RemovePropData) => void;
         deleteSlide: (slideId: string | string[]) => void;
+        moveSlide: (fromIndex: number, toIndex: number) => void;
         reorderSlides: (oldIndex: number, newIndex: number) => void;
         updateSlideIndex: (index: number) => void;
         addElement: (element: PPTElement | PPTElement[]) => void;
@@ -3274,10 +3288,11 @@ export declare const useSlidesStore: import("zustand").UseBoundStore<Omit<import
         setTemplates: (templates: SlideTemplate[]) => void;
         addImportedTemplate: (template: ImportedSlideTemplate) => void;
         replaceSlide: (slide: Slide, slideId?: string) => void;
-        addSlide: (slide: Slide | Slide[]) => void;
+        addSlide: (slide: Slide | Slide[], options?: AddSlideOptions) => void;
         updateSlide: (props: Partial<Slide>, slideId?: string) => void;
         removeSlideProps: (data: RemovePropData) => void;
         deleteSlide: (slideId: string | string[]) => void;
+        moveSlide: (fromIndex: number, toIndex: number) => void;
         reorderSlides: (oldIndex: number, newIndex: number) => void;
         updateSlideIndex: (index: number) => void;
         addElement: (element: PPTElement | PPTElement[]) => void;

package/dist/types/types/injectKey.d.ts

@@ -6,6 +6,12 @@ export type RadioGroupValue = {
 };
 export declare const SlideScaleContext: import("react").Context<number>;
 export declare const SlideIdContext: import("react").Context<string>;
+/**
+ * True while the slide tree is rendered only to be rasterized (thumbnail
+ * stage). Elements that gate on "is the current slide" (media players) still
+ * render — paused — so captures match the editor canvas.
+ */
+export declare const SlideCaptureContext: import("react").Context<boolean>;
 export declare const RadioGroupValueContext: import("react").Context<RadioGroupValue>;
 export declare const injectKeySlideScale: import("react").Context<number>;
 export declare const injectKeySlideId: import("react").Context<string>;

package/dist/types/utils/canvasHitTest.d.ts

@@ -73,7 +73,16 @@ export interface VisualHitRect {
     height: number;
     rotate: number;
     zIndex: number;
+    /**
+     * Empty placeholder slot (dashed prompt, no authored content). It is a
+     * background affordance: any element carrying visible content that
+     * overlaps it wins the pointer regardless of z-order — users click the
+     * text they SEE, not the dashed frame behind it.
+     */
+    yieldToContent?: boolean;
 }
+/** True when the element paints authored content the user can click "on". */
+export declare function elementHasClickableContent(element: PPTElement): boolean;
 /**
  * Map a slide element to a hit rectangle in `.viewport-wrapper` visual pixels.
  *
@@ -121,16 +130,19 @@ export type VisualHitPlanInput = {
 export type VisualHitPlan = {
     hitRects: VisualHitRect[];
     occluderRects: VisualHitRect[];
+    /** Rects of elements painting authored content — they beat empty placeholder slots. */
+    contentRects: VisualHitRect[];
 };
 /**
  * Selected / editing / clipping boxes leave HitLayer so Operate or the live
  * editor can own the pointer. Those boxes must still punch holes in every
  * *lower* hit rect — otherwise the first click works, then hover/click/drag
- * fall through to the card underneath.
+ * fall through to the card underneath. Empty placeholder slots additionally
+ * yield to ANY overlapping content rect regardless of z-order.
  */
 export declare function collectVisualHitPlan(input: VisualHitPlanInput): VisualHitPlan;
 export declare function pointInAnyVisualHitRect(x: number, y: number, rects: VisualHitRect[]): boolean;
-/** Occluders that sit on top of `rect` (same stack level included). */
+/** Occluders that sit on top of `rect` (same stack level included). Empty placeholder slots yield to every occluder. */
 export declare function occludersAboveRect(rect: VisualHitRect, occluders: VisualHitRect[]): VisualHitRect[];
 /**
  * Skip rebuilding hit rects when only HTML content changed,

package/dist/types/utils/commitQueue.d.ts

@@ -0,0 +1,13 @@
+type Flusher = () => void;
+/** Pending editor/table drafts. Returns an unregister function. */
+export declare function registerCommitFlusher(flush: Flusher): () => void;
+/** Runs after drafts are persisted — canvas list sync, etc. */
+export declare function registerAfterCommitDrain(flush: Flusher): () => void;
+/** Persist in-flight drafts without leaving the editor. */
+export declare function flushCommitQueue(): void;
+/**
+ * Persist every in-flight draft, then sync dependents off the store.
+ * Presentation (and any other Activity hide) must call this before unmounting editors.
+ */
+export declare function drainCommitQueue(): void;
+export {};

package/dist/types/utils/cssLength.d.ts

@@ -0,0 +1,8 @@
+/** Compact a CSS length so pixel-units can split it (`13.5 pt` → `13.5pt`). */
+export declare const compactCssLength: (raw: string) => string;
+/** Convert a CSS length to px. Unknown / keyword / % values return undefined. */
+export declare const cssLengthToPx: (raw: string | null | undefined, basePx: number) => number | undefined;
+export declare const cssLengthParts: (raw: string | null | undefined, basePx: number) => {
+    px?: number;
+    em?: number;
+};

package/dist/types/utils/database.d.ts

@@ -1,6 +1,6 @@
 import Dexie, { type EntityTable } from 'dexie';
 import type { Patch } from 'immer';
-import type { Slide } from '../types/slides';
+import type { Slide, SlideTemplate, SlideTheme } from '../types/slides';
 export interface writingBoardImg {
     id: string;
     dataURL: string;
@@ -8,6 +8,11 @@ export interface writingBoardImg {
 export interface Snapshot {
     id: number;
     index: number;
+    title?: string;
+    theme?: SlideTheme;
+    viewportSize?: number;
+    viewportRatio?: number;
+    templates?: SlideTemplate[];
     slides?: Slide[];
     patches?: Patch[];
     inversePatches?: Patch[];

package/dist/types/utils/element.d.ts

@@ -29,6 +29,11 @@ export declare const getRectRotatedOffset: (element: RotatedElementData) => {
     offsetX: number;
     offsetY: number;
 };
+/**
+ * Local control points that define a line's painted path.
+ * Includes elbows so a bent/curved stroke is never clipped to the start–end chord.
+ */
+export declare const getLineLocalPoints: (element: PPTLineElement) => [number, number][];
 /**
  * Axis-aligned bounds of a single element on the canvas.
  * @param element Element data
@@ -39,6 +44,19 @@ export declare const getElementRange: (element: PPTElement) => {
     minY: any;
     maxY: any;
 };
+export type ElementRangeAlign = {
+    minX?: number;
+    maxX?: number;
+    centerX?: number;
+    minY?: number;
+    maxY?: number;
+    centerY?: number;
+};
+/**
+ * Shift left/top so the element's painted AABB matches the given edges or centers.
+ * Lines use control-point bounds, not the start–end chord.
+ */
+export declare const alignElementToRange: (element: PPTElement, target: ElementRangeAlign) => void;
 /**
  * Combined axis-aligned bounds of multiple elements on the canvas.
  * @param elementList Elements to measure

package/dist/types/utils/imageBitmapCache.d.ts

@@ -1,6 +1,18 @@
 import type { Slide } from '../types/slides';
-export declare const getCachedImageBitmap: (src: string) => ImageBitmap | undefined;
-export declare const loadImageBitmap: (src: string) => Promise<ImageBitmap | null>;
+export declare const PREVIEW_BITMAP_MAX_EDGE = 512;
+export declare const PREVIEW_BITMAP_CACHE_MAX = 640;
+export declare const FULL_BITMAP_CACHE_MAX = 64;
+export type LoadImageBitmapOptions = {
+    maxEdge?: number;
+};
+export declare const subscribePreviewBitmaps: (fn: (src: string) => void) => () => void;
+export declare const getCachedImageBitmap: (src: string, options?: LoadImageBitmapOptions) => ImageBitmap | undefined;
+export declare const previewPaintHasMedia: (painted: Set<string> | undefined, srcs: readonly string[]) => boolean;
+export declare const loadImageBitmap: (src: string, options?: LoadImageBitmapOptions) => Promise<ImageBitmap | null>;
+export declare const loadPreviewImageBitmap: (src: string) => Promise<ImageBitmap>;
+export declare const getCachedPreviewImageBitmap: (src: string) => ImageBitmap;
+export declare const collectSlidePreviewSrcs: (slide: Slide) => string[];
 export declare const collectSlideImageSrcs: (slides: readonly Slide[]) => string[];
+export declare const prefetchPreviewImageBitmaps: (srcs: readonly string[]) => void;
 export declare const revokeImageBitmapsNotIn: (keep: Iterable<string>) => void;
 export declare const syncImageBitmapsToSlides: (slides: readonly Slide[]) => void;

package/dist/types/utils/imageSize.d.ts

@@ -0,0 +1,9 @@
+export type ImageSize = {
+    width: number;
+    height: number;
+};
+export declare const readImageSize: (buffer: ArrayBuffer | Uint8Array) => ImageSize | null;
+export declare const resizeToMaxEdge: (width: number, height: number, maxEdge: number) => {
+    width: number;
+    height: number;
+};

package/dist/types/utils/liveElementSize.d.ts

@@ -29,5 +29,24 @@ export type LivePaintExtras = {
     path?: string;
     viewBox?: readonly number[];
 };
-export declare const applyLiveSize: (id: string, left: number, top: number, width: number, height: number, canvasScale: number, extras?: LivePaintExtras) => void;
+/** True when the element's height is text-driven (auto-height box). */
+export declare const autoHeightInsetSum: (el: {
+    type?: string;
+    fixedHeight?: boolean;
+    vertical?: boolean;
+    inset?: readonly number[];
+    text?: {
+        fixedHeight?: boolean;
+        inset?: readonly number[];
+    } | null;
+}) => number | null;
+/**
+ * Height the auto-height element's text actually needs at its CURRENT live
+ * width (call after the width has been painted). scrollHeight reports the
+ * true content height even when the container still carries a stale height.
+ */
+export declare const measureAutoTextHeight: (id: string, insetSum: number) => number | null;
+export declare const applyLiveSize: (id: string, left: number, top: number, width: number, height: number, canvasScale: number, extras?: LivePaintExtras, options?: {
+    forceHeight?: boolean;
+}) => void;
 export {};

package/dist/types/utils/mediaIntern.d.ts

@@ -0,0 +1,12 @@
+import type { Slide } from '../types/slides';
+export declare const isDataUrl: (src: string) => boolean;
+export declare const onMediaInterned: (fn: (from: string, to: string) => void) => () => void;
+/** Data URL and its blob: alias are the same bytes. */
+export declare const bitmapSrcKeys: (src: string) => string[];
+export declare const getInternedBlob: (src: string) => Blob | undefined;
+export declare const startInternSlideMedia: (slide: Slide) => void;
+export declare const internMediaSrc: (src: string) => Promise<string>;
+export declare const visitSlideMediaSrcs: (slide: Slide, visit: (src: string) => void) => void;
+export declare const collectSlideMediaSrcs: (slides: readonly Slide[]) => string[];
+export declare const internSlidesMedia: (slides: Slide[]) => Promise<void>;
+export declare const resetMediaInternForTests: () => void;

package/dist/types/utils/placeholderLayout.d.ts

@@ -30,11 +30,18 @@ export interface TextBoxLayout {
     vAlign: TextAlignVertical;
     /** Flex-column vertical centering without locking box height (content slides title). */
     flexCenterInLayoutBox: boolean;
+    /** Empty placeholder slot (dashed prompt). */
+    emptyPlaceholder: boolean;
     /**
-     * Definite `height` (not `auto`). True for explicit fixed-height and for an
-     * *empty* placeholder slot (dashed box + centered prompt). A filled
-     * auto-height title/subtitle unlocks so the box can grow with the text.
+     * Auto-height paint floored at the committed height (empty placeholder
+     * slots, filled content-slide titles): `height: auto` + `min-height`. The
+     * box grows with the text the same frame the text grows — no clip, and the
+     * painted box never lags behind its glyphs.
      */
+    slotFlooredAuto: boolean;
+    /** Flex-column paint: fixed boxes, empty slots, centered layout titles. */
+    flexColumn: boolean;
+    /** Definite px `height` paint: explicit fixed-height boxes only. */
     lockPaintHeight: boolean;
 }
 export declare const V_ALIGN_JUSTIFY: {
@@ -54,11 +61,23 @@ export declare const authoredTextFitSize: (el: Pick<PPTTextElement, 'placeholder
 export declare const textBoxPaintSize: (el: PPTTextElement, layout: TextBoxLayout) => {
     width: string;
     height: string;
+    minHeight: string;
 };
 export declare const textBoxFlexColumn: (layout: TextBoxLayout) => boolean;
 export declare const textBoxJustify: (layout: TextBoxLayout) => "center" | "flex-end" | "flex-start";
 /**
- * Empty slots keep the dashed frame. Filled auto-height follows the text —
- * including shrinking off the empty-slot floor so Enter can grow the box.
+ * The ONE rule for auto-height commits: the box tracks its text but never
+ * shrinks below its slot floor. Empty slots keep the dashed frame, filled
+ * content-slide titles keep their centered layout slot, every other filled
+ * box hugs the text. The floor never exceeds the current height, so an
+ * already-short slot is never surprise-grown. Returns null when the store
+ * height must not change.
  */
-export declare const shouldBlockPlaceholderHeightShrink: (el: PPTTextElement, measuredHeight: number, contentEmpty: boolean) => boolean;
+export declare const textBoxAutoHeight: (el: PPTTextElement, layout: TextBoxLayout, measuredTextHeight: number) => number | null;
+/** Slot floor for drag-time height measurements (store content, no live editor state). */
+export declare const placeholderHeightFloor: (el: PPTTextElement, slideType?: Slide['type']) => number;
+/**
+ * Fixed mode restores a placeholder to its slot: its "fixed size" is the
+ * designed slot, not whatever the text last hugged.
+ */
+export declare const placeholderFixedRestoreHeight: (el: PPTTextElement) => number;

package/dist/types/utils/prosemirror/commitEditor.d.ts

@@ -1,6 +1,9 @@
 import { editorHtmlLooksEmpty } from './commitPolicy';
 export { editorHtmlLooksEmpty, shouldWriteEditorHtml } from './commitPolicy';
 export declare const richTextHtmlLooksEmpty: typeof editorHtmlLooksEmpty;
+export declare const storeHtmlForElement: (elementId: string) => string;
+/** Activity remounts must not rebuild an empty view over store-owned text. */
+export declare const resolveEditorMountHtml: (elementId: string, value: string) => string;
 /** Persist the live ProseMirror HTML. History is for explicit flushes, not every key. */
 export declare function commitLiveEditorToStore(elementId: string, options?: {
     history?: boolean;

package/dist/types/utils/prosemirror/index.d.ts

@@ -1,5 +1,6 @@
 import { type DirectEditorProps, EditorView } from 'prosemirror-view';
 import { type PluginOptions } from './plugins/index';
+export declare const normalizeFittedFontSizes: (html: string) => string;
 export declare const createDocument: (content: string) => import("prosemirror-model").Node;
 /** Same HTML the live editor paints, so static → edit cannot shift glyphs. */
 export declare const serializeRichTextHtml: (content: string) => string;

package/dist/types/utils/screening.d.ts

@@ -0,0 +1,10 @@
+/** Drain live editors, then enter presentation. No fullscreen — embed/agentic. */
+export declare function beginScreening(options?: {
+    fromStart?: boolean;
+}): void;
+/** Editor Present / F5: drain, screen, then request fullscreen. */
+export declare function enterScreening(options?: {
+    fromStart?: boolean;
+}): void;
+export declare function enterScreeningFromStart(): void;
+export declare function exitScreening(): void;