fika-editor 3.0.1 → 3.0.3

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/elementOutline.d.ts

@@ -1,10 +1,40 @@
-import type { LineStyleType, PPTElementOutline } from '../types/slides';
-/** Clamp corner radius to half the shorter box side. */
+import { type LineStyleType, type PPTElementOutline, type PPTShapeElement } from '../types/slides';
+/** Clamp a resolved pixel corner radius to half the shorter box side. */
 export declare const clampOutlineRadius: (radius: number, width: number, height: number) => number;
+/** Pixel radius for paint/CSS. `radius` is 0–1 of max rounding, or legacy px when `> 1`. */
+export declare const resolveOutlineRadiusPx: (radius: number | undefined, width: number, height: number) => number;
+/** Slider / label percent (0–100) for an authored outline radius. */
+export declare const outlineRadiusToPercent: (radius: number | undefined, width: number, height: number) => number;
+export declare const percentToOutlineRadius: (percent: number) => number;
 export declare const outlineRadiusCss: (radius: number | undefined, width: number, height: number) => string | undefined;
+/**
+ * Rounded rect in local units. `rx`/`ry` are elliptical radii of that space
+ * (circular after a matching non-uniform scale). Skips zero-length edges so
+ * 100% rounding is a pill/circle instead of collapsed quadratic chamfers.
+ */
+export declare const roundedRectEllipsePath: (width: number, height: number, rx: number, ry: number) => string;
+/** Circular-corner rounded rect in pixel space. 100% radius → pill / circle. */
+export declare const roundedRectArcPath: (width: number, height: number, radiusPx: number) => string;
 /** SVG path for a rectangular outline (optionally rounded). */
 export declare const roundedRectOutlinePath: (width: number, height: number, radius?: number) => string;
-/** pptxgenjs `rectRadius` is 0–1 relative to the shorter side. */
+/** Rectangles and rectangle-family formulas the border-radius slider can round. */
+export declare const isRoundableRectShape: (el: Pick<PPTShapeElement, 'path' | 'viewBox' | 'pathFormula'>) => boolean;
+/**
+ * Path the editor / painter / hit-test should use. Outline radius is a 0–1
+ * fraction of max rounding; viewBox scale keeps the corners circular.
+ */
+export declare const resolveShapePaintPath: (el: PPTShapeElement) => string;
+/** Keep ROUND_RECT keypoints / path in sync when the radius slider moves. */
+export declare const shapePropsForOutlineRadius: (el: PPTShapeElement, radius: number) => Partial<PPTShapeElement>;
+export declare const outlineElementPatch: (el: {
+    type: string;
+}, outline: PPTElementOutline, radiusChanged?: boolean) => {
+    outline: PPTElementOutline;
+} & Partial<PPTShapeElement>;
+/**
+ * pptxgenjs-plus `rectRadius` (ECMA-376 `a:gd name="adj"` / 50000).
+ * 0 = sharp corners, 1 = maximum rounding, 0.2 = 20%.
+ */
 export declare const outlineRadiusToPptxRectRadius: (radius: number, width: number, height: number) => number;
 /** pptxtojson emits border colors as a structured solid/gradient object. */
 export type PptxBorderColor = string | {

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

@@ -3,9 +3,13 @@
  *
  * Collects the non-system font families actually used in the deck, fetches their
  * woff2 bytes (bundled via `new URL(...)` so Vite emits them), decompresses
- * woff2 → TTF (via wawoff2), and returns `AddFontOptions[]` for `pptx.addFont()`.
- * PPTX embeds fonts as EOT-wrapped data and pptxgenjs handles TTF/OTF directly,
- * so the only required step is woff2 → TTF decompression.
+ * woff2 → TTF (via woff-lib, pure TS), and returns `AddFontOptions[]` for
+ * `pptx.addFont()`. PPTX embeds fonts as EOT-wrapped data and pptxgenjs handles
+ * TTF/OTF directly, so the only required step is woff2 → TTF decompression.
+ *
+ * woff-lib replaced wawoff2 here: wawoff2 is a Node-targeted Emscripten binary
+ * whose `onRuntimeInitialized` promise never resolves when the runtime fails to
+ * boot inside a bundled web build, hanging exports forever with no error.
  */
 import type pptxgen from 'pptxgenjs-plus';
 type AddFontOptions = Parameters<pptxgen['addFont']>[0];

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/importApply.d.ts

@@ -1,3 +1,5 @@
+import type { TurningMode } from '../types/slides';
+import type { ImportTurningModeInput } from './importTransition';
 export type ImportApplyMode = 'replace' | 'append';
 export interface ImportApplyOptions {
     /**
@@ -5,6 +7,14 @@ export interface ImportApplyOptions {
      * Default is `replace`.
      */
     mode?: ImportApplyMode;
+    /**
+     * Override imported slide transitions. A single mode applies to every slide;
+     * an array or index map sets individual slides (missing entries keep the
+     * file transition, or `defaultTurningMode` / Rise when the file has none).
+     */
+    turningMode?: ImportTurningModeInput;
+    /** Fallback when a slide has no file transition and no per-slide override. */
+    defaultTurningMode?: TurningMode;
     /**
      * Legacy alias: `true` replace, `false` append.
      * An empty deck (0 slides) is always replaced.

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

@@ -0,0 +1,19 @@
+import type { Slide, TurningMode } from '../types/slides';
+export declare const isTurningMode: (value: unknown) => value is TurningMode;
+/** One mode for every slide, or a per-slide list / index map. */
+export type ImportTurningModeInput = TurningMode | Array<TurningMode | null | undefined> | Record<number, TurningMode>;
+export type ImportTransitionOptions = {
+    turningMode?: ImportTurningModeInput;
+    /** Used when a slide has no file transition and no per-slide override. */
+    defaultTurningMode?: TurningMode;
+};
+export type AppliedImportTransitions = {
+    slides: Slide[];
+    /** Set when every imported slide received the same explicit override. */
+    uniformMode?: TurningMode;
+};
+/**
+ * Accept a single mode, an index-aligned array, or a 0- or 1-based index map.
+ */
+export declare const parseImportTurningMode: (value: unknown) => ImportTurningModeInput | undefined;
+export declare const applyImportTransitions: (slides: Slide[], options?: ImportTransitionOptions) => AppliedImportTransitions;

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

@@ -0,0 +1,24 @@
+import type { PPTElement } from '../types/slides';
+/**
+ * One row of the Alt+Click layer picker: an element (or a whole group)
+ * whose visual box contains the probed point.
+ */
+export interface LayerStackEntry {
+    /** Representative element — for groups, the topmost member under the point. */
+    element: PPTElement;
+    /** Ids applied to the selection when this entry is picked (empty when locked). */
+    memberIds: string[];
+    groupId?: string;
+    groupSize?: number;
+    locked: boolean;
+}
+/**
+ * All layers under a wrapper-space point, top → bottom.
+ *
+ * Group members collapse into a single entry (picking one selects the whole
+ * group, matching canvas click behavior). Hidden elements are skipped; locked
+ * elements are listed but marked non-selectable.
+ */
+export declare function layerStackAtPoint(elementList: PPTElement[], canvasScale: number, hiddenElementIdList: Iterable<string>, x: number, y: number): LayerStackEntry[];
+/** Index of the next selectable entry below `fromIndex`, wrapping. -1 when none. */
+export declare function nextSelectableLayer(entries: LayerStackEntry[], fromIndex: number): number;

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

@@ -11,11 +11,11 @@
  *   `.viewport-wrapper` (already sized to the *visual* slide). Position
  *   here is slide × canvasScale.
  *
- * Never use CSS `translate` on the painted box. Auto-size text measures
- * and rasterizes differently under a transform than under `left`/`top`,
- * so the glyphs shift on pointerup when the transform is removed. Write
- * the same `left`/`top` the store will commit — drag and drop are one
- * paint path. Scale already does this (`applyLiveSize`).
+ * Most elements use `left` / `top` so auto-size text keeps the same
+ * measurement and rasterization path during and after the gesture. Complex
+ * transparent surfaces can opt into `data-live-translate3d`; those keep
+ * their raster on a compositor layer while dragging, then settle to the
+ * committed `left` / `top` on pointerup.
  */
 export type LiveOffsetPosition = {
     id: string;
@@ -40,6 +40,7 @@ export type LivePositionCss = {
     visualTop: string;
 };
 export declare const livePositionCss: (left: number, top: number, canvasScale: number) => LivePositionCss;
+export declare const liveTranslate3dCss: (dx: number, dy: number) => string;
 export declare const applyLivePositionStyles: (nodes: LiveOffsetNodes, left: number, top: number, canvasScale: number) => void;
 export declare const readLiveMultiOrigin: (canvasScale: number) => {
     left: 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,21 @@
+import type { Slide } from '../types/slides';
+export declare const isDataUrl: (src: string) => boolean;
+export declare const isBlobUrl: (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;
+/** Live interned data URL for a blob: src, or the original if it is already persistable. */
+export declare const persistableMediaSrc: (src: string) => string;
+/**
+ * Record an object URL created outside the intern layer (e.g. pasted video)
+ * so `getInternedBlob` can still inline its bytes during export.
+ */
+export declare const registerMediaBlob: (url: string, blob: Blob) => void;
+export declare const rewritePersistableMediaSrcs: <T extends Slide>(slides: T[]) => T[];
+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;

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

@@ -0,0 +1,23 @@
+import type { PPTShapeElement } from '../types/slides';
+export declare const shapePathScale: (element: Pick<PPTShapeElement, 'width' | 'height' | 'viewBox'>) => {
+    x: number;
+    y: number;
+};
+/** Same transform the live editor SVG applies to `element.path`. */
+export declare const shapePathTransform: (element: Pick<PPTShapeElement, 'width' | 'height' | 'viewBox'>) => string;
+/**
+ * Editor-equivalent SVG (+ optional ProseMirror label). SnapDOM this instead of
+ * asking Konva to interpret PPTX/catalog arcs — browsers correct `A 50 50`
+ * radii, Konva does not.
+ */
+export declare const shapePaintHtml: (element: PPTShapeElement, text?: {
+    body: string;
+    ink: string;
+    fontFamily: string;
+    align?: string;
+    inset?: [number, number, number, number];
+    lineHeight?: number;
+    letterSpacing?: number;
+    paragraphSpace?: number;
+    fitScale?: number;
+}) => string;

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

@@ -0,0 +1,5 @@
+import type { PPTShapeElement } from '../types/slides';
+export declare const shapeTextIsEmpty: (html?: string) => boolean;
+/** Imported PPTX rects and formula rects that fill the viewBox. */
+export declare const isAxisAlignedRectPath: (path: string, viewBox: [number, number]) => boolean;
+export declare const isSimpleShape: (element: PPTShapeElement) => boolean;

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

@@ -1,3 +1,13 @@
 import type { Slide } from '../types/slides';
 /** Reorder slides without cloning unchanged slide objects (elements/background stay referentially equal). */
 export declare const reorderSlidesPreservingIdentity: (slides: readonly Slide[], oldIndex: number, newIndex: number) => Slide[];
+export declare const insertSlidesPreservingIdentity: (slides: readonly Slide[], index: number, incoming: readonly Slide[]) => Slide[];
+export declare const deleteSlidesPreservingIdentity: (slides: readonly Slide[], slideIds: readonly string[]) => {
+    slides: Slide[];
+    deletedIndexes: number[];
+};
+export declare const slideIndexAfterDelete: (prevIndex: number, prevSlides: readonly Slide[], deletedIds: ReadonlySet<string>, nextLength: number, deletedIndexes: readonly number[]) => number;
+export declare const moveSlidePreservingIdentity: (slides: readonly Slide[], fromIndex: number, toIndex: number) => {
+    slides: Slide[];
+    index: number;
+};

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

@@ -6,6 +6,8 @@ export declare const SNAP_MATCH = 0.51;
 export declare const SLIDE_MARGIN = 40;
 export declare const RELATED_GAP = 240;
 export declare const MAX_CTRL_MEASURES = 8;
+/** Same-row/column objects beat a slightly closer distant line. */
+export declare const RELATION_WEIGHT = 4;
 export type SnapKind = 'edge' | 'center' | 'canvas' | 'spacing' | 'size' | 'grid' | 'measure';
 export type SnapMode = 'smart' | 'grid';
 export interface SnapGuide {
@@ -35,6 +37,8 @@ export interface SnapOptions {
     gridSize: number;
     threshold?: number;
     index?: SnapIndex;
+    /** When set, append Ctrl distance badges for the already-queried k-set. */
+    ctrlMeasures?: boolean;
 }
 /** Search pad for the per-move Flatbush query: snap threshold or related-object reach. */
 export declare const snapQueryPad: (threshold?: number) => number;
@@ -62,6 +66,11 @@ export interface ResizeSnapOptions extends SnapOptions {
     resizeHeight?: boolean;
 }
 export declare const snapResizePoint: (currentX: number | null, currentY: number | null, others: SnapBox[], options: ResizeSnapOptions) => SnapResult;
+/**
+ * Cross-axis for a distance badge: stay on the moving box.
+ * Shared row/column uses the overlap; otherwise project onto the moving center.
+ */
+export declare const projectMeasureCross: (moving0: number, moving1: number, other0: number, other1: number) => number;
 /**
  * Ctrl-held distance badges: adjacent gaps along live guides, both axes to
  * the most related object, nearest same-row/column neighbors, and slide margins.

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

@@ -0,0 +1,12 @@
+import type { TableCellStyle } from '../types/slides';
+export { rememberTableStyleTarget, tableStyleTarget } from './tableStyleTarget';
+/**
+ * Persist any live cell draft, then patch cell styles on the store grid.
+ * Style panels only pass the style fields — they must not clone table data.
+ */
+export declare function applyTableCellStyles(style: Partial<TableCellStyle>, options?: {
+    elementId?: string;
+    cells?: string[];
+    allCells?: boolean;
+    history?: boolean;
+}): boolean;

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

@@ -0,0 +1,3 @@
+/** Keep the last in-cell style target so Present/deselect cannot widen the next fill. */
+export declare function rememberTableStyleTarget(elementId: string, cells: string[]): void;
+export declare function tableStyleTarget(elementId: string, cells?: string[]): string[];

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

@@ -1,4 +1,4 @@
-import type { Gradient, PPTElement, PPTTableElement, Slide, SlideBackground } from '../types/slides';
+import type { Gradient, PPTElement, PPTShapeElement, PPTTableElement, PPTTextElement, Slide, SlideBackground } from '../types/slides';
 /**
  * Painter's-algorithm text contrast repair for AI-imported decks.
  *
@@ -122,6 +122,30 @@ export declare const resolveElementDefaultFontColor: (preferred: string, options
     background?: SlideBackground;
     fallbackSurface?: string;
 }) => string;
+export type LiveTextPaintOptions = {
+    fill?: string;
+    background?: SlideBackground;
+    fallbackSurface?: string;
+    themeFontColor?: string;
+    /** The text/shape being painted. Own fill/gradient win; otherwise under-paints. */
+    element?: PPTTextElement | PPTShapeElement;
+    /** Painter-order siblings so overlay labels see the chip/card underneath. */
+    elements?: PPTElement[];
+};
+/**
+ * Surfaces the text actually sits on — same query as import contrast.
+ * Own opaque fill/gradient first; otherwise the topmost paint under the box.
+ */
+export declare const resolveTextPaintSurfaces: (el: PPTTextElement | PPTShapeElement | undefined, options?: LiveTextPaintOptions) => string[];
+/**
+ * Single paint-time contrast pass for the live editor and the preview raster.
+ * Surfaces match {@link fixSlideTextContrast}: overlay labels on a chip use
+ * the chip, not the slide paper. Default inks rewrite to the same hex.
+ */
+export declare const resolveLiveTextPaint: (preferred: string | undefined, html: string, options?: LiveTextPaintOptions) => {
+    ink: string;
+    html: string;
+};
 /**
  * Chart axis / legend / label ink. Same rules as text: default greys / black /
  * white snap to {@link preferredInk} on the chart fill, else the slide.