npm - @mindexec/cli - Versions diffs - 0.2.0 - Mend

@mindexec/cli 0.2.0

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 (232) hide show

package/wwwroot/index.html ADDED Viewed

@@ -0,0 +1,710 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>MindExec | Run your ideas as AI task graphs</title>
+    <meta name="description" content="MindExec is an AI execution canvas for solo builders, researchers, developers, and creators. Start with free browser tools, then move serious work into saved MindCanvas projects." />
+    <base href="/" />
+    <link rel="stylesheet" href="_content/MindExecution.Shared/css/app.css?v=20260610-video-dnd-v454" />
+    <link rel="stylesheet" href="_content/MindExecution.Shared/css/mind-map-overrides.css?v=20260610-video-dnd-v454" />
+    <!-- ?쇄뼹??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>Run your ideas as AI task graphs. MindExec starts with free browser tools for markdown previews, README checks, notes, and clipboard capture. When the work becomes worth saving, move it into MindCanvas for persistent projects, AI-assisted organization, and visual workflows.</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;
+                    } else {
+                        e.preventDefault();
+                        if (dotNetRef && dotNetRef.invokeMethodAsync) {
+                            dotNetRef.invokeMethodAsync('OnEnterPressed');
+                        }
+                    }
+                }
+            };
+            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 = '20260610-video-dnd-v454';
+            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>