@mindexec/cli 0.2.483 → 0.2.494

package/wwwroot/_content/MindExecution.Shared/js/canvas-chat-task-switch.js

@@ -0,0 +1,122 @@
+let dotnetRef = null;
+let mode = 'chat';
+let attached = false;
+let lastSignature = '';
+let lastObservedAt = 0;
+let selectionTimer = 0;
+let lastSelectionSignature = '';
+
+function textarea() {
+    return document.getElementById('global-input-textarea');
+}
+
+function isCanvasTextInputVisible() {
+    const input = textarea();
+    if (!input) return false;
+    const style = window.getComputedStyle(input);
+    return style.display !== 'none' && style.visibility !== 'hidden';
+}
+
+function isSendButton(target) {
+    const button = target?.closest?.('button');
+    if (!button) return false;
+    if (!button.closest('.global-ai-input-shell')) return false;
+    return !!button.querySelector('.fa-arrow-up');
+}
+
+function observe(prompt, event, source) {
+    const text = (prompt || '').trim();
+    if (!text || !dotnetRef) return;
+
+    const now = Date.now();
+    const signature = `${mode}|${source}|${text}`;
+    if (signature === lastSignature && now - lastObservedAt < 450) {
+        return;
+    }
+    lastSignature = signature;
+    lastObservedAt = now;
+
+    if (mode === 'task') {
+        event.preventDefault();
+        event.stopPropagation();
+        event.stopImmediatePropagation?.();
+
+        const input = textarea();
+        if (input) {
+            input.value = '';
+            input.dispatchEvent(new Event('input', { bubbles: true }));
+        }
+    }
+
+    const selectedNodeIds = readSelectedNodeIds();
+    void dotnetRef.invokeMethodAsync('OnGlobalCanvasAiSubmitObserved', text, mode, now, selectedNodeIds)
+        .catch(error => console.warn('[CanvasChatTaskSwitch] submit callback failed', error));
+}
+
+function onKeyDown(event) {
+    if (event.key !== 'Enter' || event.shiftKey || event.isComposing) return;
+    if (event.target !== textarea() || !isCanvasTextInputVisible()) return;
+    observe(event.target.value, event, 'enter');
+}
+
+function onClick(event) {
+    if (!isSendButton(event.target) || !isCanvasTextInputVisible()) return;
+    const input = textarea();
+    observe(input?.value, event, 'button');
+}
+
+function readSelectedNodeIds() {
+    try {
+        const ids = globalThis.mindMap?.getSelectedNodeIds?.();
+        if (!Array.isArray(ids)) return [];
+        return ids.filter(Boolean).map(value => String(value));
+    } catch {
+        return [];
+    }
+}
+
+function pushSelection(force = false) {
+    if (!dotnetRef) return;
+    const ids = readSelectedNodeIds();
+    const signature = ids.join('|');
+    if (!force && signature === lastSelectionSignature) return;
+    lastSelectionSignature = signature;
+    void dotnetRef.invokeMethodAsync('OnCanvasSelectionChanged', ids)
+        .catch(error => console.warn('[CanvasChatTaskSwitch] selection callback failed', error));
+}
+
+function startSelectionWatch() {
+    if (selectionTimer) return;
+    pushSelection(true);
+    selectionTimer = window.setInterval(() => pushSelection(false), 220);
+}
+
+function stopSelectionWatch() {
+    if (!selectionTimer) return;
+    window.clearInterval(selectionTimer);
+    selectionTimer = 0;
+}
+
+export function attach(ref) {
+    dotnetRef = ref;
+    if (attached) return;
+    attached = true;
+    document.addEventListener('keydown', onKeyDown, true);
+    document.addEventListener('click', onClick, true);
+    startSelectionWatch();
+}
+
+export function setMode(value) {
+    mode = value === 'task' ? 'task' : 'chat';
+}
+
+export function detach() {
+    if (!attached) return;
+    document.removeEventListener('keydown', onKeyDown, true);
+    document.removeEventListener('click', onClick, true);
+    stopSelectionWatch();
+    attached = false;
+    dotnetRef = null;
+    mode = 'chat';
+    lastSelectionSignature = '';
+}

package/wwwroot/_content/MindExecution.Shared/js/mind-map-css3d-manager.js

@@ -4707,7 +4707,11 @@
         large: Object.freeze({ tileMinWidth: 297, tileMinHeight: 189 })
     });
     const AUTOMATION_NODE_KIND_METADATA_KEY = 'AutomationNodeKind';
-    const AUTOMATION_NODE_ROLE_METADATA_KEY = 'AutomationNodeRole';
+    const AUTOMATION_NODE_ROLE_METADATA_KEY = 'AutomationNodeRole';
+    const AUTOMATION_PARENT_TASK_NODE_ID_METADATA_KEY = 'AutomationParentTaskNodeId';
+    const CANVAS_DIRECTOR_STATUS_METADATA_KEY = 'CanvasDirectorStatus';
+    const CANVAS_DIRECTOR_LAYOUT_MODE_METADATA_KEY = 'CanvasDirectorLayoutMode';
+    const CANVAS_DIRECTOR_LAYOUT_VERSION_METADATA_KEY = 'CanvasDirectorLayoutVersion';
     const AUTOMATION_NODE_LABEL_METADATA_KEY = 'AutomationNodeLabel';
     const AUTOMATION_NODE_DESCRIPTION_METADATA_KEY = 'AutomationNodeDescription';
     const AUTOMATION_INFERRED_KIND_METADATA_KEY = 'AutomationInferredKind';
@@ -5847,6 +5851,10 @@
             return;
         }
 
+        if (window.MindMapInteractions?.tryHandleReadableNodeWheelInZoomMode?.(module, event) === true) {
+            return;
+        }
+
         if (shouldEditingWheelZoom(module, event)) {
             window.MindMapInteractions?.routeWheelEventToZoom?.(module, event);
             return;
@@ -7642,7 +7650,8 @@
     function isBusinessAutomationInternalFailureText(value) {
         const text = String(value || '');
         return /ConceptVerificationException|CALL target not found in registry|Concept IR|ans_0/i.test(text)
-            || (/^Error:/i.test(text.trim()) && /Exception/i.test(text));
+            || (/^Error:/i.test(text.trim()) && /Exception/i.test(text))
+            || /Error recovered|deterministic-fallback|Recovered from\s+[A-Za-z0-9_.]+Exception/i.test(text);
     }
 
     function cleanBusinessAutomationTooltipOutput(value, maxLength = Number.POSITIVE_INFINITY) {
@@ -7654,7 +7663,7 @@
         }
 
         if (isBusinessAutomationInternalFailureText(original)) {
-            return 'AI execution failed internally. Run Node again to use the recovered fallback output.';
+            return 'AI execution was interrupted. Run this step again.';
         }
 
         const section = extractBusinessAutomationTooltipSection(raw, 'Findings:')
@@ -7717,6 +7726,74 @@
             : stripBusinessAutomationInstructionLabel(instruction);
     }
 
+    function getBusinessAutomationCanvasBody(nodeModel, fallbackContent) {
+        const status = getBusinessAutomationEffectiveRunStatus(nodeModel);
+        const intentKind = getBusinessAutomationIntentKind(nodeModel).toLowerCase();
+        const instruction = getBusinessAutomationInstructionText(nodeModel);
+        const isKorean = /[\u1100-\u11ff\u3130-\u318f\uac00-\ud7af]/.test(instruction || String(fallbackContent || ''));
+        const summary = cleanBusinessAutomationTooltipOutput(
+            getAutomationMetadataValue(nodeModel, AUTOMATION_LAST_RUN_SUMMARY_METADATA_KEY, '')
+        );
+        const handoff = cleanBusinessAutomationTooltipOutput(
+            getAutomationMetadataValue(nodeModel, AUTOMATION_LAST_OUTPUT_METADATA_KEY, '')
+        );
+        const error = compactBusinessAutomationTooltipText(
+            getAutomationMetadataValue(nodeModel, 'AutomationLastRunError', ''),
+            1400
+        );
+
+        if (intentKind === 'human-review' && status === 'waiting-user') {
+            return { text: String(fallbackContent || ''), placeholder: false, mode: 'review' };
+        }
+
+        const result = handoff || summary;
+        if (result && !['planning', 'running', 'pending'].includes(status)) {
+            return { text: result, placeholder: false, mode: 'result' };
+        }
+
+        if (status === 'failed' || status === 'blocked') {
+            return {
+                text: error || (isKorean ? '작업을 완료하지 못했습니다.' : 'This step could not be completed.'),
+                placeholder: true,
+                mode: 'error'
+            };
+        }
+
+        if (status === 'planning') {
+            return {
+                text: isKorean ? '작업 단계를 구성하고 있습니다…' : 'Building the work steps…',
+                placeholder: true,
+                mode: 'planning'
+            };
+        }
+
+        if (status === 'running') {
+            return {
+                text: isKorean ? '결과를 만드는 중입니다…' : 'Producing the result…',
+                placeholder: true,
+                mode: 'running'
+            };
+        }
+
+        if (status === 'pending') {
+            return {
+                text: isKorean ? '앞 단계의 결과를 기다리고 있습니다.' : 'Waiting for the previous result.',
+                placeholder: true,
+                mode: 'pending'
+            };
+        }
+
+        if (result) {
+            return { text: result, placeholder: false, mode: 'result' };
+        }
+
+        return {
+            text: isKorean ? '아직 결과가 없습니다.' : 'No result yet.',
+            placeholder: true,
+            mode: 'idle'
+        };
+    }
+
     function getBusinessAutomationForwardEdgeCount(nodeModel) {
         return readBusinessAutomationEdges(nodeModel)
             .filter(edge => normalizeBusinessAutomationHint(edge.targetPinId) !== 'context')
@@ -9012,14 +9089,43 @@
             .replace(/\s+/g, '-');
     }
 
+    function getBusinessAutomationDirectorStatus(nodeModel) {
+        return getAutomationMetadataValue(nodeModel, CANVAS_DIRECTOR_STATUS_METADATA_KEY, '')
+            .toLowerCase()
+            .replace(/\s+/g, '-');
+    }
+
+    function isBusinessAutomationGeneratedPendingNode(nodeModel) {
+        const role = getBusinessAutomationNodeRole(nodeModel);
+        const parentTaskNodeId = getAutomationMetadataValue(nodeModel, AUTOMATION_PARENT_TASK_NODE_ID_METADATA_KEY, '');
+        const runState = getBusinessAutomationRunState(nodeModel);
+        const runStatus = getBusinessAutomationRunStatus(nodeModel);
+        const directorStatus = getBusinessAutomationDirectorStatus(nodeModel);
+        return !!parentTaskNodeId
+            && (role === 'job' || role === 'report')
+            && (runState === 'idle' || runState === 'planned')
+            && runStatus === 'not-run'
+            && (directorStatus === 'todo' || directorStatus === 'planned');
+    }
+
     function getBusinessAutomationEffectiveRunStatus(nodeModel) {
-        return getBusinessAutomationRunState(nodeModel) === 'running'
-            ? 'running'
-            : getBusinessAutomationRunStatus(nodeModel);
+        const runState = getBusinessAutomationRunState(nodeModel);
+        if (runState === 'planning' || runState === 'running' || runState === 'waiting-user' || runState === 'blocked') {
+            return runState;
+        }
+        if (isBusinessAutomationGeneratedPendingNode(nodeModel)) {
+            return 'pending';
+        }
+        const runStatus = getBusinessAutomationRunStatus(nodeModel);
+        if (runState === 'completed' && runStatus === 'not-run') {
+            return 'completed';
+        }
+        return runStatus;
     }
 
     function hasBusinessAutomationResultOutput(nodeModel) {
-        if (getBusinessAutomationEffectiveRunStatus(nodeModel) === 'running') {
+        const status = getBusinessAutomationEffectiveRunStatus(nodeModel);
+        if (status === 'planning' || status === 'running' || status === 'pending') {
             return false;
         }
 
@@ -9048,15 +9154,24 @@
             case 'prepared': return 'Spec only';
             case 'needs-review': return 'Review needed';
             case 'error-recovered': return 'Error recovered';
+            case 'failed': return 'Failed';
+            case 'blocked': return 'Blocked';
+            case 'completed': return 'Completed';
             case 'not-run': return 'Not run';
             default: return 'Unknown';
         }
     }
 
     function getBusinessAutomationEffectiveRunStatusLabel(nodeModel) {
-        return getBusinessAutomationRunState(nodeModel) === 'running'
-            ? 'Running'
-            : getBusinessAutomationRunStatusLabel(nodeModel);
+        switch (getBusinessAutomationEffectiveRunStatus(nodeModel)) {
+            case 'planning': return 'Planning';
+            case 'running': return 'Running';
+            case 'pending': return 'Queued';
+            case 'waiting-user': return 'Waiting for you';
+            case 'blocked': return 'Blocked';
+            case 'completed': return 'Completed';
+            default: return getBusinessAutomationRunStatusLabel(nodeModel);
+        }
     }
 
     function createBusinessAutomationStatusBadge(nodeModel) {
@@ -9073,6 +9188,8 @@
         const partial = getAutomationMetadataValue(nodeModel, AUTOMATION_LAST_RUN_IS_PARTIAL_METADATA_KEY, 'false');
         const toolsUsed = getAutomationMetadataValue(nodeModel, AUTOMATION_LAST_RUN_TOOLS_USED_METADATA_KEY, '');
         const toolWarnings = getAutomationMetadataValue(nodeModel, AUTOMATION_LAST_RUN_TOOL_WARNINGS_METADATA_KEY, '');
+        const layoutMode = getAutomationMetadataValue(nodeModel, CANVAS_DIRECTOR_LAYOUT_MODE_METADATA_KEY, '');
+        const layoutVersion = getAutomationMetadataValue(nodeModel, CANVAS_DIRECTOR_LAYOUT_VERSION_METADATA_KEY, '');
         const badge = document.createElement('div');
         badge.className = `map-node-memo__automation-status is-${status}`;
         badge.dataset.automationRunState = runState;
@@ -9084,17 +9201,23 @@
             `Evidence URLs: ${evidenceCount}`,
             `Fallback: ${fallback}`,
             `Partial: ${partial}`,
+            layoutMode ? `Layout: ${layoutMode}${layoutVersion ? ` (${layoutVersion})` : ''}` : '',
             toolWarnings ? `Tool warning: ${toolWarnings}` : ''
         ].filter(Boolean).join('\n');
 
-        const dot = document.createElement('span');
-        dot.className = status === 'running'
-            ? 'map-node-memo__automation-status-spinner'
-            : 'map-node-memo__automation-status-dot';
+        const stateIcon = document.createElement('span');
+        if (status === 'planning' || status === 'running') {
+            stateIcon.className = 'map-node-memo__automation-status-spinner';
+        } else if (runState === 'completed' || status === 'completed' || status === 'answered') {
+            stateIcon.className = 'map-node-memo__automation-status-check';
+            stateIcon.textContent = '✓';
+        } else {
+            stateIcon.className = 'map-node-memo__automation-status-dot';
+        }
         const text = document.createElement('span');
         text.className = 'map-node-memo__automation-status-label';
         text.textContent = label;
-        badge.appendChild(dot);
+        badge.appendChild(stateIcon);
         badge.appendChild(text);
         return badge;
     }
@@ -9486,6 +9609,14 @@
             .forEach(element => element.remove());
         Array.from(container.querySelectorAll('.map-node-memo__automation-status'))
             .forEach(element => element.remove());
+        container.classList.remove(
+            'is-task-planning',
+            'is-task-running',
+            'is-task-pending',
+            'is-task-waiting',
+            'is-task-completed',
+            'is-task-blocked'
+        );
 
         if (!isBusinessAutomationNode(nodeModel)) {
             applyBusinessAutomationTooltip(container, null);
@@ -9532,6 +9663,12 @@
         const automationRunState = getBusinessAutomationRunState(nodeModel);
         const automationRunStatus = getBusinessAutomationEffectiveRunStatus(nodeModel);
         const automationIsRunning = automationRunStatus === 'running' || automationRunState === 'running';
+        container.classList.toggle('is-task-planning', automationRunStatus === 'planning');
+        container.classList.toggle('is-task-running', automationRunStatus === 'running');
+        container.classList.toggle('is-task-pending', automationRunStatus === 'pending');
+        container.classList.toggle('is-task-waiting', automationRunStatus === 'waiting-user' || automationRunStatus === 'needs-review');
+        container.classList.toggle('is-task-completed', automationRunState === 'completed');
+        container.classList.toggle('is-task-blocked', automationRunStatus === 'blocked');
         container.dataset.automationRunState = automationRunState;
         container.dataset.automationInstruction = getBusinessAutomationInstructionText(nodeModel);
         container.dataset.automationLastRunSummary = automationIsRunning ? '' : cleanBusinessAutomationTooltipOutput(
@@ -24111,7 +24248,14 @@
                 }
                 disableEditorAssist(bodyTextarea);
             }
-            renderMemoBodyView(bodyView, nodeModel, content);
+            const canvasBody = businessAutomation
+                ? getBusinessAutomationCanvasBody(nodeModel, content)
+                : { text: content, placeholder: false, mode: 'content' };
+            if (bodyView) {
+                bodyView.classList.toggle('is-automation-result-placeholder', !!canvasBody.placeholder);
+                bodyView.dataset.automationBodyMode = canvasBody.mode || '';
+            }
+            renderMemoBodyView(bodyView, nodeModel, canvasBody.text);
             setMemoEditingState(memoEl, memoEl.classList.contains('is-editing'));
 
             renderMemoIconButton(iconButton, iconKey);
@@ -24648,6 +24792,7 @@
         getTextOverlayScrollSyncSelectors: getTextOverlayScrollSyncSelectors,
         getReadonlyTextOverlayMode: getReadonlyTextOverlayMode,
         rememberEditingScrollState: rememberEditingScrollState,
+        syncEditingWheelScroll: syncEditingWheelScroll,
         refreshVisibleImageSources: refreshVisibleImageSources,
         restoreEditingScrollState: restoreEditingScrollState,
         setCssImageLoadingState: setCssImageLoadingState,

package/wwwroot/_content/MindExecution.Shared/js/mind-map-interactions.js

@@ -2122,7 +2122,7 @@ window.MindMapInteractions = (function () {
 
         const candidateIds = [];
         const seenIds = new Set();
-        const normalizedCellRadius = Math.max(0, Math.min(3, Math.round(Number(cellRadius || 1))));
+        const normalizedCellRadius = Math.max(0, Math.min(3, Math.round(Number(cellRadius ?? 1))));
         const cellSize = Math.max(1, Number(module.GRID_CELL_SIZE || 500));
         const currentCellX = Math.floor(Number(point.x || 0) / cellSize);
         const currentCellY = Math.floor(Number(point.y || 0) / cellSize);
@@ -2152,7 +2152,7 @@ window.MindMapInteractions = (function () {
 
     function getHitTestCandidateNodeIds(module, point, options = {}) {
         if (!module?.nodeObjectsById || !point) return null;
-        const normalizedCellRadius = Math.max(0, Math.min(3, Math.round(Number(options.cellRadius || 1))));
+        const normalizedCellRadius = Math.max(0, Math.min(3, Math.round(Number(options.cellRadius ?? 1))));
         module?.logicWorkerBridge?.primeHitTestCandidates?.(module, {
             point,
             cellRadius: normalizedCellRadius
@@ -3081,6 +3081,7 @@ window.MindMapInteractions = (function () {
 
     const DEFAULT_SCROLLABLE_SELECTORS = '.node-response, .note-content, .markdown-body, .prose, .note-textarea, .code-body, .code-content, .csv-table-scroll, .csv-table-scroll *, .pdf-content, .text-content, .file-content, .map-node-memo__body, .map-node-memo__body-view, pre, code';
     const DEFAULT_TEXT_CONTENT_SELECTORS = '.node-response, .code-body, .text-content, .markdown-body, .prose, .csv-table-scroll, .csv-table-cell';
+    const ZOOM_MODE_READABLE_WHEEL_CONTENT_TYPES = new Set(['text', 'markdown', 'note', 'memo', 'code']);
 
     function getScrollableSelectors() {
         return window.MindMapCss3DManager?.getTextInteractionScrollableSelectors?.()
@@ -6722,6 +6723,64 @@ window.MindMapInteractions = (function () {
         return Math.abs(appliedDelta) > 0.01 || Math.abs(remainingDelta) > CTRL_WHEEL_SCROLL_EDGE_EPSILON;
     }
 
+    function tryHandleReadableNodeWheelInZoomMode(module, e) {
+        if (!module || !e || typeof e.target?.closest !== 'function') {
+            return false;
+        }
+
+        const wheelAnalysis = getWheelEventAnalysis(module, e);
+        if (wheelAnalysis.isSyntheticTrackpadPinch === true ||
+            shouldZoomFromWheelEvent(module, e, wheelAnalysis) !== true) {
+            return false;
+        }
+
+        const nodeElement = e.target.closest('[data-node-id]');
+        const nodeId = String(nodeElement?.dataset?.nodeId || '').trim();
+        const entry = nodeId ? module.nodeObjectsById?.get?.(nodeId) : null;
+        const contentType = String(
+            entry?.model?.contentType ||
+            entry?.model?.ContentType ||
+            nodeElement?.dataset?.contentType ||
+            ''
+        ).trim().toLowerCase();
+        if (!nodeElement || !ZOOM_MODE_READABLE_WHEEL_CONTENT_TYPES.has(contentType)) {
+            return false;
+        }
+
+        const selectors = getScrollableSelectors();
+        let scrollableEl = e.target.closest(selectors);
+        if (!scrollableEl || !nodeElement.contains(scrollableEl)) {
+            scrollableEl = nodeElement.querySelector(selectors);
+        }
+        if (!scrollableEl) {
+            return false;
+        }
+
+        const maxScrollTop = Math.max(0, Number(scrollableEl.scrollHeight || 0) - Number(scrollableEl.clientHeight || 0));
+        if (maxScrollTop <= CTRL_WHEEL_SCROLL_EDGE_EPSILON) {
+            return false;
+        }
+
+        const deltaY = normalizeWheelDeltaY(e);
+        if (!Number.isFinite(deltaY) || Math.abs(deltaY) <= 0.01) {
+            return false;
+        }
+
+        const currentScrollTop = Math.max(0, Number(scrollableEl.scrollTop || 0));
+        const nextScrollTop = Math.min(maxScrollTop, Math.max(0, currentScrollTop + deltaY));
+        if (Math.abs(nextScrollTop - currentScrollTop) > 0.01) {
+            scrollableEl.scrollTop = nextScrollTop;
+            window.MindMapTextOverlayV2?.syncReadonlySourceScroll?.(module, scrollableEl);
+            window.MindMapCss3DManager?.syncEditingWheelScroll?.(module, scrollableEl);
+        }
+
+        // Readable text owns the wheel while the pointer is over its scrollable body,
+        // including at the top/bottom edge. Do not turn an edge-scroll into camera zoom.
+        e.preventDefault();
+        e.stopPropagation();
+        return true;
+    }
+
     function tryHandleScrollableWheelEvent(module, e, options = {}) {
         const { fallbackToTrackpadPan = false } = options;
         const wheelTarget = e?.target;
@@ -6831,6 +6890,12 @@ window.MindMapInteractions = (function () {
             wheelAnalysis.isSyntheticTrackpadPinch === true ||
             shouldZoomFromWheelEvent(module, e, wheelAnalysis);
 
+        if (shouldRouteWheelToZoom &&
+            wheelAnalysis.isSyntheticTrackpadPinch !== true &&
+            tryHandleReadableNodeWheelInZoomMode(module, e)) {
+            return;
+        }
+
         if (shouldRouteWheelToZoom) {
             if (WHEEL_DEBUG) {
                 if (!module._wheelDebug) {
@@ -7870,6 +7935,7 @@ window.MindMapInteractions = (function () {
         routeCtrlWheelEventToVerticalScroll: routeCtrlWheelEventToVerticalScroll,
         applyCtrlWheelVerticalScrollDelta: applyCtrlWheelVerticalScrollDelta,
         applyCtrlWheelToScrollableElement: applyCtrlWheelToScrollableElement,
+        tryHandleReadableNodeWheelInZoomMode: tryHandleReadableNodeWheelInZoomMode,
         shouldZoomFromWheelEvent: shouldZoomFromWheelEvent,
         shouldTreatWheelAsZoom: shouldTreatWheelAsZoom,
         isTrackpadPinchGesture: isTrackpadPinchGesture,

package/wwwroot/_content/MindExecution.Shared/js/mind-map-lod-plan-worker.js

@@ -3,6 +3,9 @@
 function createState() {
     return {
         boardId: '',
+        boardEpoch: 0,
+        engineGeneration: 0,
+        boardRevision: 0,
         nodes: new Map(),
         totalTextLikeCount: 0
     };
@@ -31,9 +34,39 @@ function normalizeNode(node) {
     };
 }
 
-function clearState(boardId) {
+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 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 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 upsertNode(node) {
@@ -71,8 +104,8 @@ function removeNode(nodeId) {
     runtime.nodes.delete(normalizedId);
 }
 
-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]);
@@ -81,7 +114,7 @@ function rebuildBoard(boardId, nodes) {
 
 function handleLodPlanQuery(message) {
     const boardId = normalizeBoardId(message.boardId);
-    if (!boardId || boardId !== runtime.boardId) {
+    if (!boardId || !ownerMatches(message)) {
         return;
     }
 
@@ -110,6 +143,9 @@ function handleLodPlanQuery(message) {
     self.postMessage({
         type: 'LOD_PLAN_RESULT',
         boardId,
+        boardEpoch: runtime.boardEpoch,
+        engineGeneration: runtime.engineGeneration,
+        boardRevision: runtime.boardRevision,
         seq: Number(message.seq || 0),
         key: String(message.key || '').trim(),
         visibilityVersion: Number(message.visibilityVersion || 0),
@@ -131,18 +167,18 @@ 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)) {
                 removeNode(message.nodeId);
             }
             break;