@netless/window-manager 1.0.13-test.9 → 1.0.13

package/src/Utils/log.ts

@@ -1,5 +1,30 @@
+import type { Logger } from "white-web-sdk";
+import { isShallowMergeAttributesRecord, stringifyForAttributesLog } from "./attributesLogStringify";
 import { WindowManager } from "../index";
 
+/** ArgusLog 经 `logger.info` 上报的单条字符串上限（含前缀） */
+const ARGUS_LOG_INFO_MAX_LENGTH = 1500;
+
+function truncateArgusLogInfoMessage(message: string): string {
+    if (message.length <= ARGUS_LOG_INFO_MAX_LENGTH) {
+        return message;
+    }
+    const ellipsis = "…";
+    return message.slice(0, ARGUS_LOG_INFO_MAX_LENGTH - ellipsis.length) + ellipsis;
+}
+
+function keysPathEqual(a: string[], b: string[]): boolean {
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
 export const log = (...args: any[]): void => {
     if (WindowManager.debug) {
         console.log(`[WindowManager]:`, ...args);
@@ -41,4 +66,207 @@ export class LocalConsole {
         }
         console.log(`[window-manager][${this.name}]: ${args.join(", ")}`);
     }
+
+    /**
+     * 销毁：清除 debounce 定时器与未输出的暂存参数。
+     * 持有 LocalConsole 的类在销毁时应调用。
+     */
+    destroy(): void {
+        if (this.flushTimer != null) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        this.pendingArgs = null;
+    }
+}
+
+/**
+ * 按 `[WindowManager][tagName]` 前缀输出。
+ * 若传入 `debounceTime`（毫秒）：窗口内多次 `log` 不立即输出，只在连续停止调用满 `debounceTime` 后输出**最后一次**的参数（尾部 debounce）。
+ */
+export class ArgusLog {
+    private pendingArgs: unknown[] | null = null;
+    private flushTimer: ReturnType<typeof setTimeout> | null = null;
+
+    /** debounce 窗口内按一层 key 合并；同 key 后者覆盖；非普通对象则整段待输出被本次值替换 */
+    private pendingShallowMerge:
+        | { kind: "record"; label: string; data: Record<string, unknown> }
+        | { kind: "atom"; label: string; value: unknown }
+        | null = null;
+    private shallowMergeTimer: ReturnType<typeof setTimeout> | null = null;
+
+    /** debounce 窗口内 safeUpdateAttributes：同 keys 数组则只更新 value，否则追加一段，flush 时拼成一条 */
+    private pendingUpdateSegments: { keys: string[]; value: unknown }[] | null = null;
+    private updateMergeTimer: ReturnType<typeof setTimeout> | null = null;
+
+    constructor(
+        private readonly logger: Logger,
+        private readonly name: string,
+        private readonly debounceTime?: number,
+    ) {}
+
+    private emitInfo(message: string): void {
+        this.logger.info(truncateArgusLogInfoMessage(message));
+    }
+
+    private flush(): void {
+        this.flushTimer = null;
+        const args = this.pendingArgs;
+        this.pendingArgs = null;
+        if (args === null) {
+            return;
+        }
+        this.emitInfo(`[WindowManager][${this.name}]: ${args.join(", ")}`);
+    }
+
+    private flushShallowMerge(): void {
+        this.shallowMergeTimer = null;
+        const p = this.pendingShallowMerge;
+        this.pendingShallowMerge = null;
+        if (p === null) {
+            return;
+        }
+        const body =
+            p.kind === "record" ? stringifyForAttributesLog(p.data) : stringifyForAttributesLog(p.value);
+        this.emitInfo(`[WindowManager][${this.name}]: ${p.label} ${body}`);
+        // 输出后释放合并对象引用，避免长时间持有 attributes 快照
+        if (p.kind === "record") {
+            for (const k of Object.keys(p.data)) {
+                delete p.data[k];
+            }
+        }
+    }
+
+    log(...args: unknown[]): void {
+        const ms = this.debounceTime;
+        if (ms != null && ms > 0) {
+            this.pendingArgs = args;
+            if (this.flushTimer != null) {
+                clearTimeout(this.flushTimer);
+            }
+            this.flushTimer = setTimeout(() => this.flush(), ms);
+            return;
+        }
+        this.emitInfo(`[WindowManager][${this.name}]: ${args.join(", ")}`);
+    }
+
+    /**
+     * 带 debounce 时：窗口内多次调用会把「一层 key」合并进同一条日志（不同 key 并存，同 key 取最后一次）。
+     * `payload` 为普通对象时做浅合并；否则视为原子值，覆盖当前待合并状态（丢弃此前累积的对象 key）。
+     * 无 debounce 或时间为 0 时立即输出。
+     */
+    logDebouncedShallowMerge(label: string, payload: unknown): void {
+        const ms = this.debounceTime;
+        const debounced = ms != null && ms > 0;
+
+        const emit = (text: string): void => {
+            this.emitInfo(`[WindowManager][${this.name}]: ${label} ${text}`);
+        };
+
+        if (!debounced) {
+            emit(stringifyForAttributesLog(payload));
+            return;
+        }
+
+        if (this.shallowMergeTimer != null) {
+            clearTimeout(this.shallowMergeTimer);
+            this.shallowMergeTimer = null;
+        }
+
+        if (isShallowMergeAttributesRecord(payload)) {
+            if (this.pendingShallowMerge?.kind === "record") {
+                this.pendingShallowMerge = {
+                    kind: "record",
+                    label,
+                    data: { ...this.pendingShallowMerge.data, ...payload },
+                };
+            } else {
+                this.pendingShallowMerge = { kind: "record", label, data: { ...payload } };
+            }
+        } else {
+            this.pendingShallowMerge = { kind: "atom", label, value: payload };
+        }
+
+        this.shallowMergeTimer = setTimeout(() => this.flushShallowMerge(), ms);
+    }
+
+    private flushUpdateAttributesMerge(): void {
+        this.updateMergeTimer = null;
+        const segments = this.pendingUpdateSegments;
+        this.pendingUpdateSegments = null;
+        if (segments === null || segments.length === 0) {
+            return;
+        }
+        const parts = segments.map(
+            (s) => `${s.keys.join(", ")} ${stringifyForAttributesLog(s.value)}`,
+        );
+        this.emitInfo(`[WindowManager][${this.name}]: safeUpdateAttributes ${parts.join(" | ")}`);
+        for (const s of segments) {
+            s.keys.length = 0;
+            s.value = undefined;
+        }
+        segments.length = 0;
+    }
+
+    /**
+     * 带 debounce 时：连续调用若 `keys` 与上一段完全相同则覆盖该段的 `value`；否则追加一段。
+     * flush 时输出一条日志，多段用 ` | ` 连接。
+     */
+    logDebouncedUpdateAttributes(keys: string[], value: unknown): void {
+        const ms = this.debounceTime;
+        const debounced = ms != null && ms > 0;
+        const keysCopy = [...keys];
+
+        if (!debounced) {
+            this.emitInfo(
+                `[WindowManager][${this.name}]: safeUpdateAttributes ${keysCopy.join(", ")} ${stringifyForAttributesLog(value)}`,
+            );
+            return;
+        }
+
+        if (this.updateMergeTimer != null) {
+            clearTimeout(this.updateMergeTimer);
+            this.updateMergeTimer = null;
+        }
+
+        if (this.pendingUpdateSegments === null || this.pendingUpdateSegments.length === 0) {
+            this.pendingUpdateSegments = [{ keys: keysCopy, value }];
+        } else {
+            const last = this.pendingUpdateSegments[this.pendingUpdateSegments.length - 1];
+            if (keysPathEqual(last.keys, keysCopy)) {
+                last.value = value;
+            } else {
+                this.pendingUpdateSegments.push({ keys: keysCopy, value });
+            }
+        }
+
+        this.updateMergeTimer = setTimeout(() => this.flushUpdateAttributesMerge(), ms);
+    }
+
+    /**
+     * 销毁：清除所有 `setTimeout` debounce 定时器，并丢弃尚未输出的暂存日志（不补打日志）。
+     * WindowManager 销毁时应调用，避免泄漏与销毁后仍触发 `logger.info`。
+     */
+    destroy(): void {
+        if (this.flushTimer != null) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        if (this.shallowMergeTimer != null) {
+            clearTimeout(this.shallowMergeTimer);
+            this.shallowMergeTimer = null;
+        }
+        if (this.updateMergeTimer != null) {
+            clearTimeout(this.updateMergeTimer);
+            this.updateMergeTimer = null;
+        }
+        this.pendingArgs = null;
+        this.pendingShallowMerge = null;
+        this.pendingUpdateSegments = null;
+    }
+
+    /** 与 `destroy()` 相同，保留旧名以兼容 */
+    dispose(): void {
+        this.destroy();
+    }
 }

package/src/View/MainView.ts

@@ -3,7 +3,7 @@ import { callbacks } from "../callback";
 import { createView } from "./ViewManager";
 import { debounce, get, isEmpty, isEqual } from "lodash";
 import { internalEmitter } from "../InternalEmitter";
-import { Fields } from "../AttributesDelegate";
+import { Fields, type MainViewCamera } from "../AttributesDelegate";
 import { setViewFocusScenePath } from "../Utils/Common";
 import { SideEffectManager } from "side-effect-manager";
 import type { Camera, Room, Size, View } from "white-web-sdk";
@@ -11,7 +11,14 @@ import type { AppManager } from "../AppManager";
 import { Events } from "../constants";
 import { LocalConsole } from "../Utils/log";
 
-(window as any).___local_log = (window as any).___local_log || new Set();
+type MainViewScreenLike = {
+    refreshSize?: (width: number, height: number) => void;
+    resizeObserver?: {
+        disconnect?: () => void;
+        observe?: (target: Element) => void;
+    };
+};
+
 export class MainViewProxy {
     /** Refresh the view's camera in an interval of 1.5s. */
     public polling = false;
@@ -19,13 +26,19 @@ export class MainViewProxy {
     private scale?: number;
     private started = false;
     private mainViewIsAddListener = false;
+    private isForcingMainViewDivElement = false;
+    private wrapperRectWorkaroundFrame = 0;
+    private pendingWrapperRectChange?: { width: number; height: number; origin?: string };
     private mainView: View;
     private store = this.manager.store;
     private viewMode = this.manager.windowManger.viewMode;
 
     private sideEffectManager = new SideEffectManager();
 
-    private playgroundSizeChangeListenerLocalConsole = new LocalConsole("playgroundSizeChangeListener", 30);
+    private playgroundSizeChangeListenerLocalConsole = new LocalConsole("playgroundSizeChangeListener", 100);
+    private sizeUpdatedLocalConsole = new LocalConsole("sizeUpdated", 100);
+    private cameraUpdatedLocalConsole = new LocalConsole("cameraUpdated", 100);
+    private cameraReactionLocalConsole = new LocalConsole("cameraReaction", 100);
 
     constructor(private manager: AppManager) {
         this.mainView = this.createMainView();
@@ -54,6 +67,9 @@ export class MainViewProxy {
         this.sideEffectManager.add(() => {
             return internalEmitter.on("containerSizeRatioUpdate", this.onUpdateContainerSizeRatio);
         });
+        this.sideEffectManager.add(() => {
+            return internalEmitter.on("wrapperRectChange", this.onWrapperRectChange);
+        });
         this.sideEffectManager.add(() => {
             return internalEmitter.on("startReconnect", () => {
                 if (!this.didRelease) {
@@ -109,14 +125,105 @@ export class MainViewProxy {
         this.moveCamera(this.mainViewCamera);
     }
 
+    private onWrapperRectChange = (payload: { width: number; height: number; origin?: string }) => {
+        this.pendingWrapperRectChange = payload;
+        if (this.wrapperRectWorkaroundFrame) {
+            cancelAnimationFrame(this.wrapperRectWorkaroundFrame);
+        }
+        this.wrapperRectWorkaroundFrame = requestAnimationFrame(this.runWrapperRectWorkaround);
+    };
+
+    private runWrapperRectWorkaround = () => {
+        this.wrapperRectWorkaroundFrame = 0;
+        const payload = this.pendingWrapperRectChange;
+        const element = this.mainView.divElement;
+        this.pendingWrapperRectChange = undefined;
+        if (!payload || !element) return;
+
+        const rect = element.getBoundingClientRect();
+        const observedSize = { width: rect.width, height: rect.height };
+        const wrapperMatchesDom =
+            Math.abs(payload.width - observedSize.width) <= 0.5 &&
+            Math.abs(payload.height - observedSize.height) <= 0.5;
+        const viewIsStale =
+            Math.abs(this.mainView.size.width - observedSize.width) > 0.5 ||
+            Math.abs(this.mainView.size.height - observedSize.height) > 0.5;
+
+        if (wrapperMatchesDom && viewIsStale) {
+            this.forceSyncMainViewDivElement(
+                `wrapperRectChange:${payload.origin || "unknown"}`,
+                observedSize,
+                element
+            );
+        }
+    };
+
+    private forceSyncMainViewDivElement(
+        reason: string,
+        observedSize: Pick<Size, "width" | "height">,
+        element: HTMLDivElement
+    ) {
+        const { width: viewWidth, height: viewHeight } = this.mainView.size;
+        let targetElement = element;
+        if (
+            Math.abs(viewWidth - observedSize.width) <= 0.5 &&
+            Math.abs(viewHeight - observedSize.height) <= 0.5
+        ) {
+            return;
+        }
+        if (this.isForcingMainViewDivElement) {
+            console.log("[window-manager] skipForceSyncMainViewDivElement " + JSON.stringify({
+                reason,
+                observedSize,
+                viewSize: this.mainView.size,
+            }));
+            return;
+        }
+        this.isForcingMainViewDivElement = true;
+        try {
+            const mainView = this.mainView as View & { screen?: MainViewScreenLike };
+            const screen = mainView.screen;
+            const resizeObserver = screen?.resizeObserver;
+            if (typeof screen?.refreshSize === "function") {
+                console.log(
+                    "[window-manager] forceSyncMainViewDivElement observerReset " +
+                        JSON.stringify({
+                            reason,
+                            viewSize: this.mainView.size,
+                            observedSize,
+                        })
+                );
+                // Reset the observer queue so we sync against the current DOM box,
+                // not a stale ResizeObserver entry from a rapid resize burst.
+                resizeObserver?.disconnect?.();
+                screen.refreshSize(observedSize.width, observedSize.height);
+                resizeObserver?.observe?.(element);
+            }
+        } finally {
+            queueMicrotask(() => {
+                const rect = targetElement.getBoundingClientRect();
+                console.log("[window-manager] forceSyncMainViewDivElementResult " + JSON.stringify({
+                    reason,
+                    viewSize: this.mainView.size,
+                    rect: { width: rect.width, height: rect.height },
+                }));
+                this.isForcingMainViewDivElement = false;
+            });
+        }
+    }
+
     public start() {
-        console.log("[window-manager] start  " + JSON.stringify(this.mainViewSize));
+        console.log("[window-manager] start attributes size:" + JSON.stringify(this.mainViewSize));
         this.sizeChangeHandler(this.mainViewSize);
         if (this.started) return;
         this.addCameraListener();
         this.addCameraReaction();
         if (this.manager.room) this.syncMainView(this.manager.room);
         this.started = true;
+        if(this.mainView.focusScenePath) {
+            this.manager.windowManger.onMainViewScenePathChangeHandler(this.mainView.focusScenePath);
+        }
+        console.log("[window-manager] start end mainView size:" + JSON.stringify(this.mainView.size));
     }
 
     public addCameraReaction = () => {
@@ -132,11 +239,11 @@ export class MainViewProxy {
     private cameraReaction = () => {
         return reaction(
             () => this.mainViewCamera,
-            camera => {
+            (camera: MainViewCamera | undefined) => {
                 if (camera && camera.id !== this.manager.uid) {
-                    console.log("[window-manager] cameraReaction  " + JSON.stringify(camera) + JSON.stringify(this.mainViewSize));
                     this.moveCameraToContian(this.mainViewSize);
                     this.moveCamera(camera);
+                    this.cameraReactionLocalConsole.log(`camera: ${JSON.stringify(camera)}, current size: ${JSON.stringify(this.mainViewSize)}`);
                 }
             },
             { fireImmediately: true }
@@ -147,7 +254,7 @@ export class MainViewProxy {
         if (size) {
             this.moveCameraToContian(size);
             this.moveCamera(this.mainViewCamera);
-            console.log("[window-manager] sizeChangeHandler  current size and camera" + JSON.stringify(size) + JSON.stringify(this.mainViewCamera) +
+            console.log("[window-manager] sizeChangeHandler current size and camera" + JSON.stringify(size) + JSON.stringify(this.mainViewCamera) +
             JSON.stringify(this.mainView.camera) + JSON.stringify(this.mainView.size));
         }
         this.ensureMainViewSize();
@@ -248,18 +355,18 @@ export class MainViewProxy {
 
     private addCameraListener() {
         this.view.callbacks.on("onCameraUpdatedByDevice", this.onCameraUpdatedByDevice);
-        this.view.callbacks.on("onCameraUpdated", this.onCameraOrSizeUpdated);
-        this.view.callbacks.on("onSizeUpdated", this.onCameraOrSizeUpdated);
+        this.view.callbacks.on("onCameraUpdated", this.onCameraUpdated);
+        this.view.callbacks.on("onSizeUpdated", this.onSizeUpdated);
     }
 
     private removeCameraListener() {
         this.view.callbacks.off("onCameraUpdatedByDevice", this.onCameraUpdatedByDevice);
-        this.view.callbacks.off("onCameraUpdated", this.onCameraOrSizeUpdated);
-        this.view.callbacks.off("onSizeUpdated", this.onCameraOrSizeUpdated);
+        this.view.callbacks.off("onCameraUpdated", this.onCameraUpdated);
+        this.view.callbacks.off("onSizeUpdated", this.onSizeUpdated);
     }
 
     private _syncMainViewTimer = 0;
-    private onCameraOrSizeUpdated = () => {
+    private handleCameraOrSizeUpdated = () => {
         callbacks.emit("cameraStateChange", this.cameraState);
         // sdk >= 2.16.43 的 syncMainView() 可以写入当前 main view 的 camera, 以修复复制粘贴元素的位置
         // 注意到这个操作会发送信令，应当避免频繁调用
@@ -270,6 +377,16 @@ export class MainViewProxy {
         this.ensureMainViewSize();
     };
 
+    private onCameraUpdated = (camera: Camera) => {
+        this.cameraUpdatedLocalConsole.log(JSON.stringify(camera));
+        this.handleCameraOrSizeUpdated();
+    };
+
+    private onSizeUpdated = (size: Size) => {
+        this.sizeUpdatedLocalConsole.log(JSON.stringify(size));
+        this.handleCameraOrSizeUpdated();
+    };
+
     private ensureMainViewSize() {
         if (
             (!this.mainViewSize ||
@@ -284,7 +401,6 @@ export class MainViewProxy {
 
     private syncMainView = (room: Room) => {
         if (room.isWritable) {
-            console.log("[window-manager] syncMainView  ");
             room.syncMainView(this.mainView);
         }
     };
@@ -328,6 +444,15 @@ export class MainViewProxy {
     };
 
     public destroy() {
+        console.log("[window-manager] destroy  ");
+        if (this.wrapperRectWorkaroundFrame) {
+            cancelAnimationFrame(this.wrapperRectWorkaroundFrame);
+            this.wrapperRectWorkaroundFrame = 0;
+        }
+        this.playgroundSizeChangeListenerLocalConsole.destroy();
+        this.sizeUpdatedLocalConsole.destroy();
+        this.cameraUpdatedLocalConsole.destroy();
+        this.cameraReactionLocalConsole.destroy();
         this.removeMainViewListener();
         this.stop();
         this.sideEffectManager.flushAll();

package/src/index.ts

@@ -12,7 +12,7 @@ import { Fields } from "./AttributesDelegate";
 import { initDb } from "./Register/storage";
 import { InvisiblePlugin, isPlayer, isRoom, RoomPhase, ViewMode } from "white-web-sdk";
 import { isEqual, isNull, isObject, omit, isNumber } from "lodash";
-import { log } from "./Utils/log";
+import { ArgusLog, log } from "./Utils/log";
 import { PageStateImpl } from "./PageState";
 import { ReconnectRefresher } from "./ReconnectRefresher";
 import { replaceRoomFunction } from "./Utils/RoomHacker";
@@ -245,6 +245,8 @@ export class WindowManager
 
     private _roomLogger?: Logger;
 
+    public attributesDeboundceLog?: ArgusLog;
+
     get Logger(): Logger | undefined {
         return this._roomLogger;
     }
@@ -253,16 +255,9 @@ export class WindowManager
         super(context);
         WindowManager.displayer = context.displayer;
         (window as any).NETLESS_DEPS = __APP_DEPENDENCIES__;
-        this.visibleStateListener();
-        document.addEventListener("visibilitychange", this.visibleStateListener);
         this.emitter.on('mainViewScenePathChange', this.onMainViewScenePathChangeHandler)
     }
 
-
-    private visibleStateListener = () => {
-        console.log("[window-manager] visibleStateListener  isVisible:" + !document.hidden);
-    }
-
     public static onCreate(manager: WindowManager) {
         WindowManager._resolve(manager);
     }
@@ -294,6 +289,7 @@ export class WindowManager
             manager = await this.initManager(room);
             if (manager) {
                 manager._roomLogger = (room as unknown as { logger: Logger }).logger;
+                manager.attributesDeboundceLog = new ArgusLog(manager._roomLogger, "attributes", 300);
                 if (WindowManager.registered.size > 0) {
                     manager._roomLogger.info(
                         `[WindowManager] registered apps: ${JSON.stringify(
@@ -403,16 +399,17 @@ export class WindowManager
         if (mainViewElement) {
             const backgroundImage = mainViewElement.querySelector('.background img');
             if (backgroundImage) {
-                // todo 获取到 back ground image 的 rect情况以及css情况是否可见
                 const backgroundImageRect = backgroundImage?.getBoundingClientRect();
                 const backgroundImageCSS = window.getComputedStyle(backgroundImage);
                 const backgroundImageVisible = backgroundImageRect?.width > 0 && backgroundImageRect?.height > 0 && backgroundImageCSS.display !== 'none';
-                console.log("[window-manager] backgroundImageVisible" + backgroundImageVisible);
+                const camera = this.mainView.camera;
+                console.log("[window-manager] backgroundImageVisible:" + backgroundImageVisible + " camera:" + JSON.stringify(camera));
                 return;
             }
-            console.log("[window-manager] onMainViewScenePathChange" + scenePath + 'backgroundImageVisible is not found');
+            console.log("[window-manager] onMainViewScenePathChange scenePath:" + scenePath + ' backgroundImageVisible is not found');
+            return;
         }
-        console.log("[window-manager] onMainViewScenePathChange" + scenePath + 'mainViewElement is not found');
+        console.log("[window-manager] onMainViewScenePathChange scenePath:" + scenePath + ' mainViewElement is not found');
     }
 
     private static initManager(room: Room): Promise<WindowManager | undefined> {
@@ -1047,7 +1044,6 @@ export class WindowManager
                 animationMode?: AnimationMode;
             }>
     ): void {
-        console.log("[window-manager] moveCameraToContain" + JSON.stringify(rectangle));
         this.mainView.moveCameraToContain(rectangle);
         setTimeout(() => {
             this.appManager?.mainViewProxy.setCameraAndSize();
@@ -1071,6 +1067,8 @@ export class WindowManager
     }
 
     private _destroy() {
+        this.attributesDeboundceLog?.destroy();
+        this.attributesDeboundceLog = undefined;
         this.containerResizeObserver?.disconnect();
         this.appManager?.destroy();
         this.cursorManager?.destroy();
@@ -1083,7 +1081,6 @@ export class WindowManager
             WindowManager.playground.parentNode?.removeChild(WindowManager.playground);
         }
         WindowManager.params = undefined;
-        document.removeEventListener("visibilitychange", this.visibleStateListener);
         this.emitter.off('mainViewScenePathChange', this.onMainViewScenePathChangeHandler);
         this._iframeBridge?.destroy();
         this._iframeBridge = undefined;
@@ -1115,12 +1112,18 @@ export class WindowManager
     public safeSetAttributes(attributes: any): void {
         if (this.canOperate) {
             this.setAttributes(attributes);
+            if (this.attributesDeboundceLog) {
+                this.attributesDeboundceLog.logDebouncedShallowMerge("safeSetAttributes", attributes);
+            }
         }
     }
 
     public safeUpdateAttributes(keys: string[], value: any): void {
         if (this.canOperate) {
             this.updateAttributes(keys, value);
+            if (this.attributesDeboundceLog) {
+                this.attributesDeboundceLog.logDebouncedUpdateAttributes(keys, value);
+            }
         }
     }
 
@@ -1131,6 +1134,7 @@ export class WindowManager
     public cleanCurrentScene(): void {
         log("clean current scene");
         this.focusedView?.cleanCurrentScene();
+        this.Logger && this.Logger.info(`[WindowManager]: cleanCurrentScene ${this.focusedView?.focusScenePath}`);
     }
 
     public redo(): number {
@@ -1143,6 +1147,7 @@ export class WindowManager
 
     public delete(): void {
         this.focusedView?.delete();
+        this.Logger && this.Logger.info(`[WindowManager]: delete ${this.focusedView?.focusScenePath}`);
     }
 
     public copy(): void {