@mindexec/cli 0.2.452 → 0.2.454

package/wwwroot/_content/MindExecution.Shared/js/mind-map-render-plan.js

@@ -1,7 +1,7 @@
 (function () {
     'use strict';
 
-    const BUILD_ID = '20260713-normal-boundary-plan-v41';
+    const BUILD_ID = '20260728-camera-render-policy-v43';
     const FRAME_SAMPLE_LIMIT = 240;
     const INITIAL_LINE_TEXTURE_ROWS = 1024;
     const GPU_WARM_RETRY_DELAY_MS = 120;
@@ -18,6 +18,147 @@
         'lodCleanup', 'lodNodeScan', 'lodResidentApply', 'lodLinePatch', 'lodImageInstances',
         'lodPositionPatch', 'lodFallbacks', 'lodOther'
     ];
+    const CAMERA_ONLY_WEBGL_BLOCKERS = Object.freeze({
+        NotCameraOnly: 1 << 0,
+        Css3dCameraPathUnavailable: 1 << 1,
+        WebglDisabled: 1 << 2,
+        BoardLoading: 1 << 3,
+        ResidentLod: 1 << 4,
+        NonCameraUpdate: 1 << 5,
+        ThemeAnimation: 1 << 6,
+        WebglTheme: 1 << 7,
+        CssCoverageIncomplete: 1 << 8,
+        FullResHandoff: 1 << 9,
+        ResidentMeshVisible: 1 << 10,
+        ImageVisual: 1 << 11,
+        AnimatedImageStatus: 1 << 12,
+        CursorVisual: 1 << 13,
+        DebugVisual: 1 << 14,
+        FullResGlVisual: 1 << 15
+    });
+    const CAMERA_ONLY_WEBGL_BLOCKER_NAMES = Object.freeze([
+        [CAMERA_ONLY_WEBGL_BLOCKERS.NotCameraOnly, 'not-camera-only'],
+        [CAMERA_ONLY_WEBGL_BLOCKERS.Css3dCameraPathUnavailable, 'css3d-camera-path-unavailable'],
+        [CAMERA_ONLY_WEBGL_BLOCKERS.WebglDisabled, 'webgl-disabled'],
+        [CAMERA_ONLY_WEBGL_BLOCKERS.BoardLoading, 'board-loading'],
+        [CAMERA_ONLY_WEBGL_BLOCKERS.ResidentLod, 'resident-lod'],
+        [CAMERA_ONLY_WEBGL_BLOCKERS.NonCameraUpdate, 'non-camera-update'],
+        [CAMERA_ONLY_WEBGL_BLOCKERS.ThemeAnimation, 'theme-animation'],
+        [CAMERA_ONLY_WEBGL_BLOCKERS.WebglTheme, 'webgl-theme'],
+        [CAMERA_ONLY_WEBGL_BLOCKERS.CssCoverageIncomplete, 'css-coverage-incomplete'],
+        [CAMERA_ONLY_WEBGL_BLOCKERS.FullResHandoff, 'fullres-handoff'],
+        [CAMERA_ONLY_WEBGL_BLOCKERS.ResidentMeshVisible, 'resident-mesh-visible'],
+        [CAMERA_ONLY_WEBGL_BLOCKERS.ImageVisual, 'image-visual'],
+        [CAMERA_ONLY_WEBGL_BLOCKERS.AnimatedImageStatus, 'animated-image-status'],
+        [CAMERA_ONLY_WEBGL_BLOCKERS.CursorVisual, 'cursor-visual'],
+        [CAMERA_ONLY_WEBGL_BLOCKERS.DebugVisual, 'debug-visual'],
+        [CAMERA_ONLY_WEBGL_BLOCKERS.FullResGlVisual, 'fullres-gl-visual']
+    ]);
+
+    function isRendererDprInteractionActive(module, frameState = null) {
+        return !!(
+            frameState?.isCameraMoving === true ||
+            module?.isZooming === true ||
+            module?.isPanning === true ||
+            module?._cameraMovingThisFrame === true ||
+            module?._panSmoothingActive === true ||
+            module?._wheelZoomBurstActive === true ||
+            module?.isDraggingNode === true ||
+            module?.isDraggingMultipleNodes === true ||
+            module?.isResizing === true ||
+            module?.isWindowResizing === true
+        );
+    }
+
+    function getCameraOnlyWebglBlockerMask(module, frameState = null) {
+        const renderer = module?.lodRenderer || null;
+        let blockers = 0;
+        if (frameState?.isCameraNavigationOnlyInteractiveFrame !== true) {
+            blockers |= CAMERA_ONLY_WEBGL_BLOCKERS.NotCameraOnly;
+        }
+        if (frameState?.canUseCss3dCameraFastPath !== true) {
+            blockers |= CAMERA_ONLY_WEBGL_BLOCKERS.Css3dCameraPathUnavailable;
+        }
+        if (frameState?.isWebglRenderEnabled !== true) {
+            blockers |= CAMERA_ONLY_WEBGL_BLOCKERS.WebglDisabled;
+        }
+        if (frameState?.isBoardLoading === true) {
+            blockers |= CAMERA_ONLY_WEBGL_BLOCKERS.BoardLoading;
+        }
+        if (frameState?.isInLodMode === true || renderer?.isInLODMode !== false) {
+            blockers |= CAMERA_ONLY_WEBGL_BLOCKERS.ResidentLod;
+        }
+        if (frameState?.hasNonCameraNavigationForcedUpdate === true) {
+            blockers |= CAMERA_ONLY_WEBGL_BLOCKERS.NonCameraUpdate;
+        }
+        if (frameState?.themeAnimatedThisFrame === true || module?._forceThemeAnimationFrame === true) {
+            blockers |= CAMERA_ONLY_WEBGL_BLOCKERS.ThemeAnimation;
+        }
+        if (module?.currentThemeObject?.userData?.localSnapGrid !== true) {
+            blockers |= CAMERA_ONLY_WEBGL_BLOCKERS.WebglTheme;
+        }
+
+        const visibleCount = Number(module?._visibleIds?.size || 0);
+        const nearCssVisibleCount = Number(renderer?._nearCssVisibleIds?.size || 0);
+        const activeFullResCssCount = Number(renderer?._activeFullResCssNodeIds?.size || 0);
+        const pendingFullResCssCount = Number(renderer?._fullResCssPendingReadyIds?.size || 0);
+        const hasCompleteCssCoverage =
+            nearCssVisibleCount === visibleCount &&
+            activeFullResCssCount === visibleCount &&
+            pendingFullResCssCount === 0 &&
+            (visibleCount === 0 || !!renderer?._lastNearCssNoWorkKey);
+        if (!hasCompleteCssCoverage) {
+            blockers |= CAMERA_ONLY_WEBGL_BLOCKERS.CssCoverageIncomplete;
+        }
+
+        // The full-res motion optimizer owns this cached proof: only CSS-backed,
+        // unselected text-like nodes enter the set after their whole GL group is
+        // hidden. Images, media, selected nodes, and open agent consoles remain
+        // outside it and therefore fail closed without a scene traversal here.
+        const motionHiddenGlCount = Number(renderer?._fullResMotionHiddenGlIds?.size || 0);
+        if (motionHiddenGlCount !== visibleCount) {
+            blockers |= CAMERA_ONLY_WEBGL_BLOCKERS.FullResGlVisual;
+        }
+
+        const fullResHandoffActive =
+            renderer?._fullResHandoffActive === true ||
+            renderer?._hasCss3dQueueItems?.() === true ||
+            renderer?._css3dProcessing === true;
+        if (fullResHandoffActive) {
+            blockers |= CAMERA_ONLY_WEBGL_BLOCKERS.FullResHandoff;
+        }
+
+        const residentMeshVisible =
+            renderer?.instancedHaloMesh?.visible === true ||
+            renderer?.instancedMesh?.visible === true ||
+            renderer?.instancedBorderLineMesh?.visible === true ||
+            renderer?.instancedLineMesh?.visible === true ||
+            renderer?.instancedConsoleMesh?.visible === true ||
+            renderer?.instancedImageMesh?.visible === true;
+        if (residentMeshVisible) {
+            blockers |= CAMERA_ONLY_WEBGL_BLOCKERS.ResidentMeshVisible;
+        }
+        if (Number(renderer?._fullResImageVisualIds?.size || 0) > 0) {
+            blockers |= CAMERA_ONLY_WEBGL_BLOCKERS.ImageVisual;
+        }
+        if (Number(module?._activeImageStatusTextures?.size || 0) > 0) {
+            blockers |= CAMERA_ONLY_WEBGL_BLOCKERS.AnimatedImageStatus;
+        }
+        if (module?.cursorMesh?.visible === true) {
+            blockers |= CAMERA_ONLY_WEBGL_BLOCKERS.CursorVisual;
+        }
+        if (Number(module?.debugGroup?.children?.length || 0) > 0) {
+            blockers |= CAMERA_ONLY_WEBGL_BLOCKERS.DebugVisual;
+        }
+        return blockers;
+    }
+
+    function getCameraOnlyWebglBlockerNames(mask) {
+        const normalizedMask = Number(mask || 0);
+        return CAMERA_ONLY_WEBGL_BLOCKER_NAMES
+            .filter(([flag]) => (normalizedMask & flag) !== 0)
+            .map(([, name]) => name);
+    }
 
     function configureImageAtlasTexture(texture, THREE) {
         if (!texture || !THREE) return texture;
@@ -410,11 +551,110 @@
         return true;
     }
 
-    function hasAnimatedGifCssFallbackCandidates(renderer, module, isAnimatedGifModel) {
+    function invalidateAnimatedGifCssFallbackCandidateCache(renderer) {
+        if (!renderer) return;
+        renderer._animatedGifFallbackCandidateCacheValid = false;
+    }
+
+    function invalidateActiveCssMediaFallbackCountCache(renderer) {
+        if (!renderer) return;
+        renderer._activeCssMediaFallbackCountCacheValid = false;
+    }
+
+    function markLodImageCssFallbacksChanged(renderer) {
+        if (!renderer) return;
+        renderer._lodImageCssFallbackRevision =
+            Number(renderer._lodImageCssFallbackRevision || 0) + 1;
+        invalidateAnimatedGifCssFallbackCandidateCache(renderer);
+        invalidateActiveCssMediaFallbackCountCache(renderer);
+    }
+
+    function createTrackedLodImageCssFallbackSet(renderer) {
+        return new class extends Set {
+            add(value) {
+                if (!this.has(value)) {
+                    super.add(value);
+                    markLodImageCssFallbacksChanged(renderer);
+                }
+                return this;
+            }
+
+            delete(value) {
+                const deleted = super.delete(value);
+                if (deleted) markLodImageCssFallbacksChanged(renderer);
+                return deleted;
+            }
+
+            clear() {
+                if (this.size <= 0) return;
+                super.clear();
+                markLodImageCssFallbacksChanged(renderer);
+            }
+        }();
+    }
+
+    function getActiveCssMediaFallbackCountCached(renderer, module) {
+        if (!renderer) return 0;
+        const nodeObjectsById = module?.nodeObjectsById || renderer?._module?.nodeObjectsById || null;
+        const fallbackRevision = Number(renderer?._lodImageCssFallbackRevision || 0);
+        const fallbackCount = Number(renderer?._lodImageCssFallbackNodeIds?.size || 0);
+        if (fallbackCount <= 0) {
+            renderer._activeCssMediaFallbackCountCacheNodeMap = nodeObjectsById;
+            renderer._activeCssMediaFallbackCountCacheRevision = fallbackRevision;
+            renderer._activeCssMediaFallbackCountCacheFallbackCount = 0;
+            renderer._activeCssMediaFallbackCountCacheValue = 0;
+            renderer._activeCssMediaFallbackCountCacheValid = true;
+            return 0;
+        }
+        if (renderer._activeCssMediaFallbackCountCacheValid === true &&
+            renderer._activeCssMediaFallbackCountCacheNodeMap === nodeObjectsById &&
+            Number(renderer._activeCssMediaFallbackCountCacheRevision || 0) === fallbackRevision &&
+            Number(renderer._activeCssMediaFallbackCountCacheFallbackCount || 0) === fallbackCount) {
+            renderer._activeCssMediaFallbackCountCacheHitCount =
+                Number(renderer._activeCssMediaFallbackCountCacheHitCount || 0) + 1;
+            return Number(renderer._activeCssMediaFallbackCountCacheValue || 0);
+        }
+
+        const activeFallbackCount =
+            Number(renderer._getActiveCssMediaLodFallbackCount?.(module) || 0);
+        renderer._activeCssMediaFallbackCountScanCount =
+            Number(renderer._activeCssMediaFallbackCountScanCount || 0) + 1;
+        renderer._activeCssMediaFallbackCountCacheNodeMap = nodeObjectsById;
+        renderer._activeCssMediaFallbackCountCacheRevision = fallbackRevision;
+        renderer._activeCssMediaFallbackCountCacheFallbackCount = fallbackCount;
+        renderer._activeCssMediaFallbackCountCacheValue = activeFallbackCount;
+        renderer._activeCssMediaFallbackCountCacheValid = true;
+        return activeFallbackCount;
+    }
+
+    function hasAnimatedGifCssFallbackCandidates(renderer, module, isAnimatedGifModel, selectionKey = '') {
         const nodeObjectsById = module?.nodeObjectsById || renderer?._module?.nodeObjectsById || null;
         if (!nodeObjectsById || typeof isAnimatedGifModel !== 'function') return false;
+        const visibilityVersion = Number(module?._visibilityVersion || 0);
+        const fallbackRevision = Number(renderer?._lodImageCssFallbackRevision || 0);
+        const fallbackCount = Number(renderer?._lodImageCssFallbackNodeIds?.size || 0);
+        const residentDirtySerial = Number(renderer?._instancesDirtySerial || 0);
+        const normalizedSelectionKey = String(selectionKey || '');
+        if (renderer?._animatedGifFallbackCandidateCacheValid === true &&
+            renderer._animatedGifFallbackCandidateNodeMap === nodeObjectsById &&
+            Number(renderer._animatedGifFallbackCandidateVisibilityVersion || 0) === visibilityVersion &&
+            Number(renderer._animatedGifFallbackCandidateFallbackRevision || 0) === fallbackRevision &&
+            Number(renderer._animatedGifFallbackCandidateFallbackCount || 0) === fallbackCount &&
+            Number(renderer._animatedGifFallbackCandidateResidentDirtySerial || 0) === residentDirtySerial &&
+            String(renderer._animatedGifFallbackCandidateSelectionKey || '') === normalizedSelectionKey) {
+            renderer._animatedGifFallbackCandidateCacheHitCount =
+                Number(renderer._animatedGifFallbackCandidateCacheHitCount || 0) + 1;
+            return renderer._animatedGifFallbackCandidateCacheValue === true;
+        }
+
+        renderer._animatedGifFallbackCandidateScanCount =
+            Number(renderer._animatedGifFallbackCandidateScanCount || 0) + 1;
         const isGifId = (value) => {
             const nodeId = String(value || '').trim();
+            if (nodeId) {
+                renderer._animatedGifFallbackCandidateNodeVisitCount =
+                    Number(renderer._animatedGifFallbackCandidateNodeVisitCount || 0) + 1;
+            }
             return !!nodeId && isAnimatedGifModel(nodeObjectsById.get(nodeId)?.model) === true;
         };
         const scan = (ids) => {
@@ -423,10 +663,21 @@
             return false;
         };
         const visibleIds = module?._visibleIds || null;
-        if (scan(visibleIds)) return true;
-        if (module?._prevVisibleIds !== visibleIds && scan(module?._prevVisibleIds)) return true;
-        if (isGifId(module?.selectedNodeIdJs) || scan(module?.multiSelectedNodeIds)) return true;
-        return scan(renderer?._lodImageCssFallbackNodeIds);
+        const result =
+            scan(visibleIds) ||
+            (module?._prevVisibleIds !== visibleIds && scan(module?._prevVisibleIds)) ||
+            isGifId(module?.selectedNodeIdJs) ||
+            scan(module?.multiSelectedNodeIds) ||
+            scan(renderer?._lodImageCssFallbackNodeIds);
+        renderer._animatedGifFallbackCandidateNodeMap = nodeObjectsById;
+        renderer._animatedGifFallbackCandidateVisibilityVersion = visibilityVersion;
+        renderer._animatedGifFallbackCandidateFallbackRevision = fallbackRevision;
+        renderer._animatedGifFallbackCandidateFallbackCount = fallbackCount;
+        renderer._animatedGifFallbackCandidateResidentDirtySerial = residentDirtySerial;
+        renderer._animatedGifFallbackCandidateSelectionKey = normalizedSelectionKey;
+        renderer._animatedGifFallbackCandidateCacheValue = result === true;
+        renderer._animatedGifFallbackCandidateCacheValid = true;
+        return result === true;
     }
 
     function hasResidentDirtyWork(renderer, camera, module, resolveLodBand, buildSelectionKey, isAnimatedGifModel) {
@@ -434,7 +685,8 @@
         const lodBand = camera && typeof resolveLodBand === 'function'
             ? resolveLodBand(Number(camera.position?.z || 0))
             : renderer._currentLodBand;
-        if (renderer._instancesDirty === true || renderer._imageInstancesDirty === true ||
+        const hasTypedResidentDirtyWork =
+            renderer._instancesDirty === true || renderer._imageInstancesDirty === true ||
             renderer._positionsOnlyDirty === true || renderer._isNodeArrayDirty === true ||
             Number(renderer._dirtyPositionIds?.size || 0) > 0 || Number(renderer._pendingSelectionRefreshIds?.size || 0) > 0 ||
             renderer._imageAtlasRebuildPending === true || Number(renderer._imageAtlasQueuedIds?.size || 0) > 0 ||
@@ -442,16 +694,28 @@
             renderer._imageAtlasBatchActive === true || renderer._lodCleanupPending === true ||
             renderer._deferLineRestorePending === true || renderer._hasPendingLineDetailRestore?.(lodBand) === true ||
             Number(renderer._pendingLodVisibilityVersion ?? -1) >= 0 || renderer._fullResHandoffActive === true ||
-            renderer.isLoading === true || module?.isLoading === true || renderer._hasResidentLodInstances?.() !== true) return true;
+            renderer.isLoading === true || module?.isLoading === true || renderer._hasResidentLodInstances?.() !== true;
+        if (hasTypedResidentDirtyWork) {
+            invalidateAnimatedGifCssFallbackCandidateCache(renderer);
+            return true;
+        }
         const selectionKey = typeof buildSelectionKey === 'function'
             ? buildSelectionKey(module?.multiSelectedNodeIds || null, module?.selectedNodeIdJs || null)
             : '';
-        if (renderer._lastAppliedLodSelectionKey !== selectionKey) return true;
+        if (renderer._lastAppliedLodSelectionKey !== selectionKey) {
+            invalidateAnimatedGifCssFallbackCandidateCache(renderer);
+            return true;
+        }
         const usesCssImageFallbacks = renderer._shouldUseCssImageFallbackInResidentLod?.(module, lodBand) === true;
-        const usesAnimatedGifFallbacks = hasAnimatedGifCssFallbackCandidates(renderer, module, isAnimatedGifModel);
+        const usesAnimatedGifFallbacks = hasAnimatedGifCssFallbackCandidates(
+            renderer,
+            module,
+            isAnimatedGifModel,
+            selectionKey
+        );
         const fallbackCount = Number(renderer._lodImageCssFallbackNodeIds?.size || 0);
         if (!usesAnimatedGifFallbacks && fallbackCount <= 0) return false;
-        const activeFallbackCount = Number(renderer._getActiveCssMediaLodFallbackCount?.(module) || 0);
+        const activeFallbackCount = getActiveCssMediaFallbackCountCached(renderer, module);
         return (usesAnimatedGifFallbacks && activeFallbackCount <= 0) ||
             (fallbackCount > 0 && (!(usesCssImageFallbacks || usesAnimatedGifFallbacks) || activeFallbackCount <= 0));
     }
@@ -800,7 +1064,13 @@
         renderer._nearCssVisibleIds?.add?.(nodeId);
         if (record.kind === 'image') renderer._syncCssImageBodyBridge?.(entry, module);
         if (record.kind === 'video') globalThis.MindMapCss3DManager?.syncVideoNodeVisibilityPlayback?.(entry.model, cssObject, true);
-        renderer._lodImageCssFallbackNodeIds?.delete?.(nodeId);
+        if (typeof renderer._deleteLodImageCssFallbackNodeId === 'function') {
+            renderer._deleteLodImageCssFallbackNodeId(nodeId);
+        } else {
+            renderer._lodImageCssFallbackNodeIds?.delete?.(nodeId);
+            invalidateAnimatedGifCssFallbackCandidateCache(renderer);
+            invalidateActiveCssMediaFallbackCountCache(renderer);
+        }
         state.parked.delete(nodeId);
         renderer._residentCssRestoreCount = Number(renderer._residentCssRestoreCount || 0) + 1;
         module._css3dVisualChangedThisFrame = true;
@@ -1462,6 +1732,10 @@
             fullResCssFringeLayoutWarmCount: Number(renderer?._fullResCssFringeLayoutWarmCount || 0),
             residentStableLineReuseCount: Number(renderer?._residentStableLineReuseCount || 0),
             residentBoostClearCount: Number(renderer?._residentBoostClearCount || 0),
+            animatedGifFallbackCandidateScanCount: Number(renderer?._animatedGifFallbackCandidateScanCount || 0),
+            animatedGifFallbackCandidateCacheHitCount: Number(renderer?._animatedGifFallbackCandidateCacheHitCount || 0),
+            activeCssMediaFallbackCountScanCount: Number(renderer?._activeCssMediaFallbackCountScanCount || 0),
+            activeCssMediaFallbackCountCacheHitCount: Number(renderer?._activeCssMediaFallbackCountCacheHitCount || 0),
             lineTextureRows: Number(renderer?.lineTextureRows || 0),
             residentGpuWarmComplete: !!renderer &&
                 renderer._hasPendingImageAtlasWork?.() !== true &&
@@ -1487,6 +1761,9 @@
     window.MindMapRenderPlan = Object.freeze({
         configureImageAtlasTexture,
         getImageAtlasOutputColorChunk,
+        isRendererDprInteractionActive,
+        getCameraOnlyWebglBlockerMask,
+        getCameraOnlyWebglBlockerNames,
         syncCommittedResidentTextCount,
         clearFullResImageVisuals,
         buildFullResKey,
@@ -1506,6 +1783,11 @@
         reuseStableVisibleCss,
         reuseActiveCssMediaFallback,
         hasAnimatedGifCssFallbackCandidates,
+        invalidateAnimatedGifCssFallbackCandidateCache,
+        getActiveCssMediaFallbackCountCached,
+        invalidateActiveCssMediaFallbackCountCache,
+        markLodImageCssFallbacksChanged,
+        createTrackedLodImageCssFallbackSet,
         hasResidentDirtyWork,
         hasPendingNearCssWarmup,
         reusePreparedImageInstances,

package/wwwroot/_framework/blazor.boot.json

@@ -1,7 +1,7 @@
 {
   "mainAssemblyName": "MindExecution.Web",
   "resources": {
-    "hash": "sha256-k4lwKbjJ9g84j895BOdrv32i+eUyBH6giaTuE3n/Wks=",
+    "hash": "sha256-ozr0I9dILkt75rgHyhws29r5tPUaoSZNhR5IIMPzRmk=",
     "fingerprinting": {
       "Google.Protobuf.9h59ukbel7.dll": "Google.Protobuf.dll",
       "Markdig.d1j7v41cl1.dll": "Markdig.dll",
@@ -122,16 +122,16 @@
       "System.brmz7yk5qh.dll": "System.dll",
       "netstandard.b50t77veor.dll": "netstandard.dll",
       "System.Private.CoreLib.g6ztz7cmo2.dll": "System.Private.CoreLib.dll",
-      "MindExecution.Core.9h7x2mjn0w.dll": "MindExecution.Core.dll",
-      "MindExecution.Kernel.8te3ay3qs6.dll": "MindExecution.Kernel.dll",
-      "MindExecution.Plugins.Admin.imt43kggvu.dll": "MindExecution.Plugins.Admin.dll",
-      "MindExecution.Plugins.Business.26yozgyvan.dll": "MindExecution.Plugins.Business.dll",
-      "MindExecution.Plugins.Concept.k7fd1qvmfx.dll": "MindExecution.Plugins.Concept.dll",
-      "MindExecution.Plugins.Directory.88ng22x3y0.dll": "MindExecution.Plugins.Directory.dll",
-      "MindExecution.Plugins.PlanMaster.ll20yqlc09.dll": "MindExecution.Plugins.PlanMaster.dll",
-      "MindExecution.Plugins.YouTube.gqu5xngvav.dll": "MindExecution.Plugins.YouTube.dll",
-      "MindExecution.Shared.6ivt1fatt3.dll": "MindExecution.Shared.dll",
-      "MindExecution.Web.7tki7xqpt0.dll": "MindExecution.Web.dll",
+      "MindExecution.Core.sxhdhda5s2.dll": "MindExecution.Core.dll",
+      "MindExecution.Kernel.j8gyjmvupu.dll": "MindExecution.Kernel.dll",
+      "MindExecution.Plugins.Admin.91tk6u6ry5.dll": "MindExecution.Plugins.Admin.dll",
+      "MindExecution.Plugins.Business.b7h6v1eygj.dll": "MindExecution.Plugins.Business.dll",
+      "MindExecution.Plugins.Concept.i2zgmkmpwv.dll": "MindExecution.Plugins.Concept.dll",
+      "MindExecution.Plugins.Directory.r6is6647n2.dll": "MindExecution.Plugins.Directory.dll",
+      "MindExecution.Plugins.PlanMaster.s95n9skblk.dll": "MindExecution.Plugins.PlanMaster.dll",
+      "MindExecution.Plugins.YouTube.33l2m0y23q.dll": "MindExecution.Plugins.YouTube.dll",
+      "MindExecution.Shared.hvehzbzkt7.dll": "MindExecution.Shared.dll",
+      "MindExecution.Web.krui41i71h.dll": "MindExecution.Web.dll",
       "dotnet.native.566r55w3xu.js": "dotnet.native.js",
       "dotnet.native.x6q5aixc38.wasm": "dotnet.native.wasm",
       "dotnet.js": "dotnet.js",
@@ -276,18 +276,18 @@
       "System.Xml.XDocument.sn51jas17n.dll": "sha256-GNI2kFgFmPTwzuzwUn8gxK+AzGLUWRJFdg9JzIbrybQ=",
       "System.brmz7yk5qh.dll": "sha256-CfM2miyj1KHApFmqMdLYWio3S/jrdON2pW9Xr2nTwlo=",
       "netstandard.b50t77veor.dll": "sha256-//jQGOXjb8ET8WtXgOJrAxLx6E7zDJ5RjRRutwkvmxo=",
-      "MindExecution.Core.9h7x2mjn0w.dll": "sha256-4xFFMH5EUob9RXyohd+joGOoBTaarjSHyzY5kx3PRew=",
-      "MindExecution.Kernel.8te3ay3qs6.dll": "sha256-RND/bkb6ILP8m7z9LRP827D9tNbpZLIKIcrd5uzm8/w=",
-      "MindExecution.Plugins.Business.26yozgyvan.dll": "sha256-BhpTZtrJq26NpvKtYqHfYLKf2pJ93U0/R7WiPZMSedc=",
-      "MindExecution.Plugins.Concept.k7fd1qvmfx.dll": "sha256-QEcnhJgU5OshztWG/haRRIbg3NnykUuI0vEYkx2d9rU=",
-      "MindExecution.Plugins.PlanMaster.ll20yqlc09.dll": "sha256-KWcHEcj5l+QAGZXfxf7DCnyH1ACHwBwSVCgRReQPvyc=",
-      "MindExecution.Shared.6ivt1fatt3.dll": "sha256-Qp5kQWJBgQ7XXBot/X/66cV19jqiEwUFLd9b20Oamgw=",
-      "MindExecution.Web.7tki7xqpt0.dll": "sha256-JVtnGWCckZKnsid5V7G/01xTp3mnhCwxl112V16RTCg="
+      "MindExecution.Core.sxhdhda5s2.dll": "sha256-EIG5k0LEruwTjYF7YvBuQE7fvA8PjNqrVdVmBFoT3Es=",
+      "MindExecution.Kernel.j8gyjmvupu.dll": "sha256-swEZF4B89KFSR41x8negm6EC2/0mUl04DC1OcftiXAs=",
+      "MindExecution.Plugins.Business.b7h6v1eygj.dll": "sha256-aeAydGWzKaSuHiyUC3J7DaAJadTFaA6+nH4FKQDw53s=",
+      "MindExecution.Plugins.Concept.i2zgmkmpwv.dll": "sha256-dqQfhEjHX5uUJGT9Mg7NBoR6acPw7mgNL8Kj3W0AOm4=",
+      "MindExecution.Plugins.PlanMaster.s95n9skblk.dll": "sha256-kOyfHalRgMqdg46kBYFgiCX658udoDuwVM9q0rRKFjM=",
+      "MindExecution.Shared.hvehzbzkt7.dll": "sha256-jaQX0/pCtCVVmjc1lhP4/7cjTOZEuRs1N6d411G2eQQ=",
+      "MindExecution.Web.krui41i71h.dll": "sha256-QHRGgfNtxRcpVgYCkRu8CAnDoOEPMxl5fO03/4xitbQ="
     },
     "lazyAssembly": {
-      "MindExecution.Plugins.Admin.imt43kggvu.dll": "sha256-Bt7O2MFpDgzgB7CeUA4tB79feUGJiGvR7Zh4fUcGY+U=",
-      "MindExecution.Plugins.Directory.88ng22x3y0.dll": "sha256-mDOSQlu0aRlQ+9xQUmvcZAazdUkU4IFbPZ4yJjCegxs=",
-      "MindExecution.Plugins.YouTube.gqu5xngvav.dll": "sha256-KJg4t8mJDtKx8ElI66yv4H9Uw04BKb2g1d2RddYYhBk="
+      "MindExecution.Plugins.Admin.91tk6u6ry5.dll": "sha256-/e3ID1fHcTs61cU4k7Xis6qyq280i5dMBV1VxEzlB/U=",
+      "MindExecution.Plugins.Directory.r6is6647n2.dll": "sha256-E+nM/owGe41raBzurfDs4uNfmMFCtzXBt9cLv5ckr8Y=",
+      "MindExecution.Plugins.YouTube.33l2m0y23q.dll": "sha256-wbIiPGdzKEfUXoG42y0fT3HqEIenHcIo9vYY4y/SAVM="
     }
   },
   "cacheBootResources": true,

package/wwwroot/index.html

@@ -4,9 +4,13 @@
 <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>MindExec | Business Execution OS for solo builders</title>
-    <meta name="description" content="MindExec is an AI business execution OS for solo builders who want to turn notes, research, assets, and repeatable execution Skills into revenue-producing work." />
-    <base href="/" />
+    <title>MindExec | Business Execution OS for solo builders</title>
+    <meta name="description" content="MindExec is an AI business execution OS for solo builders who want to turn notes, research, assets, and repeatable execution Skills into revenue-producing work." />
+    <base href="/" />
+    <meta name="theme-color" content="#071a36" />
+    <link rel="icon" type="image/png" sizes="32x32" href="/mindexec-favicon-v2.png" />
+    <link rel="apple-touch-icon" sizes="180x180" href="apple-touch-icon.png?v=20260728-app-icon-v1" />
+    <link rel="manifest" href="manifest.webmanifest?v=20260728-app-icon-v1" />
     <link rel="stylesheet" href="_content/MindExecution.Shared/css/app.css?v=20260629-ai-task-flow-v863" />
     <link rel="stylesheet" href="_content/MindExecution.Shared/css/mind-map-overrides.css?v=20260629-mdm-shadow-v856" />
     <!-- ??좎뜦堉??Font Awesome (local) ??좎뜦堉??-->
@@ -579,7 +583,7 @@
             }
 
             const base = '_content/MindExecution.Shared/js/';
-            const scriptVersion = '20260727-world-grid-spotlight-v953';
+            const scriptVersion = '20260728-camera-render-policy-v961';
             const scriptUrl = (script) => `${base}${script}?v=${scriptVersion}`;
             console.log(`[Script Loader] Shared JS version: ${scriptVersion}`);
             const criticalScripts = [

package/wwwroot/manifest.webmanifest

@@ -1,22 +1,24 @@
 {
   "name": "MindExec",
   "short_name": "MindExec",
-  "id": "./",
-  "start_url": "./",
-  "display": "standalone",
-  "background_color": "#ffffff",
-  "theme_color": "#03173d",
-  "prefer_related_applications": false,
-  "icons": [
-    {
-      "src": "icon-512.png",
-      "type": "image/png",
-      "sizes": "512x512"
-    },
-    {
-      "src": "icon-192.png",
-      "type": "image/png",
-      "sizes": "192x192"
-    }
-  ]
-}
+  "id": "./",
+  "start_url": "./",
+  "display": "standalone",
+  "background_color": "#071a36",
+  "theme_color": "#071a36",
+  "prefer_related_applications": false,
+  "icons": [
+    {
+      "src": "icon-512.png?v=20260728-app-icon-v1",
+      "type": "image/png",
+      "sizes": "512x512",
+      "purpose": "any maskable"
+    },
+    {
+      "src": "icon-192.png?v=20260728-app-icon-v1",
+      "type": "image/png",
+      "sizes": "192x192",
+      "purpose": "any maskable"
+    }
+  ]
+}