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

package/dist/core/types.d.ts

@@ -7,6 +7,7 @@ import type { SelectorShape } from "./tools";
 import type { Direction } from "re-resizable/lib/resizer";
 import type { ShapeOptType } from "../displayer/types";
 import type { AutoShapeResult } from "./autoShape/types";
+import type { RenderProbeProfile, WorkerRenderCapabilities } from "./worker/renderCapabilityProbe";
 export type PickOne<T> = {
     [P in keyof T]: Record<P, T[P]> & Partial<Record<Exclude<keyof T, P>, undefined>>;
 }[keyof T];
@@ -27,7 +28,6 @@ export type ViewWorkerOptions = {
 export interface IBitmapEraserMaskOptions {
     singleChannelTexture: boolean;
     textureSubImage2D: boolean;
-    imageBitmapDirtyRect: boolean;
 }
 export interface ICanvasSceneType {
     /** canvas 上下文 */
@@ -166,6 +166,13 @@ export type IWorkerMessage = Omit<Partial<BaseCollectorReducerAction>, "op"> & {
         bgCanvas: OffscreenCanvas;
         serviceCanvas: OffscreenCanvas;
     };
+    /** Temporary canvas used only by the SpriteJS initialization probe. */
+    probeCanvas?: OffscreenCanvas;
+    /** Frozen mainView render profile used by every TestScene candidate. */
+    probeProfile?: RenderProbeProfile;
+    /** Init reconcile service commit identity. */
+    serviceSyncId?: string;
+    serviceRevision?: number;
     /** 字体库 */
     fontBuffers?: {
         fontFamily: string;
@@ -188,6 +195,8 @@ export interface IRectType {
 }
 export interface IMainMessage extends INormalPushMsg {
     type: EPostMessageType;
+    serviceSyncId?: string;
+    serviceRevision?: number;
     /** Cursor point 生成时对应的稳定视觉工具名。 */
     cursorTool?: CursorToolName;
     dataType?: EDataType;
@@ -224,6 +233,8 @@ export interface IMainMessage extends INormalPushMsg {
     scaleType?: EScaleType;
     textOpt?: TextOptions;
     viewId?: string;
+    /** View lifecycle generation that produced this internal message. */
+    viewGeneration?: number;
     points?: [number, number][];
     isRefresh?: boolean;
     renderRect?: IRectType;
@@ -237,14 +248,45 @@ export interface IMainMessage extends INormalPushMsg {
     collectUndoTicker?: number;
     undoScopeIds?: string[];
     undoScopePhase?: "collect" | "finalize";
+    /** Bitmap Eraser target-application marker emitted after all target ops. */
+    eraseTxnPhase?: "applied" | "failed";
+    /** Internal Done result used to choose the terminal transaction marker. */
+    eraseTxnCommitStatus?: "applied" | "failed";
+    /** Internal renderer request business used to settle Snapshot waiters. */
+    reportBusiness?: "snapshot" | "bounding-box";
+    /** Structured renderer failure stage for request-scoped diagnostics. */
+    reportStage?: string;
+    reportError?: string;
+    /** Structured runtime failure code consumed by MainEngine recovery. */
+    reportErrorCode?: "WEBGL_PROGRAM_UNAVAILABLE" | "SERVICE_SYNC_COMMIT_TIMEOUT" | "IMAGE_BITMAP_RENDER_FAILED" | "INIT_CAMERA_CATCH_UP_FAILED" | "RENDER_INIT_TIMEOUT" | "CAMERA_TRANSPORT_TIMEOUT" | "RENDERER_RUNTIME_ERROR";
+    reportContextType?: ECanvasContextType;
+    reportContextLost?: boolean;
+    reportGlError?: number;
+    reportCurrentProgram?: boolean;
+    reportProgramLinked?: boolean;
+    reportProgramHasUniforms?: boolean;
     clearPreviewLocalWork?: boolean;
     autoShapeResult?: AutoShapeResult;
     [key: string]: any;
 }
 export interface IMainMessageRenderData {
     viewId: string;
+    /** Opaque View generation that produced this render. */
+    viewGeneration?: number;
+    /** BitMapEraser transaction owner, used to discard stale view renders. */
+    eraseTxnId?: string;
     rect?: IRectType;
     imageBitmap?: ImageBitmap;
+    /** Worker transferToImageBitmap output owns the complete Layer frame. */
+    isFullFrameImageBitmap?: boolean;
+    /** Monotonic sequence for FullLayer frames within one View generation. */
+    frameSequence?: number;
+    /** Worker combine-post task that produced this FullLayer frame. */
+    taskId?: number;
+    /** All local work owners represented by a coalesced Layer capture. */
+    renderWorkIds?: string[];
+    /** All erase transactions represented by a coalesced Layer capture. */
+    renderEraseTxnIds?: string[];
     isDrawAll?: boolean;
     drawCanvas?: ECanvasShowType;
     isClear?: boolean;
@@ -260,6 +302,16 @@ export interface IMainMessageRenderData {
     translate?: [number, number];
     workId?: string;
 }
+export type CameraTaskStatus = "timeout" | "failed";
+export interface ICameraTaskError {
+    code: "RENDERER_BUSINESS_TIMEOUT" | "RENDERER_BUSINESS_ERROR" | "CAMERA_TRANSPORT_TIMEOUT";
+    business: "updateCamera";
+    message: string;
+    elapsedMs?: number;
+    stage?: string;
+    blockingWorks?: string[];
+    workerType?: string;
+}
 export interface IBatchMainMessage {
     /** 绘制数据 */
     render?: Array<IMainMessageRenderData>;
@@ -267,15 +319,26 @@ export interface IBatchMainMessage {
     sp?: Array<IMainMessage>;
     workerTasksqueueCount?: number;
     cameraTaskId?: number;
+    /** 缺省表示成功 ACK；timeout/failed 表示 Camera 业务失败终态。 */
+    cameraTaskStatus?: CameraTaskStatus;
+    cameraTaskError?: ICameraTaskError;
     /** Camera 防抖重渲染及最终 Layer render 已完成。 */
     cameraSettledTaskId?: number;
     workIds?: Set<string>;
     viewId?: string;
+    /** View lifecycle generation that produced this batch. */
+    viewGeneration?: number;
+    /** Opaque runtime owner for MainThread-originated asynchronous output. */
+    viewOwner?: string;
     consumeCount?: number;
     /** 标识限频 ACK 所属的本地 work，防止旧笔迹 ACK 污染新笔迹。 */
     consumeWorkId?: string;
     subWorkerDrawCount?: number;
     fullWorkerDrawCount?: number;
+    /** Worker-owned rendering capability probe response. */
+    type?: EPostMessageType;
+    requestId?: string;
+    workerCapabilities?: WorkerRenderCapabilities;
 }
 export interface ICameraOpt {
     centerX: number;

package/dist/core/utils/indexDB.d.ts

@@ -6,9 +6,9 @@ export declare class IndexDBUtils {
     private readonly FONT_DB_VERSION;
     private constructor();
     static getInstance(): IndexDBUtils;
-    initFontDB(): Promise<IDBDatabase>;
-    getFontFromDB(fontFamily: string, url?: string): Promise<ArrayBuffer | null>;
-    saveFontToDB(fontFamily: string, url: string, buffer: ArrayBuffer): Promise<boolean>;
+    initFontDB(signal?: AbortSignal): Promise<IDBDatabase>;
+    getFontFromDB(fontFamily: string, url?: string, signal?: AbortSignal): Promise<ArrayBuffer | null>;
+    saveFontToDB(fontFamily: string, url: string, buffer: ArrayBuffer, signal?: AbortSignal): Promise<boolean>;
     clearFontCache(): Promise<boolean>;
     getFontCacheStatus(): Promise<{
         count: number;

package/dist/core/vNodeManager.d.ts

@@ -3,6 +3,8 @@ import { BaseNodeMapItem, IRectType } from "./types";
 import { EToolsKey } from ".";
 import { _SetTrue } from "../plugin";
 import { ObserverMap } from "./utils/ObserverMap";
+export type VNodeRevisionOperation = "add" | "delete" | "update" | "clear" | "permission";
+export type VNodeRevisionObserver = (operation: VNodeRevisionOperation, revision: number, key?: string) => void;
 export declare class VNodeManager {
     viewId: string;
     scene: Scene;
@@ -15,9 +17,13 @@ export declare class VNodeManager {
     private readonly spatialIndex;
     private readonly spatialEntries;
     private verifySpatialIndex;
+    private revision;
+    private readonly revisionObservers;
     constructor(viewId: string, scene: Scene);
     init(fullLayer: Group): void;
     get(name: string): BaseNodeMapItem | undefined;
+    getRevision(): number;
+    observeRevision(observer: VNodeRevisionObserver): () => void;
     setLocalUid(uid: string): void;
     getLocalUid(): string | undefined;
     setSpatialIndexVerification(enabled: boolean): void;
@@ -36,6 +42,7 @@ export declare class VNodeManager {
     unSelected(name: string): void;
     delete(name: string): void;
     clear(): void;
+    private notifyRevisionObservers;
     getRectIntersectRange(rect: IRectType, filterLock?: boolean, filterEditor?: boolean): {
         rectRange: IRectType | undefined;
         nodeRange: Map<string, BaseNodeMapItem>;

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

@@ -1,4 +1,4 @@
-import { Group, Scene } from "spritejs";
+import { Group, Layer, Scene } from "spritejs";
 import { IActiveToolsDataType, IActiveWorkDataType, IBatchMainMessage, ICameraOpt, ILayerOptionType, IOffscreenCanvasOptionType, IRectType, IWorkerMessage } from "../types";
 import { VNodeManager } from "../vNodeManager";
 import { type ECanvasContextType, ECanvasShowType, EDataType, EventWorkState } from "../enum";
@@ -8,10 +8,13 @@ import type { LocalWorkForFullWorker } from "./fullWorkerLocal";
 import type { LocalWorkForSubWorker } from "./subWorkerLocal";
 import { EWorkThreadType, type WorkThreadEngineForFullWorker, type WorkThreadEngineForSubWorker, type WorkThreadEngineForSimpleWorker } from "./workerManager";
 import { EmitEventType } from "../../plugin/types";
+import { CameraUpdateTaskContext } from "../cameraTask";
+import { type RendererBusinessTaskOptions } from "../rendererBusinessTask";
 import type { IBitmapEraserMaskOptions } from "../types";
 import { MaxDelayBatchScheduler, WorkerAckBackpressure } from "../batchScheduler";
 export interface IWorkerInitOption {
     dpr: number;
+    viewGeneration?: number;
     offscreenCanvasOpt: IOffscreenCanvasOptionType;
     layerOpt: ILayerOptionType;
     combineUnitTime?: number;
@@ -37,6 +40,7 @@ export interface ISubWorkerInitOption {
 }
 export declare abstract class WorkThreadEngineBase {
     readonly viewId: string;
+    readonly viewGeneration?: number;
     readonly type: EWorkThreadType;
     scene: Scene;
     fullLayer: Group;
@@ -48,7 +52,7 @@ export declare abstract class WorkThreadEngineBase {
     abstract localWork: LocalWorkForFullWorker | LocalWorkForSubWorker;
     abstract serviceWork?: ServiceWorkForFullWorker;
     protected isSafari: boolean;
-    protected abstract _post: (msg: IBatchMainMessage) => void;
+    protected abstract _post: (msg: IBatchMainMessage, transfer?: Transferable[]) => void;
     combinePostMsg: Set<IBatchMainMessage>;
     protected workerTaskId?: number | undefined;
     protected protectedTask?: {
@@ -56,7 +60,17 @@ export declare abstract class WorkThreadEngineBase {
         workName: EmitEventType;
         workState: EventWorkState;
     };
-    protected delayPostDoneResolve?: (bol: boolean) => void;
+    protected delayPostDoneWaiter?: {
+        promise: Promise<void>;
+        resolve: () => void;
+        reject: (error: unknown) => void;
+        reportFailureAtRendererBoundary: boolean;
+    };
+    private activePostDoneWaiter?;
+    private isCombiningPost;
+    private combinePostTaskSequence;
+    private activeCombinePostTaskId?;
+    private combinePostTransfersByTask;
     protected cacheImages: Map<string, {
         imageBitmap: ImageBitmap;
         workId: string;
@@ -64,22 +78,32 @@ export declare abstract class WorkThreadEngineBase {
     protected imageResolveMap: Map<string, {
         timer?: number;
         resolve?: (src: string) => void;
+        requestId?: string;
+        promise: Promise<string>;
     }>;
     protected taskUpdateCameraId?: number;
     protected taskUpdateCameraResolve?: (shouldRetry: boolean) => void;
     protected debounceUpdateCameraId?: number;
+    private activeCameraSettledRender?;
+    private activeCameraTaskContext?;
+    private destroyed;
+    private contextLossCleanup?;
     constructor(viewId: string, opt: IWorkerInitOption, workerType: EWorkThreadType);
+    getActualContextType(): ECanvasContextType | undefined;
+    private registerContextLossListener;
+    private removeContextLossListener;
     protected createRenderLayer(scene: Scene, opt: IWorkerInitOption): void;
     updateDpr(dpr: number): Promise<void>;
     getCachedImages(imageSrc: string): ImageBitmap | undefined;
     getCachedImagesByWorkId(workId: string): ImageBitmap | undefined;
     deleteCachedImagesByWorkId(workId: string, filter?: string): void;
     clearCacheImages(): void;
+    private closeImageBitmap;
     clearImageResolveMap(): void;
     setIsSafari(isSafari: boolean): void;
     on(msg: IWorkerMessage): Promise<void>;
     private getIconSize;
-    loadImageBitMap(msg: Pick<IWorkerMessage, "toolsType" | "opt" | "workId" | "isSubWorker">): Promise<ImageBitmap | undefined>;
+    loadImageBitMap(msg: Pick<IWorkerMessage, "toolsType" | "opt" | "workId" | "isSubWorker" | "requestId">): Promise<ImageBitmap | undefined>;
     protected createLocalWork(data: IWorkerMessage): void;
     protected updateScene(scene: Scene, offscreenCanvasOpt: IOffscreenCanvasOptionType, targetLayer?: Group): void;
     protected updateLayer(layerOpt: ILayerOptionType, targetLayer?: Group): void;
@@ -90,16 +114,37 @@ export declare abstract class WorkThreadEngineBase {
     protected setToolsOpt(opt: IActiveToolsDataType): void;
     protected setWorkOpt(opt: Partial<IActiveWorkDataType>): void;
     protected destroy(): void;
-    post(msg: IBatchMainMessage): Promise<void>;
+    protected cancelCameraSettledRender(): void;
+    protected retargetCameraSettledRender(cameraTaskId?: number): boolean;
+    protected hasCameraSettledRender(): boolean;
+    protected cancelCameraBlockingWait(): void;
+    protected startCameraSettledRender(cameraTaskId?: number, context?: CameraUpdateTaskContext): {
+        isActive: () => boolean;
+        getCameraTaskId: () => number | undefined;
+        setRenderLayers: (layers?: Layer[]) => void;
+        finish: () => void;
+    };
+    post(msg: IBatchMainMessage, options?: {
+        reportFailureAtRendererBoundary?: boolean;
+    }): Promise<void>;
+    private getOrCreatePostDoneWaiter;
     private runBatchPostData;
+    waitForRendererBusiness<T>(task: PromiseLike<T>, options: RendererBusinessTaskOptions): Promise<T>;
+    reportRendererBusinessError(error: unknown, fallback: Pick<RendererBusinessTaskOptions, "business" | "stage">, runtimeFatal?: boolean): void;
+    protected isCombinePostTaskActive(taskId: number): boolean;
+    protected trackCombinePostTransfer(taskId: number, transfer: Transferable): boolean;
+    protected commitCombinePostTransfers(taskId: number): void;
+    private releaseCombinePostTransfers;
+    protected closeCombinePostTransfers(transfers?: Transferable[]): void;
+    protected transferLayerToImageBitmap(drawCanvas: ECanvasShowType): ImageBitmap;
     protected combinePostData(): IBatchMainMessage;
     getSceneRect(): IRectType;
-    abstract combinePost(): Promise<void>;
+    abstract combinePost(taskId: number): Promise<void>;
     protected abstract getLayer(workLayer: ECanvasShowType): Group | undefined;
     abstract setCameraOpt(cameraOpt: ICameraOpt): void;
     abstract consumeDraw(type: EDataType, data: IWorkerMessage): Promise<void>;
     abstract consumeDrawAll(type: EDataType, data: IWorkerMessage): Promise<void>;
-    abstract updateCamera(msg: IWorkerMessage): Promise<void>;
+    abstract updateCamera(msg: IWorkerMessage, context?: CameraUpdateTaskContext): Promise<void>;
 }
 export declare abstract class LocalWork {
     readonly viewId: string;

package/dist/core/worker/fullWorkerLocal.d.ts

@@ -12,10 +12,14 @@ export declare class LocalWorkForFullWorker extends LocalWork {
     protected combineTimerId?: number;
     protected combineDrawResolve?: (value: boolean) => void;
     protected combineDrawActiveId?: string;
+    private disposeVNodeRevisionObserver?;
+    private bitmapEraserRenderQueue;
+    private bitmapEraserRevalidationQueued;
     protected drawWorkActiveId?: string;
     protected effectSelectNodeData: Set<IWorkerMessage>;
     constructor(opt: ISubWorkerInitOption);
-    loadImageBitMap(msg: Pick<IWorkerMessage, "toolsType" | "opt" | "workId" | "isSubWorker">): Promise<ImageBitmap | undefined>;
+    private scheduleActiveBitmapEraserRevalidation;
+    loadImageBitMap(msg: Pick<IWorkerMessage, "toolsType" | "opt" | "workId" | "isSubWorker" | "requestId">): Promise<ImageBitmap | undefined>;
     consumeDraw(data: IWorkerMessage, serviceWork: ServiceWorkForFullWorker): Promise<void>;
     consumeDrawAll(data: IWorkerMessage, serviceWork: ServiceWorkForFullWorker): Promise<void>;
     workShapesDone(scenePath: string, serviceWork: ServiceWorkForFullWorker): Promise<void>;
@@ -50,7 +54,9 @@ export declare class LocalWorkForFullWorker extends LocalWork {
     reRenderSelector(willSyncService?: boolean): Promise<void>;
     updateFullSelectWork(data: IWorkerMessage): Promise<void>;
     destroy(): void;
-    protected drawEraserCombine(workId: string, drawCount: number, needUndoTicker?: number, collectUndoTicker?: number): Promise<void>;
+    protected enqueueBitmapEraserRender(workId: string, drawCount?: number, needUndoTicker?: number, collectUndoTicker?: number, ack?: Pick<IBatchMainMessage, "consumeCount" | "consumeWorkId">): Promise<void>;
+    protected drawPencilEraserCombine(workId: string, drawCount: number, needUndoTicker?: number, collectUndoTicker?: number): Promise<void>;
+    protected postEraserBatch(workId: string, drawCount: number, needUndoTicker?: number, collectUndoTicker?: number, ack?: Pick<IBatchMainMessage, "consumeCount" | "consumeWorkId">): Promise<void>;
     protected drawPencilCombine(workId: string, drawCount: number): Promise<void>;
     protected drawSelector(res: IMainMessage, workState: EventWorkState, isLockSentEventCursor?: boolean): Promise<void>;
     protected drawPencilFull(res: IMainMessage, isLockSentEventCursor?: boolean, needUndoTicker?: number, toolsType?: EToolsKey): Promise<void>;

package/dist/core/worker/fullWorkerService.d.ts

@@ -21,6 +21,8 @@ export interface ServiceWork {
     runSelectWork(data: IWorkerMessage): void;
     consumeFull(data: IWorkerMessage): void;
     consumeDraw(data: IWorkerMessage): void;
+    flush(): Promise<void>;
+    clearAll(): void;
     destroy(): void;
 }
 export declare class ServiceWorkForFullWorker implements ServiceWork {
@@ -31,14 +33,15 @@ export declare class ServiceWorkForFullWorker implements ServiceWork {
     workShapes: Map<string, IServiceWorkItem>;
     selectorWorkShapes: Map<string, IServiceWorkItem>;
     thread: WorkThreadEngineForFullWorker;
-    protected animationId?: number | undefined;
     protected willRunEffectSelectorIds: Set<string>;
-    protected runEffectId?: number | undefined;
     protected noAnimationRect: IRectType | undefined;
     protected syncUnitTime: number;
     post: (msg: IBatchMainMessage) => Promise<void>;
+    private readonly animationScheduler;
+    private readonly effectScheduler;
     constructor(opt: ISubWorkerInitOption);
     destroy(): void;
+    clearAll(): void;
     consumeDraw(data: IWorkerMessage): Promise<void>;
     consumeFull(data: IWorkerMessage): void;
     runSelectWork(data: IWorkerMessage): void;
@@ -50,9 +53,10 @@ export declare class ServiceWorkForFullWorker implements ServiceWork {
     private activeWorkShape;
     private hasDiffData;
     protected animationDraw(): Promise<void>;
-    protected runAnimation(): void;
+    protected runAnimation(immediate?: boolean): void;
     protected computNextAnimationIndex(workShape: IServiceWorkItem, pointUnit: number): number;
     protected runEffect(): void;
     private effectRunSelector;
+    flush(): Promise<void>;
     private activeSelectorShape;
 }

package/dist/core/worker/renderCapabilityProbe.d.ts

@@ -0,0 +1,54 @@
+import { probeLayerRendering, probeLayerRenderingWithImageBitmap, type LayerRenderingProbePixelCheck, type LayerRenderingProbeResult } from "spritejs";
+import type { ECanvasContextType } from "../enum";
+export type WebGLProgramProbeResult = LayerRenderingProbeResult & {
+    /** Retained for compatibility with the former raw WebGL probe result. */
+    shaderInfoLog?: string;
+    /** Main-thread verification after the Worker ImageBitmap is drawn. */
+    destinationPixelChecks?: LayerRenderingProbePixelCheck[];
+};
+export type WebGLProgramProbeStage = LayerRenderingProbeResult["stage"];
+export type WorkerRenderCapabilities = {
+    offscreenCanvas: boolean;
+    offscreen2d: boolean;
+    webgl2: boolean;
+    webgl: boolean;
+    contextSupported: boolean;
+    /** Kept for compatibility; now contains the real SpriteJS Layer probe result. */
+    programProbe?: WebGLProgramProbeResult;
+};
+export type RenderProbeProfile = {
+    width: number;
+    height: number;
+    dpr: number;
+    testRect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+};
+export type WebGLRuntimeDiagnostics = {
+    contextLost?: boolean;
+    glError?: number;
+    currentProgram?: boolean;
+    programLinked?: boolean;
+    programHasUniforms?: boolean;
+};
+type LayerProbe = typeof probeLayerRendering;
+type ImageBitmapLayerProbe = typeof probeLayerRenderingWithImageBitmap;
+export type RenderLayerRuntime = {
+    gl?: WebGLRenderingContext | WebGL2RenderingContext | null;
+    renderer?: {
+        glRenderer?: unknown;
+        isWebGL2?: boolean;
+    };
+    canvas?: EventTarget;
+};
+export declare function resolveWorkerRenderContextType(canUseWebGL: boolean, requestedContextType?: ECanvasContextType): ECanvasContextType;
+export declare function inspectWebGLRuntime(gl: WebGLRenderingContext | WebGL2RenderingContext | null | undefined): WebGLRuntimeDiagnostics;
+export declare function getActualLayerContextType(layer: RenderLayerRuntime | null | undefined): ECanvasContextType | undefined;
+export declare function listenForRenderContextLoss(layer: RenderLayerRuntime | null | undefined, onContextLoss: (diagnostics: WebGLRuntimeDiagnostics, event: Event) => void): () => void;
+export declare function probeWorkerRenderCapabilities(requestedContextType: ECanvasContextType | undefined, transferredCanvas?: OffscreenCanvas, profile?: RenderProbeProfile, runLayerProbe?: LayerProbe): WorkerRenderCapabilities;
+export declare function probeWorkerImageBitmapRenderCapabilities(requestedContextType: ECanvasContextType | undefined, profile?: RenderProbeProfile, runLayerProbe?: ImageBitmapLayerProbe): Promise<WorkerRenderCapabilities>;
+export declare function releaseWorkerRenderCapabilities(capabilities: WorkerRenderCapabilities | undefined): boolean;
+export {};

package/dist/core/worker/simpleWorker.d.ts

@@ -1,4 +1,4 @@
-import { EventWorkState, IActiveToolsDataType, IMainMessage, IMainMessageRenderData, IWorkerMessage } from "../index";
+import { EventWorkState, IActiveToolsDataType, IBatchMainMessage, IMainMessage, IMainMessageRenderData, IWorkerMessage } from "../index";
 import { ISubWorkerInitOption } from "./base";
 import { LocalWorkForFullWorker } from "./fullWorkerLocal";
 import { ServiceWorkForFullWorker } from "./fullWorkerService";
@@ -16,7 +16,7 @@ export declare class LocalWorkForSimpleWorker extends LocalWorkForFullWorker {
     protected drawPencil(res: IMainMessage, workId?: string): Promise<void>;
     protected drawShape(res: IMainMessage): Promise<void>;
     protected drawSelector(res: IMainMessage, workState: EventWorkState, isLockSentEventCursor?: boolean, render?: IMainMessageRenderData[]): Promise<void>;
-    protected drawEraserCombine(workId: string): Promise<void>;
+    protected postEraserBatch(workId: string, _drawCount: number, _needUndoTicker?: number, _collectUndoTicker?: number, ack?: Pick<IBatchMainMessage, "consumeCount" | "consumeWorkId">): Promise<void>;
     consumeDraw(data: IWorkerMessage, serviceWork: ServiceWorkForFullWorker): Promise<void>;
     consumeDrawAll(data: IWorkerMessage, serviceWork: ServiceWorkForFullWorker): Promise<void>;
 }

package/dist/core/worker/snapshotWork.d.ts

@@ -12,6 +12,7 @@ export declare class SnapshotWork extends LocalWork {
     protected cameraOpt: ICameraOpt | undefined;
     vNodes?: VNodeManager;
     constructor(opt: ISnapshotWorkInitOption);
+    private reportRequestFailure;
     createSnapshotFullLayer(sceneOpt: IWorkerInitOption, opt: ILayerOptionType): void;
     destroySnapshotFullLayer(): void;
     private updateScene;

package/dist/core/worker/workerManager.d.ts

@@ -9,10 +9,12 @@ import { LocalWorkForSubWorker } from "./subWorkerLocal";
 import { TopLayerWorkForSubWorker } from "./subWorkerTopLayer";
 import { LocalWorkForSimpleWorker, ServiceWorkForSimpleWorker } from "./simpleWorker";
 import { SnapshotWork } from "./snapshotWork";
+import type { CameraUpdateTaskContext } from "../cameraTask";
 export declare enum EWorkThreadType {
     Full = "full",
     Sub = "sub"
 }
+export declare function prepareImageBitmapRenderData(render: IMainMessageRenderData[], scene: Scene, dpr: number): IMainMessageRenderData[];
 export type WorkerEngineFactory<T extends WorkThreadEngineBase> = (value: IWorkerMessage, post: (msg: IBatchMainMessage, transfer?: Transferable[]) => void) => T | undefined;
 export declare class WorkerManager<T extends WorkThreadEngineBase> {
     readonly _self: Worker;
@@ -22,10 +24,19 @@ export declare class WorkerManager<T extends WorkThreadEngineBase> {
     protected workThreadMap: Map<string, T>;
     private cameraRenderQueueByView;
     private viewGenerationById;
+    private retainedOffscreenProbeCapabilities?;
+    private readonly cancelledFontFaceRequests;
+    private readonly fontFaceRequestCancelers;
     constructor(worker: Worker, type: EWorkThreadType, createEngine: WorkerEngineFactory<T>);
+    private consumeRendererBusinessFailure;
     private enqueueViewTask;
+    private isStaleViewMessage;
     private init;
     private getFontFaceCssValue;
+    private isFontFaceRequestCancelled;
+    private cancelFontFaceRequest;
+    private clearFontFaceRequestCancellation;
+    private waitForFontFacePromise;
     private setFontFaces;
     private isFontAvailable;
     private areFontFacesAvailable;
@@ -41,8 +52,9 @@ export declare class WorkThreadEngineForSubWorker extends WorkThreadEngineBase {
     localWork: LocalWorkForSubWorker;
     topLayerWork?: TopLayerWorkForSubWorker;
     snapshotWork: SnapshotWork;
+    private fullLayerFrameSequence;
     constructor(viewId: string, opt: IWorkerInitOption, _post: (msg: IBatchMainMessage, transfer?: Transferable[]) => void);
-    combinePost(): Promise<void>;
+    combinePost(taskId: number): Promise<void>;
     on(msg: IWorkerMessage): Promise<void>;
     protected createLocalWork(data: IWorkerMessage): void;
     removeNode(data: IWorkerMessage): Promise<void>;
@@ -54,7 +66,7 @@ export declare class WorkThreadEngineForSubWorker extends WorkThreadEngineBase {
     private getRectImageBitmap;
     protected updateLayer(layerOpt: ILayerOptionType): void;
     updateDpr(dpr: number): Promise<void>;
-    updateCamera(msg: IWorkerMessage): Promise<void>;
+    updateCamera(msg: IWorkerMessage, context?: CameraUpdateTaskContext): Promise<void>;
     setCameraOpt(cameraOpt: ICameraOpt, layer?: Group): void;
 }
 /** full worker */
@@ -67,8 +79,9 @@ export declare class WorkThreadEngineForFullWorker extends WorkThreadEngineBase
     serviceWork: ServiceWorkForFullWorker;
     _post: (msg: IBatchMainMessage, transfer?: Transferable[] | undefined) => void;
     private debounceUpdateCache;
+    private fullLayerFrameSequence;
     constructor(viewId: string, opt: IWorkerInitOption, _post: (msg: IBatchMainMessage, transfer?: Transferable[]) => void);
-    combinePost(): Promise<void>;
+    combinePost(taskId: number): Promise<void>;
     on(msg: IWorkerMessage): Promise<void>;
     removeNode(data: IWorkerMessage): Promise<void>;
     checkTextActive(data: IWorkerMessage): Promise<void>;
@@ -81,7 +94,7 @@ export declare class WorkThreadEngineForFullWorker extends WorkThreadEngineBase
     consumeDraw(type: EDataType, data: IWorkerMessage): Promise<void>;
     consumeDrawAll(type: EDataType, data: IWorkerMessage): Promise<void>;
     updateDpr(dpr: number): Promise<void>;
-    updateCamera(msg: IWorkerMessage): Promise<void>;
+    updateCamera(msg: IWorkerMessage, context?: CameraUpdateTaskContext): Promise<void>;
     protected getRectImageBitmap(renderData: Required<Pick<IMainMessageRenderData, "rect" | "drawCanvas">>): Promise<ImageBitmap>;
     private cursorHover;
     private cursorBlur;

package/dist/displayer/floatBar/selectorGesture.d.ts

@@ -0,0 +1,2 @@
+import type { ApplianceViewManagerLike } from "../../plugin/types";
+export declare function canAcceptSelectorGesture(mananger?: ApplianceViewManagerLike): mananger is ApplianceViewManagerLike;