@mindexec/cli 0.2.493 → 0.2.495

package/wwwroot/_content/MindExecution.Shared/js/mind-map-native-render-mirror.js

@@ -0,0 +1,586 @@
+(function () {
+    'use strict';
+
+    const BUILD_ID = '20260830-actual-board-mirror-v002';
+    const EPOCH_STORAGE_KEY = 'mindexec.native-render-mirror.epoch.v1';
+    const MAX_NODES = 250000;
+    const MAX_EDGES = 500000;
+    const MAX_EDGE_POINTS = 2000000;
+    const RETRY_DELAY_MS = 120;
+    const MAX_SETTLE_RETRIES = 50;
+    const DEFAULT_NODE_COLOR = 0x4d75ffff;
+    const DEFAULT_EDGE_COLOR = 0x91a4c7ff;
+    const CONTENT_COLORS = Object.freeze({
+        text: 0x4d75ffff,
+        note: 0x4d75ffff,
+        memo: 0xf5b942ff,
+        markdown: 0x5378d9ff,
+        code: 0x3f8f73ff,
+        image: 0x9b6bd3ff,
+        video: 0xd46b78ff,
+        youtube: 0xe05b62ff,
+        agent: 0x3b82f6ff,
+        aitask: 0x3b82f6ff
+    });
+
+    let inMemoryEpochState = { engineGeneration: 0, boardEpoch: 0 };
+
+    function readEpochState() {
+        try {
+            const raw = window.sessionStorage?.getItem?.(EPOCH_STORAGE_KEY);
+            if (raw) {
+                const parsed = JSON.parse(raw);
+                const engineGeneration = Number(parsed?.engineGeneration);
+                const boardEpoch = Number(parsed?.boardEpoch);
+                if (Number.isSafeInteger(engineGeneration) && engineGeneration > 0 &&
+                    Number.isSafeInteger(boardEpoch) && boardEpoch > 0) {
+                    return { engineGeneration, boardEpoch };
+                }
+            }
+        } catch {
+        }
+        return { ...inMemoryEpochState };
+    }
+
+    function writeEpochState(state) {
+        inMemoryEpochState = { ...state };
+        try {
+            window.sessionStorage?.setItem?.(EPOCH_STORAGE_KEY, JSON.stringify(state));
+        } catch {
+        }
+    }
+
+    function allocateBoardEpoch(engineGeneration) {
+        const generation = Math.floor(Number(engineGeneration || 0));
+        if (!Number.isSafeInteger(generation) || generation <= 0) {
+            throw new Error('native-render-invalid-engine-generation');
+        }
+        const previous = readEpochState();
+        const boardEpoch = previous.engineGeneration === generation
+            ? previous.boardEpoch + 1
+            : 1;
+        if (!Number.isSafeInteger(boardEpoch) || boardEpoch <= 0) {
+            throw new Error('native-render-board-epoch-exhausted');
+        }
+        writeEpochState({ engineGeneration: generation, boardEpoch });
+        return boardEpoch;
+    }
+
+    function normalizeId(value) {
+        return String(value ?? '').trim();
+    }
+
+    function finite(value, fallback = 0) {
+        const number = Number(value);
+        return Number.isFinite(number) ? number : fallback;
+    }
+
+    function positive(value, fallback = 1) {
+        const number = Number(value);
+        return Number.isFinite(number) && number > 0 ? number : fallback;
+    }
+
+    function readMetadata(model, key) {
+        const metadata = model?.metadata ?? model?.Metadata ?? null;
+        if (!metadata) return undefined;
+        if (metadata instanceof Map) return metadata.get(key);
+        if (Object.prototype.hasOwnProperty.call(metadata, key)) return metadata[key];
+        const expected = String(key).toLowerCase();
+        const actualKey = Object.keys(metadata).find((entry) => String(entry).toLowerCase() === expected);
+        return actualKey ? metadata[actualKey] : undefined;
+    }
+
+    function parseCssColor(value, fallback) {
+        const text = String(value ?? '').trim();
+        const short = /^#([0-9a-f]{3})$/i.exec(text);
+        const long = /^#([0-9a-f]{6})$/i.exec(text);
+        let red;
+        let green;
+        let blue;
+        if (short) {
+            red = Number.parseInt(short[1][0] + short[1][0], 16);
+            green = Number.parseInt(short[1][1] + short[1][1], 16);
+            blue = Number.parseInt(short[1][2] + short[1][2], 16);
+        } else if (long) {
+            red = Number.parseInt(long[1].slice(0, 2), 16);
+            green = Number.parseInt(long[1].slice(2, 4), 16);
+            blue = Number.parseInt(long[1].slice(4, 6), 16);
+        } else {
+            return fallback;
+        }
+        return (((red << 24) | (green << 16) | (blue << 8) | 0xff) >>> 0);
+    }
+
+    function resolveNodeColor(entry) {
+        const model = entry?.model || null;
+        const contentType = String(model?.contentType ?? model?.ContentType ?? '').trim().toLowerCase();
+        const memoColor = readMetadata(model, 'memoColor');
+        return parseCssColor(memoColor, CONTENT_COLORS[contentType] ?? DEFAULT_NODE_COLOR);
+    }
+
+    function getNodeId(entry, fallbackId) {
+        return normalizeId(
+            entry?.model?.id ??
+            entry?.model?.Id ??
+            entry?.glObject?.userData?.nodeId ??
+            entry?.cssObject?.userData?.nodeId ??
+            fallbackId
+        );
+    }
+
+    function copyNodeGeometry(module) {
+        const entries = [];
+        module?.nodeObjectsById?.forEach?.((entry, fallbackId) => {
+            const id = getNodeId(entry, fallbackId);
+            const bounds = window.MindMapNodeBounds?.getNodeWorldBounds?.(entry, { allowDomLookup: false });
+            if (!id || !bounds) return;
+            const node = {
+                id,
+                x: finite(bounds.x, Number.NaN),
+                y: finite(bounds.y, Number.NaN),
+                z: finite(bounds.z, 0),
+                width: positive(bounds.width, Number.NaN),
+                height: positive(bounds.height, Number.NaN),
+                fillRgba: resolveNodeColor(entry)
+            };
+            if (!Number.isFinite(node.x) || !Number.isFinite(node.y) ||
+                !Number.isFinite(node.width) || !Number.isFinite(node.height)) {
+                throw new Error(`native-render-invalid-node-bounds:${id}`);
+            }
+            entries.push(node);
+        });
+        entries.sort((left, right) => left.id.localeCompare(right.id));
+        if (entries.length > MAX_NODES) throw new Error('native-render-node-budget-exceeded');
+        return entries;
+    }
+
+    function readAutomationEdges(model) {
+        const raw = readMetadata(model, 'AutomationOutgoingEdges');
+        if (!raw) return [];
+        if (Array.isArray(raw)) return raw;
+        if (typeof raw === 'object') return [raw];
+        try {
+            const parsed = JSON.parse(String(raw));
+            return Array.isArray(parsed) ? parsed : [];
+        } catch {
+            return [];
+        }
+    }
+
+    function buildEndpointRoute(source, target) {
+        const start = { x: source.x + source.width, y: source.y - source.height * 0.5 };
+        const end = { x: target.x, y: target.y - target.height * 0.5 };
+        if (end.x >= start.x + 64) {
+            const middleX = (start.x + end.x) * 0.5;
+            return [start, { x: middleX, y: start.y }, { x: middleX, y: end.y }, end];
+        }
+        const detourY = Math.max(source.y, target.y) + 64;
+        return [
+            start,
+            { x: start.x + 40, y: start.y },
+            { x: start.x + 40, y: detourY },
+            { x: end.x - 40, y: detourY },
+            { x: end.x - 40, y: end.y },
+            end
+        ];
+    }
+
+    function copyEdgeGeometry(module, nodesById) {
+        const edges = [];
+        const seen = new Set();
+        module?.nodeObjectsById?.forEach?.((entry, fallbackId) => {
+            const sourceId = getNodeId(entry, fallbackId);
+            const source = nodesById.get(sourceId);
+            if (!source) return;
+            for (const edge of readAutomationEdges(entry?.model)) {
+                const targetId = normalizeId(edge?.targetNodeId ?? edge?.TargetNodeId);
+                const target = nodesById.get(targetId);
+                if (!target || targetId === sourceId) continue;
+                const edgeId = normalizeId(edge?.id ?? edge?.Id) || `${sourceId}>${targetId}`;
+                if (seen.has(edgeId)) continue;
+                seen.add(edgeId);
+                edges.push({
+                    id: edgeId,
+                    sourceId,
+                    targetId,
+                    z: Math.max(source.z, target.z) + 1,
+                    width: 2,
+                    colorRgba: DEFAULT_EDGE_COLOR,
+                    points: buildEndpointRoute(source, target)
+                });
+            }
+        });
+        edges.sort((left, right) => left.id.localeCompare(right.id));
+        if (edges.length > MAX_EDGES) throw new Error('native-render-edge-budget-exceeded');
+        const pointCount = edges.reduce((total, edge) => total + edge.points.length, 0);
+        if (pointCount > MAX_EDGE_POINTS) throw new Error('native-render-edge-point-budget-exceeded');
+        return edges;
+    }
+
+    function copyCamera(module, explicitCamera = null) {
+        const camera = explicitCamera || module?.camera || null;
+        const rendererCanvas = module?.renderer?.domElement || null;
+        const logicalWidth = positive(module?._lastViewportWidth || module?.container?.clientWidth, 1);
+        const logicalHeight = positive(module?._lastViewportHeight || module?.container?.clientHeight, 1);
+        const dpr = positive(module?._lastViewportDpr || window.devicePixelRatio, 1);
+        const viewportW = Math.max(1, Math.round(positive(rendererCanvas?.width, logicalWidth * dpr)));
+        const viewportH = Math.max(1, Math.round(positive(rendererCanvas?.height, logicalHeight * dpr)));
+        return {
+            x: finite(camera?.position?.x ?? camera?.x),
+            y: finite(camera?.position?.y ?? camera?.y),
+            z: positive(camera?.position?.z ?? camera?.z, 1200),
+            near: positive(camera?.near, 0.1),
+            far: positive(camera?.far, 10000000),
+            fov: positive(camera?.fov, 45),
+            viewportW,
+            viewportH,
+            zoom: positive(camera?.zoom, 1)
+        };
+    }
+
+    function isSceneSettled(module, boardId) {
+        const state = window.mindMap?.getActiveBoardRuntimeState?.() || null;
+        if (!state || normalizeId(state.activeBoardId) !== normalizeId(boardId)) return false;
+        return state.boardLoadComplete === true &&
+            state.isLoading !== true &&
+            module?.isPanning !== true &&
+            module?._panSmoothingActive !== true &&
+            module?.isZooming !== true &&
+            module?.isDraggingNode !== true &&
+            module?.isDraggingMultipleNodes !== true &&
+            module?.isWindowResizing !== true &&
+            module?.isResizing !== true &&
+            module?._businessAutomationEdgesDirty !== true &&
+            module?._businessAutomationEdgesDeferredForMotion !== true &&
+            module?._businessAutomationConnectionDraftActive !== true;
+    }
+
+    function emit(name, detail) {
+        window.MindCanvasTrace?.emit?.(name, detail);
+    }
+
+    function publishStatus(status) {
+        window.__mindExecutionNativeRenderStatus = Object.freeze({
+            buildId: BUILD_ID,
+            ...(status || {})
+        });
+        const root = document?.documentElement;
+        if (root) {
+            root.dataset.mindexecNativeRenderMode = String(status?.mode || 'off');
+            root.dataset.mindexecNativeRenderReady = status?.ready === true ? 'true' : 'false';
+            root.dataset.mindexecNativeRenderBackend = String(status?.backend || '');
+        }
+    }
+
+    class NativeRenderMirrorController {
+        constructor(module) {
+            this.module = module || null;
+            this.api = window.mindExecDesktop?.nativeRender || window.mindExecDesktop?.nativeRenderer || null;
+            this.boardId = '';
+            this.engineGeneration = 0;
+            this.boardEpoch = 0;
+            this.boardRevision = 0;
+            this.requestSequence = 0;
+            this.nodeHandles = new Map();
+            this.edgeHandles = new Map();
+            this.nextNodeHandle = 1;
+            this.nextEdgeHandle = 1;
+            this.attached = false;
+            this.nativeReady = false;
+            this.snapshotBlocked = false;
+            this.disposed = false;
+            this.snapshotInFlight = false;
+            this.snapshotPending = false;
+            this.cameraPending = false;
+            this.cameraInFlight = false;
+            this.retryCount = 0;
+            this.retryTimer = null;
+            this.cameraFrame = 0;
+            this.unsubscribeStatus = null;
+            this._initialize();
+        }
+
+        async _initialize() {
+            if (!this.api?.getStatus) {
+                publishStatus({ mode: 'off', ready: false, backend: '', lastError: '' });
+                return;
+            }
+            try {
+                this.unsubscribeStatus = this.api.onStatus?.((status) => this._adoptStatus(status)) || null;
+                this._adoptStatus(await this.api.getStatus());
+            } catch (error) {
+                this._fallback(error, { blockSnapshot: true });
+            }
+        }
+
+        _adoptStatus(status) {
+            if (this.disposed) return;
+            const mode = String(status?.mode || 'off');
+            const generation = Math.max(0, Math.floor(Number(status?.engineGeneration || 0)));
+            const ready = mode === 'mirror' && status?.ready === true && generation > 0;
+            const wasReady = this.nativeReady;
+            const generationChanged = ready && this.engineGeneration !== generation;
+            this.nativeReady = ready;
+            publishStatus({
+                ...status,
+                mode,
+                ready,
+                backend: String(status?.backend || ''),
+                lastError: String(status?.lastError || '')
+            });
+            if (!ready) {
+                this.attached = false;
+                this.snapshotBlocked = true;
+                return;
+            }
+            if (generationChanged) {
+                this.engineGeneration = generation;
+                this.boardEpoch = 0;
+                this.boardRevision = 0;
+                this.requestSequence = 0;
+                this.attached = false;
+                this.nodeHandles.clear();
+                this.edgeHandles.clear();
+                this.nextNodeHandle = 1;
+                this.nextEdgeHandle = 1;
+            }
+            if (!this.boardId) {
+                this.boardId = normalizeId(this.module?.activeBoardId || window.mindMap?.activeBoardId);
+            }
+            if (this.boardId && !this.boardEpoch) {
+                this.boardEpoch = allocateBoardEpoch(generation);
+            }
+            if (this.boardId && (generationChanged || !wasReady)) {
+                this.snapshotBlocked = false;
+                this._scheduleSnapshot('native-ready');
+            }
+        }
+
+        resetBoard(boardId, reason = 'reset-board') {
+            const nextBoardId = normalizeId(boardId);
+            if (this.attached) void this._sendDetach(reason);
+            this.boardId = nextBoardId;
+            this.boardEpoch = nextBoardId && this.engineGeneration
+                ? allocateBoardEpoch(this.engineGeneration)
+                : 0;
+            this.boardRevision = 0;
+            this.requestSequence = 0;
+            this.attached = false;
+            this.snapshotBlocked = false;
+            this.nodeHandles.clear();
+            this.edgeHandles.clear();
+            this.nextNodeHandle = 1;
+            this.nextEdgeHandle = 1;
+            this.retryCount = 0;
+            if (nextBoardId) this._scheduleSnapshot(reason);
+        }
+
+        geometryChanged(module = this.module, boardId = this.boardId, reason = 'geometry-changed') {
+            if (module) this.module = module;
+            const normalizedBoardId = normalizeId(boardId);
+            if (!normalizedBoardId) return;
+            if (this.boardId !== normalizedBoardId) this.resetBoard(normalizedBoardId, reason);
+            this.snapshotBlocked = false;
+            this._scheduleSnapshot(reason);
+        }
+
+        cameraChanged(module = this.module, camera = null) {
+            if (module) this.module = module;
+            if (!this.attached || !this.engineGeneration || !this.boardId) {
+                if (this.snapshotBlocked) return;
+                this._scheduleSnapshot('camera-before-snapshot');
+                return;
+            }
+            this.latestCamera = copyCamera(this.module, camera);
+            this.cameraPending = true;
+            if (this.cameraFrame) return;
+            const schedule = typeof requestAnimationFrame === 'function'
+                ? requestAnimationFrame
+                : (callback) => setTimeout(callback, 16);
+            this.cameraFrame = schedule(() => {
+                this.cameraFrame = 0;
+                void this._flushCamera();
+            });
+        }
+
+        _scheduleSnapshot(reason) {
+            if (this.disposed || !this.api?.sendSnapshot) return;
+            this.snapshotPending = true;
+            this.pendingReason = String(reason || 'snapshot');
+            if (!this.nativeReady || this.snapshotBlocked) return;
+            if (this.snapshotInFlight || this.retryTimer) return;
+            this.retryTimer = setTimeout(() => {
+                this.retryTimer = null;
+                void this._flushSnapshot();
+            }, 0);
+        }
+
+        _owner(revision, sequence) {
+            return {
+                boardId: this.boardId,
+                engineGeneration: this.engineGeneration,
+                boardEpoch: this.boardEpoch,
+                boardRevision: revision,
+                requestSequence: sequence
+            };
+        }
+
+        _assignHandle(map, id, kind) {
+            let handle = map.get(id);
+            if (handle) return handle;
+            if (kind === 'node') {
+                handle = this.nextNodeHandle++;
+            } else {
+                handle = this.nextEdgeHandle++;
+            }
+            if (!Number.isSafeInteger(handle) || handle <= 0 || handle > 0xffffffff) {
+                throw new Error(`native-render-${kind}-handle-exhausted`);
+            }
+            map.set(id, handle);
+            return handle;
+        }
+
+        _copySnapshot() {
+            const copiedNodes = copyNodeGeometry(this.module);
+            const nodesById = new Map(copiedNodes.map((node) => [node.id, node]));
+            const copiedEdges = copyEdgeGeometry(this.module, nodesById);
+            const nodes = copiedNodes.map((node) => ({
+                handle: this._assignHandle(this.nodeHandles, node.id, 'node'),
+                x: node.x,
+                y: node.y,
+                z: node.z,
+                width: node.width,
+                height: node.height,
+                fillRgba: node.fillRgba
+            }));
+            const edges = copiedEdges.map((edge) => ({
+                handle: this._assignHandle(this.edgeHandles, edge.id, 'edge'),
+                sourceHandle: this._assignHandle(this.nodeHandles, edge.sourceId, 'node'),
+                targetHandle: this._assignHandle(this.nodeHandles, edge.targetId, 'node'),
+                z: edge.z,
+                width: edge.width,
+                colorRgba: edge.colorRgba,
+                points: edge.points.map((point) => ({ x: point.x, y: point.y }))
+            }));
+            return { nodes, edges, camera: copyCamera(this.module) };
+        }
+
+        async _flushSnapshot() {
+            if (this.disposed || this.snapshotInFlight || !this.snapshotPending) return;
+            if (!this.engineGeneration || !this.boardId) return;
+            if (!isSceneSettled(this.module, this.boardId)) {
+                if (++this.retryCount <= MAX_SETTLE_RETRIES) {
+                    this.retryTimer = setTimeout(() => {
+                        this.retryTimer = null;
+                        void this._flushSnapshot();
+                    }, RETRY_DELAY_MS);
+                } else {
+                    this.snapshotPending = false;
+                    emit('native.render.snapshot.rejected', { boardId: this.boardId, reason: 'scene_not_settled' });
+                }
+                return;
+            }
+
+            this.retryCount = 0;
+            this.snapshotPending = false;
+            this.snapshotInFlight = true;
+            try {
+                const copied = this._copySnapshot();
+                const revision = ++this.boardRevision;
+                const sequence = ++this.requestSequence;
+                const owner = this._owner(revision, sequence);
+                const result = await this.api.sendSnapshot({ owner, ...copied, edgeRoute: 'endpoint-v1' });
+                if (result?.accepted !== true) {
+                    throw new Error(result?.reason || result?.lastError || result?.lastRejected?.reason || 'native-render-snapshot-not-accepted');
+                }
+                this.attached = true;
+                this.snapshotBlocked = false;
+                publishStatus({ ...result, mode: 'mirror', ready: true });
+                emit('native.render.snapshot.accepted', {
+                    boardId: owner.boardId,
+                    engineGeneration: owner.engineGeneration,
+                    boardEpoch: owner.boardEpoch,
+                    boardRevision: owner.boardRevision,
+                    requestSequence: owner.requestSequence,
+                    nodes: copied.nodes.length,
+                    edges: copied.edges.length,
+                    route: 'endpoint-v1'
+                });
+            } catch (error) {
+                this._fallback(error, { blockSnapshot: !this.snapshotPending });
+            } finally {
+                this.snapshotInFlight = false;
+                if (this.snapshotPending) this._scheduleSnapshot('coalesced-geometry');
+                else if (this.cameraPending) void this._flushCamera();
+            }
+        }
+
+        async _flushCamera() {
+            if (!this.cameraPending || this.cameraInFlight || this.snapshotInFlight || !this.attached || this.disposed) return;
+            this.cameraPending = false;
+            this.cameraInFlight = true;
+            const owner = this._owner(this.boardRevision, ++this.requestSequence);
+            try {
+                const result = await this.api.sendCamera({ owner, camera: this.latestCamera || copyCamera(this.module) });
+                if (result?.accepted !== true) {
+                    throw new Error(result?.reason || result?.lastError || result?.lastRejected?.reason || 'native-render-camera-not-accepted');
+                }
+                publishStatus({ ...result, mode: 'mirror', ready: true });
+            } catch (error) {
+                this._fallback(error, { blockSnapshot: !this.snapshotPending });
+            } finally {
+                this.cameraInFlight = false;
+                if (this.cameraPending && !this.disposed) {
+                    void this._flushCamera();
+                }
+            }
+        }
+
+        async _sendDetach(reason) {
+            if (!this.api?.detach || !this.engineGeneration || !this.boardId || !this.boardEpoch) return;
+            const owner = this._owner(Math.max(1, this.boardRevision), ++this.requestSequence);
+            try {
+                await this.api.detach(owner);
+                emit('native.render.shutdown', { boardId: owner.boardId, reason: String(reason || 'detach') });
+            } catch {
+            }
+        }
+
+        _fallback(error, options = {}) {
+            const lastError = String(error?.message || error || 'native-render-failed').slice(0, 512);
+            this.attached = false;
+            if (options.blockSnapshot === true) {
+                this.snapshotBlocked = true;
+            }
+            publishStatus({ mode: 'mirror', ready: false, backend: '', lastError });
+            emit('native.render.fallback', { boardId: this.boardId, reason: lastError });
+        }
+
+        dispose() {
+            if (this.disposed) return;
+            this.disposed = true;
+            if (this.retryTimer) clearTimeout(this.retryTimer);
+            this.retryTimer = null;
+            this.unsubscribeStatus?.();
+            this.unsubscribeStatus = null;
+            if (this.attached) void this._sendDetach('logic-worker-dispose');
+            this.attached = false;
+        }
+    }
+
+    window.MindMapNativeRenderMirror = Object.assign(window.MindMapNativeRenderMirror || {}, {
+        BUILD_ID,
+        createController(module) {
+            return new NativeRenderMirrorController(module);
+        },
+        testing: {
+            copyNodeGeometry,
+            copyEdgeGeometry,
+            copyCamera,
+            buildEndpointRoute,
+            isSceneSettled,
+            parseCssColor,
+            allocateBoardEpoch
+        }
+    });
+})();

package/wwwroot/_content/MindExecution.Shared/native-core/native-core-manifest.json

@@ -3,11 +3,11 @@
   "abiVersion": 1,
   "engineVersion": "0.1.0",
   "status": "experimental-native-primary",
-  "generatedUtc": "2026-08-30T07:12:19.1507322Z",
+  "generatedUtc": "2026-08-30T10:41:24.8262997Z",
   "sources": [
     {
       "name": "engine/CMakeLists.txt",
-      "sha256": "80dafcd233aae1a5611af3930e22fc8e392a7cb9b13da50805c09c985c2f7a37"
+      "sha256": "a6c86dc750403e8251c96719721cd1cefb148218318069357ec9a018d3bee43d"
     },
     {
       "name": "engine/core/include/mindexec/core_api.h",