@web-ppt/editor 0.5.0-beta.1

package/dist/element-clipboard.d.ts

@@ -0,0 +1,23 @@
+import type { Editor, ElementId, SlideId } from '@web-ppt/edit-core';
+export declare const ELEMENT_CLIPBOARD_MIME = "application/x-web-ppt-elements+json";
+interface ElementClipboardOptions {
+    editor: Editor;
+    slideId(): SlideId;
+    editable(): boolean;
+    gestureActive(): boolean;
+    insertImage(file: File): Promise<ElementId>;
+}
+export declare class ElementClipboardController {
+    private readonly options;
+    constructor(options: ElementClipboardOptions);
+    copy(event: ClipboardEvent): void;
+    cut(event: ClipboardEvent): void;
+    paste(event: ClipboardEvent): void;
+    duplicate(event: KeyboardEvent): boolean;
+    private shouldYield;
+    private shouldYieldBase;
+    private selectedRoots;
+    private write;
+    private pastePayload;
+}
+export {};

package/dist/format-painter-types.d.ts

@@ -0,0 +1,32 @@
+import type { ElementId, FormatMaskField, TableCellAddress, TextRange } from '@web-ppt/edit-core';
+export interface FormatPainterStartOptions {
+    /** false/undefined 表示成功一次后自动退出。 */
+    readonly continuous?: boolean;
+    /** 省略时根据当前元素或文字选区选择安全默认值。 */
+    readonly mask?: readonly FormatMaskField[];
+}
+export interface FormatPainterSource {
+    readonly id: ElementId;
+    readonly cell?: TableCellAddress;
+    readonly range?: TextRange;
+    readonly mask: readonly FormatMaskField[];
+}
+export interface FormatPainterTarget {
+    readonly id: ElementId;
+    readonly cell?: TableCellAddress;
+    readonly range?: TextRange;
+}
+export interface FormatPainterSnapshot {
+    readonly active: boolean;
+    readonly mode: 'inactive' | 'single' | 'continuous';
+    readonly source: FormatPainterSource | null;
+}
+export type FormatPainterSubscriber = (snapshot: FormatPainterSnapshot) => void;
+export interface FormatPainter {
+    readonly snapshot: FormatPainterSnapshot;
+    readonly disposed: boolean;
+    start(options?: FormatPainterStartOptions): boolean;
+    apply(target: FormatPainterTarget): boolean;
+    cancel(): void;
+    subscribe(subscriber: FormatPainterSubscriber): () => void;
+}

package/dist/format-painter-view.d.ts

@@ -0,0 +1,17 @@
+import type { FormatPainter } from './format-painter-types';
+import type { FormatPainterStartOptions, FormatPainterTarget } from './format-painter-types';
+/** 视图绑定只投影状态与错误；格式真相仍完全属于会话控制器。 */
+export declare class FormatPainterViewBinding {
+    private readonly root;
+    private readonly painter;
+    private readonly onError?;
+    private readonly unsubscribe;
+    constructor(root: HTMLElement, painter: FormatPainter, onError?: ((error: unknown) => void) | undefined);
+    get active(): boolean;
+    start(options: FormatPainterStartOptions): boolean;
+    apply(target: FormatPainterTarget): boolean;
+    cancel(): void;
+    destroy(): void;
+    report(error: unknown): void;
+    private sync;
+}

package/dist/format-painter.d.ts

@@ -0,0 +1,21 @@
+import type { Editor } from '@web-ppt/edit-core';
+import type { FormatPainter, FormatPainterSnapshot, FormatPainterStartOptions, FormatPainterSubscriber, FormatPainterTarget } from './format-painter-types';
+/** 会话状态只保留稳定模型身份，不持有 DOM 或某个框架实例。 */
+export declare class SessionFormatPainter implements FormatPainter {
+    private readonly editor;
+    private current;
+    private readonly subscribers;
+    private readonly unsubscribeEditor;
+    private isDisposed;
+    constructor(editor: Editor);
+    get snapshot(): FormatPainterSnapshot;
+    get disposed(): boolean;
+    start(options?: FormatPainterStartOptions): boolean;
+    apply(target: FormatPainterTarget): boolean;
+    cancel(): void;
+    subscribe(subscriber: FormatPainterSubscriber): () => void;
+    dispose(): void;
+    private normalizedRange;
+    private emit;
+    private assertActive;
+}

package/dist/framework-adapter-binding.d.ts

@@ -0,0 +1,4 @@
+import type { EditorSession } from './session';
+import type { WebPptAdapter, WebPptAdapterBinding } from './framework-adapter-types';
+/** React/Vue/Svelte/Web Component 只需把受控 props 映射到这一处。 */
+export declare function applyWebPptAdapterBinding(adapter: WebPptAdapter, binding: WebPptAdapterBinding): Promise<EditorSession | null>;

package/dist/framework-adapter-state.d.ts

@@ -0,0 +1,9 @@
+import type { WebPptAdapterSnapshot } from './framework-adapter-types';
+export declare const DEFAULT_WEB_PPT_VIEW: Readonly<{
+    mode: "edit";
+    zoom: 1;
+    textMode: "auto";
+    snapping: true;
+}>;
+/** 空态也是完整受控状态，宿主首帧无需判空后再补默认值。 */
+export declare const WEB_PPT_IDLE_SNAPSHOT: WebPptAdapterSnapshot;

package/dist/framework-adapter-types.d.ts

@@ -0,0 +1,114 @@
+import type { EditAnimationStep, EditorChange, SlideAnimationState, SlideId, SlideTransitionInput, SlideTransitionState, TextSearchMatch } from '@web-ppt/edit-core';
+import type { RecoveryCandidate, RecoveryDecision } from './recovery-store';
+import type { EditorSession, OpenEditorOptions } from './session';
+import type { SelectionPane } from './selection-pane-types';
+import type { EditorMode, LinkFollowHandler, SlideEditor, SlideEditorOptions } from './slide-editor-types';
+import type { WebPptSource } from './source-fingerprint';
+import type { FormatPainterSnapshot, FormatPainterStartOptions } from './format-painter-types';
+import type { TextSearchOpenOptions, TextSearchOptions, TextSearchSnapshot } from './text-search-types';
+export type WebPptDocument = {
+    readonly source: WebPptSource;
+    readonly openOptions?: OpenEditorOptions;
+    readonly session?: never;
+    readonly ownership?: never;
+} | {
+    readonly session: EditorSession;
+    readonly ownership: 'external';
+    readonly source?: never;
+    readonly openOptions?: never;
+};
+export interface WebPptViewOptions {
+    readonly mode?: EditorMode;
+    readonly slideId?: SlideId;
+    readonly zoom?: number;
+    readonly textMode?: SlideEditorOptions['textMode'];
+    readonly snapping?: boolean;
+    readonly snapMargins?: SlideEditorOptions['snapMargins'];
+    readonly onLinkFollow?: LinkFollowHandler;
+}
+export interface WebPptAdapterProgress {
+    readonly phase: 'opening' | 'recovering' | 'ready';
+    readonly ratio: 0 | 1;
+}
+export interface WebPptViewState {
+    readonly mode: EditorMode;
+    readonly slideId: SlideId | null;
+    readonly zoom: number;
+    readonly snapping: boolean;
+}
+export interface WebPptFormatPainterState extends FormatPainterSnapshot {
+    /** 文档未就绪、只读或当前为查看模式时为 true。 */
+    readonly readonly: boolean;
+}
+export interface WebPptTextSearchState extends TextSearchSnapshot {
+    /** 只有文档就绪、来源可写且当前为编辑模式时为 true；查找与导航不受此值限制。 */
+    readonly canReplace: boolean;
+}
+export interface WebPptAdapterCallbacks {
+    readonly onReady?: (session: EditorSession) => void;
+    readonly onError?: (error: unknown) => void;
+    readonly onProgress?: (progress: WebPptAdapterProgress) => void;
+    readonly onChange?: (change: EditorChange) => void;
+    readonly onViewChange?: (state: WebPptViewState) => void;
+    readonly onRecovery?: (candidate: RecoveryCandidate) => RecoveryDecision | Promise<RecoveryDecision>;
+}
+export type WebPptAdapterBinding = WebPptViewOptions & WebPptAdapterCallbacks & ({
+    readonly source: WebPptSource;
+    readonly openOptions?: OpenEditorOptions;
+    readonly session?: never;
+    readonly sessionOwnership?: never;
+} | {
+    readonly session: EditorSession;
+    readonly sessionOwnership: 'external';
+    readonly source?: never;
+    readonly openOptions?: never;
+} | {
+    readonly source?: null;
+    readonly session?: null;
+    readonly sessionOwnership?: never;
+    readonly openOptions?: OpenEditorOptions;
+});
+export interface WebPptAdapterSnapshot extends WebPptViewState {
+    readonly status: 'idle' | 'opening' | 'recovering' | 'ready' | 'error' | 'disposed';
+    readonly progress: number;
+    readonly error: unknown | null;
+    readonly session: EditorSession | null;
+    readonly view: SlideEditor | null;
+    readonly selectionPane: SelectionPane | null;
+    readonly recovery: RecoveryCandidate | null;
+    readonly formatPainter: WebPptFormatPainterState;
+    readonly textSearch: WebPptTextSearchState;
+}
+export type WebPptAdapterSubscriber = (snapshot: WebPptAdapterSnapshot) => void;
+export interface WebPptAdapter {
+    readonly snapshot: WebPptAdapterSnapshot;
+    readonly disposed: boolean;
+    subscribe(subscriber: WebPptAdapterSubscriber): () => void;
+    setCallbacks(callbacks: WebPptAdapterCallbacks): void;
+    applyBinding(binding: WebPptAdapterBinding): Promise<EditorSession | null>;
+    attach(container: HTMLElement | null): void;
+    attachSelectionPane(container: HTMLElement | null): void;
+    setView(options: WebPptViewOptions): void;
+    setDocument(document: WebPptDocument | null): Promise<EditorSession | null>;
+    save(): Promise<Uint8Array>;
+    undo(): EditorChange | null;
+    redo(): EditorChange | null;
+    startFormatPainter(options?: FormatPainterStartOptions): boolean;
+    cancelFormatPainter(): void;
+    openTextSearch(options?: TextSearchOpenOptions): void;
+    closeTextSearch(): void;
+    setTextSearchQuery(query: string): void;
+    setTextSearchReplacement(replacement: string): void;
+    setTextSearchOptions(options: Partial<TextSearchOptions>): void;
+    nextTextSearch(): TextSearchMatch | null;
+    previousTextSearch(): TextSearchMatch | null;
+    replaceCurrentText(): boolean;
+    replaceAllText(): number;
+    queryTransition(): SlideTransitionState | null;
+    setTransition(value: SlideTransitionInput | null): boolean;
+    previewTransition(value?: SlideTransitionInput): Promise<boolean>;
+    queryAnimations(): SlideAnimationState | null;
+    setAnimations(value: readonly EditAnimationStep[] | null): boolean;
+    previewAnimations(value?: readonly EditAnimationStep[]): Promise<boolean>;
+    dispose(): void;
+}

package/dist/framework-adapter.d.ts

@@ -0,0 +1,2 @@
+import type { WebPptAdapter, WebPptAdapterCallbacks } from './framework-adapter-types';
+export declare function createWebPptAdapter(callbacks?: WebPptAdapterCallbacks): WebPptAdapter;

package/dist/image-crop-gesture.d.ts

@@ -0,0 +1,40 @@
+import type { Editor, ElementId, Selection, SlideId } from '@web-ppt/edit-core';
+import type { ResizeHandle } from './resize-geometry';
+interface ImageCropGestureOptions {
+    root: HTMLElement;
+    stage: HTMLElement;
+    interactionLayer: SVGSVGElement;
+    editor: Editor;
+    editable(): boolean;
+    slideId(): SlideId;
+    zoom(): number;
+    renderSelection(): void;
+}
+/** 双矩形裁剪模式独占 interaction 层；静态图片只在模型提交后增量换代。 */
+export declare class ImageCropGestureController {
+    private readonly options;
+    private readonly lifecycle;
+    private currentId;
+    constructor(options: ImageCropGestureOptions);
+    get activeId(): ElementId | null;
+    get isGestureActive(): boolean;
+    enter(id: ElementId): boolean;
+    exit(): void;
+    destroy(): void;
+    cancelGesture(): void;
+    commitGesture(): boolean;
+    sync(selection: Selection): void;
+    handleAt(target: EventTarget | null): ResizeHandle | null;
+    begin(event: PointerEvent, handle: ResizeHandle): void;
+    move(event: PointerEvent): void;
+    finish(event: PointerEvent): void;
+    cancelPointer(event: PointerEvent): void;
+    private toLocal;
+    private proposal;
+    private preview;
+    private commit;
+    private render;
+    private renderCrop;
+    private removeOverlay;
+}
+export {};

package/dist/image-insertion.d.ts

@@ -0,0 +1,46 @@
+import type { AddImageCommand, Editor, ElementId, SetBackgroundImageCommand, SlideId } from '@web-ppt/edit-core';
+export interface ImageInsertOptions {
+    readonly rect?: AddImageCommand['rect'];
+    /** 默认 5MB：留足默认 8MB 历史预算所需的 Base64 开销，保证插入后仍可撤销。 */
+    readonly maxBytes?: number;
+}
+export interface ImageReplaceOptions {
+    /** 默认使用当前单选图片。 */
+    readonly id?: ElementId;
+    readonly maxBytes?: number;
+}
+export interface ImageBackgroundOptions {
+    readonly crop?: SetBackgroundImageCommand['crop'];
+    readonly alpha?: SetBackgroundImageCommand['alpha'];
+    readonly tile?: SetBackgroundImageCommand['tile'];
+    readonly maxBytes?: number;
+}
+interface InternalImageInsertOptions extends ImageInsertOptions {
+    readonly placeholderId?: ElementId;
+}
+interface ImageInsertionControllerOptions {
+    readonly editor: Editor;
+    readonly root: HTMLElement;
+    slideId(): SlideId;
+    editable(): boolean;
+}
+export declare class ImageInsertionController {
+    private readonly options;
+    private cancelChooser;
+    private activeReads;
+    private destroyed;
+    constructor(options: ImageInsertionControllerOptions);
+    private withImageBytes;
+    insert(blob: Blob, options?: InternalImageInsertOptions): Promise<ElementId>;
+    replace(id: ElementId, blob: Blob, options?: ImageReplaceOptions): Promise<ElementId>;
+    choose(options?: InternalImageInsertOptions): Promise<ElementId | null>;
+    chooseReplacement(id: ElementId, options?: ImageReplaceOptions): Promise<ElementId | null>;
+    setBackground(blob: Blob, options?: ImageBackgroundOptions): Promise<SlideId>;
+    chooseBackground(options?: ImageBackgroundOptions): Promise<SlideId | null>;
+    private chooseFile;
+    destroy(): void;
+    private setReading;
+    private report;
+    private assertContext;
+}
+export {};

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+export { openEditor } from './session';
+export { createSelectionPane } from './selection-pane';
+export { fingerprintSource } from './source-fingerprint';
+export { RecoveryOpenCancelledError } from './recovery-store';
+export { createIndexedDbRecoveryStore } from './indexeddb-recovery-store';
+export { createWebPptAdapter, } from './framework-adapter';
+export { applyWebPptAdapterBinding } from './framework-adapter-binding';
+export { WEB_PPT_IDLE_SNAPSHOT } from './framework-adapter-state';
+export { ELEMENT_CLIPBOARD_MIME } from './element-clipboard';
+export { elementFrameToSlideMatrix, elementFrameToSlidePoint, elementParentToSlideMatrix, elementParentToSlidePoint, invertSpaceMatrix, screenToSlidePoint, slideToElementFramePoint, slideToElementParentPoint, slideToScreenPoint, transformSpacePoint, queryElementCrop, queryElementEffects, queryElementFill, queryElementLink, queryElementStroke, queryRunLink, querySlideBackground, querySlideHidden, querySlideLayout, querySlideNotes, querySlideAnimations, querySlideTransition, ANIMATION_EFFECTS, MAX_ANIMATION_STEPS, animationDirections, animationEffectsForKind, SHAPE_PATTERN_PRESETS, SLIDE_TRANSITION_TYPES, transitionDirections, } from '@web-ppt/edit-core';
+export type { EditorSession, OpenEditorOptions } from './session';
+export type { FormatPainter, FormatPainterSnapshot, FormatPainterSource, FormatPainterStartOptions, FormatPainterSubscriber, FormatPainterTarget, } from './format-painter-types';
+export type { TextSearch, TextSearchMode, TextSearchOpenOptions, TextSearchOptions, TextSearchSnapshot, TextSearchSubscriber, } from './text-search-types';
+export type { SelectionPane, SelectionPaneOptions } from './selection-pane-types';
+export type { WebPptSourceIdentity } from './source-fingerprint';
+export type { EditorRecovery, RecoveryCandidate, RecoveryDecision, RecoveryDecisionHandler, RecoveryOptions, RecoveryStore, RecoveryStoreAppend, RecoveryStoreJournal, RecoveryStoreReset, } from './recovery-store';
+export type { IndexedDbRecoveryStore, IndexedDbRecoveryStoreOptions, RecoveryCleanupResult, RecoveryStoreStats, } from './indexeddb-recovery-store';
+export type { WebPptAdapter, WebPptAdapterBinding, WebPptAdapterCallbacks, WebPptAdapterProgress, WebPptAdapterSnapshot, WebPptAdapterSubscriber, WebPptDocument, WebPptFormatPainterState, WebPptTextSearchState, WebPptViewOptions, WebPptViewState, } from './framework-adapter-types';
+export type { WebPptSource } from './source-fingerprint';
+export type { EditorMode, LinkFollowContext, LinkFollowHandler, LinkFollowSource, SlideEditor, SlideEditorOptions, } from './slide-editor-types';
+export type { ImageInsertOptions } from './image-insertion';
+export type { ImageBackgroundOptions, ImageReplaceOptions } from './image-insertion';
+export type { TableInsertOptions } from './table-insertion';
+export type { AddImageCommand, AddShapeCommand, AddTableCommand, EditAnimationStep, ElementClipboardPayload, ElementCropState, ElementEffectsState, ElementFillState, ElementLinkState, ElementStrokeState, ImageCrop, LinkOverride, LinkSourceValue, LinkTarget, ParagraphProperties, ParagraphPropertiesState, ParagraphPropertyOverrides, SlideAnimationState, SlideBackgroundState, SlideHiddenState, SlideLayoutState, RunLinkState, RunPropertiesState, RunPropertyOverrides, SlideNotesState, SlideTransitionInput, SlideTransitionState, TextBodyAutoFit, TextBodyProperties, TextBodyPropertyOverrides, ReplaceImageCommand, SetAnimationsCommand, SetBackgroundCommand, SetBackgroundCropCommand, SetBackgroundImageCommand, SetCropCommand, SetEffectsCommand, SetFillCommand, SetHiddenCommand, SetTransitionCommand, SetLayoutCommand, SetLinkCommand, SetStrokeCommand, StrokeCommandValue, VectorFill, FormatMaskField, } from '@web-ppt/edit-core';
+export type { EditorChange, FindTextRequest, ReplaceTextCommand, ReplaceTextScope, SlideId, TextSearchMatch, TextSearchScope, TextSearchTarget, } from '@web-ppt/edit-core';
+export type { SelectionPaneItem } from '@web-ppt/edit-core';
+export type { SnapMargins } from './snap';
+export type { AffineMatrix, SlideViewport, SpacePoint } from '@web-ppt/edit-core';

package/dist/indexeddb-recovery-store.d.ts

@@ -0,0 +1,30 @@
+import type { RecoveryStore } from './recovery-store';
+import type { WebPptSourceIdentity } from './source-fingerprint';
+export interface IndexedDbRecoveryStoreOptions {
+    readonly databaseName?: string;
+    readonly namespace?: string;
+    readonly compactAfterChunks?: number;
+    readonly compactToChunks?: number;
+    readonly maxJournals?: number;
+    readonly maxBytes?: number;
+    readonly retentionMs?: number;
+    /** 允许 Worker、测试或受控环境注入 IDBFactory；模块导入本身不读取 indexedDB。 */
+    readonly factory?: IDBFactory;
+    readonly now?: () => number;
+}
+export interface RecoveryStoreStats {
+    readonly journalCount: number;
+    readonly chunkCount: number;
+    readonly frameCount: number;
+    readonly estimatedBytes: number;
+}
+export interface RecoveryCleanupResult {
+    readonly journalsRemoved: number;
+    readonly estimatedBytesRemoved: number;
+}
+export interface IndexedDbRecoveryStore extends RecoveryStore {
+    stats(): Promise<RecoveryStoreStats>;
+    cleanup(preserveFingerprint?: WebPptSourceIdentity['fingerprint']): Promise<RecoveryCleanupResult>;
+    close(): Promise<void>;
+}
+export declare function createIndexedDbRecoveryStore(options?: IndexedDbRecoveryStoreOptions): IndexedDbRecoveryStore;

package/dist/keyboard-context.d.ts

@@ -0,0 +1,8 @@
+import type { Editor, SlideId } from '@web-ppt/edit-core';
+export interface KeyboardControllerOptions {
+    editor: Editor;
+    namespace: string;
+    slideId(): SlideId;
+    revealSlide(slideId: SlideId): void;
+    gestureActive(): boolean;
+}

package/dist/keyboard-delete.d.ts

@@ -0,0 +1,7 @@
+import type { KeyboardControllerOptions } from './keyboard-context';
+/** 删除键只组合公开命令；占位符清空与递归删除语义由 headless RemoveElement 决定。 */
+export declare class DeleteKeyboardController {
+    private readonly options;
+    constructor(options: KeyboardControllerOptions);
+    keyDown(event: KeyboardEvent): boolean;
+}

package/dist/keyboard-history.d.ts

@@ -0,0 +1,7 @@
+import type { KeyboardControllerOptions } from './keyboard-context';
+/** 历史快捷键只负责把画布事件路由到公开 Editor；历史语义仍由 headless 内核拥有。 */
+export declare class HistoryKeyboardController {
+    private readonly options;
+    constructor(options: KeyboardControllerOptions);
+    keyDown(event: KeyboardEvent): boolean;
+}

package/dist/keyboard-layer.d.ts

@@ -0,0 +1,7 @@
+import type { KeyboardControllerOptions } from './keyboard-context';
+/** PowerPoint 层级快捷键只编排公开 SetZ；排序规则属于选区语义，不泄漏进 DOM。 */
+export declare class LayerKeyboardController {
+    private readonly options;
+    constructor(options: KeyboardControllerOptions);
+    keyDown(event: KeyboardEvent): boolean;
+}

package/dist/keyboard-nudge.d.ts

@@ -0,0 +1,10 @@
+import type { KeyboardControllerOptions } from './keyboard-context';
+export declare class KeyboardNudgeController {
+    private readonly options;
+    private readonly activeHolds;
+    private nextHold;
+    constructor(options: KeyboardControllerOptions);
+    keyDown(event: KeyboardEvent): boolean;
+    keyUp(event: KeyboardEvent): boolean;
+    breakSequence(): void;
+}

package/dist/keyboard-owner.d.ts

@@ -0,0 +1,5 @@
+/** closed Shadow 会隐藏真实目标；画布只拥有直接发往视图根的键盘事件，全部后代都应让位。 */
+export declare function shouldYieldKeyboardEvent(event: KeyboardEvent): boolean;
+/** SVG 舞台属于画布；closed Shadow 隐藏内部表单时用焦点重定向识别宿主。 */
+export declare function shouldYieldClipboardEvent(event: ClipboardEvent): boolean;
+export declare function shouldYieldPointerEvent(event: PointerEvent): boolean;

package/dist/marquee-gesture.d.ts

@@ -0,0 +1,31 @@
+import type { Editor, ElementId } from '@web-ppt/edit-core';
+interface MarqueeGestureOptions {
+    root: HTMLElement;
+    stage: HTMLElement;
+    interactionLayer: SVGSVGElement;
+    editor: Editor;
+    zoom(): number;
+    candidateIds(enteredGroup: ElementId | null): ElementId[];
+}
+export declare class MarqueeGestureController {
+    private readonly options;
+    private readonly lifecycle;
+    private session;
+    constructor(options: MarqueeGestureOptions);
+    get isActive(): boolean;
+    begin(event: PointerEvent, enteredGroup: ElementId | null): void;
+    move(event: PointerEvent): void;
+    modifier(event: KeyboardEvent): boolean;
+    finish(event: PointerEvent): void;
+    cancel(): void;
+    cancelPointer(event: PointerEvent): void;
+    private toSlide;
+    private startPreview;
+    private rectangle;
+    private selectionAt;
+    private applyFrame;
+    private commit;
+    private combinedSelectionAt;
+    private clearPreview;
+}
+export {};

package/dist/move-gesture.d.ts

@@ -0,0 +1,34 @@
+import type { Editor, ElementId } from '@web-ppt/edit-core';
+import type { SnapMargins } from './snap';
+interface MoveGestureOptions {
+    root: HTMLElement;
+    stage: HTMLElement;
+    staticLayer: HTMLElement;
+    interactionLayer: SVGSVGElement;
+    editor: Editor;
+    zoom: () => number;
+    snapping: () => boolean;
+    margins: () => SnapMargins | undefined;
+}
+export declare class MoveGestureController {
+    private readonly options;
+    private readonly lifecycle;
+    constructor(options: MoveGestureOptions);
+    get isActive(): boolean;
+    begin(event: PointerEvent, ids: readonly ElementId[]): void;
+    move(event: PointerEvent): void;
+    finish(event: PointerEvent): void;
+    modifier(event: KeyboardEvent): boolean;
+    cancel(): void;
+    cancelPointer(event: PointerEvent): void;
+    private toSlide;
+    private positions;
+    private startPreview;
+    private proposal;
+    private applyFrame;
+    private commit;
+    private clearPreview;
+    private selectionBounds;
+    private siblingTargets;
+}
+export {};

package/dist/placeholder-overlay.d.ts

@@ -0,0 +1,3 @@
+import type { EditDoc, SlideId } from '@web-ppt/edit-core';
+/** 空占位符本身没有可命中的静态 SVG；辅助框只存在于 edit interaction 层。 */
+export declare function renderPlaceholderOverlay(layer: SVGSVGElement, doc: EditDoc, slideId: SlideId, zoom: number, enabled: boolean): void;

package/dist/pointer-gesture.d.ts

@@ -0,0 +1,37 @@
+import type { SpacePoint } from '@web-ppt/edit-core';
+export interface PointerGestureSnapshot {
+    screen: SpacePoint;
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    shiftKey: boolean;
+}
+export interface PointerGesture {
+    cursor: string;
+    dataset: {
+        name: string;
+        value: string;
+    };
+    start(): void;
+    observePointer?(snapshot: PointerGestureSnapshot): void;
+    frame(snapshot: PointerGestureSnapshot): void;
+    finish(snapshot: PointerGestureSnapshot): (() => void) | null;
+    clear(): void;
+}
+export declare class PointerGestureLifecycle {
+    private readonly root;
+    private active;
+    constructor(root: HTMLElement);
+    get isActive(): boolean;
+    begin(event: PointerEvent, gesture: PointerGesture): void;
+    move(event: PointerEvent): void;
+    finish(event: PointerEvent): 'ignored' | 'click' | 'gesture';
+    /** 键盘确认使用最后一次指针快照；先清理 capture/rAF，再执行提交，避免订阅回调重入活动手势。 */
+    commit(): boolean;
+    modifier(event: KeyboardEvent): boolean;
+    cancel(): void;
+    cancelPointer(event: PointerEvent): void;
+    private updateSnapshot;
+    private scheduleFrame;
+    private clear;
+}

package/dist/recovery-session.d.ts

@@ -0,0 +1,24 @@
+import type { Editor } from '@web-ppt/edit-core';
+import type { EditorRecovery, RecoveryOptions } from './recovery-store';
+import type { WebPptSourceIdentity } from './source-fingerprint';
+/** 编辑提交只入内存队列；IndexedDB 等慢存储始终在 microtask 后串行执行。 */
+export declare class RecoverySessionController implements EditorRecovery {
+    readonly source: WebPptSourceIdentity;
+    private readonly options;
+    private readonly idPrefix;
+    private readonly epoch;
+    private readonly unsubscribe;
+    private queued;
+    private tail;
+    private scheduled;
+    private failure;
+    private stopped;
+    private pendingFrames;
+    constructor(editor: Editor, source: WebPptSourceIdentity, options: RecoveryOptions, epoch: string);
+    get pending(): number;
+    get error(): unknown | null;
+    flush(): Promise<void>;
+    dispose(): void;
+    private enqueue;
+    private drain;
+}

package/dist/recovery-store.d.ts

@@ -0,0 +1,64 @@
+import type { RecoveryFrame } from '@web-ppt/edit-core';
+import type { WebPptSourceIdentity } from './source-fingerprint';
+export interface RecoveryStoreJournal {
+    readonly version: 1;
+    readonly source: WebPptSourceIdentity;
+    readonly idPrefix: string;
+    readonly epoch: string;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+    readonly estimatedBytes: number;
+    readonly frames: readonly RecoveryFrame[];
+}
+export interface RecoveryStoreAppend {
+    readonly source: WebPptSourceIdentity;
+    readonly idPrefix: string;
+    readonly epoch: string;
+    readonly frames: readonly RecoveryFrame[];
+}
+export interface RecoveryStoreReset {
+    readonly source: WebPptSourceIdentity;
+    readonly idPrefix: string;
+    /** 每次放弃/清理旧链都会换代，使旧页面的晚到追加必然失败。 */
+    readonly epoch: string;
+    /** store 必须在原子提交前响应取消，避免过期打开覆盖新会话代际。 */
+    readonly signal?: AbortSignal;
+}
+/** 宿主可替换此 seam；存储实现必须在 append Promise 完成前原子提交整批帧。 */
+export interface RecoveryStore {
+    load(source: WebPptSourceIdentity): Promise<RecoveryStoreJournal | null>;
+    reset(request: RecoveryStoreReset): Promise<void>;
+    append(request: RecoveryStoreAppend): Promise<void>;
+    remove(source: WebPptSourceIdentity): Promise<void>;
+}
+export interface RecoveryCandidate {
+    readonly fingerprint: WebPptSourceIdentity['fingerprint'];
+    readonly sourceByteLength: number;
+    readonly idPrefix: string;
+    readonly frameCount: number;
+    readonly estimatedBytes: number;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+    readonly dirty: true;
+    readonly latestLabel: string;
+}
+export type RecoveryDecision = 'restore' | 'discard' | 'cancel';
+export type RecoveryDecisionHandler = (candidate: RecoveryCandidate) => RecoveryDecision | Promise<RecoveryDecision>;
+export interface RecoveryOptions {
+    readonly store: RecoveryStore;
+    /** adapter 可改由 onRecovery 提供；直接 openEditor 在发现候选时必须提供。 */
+    readonly decide?: RecoveryDecisionHandler;
+    readonly onError?: (error: unknown) => void;
+    /** 框架适配器用它取消过期候选与占位；宿主也可直接控制打开流程。 */
+    readonly signal?: AbortSignal;
+}
+export interface EditorRecovery {
+    readonly source: WebPptSourceIdentity;
+    readonly pending: number;
+    readonly error: unknown | null;
+    flush(): Promise<void>;
+}
+export declare class RecoveryOpenCancelledError extends Error {
+    readonly candidate: RecoveryCandidate;
+    constructor(candidate: RecoveryCandidate);
+}

package/dist/resize-geometry.d.ts

@@ -0,0 +1,19 @@
+import type { EditDoc, ElementId, SpacePoint } from '@web-ppt/edit-core';
+import type { TransformFrame } from './transform-frame';
+export declare const RESIZE_HANDLES: readonly ["nw", "n", "ne", "e", "se", "s", "sw", "w"];
+export type ResizeHandle = typeof RESIZE_HANDLES[number];
+export declare function isResizeHandle(value: string | undefined): value is ResizeHandle;
+export interface ResizeModifiers {
+    altKey: boolean;
+    shiftKey: boolean;
+}
+export declare const MIN_RESIZE_SIZE: number;
+export declare const RESIZE_HANDLE_AXES: Record<ResizeHandle, readonly [number, number]>;
+export declare function resizeHandleAfterFlip(handle: ResizeHandle, horizontal: boolean, vertical: boolean): ResizeHandle;
+export declare function resizeElementFrame(source: TransformFrame, handle: ResizeHandle, pointerInParent: SpacePoint, modifiers?: ResizeModifiers): TransformFrame;
+interface MultiResizeTarget {
+    id: ElementId;
+    source: TransformFrame;
+}
+export declare function resizeMultiElementFrames(doc: EditDoc, targets: readonly MultiResizeTarget[], selectionSource: TransformFrame, selectionNext: TransformFrame): TransformFrame[];
+export {};