@netless/appliance-plugin 1.1.42 → 1.1.43-beta.0

package/dist/plugin/applianceMultiPlugin.d.ts

@@ -6,16 +6,31 @@ import { ApplianceMultiManager } from "./multi/applianceMultiManager";
  * 多窗口教具
  */
 export declare class ApplianceMultiPlugin extends InvisiblePlugin<AppliancePluginAttributes, any> {
+    private static drainingManager?;
+    private static drainingPromise?;
+    private callbackDisplayer?;
+    private callbackStateName?;
+    private callbackOwnerManager?;
+    private ownedManager?;
+    private roomLifecycleDisposer?;
+    private roomLifecycleOwnerManager?;
+    private undoStepForwarderDisposer?;
+    private undoStepForwarderOwnerManager?;
     static readonly kind: string;
     static currentManager?: ApplianceMultiManager;
     static logger: Logger;
     static getInstance(remake: WindowManager, adaptor: ApplianceAdaptor): Promise<AppliancePluginInstance>;
     static onCreate(plugin: InvisiblePlugin<AppliancePluginAttributes, any>): void;
     static createApplianceMultiPlugin(d: Room, kind: string): Promise<ApplianceMultiPlugin>;
-    static createCurrentManager: (remake: WindowManager, options: RequiredAppliancePluginOptions, plugin: ApplianceMultiPlugin, callbacks?: ApplianceAdaptor["callbacks"]) => void;
-    private get isReplay();
-    private get callbackName();
+    private static beginManagerDestroy;
+    static createCurrentManager: (remake: WindowManager, options: RequiredAppliancePluginOptions, plugin: ApplianceMultiPlugin, callbacks?: ApplianceAdaptor["callbacks"]) => Promise<void>;
     init(displayer: Displayer): void;
+    private unbindDisplayerCallbacks;
+    private disposeRoomLifecycleInterceptor;
+    private bindUndoStepForwarders;
+    private disposeUndoStepForwarders;
+    private destroyOwnedPluginInstance;
+    private destroyOwnedManager;
     private onPhaseChanged;
     private updateRoomWritable;
     private roomStateChangeListener;

package/dist/plugin/applianceSinglePlugin.d.ts

@@ -5,22 +5,36 @@ import { ApplianceSingleManager } from "./single/applianceSingleManager";
  * 单白板教具
  */
 export declare class ApplianceSinglePlugin extends InvisiblePlugin<AppliancePluginAttributes, any> {
+    private static drainingManager?;
+    private static drainingPromise?;
+    private callbackDisplayer?;
+    private callbackStateName?;
+    private callbackOwnerManager?;
+    private ownedManager?;
+    private roomLifecycleDisposer?;
+    private roomLifecycleOwnerManager?;
     static readonly kind: string;
     static cursorAdapter?: CursorAdapter;
+    private static cursorAdapterOwnerManager?;
+    private static cursorAdapterBinding?;
     static currentManager?: ApplianceSingleManager;
     static logger: Logger;
     static getInstance(remake: Player | Room, adaptor: ApplianceAdaptor): Promise<AppliancePluginInstance>;
     static onCreate(plugin: InvisiblePlugin<AppliancePluginAttributes, any>): void;
     static createAppliancePlugin(d: Room, kind: string): Promise<ApplianceSinglePlugin>;
-    static createCurrentManager: (displayer: Displayer, options: RequiredAppliancePluginOptions, plugin?: ApplianceSinglePlugin, callbacks?: ApplianceAdaptor["callbacks"]) => void;
+    private static beginManagerDestroy;
+    static createCurrentManager: (displayer: Displayer, options: RequiredAppliancePluginOptions, plugin?: ApplianceSinglePlugin, callbacks?: ApplianceAdaptor["callbacks"]) => Promise<void>;
     /**
      * 房间实例化时，将当前实例对displayer外部API的添加内部处理逻辑;
      * @param displayer
      */
-    static effectInstance(): void;
-    private get isReplay();
-    private get callbackName();
+    static effectInstance(adapter?: CursorAdapter | undefined, owner?: ApplianceSingleManager | undefined): void;
+    private static disposeCursorAdapterBinding;
     init(displayer: Displayer): void;
+    private unbindDisplayerCallbacks;
+    private disposeRoomLifecycleInterceptor;
+    private destroyOwnedPluginInstance;
+    private destroyOwnedManager;
     private onPhaseChanged;
     private updateRoomWritable;
     private roomStateChangeListener;

package/dist/plugin/baseApplianceManager.d.ts

@@ -1,21 +1,24 @@
 import EventEmitter2 from "eventemitter2";
 import { EStrokeType, MemberState, AppliancePluginLike, ApplianceInitLoadingChangeInfo, ApplianceFontFaceLoadState, ApplianceFontFaceRenderState, ApplianceRefreshRenderState, CallbacksFun } from "./types";
 import { Collector, ViewId } from "../collector";
+import type { BaseCollectorReducerAction, DiffOneData, ISerializableStorageData } from "../collector/types";
 import { RoomMemberManager } from "../members";
 import { TextEditorManager } from "../component/textEditor";
-import type { Camera, Displayer, DisplayerCallbacks, ISVGMarkmapInformation, ISVGUrlInformation, IconifyInformation, Logger, MarkmapId, Player, Rectangle, RequiredAppliancePluginOptions, Room, RoomMember, _ArrayTrue } from "./types";
+import type { Camera, Displayer, DisplayerCallbacks, ISVGMarkmapInformation, ISVGUrlInformation, IconifyInformation, MarkmapId, Player, Rectangle, RequiredAppliancePluginOptions, Room, RoomMember, _ArrayTrue } from "./types";
 import { CursorManager } from "../cursors";
 import { ViewContainerManager } from "./baseViewContainerManager";
-import { MasterControlForWorker } from "../core/mainEngine";
-import { EToolsKey } from "../core/enum";
+import { MasterControlForWorker, type ForceDoneReason, type ViewForceDoneAck } from "../core/mainEngine";
+import { EToolsKey, type ECanvasContextType } from "../core/enum";
 import { BaseShapeOptions } from "../core/tools/base";
 import { ICameraOpt } from "../core/types";
 import { HotkeyManager } from "../hotkey";
 import { SyncLogger } from "./syncLogger";
-import { RenderMode, RenderingCompatibilityDecision } from "./renderingCompatibility";
+import { RenderMode, RenderingCompatibilityDecision, RenderingCompatibilityReason } from "./renderingCompatibility";
+import type { WorkerRenderCapabilities } from "../core/worker/renderCapabilityProbe";
 import { RenderCotrolImple } from "../core/renderCotrol";
 import { MiniMapManagerImpl } from "../component/miniMap/manager";
 import { PluginManager, Plugin } from "../core/plugin";
+import { LoggerUtils } from "./utils";
 import { SelectorApiManager } from "./selectorApi";
 import { BackgroundImageLoadCoordinator } from "../component/backgroundImageLoadCoordinator";
 import type { ReloadBackgroundImageParams, ReloadBackgroundImageResult } from "../component/backgroundImageLoadCoordinator";
@@ -25,6 +28,13 @@ export interface BaseApplianceManagerProps {
     options: RequiredAppliancePluginOptions;
     callbacks?: CallbacksFun;
 }
+type PendingServiceDeriveData = DiffOneData<BaseCollectorReducerAction | undefined>;
+export type ForceDoneAck = {
+    status: "success" | "failed";
+    reason: ForceDoneReason;
+    views: ViewForceDoneAck[];
+    failureReasons: string[];
+};
 /** 插件管理器 */
 export declare abstract class BaseApplianceManager {
     readonly backgroundImageLoadCoordinator: BackgroundImageLoadCoordinator;
@@ -33,15 +43,30 @@ export declare abstract class BaseApplianceManager {
     private pendingSceneChecks;
     private pendingSceneChanges;
     private pendingClears;
+    private pendingViewInitStates;
+    private readonly renderRuntimeCacheKey;
+    private readonly renderRuntimeBuildMarker;
+    private renderRuntimeActivationPromise?;
+    /** Mounted Views initialize in arrival order so Init/ServiceSync postMessages do not pile up. */
+    private pendingViewInitQueue;
     private clearQueueByView;
     private viewOperationQueueByView;
+    private forceDoneQueue;
+    private forceDoneQueueByView;
+    private localMutationFenceCount;
+    private localMutationFenceByView;
+    private roomLifecycleTerminal;
+    private destroyPromise?;
+    private isDestroying;
+    private isDestroyed;
+    private orphanRepairTimer?;
     private lifecycleGeneration;
     private viewLifecycleGeneration;
     static InternalMsgEmitter: EventEmitter2;
     static PublicMsgEmitter: EventEmitter2;
     readonly version: string;
     plugin?: AppliancePluginLike;
-    readonly logger: Logger;
+    readonly logger: LoggerUtils;
     readonly syncLogger: SyncLogger;
     readonly room?: Room;
     readonly play?: Player;
@@ -58,7 +83,8 @@ export declare abstract class BaseApplianceManager {
     effectResolve?: (value: boolean) => void;
     readonly hotkeyManager: HotkeyManager;
     readonly pluginOptions: RequiredAppliancePluginOptions;
-    readonly renderMode: RenderMode;
+    renderMode: RenderMode;
+    private renderRuntimeDecisionLocked;
     readonly renderingCompatibilityDecision: RenderingCompatibilityDecision;
     readonly roomMember: RoomMemberManager;
     readonly cursor: CursorManager;
@@ -87,6 +113,15 @@ export declare abstract class BaseApplianceManager {
     notifyMainViewMounted(): void;
     isMainViewMounted(): boolean;
     waitForMainViewMounted(timeoutMs?: number): Promise<"ready" | "cancelled" | "timeout">;
+    isRenderRuntimeRecoveryAllowed(): boolean;
+    /**
+     * Serialize View mount-to-service-ready work and whole-runtime recovery in
+     * actual admission order. A recovery task owns this slot through all of its
+     * candidate attempts; nested work must execute directly to avoid self-wait.
+     */
+    private appendPendingViewInitTask;
+    queuePendingRuntimeReset<T>(task: () => Promise<T>): Promise<T>;
+    queuePendingViewInit(viewId: string, task: () => Promise<void>, generation?: number): Promise<void>;
     emitFontFaceLoadState(info: ApplianceFontFaceLoadState): void;
     emitFontFaceRenderState(info: ApplianceFontFaceRenderState): void;
     hasPolyfillMethod(methodName: "requestIdleCallback" | "cancelIdleCallback"): boolean;
@@ -126,7 +161,55 @@ export declare abstract class BaseApplianceManager {
     get hasOffscreenCanvas(): boolean;
     get isUseOffscreenTransfer(): boolean;
     isServiceSyncReady(viewId: string): boolean;
-    applyWorkerRenderProbe(success: boolean): void;
+    onViewServiceReady(viewId: string): void;
+    lockRenderRuntimeDecision(): void;
+    isRenderRuntimeDecisionLocked(): boolean;
+    ensureRenderRuntimeReady(): Promise<void>;
+    getRenderContextTypeForView(viewId: string): ECanvasContextType;
+    requiresCanvas2DCompanionRenderProbe(): boolean;
+    protected restoreCachedRenderRuntimeDecision(): Promise<void>;
+    persistRenderRuntimeDecision(): Promise<void>;
+    invalidateRenderRuntimeDecision(): Promise<void>;
+    private ensurePendingViewInitState;
+    armPendingViewInit(viewId: string): void;
+    bindPendingViewInit(viewId: string, generation: number): void;
+    private nextInitPaddingSequence;
+    private getSceneInitPaddingState;
+    private appendInitPaddingJournal;
+    queuePendingInitScenePath(viewId: string, scenePath: string): void;
+    queuePendingInitServicePull(viewId: string, scenePath: string): void;
+    queuePendingInitCamera(viewId: string, cameraOpt: ICameraOpt, scenePath?: string): void;
+    queuePendingServiceDerive(viewId: string, key: string, data: PendingServiceDeriveData): void;
+    queuePendingInitClear(viewId: string, scenePath?: string): void;
+    getPendingInitTargetScenePath(viewId: string): string | undefined;
+    getPendingInitCameraForScene(viewId: string, scenePath: string): ICameraOpt | undefined;
+    markPendingInitServiceApplied(viewId: string, scenePath: string, snapshot: ISerializableStorageData | undefined, revision?: number): void;
+    resetPendingInitRendererBaseline(viewId: string): void;
+    getPendingInitServiceBaseline(viewId: string, scenePath: string): ISerializableStorageData;
+    getPendingInitReconcileRevision(viewId: string, scenePath: string): {
+        anchorRevision: number;
+        cameraRevision: number;
+        forceFullRevision: number;
+    };
+    getPendingInitLastApplied(viewId: string, scenePath: string): {
+        revision?: number;
+        storage?: ISerializableStorageData;
+    };
+    hasPendingInitAppliedSnapshot(viewId: string, scenePath: string): boolean;
+    isPendingInitForceFullRefresh(viewId: string, scenePath: string): boolean;
+    hasPendingInitServiceChanges(viewId: string, scenePath: string): boolean;
+    clearPendingViewInitState(viewId: string): void;
+    getViewLifecycleGeneration(viewId: string): number;
+    isPendingViewInitCurrent(viewId: string, generation: number): boolean;
+    invalidatePendingViewInit(viewId: string): number;
+    /**
+     * Cancel queued and in-flight pending init for every known View. A runtime
+     * reset is broader than one View lifecycle: even a queued task whose Worker
+     * has not been created yet must not run across the reset boundary.
+     */
+    invalidateAllPendingViewInit(): number;
+    applyWorkerRenderProbe(capabilities: WorkerRenderCapabilities): void;
+    applyRuntimeRenderingDecision(renderMode: RenderMode, contextType: ECanvasContextType, reason: RenderingCompatibilityReason, issue: string): void;
     logFinalRenderDecision(): void;
     /** 是否使用简单模式, 简单模式则无需开启 miniMap 和 plugin */
     get isUseSimple(): boolean;
@@ -135,22 +218,60 @@ export declare abstract class BaseApplianceManager {
     bindPlugin(plugin: AppliancePluginLike): void;
     /** 激活 plugin */
     abstract activePlugin(): void;
+    /**
+     * Apply one remote storage removal to the matching local transaction only.
+     * A full View/Scene removal passes no storage key and clears local rendering.
+     */
+    protected handleRemoteStorageRemoval(viewId: string, storageKey?: string, options?: {
+        abortAllContinuousMethods?: boolean;
+        cancelTicker?: boolean;
+        clearView?: boolean;
+    }): void;
     /** 初始化 */
     abstract init(): void;
     /** 激活worker */
     abstract activeWorker(): Promise<void>;
-    /** 销毁 */
-    destroy(): void;
+    private canForceDoneLocalWorks;
+    /**
+     * Shared lifecycle/runtime gate for immediate and queued local mutations.
+     * Entry-specific per-View busy and serialization checks stay in the caller.
+     */
+    private isLocalMutationRuntimeAvailable;
+    /**
+     * Synchronously admits new persistent content mutations for a View.
+     *
+     * This is an admission check only: it never finalizes an active operation,
+     * waits for a worker/Undo ACK, or changes Room member state. Callers that
+     * mutate storage must pass their target viewId so a View-scoped fence cannot
+     * be bypassed. MemberState/tool selection uses the Room API path separately.
+     */
+    canAcceptLocalMutation(viewId?: string): boolean;
+    /** A disconnected Room is one-way; a later join creates a new Manager. */
+    markRoomLifecycleTerminal(): void;
+    private canQueueViewLifecycleOperation;
+    acquireLocalMutationFence(targetViewIds?: readonly string[]): () => void;
+    /**
+     * 将当前可持久化的本地操作统一收口为 Done，并等待 Render/Storage/Undo 屏障。
+     * lifecycle 调用方必须在原 setWritable(false)/disconnect/destroy 之前 await。
+     */
+    forceDoneLocalWorks(reason: ForceDoneReason, targetViewIds?: readonly string[]): Promise<ForceDoneAck>;
+    private waitForForceDoneOrInvalidation;
+    private logLifecycleError;
+    /** 销毁；默认保留 storage，仅在连接且可写时先统一 force-Done。 */
+    destroy(options?: {
+        preserveStorage?: boolean;
+    }): Promise<void>;
+    private destroyImmediately;
     /** 清空当前获焦路径下的所有内容 */
-    cleanCurrentScene(isForceEnd?: boolean): Promise<void>;
+    cleanCurrentScene(isForceEnd?: boolean): Promise<boolean>;
     isClearBusy(viewId: string): boolean;
     deferClearCamera(viewId: string, cameraOpt: ICameraOpt): void;
     private enqueueViewOperation;
-    setWritable(isWritable: boolean): Promise<void>;
+    setWritable(isWritable: boolean): Promise<ForceDoneAck | undefined>;
     /** 监听读写状态变更 */
     onWritableChange(isWritable: boolean): void;
     /** 监听路径变化。每个 view 只保留最新目标页，避免快速切页渲染中间页面。 */
-    onSceneChange: (scenePath: string, viewId: string) => Promise<void>;
+    onSceneChange: (requestedScenePath: string | undefined, viewId: string) => Promise<void>;
     private consumePendingSceneChanges;
     isSceneBusy(viewId: string): boolean;
     deferSceneCamera(viewId: string, cameraOpt: ICameraOpt): void;
@@ -164,6 +285,10 @@ export declare abstract class BaseApplianceManager {
     private schedulePendingSceneChecks;
     /** 监听房间成员变化 */
     onRoomMembersChange: (roomMembers: readonly RoomMember[]) => void;
+    private scheduleOrphanRepair;
+    private captureOrphanRepairMembers;
+    private isCurrentOrphanRepairMembers;
+    private repairOrphanStorage;
     /** 监听房间教具变更 */
     onMemberChange: import("lodash").DebouncedFunc<(memberState: MemberState) => void>;
     requestToolChange(modifyState: Partial<MemberState>): void;
@@ -218,3 +343,4 @@ export declare abstract class BaseApplianceManager {
     stopDraw(viewId: string): Promise<void>;
     setViewLocalScenePathChange(viewId: string, scenePath: string): Promise<void>;
 }
+export {};

package/dist/plugin/baseViewContainerManager.d.ts

@@ -8,6 +8,7 @@ import { ShowFloatBarMsgValue } from "../displayer/types";
 import { UndoRedoMethod } from "../undo";
 import type { ExpectedAcks } from "../undo/timing";
 import { BaseViewDisplayer } from "./displayerView";
+import { type RenderImageBitmapMemorySnapshot } from "./renderImageBitmapRetirement";
 export interface ViewInfo {
     id: string;
     focusScenePath: string;
@@ -27,7 +28,12 @@ export declare abstract class ViewContainerManager {
     abstract focuedViewId?: string;
     abstract focuedView?: ViewInfo;
     mainView?: ViewInfo;
+    protected mainViewOrigin?: ViewInfo;
+    protected readonly appViewOrigins: Map<string, ViewInfo>;
     appViews: Map<string, ViewInfo>;
+    private readonly renderImageBitmapRetirement;
+    private readonly renderImageBitmapRecoveryViews;
+    private renderImageBitmapPixelDiagnosticCanvas?;
     constructor(props: BaseSubWorkModuleProps);
     get worker(): import("../core/mainEngine").MasterControlForWorker;
     abstract getViewInitData(viewId: string): ViewWorkerOptions | undefined;
@@ -49,6 +55,7 @@ export declare abstract class ViewContainerManager {
     onFinalizeRequested: (id: number, viewId: string, workIds: string[], scenePath?: string) => void;
     onReopenStorageAck: (id: number, viewId: string, workIds: string[], scenePath?: string) => void;
     onCancelUndoTicker: (id: number, viewId: string, scenePath?: string) => void;
+    cancelViewUndoTicker(viewId: string): void;
     undo(): number;
     redo(): number;
     protected validator(target: ViewInfo, key: string, value: any): void;
@@ -57,14 +64,17 @@ export declare abstract class ViewContainerManager {
     createMianView(originMainView: ViewInfo): void;
     createAppView(originAppView: ViewInfo): void;
     isAppView(viewId: string): boolean;
+    getPreferredFocusedViewId(): string;
     getView(viewId: string): ViewInfo | undefined;
     private resolveView;
     private getViewElement;
     getFloatbarContainer(viewId?: string): HTMLElement | undefined;
     getViewOffsetToContainer(container: HTMLElement, viewId?: string): SelectorViewOffset | undefined;
     getCurScenePath(viewId: string): string | undefined;
+    getAuthoritativeScenePath(viewId: string): string | undefined;
     getAllViews(): (ViewInfo | undefined)[];
     setViewScenePath(viewId: string, scenePath: string): void;
+    setViewScenePathBeforeRenderInit(viewId: string, scenePath: string): boolean;
     setViewData(viewId: string, viewData: View): void;
     setFocuedViewId(viewId: string): void;
     setViewFocusScenePath(viewId: string, scenePath: string): void;
@@ -75,8 +85,15 @@ export declare abstract class ViewContainerManager {
     transformToOriginPoint(p: [number, number], viewId: string): [number, number];
     /** 页面坐标转换成view中心点坐标 */
     transformToScenePoint(p: [number, number], viewId: string): [number, number];
+    private inspectRenderImageBitmapPixels;
     /** 绘制view */
     render(renderData: IMainMessageRenderData[]): void;
+    /** 在一次 paint opportunity 之后释放已转移到主线程的渲染 Bitmap。 */
+    retireRenderImageBitmap(viewId: string, imageBitmap?: ImageBitmap): void;
+    /** View runtime 销毁时画布也会被丢弃，可以立即释放该 View 的 Bitmap。 */
+    disposeViewRenderImageBitmaps(viewId: string): void;
+    /** worker-image-bitmap 资源所有权诊断；estimatedBytes 不等同于实际 GPU 显存。 */
+    getRenderImageBitmapMemoryState(): RenderImageBitmapMemorySnapshot;
     /** 是否绘制浮动选框 */
     showFloatBar(viewId: string, isShow: boolean, opt?: Partial<ShowFloatBarMsgValue>): void;
     /** 激活文字编辑器 */
@@ -123,24 +140,40 @@ export declare abstract class BaseViewDisplayerManager {
     protected currentDrawingPointerId?: number;
     private pointerDrawingSession;
     private currentPointerDrawingSession?;
+    /** The single Done transition owned by the current pointer/touch gesture. */
+    private pointerDonePromise?;
     protected isTouchDrawing: boolean;
     protected cursorMouseMove: (e: MouseEvent) => void;
     protected cursorMouseMoveDebounced: DebouncedFunc<(e: MouseEvent) => void>;
     protected cursorMouseMoveThrottled: DebouncedFuncLeading<(e: MouseEvent) => void>;
     protected cursorMouseMoveFun: (e: MouseEvent) => void;
     private cursorEventElement?;
+    private eventTargetTouchAction?;
     private appliedCursorClassNames;
+    private pendingDpr?;
+    private dprMediaQuery?;
+    private dprMediaQueryListener?;
+    private pointLimitStopPending;
+    /** DOM 输入层计数，避免 localEventQueue 尚未消费时漏过点数上限。 */
+    private localBitmapEraserPointCount;
     private consumeClickerEvent;
     private _transferControlToOffscreenCanvas?;
     get moveDelayTime(): number;
     constructor(control: ApplianceManagerLike, internalMsgEmitter: EventEmitter2, viewId: string);
     protected cursorMouseLeave: () => void;
     abstract setCanvassStyle(): void;
+    protected requestDprUpdate(dpr: number): void;
+    commitDprUpdate(dpr: number): void;
+    cancelDprUpdate(): void;
+    protected resizeCanvasBackingStore(): void;
+    private observeDpr;
+    private stopObservingDpr;
     setTransferControlToOffscreenCanvas(canvas: {
         bgCanvas: HTMLCanvasElement;
         serviceCanvas: HTMLCanvasElement;
         localCanvas: HTMLCanvasElement;
     }): void;
+    resetRenderSurface(): Promise<void>;
     get transferControlToOffscreenCanvas(): {
         bgCanvas: OffscreenCanvas;
         serviceCanvas: OffscreenCanvas;
@@ -158,6 +191,7 @@ export declare abstract class BaseViewDisplayerManager {
     setActive(bol: boolean): void;
     focusElement(): void;
     stopEventHandler(): Promise<void>;
+    private finishPointerDone;
     protected getTranslate(element: any): any[];
     protected getContainerOffset(eventTraget: HTMLDivElement, offset: {
         x: number;
@@ -179,17 +213,21 @@ export declare abstract class BaseViewDisplayerManager {
     protected pointerup: (e: PointerEvent) => void;
     protected pointercancel: (e: PointerEvent) => void;
     protected clearTouchDocumentEvents(): void;
-    protected cancelTouchDrawing(): void;
+    protected cancelTouchDrawing(reason?: string, setUnwritable?: boolean): void;
     protected touchstart: (e: TouchEvent) => void;
     protected touchmove: (e: TouchEvent) => void;
     protected touchend: (e: TouchEvent) => void;
     protected touchcancel: () => void;
+    private suppressNativeTouchGestures;
+    private restoreNativeTouchGestures;
     protected bindDisplayerEvent(div: HTMLDivElement): void;
     protected removeDisplayerEvent(div: HTMLDivElement): void;
     get isBezier(): boolean;
     get maxDrawCount(): number;
     /** 检查是否超过最大绘制数量 */
-    checkConsumeCount(): boolean;
+    private isBitmapEraserTool;
+    private getFullLayerBitmapEraserMaxInputPoints;
+    checkConsumeCount(hasPoint?: boolean): boolean;
 }
 /** appView容器管理器抽象 */
 export declare abstract class AppViewDisplayerManager extends BaseViewDisplayerManager {
@@ -206,5 +244,4 @@ export declare abstract class MainViewDisplayerManager extends BaseViewDisplayer
     constructor(control: ApplianceManagerLike, internalMsgEmitter: EventEmitter2);
     get viewId(): string;
     updateSize(): void;
-    destroy(): void;
 }

package/dist/plugin/bitmapEraserOptions.d.ts

@@ -0,0 +1,9 @@
+export declare const DefaultFullLayerDoingMask = true;
+/** FullLayer 快路径单次事务最多接收的输入点数默认值。 */
+export declare const DefaultFullLayerDoingMaskMaxInputPoints = 500;
+/**
+ * 归一化客户可配置的 FullLayer Bitmap Eraser 点数上限。
+ * 该值只约束单个本地事务的逻辑 Point2d 数量，不代表像素或数组长度。
+ */
+export declare function normalizeFullLayerDoingMaskMaxInputPoints(value: unknown): number;
+export declare function normalizeFullLayerDoingMask(_value: unknown): boolean;

package/dist/plugin/const.d.ts

@@ -3,6 +3,10 @@ export { normalizeCursorOptions } from "../cursors/options";
 export type { NormalizedCursorOptions } from "../cursors/options";
 export declare const pkg_version: string;
 export declare const pkg_name: string;
+export declare const renderRuntimeBuildMarker: string;
+export declare const DefaultUndoAckTimeout = 5000;
+export declare const ClearUndoStackEndTimeout = 10000;
+export declare const BitmapEraserCommitTimeout = 10000;
 export declare const DefaultAppliancePluginExtrasOptions: Required<Omit<RequiredExtrasOptions, "canvasOpt">>;
 type DefaultCursorAppearance = CursorAppearance & Required<Pick<CursorVisual, "images" | "size" | "offset">> & {
     local: NonNullable<CursorAppearance["local"]> & {

package/dist/plugin/displayerView.d.ts

@@ -3,19 +3,14 @@ import { EmitEventType, ApplianceViewManagerLike } from "./types";
 import { TextEditorInfo } from "../component/textEditor";
 import { ShowFloatBarMsgValue } from "../displayer/types";
 import type { SelectorStyleOverrides } from "./types";
+import { type RenderSurfaceRefs } from "./renderSurface";
 export interface BaseDisplayerProps {
     viewId: string;
     mananger: ApplianceViewManagerLike;
-    refs: {
+    refs: RenderSurfaceRefs & {
         snapshotContainerRef?: React.RefObject<HTMLDivElement>;
         backgroundContainerRef?: React.RefObject<HTMLDivElement>;
         backgroundSnapshotContainerRef?: React.RefObject<HTMLDivElement>;
-        canvasContainerRef: React.RefObject<HTMLDivElement>;
-        subLocalCanvasContainerRef?: React.RefObject<HTMLDivElement>;
-        canvasServiceFloatRef: React.RefObject<HTMLCanvasElement>;
-        canvasFloatRef: React.RefObject<HTMLCanvasElement>;
-        canvasBgRef: React.RefObject<HTMLCanvasElement>;
-        canvasTopRef?: React.RefObject<HTMLCanvasElement>;
         floatBarRef: React.RefObject<HTMLDivElement>;
         customFloatbarContainerRef: React.RefObject<HTMLDivElement>;
     };
@@ -32,6 +27,7 @@ export interface BaseDisplayerState {
     activeTextId?: string;
     activeMiniMapViewId?: string;
     activeTextEditor?: boolean;
+    renderSurfaceGeneration: number;
 }
 export declare const DisplayerContext: React.Context<Pick<BaseDisplayerState, "scale" | "dpr" | "angle" | "floatBarData" | "operationType" | "activeTextEditor" | "activeTextId"> & {
     viewId: string;
@@ -47,10 +43,14 @@ export declare class BaseViewDisplayer extends React.Component<BaseDisplayerProp
     showTextFloatBar: boolean;
     canSelectorSwitch: boolean;
     rightBoundBreak: boolean;
+    private isUnmounted;
+    private readonly renderSurfaceResetWaiters;
     constructor(props: BaseDisplayerProps);
     private get editors();
     componentDidMount(): void;
     componentWillUnmount(): void;
+    setDpr(dpr: number): void;
+    resetRenderSurface(timeoutMs?: number): Promise<void>;
     setActiveMiniMap(viewId?: string): void;
     showFloatBarBtn(bol: boolean): void;
     showFloatBar(show: boolean, value?: Partial<ShowFloatBarMsgValue>): void;

package/dist/plugin/initLogAggregator.d.ts

@@ -0,0 +1,45 @@
+export declare const InitProgressLogDelayMs = 500;
+export type InitLogCategory = "render-init" | "init-padding" | "init-reconcile";
+export type InitLogDetails = Record<string, string | number | boolean | null | undefined>;
+export type InitLogProgressEvent = {
+    category: InitLogCategory;
+    viewId: string;
+    stage: string;
+    generation?: string | number;
+    lifecycleGeneration?: number;
+    details?: InitLogDetails;
+    restartView?: boolean;
+};
+export type InitLogCompletion = {
+    viewId: string;
+    generation?: string | number;
+    details?: InitLogDetails;
+};
+type TimerHandle = ReturnType<typeof setTimeout>;
+type InitLogAggregatorOptions = {
+    delayMs?: number;
+    schedule?: (callback: () => void, delayMs: number) => TimerHandle;
+    cancel?: (timer: TimerHandle) => void;
+};
+export declare function formatInitLogEvent(event: InitLogProgressEvent): string;
+export declare function formatInitLogCompletion(completion: InitLogCompletion): string;
+export declare class InitLogAggregator {
+    private readonly emit;
+    private readonly delayMs;
+    private readonly schedule;
+    private readonly cancel;
+    private readonly states;
+    private destroyed;
+    constructor(emit: (message: string) => void, options?: InitLogAggregatorOptions);
+    record(event: InitLogProgressEvent): void;
+    completeView(completion: InitLogCompletion): void;
+    cancelView(viewId: string): void;
+    destroy(): void;
+    private updateState;
+    private scheduleState;
+    private clearState;
+    private hasViewLifecycle;
+    private formatSummary;
+    private emitSummary;
+}
+export {};

package/dist/plugin/multi/applianceMultiManager.d.ts

@@ -6,6 +6,7 @@ export declare class ApplianceMultiManager extends BaseApplianceManager {
     windowManager?: WindowManager;
     viewContainerManager: ViewContainerMultiManager;
     constructor(params: BaseApplianceManagerProps);
+    requiresCanvas2DCompanionRenderProbe(): boolean;
     init(): void;
     activePlugin(): void;
     activeWorker(): Promise<void>;

package/dist/plugin/multi/containerManager.d.ts

@@ -11,20 +11,38 @@ export declare class ViewContainerMultiManager extends ViewContainerManager {
     /** 针对windowmanager的focusedChange先于onAppViewMounted*/
     tmpFocusedViewId?: string;
     private checkScaleTimer?;
+    private windowManager?;
+    private mainViewLifecycleRevision;
+    private readonly appViewLifecycleRevisionById;
+    private readonly appScenePathRetryTimerById;
+    private bumpAppViewLifecycleRevision;
+    private isCurrentAppViewLifecycleRevision;
+    private cancelAppScenePathRetry;
+    private consumeAppScenePathWhenReady;
+    private readonly focusedChangeListener;
+    getPreferredFocusedViewId(): string;
+    getAuthoritativeScenePath(viewId: string): string | undefined;
+    private readonly mainViewScenePathChangeListener;
+    private readonly boxCloseListener;
+    private readonly appScenePathChangeListener;
+    private readonly appsChangeListener;
     private readonly mainViewHotkeyListener;
     private readonly appViewListeners;
     constructor(props: BaseSubWorkModuleProps);
+    private logMainViewCameraTrace;
     private getAppViewListeners;
     private removeMainViewListeners;
     private removeAppViewListeners;
     destroyAppView(viewId: string, justLocal?: boolean): void;
     destroy(): void;
+    private removeWindowManagerListeners;
     getViewInitData(viewId: string): ViewWorkerOptions | undefined;
     mountView(viewId: string): Promise<void>;
     listenerWindowManager(windowManager: WindowManager): void;
     private onMainViewRelease;
     private mainViewDestroy;
-    onMainViewMounted: (bindMainView: View) => void;
+    onMainViewMounted: (bindMainView: View) => Promise<void>;
+    private mountMainView;
     private onMainViewSizeUpdated;
     private onMainViewCameraUpdated;
     private updateMainViewCamera;

package/dist/plugin/pluginInstanceOwner.d.ts

@@ -0,0 +1 @@
+export declare function createOwnedPluginInstanceProxy<T extends object, TManager extends object>(target: T, ownedManager: TManager | undefined, getCurrentManager: () => TManager | undefined): T;