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

package/dist/core/mainEngine.d.ts

@@ -1,14 +1,14 @@
 import type EventEmitter2 from "eventemitter2";
 import { BaseCollectorReducerAction, DiffOneData } from "../collector";
 import { BaseApplianceManager } from "../plugin/baseApplianceManager";
-import { BaseNodeMapItem, IActiveToolsDataType, IActiveWorkDataType, ICameraOpt, IMainMessage, IRectType, IUpdateNodeOpt, IWorkerMessage, IqueryTask, IworkId, ViewWorkerOptions } from "./types";
+import { BaseNodeMapItem, IActiveToolsDataType, IActiveWorkDataType, ICameraOpt, ICameraTaskError, IMainMessage, IRectType, IUpdateNodeOpt, IWorkerMessage, IqueryTask, IworkId, ViewWorkerOptions } from "./types";
 import { BaseSubWorkModuleProps, EmitEventType } from "../plugin/types";
 import type { ISVGMarkmapInformation, ISVGUrlInformation, IconifyInformation, ImageInformation, MarkmapId, _SetTrue } from "../plugin/types";
 import { MethodBuilderMain } from "./msgEvent";
 import { EToolsKey, EventWorkState } from "./enum";
 import { BaseShapeOptions } from "./tools";
 import { AppViewDisplayerManager, MainViewDisplayerManager } from "../plugin/baseViewContainerManager";
-import { UndoTickerSource } from "../undo/timing";
+import { type PendingTickerSnapshot, UndoTickerSource } from "../undo/timing";
 export type UndoTickerForceEndRoute = {
     kind: "stop-event";
 } | {
@@ -18,6 +18,19 @@ export type UndoTickerForceEndRoute = {
     kind: "wait-owner";
 };
 export declare function getUndoTickerForceEndRoute(source: UndoTickerSource): UndoTickerForceEndRoute;
+export type ForceDoneReason = "camera-update" | "dpr-update" | "scene-change" | "clean-scene" | "set-readonly" | "disconnect" | "destroy" | "view-destroy" | "render-runtime-fallback";
+type ViewForceDoneAckBase = {
+    viewId: string;
+    scenePath: string;
+    reason: ForceDoneReason;
+};
+export type ViewForceDoneAck = ViewForceDoneAckBase & ({
+    status: "success";
+} | {
+    status: "failed";
+    failureReason: string;
+});
+export type ViewStoragePolicy = "preserve-storage" | "delete-storage" | "storage-already-deleted";
 export declare abstract class MasterController {
     /** 异步同步时间间隔 */
     abstract readonly maxLastSyncTime: number;
@@ -92,13 +105,17 @@ export declare abstract class MasterController {
     /** 清空指定的view场景路径下的所有数据 */
     abstract clearViewScenePath(viewId: string, justLocal?: boolean, isFiter?: boolean): Promise<void>;
     abstract cancelLocalWorks(viewId: string, syncStorage?: boolean): void;
-    abstract waitForLocalEventQueue(): Promise<void>;
+    abstract abortActiveLocalInput(viewId: string, workId?: string): boolean;
+    abstract waitForLocalEventQueue(viewId?: string): Promise<void>;
     abstract finishActiveContinuousMethods(viewId: string, scenePath: string): Promise<void>;
-    abstract flushActiveTransactionBeforeOperation(viewId: string, scenePath: string, reason: "camera-update" | "scene-change" | "clean-scene"): Promise<void>;
+    abstract abortActiveContinuousMethods(viewId: string, workId?: string): boolean;
+    abstract forceDoneLocalWorks(viewId: string, scenePath: string, reason: ForceDoneReason): Promise<ViewForceDoneAck>;
+    abstract invalidateTransactionBarrier(viewId: string): void;
     /** 更新指定view场景路径下的相机参数 */
     abstract updateCamera(viewId: string, cameraOpt: ICameraOpt): void;
-    abstract cameraUpdateDestroy(viewId: string): void;
+    abstract cameraUpdateDestroy(viewId: string, recoverMethod?: boolean): void;
     abstract waitForCameraUpdateEnd(viewId: string): Promise<void>;
+    abstract waitForViewLifecycleIdle(viewId: string): Promise<void>;
     abstract isViewBusy(viewId: string): boolean;
     abstract recoverAfterSceneChange(viewId: string): void;
     /**  创建一个新的viewWorker */
@@ -122,6 +139,7 @@ export declare abstract class MasterController {
     /** 修正绘制异常任务 */
     abstract checkDrawingWork(viewId: string): Promise<number[]>;
 }
+export type ViewInitCompletionResult = "completed" | "timeout" | "stale";
 export declare class MasterControlForWorker extends MasterController {
     /** 异步同步时间间隔 */
     readonly maxLastSyncTime: number;
@@ -160,7 +178,9 @@ export declare class MasterControlForWorker extends MasterController {
         isFullWork: boolean;
         viewId: string;
         toolsType?: EToolsKey;
-        opt?: BaseShapeOptions;
+        opt?: BaseShapeOptions & {
+            fullLayerDoingMaskMaxInputPoints?: number;
+        };
         undoTickerId?: number;
         scenePath?: string;
     }>;
@@ -168,26 +188,61 @@ export declare class MasterControlForWorker extends MasterController {
     /** 是否任务队列化参数 */
     private tasksqueue;
     private cameraUpdateStateByView;
+    private cameraClearReplayByView;
+    private cameraClearReplaySequence;
+    private cameraFailureSequenceByView;
     private cameraUpdateEndWaitersByView;
+    private viewLifecycleIdleWaitersByView;
     private cameraTaskSequenceByView;
+    private cameraRecoverySequence;
+    private pendingDprOwnerByView;
+    private dprUpdateSequence;
+    /** Camera/DPR preparation is serialized per View. */
+    private localWorkFinalizeQueueByView;
+    /** @deprecated Legacy test/host compatibility when the per-View map is absent. */
     private localWorkFinalizeQueue;
     private operationBarrierQueueByView;
+    private operationBarrierEpochByView;
+    private operationBarrierInvalidationWaitersByView;
     private readonly cancelledEraseTxnIds;
+    private cancelledEraseTxnOwners;
+    /** Tombstones for cancelled Pencil/Shape output that may return after Clear. */
+    private cancelledLocalWorkOwners?;
+    private fullLayerBitmapEraseTxns;
+    private fullLayerBitmapEraseTxnWaiters;
     /** end */
     private snapshotMap;
+    /** Request identities prevent a late Snapshot from resolving a new request for the same View/Scene. */
+    private snapshotRequestIdByViewScene;
     private boundingRectMap;
+    private boundingRectRequestIdByViewScene;
     private clearAllResolveMap;
     private localEventQueue;
+    /** Latest serialized local-event task for each View. */
+    private localEventQueueByView;
+    /** 0ms Done handoffs must be cancellable during destroy/re-init. */
+    private localDoneDispatchTimersByView;
     private localEventSequence;
+    /** Invalidates queued pointer events without changing the View runtime owner. */
+    private localInputEpochByView?;
+    /** Pins one epoch to every Start -> Doing -> Done pointer transaction. */
+    private localInputTransactionEpochByView?;
+    private localDoneWaitSequence;
     private queuedLocalEventCount;
     private activeLocalEvent?;
+    /** Done handoff waiters are View-scoped; one View must never settle another. */
+    private localDoneWaitByView;
+    private delayWorkStateToDoneResolveByView;
+    /** @deprecated Kept as a read/cleanup compatibility alias for older hosts. */
     private localDoneWait?;
+    /** @deprecated Kept as a read/cleanup compatibility alias for older hosts. */
     private delayWorkStateToDoneResolve?;
     private animationId;
     private tmpImageConfigMap;
     private mainThread?;
     private backgroundThreadManager?;
-    private willSelectorWorkId?;
+    /** Pending auto-selection targets are isolated per View. */
+    private willSelectorWorkIdByView;
     private isLockSentEventCursor;
     private getVNodeInfoResolveMap;
     private refreshTextRenderResolveMap;
@@ -198,34 +253,87 @@ export declare class MasterControlForWorker extends MasterController {
     private serviceSyncReadyViews;
     private mainViewInitAckCallbacks;
     private readonly initAckedViewIds;
+    private viewInitAckTimeoutTimers;
+    private renderRuntimeCacheSavePromise?;
     private pendingTransportMessages;
     private isRenderTransportReady;
-    private renderProbeResolve?;
-    private renderProbeRequestId?;
-    private renderProbeTimer?;
+    private renderRuntimeFallbackSequence;
+    private activeRenderRuntimeRecovery?;
+    private viewInitRecoveryAttempts;
+    private viewInitRecoveryDestroying;
+    private viewInitAckWaiters;
+    private serviceSyncCommitWaiters;
+    private viewServiceReadyWaiters;
+    private initReconcileTasks;
+    private serviceSyncSequence;
     private initGeneration;
     private viewGenerationById;
+    private fullLayerFrameStateByView;
+    private pendingDprByView;
+    private viewRecoveryQueueByView;
     /** Camera snapshot sent in the view Init message, used for the ACK-time check. */
     private initCameraOptByView;
     private markmapIdResolveMap;
+    private getDoneWaitForView;
+    private getDoneResolverForView;
+    private getLocalWorkFinalizeQueue;
+    private setLocalWorkFinalizeQueue;
+    private clearLocalWorkFinalizeQueue;
+    private clearDoneWaitForView;
     constructor(props: BaseSubWorkModuleProps);
     get isBezier(): boolean;
-    get Logger(): import("..").Logger;
+    get Logger(): import("../plugin/utils").LoggerUtils;
+    private logRenderRuntimeFallback;
+    private logMainViewCameraTrace;
+    private closeImageBitmap;
+    private getViewSceneRequestKey;
+    private settleSnapshotFailure;
+    private settleBoundingRectFailure;
+    private settleViewRenderRequests;
     afterMainViewInitAck(callback: () => void): void;
     get isMainViewInitAck(): boolean;
     waitForMainViewInitAck(timeoutMs?: number): Promise<"ready" | "cancelled" | "timeout">;
     isViewInitAck(viewId: string): boolean;
     private ackMainViewInit;
+    private scheduleInitReconcile;
+    private isCurrentViewGeneration;
+    private reconcileViewInit;
+    private submitInitServiceSnapshot;
+    private waitForInitCameraCatchUp;
+    private waitForServiceSyncCommit;
+    private ackServiceSyncCommit;
+    private finalizeViewInitReady;
     private flushPendingTransportInitMessages;
     private getPendingInitMessageKey;
-    private pullLatestServiceDataAfterInit;
+    private markServiceSyncReady;
+    private waitForViewInitAck;
+    private waitForViewServiceReady;
+    private armViewInitAckTimeout;
+    waitForViewInitCompletion(viewId: string): Promise<ViewInitCompletionResult>;
+    private failViewInitOnTerminalRuntime;
+    private settlePendingViewInitWaitersForRecovery;
+    private isViewScopedInitFailure;
+    private scheduleViewInitRecovery;
+    private scheduleRenderRuntimeFallback;
+    private isRenderRuntimeRecoveryCurrent;
+    private assertRenderRuntimeRecoveryCurrent;
+    private isRenderRuntimeRecoveryViewCurrent;
+    private finishRenderRuntimeRecovery;
+    private persistRecoveredRenderRuntime;
+    cancelRenderRuntimeRecovery(reason: string): void;
+    private runRenderRuntimeFallback;
+    private runActiveRenderRuntimeFallback;
+    private rebuildRenderRuntimeOnSerialQueue;
     private assertMarkmapRuntimeRegistered;
-    destroy(preserveInitReady?: boolean): void;
+    destroy(preserveInitReady?: boolean, preserveCameraRecovery?: boolean): void;
+    private settlePendingMarkmapRequestsOnDestroy;
     private get consumeCount();
     private set consumeCount(value);
     private acceptConsumeAck;
     private get postCount();
     isServiceSyncReady(viewId: string): boolean;
+    isRenderRuntimeRecovering(): boolean;
+    private isViewInitReady;
     private set postCount(value);
     private get viewContainerManager();
     private get collector();
@@ -237,10 +345,21 @@ export declare class MasterControlForWorker extends MasterController {
     private get isPostCountType();
     private get isCanPostDraw();
     private get isCanStartEventConsum();
-    init(): Promise<void>;
+    init(runtimeAlreadyDestroyed?: boolean): Promise<void>;
     private useBackgroundThread;
     private useMainThread;
-    on(): Promise<boolean | void>;
+    private getRenderProbeCandidates;
+    private getRenderProbeProfile;
+    private createRenderProbeDOMCanvas;
+    private probeRenderRuntimeCandidate;
+    private createRenderProbeSession;
+    private closeRenderProbeSession;
+    private resolveRenderProbeEntry;
+    private requestRenderProbeCandidate;
+    private finalizeRenderProbeResponse;
+    private readTransferredCanvasDestinationPixels;
+    private probeAndLockRenderRuntime;
+    on(isProbeRetry?: boolean): Promise<boolean | void>;
     clearFontCache(): Promise<boolean>;
     getFontCacheStatus(): Promise<{
         count: number;
@@ -254,6 +373,22 @@ export declare class MasterControlForWorker extends MasterController {
     refreshTextRenderForWorker(tasks: Array<Pick<IWorkerMessage, "viewId" | "scenePath" | "workId" | "opt">>): Promise<boolean>;
     private buildPropertyAppliedData;
     clearReRenders(num?: number): void;
+    private retireRenderedImageBitmap;
+    private getFullLayerBitmapEraseTxns;
+    private getBitmapEraserRenderer;
+    private logBitmapEraserTrace;
+    private finishFullLayerBitmapEraseTxn;
+    private waitForFullLayerBitmapEraseTxns;
+    private rememberCancelledEraseTxn;
+    private isCancelledEraseResult;
+    private rememberCancelledLocalWork;
+    private isCancelledLocalWorkResult;
+    private isCancelledLocalWork;
+    private filterCancelledEraseRenders;
+    private reportRenderFrameError;
+    private acceptFullLayerFrame;
+    private acceptWorkerBatch;
+    private scheduleViewRecovery;
     get isBusy(): boolean;
     isViewBusy(viewId: string): boolean;
     getLockSentEventCursor(): boolean;
@@ -263,15 +398,25 @@ export declare class MasterControlForWorker extends MasterController {
     getFullWorkDrawCount(): number;
     getMaxDrawCount(): number;
     setSubWorkerDrawCount(num: number): void;
-    setConsumeCount(num: number): void;
+    setConsumeCount(num: number, consumeWorkId?: string): void;
     getConsumeCount(): number;
+    /** 当前 View 本地事务已接收的原始输入点数。 */
+    getLocalInputPointCount(viewId: string, toolsType?: EToolsKey): number;
     setWorkerTasksqueueCount(num: number): void;
     collectorSyncData(sp: IMainMessage[]): void;
     private collectorAsyncData;
+    /**
+     * Storage mutations must carry the generation of the View runtime that
+     * produced them. UI-only reports remain compatible with older workers, but
+     * a missing generation on a mutation is rejected once the View is known.
+     */
+    private isStaleViewStorageMessage;
     private onLocalEventEnd;
     private onLocalEventDoing;
     private onLocalEventStart;
     private setLocalPointIsFullWork;
+    private getFullLayerBitmapEraserMaxInputPoints;
+    private forceDoneFullLayerBitmapEraseAtPointLimit;
     private pushLocalPoint;
     private deleteLocalPoint;
     private getLocalPointInfo;
@@ -283,7 +428,9 @@ export declare class MasterControlForWorker extends MasterController {
         isFullWork: boolean;
         viewId: string;
         toolsType?: EToolsKey;
-        opt?: BaseShapeOptions;
+        opt?: BaseShapeOptions & {
+            fullLayerDoingMaskMaxInputPoints?: number;
+        };
         undoTickerId?: number;
         scenePath?: string;
     }>;
@@ -313,9 +460,18 @@ export declare class MasterControlForWorker extends MasterController {
         } | undefined;
         localDoneWait: {
             waitingMs: number;
+            token?: string;
             workIds: string[];
-            startedAt: number;
+            viewId?: string;
+            startedAt?: number;
         } | undefined;
+        localDoneWaits: {
+            waitingMs: number;
+            token?: string;
+            workIds: string[];
+            viewId?: string;
+            startedAt?: number;
+        }[];
         hasDoneResolver: boolean;
         localPoints: {
             workId: IworkId;
@@ -335,24 +491,32 @@ export declare class MasterControlForWorker extends MasterController {
             isBusy: boolean;
             hasPending: boolean;
             hasPrepare: boolean;
+            isRecovering: boolean;
+            recoveryFromGeneration: number | undefined;
+            recoveryOwner: number | undefined;
+            hasReplayCamera: boolean;
             currentTaskId: number | undefined;
-            lastAckTaskId: number | undefined;
+            transactionTaskId: number | undefined;
+            transactionGeneration: number | undefined;
+            coreAckReceived: boolean | undefined;
+            settledAckReceived: boolean | undefined;
         }[];
         operationBarrierViews: string[];
         clearBusyViews: string[];
-        pendingTickers: import("../undo/timing").PendingTickerSnapshot[];
+        pendingTickers: PendingTickerSnapshot[];
     };
     private shouldUseAutoShape;
     private toAutoShapePoints;
-    private logAutoShapeResult;
     private emitAutoShapeResult;
     private createAutoShapeTask;
     private mapAutoShapeFallback;
     private correctStorage;
     originalEventLintener(workState: EventWorkState, point: [number, number], viewId: string): Promise<void>;
-    waitForLocalEventQueue(): Promise<void>;
+    waitForLocalEventQueue(viewId?: string): Promise<void>;
     finishActiveContinuousMethods(viewId: string, scenePath: string): Promise<void>;
-    flushActiveTransactionBeforeOperation(viewId: string, scenePath: string, _reason: "camera-update" | "scene-change" | "clean-scene"): Promise<void>;
+    forceDoneLocalWorks(viewId: string, scenePath: string, reason: ForceDoneReason): Promise<ViewForceDoneAck>;
+    invalidateTransactionBarrier(viewId: string): void;
+    private waitForCurrentTransactionBarrier;
     private executeTransactionBarrier;
     private consumeOriginalEvent;
     getLocalWorkViewId(): string | undefined;
@@ -360,14 +524,18 @@ export declare class MasterControlForWorker extends MasterController {
     setCurrentToolsData(currentToolsData: IActiveToolsDataType): void;
     private prepareOnceWork;
     createViewWorker(viewId: string, options: ViewWorkerOptions, displayer: MainViewDisplayerManager | AppViewDisplayerManager): void;
-    destroyViewWorker(viewId: string, isLocal?: boolean): void;
+    private discardViewTransactions;
+    destroyViewWorker(viewId: string, storagePolicy: ViewStoragePolicy, preserveCameraRecovery?: boolean): void;
     onServiceDerive(key: string, data: DiffOneData<BaseCollectorReducerAction | undefined>): void;
     pullServiceData(viewId: string, scenePath: string, options?: {
         isAsync?: boolean;
         useAnimation?: boolean;
     }): void;
+    private pullServiceDataForReadyRenderer;
     runAnimation(): void;
     consume(): void;
+    private armBitmapEraserCommitTimeout;
+    private markFullLayerBitmapEraseDoneStaging;
     unWritable(): void;
     abled(): void;
     isAbled(): boolean;
@@ -376,23 +544,59 @@ export declare class MasterControlForWorker extends MasterController {
     post(msg: Set<IWorkerMessage>): void;
     private dispatchMessages;
     updateNode(workId: IworkId, updateNodeOpt: IUpdateNodeOpt, viewId: string, scenePath: string): void;
-    destroyTaskQueue(): void;
+    destroyTaskQueue(preserveCameraRecovery?: boolean): void;
     updateDpr(viewId: string, dpr: number): void;
+    private releasePendingDprUpdate;
+    private cancelPendingDprUpdate;
+    private applyDprUpdate;
+    private cloneCameraReplay;
+    private beginCameraClearReplay;
+    private finishCameraClearReplay;
+    private getCameraReplayCandidate;
+    private getActiveRenderRuntimeRecoveryView;
+    private nextCameraRecoveryOwner;
+    private updateCameraRecoveryReplay;
+    private beginCameraRecovery;
+    private releaseCameraRecovery;
+    private releaseRenderRuntimeRecoveryCameras;
+    private dispatchCameraRecoveryReplay;
     updateCamera(viewId: string, cameraOpt: ICameraOpt): void;
+    private updateCameraForReadyRenderer;
+    private schedulePendingCameraForView;
     private isSameCameraOpt;
     private enqueueCameraPreparation;
     private consumePendingCameraForView;
-    private resetCameraTimeout;
-    ackCameraTask(viewId: string, taskId: number): void;
-    ackCameraSettledTask(viewId: string, taskId: number): void;
-    cameraUpdateDestroy(viewId: string): void;
+    private clearCameraTaskTimeouts;
+    private startCameraTaskTimeouts;
+    private isCurrentCameraTransaction;
+    private completeCameraTransactionIfReady;
+    ackCameraTask(viewId: string, taskId: number, viewGeneration?: number): void;
+    failCameraTask(viewId: string, taskId: number, error: ICameraTaskError, viewGeneration?: number): void;
+    ackCameraSettledTask(viewId: string, taskId: number, viewGeneration?: number): void;
+    cameraUpdateDestroy(viewId: string, recoverMethod?: boolean): void;
+    private resolveCameraUpdateEndWaiters;
     waitForCameraUpdateEnd(viewId: string): Promise<void>;
-    recoverAfterSceneChange(_viewId: string): void;
+    waitForViewLifecycleIdle(viewId: string): Promise<void>;
+    private hasPendingViewLifecycleWork;
+    private resolveViewLifecycleIdleWaiters;
+    recoverAfterSceneChange(viewId: string): void;
+    abortActiveContinuousMethods(viewId: string, workId?: string): boolean;
+    abortActiveLocalInput(viewId: string, workId?: string): boolean;
     clearViewScenePath(viewId: string, justLocal?: boolean | undefined, isFiter?: boolean): Promise<void>;
     private internalMsgEmitterListener;
     private setZIndex;
     checkDrawingWork(vId: string): Promise<number[]>;
-    cancelLocalWorks(viewId: string, syncStorage?: boolean): void;
+    cancelLocalWorks(viewId: string, syncStorage?: boolean, onlyWorkIds?: ReadonlySet<string>): void;
+    timeoutLocalWorks(viewId: string, scenePath: string, reason: string, onlyWorkIds?: ReadonlySet<string>, error?: unknown): void;
+    /**
+     * Bitmap Done mutates the worker VNode/display tree before its Collector
+     * apply marker arrives. On a commit deadline, replay the captured
+     * before-images to both renderer and storage, then let the normal cancel
+     * path close the dynamic Undo scope. Compensation messages deliberately do
+     * not carry eraseTxnId, so the late Done tombstone cannot discard recovery.
+     */
+    private rollbackBitmapEraserTxn;
+    private logLocalWorkBarrierError;
     removeDrawingWork(vId: string): void;
     removeNodes(viewId: string, removeIds: string[]): void;
     hoverCursor(point: [number, number], viewId: string): void;
@@ -420,3 +624,4 @@ export declare class MasterControlForWorker extends MasterController {
         vInfo?: BaseNodeMapItem[];
     } | undefined>;
 }
+export {};

package/dist/core/mainThread/base.d.ts

@@ -7,6 +7,7 @@ import { EDataType } from "../enum";
 import { SubTopThread } from "./subTopThread";
 import { SubLocalThread } from "./subLocalThread";
 import { SubServiceThread } from "./subServiceThread";
+import type { MainThreadRenderMode } from "../../plugin/renderingCompatibility";
 export type ICanvasOptionType = IOffscreenCanvasOptionType;
 export interface IMainThreadInitOption {
     container: HTMLDivElement;
@@ -14,6 +15,10 @@ export interface IMainThreadInitOption {
     layerOpt: ILayerOptionType;
     master: MasterControlForWorker;
     displayer: MainViewDisplayerManager | AppViewDisplayerManager;
+    /** Runtime identity used to reject continuations from a replaced View. */
+    viewOwner?: string;
+    viewGeneration?: number;
+    mainThreadRenderMode?: MainThreadRenderMode;
     post(sp: Omit<IBatchMainMessage, "render">): void;
 }
 export interface ISubThreadInitOption {
@@ -60,9 +65,15 @@ export declare class MainThreadEngineImpl implements MainThreadEngine {
     private taskUpdateCameraId?;
     private taskUpdateCameraResolve?;
     private debounceUpdateCameraId?;
+    private activeCameraSettledRender?;
+    private activeCameraTaskContext?;
     private debounceUpdateCache;
     private mainThreadPostId?;
     private destroyed;
+    private readbackScheduler?;
+    private readonly restoreLayerRenderCallbacks;
+    private readonly viewOwner?;
+    private readonly viewGeneration?;
     private combinePostMsg;
     private methodBuilder;
     private cacheImages;
@@ -72,12 +83,17 @@ export declare class MainThreadEngineImpl implements MainThreadEngine {
     getCachedImagesByWorkId(workId: string): HTMLImageElement | ImageBitmap | undefined;
     deleteCachedImagesByWorkId(workId: string): void;
     clearCacheImages(): void;
-    clearImageResolveMap(): void;
+    private closeImageSource;
+    clearImageResolveMap(error?: unknown): void;
     post(msg: Omit<IBatchMainMessage, "render">): void;
+    reportRendererBusinessError(error: unknown, fallback: {
+        business: string;
+        stage: string;
+    }): void;
     updateDpr(dpr: number): void;
     on(msg: IWorkerMessage): Promise<void>;
     private getIconSize;
-    loadImageBitMap(msg: Pick<IWorkerMessage, "toolsType" | "opt" | "workId">): Promise<HTMLImageElement | ImageBitmap | undefined>;
+    loadImageBitMap(msg: Pick<IWorkerMessage, "toolsType" | "opt" | "workId" | "requestId">): Promise<HTMLImageElement | ImageBitmap | undefined>;
     private removeNode;
     consumeFull(type: EDataType, data: IWorkerMessage): Promise<void>;
     setCameraOpt(cameraOpt: ICameraOpt): void;
@@ -91,7 +107,12 @@ export declare class MainThreadEngineImpl implements MainThreadEngine {
     getSceneRect(): IRectType;
     private createScene;
     private createLayer;
+    private enableCanvas2DReadback;
+    private disableCanvas2DReadback;
     private updateScene;
     private updateLayer;
+    private cancelCameraSettledRender;
+    private retargetCameraSettledRender;
+    private cancelCameraBlockingWait;
     destroy(): void;
 }

package/dist/core/mainThread/canvas2DReadback.d.ts

@@ -0,0 +1,27 @@
+type FrameHandle = number;
+export type Canvas2DReadbackSchedulerOptions = {
+    tailFrameCount?: number;
+    requestFrame?: (callback: FrameRequestCallback) => FrameHandle;
+    cancelFrame?: (handle: FrameHandle) => void;
+    onReadbackError?: (error: unknown) => void;
+};
+/**
+ * Coalesces Canvas2D readbacks for one main-thread View. A render refreshes
+ * that Canvas' tail so continuous input performs at most one readback per RAF.
+ */
+export declare class Canvas2DReadbackScheduler {
+    private readonly pendingFrames;
+    private readonly failedCanvases;
+    private readonly tailFrameCount;
+    private readonly requestFrame;
+    private readonly cancelFrame;
+    private readonly onReadbackError?;
+    private frameHandle?;
+    private destroyed;
+    constructor(options?: Canvas2DReadbackSchedulerOptions);
+    markRendered(canvas: HTMLCanvasElement): void;
+    destroy(): void;
+    private schedule;
+    private flushFrame;
+}
+export {};

package/dist/core/mainThread/index.d.ts

@@ -8,19 +8,30 @@ export interface MainThreadManager {
     createMainThread(viewId: string, opt: IMainThreadInitOption): MainThreadEngineImpl;
     consume(msg: Set<IWorkerMessage>): Promise<void>;
     post(sp: Omit<IBatchMainMessage, "render">): void;
+    discardView(viewId: string): void;
     destroy(): void;
 }
 export declare class MainThreadManagerImpl implements MainThreadManager {
     mainThreadMap: Map<string, MainThreadEngineImpl>;
     private cameraRenderQueueByView;
     private viewGenerationById;
-    private snapshotThread?;
+    private viewOwnerById;
+    private ownerSequence;
+    private snapshotThreadsByRequest;
+    private destroyed;
     master: MasterControlForWorker;
     constructor(master: MasterControlForWorker);
     private enqueueViewTask;
+    private isStaleViewMessage;
     post: (msg: Omit<IBatchMainMessage, "render">) => void;
+    discardView(viewId: string): void;
     destroy(): void;
     createMainThread(viewId: string, opt: IMainThreadInitOption): MainThreadEngineImpl;
     createSnapshotThread(viewId: string, opt: IMainThreadInitOption): SnapshotThreadImpl;
+    private getSnapshotRequestKey;
+    private disposeSnapshotThread;
+    private releaseMessageBitmap;
+    private releaseBatchResources;
+    private releaseImageBitmap;
     consume(msg: Set<IWorkerMessage>): Promise<void>;
 }

package/dist/core/mainThread/snapshotThread.d.ts

@@ -11,22 +11,30 @@ export declare class SnapshotThreadImpl {
     fullLayer: Group;
     master: MasterControlForWorker;
     private opt;
+    private readonly viewOwner?;
+    private readonly viewGeneration?;
     private scene;
     private mainThreadPostId?;
     private combinePostMsg;
+    private destroyed;
     workShapes: Map<string, BaseShapeTool>;
     private cacheImages;
     private imageResolveMap;
+    private activeRequest?;
     constructor(viewId: string, opt: IMainThreadInitOption);
     getCachedImages(imageSrc: string): HTMLImageElement | ImageBitmap | undefined;
     getCachedImagesByWorkId(workId: string): HTMLImageElement | ImageBitmap | undefined;
     deleteCachedImagesByWorkId(workId: string): void;
     clearCacheImages(): void;
+    private closeImageSource;
+    private releaseMessageImageBitmap;
+    private releaseBatchImageBitmaps;
     clearImageResolveMap(): void;
     post(msg: Omit<IBatchMainMessage, "render">): void;
+    private reportRequestFailure;
     on(msg: IWorkerMessage): Promise<void>;
     private getIconSize;
-    loadImageBitMap(msg: Pick<IWorkerMessage, "toolsType" | "opt" | "workId">): Promise<HTMLImageElement | ImageBitmap | undefined>;
+    loadImageBitMap(msg: Pick<IWorkerMessage, "toolsType" | "opt" | "workId" | "requestId">): Promise<HTMLImageElement | ImageBitmap | undefined>;
     createWorkShapeNode(opt: IActiveToolsDataType & {
         workId: string;
     }): TextShape | import("../tools").ArrowShape | import("../tools").PencilShape | import("../tools/straight").StraightShape | import("../tools").EllipseShape | import("../tools").PolygonShape | import("../tools").StarShape | import("../tools").RectangleShape | import("../tools").SpeechBalloonShape | import("../tools").LaserPenShape | import("../tools").EraserShape | import("../tools").BitMapEraserShape | import("../tools/pencilEraser").PencilEraserShape | import("../tools").SelectorShape | ImageShape | ISvgShadowShape | undefined;
@@ -39,11 +47,12 @@ export declare class SnapshotThreadImpl {
     private getBoundingRect;
     setCameraOpt(cameraOpt: ICameraOpt): void;
     private runBatchPostData;
+    private flushPendingPost;
     private combinePostData;
     combinePost(): void;
     private createScene;
     private createLayer;
     private updateScene;
     private updateLayer;
-    destroy(): void;
+    destroy(reason?: string): void;
 }