@mindexec/cli 0.2.401 → 0.2.402

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.401",
+  "version": "0.2.402",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",

package/wwwroot/_content/MindExecution.Shared/js/mind-map-core.js

@@ -1456,7 +1456,7 @@
             overlayLayoutChanged: moduleInstance._overlayDebugLayoutChanged === true,
             overlayContentChanged: moduleInstance._overlayDebugContentChanged === true,
             overlayForceRefresh: moduleInstance._overlayDebugForceRefresh === true,
-            cameraMotionFastPathStatus: null,
+            cameraMotionFastPathStatus: moduleInstance._lastImmediateCameraFeedbackStatus || null,
             metricsSnapshotMs: Number(metricsSnapshotMs.toFixed(2)),
             metricsSnapshotCached: false,
             metricsSnapshotAgeMs: 0,
@@ -3162,6 +3162,10 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
             this._ctrlWheelScrollInputTime = 0;
             this._ctrlWheelScrollLastDeltaY = 0;
             this._cameraNavigationOverlayInputTime = 0;
+            this._lastImmediateCameraFeedbackStatus = null;
+            this._immediateCameraFeedbackCount = 0;
+            this._immediateCameraFeedbackCss3dCount = 0;
+            this._immediateCameraFeedbackEdgeCount = 0;
             // Match background-themes.js 'XYGrid' size1.
             this.GRID_SIZE = 10;
             // ?�▲??[Changed] ?�▲??
@@ -4102,6 +4106,115 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
             }
         }
 
+        applyImmediateCameraNavigationFeedback(reason = 'camera-navigation-input') {
+            const now = typeof performance !== 'undefined' && typeof performance.now === 'function'
+                ? performance.now()
+                : Date.now();
+            const status = {
+                used: false,
+                reason: String(reason || 'camera-navigation-input'),
+                css3dCamera: false,
+                automationEdges: false,
+                motionGrid: false,
+                localSnapGrid: false,
+                skippedReason: '',
+                count: Number(this._immediateCameraFeedbackCount || 0),
+                updatedAt: now
+            };
+
+            const finish = (skippedReason = '') => {
+                status.skippedReason = skippedReason;
+                this._lastImmediateCameraFeedbackStatus = status;
+                return status.used === true;
+            };
+
+            if (!this.camera || this._animationLoopExecuting === true || this.isLoading === true) {
+                return finish('runtime-busy');
+            }
+
+            const nextX = Number(this.targetX ?? this.camera.position.x);
+            const nextY = Number(this.targetY ?? this.camera.position.y);
+            const nextZ = Number(this.targetZ ?? this.camera.position.z);
+            if (!Number.isFinite(nextX) || !Number.isFinite(nextY) || !Number.isFinite(nextZ)) {
+                return finish('invalid-target');
+            }
+
+            const currentX = Number(this.camera.position.x || 0);
+            const currentY = Number(this.camera.position.y || 0);
+            const currentZ = Number(this.camera.position.z || 0);
+            if (Math.abs(nextX - currentX) < 0.001 &&
+                Math.abs(nextY - currentY) < 0.001 &&
+                Math.abs(nextZ - currentZ) < 0.001) {
+                return finish('unchanged');
+            }
+
+            this.camera.position.set(nextX, nextY, nextZ);
+            this.camera.updateMatrixWorld(true);
+            this._viewStatePersistAfterMotion = true;
+            this._cameraMovingThisFrame = true;
+            this._immediateCameraFeedbackCount = Number(this._immediateCameraFeedbackCount || 0) + 1;
+            status.used = true;
+            status.count = this._immediateCameraFeedbackCount;
+
+            const flags = this.renderDebugFlags || getRenderDebugFlagsSnapshot();
+            const isCss3dEnabled = flags.enableCss3d !== false;
+            const hasFocusedTextOverlay = !!(
+                String(this._textOverlayV2State?.selectionNodeId || '').trim() ||
+                String(this._selectableTextOverlayNodeId || '').trim()
+            );
+            const hasEditingOverlay = !!(
+                String(this._textOverlayV2State?.editing?.nodeId || '').trim() ||
+                String(this._editingOverlayState?.nodeId || '').trim() ||
+                this.isEditingNote === true
+            );
+            const isNodeInteracting = !!(
+                this.isDraggingNode ||
+                this.isDraggingMultipleNodes ||
+                this.isResizing ||
+                this.isScrollbarDragging ||
+                this.isSelecting
+            );
+            const hasCss3dDirtyTransforms = !!(
+                this._cssParentRepairNeeded === true ||
+                this._css3dVisualChangedThisFrame === true ||
+                this._css3dVisualChangedSinceLastRender === true ||
+                (this._cssTransformDirtyIds?.size || 0) > 0
+            );
+            const canRenderCss3dCamera = !!(
+                this.cssRenderer &&
+                typeof this.cssRenderer.renderCamera === 'function' &&
+                isCss3dEnabled === true &&
+                this.lodRenderer?.isInLODMode !== true &&
+                !isNodeInteracting &&
+                !hasFocusedTextOverlay &&
+                !hasEditingOverlay &&
+                !hasCss3dDirtyTransforms &&
+                this.isWindowResizing !== true
+            );
+
+            if (canRenderCss3dCamera === true) {
+                this.cssRenderer.renderCamera(this.camera);
+                this._immediateCameraFeedbackCss3dCount = Number(this._immediateCameraFeedbackCss3dCount || 0) + 1;
+                status.css3dCamera = true;
+                status.css3dCount = this._immediateCameraFeedbackCss3dCount;
+            }
+
+            if (this._shouldTouchMotionGridLayerForCameraNavigation?.() === true) {
+                status.motionGrid = this._syncMotionGridLayerForCameraNavigation?.() === true;
+            }
+
+            status.localSnapGrid = syncLocalSnapGridForCameraNavigation(this, true) === true;
+
+            if (syncBusinessAutomationEdgesForCameraNavigation(this, true, false) === true) {
+                this._immediateCameraFeedbackEdgeCount = Number(this._immediateCameraFeedbackEdgeCount || 0) + 1;
+                status.automationEdges = true;
+                status.edgeCount = this._immediateCameraFeedbackEdgeCount;
+            }
+
+            this._lastImmediateCameraFeedbackStatus = status;
+            return true;
+        }
+
         getCurrentBoardId() {
             return window.mindMap?.activeBoardId || _currentBoardId || null;
         }
@@ -5892,16 +6005,15 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
                 const forceUpdateFrames = Math.max(0, Number(this._forceUpdateFrames || 0));
                 const panLiveRefreshForceFrames = Math.max(0, Number(this._panLiveRefreshForceFrames || 0));
                 const hasForcedUpdate = forceUpdateFrames > 0;
-                // Mouse-pan live refresh keeps the render loop awake; it should not disable motion throttles.
-                const hasOnlyPanLiveRefreshForcedUpdate =
+                // Camera navigation wake frames keep the render loop awake; they should not disable motion throttles.
+                const hasOnlyCameraNavigationForcedUpdate =
                     hasForcedUpdate &&
-                    this.isPanning === true &&
-                    this.isZooming !== true &&
-                    panLiveRefreshForceFrames >= forceUpdateFrames;
-                const hasNonPanForcedUpdate =
+                    panLiveRefreshForceFrames >= forceUpdateFrames &&
+                    (this.isPanning === true || this.isZooming === true || isCameraMoving === true);
+                const hasNonCameraForcedUpdate =
                     hasForcedUpdate &&
-                    hasOnlyPanLiveRefreshForcedUpdate !== true;
-                const hasNonCameraNavigationForcedUpdate = hasNonPanForcedUpdate;
+                    hasOnlyCameraNavigationForcedUpdate !== true;
+                const hasNonCameraNavigationForcedUpdate = hasNonCameraForcedUpdate;
                 const isLodModeActive = this.lodRenderer?.isInLODMode === true;
                 const residentDirty = isResidentMidFarLodFrame &&
                     this.lodRenderer?.hasResidentDirtyWork?.(this.camera, this) === true;
@@ -6687,15 +6799,22 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
 
                 _profileSection('webglRender');
                 // ?�▼??[FIX] LOD 모드(MID/FAR)?�서??CSS3D ?�더???�출 건너?�기 ?�▼??                // CSS3D가 모두 display:none?�어???�더?��? 813�?객체�??�회?�면???�간 ?�비
+                const lastImmediateCameraFeedback = this._lastImmediateCameraFeedbackStatus || null;
+                const lastImmediateCameraFeedbackAgeMs = frameStart - Number(lastImmediateCameraFeedback?.updatedAt || 0);
+                const hasFreshImmediateCameraFeedback = !!(
+                    lastImmediateCameraFeedback?.used === true &&
+                    (this.isPanning === true || this.isZooming === true) &&
+                    lastImmediateCameraFeedbackAgeMs >= 0 &&
+                    lastImmediateCameraFeedbackAgeMs <= 120
+                );
                 const canUseCss3dCameraFastPath = !!(
                     this.cssRenderer &&
                     typeof this.cssRenderer.renderCamera === 'function' &&
                     isCss3dEnabled &&
                     !isInLodMode &&
                     shouldUpdateCss3d &&
-                    this.isPanning === true &&
-                    this.isZooming !== true &&
-                    isCameraMoving === true &&
+                    (this.isPanning === true || this.isZooming === true || isCameraMoving === true) &&
+                    (isCameraMoving === true || hasFreshImmediateCameraFeedback === true) &&
                     !isNodeInteracting &&
                     !hasNonCameraNavigationForcedUpdate &&
                     !hasPendingNearCssWarmup &&
@@ -6948,9 +7067,11 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
                         visibilityStableSkip: canSkipVisibilityCullingForStableFrame === true,
                         visibilitySkipReason: visibilityCullingSkipReason || this._lastVisibilityCullingSkipReason || '',
                         incrementalPanVisibility: isIncrementalPanVisibilityFrame === true,
+                        freshImmediateCameraFeedback: hasFreshImmediateCameraFeedback === true,
                         shouldSyncCss3dTransforms: shouldSyncCss3dTransforms === true,
                         shouldRenderCss3d: shouldRenderCss3dFrame === true,
                         usedCss3dCameraFastPath: canUseCss3dCameraFastPath === true,
+                        immediateCameraFeedback: this._lastImmediateCameraFeedbackStatus || null,
                         shouldSyncTextOverlays: shouldSyncTextOverlays === true,
                         usedPassiveOverlayCameraFastPath: usedPassiveOverlayCameraFastPath === true,
                         passiveOverlaySuppressed: isPassiveOverlaySuppressed === true,

package/wwwroot/_content/MindExecution.Shared/js/mind-map-interactions.js

@@ -5,7 +5,7 @@ window.MindMapInteractions = (function () {
     const MOTION_DOM_FANOUT_DELAY_MS = 180;
     const MOTION_DOM_FANOUT_ENABLED = false;
     const MOTION_WILL_CHANGE_ENABLE_DELAY_MS = 240;
-    const WHEEL_ZOOM_TARGET_UPDATE_MODE = 'raf-coalesced-direct';
+    const WHEEL_ZOOM_TARGET_UPDATE_MODE = 'event-direct';
     const PRIMARY_CLICK_DELAY_MS = 280;
     const BACKGROUND_PRIMARY_CLICK_DELAY_MS = 320;
     const eventHandlers = new WeakMap();
@@ -603,10 +603,34 @@ window.MindMapInteractions = (function () {
         if (!module) {
             return;
         }
-        wakeCameraNavigationAnimation(module, 'pan-input');
+        wakeCameraNavigationAnimation(module, 'pan-input', { immediate: true, forceFrames: 2 });
     }
 
-    function wakeCameraNavigationAnimation(module, reason = 'camera-navigation-input') {
+    function applyImmediateCameraNavigationFeedback(module, reason = 'camera-navigation-input') {
+        if (module && typeof module.applyImmediateCameraNavigationFeedback === 'function') {
+            module.applyImmediateCameraNavigationFeedback(reason);
+        }
+    }
+
+    function markCameraNavigationForceFrames(module, frames = 2) {
+        if (!module) {
+            return;
+        }
+
+        const safeFrames = Math.max(0, Math.floor(Number(frames || 0)));
+        if (safeFrames <= 0) {
+            return;
+        }
+
+        module._forceUpdateFrames = Math.max(Number(module._forceUpdateFrames || 0), safeFrames);
+        module._panLiveRefreshForceFrames = Math.max(Number(module._panLiveRefreshForceFrames || 0), safeFrames);
+    }
+
+    function wakeCameraNavigationAnimation(module, reason = 'camera-navigation-input', options = {}) {
+        markCameraNavigationForceFrames(module, options?.forceFrames ?? 0);
+        if (options?.immediate === true) {
+            applyImmediateCameraNavigationFeedback(module, reason);
+        }
         if (module && typeof module.requestAnimationWake === 'function') {
             module.requestAnimationWake(reason);
         }
@@ -6362,7 +6386,7 @@ window.MindMapInteractions = (function () {
         module._lastPanInputAt = panInputAt;
         module._deferPassiveOverlayRefresh = true;
         module._cameraNavigationOverlayInputTime = panInputAt;
-        wakeCameraNavigationAnimation(module, 'trackpad-pan-input');
+        wakeCameraNavigationAnimation(module, 'trackpad-pan-input', { immediate: true, forceFrames: 2 });
 
         if (module.isSelecting) {
             updateSelectionBox(module);
@@ -6387,6 +6411,13 @@ window.MindMapInteractions = (function () {
             return;
         }
 
+        if (WHEEL_ZOOM_TARGET_UPDATE_MODE === 'event-direct') {
+            const wheelNow = getWheelTimestamp();
+            markCanvasWheelActivity(module, wheelNow, { throttleMs: WHEEL_ACTIVITY_BURST_INTERVAL_MS });
+            performCameraZoomBuffered(module, deltaY, e.clientX, e.clientY, { inputTime: wheelNow });
+            return;
+        }
+
         wheelBuffer.deltaY += deltaY;
         wheelBuffer.lastClientX = e.clientX;
         wheelBuffer.lastClientY = e.clientY;
@@ -6496,9 +6527,9 @@ window.MindMapInteractions = (function () {
         const newY = worldMouseY - (worldMouseY - module.targetY) * zoomRatio;
         module.targetX = newX;
         module.targetY = newY;
+        applyImmediateCameraNavigationFeedback(module, 'wheel-zoom-input');
         const settleFrames = 2;
-        module._forceUpdateFrames = Math.max(Number(module._forceUpdateFrames || 0), settleFrames);
-        wakeCameraNavigationAnimation(module, 'wheel-zoom-input');
+        wakeCameraNavigationAnimation(module, 'wheel-zoom-input', { forceFrames: settleFrames });
         // ▲▲▲ [Changed] ▲▲▲
 
         // ▼▼▼ [Perf] 줌 종료 감지 및 CSS3D 업데이트 타이머 ▼▼▼
@@ -6649,10 +6680,11 @@ window.MindMapInteractions = (function () {
 
         const panFactor = 0.001 * module.camera.position.z;
         module.targetY -= deltaY * panFactor;
-        module._forceUpdateFrames = Math.max(module._forceUpdateFrames || 0, 2);
+        applyImmediateCameraNavigationFeedback(module, 'ctrl-wheel-pan-input');
         module._deferPassiveOverlayRefresh = false;
         module._overlayDirty = true;
         window.MindMapTextOverlayV2?.invalidateView?.(module);
+        wakeCameraNavigationAnimation(module, 'ctrl-wheel-pan-input', { forceFrames: 2 });
 
         if (module.isSelecting) {
             updateSelectionBox(module);

package/wwwroot/service-worker-assets.js

@@ -1,5 +1,5 @@
 self.assetsManifest = {
-    "version":  "GIgxXFFU",
+    "version":  "1QwFTqyQ",
     "assets":  [
                    {
                        "hash":  "sha256-+CSYMcqLNTsq3VnH11jgYyOCCdxvHzL74CBmo4sCmMU=",
@@ -78,7 +78,7 @@
                        "url":  "_content/MindExecution.Shared/js/marked.min.js"
                    },
                    {
-                       "hash":  "sha256-vg5A+jUp1q8pNFLDoYxZSJvnXKldtLM9x+4fE9ZVL8o=",
+                       "hash":  "sha256-w+HacmhIzPWqioCQJ3qhkvGgqtOlm8G/0tMPsAPtb4I=",
                        "url":  "_content/MindExecution.Shared/js/mind-map-core.js"
                    },
                    {
@@ -106,7 +106,7 @@
                        "url":  "_content/MindExecution.Shared/js/mind-map-glow-shader.js"
                    },
                    {
-                       "hash":  "sha256-EQRL/Bpor3JV+VXC+nmVHqOTG+XxE61wV1Oi6c4tL8Q=",
+                       "hash":  "sha256-QpXY2g89ekLPTa3GDB/lse5U2wQm39lXq7V3RUNLhd0=",
                        "url":  "_content/MindExecution.Shared/js/mind-map-interactions.js"
                    },
                    {

package/wwwroot/service-worker.js

@@ -1,4 +1,4 @@
-/* Manifest version: GIgxXFFU */
+/* Manifest version: 1QwFTqyQ */
 // Hosted deployments should prefer the network over stale offline caches.
 // This service worker immediately clears old Blazor offline caches and unregisters itself.