@mindexec/cli 0.2.309 → 0.2.311

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.309",
+  "version": "0.2.311",
   "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

@@ -2061,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-near-lod-pixel-snap-v790';
+    const MINDMAP_CORE_BUILD_ID = '20260621-nodeview-host-policy-v794';
     const CanvasPhase = Object.freeze({
         Booting: 'booting',
         BoardFileLoading: 'board-file-loading',
@@ -1131,6 +1131,8 @@
         enableDomOverlay: true,
         enablePassiveOverlayForVisibleNodes: true,
         enableOverlayCssZoom: true,
+        enableSharedNodeViewOverlay: true,
+        preferOverlayNodeViewHost: false,
         enableVisibilityCulling: true,
         enableLodUpdate: true,
         enableWebglRender: true,

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

@@ -27,14 +27,22 @@
     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_HOST_HYBRID = 'hybrid';
+    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 +1661,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 +3659,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 +3675,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 +3731,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 +3747,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 +3850,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 +23195,183 @@
     }
     // ▲▲▲ [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 normalizeNodeViewHost(value, fallback = NODE_VIEW_HOST_CSS3D) {
+        const normalized = String(value || '').trim().toLowerCase();
+        if (normalized === NODE_VIEW_HOST_CSS3D ||
+            normalized === NODE_VIEW_HOST_OVERLAY ||
+            normalized === NODE_VIEW_HOST_HYBRID) {
+            return normalized;
+        }
+
+        return fallback;
+    }
+
+    function getNodeViewPrimaryHost(module = _module) {
+        const flags = module?.renderDebugFlags || {};
+        const explicit = normalizeNodeViewHost(flags.nodeViewPrimaryHost, '');
+        if (explicit) {
+            return explicit;
+        }
+
+        return flags.preferOverlayNodeViewHost === true
+            ? NODE_VIEW_HOST_OVERLAY
+            : NODE_VIEW_HOST_CSS3D;
+    }
+
+    function getNodeViewHostPolicy(module, nodeModel, options = {}) {
+        const requestedHost = normalizeNodeViewHost(options.hostKind, NODE_VIEW_HOST_CSS3D);
+        const primaryHost = getNodeViewPrimaryHost(module);
+        const info = getNodeViewContentInfo(nodeModel);
+        const overlayPrimary = primaryHost === NODE_VIEW_HOST_OVERLAY;
+        const hybridPrimary = primaryHost === NODE_VIEW_HOST_HYBRID;
+
+        return {
+            rendererVersion: NODE_VIEW_RENDERER_VERSION,
+            requestedHost,
+            primaryHost,
+            effectiveHost: requestedHost,
+            isCss3dPrimary: primaryHost === NODE_VIEW_HOST_CSS3D || hybridPrimary,
+            isOverlayPrimary: overlayPrimary,
+            isHybridPrimary: hybridPrimary,
+            useSharedOverlay: module?.renderDebugFlags?.enableSharedNodeViewOverlay !== false,
+            supportsNodeView: shouldCreateDynamicNodeView(nodeModel, info) || !shouldBypassNodeViewTemplate(nodeModel, info),
+            contentTypeLower: info.contentTypeLower,
+            visualContentTypeLower: info.visualContentTypeLower
+        };
+    }
+
+    function createNodeViewElement(module, nodeModel, options = {}) {
+        if (module) {
+            _module = module;
+        }
+
+        const nodeId = getNodeId(nodeModel);
+        if (!nodeId) {
+            return null;
+        }
+
+        const hostPolicy = getNodeViewHostPolicy(module, nodeModel, options);
+        const hostKind = hostPolicy.effectiveHost;
+        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,
+            hostPolicy,
+            rendererVersion: NODE_VIEW_RENDERER_VERSION
+        };
+    }
+
     function appendCss3dResizeHitZones(wrapper, nodeModel) {
         if (!(wrapper instanceof HTMLElement) || !nodeModel?.id) {
             return;
@@ -23134,7 +23445,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 +23476,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 +23494,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 +23522,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 +23548,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 +23581,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 +23685,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 +23703,7 @@
         // ▲▲▲ [Fix] ▲▲▲
 
         requestAnimationFrame(() => {
-            syncCss3dScrollFromModel(module, nodeModel.id, {
+            syncCss3dScrollFromModel(module, resolvedNodeId, {
                 source: 'createCss3dObject'
             });
         });
@@ -23728,7 +24044,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 +24494,9 @@
         clearSelectableTextOverlay: clearSelectableTextOverlay,
         clearNativeTextSelectionSource: clearNativeTextSelectionSource,
         createCss3dObject: createCss3dObject,
+        createNodeViewElement: createNodeViewElement,
+        getNodeViewHostPolicy: getNodeViewHostPolicy,
+        getNodeViewPrimaryHost: getNodeViewPrimaryHost,
         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-near-lod-pixel-snap-v790';
+    const LOD_RENDERER_BUILD_ID = '20260621-nodeview-host-policy-v794';
     const DirtyKind = Object.freeze({
         ResidentFullRebuild: 'resident-full-rebuild',
         ResidentPatch: 'resident-patch',

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

@@ -2851,6 +2851,85 @@
         return finalizeReadonlySourceClone(module, sourceRoot, preparedClone, type, interactive, { renderMode: renderMode });
     }
 
+    function shouldUseSharedNodeViewOverlay(module, entry, mode) {
+        const manager = getCss3dManager();
+        const model = getModel(entry);
+        const policy = manager?.getNodeViewHostPolicy?.(module, model, { hostKind: 'overlay' }) || null;
+        if (policy?.useSharedOverlay === false || module?.renderDebugFlags?.enableSharedNodeViewOverlay === false) {
+            return false;
+        }
+
+        const type = getContentType(entry);
+        const normalizedMode = String(mode || '').trim().toLowerCase();
+        return policy?.isOverlayPrimary === true
+            || normalizedMode === 'full'
+            || type === 'text'
+            || type === 'markdown'
+            || type === 'note'
+            || type === 'memo'
+            || type === 'code'
+            || type === CSV_TABLE_CONTENT_TYPE;
+    }
+
+    function isOverlayPrimaryNodeViewHost(module, entry) {
+        const manager = getCss3dManager();
+        const model = getModel(entry);
+        const policy = manager?.getNodeViewHostPolicy?.(module, model, { hostKind: 'overlay' }) || null;
+        return policy?.isOverlayPrimary === true;
+    }
+
+    function createReadonlyOverlayFromNodeView(module, entry, options = {}) {
+        const manager = getCss3dManager();
+        const model = getModel(entry);
+        if (!manager?.createNodeViewElement || !model) {
+            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 sourceRoot = options.sourceRoot || getReadonlySelectionSourceRoot(entry) || nodeViewRoot;
+        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;
@@ -3115,14 +3194,20 @@
             // Memo headers collapse too easily when reconstructed from
             // independent fragments. Clone the canonical shell but strip the
             // visual chrome so CSS3D keeps ownership of card background/edge.
-            return createReadonlyMemoShellClone(module, entry, options);
+            return createReadonlyOverlayFromNodeView(module, entry, {
+                ...options,
+                renderMode: mode
+            }) || createReadonlyMemoShellClone(module, entry, options);
         }
 
         if (mode !== 'none') {
             // 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;
@@ -4216,11 +4301,14 @@
 
             const isSupported = interactive ? supportsSelection(entry) : supportsPassiveDisplay(entry);
             const canRenderFromSource = !!(entry?.cssObject?.element && entry.currentType === 'CSS' && entry.cssObject.visible);
+            const canRenderFromNodeViewHost = !interactive &&
+                isOverlayPrimaryNodeViewHost(module, entry) &&
+                isSupported;
             const canReuseExistingPassiveCard = !interactive &&
                 shouldRenderPassive &&
                 !!existingCard &&
                 existingCard.childElementCount > 0;
-            if (!entry || !isSupported || (!canRenderFromSource && !canReuseExistingPassiveCard)) {
+            if (!entry || !isSupported || (!canRenderFromSource && !canRenderFromNodeViewHost && !canReuseExistingPassiveCard)) {
                 hideCard(existingCard);
                 if (interactive) {
                     clearSelection(module, nodeId);
@@ -4230,7 +4318,7 @@
                 return;
             }
 
-            const forceRebuild = canRenderFromSource && state?.dirtyNodes?.has?.(nodeId) === true;
+            const forceRebuild = (canRenderFromSource || canRenderFromNodeViewHost) && state?.dirtyNodes?.has?.(nodeId) === true;
             const card = renderSelectionCard(module, entry, {
                 interactive: interactive,
                 forceRebuild: forceRebuild

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-D1kQwIGK/5ULx6Yo1WH3vsTRIzWc/7/k8RpSswCSqh4=",
     "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.ojp3psugsm.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.ojp3psugsm.dll": "sha256-FC0pE2bsyE9i7GNSXCghKULaYYZXUEdepb2VxPfcYaA=",
       "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-near-lod-pixel-snap-v790" />
-    <link rel="stylesheet" href="_content/MindExecution.Shared/css/mind-map-overrides.css?v=20260621-near-lod-pixel-snap-v790" />
+    <link rel="stylesheet" href="_content/MindExecution.Shared/css/app.css?v=20260621-nodeview-host-policy-v794" />
+    <link rel="stylesheet" href="_content/MindExecution.Shared/css/mind-map-overrides.css?v=20260621-nodeview-host-policy-v794" />
     <!-- ??좎뜦堉??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-near-lod-pixel-snap-v790';
+        const scriptVersion = '20260621-nodeview-host-policy-v794';
             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":  "qR19js7U",
+    "version":  "yv2PsIsP",
     "assets":  [
                    {
                        "hash":  "sha256-+CSYMcqLNTsq3VnH11jgYyOCCdxvHzL74CBmo4sCmMU=",
@@ -42,7 +42,7 @@
                        "url":  "_content/MindExecution.Shared/css/app.css"
                    },
                    {
-                       "hash":  "sha256-uUo6RfwT80RrRI95nGw6SISUrer/BE9+7P3yVivBYXQ=",
+                       "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-5WxowCqXOM5gcHZIaCotoNvWIC1paUc/UWdcQ0tqaXo=",
+                       "hash":  "sha256-wKghwA30YN9dfi92pXm49piiFewBTKC3qbNbi5Xnd+k=",
                        "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-m19Ex/iUFkKEfN82ioo9gB90TJKEIMs77mCnyk6oVoM=",
                        "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-Nct6u0jhFqOSEzDDBROMfhB4SvUw0yb2DK065toNffk=",
+                       "hash":  "sha256-x/0q02ck7cYzpzM8Imv2OIKtGY/o5/k5LyoVPCU5Xc0=",
                        "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-zGfIZ50rYA0nDkeMNB+wv2WRhssu6lHXb5ERwvLbcq4=",
+                       "hash":  "sha256-7wG4IolMJjOrSd1bOHKkXQ5t+Kz53EVo0hnmWfFY+xI=",
                        "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-FC0pE2bsyE9i7GNSXCghKULaYYZXUEdepb2VxPfcYaA=",
+                       "url":  "_framework/MindExecution.Shared.ojp3psugsm.dll"
                    },
                    {
                        "hash":  "sha256-ECPSyJrziGEVhCw8ZUXkRsfTDjWCk676m5yz99b13N4=",
@@ -770,7 +770,7 @@
                        "url":  "_framework/Websocket.Client.vapounvmnl.dll"
                    },
                    {
-                       "hash":  "sha256-/y7nWgvIiQwrfUfw4xVQPgcy9m78NRMdMq8TbflUDDI=",
+                       "hash":  "sha256-Flu3r26LvbLO2wUcZVQG1lKL/SCiMrzqzajuoIajSks=",
                        "url":  "_framework/blazor.boot.json"
                    },
                    {
@@ -834,7 +834,7 @@
                        "url":  "image-manifest.json"
                    },
                    {
-                       "hash":  "sha256-5IzHBpG6V4csffSXfPHWC7BKgybKjT61K0dk0XOOvWE=",
+                       "hash":  "sha256-1ogFlgItkavFXyCr6MK610wsv1X0dpjib/iK1tVMs5k=",
                        "url":  "index.html"
                    },
                    {

package/wwwroot/service-worker.js

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