@mindexec/cli 0.2.308 → 0.2.310

package/package.json

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

package/server.js

@@ -1871,6 +1871,135 @@ async function getRegisteredLocalFile(id) {
     return normalizedId ? localFileRegistry.get(normalizedId) || null : null;
 }
 
+function decodeAssetRequestPath(rawPath) {
+    let value = String(rawPath || '').trim();
+    if (!value) {
+        return { requestPath: '', isThumbs: false };
+    }
+
+    try {
+        if (/^https?:\/\//i.test(value)) {
+            value = new URL(value).pathname;
+        }
+    } catch {
+        // Keep the original value and let the path safety checks reject it if needed.
+    }
+
+    value = value.split(/[?#]/)[0].replaceAll('\\', '/');
+    const lower = value.toLowerCase();
+    const thumbsMarker = '/assets/thumbs/';
+    const assetsMarker = '/assets/';
+    let isThumbs = false;
+    const thumbsIndex = lower.indexOf(thumbsMarker);
+    const assetsIndex = lower.indexOf(assetsMarker);
+
+    if (thumbsIndex >= 0) {
+        value = value.slice(thumbsIndex + thumbsMarker.length);
+        isThumbs = true;
+    } else if (assetsIndex >= 0) {
+        value = value.slice(assetsIndex + assetsMarker.length);
+    }
+
+    try {
+        value = decodeURIComponent(value);
+    } catch {
+        // A malformed escape sequence should not crash the bridge.
+    }
+
+    return {
+        requestPath: value.replace(/^\/+/, ''),
+        isThumbs
+    };
+}
+
+function encodeAssetUrlPath(relativePath) {
+    return normalizePathForClient(relativePath)
+        .replace(/^\/+/, '')
+        .split('/')
+        .filter(Boolean)
+        .map(segment => encodeURIComponent(segment))
+        .join('/');
+}
+
+async function resolveAssetPathForRequest(normalizedRequestPath, options = {}) {
+    const requestPath = String(normalizedRequestPath || '').replace(/^\/+/, '');
+    if (!requestPath) {
+        return { status: 'missing', resolvedPath: null };
+    }
+
+    const isThumbs = options.thumbs === true;
+    const primaryAssetsDir = getAssetsPath();
+    const legacyAssetsDir = path.join(workspacePath, 'assets');
+    const primaryDir = isThumbs ? path.join(primaryAssetsDir, 'thumbs') : primaryAssetsDir;
+    const legacyDir = isThumbs ? path.join(legacyAssetsDir, 'thumbs') : legacyAssetsDir;
+    const primaryPath = path.resolve(primaryDir, requestPath);
+    const legacyPath = path.resolve(legacyDir, requestPath);
+
+    const candidates = [];
+    if (isPathWithin(primaryDir, primaryPath)) {
+        candidates.push(primaryPath);
+    }
+    if (isPathWithin(legacyDir, legacyPath)) {
+        candidates.push(legacyPath);
+    }
+
+    if (candidates.length === 0) {
+        return { status: 'forbidden', resolvedPath: null };
+    }
+
+    let resolvedPath = await findFirstAccessiblePath(candidates);
+    if (!resolvedPath) {
+        resolvedPath = await findFileByStem(
+            [primaryDir, legacyDir],
+            requestPath,
+            isThumbs
+                ? ['.jpg', '.jpeg', '.webp', '.png']
+                : ['.png', '.jpg', '.jpeg', '.webp', '.gif', '.bmp', '.svg', '.mp4', '.webm', '.mov']
+        );
+    }
+
+    if (!resolvedPath && isThumbs) {
+        resolvedPath = await findFileByStem(
+            [primaryAssetsDir, legacyAssetsDir],
+            requestPath,
+            ['.png', '.jpg', '.jpeg', '.webp', '.gif', '.bmp']
+        );
+    }
+
+    return {
+        status: resolvedPath ? 'found' : 'missing',
+        resolvedPath
+    };
+}
+
+app.get('/api/assets/resolve', async (req, res) => {
+    const decoded = decodeAssetRequestPath(req.query?.path || req.query?.url || '');
+    if (!decoded.requestPath) {
+        return res.json({
+            exists: false,
+            reason: 'empty-path'
+        });
+    }
+
+    const result = await resolveAssetPathForRequest(decoded.requestPath, {
+        thumbs: decoded.isThumbs
+    });
+
+    if (result.status === 'forbidden') {
+        return res.status(403).json({
+            exists: false,
+            reason: 'forbidden'
+        });
+    }
+
+    const urlPath = encodeAssetUrlPath(decoded.requestPath);
+    return res.json({
+        exists: result.status === 'found',
+        url: `/${decoded.isThumbs ? 'assets/thumbs' : 'assets'}/${urlPath}`,
+        path: decoded.requestPath
+    });
+});
+
 // Static file serving for assets (direct image loading - bypasses base64 encoding)
 // This allows browsers to directly fetch images via http://127.0.0.1:5147/assets/filename.png
 app.use('/assets', async (req, res, next) => {

package/wwwroot/_content/MindExecution.Shared/css/mind-map-overrides.css

@@ -1484,17 +1484,36 @@ html.mindcanvas-platform-apple .css3d-resolution-wrapper.is-automation-relation-
 
 .mind-map-text-overlay-v2-card.is-passive {
     pointer-events: none;
-    /* CSS3D owns card background/edge; passive overlay only contributes
-       readable text fragments and must never paint over CSS3D node chrome. */
+    /* Passive overlay paints screen-space chrome for text-like nodes so the
+       user does not see CSS3D's camera-scaled hard card edge in NEAR. */
     contain: layout style;
     overflow: visible;
-    background: transparent !important;
-    background-color: transparent !important;
+    background: rgba(255, 255, 255, 0.985) !important;
+    background-color: rgba(255, 255, 255, 0.985) !important;
     background-image: none !important;
+    border: 1px solid rgba(55, 65, 81, 0.28) !important;
+    box-shadow: 0 1px 2px rgba(15, 23, 42, 0.05) !important;
+    border-radius: 2px !important;
+    outline: none !important;
+}
+
+.mind-map-text-overlay-v2-card.is-passive[data-content-type="memo"],
+.mind-map-text-overlay-v2-card.is-passive[data-content-type="note"] {
+    border-color: rgba(55, 65, 81, 0.18) !important;
+    border-radius: 6px !important;
+}
+
+.mind-map-text-overlay-v2-card.is-passive[data-content-type="code"],
+.mind-map-text-overlay-v2-card.is-passive[data-content-type="text"],
+.mind-map-text-overlay-v2-card.is-passive[data-content-type="markdown"] {
+    border-radius: 1px !important;
 }
 
 .mind-map-text-overlay-v2-card.is-passive .mind-map-text-overlay-v2-body {
     pointer-events: auto;
+    text-rendering: auto;
+    -webkit-font-smoothing: auto;
+    -moz-osx-font-smoothing: auto;
 }
 
 .mind-map-text-overlay-v2-shell {
@@ -2042,6 +2061,20 @@ html.mindcanvas-platform-apple .css3d-resolution-wrapper.is-automation-relation-
     caret-color: transparent !important;
 }
 
+.css3d-resolution-wrapper.mind-map-v2-source-suspended:not(.node-type-image):not(.node-type-video):not(.node-type-embed),
+.css3d-resolution-wrapper.mind-map-v2-source-suspended:not(.node-type-image):not(.node-type-video):not(.node-type-embed) > .map-node,
+.css3d-resolution-wrapper.mind-map-v2-source-suspended:not(.node-type-image):not(.node-type-video):not(.node-type-embed) > .map-node-bubble,
+.css3d-resolution-wrapper.mind-map-v2-source-suspended:not(.node-type-image):not(.node-type-video):not(.node-type-embed) > .map-node-note,
+.css3d-resolution-wrapper.mind-map-v2-source-suspended:not(.node-type-image):not(.node-type-video):not(.node-type-embed) > .map-node-code,
+.css3d-resolution-wrapper.mind-map-v2-source-suspended:not(.node-type-image):not(.node-type-video):not(.node-type-embed) > .map-node-memo:not(.map-node-agent):not(.map-node-automation) {
+    background: transparent !important;
+    background-color: transparent !important;
+    background-image: none !important;
+    border-color: transparent !important;
+    outline-color: transparent !important;
+    box-shadow: none !important;
+}
+
 .css3d-resolution-wrapper.node-type-image .mind-map-v2-source-suspended,
 .css3d-resolution-wrapper.node-type-video .mind-map-v2-source-suspended,
 .css3d-resolution-wrapper.node-type-embed .mind-map-v2-source-suspended,

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

@@ -5,7 +5,7 @@
     const DEBUG = false;
     const FPS_DEBUG = false;
     const FRAME_PERF_DEBUG = false;
-    const MINDMAP_CORE_BUILD_ID = '20260621-video-prefetch-v785';
+    const MINDMAP_CORE_BUILD_ID = '20260621-asset-resolve-overlay-v793';
     const CanvasPhase = Object.freeze({
         Booting: 'booting',
         BoardFileLoading: 'board-file-loading',
@@ -77,7 +77,7 @@
     });
     const CanvasPhaseSet = new Set(Object.values(CanvasPhase));
     const VIEWPORT_METRICS_POLL_INTERVAL = 480;
-    const PASSIVE_DOM_OVERLAY_RUNTIME_ENABLED = false;
+    const PASSIVE_DOM_OVERLAY_RUNTIME_ENABLED = true;
     const PASSIVE_OVERLAY_ZOOM_DEFER_VISIBLE_THRESHOLD = 24;
     const PASSIVE_OVERLAY_INTERACTIVE_REFRESH_INTERVAL_MS = 48;
     const PASSIVE_OVERLAY_INTERACTIVE_DENSE_REFRESH_INTERVAL_MS = 72;
@@ -1131,6 +1131,7 @@
         enableDomOverlay: true,
         enablePassiveOverlayForVisibleNodes: true,
         enableOverlayCssZoom: true,
+        enableSharedNodeViewOverlay: true,
         enableVisibilityCulling: true,
         enableLodUpdate: true,
         enableWebglRender: true,
@@ -9023,6 +9024,16 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
                 const overlayV2State = useTextOverlayV2 && shouldTrackTextOverlayDirty
                     ? (this._textOverlayV2State || null)
                     : null;
+                let hasVisibleOverlayV2Card = false;
+                if (overlayV2State?.cards?.forEach) {
+                    overlayV2State.cards.forEach(card => {
+                        if (hasVisibleOverlayV2Card || !card || card.style.display === 'none') {
+                            return;
+                        }
+
+                        hasVisibleOverlayV2Card = true;
+                    });
+                }
                 const hasOverlayV2DirtyState = !!(
                     overlayV2State && (
                         overlayV2State.dirtyLayout === true ||
@@ -9033,6 +9044,12 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
                 );
                 const hasOverlayFocus = hasFocusedTextOverlay || hasEditingOverlay;
                 const hasMotionBlockingOverlayFocus = hasEditingOverlay;
+                const shouldCleanupInactivePassiveOverlay =
+                    useTextOverlayV2 &&
+                    hasVisibleOverlayV2Card === true &&
+                    shouldRenderPassiveDomTextOverlay !== true &&
+                    hasLiveInteractiveDomOverlay !== true &&
+                    !hasOverlayFocus;
                 const visibleOverlayCount = isPassiveDomOverlayRuntimeEnabled
                     ? Math.max(
                         Number(this._visibleIds?.size || 0),
@@ -9563,7 +9580,7 @@ ${summaryLines.map(line => `<div>${escapeNodeFrameDebugHtml(line)}</div>`).join(
                 const shouldSyncTextOverlays =
                     effectiveOverlayDirty === true ||
                     (useTextOverlayV2
-                        ? (hasOverlayV2DirtyState || shouldRefreshPassiveDomTextOverlay || shouldFinalizePassiveOverlayLayout || (hasMotionBlockingOverlayFocus && shouldUpdateCss3d))
+                        ? (hasOverlayV2DirtyState || shouldCleanupInactivePassiveOverlay || shouldRefreshPassiveDomTextOverlay || shouldFinalizePassiveOverlayLayout || (hasMotionBlockingOverlayFocus && shouldUpdateCss3d))
                         : (hasMotionBlockingOverlayFocus && shouldUpdateCss3d));
                 const shouldAttemptPassiveOverlayCameraFastPath =
                     useTextOverlayV2 &&

package/wwwroot/_content/MindExecution.Shared/js/mind-map-css3d-manager.js

@@ -27,14 +27,21 @@
     let _cssImagePromotionTimer = 0;
     let _cssImageBlobUrlCache = new Map();
     let _cssImageBlobUrlPending = new Map();
+    let _cssImageMissingLoopbackUrls = new Set();
     let _cssVideoBlobUrlCache = new Map();
     let _cssVideoBlobUrlPending = new Map();
+    let _cssVideoMissingLoopbackUrls = new Set();
+    let _cssLoopbackAssetResolveCache = new Map();
+    let _cssLoopbackAssetResolvePending = new Map();
     let _cssImageDisplayQueue = [];
     let _cssImageDisplayActiveCount = 0;
     let _cssImageDisplayPumpScheduled = false;
     const CSS_VIDEO_PROXY_MAX_DEVICE_PIXEL_RATIO = 2;
     const VIDEO_PLAYBACK_INTENT_METADATA_KEY = 'VideoPlaybackIntent';
     const CSV_TABLE_CONTENT_TYPE = 'csv-table';
+    const NODE_VIEW_HOST_CSS3D = 'css3d';
+    const NODE_VIEW_HOST_OVERLAY = 'overlay';
+    const NODE_VIEW_RENDERER_VERSION = 'shared-node-view-v1';
     const CSV_TABLE_MAX_RENDER_ROWS = 500;
     const CSV_TABLE_MAX_RENDER_COLUMNS = 80;
     const REMOTE_FLEET_DISPLAY_NAME = 'Multi Desktop Monitor';
@@ -1653,6 +1660,92 @@
         return LOOPBACK_ASSET_URL_REGEX.test(String(url || '').trim());
     }
 
+    function getCssLoopbackAssetResolveUrl(targetUrl) {
+        const normalized = normalizeCssMediaUrl(targetUrl);
+        if (!normalized || !isLoopbackCssAssetUrl(normalized)) {
+            return '';
+        }
+
+        try {
+            const currentOrigin = window?.location?.origin || '';
+            if (!currentOrigin) {
+                return '';
+            }
+
+            const target = new URL(normalized, window?.location?.href || currentOrigin);
+            return `${currentOrigin}/api/assets/resolve?path=${encodeURIComponent(target.pathname)}`;
+        } catch {
+            return '';
+        }
+    }
+
+    async function resolveLoopbackCssAssetUrl(targetUrl, mediaKind = 'asset') {
+        const normalized = normalizeCssMediaUrl(targetUrl);
+        if (!normalized || !isLoopbackCssAssetUrl(normalized)) {
+            return normalized;
+        }
+
+        const cached = _cssLoopbackAssetResolveCache.get(normalized);
+        if (cached) {
+            if (cached.exists === false) {
+                throw new Error(`Loopback ${mediaKind} asset was already reported missing`);
+            }
+            return normalizeCssMediaUrl(cached.url || normalized) || normalized;
+        }
+
+        const existingPending = _cssLoopbackAssetResolvePending.get(normalized);
+        if (existingPending) {
+            return await existingPending;
+        }
+
+        const resolveUrl = getCssLoopbackAssetResolveUrl(normalized);
+        if (!resolveUrl) {
+            return normalized;
+        }
+
+        const pending = (async () => {
+            const response = await fetch(resolveUrl, {
+                cache: 'no-store',
+                targetAddressSpace: 'loopback'
+            });
+
+            if (response.status === 404) {
+                // Older LocalBridge builds do not expose the resolver. Keep the
+                // previous direct asset path so existing installations still work.
+                return normalized;
+            }
+
+            if (!response.ok) {
+                throw new Error(`Asset resolve HTTP ${response.status}`);
+            }
+
+            const payload = await response.json().catch(() => null);
+            if (!payload || payload.exists !== true) {
+                _cssLoopbackAssetResolveCache.set(normalized, {
+                    exists: false,
+                    url: normalized
+                });
+                throw new Error(`Loopback ${mediaKind} asset is missing`);
+            }
+
+            const resolvedUrl = normalizeCssMediaUrl(payload.url || normalized) || normalized;
+            _cssLoopbackAssetResolveCache.set(normalized, {
+                exists: true,
+                url: resolvedUrl
+            });
+            return resolvedUrl;
+        })();
+
+        _cssLoopbackAssetResolvePending.set(normalized, pending);
+        try {
+            return await pending;
+        } finally {
+            if (_cssLoopbackAssetResolvePending.get(normalized) === pending) {
+                _cssLoopbackAssetResolvePending.delete(normalized);
+            }
+        }
+    }
+
     function shouldAttachCssMediaAuthorization(targetUrl, authToken) {
         const token = typeof authToken === 'string' ? authToken.trim() : '';
         if (!token) {
@@ -3565,6 +3658,10 @@
             return normalized;
         }
 
+        if (_cssImageMissingLoopbackUrls.has(normalized)) {
+            throw new Error('Loopback image asset was already reported missing');
+        }
+
         const cached = _cssImageBlobUrlCache.get(normalized);
         if (cached?.objectUrl) {
             touchCssImageBlobCacheEntry(normalized, cached);
@@ -3577,8 +3674,19 @@
         }
 
         const pendingFetch = (async () => {
-            const response = await fetch(normalized, getCssMediaFetchOptions(normalized));
+            let resolvedAssetUrl = normalized;
+            try {
+                resolvedAssetUrl = await resolveLoopbackCssAssetUrl(normalized, 'image');
+            } catch (error) {
+                _cssImageMissingLoopbackUrls.add(normalized);
+                throw error;
+            }
+
+            const response = await fetch(resolvedAssetUrl, getCssMediaFetchOptions(resolvedAssetUrl));
             if (!response.ok) {
+                if (response.status === 404) {
+                    _cssImageMissingLoopbackUrls.add(normalized);
+                }
                 throw new Error(`HTTP ${response.status}`);
             }
 
@@ -3622,6 +3730,10 @@
             return normalized;
         }
 
+        if (_cssVideoMissingLoopbackUrls.has(normalized)) {
+            throw new Error('Loopback video asset was already reported missing');
+        }
+
         const cached = _cssVideoBlobUrlCache.get(normalized);
         if (cached?.objectUrl) {
             touchCssVideoBlobCacheEntry(normalized, cached);
@@ -3634,8 +3746,19 @@
         }
 
         const pendingFetch = (async () => {
-            const response = await fetch(normalized, getCssMediaFetchOptions(normalized));
+            let resolvedAssetUrl = normalized;
+            try {
+                resolvedAssetUrl = await resolveLoopbackCssAssetUrl(normalized, 'video');
+            } catch (error) {
+                _cssVideoMissingLoopbackUrls.add(normalized);
+                throw error;
+            }
+
+            const response = await fetch(resolvedAssetUrl, getCssMediaFetchOptions(resolvedAssetUrl));
             if (!response.ok) {
+                if (response.status === 404) {
+                    _cssVideoMissingLoopbackUrls.add(normalized);
+                }
                 throw new Error(`HTTP ${response.status}`);
             }
 
@@ -3726,6 +3849,16 @@
                 return false;
             }
 
+            if (isLoopbackCssAssetUrl(normalized)) {
+                mediaEl.dataset.resolvedMediaSourceUrl = '';
+                mediaEl.removeAttribute('src');
+                if (mediaEl.tagName === 'IMG') {
+                    mediaEl.dataset.mediaReady = '0';
+                    mediaEl.style.opacity = '0';
+                }
+                return false;
+            }
+
             const currentDisplaySource = String(mediaEl.getAttribute('src') || '').trim();
             if (currentDisplaySource !== normalized) {
                 mediaEl.setAttribute('src', normalized);
@@ -23061,6 +23194,136 @@
     }
     // ▲▲▲ [New] ▲▲▲
 
+    function getNodeViewContentInfo(nodeModel) {
+        const contentTypeLower = String(nodeModel?.contentType ?? nodeModel?.ContentType ?? '').toLowerCase();
+        const remoteFleetMonitor = isRemoteFleetMonitorNode(nodeModel);
+        const visualContentTypeLower = remoteFleetMonitor ? 'templatelauncher' : contentTypeLower;
+        const isMediaNode = contentTypeLower === 'image' || contentTypeLower === 'video' || contentTypeLower === 'embed';
+
+        return {
+            contentTypeLower,
+            remoteFleetMonitor,
+            visualContentTypeLower,
+            isMediaNode
+        };
+    }
+
+    function shouldCreateDynamicNodeView(nodeModel, info = getNodeViewContentInfo(nodeModel)) {
+        if (info.remoteFleetMonitor) {
+            return true;
+        }
+
+        const dynamicTypes = ['text', 'markdown', 'code', 'note', 'memo', CSV_TABLE_CONTENT_TYPE, 'templatelauncher', 'image', 'video', 'embed'];
+        return dynamicTypes.includes(info.contentTypeLower);
+    }
+
+    function shouldBypassNodeViewTemplate(nodeModel, info = getNodeViewContentInfo(nodeModel)) {
+        if (info.remoteFleetMonitor) {
+            return true;
+        }
+
+        return info.contentTypeLower === 'text'
+            || info.contentTypeLower === 'markdown'
+            || info.contentTypeLower === 'note'
+            || info.contentTypeLower === 'memo'
+            || info.contentTypeLower === CSV_TABLE_CONTENT_TYPE
+            || info.contentTypeLower === 'templatelauncher'
+            || info.contentTypeLower === 'image'
+            || info.contentTypeLower === 'video'
+            || info.contentTypeLower === 'embed';
+    }
+
+    function createNodeViewElement(module, nodeModel, options = {}) {
+        if (module) {
+            _module = module;
+        }
+
+        const nodeId = getNodeId(nodeModel);
+        if (!nodeId) {
+            return null;
+        }
+
+        const hostKind = String(options.hostKind || NODE_VIEW_HOST_CSS3D).trim().toLowerCase() || NODE_VIEW_HOST_CSS3D;
+        const info = getNodeViewContentInfo(nodeModel);
+        const templateId = `node-${nodeId}`;
+        let templateElement = document.getElementById(templateId);
+
+        if (shouldBypassNodeViewTemplate(nodeModel, info)) {
+            templateElement = null;
+        }
+
+        let isDynamicallyCreated = false;
+        if (!templateElement) {
+            if (shouldCreateDynamicNodeView(nodeModel, info)) {
+                log(`[MindMapCss3DManager] Creating shared NodeView DOM for ${info.visualContentTypeLower || info.contentTypeLower} node ${nodeId} (${hostKind})`);
+                templateElement = createDynamicNodeElement(nodeModel);
+                isDynamicallyCreated = true;
+            } else {
+                if (!window._templateWarningCount) window._templateWarningCount = 0;
+                if (window._templateWarningCount < 5) {
+                    warn(`[MindMapCss3DManager] Template not found for node ${nodeId} (async templates pending). Template ID: ${templateId}`);
+                    window._templateWarningCount++;
+                    if (window._templateWarningCount === 5) {
+                        warn('[MindMapCss3DManager] ... suppressing further template warnings. Templates will be available after async render.');
+                    }
+                }
+                return null;
+            }
+        }
+
+        const width = Number(nodeModel.width || nodeModel.Width || 400);
+        const height = Number(nodeModel.height || nodeModel.Height || 200);
+        const allowsExternalNodeChrome = allowsNodeExternalChrome(nodeModel);
+        const allowsExternalMemoChrome =
+            info.contentTypeLower === 'memo'
+            && allowsExternalNodeChrome;
+        const element = isDynamicallyCreated
+            ? templateElement
+            : templateElement.cloneNode(true);
+        const idPrefix = String(options.idPrefix || (hostKind === NODE_VIEW_HOST_OVERLAY ? 'node-view-overlay' : 'css3d-node')).trim();
+        const resolutionScale = Math.max(1, Number(options.resolutionScale || getCss3dNodeResolutionScale(info.contentTypeLower) || 1));
+
+        element.id = `${idPrefix}-${nodeId}`;
+        element.dataset.nodeId = nodeId;
+        element.dataset.nodeViewHost = hostKind;
+        element.dataset.nodeViewRenderer = NODE_VIEW_RENDERER_VERSION;
+        element.dataset.contentType = info.visualContentTypeLower || info.contentTypeLower || '';
+        element.style.overflow = allowsExternalNodeChrome ? 'visible' : 'hidden';
+        if (allowsExternalNodeChrome) {
+            element.style.contain = 'layout style';
+            element.style.contentVisibility = 'visible';
+            element.style.containIntrinsicSize = 'auto';
+        }
+        element.style.display = '';
+        element.style.transformOrigin = '0% 0%';
+        applyCss3dResolutionLayout(element, width, height, resolutionScale, {
+            resetLayoutTransform: true
+        });
+        element.style.borderRadius = '0px';
+        element.style.position = 'absolute';
+        element.style.left = '0px';
+        element.style.top = '0px';
+        element.style.transition = 'none';
+        element.style.webkitTransition = 'none';
+        element.style.willChange = 'auto';
+        element.style.backfaceVisibility = 'visible';
+
+        return {
+            element,
+            width,
+            height,
+            contentTypeLower: info.contentTypeLower,
+            visualContentTypeLower: info.visualContentTypeLower,
+            isMediaNode: info.isMediaNode,
+            isDynamicallyCreated,
+            allowsExternalNodeChrome,
+            allowsExternalMemoChrome,
+            resolutionScale,
+            hostKind,
+            rendererVersion: NODE_VIEW_RENDERER_VERSION
+        };
+    }
+
     function appendCss3dResizeHitZones(wrapper, nodeModel) {
         if (!(wrapper instanceof HTMLElement) || !nodeModel?.id) {
             return;
@@ -23134,7 +23397,8 @@
             return null;
         }
 
-        const templateId = `node-${nodeModel.id}`;
+        const resolvedNodeId = getNodeId(nodeModel);
+        const templateId = `node-${resolvedNodeId}`;
         let templateElement = document.getElementById(templateId);
 
         // ▼▼▼ [New] 템플릿이 없으면 동적으로 생성 (text/markdown 타입용) ▼▼▼
@@ -23164,14 +23428,14 @@
             const dynamicTypes = ['text', 'markdown', 'code', 'note', 'memo', CSV_TABLE_CONTENT_TYPE, 'templatelauncher', 'image', 'video', 'embed'];
 
             if (remoteFleetMonitor || dynamicTypes.includes(contentTypeLower)) {
-                log(`[MindMapCss3DManager] Creating dynamic DOM element for ${visualContentTypeLower || contentTypeLower} node ${nodeModel.id}`);
-                templateElement = createDynamicNodeElement(nodeModel);
+                log(`[MindMapCss3DManager] Deferring dynamic DOM element for ${visualContentTypeLower || contentTypeLower} node ${resolvedNodeId} to shared NodeView`);
+                templateElement = document.createElement('div');
                 isDynamicallyCreated = true;
             } else {
                 // 경고 로그 제한 (초기 로딩 시 템플릿이 아직 렌더링되지 않은 경우 스팸 방지)
                 if (!window._templateWarningCount) window._templateWarningCount = 0;
                 if (window._templateWarningCount < 5) {
-                    warn(`[MindMapCss3DManager] Template not found for node ${nodeModel.id} (async templates pending). Template ID: ${templateId}`);
+                    warn(`[MindMapCss3DManager] Template not found for node ${resolvedNodeId} (async templates pending). Template ID: ${templateId}`);
                     window._templateWarningCount++;
                     if (window._templateWarningCount === 5) {
                         warn(`[MindMapCss3DManager] ... suppressing further template warnings. Templates will be available after async render.`);
@@ -23182,11 +23446,11 @@
         }
         // ▲▲▲ [New] ▲▲▲
 
-        const existingCss3dId = `css3d-node-${nodeModel.id}`;
-        const nodeEntry = module.nodeObjectsById.get(nodeModel.id);
+        const existingCss3dId = `css3d-node-${resolvedNodeId}`;
+        const nodeEntry = module.nodeObjectsById.get(resolvedNodeId);
 
         if (nodeEntry && nodeEntry.cssObject) {
-            warn(`[MindMapCss3DManager] CSS3D object already exists in memory for node ${nodeModel.id}. Returning existing object.`);
+            warn(`[MindMapCss3DManager] CSS3D object already exists in memory for node ${resolvedNodeId}. Returning existing object.`);
             return nodeEntry.cssObject;
         }
 
@@ -23210,18 +23474,22 @@
         */
         // ▲▲▲ [Critical fix] ▲▲▲
 
-        const width = Number(nodeModel.width || 400);
-        const height = Number(nodeModel.height || 200);
-        const isMediaNode = contentTypeLower === 'image' || contentTypeLower === 'video' || contentTypeLower === 'embed';
-        const allowsExternalNodeChrome = allowsNodeExternalChrome(nodeModel);
-        const allowsExternalMemoChrome =
-            contentTypeLower === 'memo'
-            && allowsExternalNodeChrome;
-        const clonedElement = isDynamicallyCreated
-            ? templateElement
-            : templateElement.cloneNode(true);
-        clonedElement.id = `css3d-node-${nodeModel.id}`;
-        clonedElement.dataset.nodeId = nodeModel.id;
+        const nodeView = createNodeViewElement(module, nodeModel, {
+            hostKind: NODE_VIEW_HOST_CSS3D,
+            idPrefix: 'css3d-node'
+        });
+        if (!nodeView?.element) {
+            return null;
+        }
+
+        const width = nodeView.width;
+        const height = nodeView.height;
+        const isMediaNode = nodeView.isMediaNode;
+        const allowsExternalNodeChrome = nodeView.allowsExternalNodeChrome;
+        const allowsExternalMemoChrome = nodeView.allowsExternalMemoChrome;
+        const clonedElement = nodeView.element;
+        clonedElement.id = `css3d-node-${resolvedNodeId}`;
+        clonedElement.dataset.nodeId = resolvedNodeId;
         clonedElement.style.overflow = allowsExternalNodeChrome ? 'visible' : 'hidden';
         if (allowsExternalNodeChrome) {
             clonedElement.style.contain = 'layout style';
@@ -23232,7 +23500,7 @@
         clonedElement.style.transformOrigin = '0% 0%';
 
         // ▼▼▼ [Clarity] Scale factor for high-resolution rendering ▼▼▼
-        const resolutionScale = getCss3dNodeResolutionScale(contentTypeLower);
+        const resolutionScale = nodeView.resolutionScale;
         applyCss3dResolutionLayout(clonedElement, width, height, resolutionScale, {
             resetLayoutTransform: true
         });
@@ -23265,7 +23533,7 @@
         wrapper.style.minHeight = `${height * resolutionScale}px`;
         wrapper.style.maxWidth = `${width * resolutionScale}px`;
         wrapper.style.maxHeight = `${height * resolutionScale}px`;
-        wrapper.dataset.nodeId = nodeModel.id;
+        wrapper.dataset.nodeId = resolvedNodeId;
         wrapper.style.transition = CSS3D_WRAPPER_TRANSITION;
         wrapper.style.webkitTransition = CSS3D_WRAPPER_WEBKIT_TRANSITION;
 
@@ -23369,7 +23637,7 @@
         const css3dObj = new CSS3DObjectCtor(wrapper);
         css3dObj.scale.set(1 / resolutionScale, 1 / resolutionScale, 1 / resolutionScale);
         css3dObj.visible = false;
-        css3dObj.userData.nodeId = nodeModel.id;
+        css3dObj.userData.nodeId = resolvedNodeId;
         css3dObj.userData.worldWidth = width;
         css3dObj.userData.worldHeight = height;
         css3dObj.userData.resolutionScale = resolutionScale;
@@ -23387,7 +23655,7 @@
         // ▲▲▲ [Fix] ▲▲▲
 
         requestAnimationFrame(() => {
-            syncCss3dScrollFromModel(module, nodeModel.id, {
+            syncCss3dScrollFromModel(module, resolvedNodeId, {
                 source: 'createCss3dObject'
             });
         });
@@ -23728,7 +23996,7 @@
                             void resolveLocalCssMediaSource(mediaEl, nodeModel, contentTypeLower);
                         } else {
                             delete mediaEl.dataset.videoCanvasProxyFailed;
-                            mediaEl.src = content;
+                            void setCssVideoElementSource(mediaEl, nodeModel, content, { load: true });
                         }
                         if (contentTypeLower === 'video' &&
                             mediaEl.dataset?.lodMediaSuspended !== 'true' &&
@@ -24178,6 +24446,7 @@
         clearSelectableTextOverlay: clearSelectableTextOverlay,
         clearNativeTextSelectionSource: clearNativeTextSelectionSource,
         createCss3dObject: createCss3dObject,
+        createNodeViewElement: createNodeViewElement,
         createEditingOverlayContent: createEditingOverlayContent,
         clearEditingOverlay: clearEditingOverlay,
         getTextInteractionContentSelectors: getTextInteractionContentSelectors,

package/wwwroot/_content/MindExecution.Shared/js/mind-map-lod-renderer.js

@@ -51,7 +51,7 @@
     // ▲▲▲ [Usage] ▲▲▲
 
     // Procedural line rendering settings
-const LOD_RENDERER_BUILD_ID = '20260621-video-prefetch-v785';
+    const LOD_RENDERER_BUILD_ID = '20260621-asset-resolve-overlay-v793';
     const DirtyKind = Object.freeze({
         ResidentFullRebuild: 'resident-full-rebuild',
         ResidentPatch: 'resident-patch',
@@ -4482,13 +4482,41 @@ const LOD_RENDERER_BUILD_ID = '20260621-video-prefetch-v785';
             }
         }
 
+        _restoreVisibleCss3dHighDetailForNear(nodeObjectsById, module, lodBand) {
+            if (lodBand !== 'NEAR' || !nodeObjectsById) {
+                return 0;
+            }
+
+            let restoredCount = 0;
+            for (const entry of nodeObjectsById.values()) {
+                const cssElement = entry?.cssObject?.element || null;
+                if (!cssElement ||
+                    entry.cssObject?.visible !== true ||
+                    cssElement.style.display === 'none' ||
+                    !cssElement.classList?.contains?.('lod-low')) {
+                    continue;
+                }
+
+                this._setCss3dLodClass(entry, true);
+                restoredCount++;
+            }
+
+            if (restoredCount > 0 && module) {
+                module._css3dVisualChangedThisFrame = true;
+                module._css3dVisualChangedSinceLastRender = true;
+            }
+
+            return restoredCount;
+        }
+
         _shouldUseHighCss3dDetail(entry, module) {
             const cameraZ = Number(module?.camera?.position?.z || 0);
-            const lodBand = this._currentLodBand || getLodBandForCameraZ(cameraZ);
-            if (lodBand === 'NEAR') {
+            const cameraBand = getLodBandForCameraZ(cameraZ);
+            if (cameraBand === 'NEAR') {
                 return true;
             }
 
+            const lodBand = this._currentLodBand || cameraBand;
             const nodeId = String(entry?.model?.id || entry?.model?.Id || entry?.glObject?.userData?.nodeId || '').trim();
             const selectedNodeId = String(module?.selectedNodeIdJs || module?.selectedNodeId || '').trim();
             if (nodeId && selectedNodeId && nodeId === selectedNodeId) {
@@ -6010,6 +6038,7 @@ const LOD_RENDERER_BUILD_ID = '20260621-video-prefetch-v785';
                 // ▼▼▼ [Fix] Keep CSS3D visibility synced while panning in near mode ▼▼▼
                 if (!this.isInLODMode) {
                     this._currentLodBand = lodBand;
+                    this._restoreVisibleCss3dHighDetailForNear(nodeObjectsById, module, lodBand);
                     const visibleIds = this._getNearVisibleIds(module);
                     if (!visibleIds || visibleIds.size === 0) {
                         perfTime('fullResHandoff', () => {

package/wwwroot/_content/MindExecution.Shared/js/mind-map-text-overlay-v2.js

@@ -2,7 +2,7 @@
     'use strict';
 
     const DEBUG = false;
-    const PASSIVE_DOM_OVERLAY_ENABLED = false;
+    const PASSIVE_DOM_OVERLAY_ENABLED = true;
     const DEFAULT_OVERLAY_SCROLLABLE_SELECTOR = '.node-response, .note-content, .markdown-body, .prose, .note-textarea, .code-body, .code-content, .pdf-content, .text-content, .file-content, .map-node-memo__body, .map-node-memo__body-view, .map-node-memo__agent-plan-body, .map-node-memo__agent-console-body, pre, code';
     const PASSIVE_OVERLAY_NEAR_EXIT_GRACE_MS = 220;
     const PASSIVE_OVERLAY_CANDIDATE_GRACE_MS = 160;
@@ -336,7 +336,7 @@
             state.passiveNearStickyUntil = 0;
         }
 
-        return hasVisibleLiveInteractiveOverlayCandidate(module);
+        return false;
     }
 
     function shouldUseVisiblePassiveOverlayCandidates(module) {
@@ -956,10 +956,6 @@
             return false;
         }
 
-        if (entry && supportsTextOverlayEntry(entry)) {
-            return false;
-        }
-
         return true;
     }
 
@@ -1298,6 +1294,29 @@
         return Math.max(baseZIndex, candidate + baseZIndex);
     }
 
+    function getDevicePixelRatio() {
+        const dpr = Number(globalThis?.devicePixelRatio || 1);
+        return Number.isFinite(dpr) && dpr > 0 ? Math.min(4, Math.max(1, dpr)) : 1;
+    }
+
+    function snapScreenPixel(value, dpr = getDevicePixelRatio()) {
+        const numeric = Number(value || 0);
+        if (!Number.isFinite(numeric)) {
+            return 0;
+        }
+
+        return Math.round(numeric * dpr) / dpr;
+    }
+
+    function snapScreenLength(value, dpr = getDevicePixelRatio()) {
+        const numeric = Number(value || 0);
+        if (!Number.isFinite(numeric)) {
+            return 1;
+        }
+
+        return Math.max(1 / dpr, Math.round(Math.max(1 / dpr, numeric) * dpr) / dpr);
+    }
+
     function applyPlacement(module, element, rect, zIndex, entry = null) {
         if (!module || !element || !rect) {
             return;
@@ -1305,8 +1324,13 @@
 
         const baseWidth = Math.max(1, Number(rect.baseWidth || rect.width || 1));
         const baseHeight = Math.max(1, Number(rect.baseHeight || rect.height || 1));
-        const scaleX = Number(rect.width || baseWidth) / baseWidth;
-        const scaleY = Number(rect.height || baseHeight) / baseHeight;
+        const dpr = getDevicePixelRatio();
+        const left = snapScreenPixel(rect.left || 0, dpr);
+        const top = snapScreenPixel(rect.top || 0, dpr);
+        const width = snapScreenLength(rect.width || baseWidth || 1, dpr);
+        const height = snapScreenLength(rect.height || baseHeight || 1, dpr);
+        const scaleX = width / baseWidth;
+        const scaleY = height / baseHeight;
         const preferCssZoom = shouldPreferOverlayCssZoom(module, entry);
         const canUseZoom =
             preferCssZoom &&
@@ -1318,10 +1342,10 @@
         const shell = element.firstElementChild || null;
 
         element.style.display = 'block';
-        element.style.left = `${Number(rect.left || 0)}px`;
-        element.style.top = `${Number(rect.top || 0)}px`;
-        element.style.width = `${Math.max(1, Number(rect.width || baseWidth || 1))}px`;
-        element.style.height = `${Math.max(1, Number(rect.height || baseHeight || 1))}px`;
+        element.style.left = `${left}px`;
+        element.style.top = `${top}px`;
+        element.style.width = `${width}px`;
+        element.style.height = `${height}px`;
         element.style.transform = '';
         element.style.zoom = '';
         applyScrollbarScaleCompensation(element, scaleX, scaleY);
@@ -1336,14 +1360,18 @@
             applyScrollbarScaleCompensation(shell, scaleX, scaleY);
 
             if (canUseZoom) {
-                shell.style.zoom = `${scaleX}`;
+                shell.style.zoom = `${Math.max(0.01, Math.round(scaleX * 100000) / 100000)}`;
                 module._overlayDebugPlacementZoomCount = Number(module._overlayDebugPlacementZoomCount || 0) + 1;
             } else {
-                shell.style.transform = `scale(${scaleX}, ${scaleY})`;
+                const snappedScaleX = Math.max(0.01, Math.round(scaleX * 100000) / 100000);
+                const snappedScaleY = Math.max(0.01, Math.round(scaleY * 100000) / 100000);
+                shell.style.transform = `scale(${snappedScaleX}, ${snappedScaleY})`;
                 module._overlayDebugPlacementTransformCount = Number(module._overlayDebugPlacementTransformCount || 0) + 1;
             }
         } else if (!canUseZoom) {
-            element.style.transform = `scale(${scaleX}, ${scaleY})`;
+            const snappedScaleX = Math.max(0.01, Math.round(scaleX * 100000) / 100000);
+            const snappedScaleY = Math.max(0.01, Math.round(scaleY * 100000) / 100000);
+            element.style.transform = `scale(${snappedScaleX}, ${snappedScaleY})`;
             module._overlayDebugPlacementTransformCount = Number(module._overlayDebugPlacementTransformCount || 0) + 1;
         }
         element.style.zIndex = String(resolveOverlayZIndex(entry, zIndex));
@@ -2823,6 +2851,77 @@
         return finalizeReadonlySourceClone(module, sourceRoot, preparedClone, type, interactive, { renderMode: renderMode });
     }
 
+    function shouldUseSharedNodeViewOverlay(module, entry, mode) {
+        if (module?.renderDebugFlags?.enableSharedNodeViewOverlay === false) {
+            return false;
+        }
+
+        const type = getContentType(entry);
+        const normalizedMode = String(mode || '').trim().toLowerCase();
+        return normalizedMode === 'full'
+            || type === 'text'
+            || type === 'markdown'
+            || type === 'note'
+            || type === 'code'
+            || type === CSV_TABLE_CONTENT_TYPE;
+    }
+
+    function createReadonlyOverlayFromNodeView(module, entry, options = {}) {
+        const manager = getCss3dManager();
+        const model = getModel(entry);
+        if (!manager?.createNodeViewElement || !model) {
+            return null;
+        }
+
+        const sourceRoot = options.sourceRoot || getReadonlySelectionSourceRoot(entry);
+        if (!sourceRoot) {
+            return null;
+        }
+
+        const type = getContentType(entry);
+        const interactive = options.interactive === true;
+        const renderMode = String(options.renderMode || getReadonlySelectionMode(entry) || type || '').trim().toLowerCase();
+        if (!shouldUseSharedNodeViewOverlay(module, entry, renderMode)) {
+            return null;
+        }
+
+        const nodeView = manager.createNodeViewElement(module, model, {
+            hostKind: 'overlay',
+            idPrefix: 'node-view-overlay',
+            readonly: true
+        });
+        const nodeViewRoot = nodeView?.element || null;
+        if (!nodeViewRoot) {
+            return null;
+        }
+
+        nodeViewRoot.classList.add('mind-map-text-overlay-v2-node-view-source');
+        nodeViewRoot.style.position = 'relative';
+        nodeViewRoot.style.left = '0px';
+        nodeViewRoot.style.top = '0px';
+        nodeViewRoot.style.pointerEvents = 'none';
+
+        const preparedRoot = prepareOverlayClone(nodeViewRoot);
+        if (!preparedRoot) {
+            return null;
+        }
+
+        const finalized = finalizeReadonlySourceClone(module, sourceRoot, preparedRoot, type, interactive, {
+            renderMode: 'node-view'
+        });
+        if (!finalized?.container) {
+            return null;
+        }
+
+        finalized.container.dataset.overlaySource = 'node-view';
+        finalized.container.dataset.nodeViewRenderer = nodeView.rendererVersion || 'shared-node-view-v1';
+        return {
+            ...finalized,
+            sourceRoot,
+            nodeViewSource: true
+        };
+    }
+
     function getRelativeFragmentPlacement(hostElement, sourceElement, hostBaseWidth, hostBaseHeight) {
         if (!hostElement || !sourceElement) {
             return null;
@@ -3094,7 +3193,10 @@
             // Passive readonly overlays only need the text surface.
             // Keep card chrome/background/borders in CSS3D to avoid duplicate
             // painting and reduce DOM work during zoom/pan.
-            return createReadonlyContentOnlyShell(module, entry, options);
+            return createReadonlyOverlayFromNodeView(module, entry, {
+                ...options,
+                renderMode: mode
+            }) || createReadonlyContentOnlyShell(module, entry, options);
         }
 
         return null;

package/wwwroot/_content/MindExecution.Shared/js/mind-map-texture-factory.js

@@ -15,6 +15,8 @@
     const renderers = new Map();
     const failedImageAssetCache = new Map();
     const pendingImageAssetFetches = new Map();
+    const imageAssetResolveCache = new Map();
+    const pendingImageAssetResolves = new Map();
     let sharedMeasurer = null;
 
     function getSharedMeasurer() {
@@ -91,6 +93,99 @@
             .test(String(url || '').trim());
     }
 
+    function getImageAssetResolveUrl(targetUrl) {
+        const normalized = normalizeImageAssetUrl(targetUrl);
+        if (!normalized || !isLoopbackImageAssetUrl(normalized)) {
+            return '';
+        }
+
+        try {
+            const currentOrigin = window?.location?.origin || '';
+            if (!currentOrigin) {
+                return '';
+            }
+
+            const target = new URL(normalized, window?.location?.href || currentOrigin);
+            return `${currentOrigin}/api/assets/resolve?path=${encodeURIComponent(target.pathname)}`;
+        } catch {
+            return '';
+        }
+    }
+
+    async function resolveLoopbackImageAssetUrl(targetUrl) {
+        const normalized = normalizeImageAssetUrl(targetUrl);
+        if (!normalized || !isLoopbackImageAssetUrl(normalized)) {
+            return normalized;
+        }
+
+        const cached = imageAssetResolveCache.get(normalized);
+        if (cached) {
+            if (cached.exists === false) {
+                const error = new Error('Loopback image asset is missing');
+                error.status = 404;
+                error.url = normalized;
+                throw error;
+            }
+            return normalizeImageAssetUrl(cached.url || normalized) || normalized;
+        }
+
+        const existingPending = pendingImageAssetResolves.get(normalized);
+        if (existingPending) {
+            return await existingPending;
+        }
+
+        const resolveUrl = getImageAssetResolveUrl(normalized);
+        if (!resolveUrl) {
+            return normalized;
+        }
+
+        const pending = (async () => {
+            const response = await fetch(resolveUrl, {
+                cache: 'no-store',
+                targetAddressSpace: 'loopback'
+            });
+
+            if (response.status === 404) {
+                return normalized;
+            }
+
+            if (!response.ok) {
+                const error = new Error(`Asset resolve HTTP ${response.status}`);
+                error.status = response.status;
+                error.url = normalized;
+                throw error;
+            }
+
+            const payload = await response.json().catch(() => null);
+            if (!payload || payload.exists !== true) {
+                imageAssetResolveCache.set(normalized, {
+                    exists: false,
+                    url: normalized
+                });
+                const error = new Error('Loopback image asset is missing');
+                error.status = 404;
+                error.url = normalized;
+                throw error;
+            }
+
+            const resolvedUrl = normalizeImageAssetUrl(payload.url || normalized) || normalized;
+            imageAssetResolveCache.set(normalized, {
+                exists: true,
+                url: resolvedUrl
+            });
+            return resolvedUrl;
+        })();
+
+        pendingImageAssetResolves.set(normalized, pending);
+        try {
+            return await pending;
+        } finally {
+            if (pendingImageAssetResolves.get(normalized) === pending) {
+                pendingImageAssetResolves.delete(normalized);
+            }
+        }
+    }
+
     function shouldAttachImageAssetAuthorization(targetUrl, authToken) {
         const token = typeof authToken === 'string' ? authToken.trim() : '';
         if (!token) {
@@ -1839,7 +1934,10 @@
             return Object.keys(requestOptions).length > 0 ? requestOptions : undefined;
         };
 
-        const fetchWithAuth = (targetUrl) => fetch(targetUrl, getFetchOptions(targetUrl));
+        const fetchWithAuth = async (targetUrl) => {
+            const resolvedTargetUrl = await resolveLoopbackImageAssetUrl(targetUrl);
+            return fetch(resolvedTargetUrl, getFetchOptions(resolvedTargetUrl));
+        };
         const fetchBlobWithAuth = async (targetUrl) => {
             const requestKey = getImageAssetErrorCacheKey(targetUrl) || normalizeImageAssetUrl(targetUrl);
             if (!requestKey) {

package/wwwroot/_framework/blazor.boot.json

@@ -1,7 +1,7 @@
 {
   "mainAssemblyName": "MindExecution.Web",
   "resources": {
-    "hash": "sha256-YgJcRsTo1IPvOdBuYHz3Mkio500xFMYOisAGvpYEHik=",
+    "hash": "sha256-YIk9DX4DKiZTExQMveGB2um1rjSUq/+iCFtZzwItvUg=",
     "fingerprinting": {
       "Google.Protobuf.9h59ukbel7.dll": "Google.Protobuf.dll",
       "Markdig.d1j7v41cl1.dll": "Markdig.dll",
@@ -131,7 +131,7 @@
       "MindExecution.Plugins.Directory.ju87t8h3zs.dll": "MindExecution.Plugins.Directory.dll",
       "MindExecution.Plugins.PlanMaster.krn3jgvjpa.dll": "MindExecution.Plugins.PlanMaster.dll",
       "MindExecution.Plugins.YouTube.5m53srfud6.dll": "MindExecution.Plugins.YouTube.dll",
-      "MindExecution.Shared.rv3rw2h14g.dll": "MindExecution.Shared.dll",
+      "MindExecution.Shared.74msadwmew.dll": "MindExecution.Shared.dll",
       "MindExecution.Web.82k6ktlkfg.dll": "MindExecution.Web.dll",
       "dotnet.js": "dotnet.js",
       "dotnet.native.qc8g39g30v.js": "dotnet.native.js",
@@ -283,7 +283,7 @@
       "MindExecution.Plugins.Business.nyr3v25v48.dll": "sha256-T4c7+fDE4TQAXAoFmHnYM+tT7RSvAM7W0VinLPoD+6U=",
       "MindExecution.Plugins.Concept.l9z9tx9svt.dll": "sha256-N/QoILmTilvX5Zo4SCy7ENTCqMzSC6RIEQlEwtxkGPo=",
       "MindExecution.Plugins.PlanMaster.krn3jgvjpa.dll": "sha256-8IFpm/2fpsWD3syyl58LTSWSGC8PfcrsLdmmSKR1Sq0=",
-      "MindExecution.Shared.rv3rw2h14g.dll": "sha256-ZwT/+Wjs0ZoDe3XZwwDlkPwo7xexhoK1RcyI2rEiywY=",
+      "MindExecution.Shared.74msadwmew.dll": "sha256-93zoKe74n9ZSDo3yiXxg1tAOzOaCbuapATS84OHGoNU=",
       "MindExecution.Web.82k6ktlkfg.dll": "sha256-ECPSyJrziGEVhCw8ZUXkRsfTDjWCk676m5yz99b13N4="
     },
     "lazyAssembly": {

package/wwwroot/index.html

@@ -7,8 +7,8 @@
     <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="/" />
-    <link rel="stylesheet" href="_content/MindExecution.Shared/css/app.css?v=20260621-video-prefetch-v785" />
-    <link rel="stylesheet" href="_content/MindExecution.Shared/css/mind-map-overrides.css?v=20260621-video-prefetch-v785" />
+    <link rel="stylesheet" href="_content/MindExecution.Shared/css/app.css?v=20260621-asset-resolve-overlay-v793" />
+    <link rel="stylesheet" href="_content/MindExecution.Shared/css/mind-map-overrides.css?v=20260621-asset-resolve-overlay-v793" />
     <!-- ??좎뜦堉??Font Awesome (local) ??좎뜦堉??-->
     <link rel="stylesheet" href="_content/MindExecution.Shared/lib/font-awesome/css/all.min.css" />
     <!-- ??좎뜦堉??-->
@@ -579,7 +579,7 @@
             }
 
             const base = '_content/MindExecution.Shared/js/';
-        const scriptVersion = '20260621-video-prefetch-v785';
+        const scriptVersion = '20260621-asset-resolve-overlay-v793';
             const scriptUrl = (script) => `${base}${script}?v=${scriptVersion}`;
             console.log(`[Script Loader] Shared JS version: ${scriptVersion}`);
             const criticalScripts = [

package/wwwroot/service-worker-assets.js

@@ -1,5 +1,5 @@
 self.assetsManifest = {
-    "version":  "jBFdtOmP",
+    "version":  "dFWDosxV",
     "assets":  [
                    {
                        "hash":  "sha256-+CSYMcqLNTsq3VnH11jgYyOCCdxvHzL74CBmo4sCmMU=",
@@ -42,7 +42,7 @@
                        "url":  "_content/MindExecution.Shared/css/app.css"
                    },
                    {
-                       "hash":  "sha256-QyE+9OXJBCXf5eXHuMaxnGjVAMIuQr72tNhfSCk6nro=",
+                       "hash":  "sha256-ha65+2w0xEoB2Mo1nEHyp7RzEI399tRfJqk2UVmQ49w=",
                        "url":  "_content/MindExecution.Shared/css/mind-map-overrides.css"
                    },
                    {
@@ -78,7 +78,7 @@
                        "url":  "_content/MindExecution.Shared/js/marked.min.js"
                    },
                    {
-                       "hash":  "sha256-bcZumly3UqFp3yXp94h51Uect2dFJXYGVRKxtJkh4HE=",
+                       "hash":  "sha256-F1INYfbVbuItU+haAmKD4slfzCEglpC7GqIV/cU0oEw=",
                        "url":  "_content/MindExecution.Shared/js/mind-map-core.js"
                    },
                    {
@@ -86,7 +86,7 @@
                        "url":  "_content/MindExecution.Shared/js/mind-map-core.js.backup"
                    },
                    {
-                       "hash":  "sha256-1hnC4MKgwN6Nsz5+5t3Kjy6m/3kfaI7QNMFKaS8H/hA=",
+                       "hash":  "sha256-vNc3xxIK/8spAKK8PmqcgHnFrXO/i2QWu1rC8MjdHgY=",
                        "url":  "_content/MindExecution.Shared/js/mind-map-css3d-manager.js"
                    },
                    {
@@ -114,7 +114,7 @@
                        "url":  "_content/MindExecution.Shared/js/mind-map-lod-plan-worker.js"
                    },
                    {
-                       "hash":  "sha256-btpizB1MkhK5bRl7BmaL4+ZNHh2bZrg160eaiBbzRy8=",
+                       "hash":  "sha256-PzCyPbFR/WA4fkMLgladZPjcf5UoNR+APa6cSvkxa84=",
                        "url":  "_content/MindExecution.Shared/js/mind-map-lod-renderer.js"
                    },
                    {
@@ -154,11 +154,11 @@
                        "url":  "_content/MindExecution.Shared/js/mind-map-text-lod-system.js"
                    },
                    {
-                       "hash":  "sha256-pEdLlTuNhb8coOCRcx1fX+xLyD8ATKxwR8CXupgbgtk=",
+                       "hash":  "sha256-+6Qe/8m04tQbsF7EQVM/v93sHAh6rjjN1btiNOe9EnQ=",
                        "url":  "_content/MindExecution.Shared/js/mind-map-text-overlay-v2.js"
                    },
                    {
-                       "hash":  "sha256-rXMMiOLaRGM1Dzp+IuVTVGJIQCVrr8apnByC4RmpbIQ=",
+                       "hash":  "sha256-uWZUzao/aNpU3SD4jtCVFMrTaGYtCAOAO6lxNt5UL1g=",
                        "url":  "_content/MindExecution.Shared/js/mind-map-texture-factory.js"
                    },
                    {
@@ -442,8 +442,8 @@
                        "url":  "_framework/MindExecution.Plugins.YouTube.5m53srfud6.dll"
                    },
                    {
-                       "hash":  "sha256-ZwT/+Wjs0ZoDe3XZwwDlkPwo7xexhoK1RcyI2rEiywY=",
-                       "url":  "_framework/MindExecution.Shared.rv3rw2h14g.dll"
+                       "hash":  "sha256-93zoKe74n9ZSDo3yiXxg1tAOzOaCbuapATS84OHGoNU=",
+                       "url":  "_framework/MindExecution.Shared.74msadwmew.dll"
                    },
                    {
                        "hash":  "sha256-ECPSyJrziGEVhCw8ZUXkRsfTDjWCk676m5yz99b13N4=",
@@ -770,7 +770,7 @@
                        "url":  "_framework/Websocket.Client.vapounvmnl.dll"
                    },
                    {
-                       "hash":  "sha256-/y7nWgvIiQwrfUfw4xVQPgcy9m78NRMdMq8TbflUDDI=",
+                       "hash":  "sha256-nQRvRaM/ZyOgFFU3k4VFcn5RCxxhN4uAIHf5Y+jHaLI=",
                        "url":  "_framework/blazor.boot.json"
                    },
                    {
@@ -834,7 +834,7 @@
                        "url":  "image-manifest.json"
                    },
                    {
-                       "hash":  "sha256-mvQ5z9xIyVIoYzxOcaAL8lUhs30CGFe2NcbVq3Wa0AU=",
+                       "hash":  "sha256-ZabWv7pPxmz7GAn1Da2AWSY8HrUnVVLo9oSmmHDOG2c=",
                        "url":  "index.html"
                    },
                    {

package/wwwroot/service-worker.js

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