@mindexec/cli 0.2.483 → 0.2.494

package/wwwroot/_content/MindExecution.Shared/native-core/mindexec-native-core-adapter.js

@@ -0,0 +1,566 @@
+(function (global) {
+    'use strict';
+
+    const API_VERSION = 1;
+    const GEOMETRY_STRIDE = 9;
+    const STATUS_STALE = 0;
+    const STATUS_OK = 1;
+    const NODE_TEXT_LIKE = 1 << 0;
+    const NODE_IMAGE = 1 << 1;
+    const VISIBILITY_PANNING = 1 << 0;
+    const VISIBILITY_ZOOMING = 1 << 1;
+    const VISIBILITY_WINDOW_RESIZING = 1 << 2;
+    const VISIBILITY_NODE_RESIZING = 1 << 3;
+    const VISIBILITY_FULL_RES = 1 << 4;
+    const VISIBILITY_CTRL_WHEEL_SCROLLING = 1 << 5;
+
+    const ARRAY = Object.freeze({
+        visible: 1,
+        entered: 2,
+        exited: 3,
+        priority: 4,
+        hit: 5,
+        selection: 6
+    });
+    const INTEGER = Object.freeze({
+        visibleCount: 1,
+        visibilityChanged: 2,
+        nodeCount: 3,
+        reconcilePending: 4,
+        omitVisibleIds: 5,
+        priorityChanged: 6,
+        useCoarseVisibility: 7,
+        gridSpanX: 8,
+        gridSpanY: 9,
+        directGridLookups: 10,
+        usedPopulatedCellScan: 11,
+        incrementalPanMode: 12,
+        incrementalPanBandCount: 13,
+        incrementalPanCellLookups: 14,
+        candidateCount: 15,
+        previousVisibleCount: 16,
+        cellLookups: 17,
+        cellRadius: 18,
+        spatialGridCellCount: 19
+    });
+    const NUMBER = Object.freeze({
+        durationMs: 1,
+        cameraZ: 2,
+        marginWorld: 3,
+        viewLeft: 4,
+        viewRight: 5,
+        viewBottom: 6,
+        viewTop: 7
+    });
+
+    function normalizeBoardId(value) {
+        return String(value ?? '').trim();
+    }
+
+    function normalizeToken(value) {
+        const number = Number(value || 0);
+        return Number.isFinite(number) && number > 0
+            ? Math.floor(number) >>> 0
+            : 0;
+    }
+
+    function normalizeRevision(value) {
+        const number = Number(value || 0);
+        return Number.isFinite(number) && number >= 0
+            ? Math.floor(number) >>> 0
+            : 0;
+    }
+
+    function normalizeNode(node) {
+        if (!node || typeof node !== 'object') return null;
+        const id = String(node.id || '').trim();
+        if (!id) return null;
+        const minX = Number(node.minX ?? 0);
+        const maxX = Number(node.maxX ?? minX);
+        const minY = Number(node.minY ?? 0);
+        const maxY = Number(node.maxY ?? minY);
+        const contentType = String(node.contentType || '').trim().toLowerCase();
+        let flags = 0;
+        if (node.textLike === true) flags |= NODE_TEXT_LIKE;
+        if (contentType === 'image') flags |= NODE_IMAGE;
+        const geometry = [
+            Number(node.x ?? minX),
+            Number(node.y ?? maxY),
+            Number(node.z ?? 0),
+            Math.max(1, Number(node.width ?? (maxX - minX) ?? 1)),
+            Math.max(1, Number(node.height ?? (maxY - minY) ?? 1)),
+            minX,
+            maxX,
+            minY,
+            maxY
+        ];
+        if (geometry.some((value) => !Number.isFinite(value)) ||
+            geometry[3] <= 0 || geometry[4] <= 0 ||
+            geometry[6] < geometry[5] || geometry[8] < geometry[7]) {
+            return null;
+        }
+        return {
+            id,
+            flags,
+            geometry
+        };
+    }
+
+    function roundProfile(value) {
+        const number = Number(value || 0);
+        return Number(Math.max(0, number).toFixed(2));
+    }
+
+    function requireFiniteNumber(value, fallback, label) {
+        const number = Number(value ?? fallback);
+        if (!Number.isFinite(number)) {
+            throw new Error(`Invalid native ${label}.`);
+        }
+        return number;
+    }
+
+    function create(module, options = {}) {
+        if (!module || typeof module._me_context_create !== 'function') {
+            throw new Error('MindExecution C++ core exports are unavailable.');
+        }
+        if (Number(module._me_core_api_version()) !== API_VERSION) {
+            throw new Error(`MindExecution C++ core ABI mismatch (expected ${API_VERSION}).`);
+        }
+        if (Number(module._me_node_geometry_stride()) !== GEOMETRY_STRIDE) {
+            throw new Error(`MindExecution C++ geometry stride mismatch (expected ${GEOMETRY_STRIDE}).`);
+        }
+
+        const emit = typeof options.postMessage === 'function'
+            ? options.postMessage
+            : (payload) => global.postMessage(payload);
+        const context = module._me_context_create(500);
+        if (!context) throw new Error('MindExecution C++ core context creation failed.');
+
+        let disposed = false;
+        let boardId = '';
+        let boardEpoch = 0;
+        let engineGeneration = 0;
+        let boardRevision = 0;
+        let nextHandle = 1;
+        const handleById = new Map();
+        const idByHandle = [''];
+
+        function intResult(kind) {
+            return Number(module._me_result_integer(context, kind) || 0);
+        }
+
+        function numberResult(kind) {
+            return Number(module._me_result_number(context, kind) || 0);
+        }
+
+        function handleResult(kind) {
+            const count = Number(module._me_result_count(context, kind) || 0);
+            const pointer = Number(module._me_result_data(context, kind) || 0);
+            if (!Number.isInteger(count) || count < 0) {
+                throw new Error(`Invalid C++ result count for kind ${kind}.`);
+            }
+            if (count === 0) return [];
+            if (pointer <= 0) {
+                throw new Error(`Missing C++ result data for kind ${kind}.`);
+            }
+            const handles = module.HEAPU32.subarray(pointer >>> 2, (pointer >>> 2) + count);
+            const ids = [];
+            const seenHandles = new Set();
+            for (let index = 0; index < handles.length; index++) {
+                const handle = Number(handles[index] || 0);
+                const id = String(idByHandle[handle] || '').trim();
+                if (handle <= 0 || !id || seenHandles.has(handle)) {
+                    throw new Error(`Invalid C++ result handle for kind ${kind}.`);
+                }
+                seenHandles.add(handle);
+                ids.push(id);
+            }
+            return ids;
+        }
+
+        function ensureHandle(id) {
+            let handle = Number(handleById.get(id) || 0);
+            if (handle > 0) return handle;
+            handle = nextHandle++;
+            handleById.set(id, handle);
+            idByHandle[handle] = id;
+            return handle;
+        }
+
+        function resetHandles() {
+            nextHandle = 1;
+            handleById.clear();
+            idByHandle.length = 1;
+            idByHandle[0] = '';
+        }
+
+        function captureOwner(message) {
+            boardId = normalizeBoardId(message.boardId);
+            boardEpoch = normalizeToken(message.boardEpoch);
+            engineGeneration = normalizeToken(message.engineGeneration);
+            boardRevision = normalizeRevision(message.boardRevision);
+        }
+
+        function ownerMatches(message) {
+            return normalizeBoardId(message.boardId) === boardId &&
+                normalizeToken(message.boardEpoch) === boardEpoch &&
+                normalizeToken(message.engineGeneration) === engineGeneration;
+        }
+
+        function postStale(type, message) {
+            emit({
+                type,
+                boardId: normalizeBoardId(message.boardId),
+                boardEpoch: normalizeToken(message.boardEpoch),
+                engineGeneration: normalizeToken(message.engineGeneration),
+                boardRevision: normalizeRevision(message.boardRevision),
+                seq: normalizeToken(message.seq),
+                stale: true,
+                coreBackend: options.backend || 'wasm'
+            });
+        }
+
+        function withBoardArrays(nodes, callback) {
+            const normalized = [];
+            const source = Array.isArray(nodes) ? nodes : [];
+            for (let index = 0; index < source.length; index++) {
+                const node = normalizeNode(source[index]);
+                if (!node) throw new Error(`Invalid native node snapshot at index ${index}.`);
+                normalized.push(node);
+            }
+
+            const handles = new Uint32Array(normalized.length);
+            const flags = new Uint32Array(normalized.length);
+            const geometry = new Float64Array(normalized.length * GEOMETRY_STRIDE);
+            for (let index = 0; index < normalized.length; index++) {
+                handles[index] = ensureHandle(normalized[index].id);
+                flags[index] = normalized[index].flags;
+                geometry.set(normalized[index].geometry, index * GEOMETRY_STRIDE);
+            }
+
+            const handlesPointer = handles.byteLength > 0 ? module._malloc(handles.byteLength) : 0;
+            const flagsPointer = flags.byteLength > 0 ? module._malloc(flags.byteLength) : 0;
+            const geometryPointer = geometry.byteLength > 0 ? module._malloc(geometry.byteLength) : 0;
+            try {
+                if (handlesPointer) module.HEAPU32.set(handles, handlesPointer >>> 2);
+                if (flagsPointer) module.HEAPU32.set(flags, flagsPointer >>> 2);
+                if (geometryPointer) module.HEAPF64.set(geometry, geometryPointer >>> 3);
+                return callback(normalized.length, handlesPointer, flagsPointer, geometryPointer);
+            } finally {
+                if (geometryPointer) module._free(geometryPointer);
+                if (flagsPointer) module._free(flagsPointer);
+                if (handlesPointer) module._free(handlesPointer);
+            }
+        }
+
+        function handleReset(message) {
+            captureOwner(message);
+            resetHandles();
+            const status = module._me_board_reset(
+                context,
+                boardEpoch,
+                engineGeneration,
+                boardRevision,
+                Math.max(1, Number(message.cellSize || 500))
+            );
+            if (status !== STATUS_OK) throw new Error(`C++ board reset failed with status ${status}.`);
+        }
+
+        function handleRebuild(message) {
+            captureOwner(message);
+            resetHandles();
+            withBoardArrays(message.nodes, (count, handles, flags, geometry) => {
+                const status = module._me_board_load(
+                    context,
+                    boardEpoch,
+                    engineGeneration,
+                    boardRevision,
+                    Math.max(1, Number(message.cellSize || 500)),
+                    count,
+                    handles,
+                    flags,
+                    geometry
+                );
+                if (status !== STATUS_OK) throw new Error(`C++ board load failed with status ${status}.`);
+            });
+        }
+
+        function handleUpsert(message) {
+            if (!ownerMatches(message)) return;
+            const node = normalizeNode(message.node);
+            if (!node) throw new Error('Invalid native node upsert snapshot.');
+            const revision = normalizeRevision(message.boardRevision);
+            const handle = ensureHandle(node.id);
+            const g = node.geometry;
+            const status = module._me_node_upsert(
+                context, boardEpoch, engineGeneration, revision, handle, node.flags,
+                g[0], g[1], g[2], g[3], g[4], g[5], g[6], g[7], g[8]
+            );
+            if (status === STATUS_OK) boardRevision = revision;
+            else if (status !== STATUS_STALE) throw new Error(`C++ node upsert failed with status ${status}.`);
+        }
+
+        function handleRemove(message) {
+            if (!ownerMatches(message)) return;
+            const id = String(message.nodeId || '').trim();
+            if (!id) return;
+            const mappedHandle = Number(handleById.get(id) || 0);
+            // A valid board mutation must advance the mirrored revision even
+            // when this node never entered the native mirror (for example,
+            // because its geometry snapshot was invalid). The C++ remove API
+            // deliberately accepts an unused non-zero handle as a no-op.
+            const handle = mappedHandle > 0 ? mappedHandle : nextHandle;
+            const revision = normalizeRevision(message.boardRevision);
+            const status = module._me_node_remove(context, boardEpoch, engineGeneration, revision, handle);
+            if (status === STATUS_OK) {
+                boardRevision = revision;
+                if (mappedHandle > 0) {
+                    handleById.delete(id);
+                    idByHandle[mappedHandle] = '';
+                }
+            } else if (status !== STATUS_STALE) throw new Error(`C++ node removal failed with status ${status}.`);
+        }
+
+        function handleVisibility(message) {
+            const camera = message.camera || {};
+            const state = message.state || {};
+            let stateFlags = 0;
+            if (state.isPanning === true) stateFlags |= VISIBILITY_PANNING;
+            if (state.isZooming === true) stateFlags |= VISIBILITY_ZOOMING;
+            if (state.isWindowResizing === true) stateFlags |= VISIBILITY_WINDOW_RESIZING;
+            if (state.isResizing === true) stateFlags |= VISIBILITY_NODE_RESIZING;
+            if (state.isFullResMode === true) stateFlags |= VISIBILITY_FULL_RES;
+            if (state.isCtrlWheelVerticalScrolling === true) stateFlags |= VISIBILITY_CTRL_WHEEL_SCROLLING;
+            const cameraX = requireFiniteNumber(camera.x, 0, 'camera.x');
+            const cameraY = requireFiniteNumber(camera.y, 0, 'camera.y');
+            const cameraZ = requireFiniteNumber(camera.z, 0, 'camera.z');
+            const cameraNear = requireFiniteNumber(camera.near, 0, 'camera.near');
+            const cameraFar = requireFiniteNumber(camera.far, Number.MAX_SAFE_INTEGER, 'camera.far');
+            const cameraFov = requireFiniteNumber(camera.fov, 45, 'camera.fov');
+            const cameraAspect = Math.max(0.1, requireFiniteNumber(camera.aspect, 1, 'camera.aspect'));
+            const viewportWidth = Math.max(1, requireFiniteNumber(camera.viewportW, 1, 'camera.viewportW'));
+            const viewportHeight = Math.max(1, requireFiniteNumber(camera.viewportH, 1, 'camera.viewportH'));
+            const ctrlWheelDeltaY = requireFiniteNumber(state.lastCtrlWheelDeltaY, 0, 'lastCtrlWheelDeltaY');
+            const panWorldDeltaX = requireFiniteNumber(state.lastPanWorldDeltaX, 0, 'lastPanWorldDeltaX');
+            const panWorldDeltaY = requireFiniteNumber(state.lastPanWorldDeltaY, 0, 'lastPanWorldDeltaY');
+            const status = module._me_visibility_query(
+                context,
+                normalizeToken(message.boardEpoch),
+                normalizeToken(message.engineGeneration),
+                normalizeRevision(message.boardRevision),
+                normalizeToken(message.seq),
+                normalizeToken(message.mainLastAppliedSeq),
+                cameraX,
+                cameraY,
+                cameraZ,
+                cameraNear,
+                cameraFar,
+                cameraFov,
+                cameraAspect,
+                viewportWidth,
+                viewportHeight,
+                stateFlags,
+                ctrlWheelDeltaY,
+                panWorldDeltaX,
+                panWorldDeltaY
+            );
+            if (status !== STATUS_OK) {
+                if (status !== STATUS_STALE) throw new Error(`C++ visibility query failed with status ${status}.`);
+                postStale('VISIBILITY_RESULT', message);
+                return;
+            }
+
+            const omitVisibleIds = intResult(INTEGER.omitVisibleIds) === 1;
+            const priorityChanged = intResult(INTEGER.priorityChanged) === 1;
+            const visibleCount = intResult(INTEGER.visibleCount);
+            emit({
+                type: 'VISIBILITY_RESULT',
+                boardId,
+                boardEpoch,
+                engineGeneration,
+                boardRevision,
+                seq: normalizeToken(message.seq),
+                visibleIds: omitVisibleIds ? undefined : handleResult(ARRAY.visible),
+                visibleCount,
+                enteredIds: handleResult(ARRAY.entered),
+                exitedIds: handleResult(ARRAY.exited),
+                priorityIds: priorityChanged ? handleResult(ARRAY.priority) : undefined,
+                visibilityChanged: intResult(INTEGER.visibilityChanged) === 1,
+                viewportRect: {
+                    left: numberResult(NUMBER.viewLeft),
+                    right: numberResult(NUMBER.viewRight),
+                    bottom: numberResult(NUMBER.viewBottom),
+                    top: numberResult(NUMBER.viewTop),
+                    mode: state.isFullResMode === true ? 'full-res' : 'lod',
+                    cameraZ
+                },
+                lastVisibilityNodeCount: intResult(INTEGER.nodeCount),
+                fullResVisibilityReconcilePending: intResult(INTEGER.reconcilePending) === 1,
+                coreBackend: options.backend || 'wasm',
+                profile: {
+                    durationMs: roundProfile(numberResult(NUMBER.durationMs)),
+                    cameraZ: Number(numberResult(NUMBER.cameraZ).toFixed(2)),
+                    useCoarseVisibility: intResult(INTEGER.useCoarseVisibility) === 1,
+                    marginWorld: Number(numberResult(NUMBER.marginWorld).toFixed(2)),
+                    gridSpanX: intResult(INTEGER.gridSpanX),
+                    gridSpanY: intResult(INTEGER.gridSpanY),
+                    directGridLookups: intResult(INTEGER.directGridLookups),
+                    usedPopulatedCellScan: intResult(INTEGER.usedPopulatedCellScan) === 1,
+                    incrementalPanMode: intResult(INTEGER.incrementalPanMode) === 1,
+                    incrementalPanBandCount: intResult(INTEGER.incrementalPanBandCount),
+                    incrementalPanCellLookups: intResult(INTEGER.incrementalPanCellLookups),
+                    omittedFullVisibleIds: omitVisibleIds,
+                    candidateCount: intResult(INTEGER.candidateCount),
+                    processedCount: intResult(INTEGER.candidateCount),
+                    prevVisibleCount: intResult(INTEGER.previousVisibleCount),
+                    nextVisibleCount: visibleCount,
+                    visibilityChanged: intResult(INTEGER.visibilityChanged) === 1,
+                    backend: options.backend || 'wasm'
+                }
+            });
+        }
+
+        function handleHitTest(message) {
+            const cellRadius = Math.max(0, Math.min(3, Math.round(
+                requireFiniteNumber(message.cellRadius, 1, 'hit cellRadius')
+            )));
+            const cellX = Math.floor(requireFiniteNumber(message.cellX, 0, 'hit cellX'));
+            const cellY = Math.floor(requireFiniteNumber(message.cellY, 0, 'hit cellY'));
+            const status = module._me_hit_test_query(
+                context,
+                normalizeToken(message.boardEpoch),
+                normalizeToken(message.engineGeneration),
+                normalizeRevision(message.boardRevision),
+                cellX,
+                cellY,
+                cellRadius
+            );
+            if (status !== STATUS_OK) {
+                if (status !== STATUS_STALE) throw new Error(`C++ hit-test query failed with status ${status}.`);
+                postStale('HIT_TEST_RESULT', message);
+                return;
+            }
+            emit({
+                type: 'HIT_TEST_RESULT',
+                boardId,
+                boardEpoch,
+                engineGeneration,
+                boardRevision,
+                seq: normalizeToken(message.seq),
+                cellX,
+                cellY,
+                cellRadius,
+                rangeKey: `${cellX}:${cellY}:${cellRadius}`,
+                candidateIds: handleResult(ARRAY.hit),
+                coreBackend: options.backend || 'wasm',
+                profile: {
+                    durationMs: roundProfile(numberResult(NUMBER.durationMs)),
+                    cellLookups: intResult(INTEGER.cellLookups),
+                    candidateCount: intResult(INTEGER.candidateCount),
+                    spatialGridCellCount: intResult(INTEGER.spatialGridCellCount),
+                    backend: options.backend || 'wasm'
+                }
+            });
+        }
+
+        function handleSelection(message) {
+            const rect = message.selectionRect || null;
+            if (!rect) {
+                postStale('SELECTION_QUERY_RESULT', message);
+                return;
+            }
+            const rectLeft = requireFiniteNumber(rect.left, 0, 'selection left');
+            const rectRight = requireFiniteNumber(rect.right, 0, 'selection right');
+            const rectBottom = requireFiniteNumber(rect.bottom, 0, 'selection bottom');
+            const rectTop = requireFiniteNumber(rect.top, 0, 'selection top');
+            const status = module._me_selection_query(
+                context,
+                normalizeToken(message.boardEpoch),
+                normalizeToken(message.engineGeneration),
+                normalizeRevision(message.boardRevision),
+                rectLeft, rectRight, rectBottom, rectTop
+            );
+            if (status !== STATUS_OK) {
+                if (status !== STATUS_STALE) throw new Error(`C++ selection query failed with status ${status}.`);
+                postStale('SELECTION_QUERY_RESULT', message);
+                return;
+            }
+            const normalizedRect = {
+                left: Math.min(rectLeft, rectRight),
+                right: Math.max(rectLeft, rectRight),
+                bottom: Math.min(rectBottom, rectTop),
+                top: Math.max(rectBottom, rectTop)
+            };
+            const selectedIds = handleResult(ARRAY.selection);
+            emit({
+                type: 'SELECTION_QUERY_RESULT',
+                boardId,
+                boardEpoch,
+                engineGeneration,
+                boardRevision,
+                seq: normalizeToken(message.seq),
+                selectedIds,
+                selectionRect: normalizedRect,
+                coreBackend: options.backend || 'wasm',
+                profile: {
+                    durationMs: roundProfile(numberResult(NUMBER.durationMs)),
+                    candidateCount: intResult(INTEGER.candidateCount),
+                    selectedCount: selectedIds.length,
+                    gridSpanX: intResult(INTEGER.gridSpanX),
+                    gridSpanY: intResult(INTEGER.gridSpanY),
+                    directGridLookups: intResult(INTEGER.directGridLookups),
+                    usedPopulatedCellScan: intResult(INTEGER.usedPopulatedCellScan) === 1,
+                    backend: options.backend || 'wasm'
+                }
+            });
+        }
+
+        function handleMessage(message) {
+            if (disposed || !message || typeof message !== 'object') return false;
+            switch (String(message.type || '')) {
+                case 'RESET_BOARD':
+                    handleReset(message);
+                    return true;
+                case 'REBUILD_BOARD':
+                    handleRebuild(message);
+                    return true;
+                case 'UPSERT_NODE':
+                    handleUpsert(message);
+                    return true;
+                case 'REMOVE_NODE':
+                    handleRemove(message);
+                    return true;
+                case 'VISIBILITY_QUERY':
+                    handleVisibility(message);
+                    return true;
+                case 'HIT_TEST_QUERY':
+                    handleHitTest(message);
+                    return true;
+                case 'SELECTION_QUERY':
+                    handleSelection(message);
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
+        function dispose() {
+            if (disposed) return;
+            disposed = true;
+            module._me_context_destroy(context);
+            resetHandles();
+        }
+
+        return {
+            handleMessage,
+            dispose,
+            apiVersion: API_VERSION,
+            backend: options.backend || 'wasm'
+        };
+    }
+
+    global.MindExecutionNativeCoreAdapter = Object.freeze({
+        API_VERSION,
+        create
+    });
+})(typeof self !== 'undefined' ? self : globalThis);

package/wwwroot/_content/MindExecution.Shared/native-core/mindexec-native-core-worker.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const NATIVE_CORE_WORKER_BUILD_ID = '20260830-native-core-v004';
+const pendingMessages = [];
+let runtime = null;
+let initializationFailed = false;
+
+self.onmessage = function (event) {
+    const message = event?.data || null;
+    if (!message || typeof message !== 'object' || initializationFailed) return;
+    if (!runtime) {
+        pendingMessages.push(message);
+        return;
+    }
+    try {
+        runtime.handleMessage(message);
+    } catch (error) {
+        self.postMessage({
+            type: 'NATIVE_CORE_RUNTIME_ERROR',
+            message: String(error?.message || error || 'unknown native core error')
+        });
+        setTimeout(() => { throw error; }, 0);
+    }
+};
+
+function runtimeUrl(fileName) {
+    return new URL(`./${fileName}?v=${NATIVE_CORE_WORKER_BUILD_ID}`, self.location.href).href;
+}
+
+function locateRuntimeFile(path) {
+    return runtimeUrl(path);
+}
+
+async function initialize() {
+    importScripts(runtimeUrl('mindexec-native-core-adapter.js'));
+    importScripts(runtimeUrl('mindexec-core.js'));
+
+    let simdFactory = null;
+    try {
+        importScripts(runtimeUrl('mindexec-core-simd.js'));
+        simdFactory = typeof self.createMindExecutionCoreSimd === 'function'
+            ? self.createMindExecutionCoreSimd
+            : null;
+    } catch {
+        simdFactory = null;
+    }
+
+    let module = null;
+    let backend = 'wasm-scalar';
+    if (simdFactory) {
+        try {
+            module = await simdFactory({ locateFile: locateRuntimeFile });
+            backend = 'wasm-simd';
+        } catch {
+            module = null;
+        }
+    }
+    if (!module) {
+        if (typeof self.createMindExecutionCore !== 'function') {
+            throw new Error('Scalar MindExecution C++ core factory is unavailable.');
+        }
+        module = await self.createMindExecutionCore({ locateFile: locateRuntimeFile });
+    }
+
+    runtime = self.MindExecutionNativeCoreAdapter.create(module, {
+        backend,
+        postMessage: (payload) => self.postMessage(payload)
+    });
+    while (pendingMessages.length > 0) {
+        runtime.handleMessage(pendingMessages.shift());
+    }
+    self.postMessage({
+        type: 'READY',
+        worker: 'native-core',
+        backend,
+        apiVersion: runtime.apiVersion,
+        buildId: NATIVE_CORE_WORKER_BUILD_ID
+    });
+}
+
+initialize().catch((error) => {
+    initializationFailed = true;
+    self.postMessage({
+        type: 'NATIVE_CORE_INIT_ERROR',
+        message: String(error?.message || error || 'native core initialization failed'),
+        buildId: NATIVE_CORE_WORKER_BUILD_ID
+    });
+    setTimeout(() => { throw error; }, 0);
+});