noteconnection 1.6.8 → 1.8.0

package/dist/src/frontend/simulationWorker.js

@@ -12,6 +12,194 @@ let currentSettings = {
     velocityDecay: 0.2
 };
 
+let startupProfile = {
+    id: 'default',
+    pilotEnabled: false,
+    tickMaxFps: 0,
+    lowAlphaTickMaxFps: 0,
+    lowAlphaThreshold: 0.08,
+    stableAlphaThreshold: 0.05,
+    stableHoldTicks: 8,
+    stableTimeoutMs: 12000,
+    deltaEnabled: false,
+    deltaEpsilonPx: 0.6,
+    fullSyncEveryTicks: 3,
+    lowAlphaDeltaEpsilonMultiplier: 1.35,
+    lowAlphaFullSyncEveryTicks: 5
+};
+
+let startupRuntimeState = {
+    tickMinIntervalMs: 0,
+    lowAlphaTickMinIntervalMs: 0,
+    lastTickEmitTs: 0,
+    initTs: 0,
+    stableTickStreak: 0,
+    stableAnnounced: false,
+    tickCount: 0,
+    prevPositions: new Map()
+};
+
+function parseFiniteNumber(value, fallback) {
+    if (Number.isFinite(value)) {
+        return value;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function parsePositiveInt(value, fallback) {
+    const parsed = Math.floor(parseFiniteNumber(value, fallback));
+    return parsed > 0 ? parsed : fallback;
+}
+
+function configureStartupProfile(profile) {
+    const next = {
+        id: (profile && typeof profile.id === 'string' && profile.id.trim().length > 0)
+            ? profile.id.trim()
+            : 'default',
+        pilotEnabled: Boolean(profile && profile.pilotEnabled === true),
+        tickMaxFps: Math.max(0, parsePositiveInt(profile ? profile.tickMaxFps : 0, 0)),
+        lowAlphaTickMaxFps: Math.max(0, parsePositiveInt(profile ? profile.lowAlphaTickMaxFps : 0, 0)),
+        lowAlphaThreshold: Math.max(0.0001, parseFiniteNumber(profile ? profile.lowAlphaThreshold : 0.08, 0.08)),
+        stableAlphaThreshold: Math.max(0.0001, parseFiniteNumber(profile ? profile.stableAlphaThreshold : 0.05, 0.05)),
+        stableHoldTicks: Math.max(1, parsePositiveInt(profile ? profile.stableHoldTicks : 8, 8)),
+        stableTimeoutMs: Math.max(1000, parsePositiveInt(profile ? profile.stableTimeoutMs : 12000, 12000)),
+        deltaEnabled: Boolean(profile && profile.deltaEnabled === true),
+        deltaEpsilonPx: Math.max(0.0001, parseFiniteNumber(profile ? profile.deltaEpsilonPx : 0.6, 0.6)),
+        fullSyncEveryTicks: Math.max(1, parsePositiveInt(profile ? profile.fullSyncEveryTicks : 3, 3)),
+        lowAlphaDeltaEpsilonMultiplier: Math.max(
+            1,
+            parseFiniteNumber(profile ? profile.lowAlphaDeltaEpsilonMultiplier : 1.35, 1.35)
+        ),
+        lowAlphaFullSyncEveryTicks: Math.max(
+            1,
+            parsePositiveInt(
+                profile ? profile.lowAlphaFullSyncEveryTicks : Math.max(4, parsePositiveInt(profile ? profile.fullSyncEveryTicks : 3, 3)),
+                Math.max(4, parsePositiveInt(profile ? profile.fullSyncEveryTicks : 3, 3))
+            )
+        )
+    };
+
+    startupProfile = next;
+    startupRuntimeState = {
+        tickMinIntervalMs: next.tickMaxFps > 0 ? Math.max(1, Math.floor(1000 / next.tickMaxFps)) : 0,
+        lowAlphaTickMinIntervalMs: next.lowAlphaTickMaxFps > 0 ? Math.max(1, Math.floor(1000 / next.lowAlphaTickMaxFps)) : 0,
+        lastTickEmitTs: 0,
+        initTs: Date.now(),
+        stableTickStreak: 0,
+        stableAnnounced: false,
+        tickCount: 0,
+        prevPositions: new Map()
+    };
+
+    console.log('[Worker] Startup profile configured:', {
+        id: next.id,
+        pilotEnabled: next.pilotEnabled,
+        tickMaxFps: next.tickMaxFps,
+        tickMinIntervalMs: startupRuntimeState.tickMinIntervalMs,
+        lowAlphaTickMaxFps: next.lowAlphaTickMaxFps,
+        lowAlphaTickMinIntervalMs: startupRuntimeState.lowAlphaTickMinIntervalMs,
+        lowAlphaThreshold: next.lowAlphaThreshold,
+        stableAlphaThreshold: next.stableAlphaThreshold,
+        stableHoldTicks: next.stableHoldTicks,
+        stableTimeoutMs: next.stableTimeoutMs,
+        deltaEnabled: next.deltaEnabled,
+        deltaEpsilonPx: next.deltaEpsilonPx,
+        fullSyncEveryTicks: next.fullSyncEveryTicks,
+        lowAlphaDeltaEpsilonMultiplier: next.lowAlphaDeltaEpsilonMultiplier,
+        lowAlphaFullSyncEveryTicks: next.lowAlphaFullSyncEveryTicks
+    });
+}
+
+function resolveTickMinIntervalMs(alpha) {
+    const highAlphaIntervalMs = startupRuntimeState.tickMinIntervalMs;
+    const lowAlphaIntervalMs = startupRuntimeState.lowAlphaTickMinIntervalMs;
+    if (lowAlphaIntervalMs <= 0) {
+        return highAlphaIntervalMs;
+    }
+    if (alpha <= startupProfile.lowAlphaThreshold) {
+        return Math.max(highAlphaIntervalMs, lowAlphaIntervalMs);
+    }
+    return highAlphaIntervalMs;
+}
+
+function resolveDeltaEpsilonPx(alpha) {
+    let epsilon = startupProfile.deltaEpsilonPx;
+    if (alpha <= startupProfile.lowAlphaThreshold) {
+        epsilon *= startupProfile.lowAlphaDeltaEpsilonMultiplier;
+    }
+    return Math.max(0.0001, epsilon);
+}
+
+function resolveFullSyncEveryTicks(alpha) {
+    if (alpha <= startupProfile.lowAlphaThreshold) {
+        return Math.max(startupProfile.fullSyncEveryTicks, startupProfile.lowAlphaFullSyncEveryTicks);
+    }
+    return startupProfile.fullSyncEveryTicks;
+}
+
+function buildFullPositionPayload() {
+    const payload = new Array(nodes.length);
+    for (let index = 0; index < nodes.length; index += 1) {
+        const n = nodes[index];
+        const x = Number.isFinite(n.x) ? n.x : 0;
+        const y = Number.isFinite(n.y) ? n.y : 0;
+        payload[index] = { id: n.id, i: index, x, y };
+        startupRuntimeState.prevPositions.set(n.id, { x, y });
+    }
+    return payload;
+}
+
+function buildDeltaPositionPayload(alpha) {
+    const payload = [];
+    const epsilon = resolveDeltaEpsilonPx(alpha);
+    for (let index = 0; index < nodes.length; index += 1) {
+        const n = nodes[index];
+        const x = Number.isFinite(n.x) ? n.x : 0;
+        const y = Number.isFinite(n.y) ? n.y : 0;
+        const prev = startupRuntimeState.prevPositions.get(n.id);
+        if (!prev || Math.abs(prev.x - x) >= epsilon || Math.abs(prev.y - y) >= epsilon) {
+            payload.push({ id: n.id, i: index, x, y });
+            startupRuntimeState.prevPositions.set(n.id, { x, y });
+        }
+    }
+    return payload;
+}
+
+function buildTickPositionsPayload(alpha) {
+    startupRuntimeState.tickCount += 1;
+    const activeFullSyncEveryTicks = resolveFullSyncEveryTicks(alpha);
+    const forceFull =
+        startupRuntimeState.tickCount === 1 ||
+        startupProfile.deltaEnabled !== true ||
+        activeFullSyncEveryTicks <= 1 ||
+        (startupRuntimeState.tickCount % activeFullSyncEveryTicks) === 0;
+
+    if (forceFull) {
+        return {
+            nodes: buildFullPositionPayload(),
+            isDelta: false,
+            tickMode: 'full'
+        };
+    }
+
+    const deltaNodes = buildDeltaPositionPayload(alpha);
+    const changeRatio = nodes.length > 0 ? (deltaNodes.length / nodes.length) : 0;
+    if (changeRatio >= 0.7) {
+        return {
+            nodes: buildFullPositionPayload(),
+            isDelta: false,
+            tickMode: 'full'
+        };
+    }
+
+    return {
+        nodes: deltaNodes,
+        isDelta: true,
+        tickMode: 'delta'
+    };
+}
+
 onmessage = function(event) {
     const { type, payload } = event.data;
 
@@ -52,10 +240,12 @@ function initSimulation(data) {
     nodes = data.nodes;
     links = data.links;
     const { width, height } = data;
-    const { settings } = data; // Settings if provided
+    const { settings, startupProfile: startupProfilePayload } = data; // Settings if provided
 
     console.log(`[Worker] Initializing simulation with ${nodes.length} nodes, ${links.length} edges`);
 
+    configureStartupProfile(startupProfilePayload || {});
+
     if (settings) {
         currentSettings = { ...currentSettings, ...settings };
     }
@@ -89,10 +279,53 @@ function initSimulation(data) {
         .velocityDecay(currentSettings.velocityDecay);
 
     simulation.on("tick", () => {
-        // Optimization: For very large graphs, maybe use Float32Array?
-        // For now, post simplified objects
-        const positions = nodes.map(n => ({ id: n.id, x: n.x, y: n.y }));
-        postMessage({ type: 'tick', nodes: positions });
+        const now = Date.now();
+        const alpha = (simulation && typeof simulation.alpha === 'function')
+            ? simulation.alpha()
+            : 1;
+        const activeTickMinIntervalMs = resolveTickMinIntervalMs(alpha);
+        if (
+            activeTickMinIntervalMs > 0 &&
+            (now - startupRuntimeState.lastTickEmitTs) < activeTickMinIntervalMs
+        ) {
+            return;
+        }
+        startupRuntimeState.lastTickEmitTs = now;
+
+        let isStartupStable = false;
+
+        if (!startupRuntimeState.stableAnnounced) {
+            if (alpha <= startupProfile.stableAlphaThreshold) {
+                startupRuntimeState.stableTickStreak += 1;
+            } else {
+                startupRuntimeState.stableTickStreak = 0;
+            }
+
+            const elapsedMs = now - startupRuntimeState.initTs;
+            if (
+                startupRuntimeState.stableTickStreak >= startupProfile.stableHoldTicks ||
+                elapsedMs >= startupProfile.stableTimeoutMs
+            ) {
+                startupRuntimeState.stableAnnounced = true;
+                isStartupStable = true;
+                postMessage({
+                    type: 'startupStable',
+                    alpha,
+                    elapsedMs
+                });
+            }
+        }
+
+        const tickPositions = buildTickPositionsPayload(alpha);
+        postMessage({
+            type: 'tick',
+            nodes: tickPositions.nodes,
+            isDelta: tickPositions.isDelta,
+            tickMode: tickPositions.tickMode,
+            alpha,
+            emittedAt: now,
+            isStartupStable
+        });
     });
     
     // Initial warmup
@@ -175,6 +408,8 @@ function setNodes(payload) {
     // Re-initialize key forces
     simulation.nodes(nodes);
     simulation.force("link").links(links);
+    startupRuntimeState.prevPositions = new Map();
+    startupRuntimeState.tickCount = 0;
     
     // If we want to support collision updates based on new subset
     // simulation.force("collide")...
@@ -216,7 +451,7 @@ function fixNodes(nodeUpdates) {
     nodeUpdates.forEach(update => {
         const node = nodes.find(n => n.id === update.id);
         if (node) {
-            if (update.cod === 'fix') {
+            if (update.cmd === 'fix') {
                  node.fx = update.x;
                  node.fy = update.y;
             } else if (update.cmd === 'unfix') {

package/dist/src/frontend/source_manager.js

@@ -1,10 +1,57 @@
 document.addEventListener('DOMContentLoaded', () => {
+    const hasExplicitBrowserRuntimeBootstrap = () => {
+        if (typeof window === 'undefined' || !window.__NC_SIDECAR_RUNTIME) {
+            return false;
+        }
+        const currentOrigin = String((window.location && window.location.origin) || '').trim().replace(/\/+$/, '');
+        const runtimeBaseUrl = String(window.__NC_SIDECAR_RUNTIME.baseUrl || '').trim().replace(/\/+$/, '');
+        return Boolean(currentOrigin && runtimeBaseUrl && currentOrigin === runtimeBaseUrl);
+    };
+
+    const isDetachedTauriCliPreviewPage = () =>
+        !window.__TAURI__ &&
+        Array.from(document.scripts || []).some((script) =>
+            /__tauri_cli/.test(String(script && (script.text || script.textContent) || ''))
+        );
+
+    const getRuntimeBaseOrigin = () => {
+        const bridge = (typeof window !== 'undefined') ? window.NoteConnectionRuntime : null;
+        const baseUrl = bridge && typeof bridge.getBaseUrl === 'function'
+            ? String(bridge.getBaseUrl() || '').trim()
+            : '';
+        if (!baseUrl) {
+            return '';
+        }
+        try {
+            return new URL(baseUrl).origin;
+        } catch (_error) {
+            return '';
+        }
+    };
+
+    const isDetachedPreviewWithoutRuntimeBootstrap = () =>
+        isDetachedTauriCliPreviewPage() && window.location.origin !== getRuntimeBaseOrigin();
+
+    const canUseBrowserRuntimeBackend = () => {
+        if (typeof window === 'undefined' || window.__TAURI__) {
+            return false;
+        }
+        if (isDetachedPreviewWithoutRuntimeBootstrap()) {
+            return false;
+        }
+        if (hasExplicitBrowserRuntimeBootstrap()) {
+            return true;
+        }
+        const origin = String((window.location && window.location.origin) || '').trim().toLowerCase();
+        return /^https?:\/\/(?:127\.0\.0\.1|localhost):3000$/.test(origin);
+    };
+
     let runtimeCaps = {
         platform: 'web',
-        supports_sidecar: true,
-        supports_build: true,
-        supports_content_api: true,
-        supports_kb_runtime_change: true,
+        supports_sidecar: canUseBrowserRuntimeBackend(),
+        supports_build: canUseBrowserRuntimeBackend(),
+        supports_content_api: canUseBrowserRuntimeBackend(),
+        supports_kb_runtime_change: false,
         supports_native_pathmode: false,
         supports_mobile_wasm_compute: false,
         mobile_wasm_reason: 'non-mobile-runtime'
@@ -38,6 +85,11 @@ document.addEventListener('DOMContentLoaded', () => {
         return null;
     };
 
+    const isStandaloneFrontendPreviewRuntime = () =>
+        !window.__TAURI__ &&
+        !resolveCapacitorPlatform() &&
+        runtimeCaps.supports_sidecar !== true;
+
     const supportsCapacitorContentApi = () => {
         if (typeof window === 'undefined') {
             return false;
@@ -190,6 +242,20 @@ document.addEventListener('DOMContentLoaded', () => {
                     supports_mobile_wasm_compute: runtimeCaps.supports_mobile_wasm_compute,
                     mobile_wasm_reason: runtimeCaps.mobile_wasm_reason
                 });
+            } else {
+                const browserRuntimeBackend = canUseBrowserRuntimeBackend();
+                runtimeCaps = {
+                    ...runtimeCaps,
+                    platform: 'web',
+                    supports_sidecar: browserRuntimeBackend,
+                    supports_build: browserRuntimeBackend,
+                    supports_content_api: browserRuntimeBackend,
+                    supports_kb_runtime_change: false,
+                    supports_native_pathmode: false
+                };
+                if (!browserRuntimeBackend) {
+                    console.log('[SourceManager] Frontend preview runtime detected: backend-dependent APIs disabled until a runtime bootstrap is provided.');
+                }
             }
             exposeRuntimeCaps();
             return;
@@ -249,6 +315,39 @@ document.addEventListener('DOMContentLoaded', () => {
         const parseGraphDataPayload = (text) => {
             const trimmed = text.trim();
             let parsed = null;
+            const extractAssignedJson = (sourceText, equalsIndex) => {
+                const textAfterEquals = sourceText.slice(equalsIndex + 1);
+                const openingIndex = textAfterEquals.search(/[\[{]/);
+                if (openingIndex < 0) {
+                    return '';
+                }
+                const startIndex = equalsIndex + 1 + openingIndex;
+                const openingChar = sourceText.charAt(startIndex);
+                const closingChar = openingChar === '{' ? '}' : ']';
+                let depth = 0;
+                let inString = false;
+
+                for (let cursor = startIndex; cursor < sourceText.length; cursor += 1) {
+                    const char = sourceText.charAt(cursor);
+                    const previous = sourceText.charAt(cursor - 1);
+                    if (char === '"' && previous !== '\\') {
+                        inString = !inString;
+                    }
+                    if (inString) {
+                        continue;
+                    }
+                    if (char === openingChar) {
+                        depth += 1;
+                    } else if (char === closingChar) {
+                        depth -= 1;
+                        if (depth === 0) {
+                            return sourceText.slice(startIndex, cursor + 1);
+                        }
+                    }
+                }
+
+                return '';
+            };
 
             // Expected format: const graphData = {...};
             if (
@@ -258,10 +357,7 @@ document.addEventListener('DOMContentLoaded', () => {
             ) {
                 const eqPos = trimmed.indexOf('=');
                 if (eqPos > -1) {
-                    let jsonText = trimmed.slice(eqPos + 1).trim();
-                    if (jsonText.endsWith(';')) {
-                        jsonText = jsonText.slice(0, -1);
-                    }
+                    const jsonText = extractAssignedJson(trimmed, eqPos);
                     parsed = JSON.parse(jsonText);
                 }
             } else if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
@@ -284,10 +380,7 @@ document.addEventListener('DOMContentLoaded', () => {
                     if (equalsIndex < 0) {
                         continue;
                     }
-                    let candidateJson = trimmed.slice(equalsIndex + 1).trim();
-                    if (candidateJson.endsWith(';')) {
-                        candidateJson = candidateJson.slice(0, -1).trim();
-                    }
+                    const candidateJson = extractAssignedJson(trimmed, equalsIndex);
                     if (!candidateJson) {
                         continue;
                     }
@@ -324,6 +417,23 @@ document.addEventListener('DOMContentLoaded', () => {
             }
         }
 
+        if (isDetachedPreviewWithoutRuntimeBootstrap()) {
+            throw new Error('Detached preview runtime has no sidecar-backed graph asset bootstrap.');
+        }
+
+        if (!window.__TAURI__ && runtimeCaps.supports_sidecar !== true) {
+            const previewUrl = `${src}?v=${Date.now()}`;
+            const response = await fetch(previewUrl, { cache: 'no-store' });
+            if (!response.ok) {
+                throw new Error(`Failed to fetch ${src}: HTTP ${response.status}`);
+            }
+            const text = await response.text();
+            const parsed = parseGraphDataPayload(text);
+            window.graphData = parsed;
+            console.log(`[Loader] Loaded ${src} via frontend preview asset: ${parsed.nodes.length} nodes`);
+            return;
+        }
+
         // ─── Strategy 1: HTTP fetch from sidecar (works in browser, may fail in Tauri WebView) ───
         // 策略1：通过 HTTP 从 sidecar 获取（浏览器中有效，Tauri WebView 中可能因混合内容限制而失败）
         const maxAttempts = (window.__TAURI__ && runtimeCaps.supports_sidecar) ? 20 : 1;
@@ -379,10 +489,7 @@ document.addEventListener('DOMContentLoaded', () => {
 
     const loadScript = async (src) => {
         const isRuntimeGeneratedDataAsset = src.startsWith('data');
-        const useRuntimeGeneratedAssetFlow = Boolean(
-            isRuntimeGeneratedDataAsset &&
-            (window.__TAURI__ || (typeof runtimeCaps.platform === 'string' && runtimeCaps.platform.startsWith('capacitor-')))
-        );
+        const useRuntimeGeneratedAssetFlow = Boolean(isRuntimeGeneratedDataAsset);
         if (useRuntimeGeneratedAssetFlow) {
             await loadGraphDataFromSidecar(src);
             return;
@@ -452,6 +559,19 @@ document.addEventListener('DOMContentLoaded', () => {
     };
 
     const bootstrapScriptLoad = () => {
+        if (isDetachedPreviewWithoutRuntimeBootstrap()) {
+            console.log('[Loader] Detached preview runtime detected. Skipping runtime graph preload and loading app.js directly.');
+            triggerWelcomeModal(false);
+            loadScript('app.js')
+                .then(() => {
+                    console.log('[Loader] app.js loaded successfully');
+                })
+                .catch(err => {
+                    console.error('[Loader] Failed to load app.js (Critical Error):', err);
+                });
+            return;
+        }
+
         // Load data.js first (Critical Data), then app.js (Application Logic)
         loadScript('data.js')
             .then(() => {
@@ -492,7 +612,7 @@ document.addEventListener('DOMContentLoaded', () => {
 
     if (!folderSelect || !loadBtn) return;
     if (loadBtn.dataset.sourceManagerBound === '1') {
-        console.warn('[SourceManager] Already initialized, skipping duplicate binding.');
+        console.log('[SourceManager] Duplicate binding guard triggered; skipping re-initialization.');
         return;
     }
     loadBtn.dataset.sourceManagerBound = '1';
@@ -610,6 +730,33 @@ document.addEventListener('DOMContentLoaded', () => {
         return await provider.checkCache(target);
     };
 
+    const ACTIVE_SOURCE_TARGET_EVENT = 'noteconnection:active-target-changed';
+
+    const normalizeActiveSourceTarget = (target) => {
+        const normalized = String(target || '').trim();
+        return normalized || 'ALL_FOLDERS';
+    };
+
+    const publishActiveSourceTarget = (target, source) => {
+        const normalizedTarget = normalizeActiveSourceTarget(target);
+        const payload = {
+            target: normalizedTarget,
+            source: String(source || 'source-manager').trim() || 'source-manager',
+            scope: normalizedTarget === 'ALL_FOLDERS'
+                ? null
+                : {
+                    workspaceId: normalizedTarget.toLowerCase(),
+                    corpusId: normalizedTarget.toLowerCase(),
+                    sourcePathPrefixes: [`Knowledge_Base/${normalizedTarget}`],
+                },
+        };
+        window.__NC_ACTIVE_SOURCE_TARGET = payload;
+        if (typeof window.dispatchEvent === 'function' && typeof window.CustomEvent === 'function') {
+            window.dispatchEvent(new CustomEvent(ACTIVE_SOURCE_TARGET_EVENT, { detail: payload }));
+        }
+        return payload;
+    };
+
     const syncSidecarKbPath = async (kbPath) => {
         if (!kbPath) {
             return;
@@ -775,7 +922,13 @@ document.addEventListener('DOMContentLoaded', () => {
             let folders = [];
             const inCapacitorRuntime = isCapacitorNativeRuntime();
 
-            if (inCapacitorRuntime) {
+            if (
+                isStandaloneFrontendPreviewRuntime() ||
+                isDetachedPreviewWithoutRuntimeBootstrap()
+            ) {
+                kbPath = t('source.previewPath');
+                folders = [];
+            } else if (inCapacitorRuntime) {
                 kbPath = t('source.capacitor.bundlePath');
                 const provider = getStorageProvider();
                 let listedFolders = [];
@@ -868,6 +1021,17 @@ document.addEventListener('DOMContentLoaded', () => {
                 folderSelect.appendChild(packagedOption);
             }
 
+            if (folderSelect.options.length === 0 && isStandaloneFrontendPreviewRuntime()) {
+                const previewOption = document.createElement('option');
+                previewOption.value = '';
+                previewOption.disabled = true;
+                previewOption.selected = true;
+                previewOption.textContent = t('source.previewPath');
+                folderSelect.appendChild(previewOption);
+                loadBtn.disabled = true;
+                return;
+            }
+
             if (folderSelect.options.length === 0) {
                 const emptyOption = document.createElement('option');
                 emptyOption.value = '';
@@ -892,6 +1056,7 @@ document.addEventListener('DOMContentLoaded', () => {
             } else {
                 folderSelect.value = folderSelect.options[0].value;
             }
+            publishActiveSourceTarget(folderSelect.value, 'folder-bootstrap');
             console.log('[SourceManager] Folder dropdown populated with', folderSelect.options.length, 'options');
             
         } catch (err) {
@@ -913,10 +1078,10 @@ document.addEventListener('DOMContentLoaded', () => {
         updateRuntimeCapabilityNotice();
         updateKbPathControls();
 
-        // Start static graph/frontend bootstrap immediately so UI initialization
-        // does not block on sidecar ping retries.
+        if (window.__TAURI__ && runtimeCaps.supports_sidecar) {
+            await waitForSidecarReady();
+        }
         bootstrapScriptLoad();
-        await waitForSidecarReady();
 
         if (window.i18n && window.i18n.isInitialized) {
             await fetchFolders();
@@ -938,6 +1103,7 @@ document.addEventListener('DOMContentLoaded', () => {
         if (folderSelect.value) {
             localStorage.setItem(LAST_TARGET_KEY, folderSelect.value);
         }
+        publishActiveSourceTarget(folderSelect.value, 'folder-change');
     });
 
     // Add refresh functionality (will be triggered by IPC event from main process)
@@ -1039,6 +1205,7 @@ document.addEventListener('DOMContentLoaded', () => {
                 return;
             }
             localStorage.setItem(LAST_TARGET_KEY, target);
+            publishActiveSourceTarget(target, 'build-request');
 
             // Feature: Check for cached graph (Multi-Session Optimization)
             // Bridge-first runtime: sidecar HTTP path with Tauri IPC fallback.
@@ -1067,6 +1234,7 @@ document.addEventListener('DOMContentLoaded', () => {
                         const restoreSuccess = await storageProvider.restoreCache(target);
 
                         if (restoreSuccess) {
+                            publishActiveSourceTarget(target, 'cache-restore');
                             keepLockedForReload = requestSafeReload('cache-restore', { force: true });
                             return;
                         }
@@ -1134,6 +1302,7 @@ document.addEventListener('DOMContentLoaded', () => {
             }
 
             if (success) {
+                publishActiveSourceTarget(target, 'build-success');
                 keepLockedForReload = true;
 
                 // v1.0.1: Pre-verify data.js is accessible before triggering reload.