@mindexec/cli 0.2.0

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

@@ -0,0 +1,4323 @@
+(function () {
+    'use strict';
+
+    const DEBUG = false;
+    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;
+    const PASSIVE_OVERLAY_VIEWPORT_PAD_PX = 32;
+    const PASSIVE_OVERLAY_CARD_LIMIT_DEFAULT = 28;
+    const PASSIVE_OVERLAY_CARD_LIMIT_DENSE = 20;
+    const PASSIVE_OVERLAY_CARD_LIMIT_VERY_SLOW = 12;
+    const PASSIVE_OVERLAY_FRAGMENT_WIDTH_BIAS_PX = 0;
+    const PASSIVE_OVERLAY_OVERLAP_MIN_PX = 2;
+    const PASSIVE_OVERLAY_OVERLAP_MIN_AREA_PX = 16;
+    const PASSIVE_OVERLAY_STACK_Z_SCALE = 10000;
+    const log = DEBUG ? console.log.bind(console, '[MindMapTextOverlayV2]') : () => { };
+    let _projCornerTopLeft = null;
+    let _projCornerTopRight = null;
+    let _projCornerBottomLeft = null;
+    let _projCornerBottomRight = null;
+
+    function ensureProjectionTemps() {
+        const THREERef = globalThis.THREE;
+        if (!THREERef) {
+            return null;
+        }
+
+        if (!_projCornerTopLeft) {
+            _projCornerTopLeft = new THREERef.Vector3();
+            _projCornerTopRight = new THREERef.Vector3();
+            _projCornerBottomLeft = new THREERef.Vector3();
+            _projCornerBottomRight = new THREERef.Vector3();
+        }
+
+        return THREERef;
+    }
+
+    function normalizeId(nodeId) {
+        return String(nodeId ?? '').trim();
+    }
+
+    function getModel(target) {
+        return target?.model || target || null;
+    }
+
+    function getNodeId(target) {
+        const model = getModel(target);
+        return normalizeId(model?.id ?? model?.Id);
+    }
+
+    function getContentType(target) {
+        const model = getModel(target);
+        return String(model?.contentType ?? model?.ContentType ?? '').trim().toLowerCase();
+    }
+
+    function isMediaOverlayExcluded(entry) {
+        const type = getContentType(entry);
+        return type === 'image' || type === 'video' || type === 'embed';
+    }
+
+    function getPrompt(target) {
+        const model = getModel(target);
+        return String(model?.prompt ?? model?.Prompt ?? '');
+    }
+
+    function getResponse(target) {
+        const model = getModel(target);
+        return String(model?.response ?? model?.Response ?? model?.content ?? model?.Content ?? '');
+    }
+
+    function getMetadata(target) {
+        const model = getModel(target);
+        return model?.metadata || model?.Metadata || {};
+    }
+
+    function getNodeSemanticType(target) {
+        const metadata = getMetadata(target);
+        const model = getModel(target);
+        return String(metadata?.SemanticType || metadata?.semanticType || model?.SemanticType || model?.semanticType || '').trim();
+    }
+
+    function isAgentStyledMemoEntry(entry) {
+        const semanticType = getNodeSemanticType(entry);
+        return semanticType === 'MindCanvasAgent'
+            || semanticType === 'AgentCommand'
+            || semanticType === 'BusinessAutomationNode';
+    }
+
+    function isDomOverlayDebugEnabled(module) {
+        return module?.renderDebugFlags?.enableDomOverlay !== false;
+    }
+
+    function isEnabled(module) {
+        return module?.useTextOverlayV2 === true && isDomOverlayDebugEnabled(module);
+    }
+
+    function nowMs() {
+        if (typeof performance !== 'undefined' && typeof performance.now === 'function') {
+            return performance.now();
+        }
+
+        return Date.now();
+    }
+
+    function getCss3dManager() {
+        return window.MindMapCss3DManager || null;
+    }
+
+    function supportsTextOverlayEntry(entry) {
+        const manager = getCss3dManager();
+        const model = getModel(entry);
+        if (manager?.supportsTextOverlay) {
+            return manager.supportsTextOverlay(model);
+        }
+
+        const type = getContentType(entry);
+        return type === 'text' || type === 'markdown' || type === 'note' || type === 'memo' || type === 'code';
+    }
+
+    function supportsSelection(entry) {
+        const manager = getCss3dManager();
+        const model = getModel(entry);
+        if (manager?.supportsSelectionTextOverlay) {
+            return manager.supportsSelectionTextOverlay(model);
+        }
+
+        const type = getContentType(entry);
+        return type === 'text' || type === 'markdown';
+    }
+
+    function supportsPassiveDisplay(entry) {
+        const manager = getCss3dManager();
+        if (manager?.getReadonlyTextOverlayMode) {
+            return String(getReadonlySelectionMode(entry) || '').trim().toLowerCase() !== 'none';
+        }
+
+        return supportsTextOverlayEntry(entry);
+    }
+
+    function blocksPassiveOverlayStack(entry) {
+        const type = getContentType(entry);
+        const isVisualStackBlocker = type === 'image'
+            || type === 'video'
+            || type === 'embed'
+            || type === 'memo'
+            || isAgentStyledMemoEntry(entry);
+        if (!isVisualStackBlocker) {
+            return false;
+        }
+
+        const hasVisibleGl = !!entry?.glObject && entry.glObject.visible !== false;
+        const hasVisibleCss = !!entry?.cssObject && entry.cssObject.visible !== false;
+        return hasVisibleGl || hasVisibleCss;
+    }
+
+    function shouldKeepPassiveCardWhenSelected(entry) {
+        return supportsPassiveDisplay(entry);
+    }
+
+    function supportsEditing(entry) {
+        const manager = getCss3dManager();
+        const model = getModel(entry);
+        if (manager?.supportsEditingOverlay) {
+            return manager.supportsEditingOverlay(model);
+        }
+
+        const type = getContentType(entry);
+        return type === 'memo' || type === 'note';
+    }
+
+    function usesDomTextOverlay(module) {
+        return module?.useDomTextOverlay === true;
+    }
+
+    function getCurrentLodBand(module) {
+        const explicitBand = String(module?.lodRenderer?._currentLodBand || '').trim().toUpperCase();
+        if (explicitBand) {
+            return explicitBand;
+        }
+
+        const cameraZ = Number(module?.camera?.position?.z || 0);
+        const thresholds = globalThis.LODRenderer?.LOD_THRESHOLDS || {
+            NEAR: 4500,
+            NORMAL: 12000,
+            MID: 12000,
+            FAR: 30000
+        };
+
+        if (cameraZ >= Number(thresholds.FAR || 25000)) {
+            return 'FAR';
+        }
+        if (cameraZ >= Number(thresholds.MID || thresholds.NORMAL || 12000)) {
+            return 'MID';
+        }
+        if (cameraZ >= Number(thresholds.NORMAL || thresholds.NEAR || 4500)) {
+            return 'NORMAL';
+        }
+        return 'NEAR';
+    }
+
+    function getScrollableSelector() {
+        return getCss3dManager()?.getTextInteractionScrollableSelectors?.()
+            || DEFAULT_OVERLAY_SCROLLABLE_SELECTOR;
+    }
+
+    function getScrollSyncSelectors() {
+        return getCss3dManager()?.getTextOverlayScrollSyncSelectors?.() || [
+            '.node-response',
+            '.note-content',
+            '.markdown-body',
+            '.prose',
+            '.code-body',
+            '.note-textarea',
+            '.map-node-memo__body',
+            '.map-node-memo__body-view',
+            '.map-node-memo__agent-plan-body',
+            '.map-node-memo__agent-console-body'
+        ];
+    }
+
+    function getPrimaryContentSelector() {
+        return getCss3dManager()?.getTextOverlayPrimaryContentSelectors?.()
+            || '[id^="node-response-"], .node-response, .note-content, .markdown-body, .code-body, .map-node-memo__body-view, .map-node-memo__agent-plan-body, .map-node-memo__agent-console-body';
+    }
+
+    function shouldRenderPassiveDomOverlays(module) {
+        if (!isEnabled(module) || !usesDomTextOverlay(module)) {
+            return false;
+        }
+
+        const state = ensureState(module);
+        if (hasBlockingPassiveOverlayInteraction(module, state)) {
+            if (state) {
+                state.passiveNearStickyUntil = 0;
+            }
+            return false;
+        }
+
+        const currentBand = getCurrentLodBand(module);
+        if (currentBand === 'NEAR') {
+            if (state) {
+                state.passiveNearStickyUntil = nowMs() + PASSIVE_OVERLAY_NEAR_EXIT_GRACE_MS;
+            }
+            return true;
+        }
+
+        if (state) {
+            state.passiveNearStickyUntil = 0;
+        }
+
+        return false;
+    }
+
+    function shouldUseVisiblePassiveOverlayCandidates(module) {
+        return module?.renderDebugFlags?.enablePassiveOverlayForVisibleNodes !== false;
+    }
+
+    function hasBlockingPassiveOverlayInteraction(module, state = ensureState(module)) {
+        const hasBlockingTextInteraction =
+            !!normalizeId(state?.selectionNodeId) ||
+            !!normalizeId(state?.editing?.nodeId) ||
+            module?.isEditingNote === true ||
+            getCss3dManager()?.hasNativeTextSelectionSource?.(module) === true ||
+            getCss3dManager()?.hasSelectableTextOverlay?.(module) === true;
+
+        return hasBlockingTextInteraction;
+    }
+
+    function buildInteractionKey(module, state) {
+        const selectedNodeId = normalizeId(module?.selectedNodeIdJs);
+        const multiSelectedCount = Number(module?.multiSelectedNodeIds?.size || 0);
+        const nativeSelectionNodeId = normalizeId(module?._nativeTextSelectionSourceNodeId);
+        const selectableOverlayNodeId = normalizeId(module?._selectableTextOverlayNodeId);
+        const activeSelectionNodeId = normalizeId(state?.selectionNodeId);
+        const editingNodeId = normalizeId(state?.editing?.nodeId);
+        const isEditingNote = module?.isEditingNote === true ? '1' : '0';
+        return [
+            selectedNodeId,
+            String(multiSelectedCount),
+            nativeSelectionNodeId,
+            selectableOverlayNodeId,
+            activeSelectionNodeId,
+            editingNodeId,
+            isEditingNote
+        ].join('|');
+    }
+
+    function getPassiveViewportWorldBounds(module) {
+        const container = module?.container || null;
+        const camera = module?.camera || null;
+        if (!container || !camera?.isPerspectiveCamera) {
+            return null;
+        }
+
+        const viewportWidthPx = Math.max(1, Number(container.clientWidth || container.offsetWidth || 0));
+        const viewportHeightPx = Math.max(1, Number(container.clientHeight || container.offsetHeight || 0));
+        const cameraZ = Number(camera.position?.z || 0);
+        const fov = Number(camera.fov || 0);
+        if (!(viewportWidthPx > 0) || !(viewportHeightPx > 0) || !(cameraZ > 0) || !(fov > 0)) {
+            return null;
+        }
+
+        const vfov = (fov * Math.PI) / 180;
+        const worldHeight = 2 * Math.tan(vfov / 2) * cameraZ;
+        if (!(worldHeight > 0)) {
+            return null;
+        }
+
+        const worldWidth = worldHeight * Number(camera.aspect || (viewportWidthPx / viewportHeightPx) || 1);
+        const pixelsPerWorld = viewportHeightPx / worldHeight;
+        const padWorld = PASSIVE_OVERLAY_VIEWPORT_PAD_PX / Math.max(0.0001, pixelsPerWorld);
+        const halfWidth = worldWidth * 0.5;
+        const halfHeight = worldHeight * 0.5;
+        const centerX = Number(camera.position?.x || 0);
+        const centerY = Number(camera.position?.y || 0);
+
+        return {
+            left: centerX - halfWidth - padWorld,
+            right: centerX + halfWidth + padWorld,
+            top: centerY + halfHeight + padWorld,
+            bottom: centerY - halfHeight - padWorld,
+            centerX,
+            centerY
+        };
+    }
+
+    function getPassiveCandidateWorldBounds(entry) {
+        const model = getModel(entry);
+        const obj = entry?.glObject || entry?.cssObject || null;
+        if (!model || !obj?.position) {
+            return null;
+        }
+
+        const width = Math.max(
+            1,
+            Number(model?.width || model?.Width || 0),
+            Number(entry?.cssObject?.element?.offsetWidth || 0)
+        );
+        const height = Math.max(
+            1,
+            Number(model?.height || model?.Height || 0),
+            Number(entry?.cssObject?.element?.offsetHeight || 0)
+        );
+        const left = Number(obj.position.x || 0);
+        const top = Number(obj.position.y || 0);
+
+        return {
+            left,
+            right: left + width,
+            top,
+            bottom: top - height,
+            centerX: left + (width * 0.5),
+            centerY: top - (height * 0.5)
+        };
+    }
+
+    function intersectsPassiveViewport(bounds, viewportBounds) {
+        if (!bounds || !viewportBounds) {
+            return true;
+        }
+
+        return !(
+            bounds.right < viewportBounds.left ||
+            bounds.left > viewportBounds.right ||
+            bounds.top < viewportBounds.bottom ||
+            bounds.bottom > viewportBounds.top
+        );
+    }
+
+    function getPassiveViewportVisibleArea(bounds, viewportBounds) {
+        if (!bounds || !viewportBounds) {
+            return 0;
+        }
+
+        const overlapWidth = Math.max(
+            0,
+            Math.min(bounds.right, viewportBounds.right) - Math.max(bounds.left, viewportBounds.left)
+        );
+        const overlapHeight = Math.max(
+            0,
+            Math.min(bounds.top, viewportBounds.top) - Math.max(bounds.bottom, viewportBounds.bottom)
+        );
+        return overlapWidth * overlapHeight;
+    }
+
+    function parseCssStackZIndex(element) {
+        const readNumeric = value => {
+            const raw = String(value ?? '').trim();
+            if (!raw || raw.toLowerCase() === 'auto') {
+                return null;
+            }
+
+            const number = Number(raw);
+            return Number.isFinite(number) ? number : null;
+        };
+
+        const inlineZ = readNumeric(element?.style?.zIndex);
+        if (inlineZ !== null) {
+            return inlineZ;
+        }
+
+        try {
+            return readNumeric(window.getComputedStyle?.(element)?.zIndex);
+        } catch {
+            return null;
+        }
+    }
+
+    function getCss3dDomStackIndex(entry, fallbackIndex = 0) {
+        const element = entry?.cssObject?.element || null;
+        const parentElement = element?.parentElement || null;
+        if (parentElement?.children?.length) {
+            const index = Array.prototype.indexOf.call(parentElement.children, element);
+            if (index >= 0) {
+                return index;
+            }
+        }
+
+        const cssParent = entry?.cssObject?.parent || null;
+        const cssChildren = cssParent?.children || null;
+        if (Array.isArray(cssChildren)) {
+            const index = cssChildren.indexOf(entry.cssObject);
+            if (index >= 0) {
+                return index;
+            }
+        }
+
+        return Number(fallbackIndex || 0);
+    }
+
+    function getWebglRenderStackIndex(entry, fallbackIndex = 0) {
+        let maxOrder = Number(entry?.glObject?.userData?.baseRenderOrder);
+        if (!Number.isFinite(maxOrder)) {
+            maxOrder = Number(entry?.bodyMesh?.renderOrder);
+        }
+
+        entry?.glObject?.traverse?.(child => {
+            if (!child || !(child.isMesh || child.isLine)) {
+                return;
+            }
+
+            const order = Number(child.renderOrder);
+            if (Number.isFinite(order) && (!Number.isFinite(maxOrder) || order > maxOrder)) {
+                maxOrder = order;
+            }
+        });
+
+        return Number.isFinite(maxOrder) ? maxOrder : Number(fallbackIndex || 0);
+    }
+
+    function getPassiveOverlayStackRank(entry, sourceIndex = 0) {
+        const element = entry?.cssObject?.element || null;
+        const cssZIndex = parseCssStackZIndex(element);
+        const zBand = Number.isFinite(cssZIndex)
+            ? cssZIndex
+            : (!element ? getWebglRenderStackIndex(entry, 0) : 0);
+        const domIndex = element
+            ? getCss3dDomStackIndex(entry, sourceIndex)
+            : Number(sourceIndex || 0);
+
+        // Match CSS3D stacking: explicit CSS z-index first, DOM sibling order second.
+        return (zBand * PASSIVE_OVERLAY_STACK_Z_SCALE) + domIndex;
+    }
+
+    function getPassiveOverlayScreenRect(module, entry) {
+        const rect = getPlacementRect(module, entry);
+        if (!rect) {
+            return null;
+        }
+
+        const left = Number(rect.left || 0);
+        const top = Number(rect.top || 0);
+        const width = Math.max(1, Number(rect.width || rect.baseWidth || 1));
+        const height = Math.max(1, Number(rect.height || rect.baseHeight || 1));
+        if (!Number.isFinite(left) || !Number.isFinite(top) || !Number.isFinite(width) || !Number.isFinite(height)) {
+            return null;
+        }
+
+        return {
+            left,
+            top,
+            right: left + width,
+            bottom: top + height,
+            width,
+            height
+        };
+    }
+
+    function doPassiveOverlayRectsOverlap(a, b) {
+        if (!a || !b) {
+            return false;
+        }
+
+        const overlapWidth = Math.min(a.right, b.right) - Math.max(a.left, b.left);
+        const overlapHeight = Math.min(a.bottom, b.bottom) - Math.max(a.top, b.top);
+        if (overlapWidth <= PASSIVE_OVERLAY_OVERLAP_MIN_PX || overlapHeight <= PASSIVE_OVERLAY_OVERLAP_MIN_PX) {
+            return false;
+        }
+
+        return (overlapWidth * overlapHeight) >= PASSIVE_OVERLAY_OVERLAP_MIN_AREA_PX;
+    }
+
+    function collectBlockerConnectedPassiveOverlayIds(enriched) {
+        const suppressedIds = new Set();
+        if (!Array.isArray(enriched) || enriched.length <= 1) {
+            return suppressedIds;
+        }
+
+        const seeds = enriched.filter(item =>
+            item?.renderPassiveOverlay === false &&
+            item.rect &&
+            Number.isFinite(item.stackRank));
+        if (seeds.length === 0) {
+            return suppressedIds;
+        }
+
+        const visited = new Set();
+        const queue = seeds.map(seed => ({
+            item: seed,
+            blockerRank: Number(seed.stackRank)
+        }));
+
+        while (queue.length > 0) {
+            const current = queue.shift();
+            const currentItem = current?.item || null;
+            const blockerRank = Number(current?.blockerRank);
+            if (!currentItem?.rect || !Number.isFinite(blockerRank)) {
+                continue;
+            }
+
+            enriched.forEach(candidate => {
+                if (!candidate?.rect || candidate === currentItem) {
+                    return;
+                }
+
+                const candidateRank = Number(candidate.stackRank);
+                if (Number.isFinite(candidateRank) && candidateRank > blockerRank) {
+                    return;
+                }
+
+                if (!doPassiveOverlayRectsOverlap(currentItem.rect, candidate.rect)) {
+                    return;
+                }
+
+                const visitKey = `${candidate.nodeId || candidate.priorityIndex}|${blockerRank}`;
+                if (visited.has(visitKey)) {
+                    return;
+                }
+
+                visited.add(visitKey);
+                if (candidate.renderPassiveOverlay !== false) {
+                    suppressedIds.add(candidate.nodeId);
+                }
+
+                queue.push({
+                    item: candidate,
+                    blockerRank
+                });
+            });
+        }
+
+        return suppressedIds;
+    }
+
+    function comparePassiveOverlayStack(a, b) {
+        const stackDelta = Number(b?.stackRank || 0) - Number(a?.stackRank || 0);
+        if (stackDelta !== 0) {
+            return stackDelta;
+        }
+
+        const sourceDelta = Number(b?.sourceIndex || 0) - Number(a?.sourceIndex || 0);
+        if (sourceDelta !== 0) {
+            return sourceDelta;
+        }
+
+        return Number(a?.priorityIndex || 0) - Number(b?.priorityIndex || 0);
+    }
+
+    function collectConnectedPassiveOverlayWinnerIds(enriched, suppressedIds) {
+        const winnerIds = new Set();
+        const candidates = Array.isArray(enriched)
+            ? enriched.filter(item =>
+                item?.renderPassiveOverlay !== false &&
+                item.nodeId &&
+                item.rect &&
+                !(suppressedIds instanceof Set && suppressedIds.has(item.nodeId)))
+            : [];
+        if (candidates.length === 0) {
+            return winnerIds;
+        }
+
+        const visited = new Set();
+        candidates.forEach(seed => {
+            if (!seed?.nodeId || visited.has(seed.nodeId)) {
+                return;
+            }
+
+            const component = [];
+            const queue = [seed];
+            visited.add(seed.nodeId);
+
+            while (queue.length > 0) {
+                const current = queue.shift();
+                component.push(current);
+
+                candidates.forEach(candidate => {
+                    if (!candidate?.nodeId || visited.has(candidate.nodeId)) {
+                        return;
+                    }
+
+                    if (!doPassiveOverlayRectsOverlap(current.rect, candidate.rect)) {
+                        return;
+                    }
+
+                    visited.add(candidate.nodeId);
+                    queue.push(candidate);
+                });
+            }
+
+            component.sort(comparePassiveOverlayStack);
+            if (component[0]?.nodeId) {
+                winnerIds.add(component[0].nodeId);
+            }
+        });
+
+        return winnerIds;
+    }
+
+    function filterPassiveOverlayTopmostCandidates(module, prioritized, blockers = []) {
+        const overlayCandidates = Array.isArray(prioritized) ? prioritized : [];
+        const visualBlockers = Array.isArray(blockers) ? blockers : [];
+        const stackItems = overlayCandidates.concat(visualBlockers);
+        if (stackItems.length <= 1) {
+            return {
+                candidates: overlayCandidates,
+                suppressedCount: 0,
+                suppressedIds: new Set()
+            };
+        }
+
+        const enriched = stackItems.map((candidate, priorityIndex) => {
+            const entry = candidate?.entry || module?.nodeObjectsById?.get?.(candidate?.nodeId) || null;
+            return {
+                ...candidate,
+                entry,
+                priorityIndex,
+                renderPassiveOverlay: candidate?.renderPassiveOverlay !== false,
+                stackRank: getPassiveOverlayStackRank(entry, candidate?.sourceIndex ?? priorityIndex),
+                rect: entry ? getPassiveOverlayScreenRect(module, entry) : null
+            };
+        });
+
+        const blockerConnectedSuppressedIds = collectBlockerConnectedPassiveOverlayIds(enriched);
+        const connectedWinnerIds = collectConnectedPassiveOverlayWinnerIds(enriched, blockerConnectedSuppressedIds);
+        const byStack = enriched.slice().sort(comparePassiveOverlayStack);
+
+        const acceptedTopmost = [];
+        let suppressedCount = 0;
+        const suppressedIds = new Set();
+        const suppressCandidate = candidate => {
+            if (!candidate?.nodeId || suppressedIds.has(candidate.nodeId)) {
+                return;
+            }
+
+            suppressedCount += 1;
+            suppressedIds.add(candidate.nodeId);
+        };
+
+        byStack.forEach(candidate => {
+            if (candidate.renderPassiveOverlay === false) {
+                if (candidate.rect) {
+                    acceptedTopmost.push(candidate);
+                }
+                return;
+            }
+
+            if (blockerConnectedSuppressedIds.has(candidate.nodeId)) {
+                suppressCandidate(candidate);
+                return;
+            }
+
+            if (!connectedWinnerIds.has(candidate.nodeId)) {
+                suppressCandidate(candidate);
+                return;
+            }
+
+            const overlapsTopCandidate = candidate.rect && acceptedTopmost.some(existing =>
+                existing.rect && doPassiveOverlayRectsOverlap(candidate.rect, existing.rect));
+            if (overlapsTopCandidate) {
+                suppressCandidate(candidate);
+                return;
+            }
+
+            acceptedTopmost.push(candidate);
+        });
+
+        const acceptedIds = new Set(acceptedTopmost
+            .filter(candidate => candidate.renderPassiveOverlay !== false)
+            .map(candidate => candidate.nodeId));
+        return {
+            candidates: enriched
+                .filter(candidate => candidate.renderPassiveOverlay !== false && acceptedIds.has(candidate.nodeId))
+                .sort((a, b) => a.priorityIndex - b.priorityIndex),
+            suppressedCount,
+            suppressedIds
+        };
+    }
+
+    function getPassiveOverlayCardLimit(module, candidateCount) {
+        if (!(candidateCount > 0)) {
+            return 0;
+        }
+
+        const avgFrameTime = Number(module?._avgFrameTime || 0);
+        const cameraZ = Number(module?.camera?.position?.z || 0);
+        let limit = PASSIVE_OVERLAY_CARD_LIMIT_DEFAULT;
+
+        if (candidateCount >= 32) {
+            limit = Math.min(limit, PASSIVE_OVERLAY_CARD_LIMIT_DENSE);
+        }
+
+        if (avgFrameTime > 28) {
+            limit = Math.min(limit, PASSIVE_OVERLAY_CARD_LIMIT_VERY_SLOW);
+        } else if (avgFrameTime > 22) {
+            limit = Math.min(limit, 16);
+        } else if (avgFrameTime > 18) {
+            limit = Math.min(limit, 18);
+        }
+
+        if (cameraZ > 3600) {
+            limit = Math.min(limit, 16);
+        } else if (cameraZ > 3000) {
+            limit = Math.min(limit, 18);
+        } else if (cameraZ > 2200) {
+            limit = Math.min(limit, 22);
+        }
+
+        return Math.min(candidateCount, Math.max(6, limit));
+    }
+
+    function collectVisiblePassiveCandidateIds(module, state, visibleIds) {
+        const prioritized = [];
+        const blockers = [];
+        const viewportBounds = getPassiveViewportWorldBounds(module);
+        let supportedVisibleCount = 0;
+        let sourceIndex = 0;
+        let blockerCount = 0;
+
+        visibleIds.forEach(nodeId => {
+            const normalizedId = normalizeId(nodeId);
+            if (!normalizedId) {
+                return;
+            }
+
+            const entry = module?.nodeObjectsById?.get?.(normalizedId) || null;
+            if (!entry) {
+                return;
+            }
+
+            const bounds = getPassiveCandidateWorldBounds(entry);
+            if (viewportBounds && bounds && !intersectsPassiveViewport(bounds, viewportBounds)) {
+                return;
+            }
+
+            const nextSourceIndex = sourceIndex++;
+            if (!supportsPassiveDisplay(entry)) {
+                if (blocksPassiveOverlayStack(entry)) {
+                    blockers.push({
+                        nodeId: normalizedId,
+                        entry,
+                        sourceIndex: nextSourceIndex,
+                        renderPassiveOverlay: false
+                    });
+                    blockerCount += 1;
+                }
+                return;
+            }
+
+            supportedVisibleCount += 1;
+            const card = state?.cards?.get?.(selectionCardKey(normalizedId)) || null;
+            const visibleArea = getPassiveViewportVisibleArea(bounds, viewportBounds);
+            const dx = bounds ? (bounds.centerX - Number(viewportBounds?.centerX || 0)) : 0;
+            const dy = bounds ? (bounds.centerY - Number(viewportBounds?.centerY || 0)) : 0;
+            prioritized.push({
+                nodeId: normalizedId,
+                entry,
+                sourceIndex: nextSourceIndex,
+                sticky: card && card.style.display !== 'none' ? 0 : 1,
+                canRenderFromCss: canOverlayCssEntry(entry) ? 0 : 1,
+                visibleArea,
+                distSq: (dx * dx) + (dy * dy)
+            });
+        });
+
+        prioritized.sort((a, b) => {
+            if (a.sticky !== b.sticky) {
+                return a.sticky - b.sticky;
+            }
+            if (a.canRenderFromCss !== b.canRenderFromCss) {
+                return a.canRenderFromCss - b.canRenderFromCss;
+            }
+            if (a.visibleArea !== b.visibleArea) {
+                return b.visibleArea - a.visibleArea;
+            }
+            return a.distSq - b.distSq;
+        });
+
+        const overlapFiltered = filterPassiveOverlayTopmostCandidates(module, prioritized, blockers);
+        const filteredCandidates = overlapFiltered.candidates;
+        const limit = getPassiveOverlayCardLimit(module, filteredCandidates.length);
+        const candidateIds = new Set();
+        for (let i = 0; i < filteredCandidates.length && candidateIds.size < limit; i++) {
+            candidateIds.add(filteredCandidates[i].nodeId);
+        }
+
+        module._overlayDebugPassiveVisibleCandidateCount = candidateIds.size;
+        module._overlayDebugPassiveVisibleSupportedCount = supportedVisibleCount;
+        module._overlayDebugPassiveViewportCandidateCount = prioritized.length;
+        module._overlayDebugPassiveCardLimit = limit;
+        module._overlayDebugPassiveOverlapSuppressedCount = Number(overlapFiltered.suppressedCount || 0);
+        module._overlayDebugPassiveOccluderCount = blockerCount;
+        module._overlaySuppressedPassiveNodeIds = overlapFiltered.suppressedIds instanceof Set
+            ? overlapFiltered.suppressedIds
+            : new Set();
+        return candidateIds;
+    }
+
+    function shouldPreferOverlayCssZoom(module, entry = null) {
+        if (module?.renderDebugFlags?.enableOverlayCssZoom === false) {
+            return false;
+        }
+
+        if (entry && supportsTextOverlayEntry(entry)) {
+            return false;
+        }
+
+        return true;
+    }
+
+    function ensureState(module) {
+        if (!module) {
+            return null;
+        }
+
+        if (!module._textOverlayV2State) {
+            module._textOverlayV2State = {
+                layer: null,
+                cards: new Map(),
+                dirtyNodes: new Set(),
+                dirtyLayout: true,
+                dirtySelection: true,
+                dirtyEditing: true,
+                selectionNodeId: '',
+                editing: null,
+                motionHintActive: false,
+                lastPassiveRenderEnabled: null,
+                lastViewKey: '',
+                lastVisibilityVersion: -1,
+                lastInteractionKey: '',
+                layoutSnapshot: null,
+                passiveNearStickyUntil: 0,
+                passiveCandidateIds: new Set(),
+                passiveCandidateVisibleUntil: 0
+            };
+        }
+
+        return module._textOverlayV2State;
+    }
+
+    function ensureLayer(module) {
+        const state = ensureState(module);
+        if (!state || !module?.container) {
+            return null;
+        }
+
+        if (!state.layer || !state.layer.isConnected) {
+            const layer = document.createElement('div');
+            layer.className = 'mind-map-text-overlay-v2-layer';
+            state.layer = layer;
+        }
+
+        if (state.layer.parentElement !== module.container) {
+            module.container.appendChild(state.layer);
+        }
+
+        state.layer.classList.toggle('is-motion-hint', state.motionHintActive === true);
+        state.layer.style.willChange = state.motionHintActive === true ? 'transform' : 'auto';
+        state.layer.style.backfaceVisibility = state.motionHintActive === true ? 'hidden' : '';
+        state.layer.style.webkitBackfaceVisibility = state.motionHintActive === true ? 'hidden' : '';
+
+        return state.layer;
+    }
+
+    function getHostElement(entry) {
+        const wrapper = entry?.cssObject?.element || null;
+        if (!wrapper) {
+            return null;
+        }
+
+        return wrapper.firstElementChild || wrapper;
+    }
+
+    function getReadonlyCloneSourceElement(entry) {
+        return entry?.cssObject?.element || getHostElement(entry) || null;
+    }
+
+    function getReadonlySelectionSourceRoot(entry) {
+        return getHostElement(entry) || getReadonlyCloneSourceElement(entry) || null;
+    }
+
+    function getReadonlySelectionMode(entry) {
+        return getCss3dManager()?.getReadonlyTextOverlayMode?.(entry) || 'none';
+    }
+
+    function getReadonlySourceEpoch(module) {
+        return Number(module?._readonlyOverlaySourceEpoch || 0);
+    }
+
+    function bumpReadonlySourceEpoch(module) {
+        if (!module) {
+            return 0;
+        }
+
+        const nextEpoch = getReadonlySourceEpoch(module) + 1;
+        module._readonlyOverlaySourceEpoch = nextEpoch;
+        return nextEpoch;
+    }
+
+    function getDomPlacementRect(module, entry) {
+        const container = module?.container;
+        const model = getModel(entry);
+        const host = getHostElement(entry);
+        if (!container || !host || !host.isConnected) {
+            return null;
+        }
+
+        const hostRect = host.getBoundingClientRect();
+        const containerRect = container.getBoundingClientRect();
+        if (hostRect.width <= 0 || hostRect.height <= 0) {
+            return null;
+        }
+
+        const logicalWidth = Math.max(
+            Number(host.offsetWidth || 0),
+            Number(host.clientWidth || 0),
+            Number(model?.width || model?.Width || 0)
+        );
+        const logicalHeight = Math.max(
+            Number(host.offsetHeight || 0),
+            Number(host.clientHeight || 0),
+            Number(model?.height || model?.Height || 0)
+        );
+
+        return {
+            left: hostRect.left - containerRect.left,
+            top: hostRect.top - containerRect.top,
+            width: hostRect.width,
+            height: hostRect.height,
+            baseWidth: Math.max(1, logicalWidth > 0 ? logicalWidth : Math.round(hostRect.width)),
+            baseHeight: Math.max(1, logicalHeight > 0 ? logicalHeight : Math.round(hostRect.height))
+        };
+    }
+
+    function getPlacementRect(module, entry) {
+        const container = module?.container;
+        const camera = module?.camera || null;
+        const model = getModel(entry);
+        const obj = entry?.glObject || entry?.cssObject || null;
+        if (!container) {
+            return null;
+        }
+
+        const domRect = getDomPlacementRect(module, entry);
+        if (domRect) {
+            return domRect;
+        }
+
+        const THREERef = camera && obj ? ensureProjectionTemps() : null;
+        if (THREERef && obj?.matrixWorld && typeof _projCornerTopLeft?.project === 'function') {
+            const viewportWidth = Math.max(1, Number(container.clientWidth || container.offsetWidth || 0));
+            const viewportHeight = Math.max(1, Number(container.clientHeight || container.offsetHeight || 0));
+            const baseWidth = Math.max(1, Number(model?.width || model?.Width || 1));
+            const baseHeight = Math.max(1, Number(model?.height || model?.Height || 1));
+
+            obj.updateWorldMatrix?.(true, false);
+
+            const corners = [
+                _projCornerTopLeft.set(0, 0, 0).applyMatrix4(obj.matrixWorld),
+                _projCornerTopRight.set(baseWidth, 0, 0).applyMatrix4(obj.matrixWorld),
+                _projCornerBottomLeft.set(0, -baseHeight, 0).applyMatrix4(obj.matrixWorld),
+                _projCornerBottomRight.set(baseWidth, -baseHeight, 0).applyMatrix4(obj.matrixWorld)
+            ];
+
+            let minX = Number.POSITIVE_INFINITY;
+            let maxX = Number.NEGATIVE_INFINITY;
+            let minY = Number.POSITIVE_INFINITY;
+            let maxY = Number.NEGATIVE_INFINITY;
+            let visibleCornerCount = 0;
+
+            for (let i = 0; i < corners.length; i++) {
+                const projected = corners[i].project(camera);
+                if (!Number.isFinite(projected.x) || !Number.isFinite(projected.y) || !Number.isFinite(projected.z)) {
+                    continue;
+                }
+
+                if (projected.z >= -1 && projected.z <= 1) {
+                    visibleCornerCount += 1;
+                }
+
+                const screenX = (projected.x * 0.5 + 0.5) * viewportWidth;
+                const screenY = (-projected.y * 0.5 + 0.5) * viewportHeight;
+                minX = Math.min(minX, screenX);
+                maxX = Math.max(maxX, screenX);
+                minY = Math.min(minY, screenY);
+                maxY = Math.max(maxY, screenY);
+            }
+
+            if (visibleCornerCount > 0 &&
+                Number.isFinite(minX) &&
+                Number.isFinite(maxX) &&
+                Number.isFinite(minY) &&
+                Number.isFinite(maxY)) {
+                return {
+                    left: minX,
+                    top: minY,
+                    width: Math.max(1, maxX - minX),
+                    height: Math.max(1, maxY - minY),
+                    baseWidth,
+                    baseHeight
+                };
+            }
+        }
+
+        return null;
+    }
+
+    function cloneSourceSubtree(entry, selector) {
+        const host = getHostElement(entry);
+        const source = host?.querySelector?.(selector) || null;
+        if (!source) {
+            return null;
+        }
+
+        return prepareOverlayClone(source.cloneNode(true));
+    }
+
+    function getReadonlyLivePortal(entry) {
+        return entry?._readonlyOverlayLivePortal || null;
+    }
+
+    function isReadonlyLivePortalActive(entry) {
+        const portal = getReadonlyLivePortal(entry);
+        return !!portal?.sourceElement && !!portal?.active;
+    }
+
+    function clearReadonlyLivePortalStyles(sourceElement, portal) {
+        if (!sourceElement?.style || !portal) {
+            return;
+        }
+
+        sourceElement.classList?.remove?.('mind-map-text-overlay-v2-live-source');
+        sourceElement.style.width = portal.width ?? '';
+        sourceElement.style.height = portal.height ?? '';
+        sourceElement.style.transform = portal.transform ?? '';
+        sourceElement.style.transformOrigin = portal.transformOrigin ?? '';
+        sourceElement.style.zoom = portal.zoom ?? '';
+        sourceElement.style.pointerEvents = portal.pointerEvents ?? '';
+        sourceElement.style.userSelect = portal.userSelect ?? '';
+        sourceElement.style.webkitUserSelect = portal.webkitUserSelect ?? '';
+    }
+
+    function restoreReadonlyLivePortal(entry) {
+        const portal = getReadonlyLivePortal(entry);
+        if (!portal?.sourceElement) {
+            return false;
+        }
+
+        const sourceElement = portal.sourceElement;
+        clearReadonlyLivePortalStyles(sourceElement, portal);
+
+        const parent = portal.parentElement || null;
+        const nextSibling = portal.nextSibling || null;
+        if (parent?.isConnected) {
+            if (nextSibling?.parentElement === parent) {
+                parent.insertBefore(sourceElement, nextSibling);
+            } else {
+                parent.appendChild(sourceElement);
+            }
+        }
+
+        if (portal.cardElement?.firstElementChild === sourceElement) {
+            portal.cardElement.removeChild(sourceElement);
+        }
+
+        entry._readonlyOverlayLivePortal = null;
+        return true;
+    }
+
+    function createReadonlyLiveSourcePortal(entry, card, options = {}) {
+        if (!entry || !card || options.interactive === true) {
+            return null;
+        }
+
+        const existingPortal = getReadonlyLivePortal(entry);
+        if (existingPortal?.active && existingPortal.sourceElement) {
+            if (existingPortal.sourceElement.parentElement !== card) {
+                card.appendChild(existingPortal.sourceElement);
+            }
+
+            existingPortal.cardElement = card;
+            return {
+                container: existingPortal.sourceElement,
+                sourceRoot: existingPortal.sourceElement,
+                liveSource: true
+            };
+        }
+
+        const wrapper = entry?.cssObject?.element || null;
+        const sourceElement = getReadonlySelectionSourceRoot(entry);
+        if (!wrapper || !sourceElement || sourceElement === wrapper) {
+            return null;
+        }
+
+        if (existingPortal?.active) {
+            restoreReadonlyLivePortal(entry);
+        }
+
+        entry._readonlyOverlayLivePortal = {
+            active: true,
+            cardElement: card,
+            parentElement: sourceElement.parentElement || null,
+            nextSibling: sourceElement.nextSibling || null,
+            sourceElement: sourceElement,
+            width: sourceElement.style.width,
+            height: sourceElement.style.height,
+            transform: sourceElement.style.transform,
+            transformOrigin: sourceElement.style.transformOrigin,
+            zoom: sourceElement.style.zoom,
+            pointerEvents: sourceElement.style.pointerEvents,
+            userSelect: sourceElement.style.userSelect,
+            webkitUserSelect: sourceElement.style.webkitUserSelect
+        };
+
+        sourceElement.classList.add('mind-map-text-overlay-v2-live-source');
+        sourceElement.style.pointerEvents = 'none';
+        sourceElement.style.userSelect = 'none';
+        sourceElement.style.webkitUserSelect = 'none';
+        card.appendChild(sourceElement);
+
+        return {
+            container: sourceElement,
+            sourceRoot: sourceElement,
+            liveSource: true
+        };
+    }
+
+    function resolveOverlayZIndex(entry, baseZIndex) {
+        const candidate = getPassiveOverlayStackRank(entry, 0);
+
+        if (!Number.isFinite(candidate)) {
+            return baseZIndex;
+        }
+
+        return Math.max(baseZIndex, candidate + baseZIndex);
+    }
+
+    function applyPlacement(module, element, rect, zIndex, entry = null) {
+        if (!module || !element || !rect) {
+            return;
+        }
+
+        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 preferCssZoom = shouldPreferOverlayCssZoom(module, entry);
+        const canUseZoom =
+            preferCssZoom &&
+            Number.isFinite(scaleX) &&
+            Number.isFinite(scaleY) &&
+            scaleX > 0 &&
+            scaleY > 0 &&
+            Math.abs(scaleX - scaleY) < 0.02;
+        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.transform = '';
+        element.style.zoom = '';
+        applyScrollbarScaleCompensation(element, scaleX, scaleY);
+        applyScrollbarScaleCompensation(entry?.cssObject?.element || null, scaleX, scaleY);
+
+        if (shell?.style) {
+            shell.style.width = `${baseWidth}px`;
+            shell.style.height = `${baseHeight}px`;
+            shell.style.transformOrigin = '0 0';
+            shell.style.zoom = '';
+            shell.style.transform = '';
+            applyScrollbarScaleCompensation(shell, scaleX, scaleY);
+
+            if (canUseZoom) {
+                shell.style.zoom = `${scaleX}`;
+                module._overlayDebugPlacementZoomCount = Number(module._overlayDebugPlacementZoomCount || 0) + 1;
+            } else {
+                shell.style.transform = `scale(${scaleX}, ${scaleY})`;
+                module._overlayDebugPlacementTransformCount = Number(module._overlayDebugPlacementTransformCount || 0) + 1;
+            }
+        } else if (!canUseZoom) {
+            element.style.transform = `scale(${scaleX}, ${scaleY})`;
+            module._overlayDebugPlacementTransformCount = Number(module._overlayDebugPlacementTransformCount || 0) + 1;
+        }
+        element.style.zIndex = String(resolveOverlayZIndex(entry, zIndex));
+    }
+
+    function applyScrollbarScaleCompensation(target, scaleX, scaleY) {
+        if (!target) {
+            return;
+        }
+
+        const scrollbarSizeX = 8;
+        const scrollbarSizeY = 8;
+        const scrollbarGutter = 14;
+
+        const applyVars = (element) => {
+            const style = element?.style;
+            if (!style) {
+                return;
+            }
+
+            style.setProperty('--mind-map-text-scrollbar-size', `${scrollbarSizeX}px`);
+            style.setProperty('--mind-map-text-scrollbar-size-x', `${scrollbarSizeX}px`);
+            style.setProperty('--mind-map-text-scrollbar-size-y', `${scrollbarSizeY}px`);
+            style.setProperty('--mind-map-text-scrollbar-gutter', `${scrollbarGutter}px`);
+            style.scrollbarWidth = 'thin';
+            style.scrollbarColor = 'rgba(0, 0, 0, 0.2) transparent';
+        };
+
+        applyVars(target);
+        target.querySelectorAll?.(
+            '.thin-scrollbar, .note-textarea, .note-content, .markdown-body, .prose, .code-body, .map-node-memo__body, .map-node-memo__body-view'
+        )?.forEach?.(applyVars);
+    }
+
+    function setSourceAgentConsoleOverlayMode(wrapper, enabled) {
+        const consolePanel = wrapper?.querySelector?.('.map-node-memo__agent-console-panel') || null;
+        if (!consolePanel) {
+            return;
+        }
+
+        const targets = [consolePanel, ...Array.from(consolePanel.querySelectorAll?.('*') || [])];
+        targets.forEach(target => {
+            if (!target?.style) {
+                return;
+            }
+
+            if (enabled) {
+                target.style.pointerEvents = 'auto';
+                return;
+            }
+
+            target.style.pointerEvents = '';
+        });
+    }
+
+    function suspendSource(entry, options = {}) {
+        const wrapper = entry?.cssObject?.element || null;
+        if (!wrapper) {
+            return;
+        }
+
+        const disablePointerEvents = options.disablePointerEvents !== false;
+        if (isReadonlyLivePortalActive(entry)) {
+            wrapper.style.pointerEvents = disablePointerEvents ? 'none' : '';
+            if (wrapper.firstElementChild) {
+                wrapper.firstElementChild.style.pointerEvents = disablePointerEvents ? 'none' : '';
+            }
+            setSourceAgentConsoleOverlayMode(wrapper, true);
+            return;
+        }
+
+        window.MindMapCss3DManager?.setTextOverlaySourceActive?.(entry, true);
+        wrapper.classList.add('mind-map-v2-source-suspended');
+        if (disablePointerEvents) {
+            wrapper.style.pointerEvents = 'none';
+            if (wrapper.firstElementChild) {
+                wrapper.firstElementChild.style.pointerEvents = 'none';
+            }
+        } else {
+            wrapper.style.pointerEvents = '';
+            if (wrapper.firstElementChild) {
+                wrapper.firstElementChild.style.pointerEvents = '';
+            }
+        }
+        setSourceAgentConsoleOverlayMode(wrapper, true);
+    }
+
+    function resumeSource(entry) {
+        const wrapper = entry?.cssObject?.element || null;
+        if (!wrapper) {
+            return;
+        }
+
+        restoreReadonlyLivePortal(entry);
+        window.MindMapCss3DManager?.setTextOverlaySourceActive?.(entry, false);
+        wrapper.classList.remove('mind-map-v2-source-suspended');
+        wrapper.style.pointerEvents = '';
+        if (wrapper.firstElementChild) {
+            wrapper.firstElementChild.style.pointerEvents = '';
+        }
+        setSourceAgentConsoleOverlayMode(wrapper, false);
+    }
+
+    function selectionCardKey(nodeId) {
+        return `selection:${normalizeId(nodeId)}`;
+    }
+
+    function editingCardKey(nodeId) {
+        return `editing:${normalizeId(nodeId)}`;
+    }
+
+    function ensureCard(module, cardKey, nodeId, kind) {
+        const state = ensureState(module);
+        const layer = ensureLayer(module);
+        if (!state || !layer || !cardKey) {
+            return null;
+        }
+
+        let card = state.cards.get(cardKey) || null;
+        if (!card) {
+            card = document.createElement('div');
+            card.className = 'mind-map-text-overlay-v2-card';
+            state.cards.set(cardKey, card);
+            layer.appendChild(card);
+        } else if (card.parentElement !== layer) {
+            layer.appendChild(card);
+        }
+
+        card.dataset.cardKey = cardKey;
+        card.dataset.nodeId = normalizeId(nodeId);
+        card.dataset.kind = kind;
+        return card;
+    }
+
+    function hideCard(card) {
+        if (!card) {
+            return;
+        }
+
+        card.style.display = 'none';
+    }
+
+    function removeCard(state, cardKey) {
+        if (!state || !cardKey) {
+            return false;
+        }
+
+        const card = state.cards.get(cardKey) || null;
+        if (!card) {
+            return false;
+        }
+
+        hideCard(card);
+        card.replaceChildren?.();
+        card.remove?.();
+        state.cards.delete(cardKey);
+        return true;
+    }
+
+    function purgeMediaOverlayCards(module, state = ensureState(module), options = {}) {
+        if (!module || !state) {
+            return 0;
+        }
+
+        const sourceIdsToResume = new Set();
+        const cardKeysToRemove = [];
+        state.cards.forEach((card, cardKey) => {
+            const nodeId = normalizeId(card?.dataset?.nodeId);
+            const entry = nodeId ? module?.nodeObjectsById?.get?.(nodeId) || null : null;
+            const cardContentType = String(card?.dataset?.contentType || '').trim().toLowerCase();
+            const isMediaCard =
+                isMediaOverlayExcluded(entry) ||
+                cardContentType === 'image' ||
+                cardContentType === 'video' ||
+                cardContentType === 'embed';
+            if (!isMediaCard) {
+                return;
+            }
+
+            if (nodeId) {
+                sourceIdsToResume.add(nodeId);
+                state.passiveCandidateIds?.delete?.(nodeId);
+            }
+            cardKeysToRemove.push(cardKey);
+        });
+
+        const knownCards = new Set(state.cards.values());
+        state.layer?.querySelectorAll?.('.mind-map-text-overlay-v2-card')?.forEach?.(card => {
+            if (knownCards.has(card)) {
+                return;
+            }
+
+            const nodeId = normalizeId(card?.dataset?.nodeId);
+            const entry = nodeId ? module?.nodeObjectsById?.get?.(nodeId) || null : null;
+            const cardContentType = String(card?.dataset?.contentType || '').trim().toLowerCase();
+            const isMediaCard =
+                isMediaOverlayExcluded(entry) ||
+                cardContentType === 'image' ||
+                cardContentType === 'video' ||
+                cardContentType === 'embed';
+            if (!isMediaCard) {
+                return;
+            }
+
+            if (entry) {
+                resumeSource(entry);
+            }
+            hideCard(card);
+            card.replaceChildren?.();
+            card.remove?.();
+        });
+
+        const selectedNodeId = normalizeId(module?.selectedNodeIdJs);
+        const activeSelectionNodeId = normalizeId(state.selectionNodeId);
+        const editingNodeId = normalizeId(state?.editing?.nodeId);
+        [selectedNodeId, activeSelectionNodeId, editingNodeId].forEach(nodeId => {
+            if (!nodeId) {
+                return;
+            }
+
+            const entry = module?.nodeObjectsById?.get?.(nodeId) || null;
+            if (!isMediaOverlayExcluded(entry)) {
+                return;
+            }
+
+            sourceIdsToResume.add(nodeId);
+            state.passiveCandidateIds?.delete?.(nodeId);
+            cardKeysToRemove.push(selectionCardKey(nodeId), editingCardKey(nodeId));
+            if (activeSelectionNodeId === nodeId) {
+                state.selectionNodeId = '';
+            }
+            if (editingNodeId === nodeId) {
+                state.editing = null;
+            }
+        });
+
+        if (options.resumeAllMedia === true && module?.nodeObjectsById?.forEach) {
+            module.nodeObjectsById.forEach((entry, nodeId) => {
+                if (isMediaOverlayExcluded(entry)) {
+                    sourceIdsToResume.add(normalizeId(nodeId || getNodeId(entry)));
+                }
+            });
+        }
+
+        sourceIdsToResume.forEach(nodeId => {
+            const entry = module?.nodeObjectsById?.get?.(nodeId) || null;
+            if (entry) {
+                resumeSource(entry);
+            }
+        });
+
+        let removedCount = 0;
+        new Set(cardKeysToRemove).forEach(cardKey => {
+            if (removeCard(state, cardKey)) {
+                removedCount += 1;
+            }
+        });
+
+        if (removedCount > 0) {
+            state.dirtyLayout = true;
+            module._overlayDirty = true;
+            module._lastOverlayKey = '';
+            syncLayerVisibility(module);
+        }
+
+        return removedCount;
+    }
+
+    function setCardMode(card, mode, interactive = true) {
+        if (!card) {
+            return;
+        }
+
+        const isInteractiveSelection = mode === 'selection' && interactive;
+        card.classList.toggle('is-selection', mode === 'selection');
+        card.classList.toggle('is-editing', mode === 'editing');
+        card.classList.toggle('mind-map-text-overlay-selectable', isInteractiveSelection);
+        card.classList.toggle('is-passive', mode === 'selection' && !interactive);
+        card.dataset.overlayMode = String(mode || '');
+        card.dataset.overlayInteractive = interactive ? 'true' : 'false';
+        card.style.pointerEvents = (mode === 'selection' && !interactive) ? 'none' : 'auto';
+    }
+
+    function preserveBodyScroll(card) {
+        const body = card?.querySelector?.('.mind-map-text-overlay-v2-body');
+        if (!body) {
+            return null;
+        }
+
+        const source = body._mindMapSourceScrollTarget || null;
+        if (source) {
+            return {
+                top: source.scrollTop || 0,
+                left: source.scrollLeft || 0
+            };
+        }
+
+        return {
+            top: body.scrollTop,
+            left: body.scrollLeft
+        };
+    }
+
+    function restoreBodyScroll(card, scrollState) {
+        if (!scrollState) {
+            return;
+        }
+
+        const body = card?.querySelector?.('.mind-map-text-overlay-v2-body');
+        if (!body) {
+            return;
+        }
+
+        const source = body._mindMapSourceScrollTarget || null;
+        if (source) {
+            syncScrollPositionByRatio(source, body);
+            return;
+        }
+
+        body.scrollTop = scrollState.top || 0;
+        body.scrollLeft = scrollState.left || 0;
+    }
+
+    function hashText(value) {
+        const text = String(value ?? '');
+        let hash = 0;
+        for (let i = 0; i < text.length; i += 1) {
+            hash = ((hash * 31) + text.charCodeAt(i)) | 0;
+        }
+
+        return String(hash >>> 0);
+    }
+
+    function getMemoSourceElement(entry) {
+        const host = getHostElement(entry);
+        if (!host) {
+            return null;
+        }
+
+        if (host.matches?.('.map-node-memo')) {
+            return host;
+        }
+
+        return host.querySelector?.('.map-node-memo') || host;
+    }
+
+    function buildMemoAgentOverlayKey(entry) {
+        const sourceRoot = getMemoSourceElement(entry);
+        if (!sourceRoot) {
+            return '';
+        }
+
+        const planPanel = sourceRoot.querySelector?.('.map-node-memo__agent-plan-panel') || null;
+        const consolePanel = sourceRoot.querySelector?.('.map-node-memo__agent-console-panel') || null;
+        if (!planPanel && !consolePanel) {
+            return '';
+        }
+
+        return JSON.stringify({
+            planOpen: String(sourceRoot.dataset?.agentPlanOpen || ''),
+            planReviewed: String(sourceRoot.dataset?.agentPlanReviewed || ''),
+            consoleOpen: String(sourceRoot.dataset?.agentConsoleOpen || ''),
+            consoleHeight: String(sourceRoot.dataset?.agentConsoleHeight || consolePanel?.style?.height || ''),
+            actionPending: String(sourceRoot.dataset?.agentActionPending || ''),
+            pendingAction: String(sourceRoot.dataset?.agentPendingAction || ''),
+            planDisplay: String(planPanel?.style?.display || ''),
+            consoleDisplay: String(consolePanel?.style?.display || ''),
+            planHash: hashText(planPanel?.textContent || ''),
+            consoleHash: hashText(consolePanel?.textContent || '')
+        });
+    }
+
+    function stripCloneIds(root) {
+        if (!root) {
+            return;
+        }
+
+        if (root.id) {
+            root.removeAttribute('id');
+        }
+
+        root.querySelectorAll?.('[id]').forEach(element => {
+            element.removeAttribute('id');
+        });
+    }
+
+    function prepareOverlayClone(root) {
+        if (!root) {
+            return null;
+        }
+
+        stripCloneIds(root);
+
+        const nodes = [root, ...Array.from(root.querySelectorAll?.('*') || [])];
+        nodes.forEach(node => {
+            if (!node?.style) {
+                return;
+            }
+
+            node.setAttribute?.('aria-hidden', 'true');
+            node.style.pointerEvents = 'none';
+
+            if (node.tagName === 'INPUT' || node.tagName === 'TEXTAREA') {
+                node.readOnly = true;
+                node.tabIndex = -1;
+            } else if (node.tagName === 'BUTTON') {
+                node.tabIndex = -1;
+            }
+        });
+
+        return root;
+    }
+
+    function clearSourcePresentationOverrides(root) {
+        if (!root) {
+            return null;
+        }
+
+        const targets = [root, ...Array.from(root.querySelectorAll?.('*') || [])];
+        targets.forEach(target => {
+            if (!target?.style) {
+                return;
+            }
+
+            target.classList?.remove?.('mind-map-v2-source-suspended');
+            target.classList?.remove?.('mind-map-text-overlay-source-suspended');
+            target.removeAttribute?.('data-text-overlay-source-suspended');
+            target.style.opacity = '';
+            target.style.caretColor = '';
+            target.style.contentVisibility = '';
+            target.style.containIntrinsicSize = '';
+            target.style.contain = '';
+        });
+
+        return root;
+    }
+
+    function cloneReadonlyFragment(sourceElement) {
+        if (!sourceElement) {
+            return null;
+        }
+
+        const clone = sourceElement.cloneNode(true);
+        if (clone && (sourceElement.tagName === 'TEXTAREA' || sourceElement.tagName === 'INPUT')) {
+            clone.value = sourceElement.value ?? sourceElement.getAttribute?.('value') ?? '';
+        }
+
+        clearSourcePresentationOverrides(clone);
+        clone.querySelectorAll?.('.map-node-memo__icon-popover')?.forEach?.(element => element.remove());
+        return prepareOverlayClone(clone);
+    }
+
+    function readComputedStyleValue(computed, property, cssName = null) {
+        if (!computed) {
+            return '';
+        }
+
+        const directValue = property ? computed[property] : '';
+        if (directValue !== null && directValue !== undefined && directValue !== '') {
+            return String(directValue);
+        }
+
+        if (cssName && typeof computed.getPropertyValue === 'function') {
+            const rawValue = computed.getPropertyValue(cssName);
+            if (rawValue !== null && rawValue !== undefined && rawValue !== '') {
+                return String(rawValue).trim();
+            }
+        }
+
+        return '';
+    }
+
+    const TEXT_OVERLAY_LAYOUT_SYNC_CSS_PROPERTIES = [
+        'padding-top',
+        'padding-right',
+        'padding-bottom',
+        'padding-left',
+        'overflow',
+        'overflow-x',
+        'overflow-y',
+        'scrollbar-gutter',
+        'scrollbar-width',
+        'scrollbar-color',
+        'text-decoration',
+        'text-decoration-line',
+        'text-decoration-thickness',
+        'text-underline-offset',
+        'text-shadow',
+        '-webkit-text-fill-color',
+        '-webkit-text-size-adjust'
+    ];
+
+    const TEXT_OVERLAY_LAYOUT_SYNC_CUSTOM_PROPERTIES = [
+        '--mind-map-text-scrollbar-size',
+        '--mind-map-text-scrollbar-size-x',
+        '--mind-map-text-scrollbar-size-y',
+        '--mind-map-text-scrollbar-gutter'
+    ];
+
+    function applyTextLayoutSurfaceFromSource(sourceElement, targetElement) {
+        if (!sourceElement || !targetElement?.style || typeof window?.getComputedStyle !== 'function') {
+            return;
+        }
+
+        const computed = window.getComputedStyle(sourceElement);
+        if (!computed) {
+            return;
+        }
+
+        TEXT_OVERLAY_LAYOUT_SYNC_CSS_PROPERTIES.forEach(cssName => {
+            const value = readComputedStyleValue(computed, null, cssName);
+            if (value) {
+                targetElement.style.setProperty(cssName, value, 'important');
+            }
+        });
+
+        TEXT_OVERLAY_LAYOUT_SYNC_CUSTOM_PROPERTIES.forEach(cssName => {
+            const value = readComputedStyleValue(computed, null, cssName);
+            if (value) {
+                targetElement.style.setProperty(cssName, value, 'important');
+            }
+        });
+    }
+
+    function applyInheritedTypographyFromSource(sourceElement, targetElement) {
+        if (!sourceElement || !targetElement?.style || typeof window?.getComputedStyle !== 'function') {
+            return;
+        }
+
+        const computed = window.getComputedStyle(sourceElement);
+        if (!computed) {
+            return;
+        }
+
+        const copyStyle = (property, value, cssName = null) => {
+            if (value === null || value === undefined || value === '') {
+                return;
+            }
+
+            if (cssName) {
+                targetElement.style.setProperty(cssName, value);
+                return;
+            }
+
+            targetElement.style[property] = value;
+        };
+
+        copyStyle('fontFamily', readComputedStyleValue(computed, 'fontFamily'));
+        copyStyle('fontSize', readComputedStyleValue(computed, 'fontSize'));
+        copyStyle('fontWeight', readComputedStyleValue(computed, 'fontWeight'));
+        copyStyle('fontStyle', readComputedStyleValue(computed, 'fontStyle'));
+        copyStyle('fontStretch', readComputedStyleValue(computed, 'fontStretch'));
+        copyStyle('lineHeight', readComputedStyleValue(computed, 'lineHeight'));
+        copyStyle('letterSpacing', readComputedStyleValue(computed, 'letterSpacing'));
+        copyStyle('wordSpacing', readComputedStyleValue(computed, 'wordSpacing'));
+        copyStyle('fontKerning', readComputedStyleValue(computed, 'fontKerning'));
+        copyStyle('fontFeatureSettings', readComputedStyleValue(computed, 'fontFeatureSettings'));
+        copyStyle('fontVariationSettings', readComputedStyleValue(computed, 'fontVariationSettings'));
+        copyStyle('fontOpticalSizing', readComputedStyleValue(computed, 'fontOpticalSizing'));
+        copyStyle('textRendering', readComputedStyleValue(computed, 'textRendering'));
+        copyStyle('color', readComputedStyleValue(computed, 'color'));
+        copyStyle('textSizeAdjust', readComputedStyleValue(computed, 'textSizeAdjust', 'text-size-adjust'));
+        copyStyle('boxSizing', readComputedStyleValue(computed, 'boxSizing', 'box-sizing'));
+        copyStyle('whiteSpace', readComputedStyleValue(computed, 'whiteSpace', 'white-space'));
+        copyStyle('wordBreak', readComputedStyleValue(computed, 'wordBreak', 'word-break'));
+        copyStyle('overflowWrap', readComputedStyleValue(computed, 'overflowWrap', 'overflow-wrap'));
+        copyStyle('wordWrap', readComputedStyleValue(computed, 'wordWrap', 'word-wrap'));
+        copyStyle('lineBreak', readComputedStyleValue(computed, 'lineBreak', 'line-break'));
+        copyStyle('hyphens', readComputedStyleValue(computed, 'hyphens', 'hyphens'));
+        copyStyle('tabSize', readComputedStyleValue(computed, 'tabSize', 'tab-size'));
+        copyStyle('textAlign', readComputedStyleValue(computed, 'textAlign', 'text-align'));
+        copyStyle('textIndent', readComputedStyleValue(computed, 'textIndent', 'text-indent'));
+        copyStyle('textTransform', readComputedStyleValue(computed, 'textTransform', 'text-transform'));
+        copyStyle('direction', readComputedStyleValue(computed, 'direction', 'direction'));
+        copyStyle('unicodeBidi', readComputedStyleValue(computed, 'unicodeBidi', 'unicode-bidi'));
+        copyStyle('writingMode', readComputedStyleValue(computed, 'writingMode', 'writing-mode'));
+        copyStyle('textOrientation', readComputedStyleValue(computed, 'textOrientation', 'text-orientation'));
+        copyStyle(null, readComputedStyleValue(computed, null, 'text-wrap'), 'text-wrap');
+        copyStyle(null, readComputedStyleValue(computed, null, 'text-wrap-mode'), 'text-wrap-mode');
+        copyStyle(null, readComputedStyleValue(computed, null, 'text-wrap-style'), 'text-wrap-style');
+        targetElement.style.setProperty('-webkit-font-smoothing', 'antialiased');
+        targetElement.style.setProperty('-moz-osx-font-smoothing', 'grayscale');
+    }
+
+    function getTypographySyncChildren(element) {
+        if (!element?.children?.length) {
+            return [];
+        }
+
+        return Array.from(element.children).filter(child =>
+            !!child &&
+            !child.classList?.contains?.('map-node-memo__icon-popover')
+        );
+    }
+
+    function applyTypographyTreeFromSource(sourceElement, targetElement) {
+        if (!sourceElement || !targetElement) {
+            return;
+        }
+
+        applyInheritedTypographyFromSource(sourceElement, targetElement);
+        applyTextLayoutSurfaceFromSource(sourceElement, targetElement);
+
+        const sourceChildren = getTypographySyncChildren(sourceElement);
+        const targetChildren = getTypographySyncChildren(targetElement);
+        const childCount = Math.min(sourceChildren.length, targetChildren.length);
+        for (let index = 0; index < childCount; index += 1) {
+            applyTypographyTreeFromSource(sourceChildren[index], targetChildren[index]);
+        }
+    }
+
+    function createReadonlyTextReplica(sourceElement) {
+        if (!sourceElement) {
+            return null;
+        }
+
+        const replica = document.createElement('div');
+        const computed = typeof window?.getComputedStyle === 'function'
+            ? window.getComputedStyle(sourceElement)
+            : null;
+        const isSingleLineInput = sourceElement.tagName === 'INPUT';
+        replica.className = sourceElement.className || '';
+        replica.textContent = sourceElement.value ?? sourceElement.textContent ?? '';
+        replica.setAttribute('aria-hidden', 'true');
+        replica.style.display = 'block';
+        replica.style.width = '100%';
+        replica.style.height = '100%';
+        replica.style.boxSizing = 'border-box';
+        replica.style.whiteSpace = isSingleLineInput
+            ? 'nowrap'
+            : readComputedStyleValue(computed, 'whiteSpace', 'white-space') || 'pre-wrap';
+        replica.style.overflow = isSingleLineInput
+            ? 'hidden'
+            : readComputedStyleValue(computed, 'overflow', 'overflow') || 'hidden';
+        replica.style.textOverflow = isSingleLineInput
+            ? readComputedStyleValue(computed, 'textOverflow', 'text-overflow') || 'ellipsis'
+            : readComputedStyleValue(computed, 'textOverflow', 'text-overflow');
+        replica.style.overflowWrap = readComputedStyleValue(computed, 'overflowWrap', 'overflow-wrap') || '';
+        replica.style.wordBreak = readComputedStyleValue(computed, 'wordBreak', 'word-break') || '';
+        replica.style.lineBreak = readComputedStyleValue(computed, 'lineBreak', 'line-break') || '';
+        replica.style.hyphens = readComputedStyleValue(computed, 'hyphens', 'hyphens') || '';
+        replica.style.pointerEvents = 'none';
+        replica.style.userSelect = 'none';
+        replica.style.webkitUserSelect = 'none';
+        applyTypographyTreeFromSource(sourceElement, replica);
+        clearSourcePresentationOverrides(replica);
+        return replica;
+    }
+
+    function getScrollableMax(element, axis) {
+        if (!element) {
+            return 0;
+        }
+
+        const scrollSize = axis === 'x'
+            ? Number(element.scrollWidth || 0)
+            : Number(element.scrollHeight || 0);
+        const clientSize = axis === 'x'
+            ? Number(element.clientWidth || 0)
+            : Number(element.clientHeight || 0);
+        return Math.max(0, scrollSize - clientSize);
+    }
+
+    function getMappedScrollPosition(fromElement, toElement, axis) {
+        const fromValue = axis === 'x'
+            ? Number(fromElement?.scrollLeft || 0)
+            : Number(fromElement?.scrollTop || 0);
+        const fromMax = getScrollableMax(fromElement, axis);
+        const toMax = getScrollableMax(toElement, axis);
+        if (toMax <= 0) {
+            return 0;
+        }
+
+        if (fromMax <= 0) {
+            return Math.max(0, Math.min(toMax, Math.round(fromValue)));
+        }
+
+        const ratio = Math.max(0, Math.min(1, fromValue / fromMax));
+        return Math.max(0, Math.min(toMax, Math.round(ratio * toMax)));
+    }
+
+    function setScrollPositionIfNeeded(element, axis, value) {
+        if (!element) {
+            return false;
+        }
+
+        const current = axis === 'x'
+            ? Number(element.scrollLeft || 0)
+            : Number(element.scrollTop || 0);
+        if (Math.abs(current - value) < 1) {
+            return false;
+        }
+
+        if (axis === 'x') {
+            element.scrollLeft = value;
+        } else {
+            element.scrollTop = value;
+        }
+        return true;
+    }
+
+    function syncScrollPositionByRatio(fromElement, toElement) {
+        if (!fromElement || !toElement) {
+            return false;
+        }
+
+        const nextTop = getMappedScrollPosition(fromElement, toElement, 'y');
+        const nextLeft = getMappedScrollPosition(fromElement, toElement, 'x');
+        const changedTop = setScrollPositionIfNeeded(toElement, 'y', nextTop);
+        const changedLeft = setScrollPositionIfNeeded(toElement, 'x', nextLeft);
+        return changedTop || changedLeft;
+    }
+
+    function getAllScrollableTargets(root) {
+        if (!root?.querySelectorAll) {
+            return [];
+        }
+
+        const selector = getScrollableSelector();
+        const targets = [];
+        if (root.matches?.(selector)) {
+            targets.push(root);
+        }
+
+        root.querySelectorAll?.(selector)?.forEach?.(target => {
+            targets.push(target);
+        });
+
+        return Array.from(new Set(targets.filter(Boolean)));
+    }
+
+    function linkOverlayScrollTarget(sourceTarget, cloneTarget) {
+        if (!sourceTarget || !cloneTarget) {
+            return;
+        }
+
+        cloneTarget._mindMapSourceScrollTarget = sourceTarget;
+        syncScrollPositionByRatio(sourceTarget, cloneTarget);
+    }
+
+    function linkOverlayCloneScrollTargets(sourceRoot, cloneRoot) {
+        const sourceTargets = getAllScrollableTargets(sourceRoot);
+        const cloneTargets = getAllScrollableTargets(cloneRoot);
+        const count = Math.min(sourceTargets.length, cloneTargets.length);
+        for (let index = 0; index < count; index += 1) {
+            linkOverlayScrollTarget(sourceTargets[index], cloneTargets[index]);
+        }
+    }
+
+    function syncCloneScrollPosition(sourceRoot, cloneRoot, selector) {
+        const source = sourceRoot?.querySelector?.(selector) || null;
+        const clone = cloneRoot?.querySelector?.(selector) || null;
+        if (!source || !clone) {
+            return;
+        }
+
+        clone._mindMapSourceScrollTarget = source;
+        syncScrollPositionByRatio(source, clone);
+    }
+
+    function getOverlayCloneScrollableTargets(root) {
+        if (!root?.querySelectorAll) {
+            return [];
+        }
+
+        const selector = getScrollableSelector();
+        const rawTargets = Array.from(root.querySelectorAll(selector) || []);
+        const targets = rawTargets.filter(target => {
+            if (!target) {
+                return false;
+            }
+
+            const parentScrollable = target.parentElement?.closest?.(selector) || null;
+            return !parentScrollable;
+        });
+        if (root.matches?.(selector)) {
+            targets.unshift(root);
+        }
+
+        return Array.from(new Set(targets.filter(Boolean)));
+    }
+
+    function syncOverlayCloneScrollPositions(sourceRoot, cloneRoot) {
+        if (!sourceRoot || !cloneRoot) {
+            return;
+        }
+
+        linkOverlayCloneScrollTargets(sourceRoot, cloneRoot);
+        getScrollSyncSelectors().forEach(selector => syncCloneScrollPosition(sourceRoot, cloneRoot, selector));
+    }
+
+    function syncReadonlyOverlayScrollTarget(module, target) {
+        const source = target?._mindMapSourceScrollTarget || null;
+        if (!target || !source) {
+            return;
+        }
+
+        if (target._mindMapReadonlyOverlayScrollSyncing === true) {
+            return;
+        }
+
+        source._mindMapReadonlyOverlayScrollSyncing = true;
+        try {
+            const changed = syncScrollPositionByRatio(target, source);
+            if (changed) {
+                const nodeId =
+                    normalizeId(source.dataset?.nodeId) ||
+                    normalizeId(source.closest?.('[data-node-id]')?.dataset?.nodeId) ||
+                    normalizeId(target.dataset?.nodeId) ||
+                    normalizeId(target.closest?.('[data-node-id]')?.dataset?.nodeId);
+                if (nodeId) {
+                    window.MindMapCss3DManager?.syncCss3dScrollFromElement?.(module, nodeId, target);
+                }
+                syncReadonlySourceNodeScrollState(module, source);
+            }
+        } finally {
+            requestAnimationFrame(() => {
+                source._mindMapReadonlyOverlayScrollSyncing = false;
+            });
+        }
+    }
+
+    function syncReadonlyOverlayCloneFromSource(target) {
+        const source = target?._mindMapSourceScrollTarget || null;
+        if (!target || !source) {
+            return;
+        }
+
+        if (source._mindMapReadonlyOverlayScrollSyncing === true) {
+            return;
+        }
+
+        target._mindMapReadonlyOverlayScrollSyncing = true;
+        try {
+            syncScrollPositionByRatio(source, target);
+        } finally {
+            requestAnimationFrame(() => {
+                target._mindMapReadonlyOverlayScrollSyncing = false;
+            });
+        }
+    }
+
+    function syncReadonlyOverlayCardScrollFromSource(card) {
+        if (!card) {
+            return false;
+        }
+
+        let synced = false;
+        const targets = getOverlayCloneScrollableTargets(card);
+        targets.forEach(target => {
+            if (!target?._mindMapSourceScrollTarget) {
+                return;
+            }
+
+            syncReadonlyOverlayCloneFromSource(target);
+            synced = true;
+        });
+
+        return synced;
+    }
+
+    function scheduleReadonlyOverlayCardScrollSync(card) {
+        if (!card || card._mindMapReadonlyOverlayCardScrollSyncScheduled === true) {
+            return;
+        }
+
+        card._mindMapReadonlyOverlayCardScrollSyncScheduled = true;
+        requestAnimationFrame(() => {
+            syncReadonlyOverlayCardScrollFromSource(card);
+            requestAnimationFrame(() => {
+                syncReadonlyOverlayCardScrollFromSource(card);
+                card._mindMapReadonlyOverlayCardScrollSyncScheduled = false;
+            });
+        });
+    }
+
+    function collectReadonlyOverlayMirrorTargets(sourceTarget) {
+        const targets = sourceTarget?._mindMapReadonlyOverlayCloneTargets;
+        if (!(targets instanceof Set) || targets.size === 0) {
+            return [];
+        }
+
+        const connectedTargets = [];
+        targets.forEach(target => {
+            if (!target || target.isConnected === false || target._mindMapSourceScrollTarget !== sourceTarget) {
+                targets.delete(target);
+                return;
+            }
+
+            connectedTargets.push(target);
+        });
+
+        return connectedTargets;
+    }
+
+    function syncReadonlySourceNodeScrollState(module, sourceTarget) {
+        if (!module?.nodeObjectsById || !sourceTarget) {
+            return;
+        }
+
+        const nodeId =
+            normalizeId(sourceTarget.dataset?.nodeId) ||
+            normalizeId(sourceTarget.closest?.('[data-node-id]')?.dataset?.nodeId);
+        if (!nodeId) {
+            return;
+        }
+
+        const nodeEntry = module.nodeObjectsById.get(nodeId);
+        if (!nodeEntry?.model) {
+            return;
+        }
+
+        window.MindMapCss3DManager?.syncCss3dScrollFromElement?.(module, nodeId, sourceTarget);
+
+        const sourceMaxScroll = Math.max(
+            0,
+            Number(sourceTarget.scrollHeight || 0) - Number(sourceTarget.clientHeight || 0)
+        );
+        const modelMaxScroll = Math.max(0, Number(nodeEntry.model.maxScroll || 0));
+        if (sourceMaxScroll <= 0 || modelMaxScroll <= 0) {
+            return;
+        }
+
+        const scrollRatio = Math.max(0, Math.min(1, Number(sourceTarget.scrollTop || 0) / sourceMaxScroll));
+        const nextOffset = Math.round(scrollRatio * modelMaxScroll);
+        if (!Number.isFinite(nextOffset)) {
+            return;
+        }
+
+        window.MindMapPipeline?.setScrollPosition?.(module, nodeId, nextOffset);
+    }
+
+    function syncReadonlySourceScroll(module, sourceTarget) {
+        const resolvedSource = sourceTarget?._mindMapSourceScrollTarget || sourceTarget || null;
+        if (!resolvedSource) {
+            return false;
+        }
+
+        const mirrorTargets = collectReadonlyOverlayMirrorTargets(resolvedSource);
+        mirrorTargets.forEach(target => syncReadonlyOverlayCloneFromSource(target));
+        syncReadonlySourceNodeScrollState(module, resolvedSource);
+        return mirrorTargets.length > 0;
+    }
+
+    function bindReadonlySourceScrollSync(module, sourceTarget, target) {
+        if (!module || !sourceTarget || !target || typeof sourceTarget.addEventListener !== 'function') {
+            return;
+        }
+
+        if (!(sourceTarget._mindMapReadonlyOverlayCloneTargets instanceof Set)) {
+            sourceTarget._mindMapReadonlyOverlayCloneTargets = new Set();
+        }
+        sourceTarget._mindMapReadonlyOverlayCloneTargets.add(target);
+
+        if (sourceTarget._mindMapReadonlyOverlaySourceScrollModule === module &&
+            sourceTarget._mindMapReadonlyOverlaySourceScrollHandler) {
+            return;
+        }
+
+        if (sourceTarget._mindMapReadonlyOverlaySourceScrollHandler) {
+            sourceTarget.removeEventListener('scroll', sourceTarget._mindMapReadonlyOverlaySourceScrollHandler);
+        }
+
+        const handler = () => {
+            syncReadonlySourceScroll(module, sourceTarget);
+        };
+
+        sourceTarget._mindMapReadonlyOverlaySourceScrollModule = module;
+        sourceTarget._mindMapReadonlyOverlaySourceScrollHandler = handler;
+        sourceTarget.addEventListener('scroll', handler, { passive: true });
+    }
+
+    function getWheelDeltaPixels(event) {
+        const mode = Number(event?.deltaMode || 0);
+        const multiplier = mode === 1
+            ? 16
+            : mode === 2
+                ? Math.max(1, Number(window?.innerHeight || 800))
+                : 1;
+        return {
+            x: Number(event?.deltaX || 0) * multiplier,
+            y: Number(event?.deltaY || 0) * multiplier
+        };
+    }
+
+    function scrollSourceFromOverlayWheel(module, target, sourceTarget, event) {
+        if (!sourceTarget || !event) {
+            return false;
+        }
+
+        const delta = getWheelDeltaPixels(event);
+        const maxTop = getScrollableMax(sourceTarget, 'y');
+        const maxLeft = getScrollableMax(sourceTarget, 'x');
+        const horizontalDelta = event.shiftKey && Math.abs(delta.x) < Math.abs(delta.y)
+            ? delta.y
+            : delta.x;
+        const nextTop = Math.max(0, Math.min(maxTop, Number(sourceTarget.scrollTop || 0) + delta.y));
+        const nextLeft = Math.max(0, Math.min(maxLeft, Number(sourceTarget.scrollLeft || 0) + horizontalDelta));
+        const changedTop = setScrollPositionIfNeeded(sourceTarget, 'y', nextTop);
+        const changedLeft = setScrollPositionIfNeeded(sourceTarget, 'x', nextLeft);
+        const changed = changedTop || changedLeft;
+        if (!changed) {
+            return false;
+        }
+
+        syncReadonlySourceNodeScrollState(module, sourceTarget);
+        syncReadonlyOverlayCloneFromSource(target);
+        requestAnimationFrame(() => syncReadonlyOverlayCloneFromSource(target));
+        return true;
+    }
+
+    function shouldRouteReadonlyOverlayWheelToZoom(module, event) {
+        if (!event) {
+            return false;
+        }
+
+        if (window.MindMapInteractions?.isTrackpadPinchGesture?.(event) === true) {
+            return true;
+        }
+
+        if (typeof window.MindMapInteractions?.shouldZoomFromWheelEvent === 'function') {
+            return window.MindMapInteractions.shouldZoomFromWheelEvent(module, event) === true;
+        }
+
+        const nav = typeof navigator !== 'undefined' ? navigator : null;
+        const isMacLike = /mac|iphone|ipad/i.test(String(nav?.platform || nav?.userAgent || ''));
+        const modifierActive = isMacLike ? event.metaKey === true : event.ctrlKey === true;
+        return module?.swapWheelZoomControls === true ? modifierActive : !modifierActive;
+    }
+
+    function bindReadonlyOverlayScrollSync(module, target) {
+        if (!target || typeof target.addEventListener !== 'function') {
+            return;
+        }
+
+        if (target._mindMapReadonlyOverlayScrollSyncModule === module &&
+            target._mindMapReadonlyOverlayScrollSyncHandler) {
+            return;
+        }
+
+        if (target._mindMapReadonlyOverlayScrollSyncHandler) {
+            target.removeEventListener('scroll', target._mindMapReadonlyOverlayScrollSyncHandler);
+        }
+
+        const handler = () => {
+            syncReadonlyOverlayScrollTarget(module, target);
+        };
+
+        target._mindMapReadonlyOverlayScrollSyncModule = module;
+        target._mindMapReadonlyOverlayScrollSyncHandler = handler;
+        target.addEventListener('scroll', handler, { passive: true });
+    }
+
+    function bindReadonlyOverlayWheelRouting(module, target) {
+        if (!module || !target || typeof target.addEventListener !== 'function') {
+            return;
+        }
+
+        if (target._mindMapReadonlyOverlayWheelModule === module && target._mindMapReadonlyOverlayWheelHandler) {
+            return;
+        }
+
+        if (target._mindMapReadonlyOverlayWheelHandler) {
+            target.removeEventListener('wheel', target._mindMapReadonlyOverlayWheelHandler);
+        }
+
+        const routeToCss3dSource = (event) => {
+            const sourceTarget = target?._mindMapSourceScrollTarget || null;
+            if (!sourceTarget) {
+                return false;
+            }
+
+            if (scrollSourceFromOverlayWheel(module, target, sourceTarget, event)) {
+                event.preventDefault();
+                event.stopPropagation();
+                return true;
+            }
+
+            return false;
+        };
+
+        const handler = (event) => {
+            if (shouldRouteReadonlyOverlayWheelToZoom(module, event)) {
+                window.MindMapInteractions?.routeWheelEventToZoom?.(module, event);
+                return;
+            }
+
+            if (routeToCss3dSource(event)) {
+                return;
+            }
+
+            const isScrollable = target.scrollHeight > target.clientHeight;
+            if (isScrollable) {
+                const handledByScroll =
+                    window.MindMapInteractions?.applyCtrlWheelToScrollableElement?.(
+                        module,
+                        target,
+                        event.deltaY,
+                        () => syncReadonlyOverlayScrollTarget(module, target)
+                    ) === true;
+                if (handledByScroll) {
+                    event.preventDefault();
+                    event.stopPropagation();
+                    return;
+                }
+            }
+
+            window.MindMapInteractions?.routeCtrlWheelEventToVerticalScroll?.(module, event);
+        };
+
+        target._mindMapReadonlyOverlayWheelModule = module;
+        target._mindMapReadonlyOverlayWheelHandler = handler;
+        target.addEventListener('wheel', handler, { passive: false });
+    }
+
+    function bindReadonlyOverlayPanRouting(module, target) {
+        if (!module || !target || typeof target.addEventListener !== 'function') {
+            return;
+        }
+
+        if (target._mindMapReadonlyOverlayPanModule === module && target._mindMapReadonlyOverlayPanHandler) {
+            return;
+        }
+
+        if (target._mindMapReadonlyOverlayPanHandler) {
+            target.removeEventListener('mousedown', target._mindMapReadonlyOverlayPanHandler);
+        }
+
+        const handler = (event) => {
+            if (event?.button !== 1 && event?.button !== 2) {
+                return;
+            }
+
+            window.MindMapInteractions?.beginPanFromMouseEvent?.(module, event, target);
+        };
+
+        target._mindMapReadonlyOverlayPanModule = module;
+        target._mindMapReadonlyOverlayPanHandler = handler;
+        target.addEventListener('mousedown', handler, { passive: false });
+    }
+
+    function bindReadonlyOverlayPrimaryPointerRouting(module, root, sourceRoot) {
+        if (!module || !root || typeof root.addEventListener !== 'function') {
+            return;
+        }
+
+        root._mindMapReadonlyOverlaySourceRoot = sourceRoot || null;
+
+        if (root._mindMapReadonlyOverlayPrimaryPointerModule === module &&
+            root._mindMapReadonlyOverlayPrimaryPointerHandler) {
+            return;
+        }
+
+        if (root._mindMapReadonlyOverlayPrimaryPointerHandler) {
+            root.removeEventListener('mousedown', root._mindMapReadonlyOverlayPrimaryPointerHandler);
+            root.removeEventListener('mouseup', root._mindMapReadonlyOverlayPrimaryPointerHandler);
+        }
+
+        const handler = (event) => {
+            if (!event || event.button !== 0) {
+                return;
+            }
+
+            const nodeId =
+                normalizeId(root.dataset.nodeId) ||
+                normalizeId(root._mindMapReadonlyOverlaySourceRoot?.dataset?.nodeId) ||
+                normalizeId(root.closest?.('[data-node-id]')?.dataset?.nodeId);
+
+            if (!nodeId) {
+                return;
+            }
+
+            if (event.type === 'mousedown') {
+                root._mindMapReadonlyOverlayPrimaryPointerStart = {
+                    x: Number(event.clientX || 0),
+                    y: Number(event.clientY || 0)
+                };
+                window.MindMapInteractions?.prepareOverlayPrimaryPointer?.(module);
+                root._mindMapReadonlyOverlayDragStarted = false;
+                if (root.dataset.overlayInteractive !== 'true') {
+                    root._mindMapReadonlyOverlayDragStarted =
+                        window.MindMapInteractions?.beginOverlayNodeDrag?.(module, event, nodeId) === true;
+                }
+                if (root.dataset.overlayInteractive !== 'true') {
+                    event.preventDefault();
+                    event.stopPropagation();
+                }
+                return;
+            }
+
+            const start = root._mindMapReadonlyOverlayPrimaryPointerStart || null;
+
+            if (module?.isSelecting === true || !start) {
+                root._mindMapReadonlyOverlayDragStarted = false;
+                root._mindMapReadonlyOverlayPrimaryPointerStart = null;
+                return;
+            }
+
+            if (module?._overlayPointerDragActive === true ||
+                module?.isDraggingNode === true ||
+                module?.isDraggingMultipleNodes === true ||
+                root._mindMapReadonlyOverlayDragStarted === true) {
+                root._mindMapReadonlyOverlayDragStarted = false;
+                root._mindMapReadonlyOverlayPrimaryPointerStart = null;
+                return;
+            }
+
+            const interactive = root.dataset.overlayInteractive === 'true';
+            root._mindMapReadonlyOverlayPrimaryPointerStart = null;
+            const movedEnough =
+                !!start &&
+                (Math.abs(Number(event.clientX || 0) - start.x) > 4 ||
+                    Math.abs(Number(event.clientY || 0) - start.y) > 4);
+            if (interactive && movedEnough) {
+                return;
+            }
+
+            const result = window.MindMapInteractions?.handleOverlayPrimaryPointer?.(module, nodeId, {
+                event,
+                target: event.target,
+                shiftKey: !!event.shiftKey,
+                ctrlKey: !!event.ctrlKey,
+                metaKey: !!event.metaKey
+            });
+
+            if (!result?.handled) {
+                return;
+            }
+
+            if (result.suppressDefault !== false) {
+                event.preventDefault();
+                event.stopPropagation();
+            }
+        };
+
+        root._mindMapReadonlyOverlayPrimaryPointerModule = module;
+        root._mindMapReadonlyOverlayPrimaryPointerHandler = handler;
+        root.addEventListener('mousedown', handler, { passive: false });
+        root.addEventListener('mouseup', handler, { passive: false });
+    }
+
+    function applyPassiveAgentOverlayControlPassthrough(root, interactive) {
+        if (!root?.classList?.contains?.('mind-map-text-overlay-v2-source-clone')) {
+            return;
+        }
+
+        if (String(root.dataset?.overlayCloneMode || '').trim().toLowerCase() !== 'agent-memo') {
+            return;
+        }
+
+        root.querySelectorAll?.([
+            '.map-node-memo__icon-wrap',
+            '.map-node-memo__icon-wrap *',
+            '.map-node-memo__agent-actions',
+            '.map-node-memo__agent-actions *',
+            '.map-node-memo__agent-results',
+            '.map-node-memo__agent-results *'
+        ].join(', '))?.forEach?.(element => {
+            if (!element?.style) {
+                return;
+            }
+
+            element.style.pointerEvents = interactive ? 'auto' : 'none';
+            element.style.userSelect = interactive ? 'text' : 'none';
+            element.style.webkitUserSelect = interactive ? 'text' : 'none';
+        });
+    }
+
+    function refreshOverlayCloneInteractivity(module, root, interactive, fallbackSourceRoot = null) {
+        if (!root) {
+            return;
+        }
+
+        const candidates = [root, ...Array.from(root.querySelectorAll?.('*') || [])];
+        candidates.forEach(candidate => {
+            if (!candidate) {
+                return;
+            }
+
+            const sourceRoot = candidate._mindMapReadonlyOverlaySourceRoot || (candidate === root ? fallbackSourceRoot : null);
+            if (!sourceRoot) {
+                return;
+            }
+
+            applyOverlayCloneInteractivity(module, candidate, interactive, sourceRoot);
+        });
+    }
+
+    function applyOverlayCloneInteractivity(module, root, interactive, sourceRoot = null) {
+        if (!root) {
+            return;
+        }
+
+        root.dataset.overlayInteractive = interactive ? 'true' : 'false';
+        root._mindMapReadonlyOverlaySourceRoot = sourceRoot || root._mindMapReadonlyOverlaySourceRoot || null;
+        if (root.classList?.contains?.('mind-map-text-overlay-v2-source-clone')) {
+            root.style.pointerEvents = interactive ? 'auto' : 'none';
+            root.style.userSelect = interactive ? 'text' : 'none';
+            root.style.webkitUserSelect = interactive ? 'text' : 'none';
+        }
+        if (root.classList?.contains?.('mind-map-text-overlay-v2-content-shell')) {
+            root.style.pointerEvents = 'none';
+        }
+        if (!interactive && root._mindMapReadonlyOverlaySourceRoot) {
+            bindReadonlyOverlayPrimaryPointerRouting(module, root, root._mindMapReadonlyOverlaySourceRoot);
+        }
+
+        if (root.classList?.contains?.('mind-map-text-overlay-v2-fragment')) {
+            root.style.pointerEvents = interactive ? 'auto' : 'none';
+            root.style.userSelect = interactive ? 'text' : 'none';
+            root.style.webkitUserSelect = interactive ? 'text' : 'none';
+        }
+
+        if (root.classList?.contains?.('mind-map-text-overlay-v2-content-shell')) {
+            root.querySelectorAll?.('.mind-map-text-overlay-v2-fragment')?.forEach?.(fragment => {
+                if (!fragment?.style) {
+                    return;
+                }
+
+                fragment.style.pointerEvents = interactive ? 'auto' : 'none';
+                fragment.style.userSelect = interactive ? 'text' : 'none';
+                fragment.style.webkitUserSelect = interactive ? 'text' : 'none';
+            });
+        }
+
+        applyPassiveAgentOverlayControlPassthrough(root, interactive);
+
+        root.querySelectorAll?.('.node-prompt-copy-button, .node-prompt-copy-button *')?.forEach?.(element => {
+            if (!element?.style) {
+                return;
+            }
+
+            element.style.pointerEvents = 'auto';
+            element.style.userSelect = 'none';
+            element.style.webkitUserSelect = 'none';
+            element.style.cursor = 'pointer';
+        });
+
+        const scrollTargets = getOverlayCloneScrollableTargets(root);
+        scrollTargets.forEach(target => {
+            target.classList.add('mind-map-text-overlay-v2-body');
+            target.style.pointerEvents = 'auto';
+            bindReadonlyOverlayScrollSync(module, target);
+            bindReadonlyOverlayWheelRouting(module, target);
+            bindReadonlyOverlayPanRouting(module, target);
+            bindReadonlySourceScrollSync(module, target._mindMapSourceScrollTarget || null, target);
+            if (!interactive) {
+                target.style.cursor = '';
+                target.style.userSelect = 'none';
+                target.style.webkitUserSelect = 'none';
+                return;
+            }
+
+            target.style.cursor = 'text';
+            target.style.userSelect = 'text';
+            target.style.webkitUserSelect = 'text';
+
+            target.querySelectorAll?.('*')?.forEach?.(element => {
+                if (!element?.style) {
+                    return;
+                }
+
+                element.style.pointerEvents = 'auto';
+                element.style.userSelect = 'text';
+                element.style.webkitUserSelect = 'text';
+            });
+        });
+    }
+
+    function applyReadonlyOverlayContainerStyles(clone, type, options = {}) {
+        if (!clone) {
+            return null;
+        }
+
+        const renderMode = String(options.renderMode || '').trim().toLowerCase();
+        const preserveAgentPanels = renderMode === 'agent-memo';
+
+        // CSS3D is the canonical readonly renderer. Source clones must not
+        // receive legacy overlay shell layout classes, or they drift away
+        // from CSS3D's DOM/CSS contract and markdown can collapse/clamp.
+        clone.classList.add('mind-map-text-overlay-v2-source-clone');
+        clone.dataset.overlayCloneType = String(type || '');
+        clone.dataset.overlayCloneMode = renderMode;
+        clone.classList.remove('mind-map-v2-source-suspended');
+        clone.classList.remove('selected');
+        clone.style.pointerEvents = '';
+        clone.style.maxWidth = 'none';
+        clone.style.minWidth = '0';
+        clone.style.contentVisibility = 'visible';
+        clone.style.containIntrinsicSize = 'auto';
+        clone.style.contain = 'layout style';
+        clone.style.setProperty('--mind-map-text-scrollbar-size', '8px');
+        clone.style.setProperty('--mind-map-text-scrollbar-size-x', '8px');
+        clone.style.setProperty('--mind-map-text-scrollbar-size-y', '8px');
+        clone.style.setProperty('--mind-map-text-scrollbar-gutter', '14px');
+
+        const consolePanel = clone.querySelector?.('.map-node-memo__agent-console-panel') || null;
+        if (consolePanel && !preserveAgentPanels) {
+            // Agent console stays on the CSS3D source path because it is laid
+            // out as an absolute panel outside the main shell. Duplicating it
+            // inside the screen-space overlay drifts/clips the console body.
+            consolePanel.style.display = 'none';
+            consolePanel.setAttribute('aria-hidden', 'true');
+        }
+
+        return clone;
+    }
+
+    function finalizeReadonlySourceClone(module, sourceRoot, clone, type, interactive, options = {}) {
+        const styledClone = applyReadonlyOverlayContainerStyles(clone, type, options);
+        if (!styledClone) {
+            return null;
+        }
+
+        applyTypographyTreeFromSource(sourceRoot, styledClone);
+        syncOverlayCloneScrollPositions(sourceRoot, styledClone);
+        applyOverlayCloneInteractivity(module, styledClone, interactive);
+        return { container: styledClone };
+    }
+
+    function createReadonlyOverlayFromSource(module, entry, options = {}) {
+        const sourceRoot = options.sourceRoot || getReadonlyCloneSourceElement(entry);
+        if (!sourceRoot) {
+            return null;
+        }
+
+        const interactive = options.interactive === true;
+        const type = getContentType(entry);
+        const renderMode = String(options.renderMode || getReadonlySelectionMode(entry) || type || '').trim().toLowerCase();
+        const clone = clearSourcePresentationOverrides(sourceRoot.cloneNode(true));
+        const preparedClone = prepareOverlayClone(clone);
+        if (!preparedClone) {
+            return null;
+        }
+
+        return finalizeReadonlySourceClone(module, sourceRoot, preparedClone, type, interactive, { renderMode: renderMode });
+    }
+
+    function getRelativeFragmentPlacement(hostElement, sourceElement, hostBaseWidth, hostBaseHeight) {
+        if (!hostElement || !sourceElement) {
+            return null;
+        }
+
+        const hostRect = hostElement.getBoundingClientRect();
+        const sourceRect = sourceElement.getBoundingClientRect();
+        const scaleX = Math.max(0.0001, Number(hostRect.width || 0) / Math.max(1, Number(hostBaseWidth || 1)));
+        const scaleY = Math.max(0.0001, Number(hostRect.height || 0) / Math.max(1, Number(hostBaseHeight || 1)));
+        const rawLeft = (sourceRect.left - hostRect.left) / scaleX;
+        const rawTop = (sourceRect.top - hostRect.top) / scaleY;
+        const left = Math.round(rawLeft);
+        const top = Math.round(rawTop);
+        const measuredWidth = Number(sourceElement.offsetWidth || 0);
+        const measuredHeight = Number(sourceElement.offsetHeight || 0);
+        const baseWidth = Math.max(
+            1,
+            Math.round(measuredWidth > 0 ? measuredWidth : Number(sourceRect.width / scaleX || 1))
+        ) + PASSIVE_OVERLAY_FRAGMENT_WIDTH_BIAS_PX;
+        const baseHeight = Math.max(
+            1,
+            Math.round(measuredHeight > 0 ? measuredHeight : Number(sourceRect.height / scaleY || 1))
+        );
+
+        return {
+            left: left,
+            top: top,
+            width: baseWidth,
+            height: baseHeight
+        };
+    }
+
+    function appendReadonlyFragment(shell, hostElement, sourceElement, cloneElement, hostBaseWidth, hostBaseHeight) {
+        if (!shell || !hostElement || !sourceElement || !cloneElement) {
+            return false;
+        }
+
+        const placement = getRelativeFragmentPlacement(hostElement, sourceElement, hostBaseWidth, hostBaseHeight);
+        if (!placement) {
+            return false;
+        }
+
+        cloneElement.classList.add('mind-map-text-overlay-v2-fragment');
+        applyTypographyTreeFromSource(sourceElement, cloneElement);
+        cloneElement.style.position = 'absolute';
+        cloneElement.style.left = `${placement.left}px`;
+        cloneElement.style.top = `${placement.top}px`;
+        cloneElement.style.width = `${placement.width}px`;
+        cloneElement.style.height = `${placement.height}px`;
+        cloneElement.style.margin = '0';
+        cloneElement.style.pointerEvents = 'none';
+        linkOverlayCloneScrollTargets(sourceElement, cloneElement);
+        shell.appendChild(cloneElement);
+        return true;
+    }
+
+    function appendReadonlyContentRootClone(shell, hostElement, sourceElement, hostBaseWidth, hostBaseHeight) {
+        if (!shell || !hostElement || !sourceElement || sourceElement === hostElement) {
+            return false;
+        }
+
+        const clone = cloneReadonlyFragment(sourceElement);
+        if (!clone) {
+            return false;
+        }
+
+        return appendReadonlyFragment(shell, hostElement, sourceElement, clone, hostBaseWidth, hostBaseHeight);
+    }
+
+    function isVisibleOverlaySourceElement(element) {
+        return !!element &&
+            element.style?.display !== 'none' &&
+            (Number(element.offsetWidth || 0) > 0 || Number(element.offsetHeight || 0) > 0);
+    }
+
+    function createReadonlyContentOnlyShell(module, entry, options = {}) {
+        const hostElement = getReadonlySelectionSourceRoot(entry);
+        if (!hostElement) {
+            return null;
+        }
+
+        const contentSourceRoot =
+            hostElement.querySelector?.('.node-content-wrapper, .node-content') || hostElement;
+        const model = getModel(entry);
+        const hostBaseWidth = Math.max(1, Number(hostElement.offsetWidth || model?.width || model?.Width || 1));
+        const hostBaseHeight = Math.max(1, Number(hostElement.offsetHeight || model?.height || model?.Height || 1));
+        const shell = document.createElement('div');
+        const type = getContentType(entry);
+        const interactive = options.interactive === true;
+        let appended = false;
+
+        shell.className = 'mind-map-text-overlay-v2-source-clone mind-map-text-overlay-v2-content-shell';
+        shell.dataset.overlayCloneType = String(type || '');
+        shell.style.position = 'relative';
+        shell.style.width = `${hostBaseWidth}px`;
+        shell.style.height = `${hostBaseHeight}px`;
+        shell.style.overflow = 'visible';
+        shell.style.pointerEvents = 'none';
+        shell.style.background = 'transparent';
+        shell.style.border = '0';
+        shell.style.boxShadow = 'none';
+        shell.style.outline = 'none';
+        applyInheritedTypographyFromSource(contentSourceRoot, shell);
+
+        const appendFragmentClone = (sourceElement) => {
+            if (!isVisibleOverlaySourceElement(sourceElement)) {
+                return;
+            }
+
+            const clone = cloneReadonlyFragment(sourceElement);
+            if (!clone) {
+                return;
+            }
+
+            appended = appendReadonlyFragment(
+                shell,
+                hostElement,
+                sourceElement,
+                clone,
+                hostBaseWidth,
+                hostBaseHeight
+            ) || appended;
+        };
+
+        const appendCustomFragmentClone = (sourceElement, clone) => {
+            if (!isVisibleOverlaySourceElement(sourceElement) || !clone) {
+                return;
+            }
+
+            appended = appendReadonlyFragment(
+                shell,
+                hostElement,
+                sourceElement,
+                clone,
+                hostBaseWidth,
+                hostBaseHeight
+            ) || appended;
+        };
+
+        if (type === 'memo') {
+            appendFragmentClone(hostElement.querySelector?.('.map-node-memo__icon-wrap') || null);
+
+            const titleInput = hostElement.querySelector?.('.map-node-memo__title') || null;
+            appendCustomFragmentClone(titleInput, createReadonlyTextReplica(titleInput));
+
+            const primarySelectors = getPrimaryContentSelector();
+            const primaryElements = primarySelectors
+                ? Array.from(hostElement.querySelectorAll?.(primarySelectors) || [])
+                : [];
+            primaryElements.forEach(appendFragmentClone);
+        } else {
+            appended = appendReadonlyContentRootClone(
+                shell,
+                hostElement,
+                contentSourceRoot,
+                hostBaseWidth,
+                hostBaseHeight
+            ) || appended;
+
+            if (!appended) {
+                const visibleContentChildren = Array.from(contentSourceRoot.children || [])
+                    .filter(isVisibleOverlaySourceElement);
+
+                if (visibleContentChildren.length > 0) {
+                    visibleContentChildren.forEach(appendFragmentClone);
+                } else {
+                    const primarySelectors = getPrimaryContentSelector();
+                    const primaryElements = primarySelectors
+                        ? Array.from(contentSourceRoot.querySelectorAll?.(primarySelectors) || [])
+                        : [];
+                    primaryElements.forEach(appendFragmentClone);
+                }
+            }
+        }
+
+        if (!appended) {
+            return null;
+        }
+
+        syncOverlayCloneScrollPositions(hostElement, shell);
+        applyOverlayCloneInteractivity(module, shell, interactive, hostElement);
+        return { container: shell, sourceRoot: hostElement };
+    }
+
+    function createReadonlyMemoShellClone(module, entry, options = {}) {
+        const hostElement = getReadonlySelectionSourceRoot(entry);
+        if (!hostElement) {
+            return null;
+        }
+
+        const sourceRoot = hostElement.querySelector?.('.map-node-memo__shell') || null;
+        if (!sourceRoot) {
+            return null;
+        }
+
+        const interactive = options.interactive === true;
+        const clone = cloneReadonlyFragment(sourceRoot);
+        if (!clone) {
+            return null;
+        }
+
+        clone.classList.add('mind-map-text-overlay-v2-readonly-memo-surface');
+        clone.querySelectorAll?.([
+            '.map-node-memo__icon-popover',
+            '.map-node-memo__agent-actions',
+            '.map-node-memo__agent-console-panel',
+            '.map-node-memo__agent-running-indicator'
+        ].join(', '))?.forEach?.(element => element.remove());
+
+        const titleInput = clone.querySelector?.('.map-node-memo__title') || null;
+        if (titleInput) {
+            titleInput.readOnly = true;
+            titleInput.disabled = false;
+            titleInput.tabIndex = interactive ? 0 : -1;
+            titleInput.style.pointerEvents = interactive ? 'auto' : 'none';
+            titleInput.style.userSelect = interactive ? 'text' : 'none';
+            titleInput.style.webkitUserSelect = interactive ? 'text' : 'none';
+        }
+
+        const bodyView = clone.querySelector?.('.map-node-memo__body-view') || null;
+        if (bodyView) {
+            bodyView.style.display = '';
+            bodyView.setAttribute('aria-hidden', 'false');
+        }
+
+        clone.querySelectorAll?.('.map-node-memo__body')?.forEach?.(element => element.remove());
+        syncOverlayCloneScrollPositions(sourceRoot, clone);
+        applyOverlayCloneInteractivity(module, clone, interactive, hostElement);
+        return { container: clone, sourceRoot: hostElement };
+    }
+
+    function createReadonlyAgentMemoSourceClone(module, entry, options = {}) {
+        const hostElement = getReadonlySelectionSourceRoot(entry);
+        if (!hostElement) {
+            return null;
+        }
+
+        return createReadonlyOverlayFromSource(module, entry, {
+            ...options,
+            sourceRoot: hostElement,
+            renderMode: 'agent-memo'
+        });
+    }
+
+    function createReadonlySelectionShell(module, entry, options = {}) {
+        const mode = getReadonlySelectionMode(entry);
+        if (mode === 'agent-memo') {
+            // Agent memo nodes must mirror the CSS3D source as-is. Their
+            // auxiliary plan/console panels live outside the simplified memo
+            // shell, so the readonly overlay needs the full host clone.
+            return createReadonlyAgentMemoSourceClone(module, entry, options);
+        }
+
+        if (mode === 'memo') {
+            // 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);
+        }
+
+        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 null;
+    }
+
+    function buildOverlayViewKey(module, snapshot) {
+        if (!snapshot) {
+            return '';
+        }
+
+        const isInteractive =
+            !!module?.isZooming ||
+            !!module?.isPanning ||
+            !!module?.isDraggingNode ||
+            !!module?.isDraggingMultipleNodes ||
+            !!module?.isResizing ||
+            !!module?.isWindowResizing;
+        const precision = isInteractive ? 4 : 2;
+        const round = value => Number(value || 0).toFixed(precision);
+
+        return [
+            round(snapshot.x),
+            round(snapshot.y),
+            round(snapshot.z),
+            round(snapshot.cursorX),
+            round(snapshot.cursorY)
+        ].join('|');
+    }
+
+    function isCameraViewTransformCompatible(module) {
+        const camera = module?.camera || null;
+        if (!camera) {
+            return false;
+        }
+
+        const rotation = camera.rotation || null;
+        const tolerance = 0.0001;
+        return !!rotation &&
+            Math.abs(Number(rotation.x || 0)) < tolerance &&
+            Math.abs(Number(rotation.y || 0)) < tolerance &&
+            Math.abs(Number(rotation.z || 0)) < tolerance;
+    }
+
+    function buildLayerLayoutSnapshot(module, snapshot = null) {
+        const container = module?.container || null;
+        const camera = module?.camera || null;
+        const view = snapshot || (typeof module?.buildViewStateSnapshot === 'function'
+            ? module.buildViewStateSnapshot()
+            : null);
+        if (!container || !camera || !view) {
+            return null;
+        }
+
+        const width = Math.max(1, Number(container.clientWidth || container.offsetWidth || 0));
+        const height = Math.max(1, Number(container.clientHeight || container.offsetHeight || 0));
+        const fov = Number(camera.fov || 0);
+        if (!(fov > 0) || !(view.z > 0)) {
+            return null;
+        }
+
+        const vfov = (fov * Math.PI) / 180;
+        const viewHeight = 2 * Math.tan(vfov / 2) * Number(view.z || 0);
+        if (!(viewHeight > 0)) {
+            return null;
+        }
+
+        return {
+            x: Number(view.x || 0),
+            y: Number(view.y || 0),
+            z: Number(view.z || 0),
+            width,
+            height,
+            fov,
+            pixelsPerWorld: height / viewHeight
+        };
+    }
+
+    function clearLayerTransform(layer) {
+        if (!layer?.style) {
+            return;
+        }
+
+        layer.style.transformOrigin = '';
+        layer.style.transform = '';
+    }
+
+    function applyLayerViewTransform(layer, baseSnapshot, nextSnapshot) {
+        if (!layer?.style || !baseSnapshot || !nextSnapshot) {
+            return false;
+        }
+
+        const basePixelsPerWorld = Number(baseSnapshot.pixelsPerWorld || 0);
+        const nextPixelsPerWorld = Number(nextSnapshot.pixelsPerWorld || 0);
+        if (!(basePixelsPerWorld > 0) || !(nextPixelsPerWorld > 0)) {
+            return false;
+        }
+
+        const scale = nextPixelsPerWorld / basePixelsPerWorld;
+        const centerX = nextSnapshot.width * 0.5;
+        const centerY = nextSnapshot.height * 0.5;
+        const translateX =
+            (centerX * (1 - scale)) +
+            ((Number(baseSnapshot.x || 0) - Number(nextSnapshot.x || 0)) * nextPixelsPerWorld);
+        const translateY =
+            (centerY * (1 - scale)) +
+            ((Number(nextSnapshot.y || 0) - Number(baseSnapshot.y || 0)) * nextPixelsPerWorld);
+
+        layer.style.transformOrigin = '0 0';
+        layer.style.transform = `translate(${translateX}px, ${translateY}px) scale(${scale})`;
+        return true;
+    }
+
+    function canUseLayerTransformFastPath(module, state, snapshot, visibilityVersion, contentChanged, forceRefresh) {
+        if (!state?.layer || !snapshot) {
+            return false;
+        }
+
+        if (contentChanged || forceRefresh || state.dirtyLayout === true) {
+            return false;
+        }
+
+        if (!shouldRenderPassiveDomOverlays(module)) {
+            return false;
+        }
+
+        if (!!normalizeId(state.selectionNodeId) || !!normalizeId(state.editing?.nodeId)) {
+            return false;
+        }
+
+        const allowDeferredVisibilityRefresh =
+            module?._deferPassiveOverlayRefresh === true &&
+            (module?.isZooming === true || module?.isPanning === true);
+        if (!allowDeferredVisibilityRefresh &&
+            Number(state.lastVisibilityVersion || 0) !== Number(visibilityVersion || 0)) {
+            return false;
+        }
+
+        if (!isCameraViewTransformCompatible(module)) {
+            return false;
+        }
+
+        const hasVisibleCard = state.cards.size > 0 &&
+            Array.from(state.cards.values()).some(card => !!card && card.style.display !== 'none');
+        if (!hasVisibleCard) {
+            return false;
+        }
+
+        const baseSnapshot = state.layoutSnapshot;
+        const nextSnapshot = buildLayerLayoutSnapshot(module, snapshot);
+        if (!baseSnapshot || !nextSnapshot) {
+            return false;
+        }
+
+        const tolerance = 0.01;
+        if (Math.abs(Number(baseSnapshot.width || 0) - Number(nextSnapshot.width || 0)) > tolerance ||
+            Math.abs(Number(baseSnapshot.height || 0) - Number(nextSnapshot.height || 0)) > tolerance ||
+            Math.abs(Number(baseSnapshot.fov || 0) - Number(nextSnapshot.fov || 0)) > tolerance) {
+            return false;
+        }
+
+        return applyLayerViewTransform(state.layer, baseSnapshot, nextSnapshot);
+    }
+
+    function syncPassiveViewTransform(module) {
+        if (!shouldRenderPassiveDomOverlays(module)) {
+            return false;
+        }
+
+        const state = ensureState(module);
+        const snapshot = typeof module?.buildViewStateSnapshot === 'function'
+            ? module.buildViewStateSnapshot()
+            : null;
+        const visibilityVersion = Number(module?._visibilityVersion || 0);
+        return canUseLayerTransformFastPath(
+            module,
+            state,
+            snapshot,
+            visibilityVersion,
+            false,
+            false
+        );
+    }
+
+    function updateNodePlacement(module, nodeId) {
+        const state = ensureState(module);
+        const layer = state?.layer || ensureLayer(module);
+        const normalizedNodeId = normalizeId(nodeId);
+        if (!state || !layer || !normalizedNodeId) {
+            return false;
+        }
+
+        const entry = module?.nodeObjectsById?.get?.(normalizedNodeId) || null;
+        if (!entry) {
+            return false;
+        }
+
+        const rect = getPlacementRect(module, entry);
+        if (!rect) {
+            return false;
+        }
+
+        let moved = false;
+        const selectionCard = state.cards.get(selectionCardKey(normalizedNodeId)) || null;
+        if (selectionCard && selectionCard.style.display !== 'none') {
+            applyPlacement(module, selectionCard, rect, 8, entry);
+            moved = true;
+        }
+
+        const editingCard = state.cards.get(editingCardKey(normalizedNodeId)) || null;
+        if (editingCard && editingCard.style.display !== 'none') {
+            applyPlacement(module, editingCard, rect, 12, entry);
+            moved = true;
+        }
+
+        if (!moved) {
+            return false;
+        }
+
+        // Node dragging changes card placement while the camera snapshot stays
+        // stable. Reset any passive fast-path transform so text tracks the node.
+        clearLayerTransform(layer);
+        const snapshot = typeof module?.buildViewStateSnapshot === 'function'
+            ? module.buildViewStateSnapshot()
+            : null;
+        state.layoutSnapshot = buildLayerLayoutSnapshot(module, snapshot);
+        state.lastViewKey = snapshot ? buildOverlayViewKey(module, snapshot) : state.lastViewKey;
+        state.lastVisibilityVersion = Number(module?._visibilityVersion || 0);
+        state.dirtyLayout = false;
+        module._overlayDebugLayoutChanged = true;
+        return true;
+    }
+
+    function canOverlayCssEntry(entry) {
+        return !!(
+            entry &&
+            entry.currentType === 'CSS' &&
+            entry.cssObject?.visible === true &&
+            entry.cssObject?.element &&
+            supportsPassiveDisplay(entry)
+        );
+    }
+
+    function shouldSkipCss3dRender(module) {
+        if (!shouldRenderPassiveDomOverlays(module)) {
+            return false;
+        }
+
+        if (!!normalizeId(module?._textOverlayV2State?.editing?.nodeId)) {
+            return false;
+        }
+
+        const visibleIds = module?._visibleIds || module?._prevVisibleIds || null;
+        if (!visibleIds?.forEach || visibleIds.size === 0) {
+            return false;
+        }
+
+        let sawCoveredCssNode = false;
+        let foundUnsupportedVisibleCssNode = false;
+
+        visibleIds.forEach(nodeId => {
+            if (foundUnsupportedVisibleCssNode) {
+                return;
+            }
+
+            const entry = module?.nodeObjectsById?.get?.(nodeId) || null;
+            if (!entry || entry.currentType !== 'CSS' || entry.cssObject?.visible !== true) {
+                return;
+            }
+
+            if (!canOverlayCssEntry(entry)) {
+                foundUnsupportedVisibleCssNode = true;
+                return;
+            }
+
+            sawCoveredCssNode = true;
+        });
+
+        return sawCoveredCssNode && !foundUnsupportedVisibleCssNode;
+    }
+
+    function buildSelectionContentKey(entry) {
+        const model = getModel(entry);
+        const metadata = getMetadata(model);
+        return JSON.stringify({
+            kind: 'selection',
+            type: getContentType(model),
+            width: Number(model?.width || model?.Width || 0),
+            height: Number(model?.height || model?.Height || 0),
+            prompt: getPrompt(model),
+            response: getResponse(model),
+            isWordWrap: model?.isWordWrap !== false,
+            memoColor: metadata?.memoColor || metadata?.MemoColor || '',
+            semanticType: metadata?.semanticType || metadata?.SemanticType || '',
+            memoAgentOverlay: getContentType(model) === 'memo' ? buildMemoAgentOverlayKey(entry) : ''
+        });
+    }
+
+    function applyEditingSurfaceTransparencyClasses(surface, kind) {
+        if (!surface?.classList) {
+            return null;
+        }
+
+        surface.classList.add('mind-map-text-overlay-v2-editing-surface');
+        if (kind === 'memo') {
+            surface.classList.add('mind-map-text-overlay-v2-editing-memo-surface');
+        } else if (kind === 'note') {
+            surface.classList.add('mind-map-text-overlay-v2-editing-note-surface');
+        }
+
+        return surface;
+    }
+
+    // Editing overlays must come from the CSS3D manager's canonical builder.
+    // Overlay V2 is only responsible for placement and focus routing.
+    function createEditingCardFromCss3dSource(module, entry, expectedKind) {
+        const nodeId = getNodeId(entry);
+        const card = ensureCard(module, editingCardKey(nodeId), nodeId, `editing-${expectedKind}`);
+        if (!card) {
+            return null;
+        }
+
+        card.replaceChildren();
+        setCardMode(card, 'editing');
+
+        const created = getCss3dManager()?.createEditingOverlayContent?.(entry) || null;
+        if (!created?.card) {
+            return null;
+        }
+
+        const kind = String(created.kind || expectedKind || '').trim().toLowerCase();
+        const editingSurface = applyEditingSurfaceTransparencyClasses(created.card, kind);
+        if (!editingSurface) {
+            return null;
+        }
+
+        card.appendChild(editingSurface);
+
+        if (kind === 'note' && created.textarea) {
+            getCss3dManager()?.bindNoteEditingWheelZoom?.(module, created.textarea);
+        }
+        if (kind === 'memo') {
+            getCss3dManager()?.bindMemoWheelRouting?.(module, card);
+        }
+        if (created.textarea) {
+            getCss3dManager()?.restoreEditingScrollState?.(entry, created.textarea);
+        }
+        getCss3dManager()?.bindEditingOverlayPan?.(module, card);
+
+        return {
+            card,
+            focusTarget: created.focusTarget || created.textarea || created.titleInput || null,
+            titleInput: created.titleInput || null,
+            textarea: created.textarea || null,
+            initialTitle: created.initialTitle,
+            initialValue: created.initialValue
+        };
+    }
+
+    function renderSelectionCard(module, entry, options = {}) {
+        const nodeId = getNodeId(entry);
+        if (!nodeId) {
+            return null;
+        }
+
+        const interactive = options.interactive === true;
+        const forceRebuild = options.forceRebuild === true;
+        const card = ensureCard(module, selectionCardKey(nodeId), nodeId, 'selection');
+        if (!card) {
+            return null;
+        }
+        card.style.pointerEvents = 'none';
+        card.dataset.contentType = getContentType(entry);
+
+        const contentKey = buildSelectionContentKey(entry);
+        const sourceEpoch = String(getReadonlySourceEpoch(module));
+        const sourceRoot = getReadonlySelectionSourceRoot(entry);
+        if (!forceRebuild &&
+            card.dataset.contentKey === contentKey &&
+            card.dataset.sourceEpoch === sourceEpoch &&
+            card.childElementCount > 0) {
+            setCardMode(card, 'selection', interactive);
+            if (card.dataset.sourceKind !== 'live') {
+                bindReadonlyOverlayPrimaryPointerRouting(module, card, sourceRoot);
+                refreshOverlayCloneInteractivity(module, card.firstElementChild || card, interactive, sourceRoot);
+                syncReadonlyOverlayCardScrollFromSource(card);
+                scheduleReadonlyOverlayCardScrollSync(card);
+            }
+            return card;
+        }
+
+        if (card.dataset.sourceKind === 'live') {
+            resumeSource(entry);
+        }
+
+        const previousScroll = preserveBodyScroll(card);
+        card.replaceChildren();
+        setCardMode(card, 'selection', interactive);
+        card.dataset.contentKey = contentKey;
+        card.dataset.sourceEpoch = sourceEpoch;
+
+        // Keep CSS3D as the single readonly source of truth. If the source
+        // shell is unavailable, skip the overlay instead of rebuilding a
+        // second, divergent readonly DOM path.
+        const shellResult = createReadonlySelectionShell(module, entry, { interactive: interactive, cardElement: card }) || null;
+        const shell = shellResult?.container || null;
+        const shellSourceRoot = shellResult?.sourceRoot || sourceRoot;
+        if (!shell) {
+            card.dataset.contentKey = '';
+            card.dataset.sourceEpoch = '';
+            card.dataset.sourceKind = '';
+            return null;
+        }
+
+        card.dataset.sourceKind = shellResult?.liveSource === true ? 'live' : 'clone';
+        card.appendChild(shell);
+        if (card.dataset.sourceKind !== 'live') {
+            bindReadonlyOverlayPrimaryPointerRouting(module, card, shellSourceRoot);
+            syncReadonlyOverlayCardScrollFromSource(card);
+            scheduleReadonlyOverlayCardScrollSync(card);
+        }
+        restoreBodyScroll(card, previousScroll);
+        if (card.dataset.sourceKind !== 'live') {
+            syncReadonlyOverlayCardScrollFromSource(card);
+            scheduleReadonlyOverlayCardScrollSync(card);
+        }
+        return card;
+    }
+
+    function createNoteEditingCard(module, entry) {
+        return createEditingCardFromCss3dSource(module, entry, 'note');
+    }
+
+    function createMemoEditingCard(module, entry) {
+        return createEditingCardFromCss3dSource(module, entry, 'memo');
+    }
+
+    function commitEditing(module) {
+        const state = ensureState(module);
+        const editing = state?.editing;
+        if (!editing?.nodeId) {
+            return false;
+        }
+
+        const entry = module?.nodeObjectsById?.get?.(editing.nodeId) || null;
+        if (!entry?.model) {
+            return false;
+        }
+
+        if (editing.textarea) {
+            getCss3dManager()?.rememberEditingScrollState?.(entry, editing.textarea);
+            getCss3dManager()?.syncCss3dScrollFromElement?.(module, editing.nodeId, editing.textarea);
+        }
+
+        if (editing.kind === 'memo') {
+            const title = String(editing.titleInput?.value || '');
+            const content = String(editing.textarea?.value || '');
+            const previousTitle = String(editing.initialTitle ?? getPrompt(entry));
+            const previousContent = String(editing.initialValue ?? getResponse(entry));
+
+            if (title === previousTitle && content === previousContent) {
+                return false;
+            }
+
+            entry.model.prompt = title;
+            entry.model.Prompt = title;
+            entry.model.response = content;
+            entry.model.Response = content;
+            editing.initialTitle = title;
+            editing.initialValue = content;
+            window.MindMapTextLOD?.invalidateNodeCache?.(String(entry.model.id), false);
+            module.dotNetHelper?.invokeMethodAsync?.('UpdateMemoNodeFields', String(entry.model.id), title, content).catch(() => { });
+        } else {
+            const value = String(editing.textarea?.value || '');
+            const previousValue = String(editing.initialValue ?? getResponse(entry));
+
+            if (value === previousValue) {
+                return false;
+            }
+
+            entry.model.response = value;
+            entry.model.Response = value;
+            entry.model.content = value;
+            entry.model.Content = value;
+            editing.initialValue = value;
+
+            if (window.MindMapNodes?.pendingNodeUpdates) {
+                window.MindMapNodes.pendingNodeUpdates.set(entry.model.id, {
+                    content: value,
+                    width: entry.model.width,
+                    height: entry.model.height
+                });
+            }
+
+            window.MindMapTextLOD?.invalidateNodeCache?.(String(entry.model.id), false);
+            module.dotNetHelper?.invokeMethodAsync?.('UpdateNodeContent', entry.model.id, value).catch(() => { });
+        }
+
+        if (entry.cssObject && window.MindMapCss3DManager?.syncCss3dContent) {
+            window.MindMapCss3DManager.syncCss3dContent(entry.model, entry.cssObject);
+        }
+
+        return true;
+    }
+
+    function activateSelection(module, nodeId) {
+        if (!isEnabled(module)) {
+            return false;
+        }
+
+        const id = normalizeId(nodeId);
+        if (!id) {
+            return false;
+        }
+
+        const entry = module?.nodeObjectsById?.get?.(id) || null;
+        if (!entry || !supportsSelection(entry)) {
+            return false;
+        }
+
+        const state = ensureState(module);
+        if (!state) {
+            return false;
+        }
+
+        if (state.selectionNodeId === id) {
+            state.dirtyLayout = true;
+            module._overlayDirty = true;
+            return true;
+        }
+
+        clearSelection(module);
+        state.selectionNodeId = id;
+        state.dirtySelection = true;
+        state.dirtyLayout = true;
+        module._overlayDirty = true;
+        module._lastOverlayKey = '';
+        syncLayerVisibility(module);
+        return true;
+    }
+
+    function clearSelection(module, nodeId = null) {
+        const state = ensureState(module);
+        const activeId = normalizeId(state?.selectionNodeId);
+        const requestedId = nodeId === null ? activeId : normalizeId(nodeId);
+        if (!state || !activeId || !requestedId || requestedId !== activeId) {
+            return false;
+        }
+
+        const entry = module?.nodeObjectsById?.get?.(activeId) || null;
+        if (entry) {
+            resumeSource(entry);
+        }
+
+        hideCard(state.cards.get(selectionCardKey(activeId)));
+        state.selectionNodeId = '';
+        state.dirtySelection = true;
+        state.dirtyLayout = true;
+        module._overlayDirty = true;
+        module._lastOverlayKey = '';
+        return true;
+    }
+
+    function beginEditing(module, nodeEntry) {
+        if (!isEnabled(module) || !supportsEditing(nodeEntry)) {
+            return false;
+        }
+
+        const state = ensureState(module);
+        const nodeId = getNodeId(nodeEntry);
+        const kind = getContentType(nodeEntry) === 'memo' ? 'memo' : 'note';
+        if (!state || !nodeId) {
+            return false;
+        }
+
+        if (state.editing?.nodeId === nodeId) {
+            state.editing.shouldFocus = true;
+            state.dirtyLayout = true;
+            module._overlayDirty = true;
+            return true;
+        }
+
+        if (state.editing?.nodeId) {
+            clearEditing(module, { commit: true, preserveEditingFlag: true });
+        }
+
+        clearSelection(module);
+
+        state.editing = {
+            nodeId,
+            kind,
+            element: null,
+            titleInput: null,
+            textarea: null,
+            focusTarget: null,
+            initialTitle: kind === 'memo' ? getPrompt(nodeEntry) : null,
+            initialValue: getResponse(nodeEntry),
+            shouldFocus: true
+        };
+        state.dirtyEditing = true;
+        state.dirtyLayout = true;
+        module.isEditingNote = true;
+        module._overlayDirty = true;
+        module._lastOverlayKey = '';
+        return true;
+    }
+
+    function clearEditing(module, options = {}) {
+        const state = ensureState(module);
+        const editing = state?.editing;
+        if (!editing?.nodeId) {
+            return false;
+        }
+
+        const { commit = true, nodeId = null, preserveEditingFlag = false } = options;
+        const activeId = normalizeId(editing.nodeId);
+        const requestedId = nodeId === null ? activeId : normalizeId(nodeId);
+        if (!requestedId || requestedId !== activeId) {
+            return false;
+        }
+
+        const entry = module?.nodeObjectsById?.get?.(activeId) || null;
+        if (entry && editing.textarea) {
+            getCss3dManager()?.rememberEditingScrollState?.(entry, editing.textarea);
+            getCss3dManager()?.syncCss3dScrollFromElement?.(module, activeId, editing.textarea);
+        }
+
+        if (commit) {
+            commitEditing(module);
+        }
+
+        if (entry) {
+            resumeSource(entry);
+        }
+
+        hideCard(state.cards.get(editingCardKey(activeId)));
+        state.editing = null;
+        state.dirtyEditing = true;
+        state.dirtyLayout = true;
+        if (!preserveEditingFlag) {
+            module.isEditingNote = false;
+        }
+        module._overlayDirty = true;
+        module._lastOverlayKey = '';
+        syncLayerVisibility(module);
+        return true;
+    }
+
+    function invalidateNode(module, nodeId, reason = 'content') {
+        const state = ensureState(module);
+        const id = normalizeId(nodeId);
+        if (!state || !id) {
+            return;
+        }
+
+        const entry = module?.nodeObjectsById?.get?.(id) || null;
+        if (isMediaOverlayExcluded(entry)) {
+            purgeMediaOverlayCards(module, state);
+        }
+
+        state.dirtyNodes.add(id);
+        if (reason === 'layout') {
+            state.dirtyLayout = true;
+        }
+        module._overlayDirty = true;
+        module._lastOverlayKey = '';
+    }
+
+    function invalidateView(module) {
+        const state = ensureState(module);
+        if (!state) {
+            return;
+        }
+
+        if (hasBlockingPassiveOverlayInteraction(module, state)) {
+            hidePassiveSelectionCards(module, state);
+        }
+        state.dirtyLayout = true;
+        module._overlayDirty = true;
+        module._lastOverlayKey = '';
+    }
+
+    function hidePassiveSelectionCards(module, state = ensureState(module), options = {}) {
+        if (!module || !state) {
+            return 0;
+        }
+
+        const onlyNodeIds = options?.onlyNodeIds instanceof Set
+            ? options.onlyNodeIds
+            : null;
+        let hiddenCount = 0;
+        state.cards.forEach(card => {
+            if (!card || card.style.display === 'none') {
+                return;
+            }
+
+            const isPassiveSelectionCard =
+                String(card.dataset?.overlayMode || '') === 'selection' &&
+                String(card.dataset?.overlayInteractive || '') !== 'true';
+            if (!isPassiveSelectionCard) {
+                return;
+            }
+
+            const nodeId = normalizeId(card.dataset?.nodeId);
+            if (onlyNodeIds && (!nodeId || !onlyNodeIds.has(nodeId))) {
+                return;
+            }
+            if (nodeId) {
+                const entry = module?.nodeObjectsById?.get?.(nodeId) || null;
+                if (entry) {
+                    resumeSource(entry);
+                }
+            }
+
+            hideCard(card);
+            hiddenCount += 1;
+        });
+
+        if (hiddenCount > 0) {
+            if (onlyNodeIds) {
+                onlyNodeIds.forEach(nodeId => state.passiveCandidateIds.delete(normalizeId(nodeId)));
+            } else {
+                state.passiveCandidateIds.clear();
+                state.passiveCandidateVisibleUntil = 0;
+            }
+            const hasVisibleCard = Array.from(state.cards.values()).some(card =>
+                !!card && card.style.display !== 'none');
+            if (!hasVisibleCard) {
+                clearLayerTransform(state.layer);
+                if (state.layer?.style) {
+                    state.layer.style.display = 'none';
+                }
+            }
+        }
+
+        return hiddenCount;
+    }
+
+    function hideUnusedCards(module, keepCardKeys) {
+        const state = ensureState(module);
+        if (!state) {
+            return;
+        }
+
+        const keptNodeIds = new Set();
+        keepCardKeys.forEach(cardKey => {
+            const keptCard = state.cards.get(cardKey);
+            const keptNodeId = normalizeId(keptCard?.dataset?.nodeId);
+            if (keptNodeId) {
+                keptNodeIds.add(keptNodeId);
+            }
+        });
+
+        state.cards.forEach((card, cardKey) => {
+            if (!keepCardKeys.has(cardKey)) {
+                const nodeId = normalizeId(card?.dataset?.nodeId);
+                if (nodeId && !keptNodeIds.has(nodeId)) {
+                    const entry = module?.nodeObjectsById?.get?.(nodeId) || null;
+                    if (entry) {
+                        resumeSource(entry);
+                    }
+                }
+                const staleEntry = nodeId ? module?.nodeObjectsById?.get?.(nodeId) || null : null;
+                if (isMediaOverlayExcluded(staleEntry)) {
+                    removeCard(state, cardKey);
+                } else {
+                    hideCard(card);
+                }
+            }
+        });
+    }
+
+    function syncLayerVisibility(module) {
+        const state = ensureState(module);
+        const layer = state?.layer;
+        if (!layer) {
+            return;
+        }
+
+        if (!normalizeId(state.selectionNodeId) && !normalizeId(state.editing?.nodeId)) {
+            const hasVisibleCards = Array.from(state.cards.values()).some(card =>
+                !!card && card.style.display !== 'none');
+            layer.style.display = hasVisibleCards ? '' : 'none';
+        }
+    }
+
+    function setPassiveOverlaySuppressed(module, suppressed) {
+        const state = ensureState(module);
+        const layer = state?.layer;
+        if (!state || !layer) {
+            if (module) {
+                module._suppressPassiveDomOverlayDuringZoom = suppressed === true;
+            }
+            return false;
+        }
+
+        const wasSuppressed = module?._suppressPassiveDomOverlayDuringZoom === true;
+        const nextSuppressed = suppressed === true &&
+            !normalizeId(state.editing?.nodeId);
+        module._suppressPassiveDomOverlayDuringZoom = nextSuppressed;
+
+        if (wasSuppressed === nextSuppressed) {
+            return nextSuppressed;
+        }
+
+        if (nextSuppressed) {
+            state.cards.forEach(card => {
+                if (!card || card.style.display === 'none') {
+                    return;
+                }
+
+                const nodeId = normalizeId(card.dataset?.nodeId);
+                if (!nodeId) {
+                    return;
+                }
+
+                const entry = module?.nodeObjectsById?.get?.(nodeId) || null;
+                if (entry) {
+                    resumeSource(entry);
+                }
+            });
+            clearLayerTransform(layer);
+            layer.style.display = 'none';
+            return true;
+        }
+
+        layer.style.display = Array.from(state.cards.values()).some(card =>
+            !!card && card.style.display !== 'none') ? '' : 'none';
+        return true;
+    }
+
+    function setMotionHint(module, active) {
+        const state = ensureState(module);
+        if (!state) {
+            return false;
+        }
+
+        const nextActive = active === true;
+        const layer = state.layer;
+        if (state.motionHintActive === nextActive && layer?.style) {
+            return nextActive;
+        }
+        state.motionHintActive = nextActive;
+
+        if (!layer?.style) {
+            return nextActive;
+        }
+
+        layer.classList.toggle('is-motion-hint', nextActive);
+        layer.style.willChange = nextActive ? 'transform' : 'auto';
+        layer.style.backfaceVisibility = nextActive ? 'hidden' : '';
+        layer.style.webkitBackfaceVisibility = nextActive ? 'hidden' : '';
+        return nextActive;
+    }
+
+    function cleanupDisabledOverlay(module, state = ensureState(module)) {
+        if (!module || !state) {
+            return;
+        }
+
+        if (normalizeId(state.editing?.nodeId)) {
+            clearEditing(module, { commit: true });
+        }
+
+        state.cards.forEach(card => {
+            const nodeId = normalizeId(card?.dataset?.nodeId);
+            if (nodeId) {
+                const entry = module?.nodeObjectsById?.get?.(nodeId) || null;
+                if (entry) {
+                    resumeSource(entry);
+                }
+            }
+            hideCard(card);
+        });
+
+        clearLayerTransform(state.layer);
+        if (state.layer?.style) {
+            state.layer.style.display = 'none';
+        }
+
+        state.layoutSnapshot = null;
+        state.lastPassiveRenderEnabled = null;
+        state.lastViewKey = '';
+        state.lastVisibilityVersion = -1;
+        state.lastInteractionKey = '';
+        state.dirtyLayout = false;
+        state.dirtySelection = false;
+        state.dirtyEditing = false;
+        state.dirtyNodes.clear();
+        module._overlayDirty = false;
+        module._lastOverlayKey = '';
+        module._usedPassiveOverlayCameraFastPathLastFrame = false;
+        module._suppressPassiveDomOverlayDuringZoom = false;
+        module._overlayDebugPassiveVisibleCandidateCount = 0;
+        module._overlayDebugPassiveVisibleSupportedCount = 0;
+        module._overlayDebugPassiveViewportCandidateCount = 0;
+        module._overlayDebugPassiveCardLimit = 0;
+        module._overlayDebugPassiveOverlapSuppressedCount = 0;
+        module._overlayDebugKeepCardCount = 0;
+        module._overlayDebugPlacementZoomCount = 0;
+        module._overlayDebugPlacementTransformCount = 0;
+        module._overlayDebugLayoutChanged = false;
+        module._overlayDebugContentChanged = false;
+        module._overlayDebugForceRefresh = false;
+        setMotionHint(module, false);
+    }
+
+    function updateSelectionCard(module, state, keepCardKeys) {
+        const activeSelectionNodeId = normalizeId(state?.selectionNodeId);
+        const selectedNodeId = normalizeId(module?.selectedNodeIdJs);
+        const visibleIds = module?._visibleIds || module?._prevVisibleIds || null;
+        const shouldRenderPassive = shouldRenderPassiveDomOverlays(module);
+        if (activeSelectionNodeId && selectedNodeId !== activeSelectionNodeId) {
+            clearSelection(module, activeSelectionNodeId);
+        }
+
+        const candidateIds = new Set();
+        let passiveVisibleCandidateCount = 0;
+        module._overlayDebugPassiveVisibleSupportedCount = 0;
+        module._overlayDebugPassiveViewportCandidateCount = 0;
+        module._overlayDebugPassiveCardLimit = 0;
+        module._overlayDebugPassiveOverlapSuppressedCount = 0;
+        module._overlayDebugPassiveOccluderCount = 0;
+        module._overlaySuppressedPassiveNodeIds = new Set();
+        if (shouldRenderPassive && shouldUseVisiblePassiveOverlayCandidates(module) && visibleIds?.forEach) {
+            const passiveCandidateIds = collectVisiblePassiveCandidateIds(module, state, visibleIds);
+            passiveVisibleCandidateCount = passiveCandidateIds.size;
+            passiveCandidateIds.forEach(nodeId => candidateIds.add(nodeId));
+        }
+        const suppressedPassiveIds = module._overlaySuppressedPassiveNodeIds instanceof Set
+            ? module._overlaySuppressedPassiveNodeIds
+            : new Set();
+        const now = nowMs();
+        if (shouldRenderPassive && candidateIds.size > 0) {
+            state.passiveCandidateIds = new Set(candidateIds);
+            state.passiveCandidateVisibleUntil = now + PASSIVE_OVERLAY_CANDIDATE_GRACE_MS;
+        } else if (shouldRenderPassive &&
+            state.passiveCandidateIds?.size > 0 &&
+            Number(state.passiveCandidateVisibleUntil || 0) > now) {
+            state.passiveCandidateIds.forEach(nodeId => {
+                const normalizedId = normalizeId(nodeId);
+                if (normalizedId && !suppressedPassiveIds.has(normalizedId)) {
+                    candidateIds.add(normalizedId);
+                }
+            });
+        } else if (!shouldRenderPassive) {
+            state.passiveCandidateIds.clear();
+            state.passiveCandidateVisibleUntil = 0;
+        }
+        module._overlayDebugPassiveVisibleCandidateCount = passiveVisibleCandidateCount;
+        if (shouldRenderPassive && selectedNodeId) {
+            candidateIds.add(selectedNodeId);
+        }
+        if (activeSelectionNodeId) {
+            candidateIds.add(activeSelectionNodeId);
+        }
+
+        candidateIds.forEach(nodeId => {
+            const interactive = activeSelectionNodeId === nodeId;
+            if (!interactive && normalizeId(state?.editing?.nodeId) === nodeId) {
+                return;
+            }
+
+            const entry = module?.nodeObjectsById?.get?.(nodeId) || null;
+            const existingCard = state.cards.get(selectionCardKey(nodeId)) || null;
+            if (isMediaOverlayExcluded(entry)) {
+                if (entry) {
+                    resumeSource(entry);
+                }
+                if (existingCard) {
+                    removeCard(state, selectionCardKey(nodeId));
+                }
+                removeCard(state, editingCardKey(nodeId));
+                state.passiveCandidateIds?.delete?.(nodeId);
+                if (interactive) {
+                    state.selectionNodeId = '';
+                    state.dirtySelection = true;
+                    module._overlayDirty = true;
+                    module._lastOverlayKey = '';
+                }
+                return;
+            }
+
+            const isSelectedPassiveNode = !interactive && selectedNodeId === nodeId;
+            const keepPassiveCard = isSelectedPassiveNode && shouldKeepPassiveCardWhenSelected(entry);
+            if (isSelectedPassiveNode) {
+                if (!keepPassiveCard) {
+                    if (entry) {
+                        resumeSource(entry);
+                    }
+                    hideCard(state.cards.get(selectionCardKey(nodeId)));
+                    return;
+                }
+            }
+
+            const isSupported = interactive ? supportsSelection(entry) : supportsPassiveDisplay(entry);
+            const canRenderFromSource = !!(entry?.cssObject?.element && entry.currentType === 'CSS' && entry.cssObject.visible);
+            const canReuseExistingPassiveCard = !interactive &&
+                shouldRenderPassive &&
+                !!existingCard &&
+                existingCard.childElementCount > 0;
+            if (!entry || !isSupported || (!canRenderFromSource && !canReuseExistingPassiveCard)) {
+                hideCard(existingCard);
+                if (interactive) {
+                    clearSelection(module, nodeId);
+                } else if (entry) {
+                    resumeSource(entry);
+                }
+                return;
+            }
+
+            const forceRebuild = canRenderFromSource && state?.dirtyNodes?.has?.(nodeId) === true;
+            const card = renderSelectionCard(module, entry, {
+                interactive: interactive,
+                forceRebuild: forceRebuild
+            });
+            const rect = getPlacementRect(module, entry);
+            if (!card || !rect) {
+                if (interactive) {
+                    clearSelection(module, nodeId);
+                }
+                return;
+            }
+
+            applyPlacement(module, card, rect, 8, entry);
+            if (canRenderFromSource) {
+                suspendSource(entry, { disablePointerEvents: interactive });
+            }
+            keepCardKeys.add(selectionCardKey(nodeId));
+        });
+    }
+
+    function updateEditingCard(module, state, keepCardKeys) {
+        const editing = state?.editing;
+        const nodeId = normalizeId(editing?.nodeId);
+        if (!nodeId) {
+            return;
+        }
+
+        const entry = module?.nodeObjectsById?.get?.(nodeId) || null;
+        const canRenderFromSource = !!(entry?.cssObject?.element && entry.currentType === 'CSS' && entry.cssObject.visible);
+        if (!entry || !supportsEditing(entry) || !canRenderFromSource) {
+            clearEditing(module, { commit: true });
+            return;
+        }
+
+        if (!editing.element || !editing.element.isConnected) {
+            const created = editing.kind === 'memo'
+                ? createMemoEditingCard(module, entry)
+                : createNoteEditingCard(module, entry);
+
+            if (!created?.card) {
+                clearEditing(module, { commit: true });
+                return;
+            }
+
+            editing.element = created.card;
+            editing.titleInput = created.titleInput || null;
+            editing.textarea = created.textarea || null;
+            editing.focusTarget = created.focusTarget || created.textarea || created.titleInput || null;
+            editing.initialTitle = created.initialTitle ?? editing.initialTitle ?? null;
+            editing.initialValue = created.initialValue ?? editing.initialValue ?? '';
+        }
+
+        const rect = getPlacementRect(module, entry);
+        if (!rect) {
+            clearEditing(module, { commit: true });
+            return;
+        }
+
+        applyPlacement(module, editing.element, rect, 12, entry);
+        suspendSource(entry);
+        keepCardKeys.add(editingCardKey(nodeId));
+
+        if (editing.shouldFocus && editing.focusTarget) {
+            editing.shouldFocus = false;
+            setTimeout(() => {
+                try {
+                    editing.focusTarget.focus({ preventScroll: true });
+                } catch {
+                    try { editing.focusTarget.focus(); } catch { }
+                }
+
+                if (typeof editing.focusTarget.setSelectionRange === 'function') {
+                    const nextValue = String(editing.focusTarget.value || '');
+                    editing.focusTarget.setSelectionRange(nextValue.length, nextValue.length);
+                }
+                if (editing.textarea) {
+                    getCss3dManager()?.restoreEditingScrollState?.(entry, editing.textarea);
+                }
+            }, 0);
+        }
+    }
+
+    function updateFrame(module) {
+        const state = ensureState(module);
+        if (!state) {
+            return;
+        }
+
+        if (!isEnabled(module)) {
+            cleanupDisabledOverlay(module, state);
+            return;
+        }
+
+        const selectedMediaEntry = normalizeId(module?.selectedNodeIdJs)
+            ? module?.nodeObjectsById?.get?.(normalizeId(module.selectedNodeIdJs)) || null
+            : null;
+        const shouldAuditMediaSources =
+            state.cards.size > 0 ||
+            state.dirtyNodes.size > 0 ||
+            module?._overlayDirty === true ||
+            isMediaOverlayExcluded(selectedMediaEntry);
+        purgeMediaOverlayCards(module, state, { resumeAllMedia: shouldAuditMediaSources });
+
+        const interactionKey = buildInteractionKey(module, state);
+        const interactionChanged = state.lastInteractionKey !== interactionKey;
+        if (interactionChanged) {
+            state.dirtyLayout = true;
+        }
+
+        if (hasBlockingPassiveOverlayInteraction(module, state)) {
+            hidePassiveSelectionCards(module, state);
+        }
+
+        const passiveRenderEnabled = shouldRenderPassiveDomOverlays(module);
+        if (state.lastPassiveRenderEnabled !== passiveRenderEnabled) {
+            if (passiveRenderEnabled === true) {
+                // Re-entering passive overlay should always re-clone from the
+                // current CSS3D source instead of reusing an old readonly DOM.
+                bumpReadonlySourceEpoch(module);
+            }
+            state.dirtyLayout = true;
+            state.lastPassiveRenderEnabled = passiveRenderEnabled;
+        }
+
+        if (module?._suppressPassiveDomOverlayDuringZoom === true &&
+            !normalizeId(state.editing?.nodeId)) {
+            setPassiveOverlaySuppressed(module, true);
+            return;
+        }
+
+        const layer = ensureLayer(module);
+        if (!state || !layer) {
+            return;
+        }
+
+        setPassiveOverlaySuppressed(module, false);
+
+        const snapshot = typeof module.buildViewStateSnapshot === 'function'
+            ? module.buildViewStateSnapshot()
+            : null;
+        const viewKey = snapshot
+            ? buildOverlayViewKey(module, snapshot)
+            : '';
+        const visibilityVersion = Number(module?._visibilityVersion || 0);
+        const layoutChanged =
+            interactionChanged ||
+            state.lastViewKey !== viewKey ||
+            state.lastVisibilityVersion !== visibilityVersion ||
+            state.dirtyLayout === true;
+        const contentChanged =
+            state.dirtySelection === true ||
+            state.dirtyEditing === true ||
+            state.dirtyNodes.size > 0;
+        const hasActiveOverlayCard =
+            !!normalizeId(state.selectionNodeId) ||
+            !!normalizeId(state.editing?.nodeId);
+        const hasVisibleOverlayCard =
+            state.cards.size > 0 &&
+            Array.from(state.cards.values()).some(card => !!card && card.style.display !== 'none');
+        const forceRefresh =
+            module?._overlayDirty === true &&
+            (
+                contentChanged ||
+                !hasVisibleOverlayCard ||
+                state.lastVisibilityVersion !== visibilityVersion
+            );
+        module._overlayDebugLayoutChanged = layoutChanged;
+        module._overlayDebugContentChanged = contentChanged;
+        module._overlayDebugForceRefresh = forceRefresh;
+        const shouldKeepPassiveOverlayWarm =
+            shouldRenderPassiveDomOverlays(module) &&
+            ((module?._visibleIds?.size || module?._prevVisibleIds?.size || 0) > 0);
+
+        if (!hasActiveOverlayCard && !hasVisibleOverlayCard && !contentChanged && !shouldKeepPassiveOverlayWarm) {
+            state.lastViewKey = viewKey;
+            state.lastVisibilityVersion = visibilityVersion;
+            state.lastInteractionKey = interactionKey;
+            state.dirtyLayout = false;
+            state.layoutSnapshot = null;
+            clearLayerTransform(layer);
+            if (layer.style.display !== 'none') {
+                layer.style.display = 'none';
+            }
+            return;
+        }
+
+        if (canUseLayerTransformFastPath(module, state, snapshot, visibilityVersion, contentChanged, forceRefresh)) {
+            state.lastViewKey = viewKey;
+            state.lastVisibilityVersion = visibilityVersion;
+            state.lastInteractionKey = interactionKey;
+            if (layer.style.display === 'none') {
+                layer.style.display = '';
+            }
+            return;
+        }
+
+        if (!layoutChanged && !contentChanged && !forceRefresh) {
+            state.lastInteractionKey = interactionKey;
+            return;
+        }
+
+        state.lastViewKey = viewKey;
+        state.lastVisibilityVersion = visibilityVersion;
+        state.lastInteractionKey = interactionKey;
+        clearLayerTransform(layer);
+        module._overlayDebugPlacementZoomCount = 0;
+        module._overlayDebugPlacementTransformCount = 0;
+
+        const keepCardKeys = new Set();
+        updateSelectionCard(module, state, keepCardKeys);
+        updateEditingCard(module, state, keepCardKeys);
+        hideUnusedCards(module, keepCardKeys);
+        module._overlayDebugKeepCardCount = keepCardKeys.size;
+
+        layer.style.display = keepCardKeys.size > 0 ? '' : 'none';
+        state.layoutSnapshot = keepCardKeys.size > 0
+            ? buildLayerLayoutSnapshot(module, snapshot)
+            : null;
+        state.dirtyNodes.clear();
+        state.dirtyLayout = false;
+        state.dirtySelection = false;
+        state.dirtyEditing = false;
+        state.lastInteractionKey = interactionKey;
+    }
+
+    function hasSelection(module, nodeId = null) {
+        const state = ensureState(module);
+        const activeId = normalizeId(state?.selectionNodeId);
+        if (!activeId) {
+            return false;
+        }
+
+        return nodeId === null ? true : activeId === normalizeId(nodeId);
+    }
+
+    function hasEditing(module, nodeId = null) {
+        const state = ensureState(module);
+        const activeId = normalizeId(state?.editing?.nodeId);
+        if (!activeId) {
+            return false;
+        }
+
+        return nodeId === null ? true : activeId === normalizeId(nodeId);
+    }
+
+    function getDebugResponseElement(root) {
+        if (!root?.querySelector) {
+            return null;
+        }
+
+        return root.querySelector(getPrimaryContentSelector()) || null;
+    }
+
+    function normalizeDebugHtml(value) {
+        return String(value || '')
+            .replace(/\s+/g, ' ')
+            .replace(/>\s+</g, '><')
+            .trim();
+    }
+
+    function truncateDebugText(value, maxLength = 4000) {
+        const text = String(value || '');
+        if (text.length <= maxLength) {
+            return text;
+        }
+
+        return `${text.slice(0, maxLength)}\n... [truncated ${text.length - maxLength} chars]`;
+    }
+
+    function buildOverlayDebugSnapshot(module) {
+        const state = ensureState(module);
+        if (!module || !state) {
+            return null;
+        }
+
+        let nodeId = normalizeId(state.selectionNodeId);
+        let card = nodeId ? state.cards.get(selectionCardKey(nodeId)) || null : null;
+
+        if ((!nodeId || !card || card.style.display === 'none') && normalizeId(module?.selectedNodeIdJs)) {
+            nodeId = normalizeId(module.selectedNodeIdJs);
+            card = state.cards.get(selectionCardKey(nodeId)) || null;
+        }
+
+        if (!nodeId || !card || card.style.display === 'none') {
+            for (const candidateCard of state.cards.values()) {
+                if (!candidateCard || candidateCard.style.display === 'none') {
+                    continue;
+                }
+
+                const candidateNodeId = normalizeId(candidateCard.dataset?.nodeId);
+                if (!candidateNodeId) {
+                    continue;
+                }
+
+                nodeId = candidateNodeId;
+                card = candidateCard;
+                break;
+            }
+        }
+
+        if (!nodeId || !card) {
+            return {
+                available: false,
+                reason: 'No visible overlay card',
+                selectedNodeId: normalizeId(module?.selectedNodeIdJs),
+                overlaySuppressed: module?._suppressPassiveDomOverlayDuringZoom === true
+            };
+        }
+
+        const entry = module?.nodeObjectsById?.get?.(nodeId) || null;
+        const sourceRoot = entry ? getReadonlyCloneSourceElement(entry) : null;
+        const overlayRoot = card.firstElementChild || null;
+        const sourceResponse = getDebugResponseElement(sourceRoot);
+        const overlayResponse = getDebugResponseElement(overlayRoot);
+        const sourceHtml = sourceResponse?.innerHTML || '';
+        const overlayHtml = overlayResponse?.innerHTML || '';
+        const normalizedSourceHtml = normalizeDebugHtml(sourceHtml);
+        const normalizedOverlayHtml = normalizeDebugHtml(overlayHtml);
+        const sourceText = sourceResponse?.textContent || '';
+        const overlayText = overlayResponse?.textContent || '';
+
+        return {
+            available: true,
+            nodeId,
+            contentType: getContentType(entry),
+            overlayCardKey: String(card.dataset?.cardKey || ''),
+            overlayCardKind: String(card.dataset?.kind || ''),
+            overlayContentKey: String(card.dataset?.contentKey || ''),
+            overlaySourceEpoch: String(card.dataset?.sourceEpoch || ''),
+            sourceExists: !!sourceRoot,
+            overlayExists: !!overlayRoot,
+            sourceRootClass: sourceRoot?.className || '',
+            overlayRootClass: overlayRoot?.className || '',
+            sourceResponseClass: sourceResponse?.className || '',
+            overlayResponseClass: overlayResponse?.className || '',
+            sourceSuspended: sourceRoot?.classList?.contains?.('mind-map-v2-source-suspended') === true,
+            overlaySuppressed: module?._suppressPassiveDomOverlayDuringZoom === true,
+            htmlMatches: normalizedSourceHtml === normalizedOverlayHtml,
+            textMatches: String(sourceText).trim() === String(overlayText).trim(),
+            sourceHtmlLength: sourceHtml.length,
+            overlayHtmlLength: overlayHtml.length,
+            sourceTextLength: sourceText.length,
+            overlayTextLength: overlayText.length,
+            sourceChildCount: Number(sourceResponse?.childElementCount || 0),
+            overlayChildCount: Number(overlayResponse?.childElementCount || 0),
+            sourceScrollHeight: Number(sourceResponse?.scrollHeight || 0),
+            overlayScrollHeight: Number(overlayResponse?.scrollHeight || 0),
+            sourceClientHeight: Number(sourceResponse?.clientHeight || 0),
+            overlayClientHeight: Number(overlayResponse?.clientHeight || 0),
+            sourceHtmlSnippet: truncateDebugText(sourceHtml),
+            overlayHtmlSnippet: truncateDebugText(overlayHtml),
+            sourceTextSnippet: truncateDebugText(sourceText, 1200),
+            overlayTextSnippet: truncateDebugText(overlayText, 1200)
+        };
+    }
+
+    function init(module) {
+        if (!module) {
+            return;
+        }
+
+        const state = ensureState(module);
+        ensureLayer(module);
+        window.MindMapCss3DManager?.injectMarkdownStyles?.();
+        if (state) {
+            state.dirtyLayout = true;
+            state.dirtySelection = true;
+            state.dirtyEditing = true;
+        }
+        module._overlayDirty = true;
+        log('initialized');
+    }
+
+    window.MindMapTextOverlayV2 = {
+        init: init,
+        updateFrame: updateFrame,
+        syncPassiveViewTransform: syncPassiveViewTransform,
+        setPassiveOverlaySuppressed: setPassiveOverlaySuppressed,
+        setMotionHint: setMotionHint,
+        invalidateNode: invalidateNode,
+        invalidateView: invalidateView,
+        updateNodePlacement: updateNodePlacement,
+        shouldRenderPassiveDomOverlays: shouldRenderPassiveDomOverlays,
+        shouldSkipCss3dRender: shouldSkipCss3dRender,
+        activateSelection: activateSelection,
+        clearSelection: clearSelection,
+        beginEditing: beginEditing,
+        clearEditing: clearEditing,
+        hasSelection: hasSelection,
+        hasEditing: hasEditing,
+        getDebugSnapshot: buildOverlayDebugSnapshot,
+        purgeMediaOverlayCards: purgeMediaOverlayCards,
+        suspendSource: suspendSource,
+        resumeSource: resumeSource,
+        syncReadonlySourceScroll: syncReadonlySourceScroll
+    };
+})();