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

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

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;

package/dist/plugin/renderImageBitmapRetirement.d.ts

@@ -0,0 +1,100 @@
+export declare const RenderImageBitmapRetireTimeoutMs = 5000;
+export declare const RenderImageBitmapMemoryPressureBytes: number;
+export declare const RenderImageBitmapMemoryPressureCount = 128;
+export declare const RenderImageBitmapMemoryPressureReportIntervalMs = 5000;
+type TimerHandle = ReturnType<typeof setTimeout>;
+export type RenderImageBitmapRetirementScheduler = {
+    requestFrame: (callback: FrameRequestCallback) => number;
+    cancelFrame: (handle: number) => void;
+    setTimer: (callback: () => void, timeoutMs: number) => TimerHandle;
+    clearTimer: (handle: TimerHandle) => void;
+    now: () => number;
+};
+export type RenderImageBitmapRetirementOptions = {
+    timeoutMs?: number;
+    memoryPressureBytes?: number;
+    memoryPressureCount?: number;
+    memoryPressureReportIntervalMs?: number;
+    scheduler?: Partial<RenderImageBitmapRetirementScheduler>;
+    onCloseError?: (viewId: string, error: unknown, snapshot: RenderImageBitmapMemorySnapshot) => void;
+    onScheduleError?: (stage: "request-frame" | "set-watchdog", error: unknown, snapshot: RenderImageBitmapMemorySnapshot) => void;
+    onTimeout?: (event: RenderImageBitmapTimeoutEvent) => void;
+    onMemoryPressure?: (snapshot: RenderImageBitmapMemorySnapshot) => void;
+};
+export type RenderImageBitmapMemoryViewSnapshot = Readonly<{
+    viewId: string;
+    activeCount: number;
+    estimatedBytes: number;
+    oldestAgeMs: number;
+}>;
+/**
+ * Tracks ImageBitmap ownership, not browser heap or exact GPU allocation.
+ * estimatedBytes uses width * height * 4 as a stable pressure signal.
+ */
+export type RenderImageBitmapMemorySnapshot = Readonly<{
+    activeCount: number;
+    estimatedBytes: number;
+    peakActiveCount: number;
+    peakEstimatedBytes: number;
+    totalRetiredCount: number;
+    totalReleasedCount: number;
+    watchdogReleasedCount: number;
+    closeErrorCount: number;
+    oldestAgeMs: number;
+    activeViews: ReadonlyArray<RenderImageBitmapMemoryViewSnapshot>;
+    destroyed: boolean;
+}>;
+export type RenderImageBitmapTimeoutEvent = Readonly<{
+    viewIds: ReadonlySet<string>;
+    releasedCount: number;
+    releasedEstimatedBytes: number;
+    oldestAgeMs: number;
+    snapshot: RenderImageBitmapMemorySnapshot;
+}>;
+export declare function getRenderImageBitmapDestroyLogLevel(beforeDestroy: RenderImageBitmapMemorySnapshot, afterDestroy: RenderImageBitmapMemorySnapshot): "error" | "info" | undefined;
+/**
+ * Keeps transferred render bitmaps alive across one browser paint opportunity.
+ * The first RAF promotes a bitmap to awaitingPaint; the second RAF releases it.
+ */
+export declare class RenderImageBitmapRetirementQueue {
+    private pending;
+    private awaitingPaint;
+    private readonly entries;
+    private readonly timeoutMs;
+    private readonly memoryPressureBytes;
+    private readonly memoryPressureCount;
+    private readonly memoryPressureReportIntervalMs;
+    private readonly scheduler;
+    private readonly onCloseError?;
+    private readonly onScheduleError?;
+    private readonly onTimeout?;
+    private readonly onMemoryPressure?;
+    private activeEstimatedBytes;
+    private peakActiveCount;
+    private peakEstimatedBytes;
+    private totalRetiredCount;
+    private totalReleasedCount;
+    private watchdogReleasedCount;
+    private closeErrorCount;
+    private lastMemoryPressureReportAt;
+    private frameHandle?;
+    private watchdogHandle?;
+    private destroyed;
+    constructor(options?: RenderImageBitmapRetirementOptions);
+    retire(viewId: string, bitmap: ImageBitmap): void;
+    getMemorySnapshot(): RenderImageBitmapMemorySnapshot;
+    closeNow(viewId: string, bitmap: ImageBitmap): void;
+    releaseView(viewId: string): void;
+    destroy(): RenderImageBitmapMemorySnapshot;
+    private ensureFrame;
+    private readonly onFrame;
+    private ensureWatchdog;
+    private readonly onWatchdog;
+    private releaseEntry;
+    private closeBitmap;
+    private estimateBitmapBytes;
+    private reportMemoryPressure;
+    private stopSchedulersWhenEmpty;
+    private cancelSchedulers;
+}
+export {};

package/dist/plugin/renderRuntimeCache.d.ts

@@ -0,0 +1,18 @@
+import { type CompactRenderModel } from "./renderingCompatibility";
+export declare const RenderModeCacheDatabaseName = "__APPLIANCE_PLUGIN_RENDER_MODE_DB";
+export declare const RenderModeCacheStoreName = "renderModes";
+export type CachedRenderRuntimeReadResult = {
+    renderModel?: CompactRenderModel;
+    readFailed?: boolean;
+    reason?: string;
+};
+type IDBFactoryLike = Pick<IDBFactory, "open"> & Partial<Pick<IDBFactory, "deleteDatabase">>;
+export type RenderRuntimeCacheDeadlineOptions = {
+    timeoutMs?: number;
+};
+export declare function createRenderRuntimeCacheKey(userAgent: string): string;
+export declare function readCachedRenderRuntimeDecisionWithStatus(key: string, factory?: IDBFactoryLike | undefined, options?: RenderRuntimeCacheDeadlineOptions): Promise<CachedRenderRuntimeReadResult>;
+export declare function readCachedRenderRuntimeDecision(key: string, factory?: IDBFactoryLike | undefined, options?: RenderRuntimeCacheDeadlineOptions): Promise<CompactRenderModel | undefined>;
+export declare function writeCachedRenderRuntimeDecision(key: string, renderModel: CompactRenderModel, factory?: IDBFactoryLike | undefined, options?: RenderRuntimeCacheDeadlineOptions): Promise<boolean>;
+export declare function deleteCachedRenderRuntimeDecision(key: string, factory?: IDBFactoryLike | undefined, options?: RenderRuntimeCacheDeadlineOptions): Promise<boolean>;
+export {};