@mindexec/cli 0.2.483 → 0.2.494

package/wwwroot/_content/MindExecution.Shared/js/mind-map-native-core-bridge.js

@@ -0,0 +1,399 @@
+(function () {
+    'use strict';
+
+    const BUILD_ID = '20260830-native-core-primary-v006';
+    const STORAGE_KEY = 'mindmap.nativeCore.mode';
+    const NATIVE_WORKER_URL = `_content/MindExecution.Shared/native-core/mindexec-native-core-worker.js?v=${BUILD_ID}`;
+    const VALID_MODES = new Set(['off', 'compare', 'native']);
+    const RESULT_TYPES = new Set(['VISIBILITY_RESULT', 'HIT_TEST_RESULT', 'SELECTION_QUERY_RESULT']);
+    const MIRRORED_TYPES = new Set([
+        'RESET_BOARD',
+        'REBUILD_BOARD',
+        'UPSERT_NODE',
+        'REMOVE_NODE',
+        'VISIBILITY_QUERY',
+        'HIT_TEST_QUERY',
+        'SELECTION_QUERY'
+    ]);
+
+    function resolveMode() {
+        try {
+            const queryMode = new URLSearchParams(window.location?.search || '').get('nativeCore');
+            if (VALID_MODES.has(String(queryMode || '').toLowerCase())) {
+                return String(queryMode).toLowerCase();
+            }
+        } catch { }
+        try {
+            const saved = String(window.localStorage?.getItem(STORAGE_KEY) || '').toLowerCase();
+            if (VALID_MODES.has(saved)) return saved;
+        } catch { }
+        return 'off';
+    }
+
+    const mode = resolveMode();
+    const status = {
+        mode,
+        ready: false,
+        backend: '',
+        activeBackend: mode === 'off' ? 'off' : '',
+        fallbackActive: false,
+        fallbackCount: 0,
+        fallbackReason: '',
+        primaryResults: 0,
+        lastPrimaryResultType: '',
+        lastPrimaryDurationMs: 0,
+        lastPrimaryRoundTripMs: 0,
+        comparisons: 0,
+        mismatches: 0,
+        lastComparison: null,
+        lastError: '',
+        buildId: BUILD_ID
+    };
+    window.__mindExecutionNativeCoreStatus = status;
+
+    function publishRuntimeStatus() {
+        const root = document.documentElement;
+        if (!root) return;
+        root.dataset.mindexecNativeCoreMode = status.mode;
+        root.dataset.mindexecNativeCoreReady = status.ready ? 'true' : 'false';
+        root.dataset.mindexecNativeCoreBackend = status.backend || '';
+        root.dataset.mindexecNativeCoreActiveBackend = status.activeBackend || '';
+        root.dataset.mindexecNativeCoreFallback = status.fallbackActive ? 'true' : 'false';
+        root.dataset.mindexecNativeCoreError = status.lastError || '';
+    }
+
+    publishRuntimeStatus();
+
+    function normalizeToken(value) {
+        const number = Number(value || 0);
+        return Number.isFinite(number) && number >= 0 ? Math.floor(number) : 0;
+    }
+
+    function resultKey(payload) {
+        return [
+            String(payload?.type || ''),
+            String(payload?.boardId || '').trim(),
+            normalizeToken(payload?.engineGeneration),
+            normalizeToken(payload?.boardEpoch),
+            normalizeToken(payload?.boardRevision),
+            normalizeToken(payload?.seq)
+        ].join(':');
+    }
+
+    function normalizeIds(source) {
+        if (!Array.isArray(source)) return null;
+        return source
+            .map((value) => String(value || '').trim())
+            .filter(Boolean)
+            .sort();
+    }
+
+    function arraysEqual(left, right) {
+        if (left === null || right === null) return left === right;
+        if (left.length !== right.length) return false;
+        for (let index = 0; index < left.length; index++) {
+            if (left[index] !== right[index]) return false;
+        }
+        return true;
+    }
+
+    function numbersEqual(left, right, tolerance = 0.000001) {
+        const leftNumber = Number(left);
+        const rightNumber = Number(right);
+        if (!Number.isFinite(leftNumber) || !Number.isFinite(rightNumber)) {
+            return leftNumber === rightNumber;
+        }
+        return Math.abs(leftNumber - rightNumber) <= tolerance;
+    }
+
+    function viewportRectsEqual(left, right) {
+        if (!left || !right) return left === right;
+        return numbersEqual(left.left, right.left) &&
+            numbersEqual(left.right, right.right) &&
+            numbersEqual(left.bottom, right.bottom) &&
+            numbersEqual(left.top, right.top) &&
+            String(left.mode || '') === String(right.mode || '') &&
+            numbersEqual(left.cameraZ, right.cameraZ);
+    }
+
+    function comparePayloads(primary, native) {
+        const type = String(primary?.type || '');
+        const details = { type, seq: normalizeToken(primary?.seq), differences: [] };
+        if (primary?.stale === true || native?.stale === true) {
+            if (primary?.stale !== native?.stale) details.differences.push('stale');
+            return details;
+        }
+        if (type === 'VISIBILITY_RESULT') {
+            if (Number(primary.visibleCount) !== Number(native.visibleCount)) details.differences.push('visibleCount');
+            if (primary.visibilityChanged !== native.visibilityChanged) details.differences.push('visibilityChanged');
+            if (primary.fullResVisibilityReconcilePending !== native.fullResVisibilityReconcilePending) {
+                details.differences.push('fullResVisibilityReconcilePending');
+            }
+            if (Number(primary.lastVisibilityNodeCount) !== Number(native.lastVisibilityNodeCount)) {
+                details.differences.push('lastVisibilityNodeCount');
+            }
+            if (!viewportRectsEqual(primary.viewportRect, native.viewportRect)) details.differences.push('viewportRect');
+            if (!arraysEqual(normalizeIds(primary.enteredIds), normalizeIds(native.enteredIds))) details.differences.push('enteredIds');
+            if (!arraysEqual(normalizeIds(primary.exitedIds), normalizeIds(native.exitedIds))) details.differences.push('exitedIds');
+            const primaryHasVisibleIds = Array.isArray(primary.visibleIds);
+            const nativeHasVisibleIds = Array.isArray(native.visibleIds);
+            if (primaryHasVisibleIds !== nativeHasVisibleIds) details.differences.push('visibleIdsPresence');
+            else if (primaryHasVisibleIds && !arraysEqual(normalizeIds(primary.visibleIds), normalizeIds(native.visibleIds))) {
+                details.differences.push('visibleIds');
+            }
+            const primaryHasPriorityIds = Array.isArray(primary.priorityIds);
+            const nativeHasPriorityIds = Array.isArray(native.priorityIds);
+            if (primaryHasPriorityIds !== nativeHasPriorityIds) details.differences.push('priorityIdsPresence');
+            else if (primaryHasPriorityIds) {
+                const primaryOrder = primary.priorityIds.map((value) => String(value || '').trim()).filter(Boolean);
+                const nativeOrder = native.priorityIds.map((value) => String(value || '').trim()).filter(Boolean);
+                if (!arraysEqual(primaryOrder, nativeOrder)) details.differences.push('priorityOrder');
+            }
+        } else if (type === 'HIT_TEST_RESULT') {
+            if (!arraysEqual(normalizeIds(primary.candidateIds), normalizeIds(native.candidateIds))) {
+                details.differences.push('candidateIds');
+            }
+        } else if (type === 'SELECTION_QUERY_RESULT') {
+            if (!arraysEqual(normalizeIds(primary.selectedIds), normalizeIds(native.selectedIds))) {
+                details.differences.push('selectedIds');
+            }
+        }
+        return details;
+    }
+
+    function recordComparison(primary, native) {
+        const comparison = comparePayloads(primary, native);
+        comparison.matched = comparison.differences.length === 0;
+        comparison.primaryDurationMs = Number(primary?.profile?.durationMs || 0);
+        comparison.nativeDurationMs = Number(native?.profile?.durationMs || 0);
+        status.comparisons++;
+        if (!comparison.matched) status.mismatches++;
+        status.lastComparison = comparison;
+        window.MindCanvasTrace?.emit?.('nativeCore.compare', comparison);
+        if (!comparison.matched && status.mismatches <= 5) {
+            console.warn('[MindExecutionNativeCore] C++ shadow result differs from JS.', comparison);
+        }
+    }
+
+    class NativeCoreShadow {
+        constructor() {
+            this.primaryResults = new Map();
+            this.nativeResults = new Map();
+            this.worker = null;
+            try {
+                this.worker = new Worker(NATIVE_WORKER_URL);
+                this.worker.onmessage = (event) => this._onMessage(event?.data || null);
+                this.worker.onerror = (error) => {
+                    this._disable(String(error?.message || 'native core worker error'));
+                };
+            } catch (error) {
+                status.lastError = String(error?.message || error || 'native core worker creation failed');
+            }
+        }
+
+        _onMessage(data) {
+            if (!data || typeof data !== 'object') return;
+            if (data.type === 'READY') {
+                status.ready = true;
+                status.backend = String(data.backend || 'wasm');
+                status.activeBackend = status.backend;
+                status.fallbackActive = false;
+                status.fallbackReason = '';
+                status.lastError = '';
+                publishRuntimeStatus();
+                window.MindCanvasTrace?.emit?.('nativeCore.ready', {
+                    mode,
+                    backend: status.backend,
+                    apiVersion: Number(data.apiVersion || 0),
+                    buildId: String(data.buildId || '')
+                });
+                return;
+            }
+            if (data.type === 'NATIVE_CORE_INIT_ERROR' || data.type === 'NATIVE_CORE_RUNTIME_ERROR') {
+                this._disable(String(data.message || data.type));
+                return;
+            }
+            if (!RESULT_TYPES.has(String(data.type || ''))) return;
+            const key = resultKey(data);
+            this.nativeResults.set(key, data);
+            this._compareIfReady(key);
+            this._trim();
+        }
+
+        _disable(message) {
+            status.lastError = String(message || 'native core disabled');
+            status.ready = false;
+            status.backend = '';
+            status.activeBackend = '';
+            publishRuntimeStatus();
+            try { this.worker?.terminate?.(); } catch { }
+            this.worker = null;
+            this.primaryResults.clear();
+            this.nativeResults.clear();
+        }
+
+        _compareIfReady(key) {
+            const primary = this.primaryResults.get(key);
+            const native = this.nativeResults.get(key);
+            if (!primary || !native) return;
+            this.primaryResults.delete(key);
+            this.nativeResults.delete(key);
+            recordComparison(primary, native);
+            this._trim();
+        }
+
+        _trim() {
+            const trimMap = (map) => {
+                while (map.size > 64) map.delete(map.keys().next().value);
+            };
+            trimMap(this.primaryResults);
+            trimMap(this.nativeResults);
+        }
+
+        post(payload) {
+            if (!this.worker || !MIRRORED_TYPES.has(String(payload?.type || ''))) return false;
+            try {
+                this.worker.postMessage(payload);
+                return true;
+            } catch (error) {
+                status.lastError = String(error?.message || error || 'native core shadow post failed');
+                return false;
+            }
+        }
+
+        observePrimaryResult(payload) {
+            if (!RESULT_TYPES.has(String(payload?.type || ''))) return;
+            const key = resultKey(payload);
+            this.primaryResults.set(key, payload);
+            this._compareIfReady(key);
+            this._trim();
+        }
+
+        dispose() {
+            try { this.worker?.terminate?.(); } catch { }
+            this.worker = null;
+            this.primaryResults.clear();
+            this.nativeResults.clear();
+            status.ready = false;
+            status.backend = '';
+            status.activeBackend = '';
+            publishRuntimeStatus();
+        }
+    }
+
+    window.MindMapNativeCoreBridge = Object.freeze({
+        BUILD_ID,
+        STORAGE_KEY,
+        NATIVE_WORKER_URL,
+        getMode() {
+            return mode;
+        },
+        getPrimaryWorkerUrl(defaultUrl) {
+            return mode === 'native' ? NATIVE_WORKER_URL : defaultUrl;
+        },
+        createShadow() {
+            return mode === 'compare' ? new NativeCoreShadow() : null;
+        },
+        notifyPrimaryReady(data) {
+            if (mode !== 'native') return false;
+            status.ready = true;
+            status.backend = String(data?.backend || 'wasm');
+            status.activeBackend = status.backend;
+            status.fallbackActive = false;
+            status.fallbackReason = '';
+            status.primaryResults = 0;
+            status.lastPrimaryResultType = '';
+            status.lastPrimaryDurationMs = 0;
+            status.lastPrimaryRoundTripMs = 0;
+            status.lastError = '';
+            publishRuntimeStatus();
+            window.MindCanvasTrace?.emit?.('nativeCore.primaryReady', {
+                mode,
+                backend: status.backend,
+                apiVersion: Number(data?.apiVersion || 0),
+                buildId: String(data?.buildId || '')
+            });
+            return true;
+        },
+        notifyPrimaryFallback(reason) {
+            if (mode !== 'native') return false;
+            const message = String(reason || 'native core fallback');
+            status.ready = false;
+            status.backend = '';
+            status.activeBackend = 'legacy-js';
+            status.fallbackActive = true;
+            status.fallbackCount++;
+            status.fallbackReason = message;
+            status.lastError = message;
+            publishRuntimeStatus();
+            window.MindCanvasTrace?.emit?.('nativeCore.primaryFallback', {
+                mode,
+                reason: message,
+                fallbackCount: status.fallbackCount
+            });
+            return true;
+        },
+        notifyPrimaryResultAccepted(data, roundTripMs = 0) {
+            if (mode !== 'native' || status.ready !== true || status.fallbackActive === true) return false;
+            status.primaryResults++;
+            status.lastPrimaryResultType = String(data?.type || '');
+            status.lastPrimaryDurationMs = Number(data?.profile?.durationMs || 0);
+            status.lastPrimaryRoundTripMs = Number(Math.max(0, Number(roundTripMs || 0)).toFixed(2));
+            return true;
+        },
+        notifyPrimaryDisposed(reason = 'native primary disposed') {
+            if (mode !== 'native') return false;
+            status.ready = false;
+            status.backend = '';
+            status.activeBackend = '';
+            status.fallbackActive = false;
+            status.fallbackReason = '';
+            status.primaryResults = 0;
+            status.lastPrimaryResultType = '';
+            status.lastPrimaryDurationMs = 0;
+            status.lastPrimaryRoundTripMs = 0;
+            status.lastError = '';
+            publishRuntimeStatus();
+            window.MindCanvasTrace?.emit?.('nativeCore.primaryDisposed', {
+                mode,
+                reason: String(reason || 'native primary disposed')
+            });
+            return true;
+        },
+        notifyFallbackReady() {
+            if (mode !== 'native' || status.fallbackActive !== true) return false;
+            status.activeBackend = 'legacy-js';
+            publishRuntimeStatus();
+            return true;
+        },
+        notifyFallbackUnavailable(reason) {
+            if (mode !== 'native' || status.fallbackActive !== true) return false;
+            const message = String(reason || 'legacy visibility fallback unavailable');
+            status.ready = false;
+            status.backend = '';
+            status.activeBackend = 'main-thread-js';
+            status.fallbackReason = `${status.fallbackReason || 'native core fallback'}; ${message}`;
+            status.lastError = message;
+            publishRuntimeStatus();
+            window.MindCanvasTrace?.emit?.('nativeCore.fallbackUnavailable', {
+                mode,
+                reason: message,
+                activeBackend: status.activeBackend
+            });
+            return true;
+        },
+        getStatus() {
+            return { ...status };
+        },
+        setMode(nextMode) {
+            const normalized = String(nextMode || '').toLowerCase();
+            if (!VALID_MODES.has(normalized)) return false;
+            try {
+                window.localStorage?.setItem(STORAGE_KEY, normalized);
+                return true;
+            } catch {
+                return false;
+            }
+        }
+    });
+})();

package/wwwroot/_content/MindExecution.Shared/js/mind-map-node-search-worker.js

@@ -15,6 +15,9 @@ const TOKEN_REGEX = /[\p{L}\p{M}\p{N}]{2,}/gu;
 function createState() {
     return {
         boardId: '',
+        boardEpoch: 0,
+        engineGeneration: 0,
+        boardRevision: 0,
         documents: new Map(),
         tokenIndex: new Map(),
         prefixIndex: new Map(),
@@ -28,6 +31,33 @@ function normalizeBoardId(boardId) {
     return String(boardId ?? '').trim();
 }
 
+function normalizeOwnerToken(value) {
+    const number = Number(value || 0);
+    return Number.isFinite(number) && number > 0 ? Math.floor(number) : 0;
+}
+
+function normalizeBoardRevision(value) {
+    const number = Number(value || 0);
+    return Number.isFinite(number) && number >= 0 ? Math.floor(number) : 0;
+}
+
+function ownerMatches(message, requireRevision = true) {
+    if (normalizeBoardId(message?.boardId) !== runtime.boardId ||
+        normalizeOwnerToken(message?.boardEpoch) !== runtime.boardEpoch ||
+        normalizeOwnerToken(message?.engineGeneration) !== runtime.engineGeneration) {
+        return false;
+    }
+    return requireRevision !== true || normalizeBoardRevision(message?.boardRevision) === runtime.boardRevision;
+}
+
+function acceptMutationRevision(message) {
+    if (!ownerMatches(message, false)) return false;
+    const revision = normalizeBoardRevision(message?.boardRevision);
+    if (revision < runtime.boardRevision) return false;
+    runtime.boardRevision = revision;
+    return true;
+}
+
 function limitText(value, maxLength) {
     const text = String(value ?? '');
     if (!text) {
@@ -212,9 +242,12 @@ function addPostingMatches(index, key, candidateScores, weight) {
     });
 }
 
-function clearState(boardId) {
+function clearState(boardId, boardEpoch = 0, engineGeneration = 0, boardRevision = 0) {
     runtime = createState();
     runtime.boardId = normalizeBoardId(boardId);
+    runtime.boardEpoch = normalizeOwnerToken(boardEpoch);
+    runtime.engineGeneration = normalizeOwnerToken(engineGeneration);
+    runtime.boardRevision = normalizeBoardRevision(boardRevision);
 }
 
 function normalizeNodeSnapshot(node) {
@@ -303,8 +336,8 @@ function upsertNode(node) {
     document.ngrams.forEach((ngram) => addPosting(runtime.ngramIndex, ngram, document.nodeId));
 }
 
-function rebuildBoard(boardId, nodes) {
-    clearState(boardId);
+function rebuildBoard(boardId, nodes, boardEpoch, engineGeneration, boardRevision) {
+    clearState(boardId, boardEpoch, engineGeneration, boardRevision);
     const sourceNodes = Array.isArray(nodes) ? nodes : [];
     for (let i = 0; i < sourceNodes.length; i++) {
         upsertNode(sourceNodes[i]);
@@ -391,13 +424,17 @@ function calculateViewportBoost(document, camera) {
 
 function handleSearchQuery(message) {
     const boardId = normalizeBoardId(message.boardId);
-    if (!boardId || boardId !== runtime.boardId) {
+    if (!boardId || !ownerMatches(message)) {
         self.postMessage({
             type: 'SEARCH_RESULT',
             boardId,
+            boardEpoch: normalizeOwnerToken(message.boardEpoch),
+            engineGeneration: normalizeOwnerToken(message.engineGeneration),
+            boardRevision: normalizeBoardRevision(message.boardRevision),
             seq: Number(message.seq || 0),
             query: String(message.query || ''),
-            hits: []
+            hits: [],
+            stale: true
         });
         return;
     }
@@ -411,6 +448,9 @@ function handleSearchQuery(message) {
         self.postMessage({
             type: 'SEARCH_RESULT',
             boardId,
+            boardEpoch: runtime.boardEpoch,
+            engineGeneration: runtime.engineGeneration,
+            boardRevision: runtime.boardRevision,
             seq: Number(message.seq || 0),
             query: String(message.query || ''),
             hits: []
@@ -494,6 +534,9 @@ function handleSearchQuery(message) {
     self.postMessage({
         type: 'SEARCH_RESULT',
         boardId,
+        boardEpoch: runtime.boardEpoch,
+        engineGeneration: runtime.engineGeneration,
+        boardRevision: runtime.boardRevision,
         seq: Number(message.seq || 0),
         query: String(message.query || ''),
         hits: ranked.slice(0, normalizedLimit),
@@ -513,23 +556,23 @@ self.onmessage = function (event) {
 
     switch (message.type) {
         case 'RESET_BOARD':
-            clearState(message.boardId);
+            clearState(message.boardId, message.boardEpoch, message.engineGeneration, message.boardRevision);
             break;
         case 'REBUILD_BOARD':
-            rebuildBoard(message.boardId, message.nodes);
+            rebuildBoard(message.boardId, message.nodes, message.boardEpoch, message.engineGeneration, message.boardRevision);
             break;
         case 'UPSERT_NODE':
-            if (normalizeBoardId(message.boardId) === runtime.boardId) {
+            if (acceptMutationRevision(message)) {
                 upsertNode(message.node);
             }
             break;
         case 'REMOVE_NODE':
-            if (normalizeBoardId(message.boardId) === runtime.boardId) {
+            if (acceptMutationRevision(message)) {
                 removeDocument(String(message.nodeId || '').trim());
             }
             break;
         case 'BATCH_SYNC':
-            if (normalizeBoardId(message.boardId) === runtime.boardId) {
+            if (ownerMatches(message)) {
                 const removedIds = Array.isArray(message.removedIds) ? message.removedIds : [];
                 for (let i = 0; i < removedIds.length; i++) {
                     removeDocument(String(removedIds[i] || '').trim());