npm - @mindexec/cli - Versions diffs - 0.2.383 → 0.2.385 - Mend

@mindexec/cli 0.2.383 → 0.2.385

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (267) hide show

package/wwwroot/index.html CHANGED Viewed

@@ -1,22 +1,736 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <meta
-      name="description"
-      content="MindExec React is a fast AI execution canvas for solo builders, notes, assets, and task graphs."
-    />
-    <meta name="build-version" content="hosted-bridge-loopback-access-2026-06-27" />
-    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
-    <link rel="manifest" href="/manifest.webmanifest" />
-    <title>MindExec React</title>
-    <script type="module" crossorigin src="/assets/index-qITXeJUr.js"></script>
-    <link rel="modulepreload" crossorigin href="/assets/vendor-react-BXzpOyCS.js">
-    <link rel="modulepreload" crossorigin href="/assets/app-runtime-xD2Z3NdN.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-yNpEK-gp.css">
-  </head>
-  <body>
-    <div id="root"></div>
-  </body>
-</html>
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>MindExec | Business Execution OS for solo builders</title>
+    <meta name="description" content="MindExec is an AI business execution OS for solo builders who want to turn notes, research, assets, and repeatable execution Skills into revenue-producing work." />
+    <base href="/" />
+    <link rel="stylesheet" href="_content/MindExecution.Shared/css/app.css?v=20260627-blazor-ui-complete-v832" />
+    <link rel="stylesheet" href="_content/MindExecution.Shared/css/mind-map-overrides.css?v=20260627-blazor-ui-complete-v832" />
+    <!-- ??좎뜦堉??Font Awesome (local) ??좎뜦堉??-->
+    <link rel="stylesheet" href="_content/MindExecution.Shared/lib/font-awesome/css/all.min.css" />
+    <!-- ??좎뜦堉??-->
+    <style>
+        #app {
+            min-height: 100vh;
+        }
+        .app-static-fallback {
+            width: min(960px, calc(100% - 32px));
+            margin: 0 auto;
+            padding: 56px 0 48px;
+            color: #0f172a;
+            line-height: 1.7;
+        }
+        .app-static-fallback__eyebrow {
+            display: inline-flex;
+            padding: 6px 10px;
+            border-radius: 999px;
+            background: rgba(255, 255, 255, 0.84);
+            border: 1px solid rgba(148, 163, 184, 0.25);
+            font-size: 12px;
+            font-weight: 700;
+            color: #334155;
+        }
+        .app-static-fallback h1 {
+            margin: 16px 0 0;
+            font-size: clamp(30px, 4vw, 48px);
+            line-height: 1.05;
+            font-weight: 800;
+        }
+        .app-static-fallback p {
+            max-width: 760px;
+            margin: 16px 0 0;
+            color: #475569;
+        }
+        .app-static-fallback a {
+            color: #0f172a;
+            font-weight: 700;
+        }
+        #blazor-error-ui {
+            display: none;
+        }
+        #blazor-error-ui.is-visible {
+            position: fixed;
+            right: 20px;
+            bottom: 20px;
+            z-index: 9999;
+            display: flex;
+            align-items: center;
+            gap: 12px;
+            max-width: 420px;
+            padding: 14px 16px;
+            border-radius: 14px;
+            background: rgba(15, 23, 42, 0.96);
+            color: #fff;
+            box-shadow: 0 18px 48px rgba(15, 23, 42, 0.28);
+        }
+        .blazor-error-ui__message {
+            flex: 1;
+            font-size: 14px;
+            line-height: 1.6;
+        }
+        #blazor-error-ui .reload,
+        #blazor-error-ui .dismiss {
+            color: #fff;
+            font-size: 13px;
+            font-weight: 700;
+            text-decoration: none;
+            cursor: pointer;
+        }
+    </style>
+</head>
+<body>
+    <div id="app-container">
+        <div id="app">
+            <article class="app-static-fallback" id="app-static-fallback">
+                <div class="app-static-fallback__eyebrow">MindExec</div>
+                <h1>MindExec</h1>
+                <p>Turn ideas into revenue execution. MindExec is a Business Execution OS that moves serious work into MindCanvas, where context, AI Tasks, execution Skills, media, and results stay connected.</p>
+                <p><a href="/mindcanvas">Open MindCanvas</a> | <a href="/pricing">See pricing</a> | <a href="/tools">Browse free tools</a></p>
+                <noscript>
+                    <p>JavaScript is required for the interactive tool experience.</p>
+                </noscript>
+            </article>
+        </div>
+    </div>
+    <div id="three-js-container"
+        style="display: none; position: fixed; top:0; left:0; width:100%; height:100%; z-index:999; background-color: rgba(0,0,0,0.5);">
+    </div>
+    <!-- Selection rectangle overlay -->
+    <div id="selection-rectangle"
+        style="position: fixed; border:2px solid #1173d4; background-color: rgba(17, 115, 212, 0.15); pointer-events: none; display: none; z-index:100;">
+    </div>
+    <div id="blazor-error-ui" role="alert" aria-live="assertive">
+        <div class="blazor-error-ui__message"></div>
+        <a href="." class="reload">Reload</a>
+        <span class="dismiss">Dismiss</span>
+    </div>
+    <!-- Aggressively remove any existing service workers and caches so hosted deploys pick up new JS immediately -->
+    <script>
+        window.__swCleanup = (async () => {
+            try {
+                let hadAnything = false;
+                if ('serviceWorker' in navigator) {
+                    const regs = await navigator.serviceWorker.getRegistrations();
+                    hadAnything = hadAnything || regs.length > 0;
+                    await Promise.allSettled(regs.map(r => r.unregister()));
+                }
+                if (window.caches) {
+                    const keys = await caches.keys();
+                    hadAnything = hadAnything || keys.length > 0;
+                    await Promise.allSettled(keys.map(k => caches.delete(k)));
+                }
+                return hadAnything;
+            } catch (e) {
+                console.debug('SW cleanup skipped:', e);
+                return false;
+            }
+        })();
+    </script>
+    <!-- Blazor WASM loader (autostart disabled; we'll start after our scripts load) -->
+    <script src="_framework/blazor.webassembly.js" autostart="false"></script>
+    <!-- Global helpers and libraries -->
+    <script src="js/marketing-tool.js"></script>
+    <script>
+        window.showBlazorBootError = function (message) {
+            const errorUi = document.getElementById('blazor-error-ui');
+            if (!errorUi) return;
+            const messageElement = errorUi.querySelector('.blazor-error-ui__message');
+            if (messageElement) {
+                messageElement.textContent = message || 'This page could not finish loading.';
+            }
+            errorUi.classList.add('is-visible');
+            errorUi.removeAttribute('hidden');
+        };
+        window.hideBlazorBootError = function () {
+            const errorUi = document.getElementById('blazor-error-ui');
+            if (!errorUi) return;
+            errorUi.classList.remove('is-visible');
+        };
+        document.addEventListener('click', (event) => {
+            const target = event.target;
+            if (target instanceof HTMLElement && target.classList.contains('dismiss')) {
+                window.hideBlazorBootError();
+            }
+        });
+        // Global textarea handlers
+        function adjustTextareaHeight(element) {
+            if (!element) return;
+            // ??좎뜦堉??[Change] Add jitter-prevention logic ??좎뜦堉??
+            // Compare the previous text length. When content grows, skip the 'auto' reset.
+            // Only reset to 'auto' when shrinking (during deletion).
+            const currentLength = element.value.length;
+            const prevLength = parseInt(element.dataset.prevLength || '0');
+            if (currentLength < prevLength) {
+                element.style.height = 'auto'; // reset height when deleting to allow shrink
+            }
+            element.dataset.prevLength = currentLength; // store current length
+            // ??좎뜦堉??[Change] ??좎뜦堉??
+            const computedStyles = window.getComputedStyle(element);
+            const lineHeight = parseFloat(computedStyles.lineHeight || '24') || 24;
+            const paddingTop = parseFloat(computedStyles.paddingTop || '0') || 0;
+            const paddingBottom = parseFloat(computedStyles.paddingBottom || '0') || 0;
+            const verticalPadding = paddingTop + paddingBottom;
+            const maxLines = 6; // limit to 6 lines
+            const maxHeight = (lineHeight * maxLines) + verticalPadding;
+            const minHeightPx = Math.max(lineHeight + verticalPadding, 42);
+            const newHeight = Math.min(element.scrollHeight, maxHeight);
+            // Even if content didn't shrink, apply if scrollHeight grew
+            element.style.height = Math.max(newHeight, minHeightPx) + 'px';
+            element.style.overflowY = 'hidden';
+        }
+        function resetTextareaHeight(element) {
+            if (!element) return;
+            const computedStyles = window.getComputedStyle(element);
+            const lineHeight = parseFloat(computedStyles.lineHeight || '24') || 24;
+            const paddingTop = parseFloat(computedStyles.paddingTop || '0') || 0;
+            const paddingBottom = parseFloat(computedStyles.paddingBottom || '0') || 0;
+            const minHeightPx = Math.max(lineHeight + paddingTop + paddingBottom, 42);
+            element.style.height = minHeightPx + 'px';
+            element.style.overflowY = 'hidden';
+        }
+        function attachTextareaHandlers(element, dotNetRef) {
+            if (!element) return;
+            if (element.__mindexecEnterHandler) {
+                element.removeEventListener('keydown', element.__mindexecEnterHandler);
+            }
+            const handleKeyDown = (e) => {
+                if (e.key === 'Enter') {
+                    if (e.shiftKey) {
+                        return;
+                    }
+                    if (e.repeat || e.isComposing || e.keyCode === 229) {
+                        return;
+                    }
+                    e.preventDefault();
+                    const now = performance.now();
+                    if (element.__mindexecLastEnterAt && now - element.__mindexecLastEnterAt < 650) {
+                        return;
+                    }
+                    const promptSnapshot = element.value || '';
+                    if (!promptSnapshot.trim()) {
+                        return;
+                    }
+                    element.__mindexecLastEnterAt = now;
+                    const submitId = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+                    element.value = '';
+                    element.dispatchEvent(new Event('input', { bubbles: true }));
+                    resetTextareaHeight(element);
+                    if (dotNetRef && dotNetRef.invokeMethodAsync) {
+                        dotNetRef.invokeMethodAsync('OnGlobalInputEnterPressed', promptSnapshot, submitId)
+                            .catch((err) => console.warn('[GlobalInput] Enter submit failed:', err));
+                    }
+                }
+            };
+            element.__mindexecEnterHandler = handleKeyDown;
+            element.addEventListener('keydown', handleKeyDown);
+        }
+        function blurElement(element) {
+            if (element) element.blur();
+            if (document && document.body) document.body.focus();
+        }
+        function focusGlobalTextarea() {
+            const textarea = document.getElementById('global-input-textarea');
+            if (textarea) {
+                textarea.focus();
+                textarea.setSelectionRange(textarea.value.length, textarea.value.length);
+            }
+        }
+        window.adjustTextareaHeight = adjustTextareaHeight;
+        window.resetTextareaHeight = resetTextareaHeight;
+        window.attachTextareaHandlers = attachTextareaHandlers;
+        window.blurElement = blurElement;
+        window.focusGlobalTextarea = focusGlobalTextarea;
+        // Prevent default page-level DnD behavior
+        document.addEventListener('dragover', (e) => {
+            e.preventDefault();
+            // ??좎뜦堉??[Change] Remove/avoid stopPropagation (do not disrupt event flow) ??좎뜦堉??
+            // e.stopPropagation();
+            // ??좎뜦堉??[Change] ??좎뜦堉??
+            // ??좎뜦堉??[Change] Default is 'none', but only apply when not handled by children ??좎뜦堉??
+            // (If MindMapDnD handles it, this code won't run or will be ignored)
+            // e.dataTransfer.dropEffect = 'none';
+        }, false);
+        document.addEventListener('dragleave', (e) => {
+            e.preventDefault();
+            // e.stopPropagation(); // removed
+        }, false);
+        document.addEventListener('drop', (e) => {
+            e.preventDefault();
+            // e.stopPropagation(); // removed
+        }, false);
+    </script>
+    <!-- Paddle.js -->
+    <script src="https://cdn.paddle.com/paddle/v2/paddle.js"></script>
+    <!-- App scripts and libs REQUIRED before Blazor starts -->
+    <script>
+        window.mindExecutionStartupTiming = window.mindExecutionStartupTiming || (() => {
+            const perf = window.performance;
+            const now = () => perf && typeof perf.now === 'function'
+                ? perf.now()
+                : Date.now();
+            const marks = new Map();
+            const pageStart = now();
+            marks.set('page-start', pageStart);
+            function toDuration(value) {
+                return `${Math.round(value)}ms`;
+            }
+            function formatDetails(details) {
+                if (!details || typeof details !== 'object') {
+                    return '';
+                }
+                const parts = Object.entries(details)
+                    .filter(([, value]) => value !== undefined && value !== null && value !== '')
+                    .map(([key, value]) => `${key}=${typeof value === 'number' ? Math.round(value) : value}`);
+                return parts.length > 0 ? ` | ${parts.join(', ')}` : '';
+            }
+            function elapsedSince(markName, currentNow) {
+                const startedAt = marks.get(markName);
+                return typeof startedAt === 'number' ? currentNow - startedAt : null;
+            }
+            return {
+                mark(stage, details) {
+                    const currentNow = now();
+                    marks.set(stage, currentNow);
+                    const pageElapsed = elapsedSince('page-start', currentNow) ?? 0;
+                    try {
+                        window.dispatchEvent(new CustomEvent(`startup-timing:${stage}`, {
+                            detail: {
+                                stage,
+                                elapsedMs: Math.round(pageElapsed),
+                                details: details || null
+                            }
+                        }));
+                    } catch { }
+                    console.log(`[Startup Timing] ${stage}: ${toDuration(pageElapsed)} since page start${formatDetails(details)}`);
+                    return Math.round(pageElapsed);
+                },
+                logMindCanvasReady(details) {
+                    const currentNow = now();
+                    marks.set('mindcanvas-ready', currentNow);
+                    const segments = [];
+                    const pageElapsed = elapsedSince('page-start', currentNow);
+                    const scriptLoaderElapsed = elapsedSince('script-loader-start', currentNow);
+                    const blazorElapsed = elapsedSince('blazor-start', currentNow);
+                    const bootstrapElapsed = elapsedSince('mindcanvas-bootstrap-start', currentNow);
+                    const boardElapsed = elapsedSince('mindcanvas-board-load-start', currentNow);
+                    if (pageElapsed !== null) segments.push(`page=${toDuration(pageElapsed)}`);
+                    if (scriptLoaderElapsed !== null) segments.push(`scriptLoader=${toDuration(scriptLoaderElapsed)}`);
+                    if (blazorElapsed !== null) segments.push(`blazor=${toDuration(blazorElapsed)}`);
+                    if (bootstrapElapsed !== null) segments.push(`bootstrap=${toDuration(bootstrapElapsed)}`);
+                    if (boardElapsed !== null) segments.push(`board=${toDuration(boardElapsed)}`);
+                    try {
+                        window.dispatchEvent(new CustomEvent('startup-timing:mindcanvas-ready', {
+                            detail: {
+                                stage: 'mindcanvas-ready',
+                                elapsedMs: Math.round(pageElapsed ?? 0),
+                                details: details || null
+                            }
+                        }));
+                    } catch { }
+                    console.log(`[Startup Timing] MindCanvas ready: ${segments.join(' | ')}${formatDetails(details)}`);
+                    return Math.round(pageElapsed ?? 0);
+                }
+            };
+        })();
+        window.mindExecutionStartupTiming.mark('index-html-ready', {
+            route: window.location.pathname || '/'
+        });
+        window.__marketingToolHosts = [
+            'mdview.pages.dev', 'mdview.mindexec.io', 'markdown-viewer.pages.dev', 'markdown-viewer.mindexec.io',
+            'bulkmd.pages.dev', 'bulkmd.mindexec.io', 'bulk-markdown-viewer.pages.dev', 'bulk-markdown-viewer.mindexec.io',
+            'mdoutln.pages.dev', 'mdoutln.mindexec.io', 'markdown-outline.pages.dev', 'markdown-outline.mindexec.io',
+            'mdtable.pages.dev', 'mdtable.mindexec.io', 'markdown-table-formatter.pages.dev', 'markdown-table-formatter.mindexec.io',
+            'readme.pages.dev', 'readme.mindexec.io', 'readme-previewer.pages.dev', 'readme-previewer.mindexec.io',
+            'md2html.pages.dev', 'md2html.mindexec.io', 'markdown-to-html.pages.dev', 'markdown-to-html.mindexec.io',
+            'mdcheck.pages.dev', 'mdcheck.mindexec.io', 'markdown-link-checker.pages.dev', 'markdown-link-checker.mindexec.io',
+            'quickpad.pages.dev', 'quickpad.mindexec.io', 'browser-notepad.pages.dev', 'browser-notepad.mindexec.io',
+            'clipbrd.pages.dev', 'clipbrd.mindexec.io', 'clipboard-board.pages.dev', 'clipboard-board.mindexec.io'
+        ];
+        window.__matchesMarketingToolHost = function (configuredHost, runtimeHost) {
+            if (!configuredHost || !runtimeHost) {
+                return false;
+            }
+            const normalizedConfiguredHost = configuredHost.toLowerCase();
+            const normalizedRuntimeHost = runtimeHost.toLowerCase();
+            if (normalizedConfiguredHost === normalizedRuntimeHost) {
+                return true;
+            }
+            if (!normalizedConfiguredHost.endsWith('.pages.dev') || !normalizedRuntimeHost.endsWith('.pages.dev')) {
+                return false;
+            }
+            const configuredPrefix = normalizedConfiguredHost.slice(0, -'.pages.dev'.length);
+            const runtimePrefix = normalizedRuntimeHost.slice(0, -'.pages.dev'.length);
+            return runtimePrefix === configuredPrefix || runtimePrefix.startsWith(`${configuredPrefix}-`);
+        };
+        window.__isMarketingToolHost = window.__marketingToolHosts.some(host =>
+            window.__matchesMarketingToolHost(host, location.host || '')
+        );
+    </script>
+    <!-- ??좎뜦堉??[Upgrade] Three.js r168 via ESM ??좎뜦堉??-->
+    <script type="importmap">
+    {
+        "imports": {
+            "three": "https://cdn.jsdelivr.net/npm/three@0.168.0/build/three.module.js"
+        }
+    }
+    </script>
+    <script type="module">
+        if (!window.__isMarketingToolHost) {
+            const THREE = await import('three');
+            window.THREE = THREE;
+            globalThis.THREE = THREE;
+            console.log('[Three.js] r' + THREE.REVISION + ' loaded (ESM ??global)');
+            window.THREE_LOADED = true;
+            window.dispatchEvent(new Event('three-loaded'));
+        } else {
+            console.log('[Script Loader] Marketing tool host detected. Skipping Three.js preload.');
+        }
+    </script>
+    <!-- Wait for THREE then load dependent scripts -->
+    <script>
+        function loadScript(src, options = {}) {
+            const SCRIPT_LOAD_TIMEOUT_MS = 15000;
+            const SCRIPT_LOAD_SLOW_MS = 3000;
+            window.__mindExecutionScriptLoaderState = window.__mindExecutionScriptLoaderState || {
+                pending: {},
+                completed: [],
+                lastError: null
+            };
+            const label = options.label || src;
+            const startAt = performance.now();
+            window.__mindExecutionScriptLoaderState.pending[label] = {
+                src,
+                label,
+                startedAt: startAt
+            };
+            return new Promise((resolve, reject) => {
+                const s = document.createElement('script');
+                s.src = src;
+                if (options.ordered === true) {
+                    // Ordered dynamic scripts still fetch in parallel, but execute in append order.
+                    s.async = false;
+                }
+                if (options.fetchPriority) {
+                    s.fetchPriority = options.fetchPriority;
+                }
+                let finished = false;
+                const complete = (kind, error = null) => {
+                    if (finished) return;
+                    finished = true;
+                    clearTimeout(timeoutHandle);
+                    const elapsedMs = Math.max(0, performance.now() - startAt);
+                    delete window.__mindExecutionScriptLoaderState.pending[label];
+                    if (kind === 'load') {
+                        window.__mindExecutionScriptLoaderState.completed.push({
+                            label,
+                            elapsedMs: Math.round(elapsedMs),
+                            loadedAt: Date.now()
+                        });
+                        if (elapsedMs >= SCRIPT_LOAD_SLOW_MS) {
+                            console.warn(`[Script Loader] Slow script load: ${label} (${elapsedMs.toFixed(0)}ms)`);
+                        }
+                        resolve();
+                        return;
+                    }
+                    const pendingLabels = Object.keys(window.__mindExecutionScriptLoaderState.pending || {});
+                    const failure = error instanceof Error
+                        ? error
+                        : new Error(String(error || `Failed to load script: ${label}`));
+                    window.__mindExecutionScriptLoaderState.lastError = {
+                        label,
+                        src,
+                        kind,
+                        elapsedMs: Math.round(elapsedMs),
+                        pending: pendingLabels,
+                        message: failure.message
+                    };
+                    reject(failure);
+                };
+                const timeoutHandle = setTimeout(() => {
+                    const pendingLabels = Object.keys(window.__mindExecutionScriptLoaderState.pending || {});
+                    complete('timeout', new Error(`[Script Loader] Timeout waiting for ${label} after ${SCRIPT_LOAD_TIMEOUT_MS}ms | pending=${pendingLabels.join(', ') || '-'}`));
+                }, options.timeoutMs || SCRIPT_LOAD_TIMEOUT_MS);
+                s.onload = () => complete('load');
+                s.onerror = () => complete('error', new Error(`[Script Loader] Failed to load ${label}`));
+                document.head.appendChild(s);
+            });
+        }
+        function loadScriptBatchOrdered(scripts, scriptUrl, onLoaded) {
+            const scriptPromises = [];
+            for (const script of scripts) {
+                const promise = loadScript(scriptUrl(script), {
+                    ordered: true,
+                    fetchPriority: 'high',
+                    label: script
+                }).then(() => {
+                    onLoaded?.(script);
+                });
+                scriptPromises.push(promise);
+            }
+            return Promise.all(scriptPromises);
+        }
+        async function loadDependentScripts() {
+            window.mindExecutionStartupTiming?.mark('script-loader-start', {
+                route: window.location.pathname || '/'
+            });
+            if (window.__isMarketingToolHost) {
+                console.log('[Script Loader] Marketing tool host detected. Skipping MindMap script bundle.');
+                try {
+                    if (window.__swCleanup) {
+                        const cleaned = await window.__swCleanup;
+                        const flag = '__swCleanedOnce';
+                        if (cleaned && !sessionStorage.getItem(flag)) {
+                            sessionStorage.setItem(flag, '1');
+                            location.reload();
+                            return;
+                        }
+                    }
+                } catch { }
+                if (window.Blazor && Blazor.start) {
+                    window.mindExecutionStartupTiming?.mark('blazor-start', { marketingToolHost: true });
+                    await Blazor.start();
+                }
+                return;
+            }
+            // Wait for THREE to be available
+            if (!window.THREE_LOADED) {
+                await new Promise(r => window.addEventListener('three-loaded', r, { once: true }));
+            }
+            const base = '_content/MindExecution.Shared/js/';
+        const scriptVersion = '20260627-blazor-ui-complete-v832';
+            const scriptUrl = (script) => `${base}${script}?v=${scriptVersion}`;
+            console.log(`[Script Loader] Shared JS version: ${scriptVersion}`);
+            const criticalScripts = [
+                'mind-map-dev-guards.js',
+                'renderers/CSS3DRenderer.js',
+                'helpers/InfiniteGridHelper.js',
+                'marked.min.js',
+                'background-themes.js',
+                'mind-map-logic-workers.js',
+                // Troika removed
+                'texture-worker-manager.js',  // ??Web Worker ??좎럩?ゅ뜝???좎럩苑?
+                'mind-map-texture-factory.js',
+                'mind-map-glow-shader.js',  // ??SDF Glow (no textures, GPU only)
+                'mind-map-css3d-manager.js',
+                'mind-map-text-overlay-v2.js',
+                'mind-map-object-manager.js',
+                'mind-map-pipeline.js',
+                'mind-map-nodes.js',
+                'mind-map-menu-manager.js',
+                'mind-map-multi-select.js',
+                'mind-map-interactions.js',
+                'mind-map-dnd.js',
+                'mind-map-lod-renderer.js',
+                'mind-map-text-lod-system.js',  // ??Text LOD ??좎럩???(??좎럩????좎럩?ゅ뜝???좎럩彛?
+                'mind-map-core.js',
+                'mindmap-toolbar.js',
+                'token-manager.js',
+                'file-system-helper.js'
+            ];
+            const routePath = (location.pathname || '/').toLowerCase();
+            const routeCriticalScripts = [];
+            if (routePath === '/code' || routePath === '/agent') {
+                routeCriticalScripts.push('code-master.js', 'agent-visualization.js');
+            }
+            if (routePath === '/planmaster' || routePath === '/planagent') {
+                routeCriticalScripts.push('plan-master.js');
+            }
+            const deferredScripts = ['plan-master.js', 'code-master.js', 'agent-visualization.js']
+                .filter(script => !routeCriticalScripts.includes(script));
+            function queueAgentSettings(globalName, pendingKey) {
+                if (window[globalName]) return;
+                window[globalName] = {
+                    applySettings(settings) {
+                        window[pendingKey] = Object.assign({}, window[pendingKey] || {}, settings || {});
+                    }
+                };
+            }
+            function flushQueuedAgentSettings(script) {
+                const mappings = {
+                    'plan-master.js': ['planAgent', '__pendingPlanAgentSettings'],
+                    'code-master.js': ['codeAgent', '__pendingCodeAgentSettings']
+                };
+                const mapping = mappings[script];
+                if (!mapping) return;
+                const [globalName, pendingKey] = mapping;
+                const pending = window[pendingKey];
+                if (pending && window[globalName]?.applySettings) {
+                    window[pendingKey] = null;
+                    window[globalName].applySettings(pending);
+                }
+            }
+            queueAgentSettings('planAgent', '__pendingPlanAgentSettings');
+            queueAgentSettings('codeAgent', '__pendingCodeAgentSettings');
+            await loadScriptBatchOrdered(
+                [...criticalScripts, ...routeCriticalScripts],
+                scriptUrl,
+                flushQueuedAgentSettings
+            );
+            window.MindCanvasBuildInfo?.setRuntime?.('scriptVersion', scriptVersion);
+            window.MindCanvasBuildInfo?.validateRequiredParts?.(['devGuards', 'core', 'lodRenderer']);
+            console.log('[Script Loader] Critical scripts loaded, starting Blazor...');
+            window.mindExecutionStartupTiming?.mark('critical-scripts-loaded', {
+                criticalCount: criticalScripts.length + routeCriticalScripts.length
+            });
+            // SW cleanup
+            try {
+                if (window.__swCleanup) {
+                    const cleaned = await window.__swCleanup;
+                    const flag = '__swCleanedOnce';
+                    if (cleaned && !sessionStorage.getItem(flag)) {
+                        sessionStorage.setItem(flag, '1');
+                        location.reload();
+                        return;
+                    }
+                }
+            } catch { }
+            // Start Blazor
+            if (window.Blazor && Blazor.start) {
+                window.mindExecutionStartupTiming?.mark('blazor-start', { marketingToolHost: false });
+                await Blazor.start();
+            }
+            const scheduleDeferredScripts = window.requestIdleCallback
+                ? ((callback) => window.requestIdleCallback(callback, { timeout: 1500 }))
+                : ((callback) => setTimeout(callback, 0));
+            const loadDeferredScriptsNow = () => {
+                scheduleDeferredScripts(() => {
+                    (async () => {
+                        await loadScriptBatchOrdered(
+                            deferredScripts,
+                            scriptUrl,
+                            flushQueuedAgentSettings
+                        );
+                        console.log('[Script Loader] Deferred scripts loaded.');
+                        window.mindExecutionStartupTiming?.mark('deferred-scripts-loaded', {
+                            deferredCount: deferredScripts.length
+                        });
+                    })().catch(e => console.error('[Script Loader] Deferred load failed:', e));
+                });
+            };
+            if (routePath === '/mindcanvas' && deferredScripts.length > 0) {
+                let deferredStarted = false;
+                const startDeferredAfterMindCanvasReady = () => {
+                    if (deferredStarted) return;
+                    deferredStarted = true;
+                    loadDeferredScriptsNow();
+                };
+                window.addEventListener('startup-timing:mindcanvas-ready', startDeferredAfterMindCanvasReady, { once: true });
+                setTimeout(startDeferredAfterMindCanvasReady, 20000);
+            } else {
+                loadDeferredScriptsNow();
+            }
+        }
+        // Start loading
+        loadDependentScripts().catch(e => {
+            console.error('[Script Loader] Failed:', e);
+            window.showBlazorBootError('The page could not finish loading. Reload and try again.');
+        });
+    </script>
+    <!-- ??좎뜦堉??[Upgrade] ??좎뜦堉??-->
+</body>
+</html>