@mindexec/cli 0.2.499 → 0.2.501

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

@@ -0,0 +1,1275 @@
+(function () {
+    'use strict';
+
+    const BUILD_ID = '20260831-native-render-webview2-v003';
+    const WIRE_PREFIX = 'mindexec.native-render.v1';
+    const PROTOCOL_MAGIC = 0x31524e4d;
+    const PROTOCOL_VERSION = 1;
+    const HEADER_BYTES = 12;
+    const MAX_BINARY_BYTES = 8 * 1024 * 1024;
+    const MAX_BOARD_ID_BYTES = 256;
+    const MAX_BACKEND_BYTES = 64;
+    const MAX_REASON_BYTES = 512;
+    const MAX_NODE_COUNT = 250000;
+    const MAX_EDGE_COUNT = 500000;
+    const MAX_EDGE_POINT_COUNT = 2000000;
+    const MAX_PENDING_REQUESTS = 8;
+    const RESPONSE_TIMEOUT_MS = 5000;
+    const MAX_UINT32 = 0xffffffff;
+    const MAX_UINT64 = 0xffffffffffffffffn;
+    const REQUEST_ID_PATTERN = /^[1-9][0-9]{0,15}$/;
+    const SESSION_TOKEN_PATTERN = /^[A-Za-z0-9_-]{16,64}$/;
+    const BASE64_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+
+    const REQUEST_TYPE = Object.freeze({
+        snapshot: 1,
+        camera: 2,
+        detach: 3
+    });
+
+    const RESPONSE_TYPE = Object.freeze({
+        ready: 0x8001,
+        accepted: 0x8002,
+        rejected: 0x8003,
+        shutdown: 0x8004
+    });
+
+    const webview = window?.chrome?.webview;
+    if (!webview ||
+        typeof webview.postMessage !== 'function' ||
+        typeof webview.addEventListener !== 'function') {
+        return;
+    }
+
+    let hybridCompareEnabled = false;
+    try {
+        hybridCompareEnabled = new window.URLSearchParams(window.location?.search || '')
+            .get('nativeDesktop') === 'hybridCompare';
+    } catch {
+        hybridCompareEnabled = false;
+    }
+    if (!hybridCompareEnabled ||
+        typeof window.TextEncoder !== 'function' ||
+        typeof window.TextDecoder !== 'function' ||
+        typeof window.atob !== 'function' ||
+        typeof window.btoa !== 'function' ||
+        typeof window.setTimeout !== 'function' ||
+        typeof window.clearTimeout !== 'function') {
+        return;
+    }
+
+    const textEncoder = new window.TextEncoder();
+    const textDecoder = new window.TextDecoder('utf-8', { fatal: true });
+    const statusListeners = new Set();
+    const pending = new Map();
+    const root = window.document?.documentElement || null;
+    const visualViewportTarget = window.visualViewport || null;
+
+    let nextRequestId = 1;
+    let sessionToken = '';
+    let statusChecked = false;
+    let disposed = false;
+    let hasAcceptedSnapshot = false;
+    let acceptedSnapshotOwner = null;
+    let viewportEpoch = 0;
+    let viewportAcknowledgementRequired = false;
+    let requestedCompareLayer = 'web';
+    let effectiveCompareLayer = 'web';
+    const status = {
+        mode: 'mirror',
+        ready: false,
+        backend: '',
+        engineGeneration: 0,
+        acceptedFrames: 0,
+        rejectedFrames: 0,
+        lastError: ''
+    };
+
+    function createProtocolError(code) {
+        const error = new Error(code);
+        error.code = code;
+        return error;
+    }
+
+    function toFiniteNumber(value, name) {
+        if (typeof value !== 'number' || !Number.isFinite(value)) {
+            throw createProtocolError(`native-renderer-invalid-${name}`);
+        }
+        return value;
+    }
+
+    function toUint32(value, name) {
+        if (typeof value !== 'number' ||
+            !Number.isInteger(value) ||
+            value < 0 ||
+            value > MAX_UINT32) {
+            throw createProtocolError(`native-renderer-invalid-${name}`);
+        }
+        return value;
+    }
+
+    function toUint64(value, name) {
+        let result;
+        if (typeof value === 'bigint') {
+            result = value;
+        } else if (typeof value === 'number') {
+            if (!Number.isInteger(value)) {
+                throw createProtocolError(`native-renderer-invalid-${name}`);
+            }
+            if (!Number.isSafeInteger(value)) {
+                throw createProtocolError(`native-renderer-unsafe-${name}`);
+            }
+            result = BigInt(value);
+        } else {
+            throw createProtocolError(`native-renderer-invalid-${name}`);
+        }
+        if (result < 0n || result > MAX_UINT64) {
+            throw createProtocolError(`native-renderer-invalid-${name}`);
+        }
+        return result;
+    }
+
+    function encodeUtf8U16(value, name, { allowEmpty = false, maxBytes = 0xffff } = {}) {
+        if (typeof value !== 'string' || value.includes('\0')) {
+            throw createProtocolError(`native-renderer-invalid-${name}`);
+        }
+        const encoded = textEncoder.encode(value);
+        let roundTrip;
+        try {
+            roundTrip = textDecoder.decode(encoded);
+        } catch {
+            throw createProtocolError(`native-renderer-invalid-${name}`);
+        }
+        if (roundTrip !== value || (!allowEmpty && encoded.length === 0) || encoded.length > maxBytes) {
+            throw createProtocolError(`native-renderer-invalid-${name}`);
+        }
+        return encoded;
+    }
+
+    function normalizeOwner(owner) {
+        if (!owner || typeof owner !== 'object' || Array.isArray(owner)) {
+            throw createProtocolError('native-renderer-invalid-owner');
+        }
+        const normalized = {
+            boardId: owner.boardId,
+            boardIdBytes: encodeUtf8U16(owner.boardId, 'board-id', { maxBytes: MAX_BOARD_ID_BYTES }),
+            engineGeneration: toUint64(owner.engineGeneration, 'engine-generation'),
+            boardEpoch: toUint64(owner.boardEpoch, 'board-epoch'),
+            boardRevision: toUint64(owner.boardRevision, 'board-revision'),
+            requestSequence: toUint64(owner.requestSequence, 'request-sequence')
+        };
+        if (normalized.engineGeneration === 0n ||
+            normalized.boardEpoch === 0n ||
+            normalized.boardRevision === 0n ||
+            normalized.requestSequence === 0n) {
+            throw createProtocolError('native-renderer-owner-token-zero');
+        }
+        return normalized;
+    }
+
+    function ownersEqual(left, right) {
+        return left?.boardId === right?.boardId &&
+            left?.engineGeneration === right?.engineGeneration &&
+            left?.boardEpoch === right?.boardEpoch &&
+            left?.boardRevision === right?.boardRevision &&
+            left?.requestSequence === right?.requestSequence;
+    }
+
+    function normalizeCamera(camera) {
+        if (!camera || typeof camera !== 'object' || Array.isArray(camera)) {
+            throw createProtocolError('native-renderer-invalid-camera');
+        }
+        const normalized = {
+            x: toFiniteNumber(camera.x, 'camera-x'),
+            y: toFiniteNumber(camera.y, 'camera-y'),
+            z: toFiniteNumber(camera.z, 'camera-z'),
+            near: toFiniteNumber(camera.near, 'camera-near'),
+            far: toFiniteNumber(camera.far, 'camera-far'),
+            fov: toFiniteNumber(camera.fov, 'camera-fov'),
+            viewportW: toFiniteNumber(camera.viewportW, 'camera-viewport-w'),
+            viewportH: toFiniteNumber(camera.viewportH, 'camera-viewport-h'),
+            zoom: toFiniteNumber(camera.zoom, 'camera-zoom')
+        };
+        if (normalized.near <= 0 ||
+            normalized.far <= normalized.near ||
+            normalized.fov <= 0 ||
+            normalized.fov >= 180 ||
+            normalized.viewportW <= 0 ||
+            normalized.viewportH <= 0 ||
+            normalized.zoom <= 0) {
+            throw createProtocolError('native-renderer-invalid-camera-range');
+        }
+        return normalized;
+    }
+
+    function currentRawPhysicalViewport() {
+        const visualViewport = window.visualViewport;
+        const visualWidth = Number(visualViewport?.width);
+        const visualHeight = Number(visualViewport?.height);
+        const innerWidth = Number(window.innerWidth);
+        const innerHeight = Number(window.innerHeight);
+        const cssWidth = Number.isFinite(visualWidth) && visualWidth > 0
+            ? visualWidth
+            : innerWidth;
+        const cssHeight = Number.isFinite(visualHeight) && visualHeight > 0
+            ? visualHeight
+            : innerHeight;
+        const dpr = Number(window.devicePixelRatio);
+        if (!Number.isFinite(cssWidth) || cssWidth <= 0 ||
+            !Number.isFinite(cssHeight) || cssHeight <= 0 ||
+            !Number.isFinite(dpr) || dpr <= 0) {
+            throw createProtocolError('native-renderer-invalid-physical-viewport');
+        }
+        const viewportW = Math.max(1, Math.round(cssWidth * dpr));
+        const viewportH = Math.max(1, Math.round(cssHeight * dpr));
+        if (!Number.isSafeInteger(viewportW) || !Number.isSafeInteger(viewportH)) {
+            throw createProtocolError('native-renderer-invalid-physical-viewport');
+        }
+        return { viewportW, viewportH };
+    }
+
+    function normalizeHybridCamera(camera) {
+        return {
+            ...normalizeCamera(camera),
+            ...currentRawPhysicalViewport()
+        };
+    }
+
+    function normalizeNodes(nodes) {
+        if (!Array.isArray(nodes)) {
+            throw createProtocolError('native-renderer-invalid-nodes');
+        }
+        if (nodes.length > MAX_NODE_COUNT) {
+            throw createProtocolError('native-renderer-too-many-nodes');
+        }
+        const handles = new Set();
+        const normalized = [];
+        for (let index = 0; index < nodes.length; index += 1) {
+            const node = nodes[index];
+            if (!node || typeof node !== 'object' || Array.isArray(node)) {
+                throw createProtocolError(`native-renderer-invalid-node-${index}`);
+            }
+            const handle = toUint32(node.handle, `node-handle-${index}`);
+            if (handle === 0 || handles.has(handle)) {
+                throw createProtocolError(`native-renderer-duplicate-node-handle-${index}`);
+            }
+            handles.add(handle);
+            const entry = {
+                handle,
+                x: toFiniteNumber(node.x, `node-x-${index}`),
+                y: toFiniteNumber(node.y, `node-y-${index}`),
+                z: toFiniteNumber(node.z, `node-z-${index}`),
+                width: toFiniteNumber(node.width, `node-width-${index}`),
+                height: toFiniteNumber(node.height, `node-height-${index}`),
+                fillRgba: toUint32(node.fillRgba, `node-fill-${index}`)
+            };
+            if (entry.width <= 0 || entry.height <= 0) {
+                throw createProtocolError(`native-renderer-invalid-node-size-${index}`);
+            }
+            normalized.push(entry);
+        }
+        return { nodes: normalized, handles };
+    }
+
+    function normalizeEdges(edges, nodeHandles) {
+        if (!Array.isArray(edges)) {
+            throw createProtocolError('native-renderer-invalid-edges');
+        }
+        if (edges.length > MAX_EDGE_COUNT) {
+            throw createProtocolError('native-renderer-too-many-edges');
+        }
+        const handles = new Set();
+        const normalized = [];
+        let totalPointCount = 0;
+        for (let index = 0; index < edges.length; index += 1) {
+            const edge = edges[index];
+            if (!edge || typeof edge !== 'object' || Array.isArray(edge) || !Array.isArray(edge.points)) {
+                throw createProtocolError(`native-renderer-invalid-edge-${index}`);
+            }
+            const handle = toUint32(edge.handle, `edge-handle-${index}`);
+            if (handle === 0 || handles.has(handle)) {
+                throw createProtocolError(`native-renderer-duplicate-edge-handle-${index}`);
+            }
+            handles.add(handle);
+            if (edge.points.length < 2) {
+                throw createProtocolError(`native-renderer-invalid-edge-points-${index}`);
+            }
+            totalPointCount += edge.points.length;
+            if (!Number.isSafeInteger(totalPointCount) || totalPointCount > MAX_EDGE_POINT_COUNT) {
+                throw createProtocolError('native-renderer-too-many-edge-points');
+            }
+            const points = [];
+            for (let pointIndex = 0; pointIndex < edge.points.length; pointIndex += 1) {
+                const point = edge.points[pointIndex];
+                if (!point || typeof point !== 'object' || Array.isArray(point)) {
+                    throw createProtocolError(`native-renderer-invalid-edge-point-${index}-${pointIndex}`);
+                }
+                points.push({
+                    x: toFiniteNumber(point.x, `edge-point-x-${index}-${pointIndex}`),
+                    y: toFiniteNumber(point.y, `edge-point-y-${index}-${pointIndex}`)
+                });
+            }
+            const entry = {
+                handle,
+                sourceHandle: toUint32(edge.sourceHandle, `edge-source-${index}`),
+                targetHandle: toUint32(edge.targetHandle, `edge-target-${index}`),
+                z: toFiniteNumber(edge.z, `edge-z-${index}`),
+                width: toFiniteNumber(edge.width, `edge-width-${index}`),
+                colorRgba: toUint32(edge.colorRgba, `edge-color-${index}`),
+                points
+            };
+            if (entry.sourceHandle === 0 ||
+                entry.targetHandle === 0 ||
+                !nodeHandles.has(entry.sourceHandle) ||
+                !nodeHandles.has(entry.targetHandle) ||
+                entry.width <= 0) {
+                throw createProtocolError(`native-renderer-invalid-edge-range-${index}`);
+            }
+            normalized.push(entry);
+        }
+        return { edges: normalized, totalPointCount };
+    }
+
+    class BinaryWriter {
+        constructor(length) {
+            this.bytes = new Uint8Array(length);
+            this.view = new DataView(this.bytes.buffer);
+            this.offset = 0;
+        }
+
+        uint16(value) {
+            this.view.setUint16(this.offset, value, true);
+            this.offset += 2;
+        }
+
+        uint32(value) {
+            this.view.setUint32(this.offset, value, true);
+            this.offset += 4;
+        }
+
+        uint64(value) {
+            this.view.setBigUint64(this.offset, value, true);
+            this.offset += 8;
+        }
+
+        float64(value) {
+            this.view.setFloat64(this.offset, value, true);
+            this.offset += 8;
+        }
+
+        raw(bytes) {
+            this.bytes.set(bytes, this.offset);
+            this.offset += bytes.length;
+        }
+
+        finish(code) {
+            if (this.offset !== this.bytes.length) {
+                throw createProtocolError(code);
+            }
+            return this.bytes;
+        }
+    }
+
+    function ownerPayloadBytes(owner) {
+        return 2 + owner.boardIdBytes.length + 32;
+    }
+
+    function writeOwner(writer, owner) {
+        writer.uint16(owner.boardIdBytes.length);
+        writer.raw(owner.boardIdBytes);
+        writer.uint64(owner.engineGeneration);
+        writer.uint64(owner.boardEpoch);
+        writer.uint64(owner.boardRevision);
+        writer.uint64(owner.requestSequence);
+    }
+
+    function writeCamera(writer, camera) {
+        for (const value of [
+            camera.x,
+            camera.y,
+            camera.z,
+            camera.near,
+            camera.far,
+            camera.fov,
+            camera.viewportW,
+            camera.viewportH,
+            camera.zoom
+        ]) {
+            writer.float64(value);
+        }
+    }
+
+    function framePayload(requestType, payload) {
+        const frameLength = HEADER_BYTES + payload.length;
+        if (frameLength > MAX_BINARY_BYTES) {
+            throw createProtocolError('native-renderer-payload-too-large');
+        }
+        const writer = new BinaryWriter(frameLength);
+        writer.uint32(PROTOCOL_MAGIC);
+        writer.uint16(PROTOCOL_VERSION);
+        writer.uint16(requestType);
+        writer.uint32(payload.length);
+        writer.raw(payload);
+        return writer.finish('native-renderer-frame-size-mismatch');
+    }
+
+    function encodeSnapshotMessage(scene, owner) {
+        if (!scene || typeof scene !== 'object' || Array.isArray(scene)) {
+            throw createProtocolError('native-renderer-invalid-scene');
+        }
+        const camera = normalizeHybridCamera(scene.camera);
+        if (!Array.isArray(scene.nodes) || !Array.isArray(scene.edges)) {
+            throw createProtocolError(!Array.isArray(scene.nodes)
+                ? 'native-renderer-invalid-nodes'
+                : 'native-renderer-invalid-edges');
+        }
+        const fixedLength = ownerPayloadBytes(owner) + 72 + 12 +
+            scene.nodes.length * 48 + scene.edges.length * 36;
+        if (!Number.isSafeInteger(fixedLength) || HEADER_BYTES + fixedLength > MAX_BINARY_BYTES) {
+            throw createProtocolError('native-renderer-payload-too-large');
+        }
+        const normalizedNodes = normalizeNodes(scene.nodes);
+        const normalizedEdges = normalizeEdges(scene.edges, normalizedNodes.handles);
+        const payloadLength = fixedLength + normalizedEdges.totalPointCount * 16;
+        if (!Number.isSafeInteger(payloadLength) || HEADER_BYTES + payloadLength > MAX_BINARY_BYTES) {
+            throw createProtocolError('native-renderer-payload-too-large');
+        }
+        const writer = new BinaryWriter(payloadLength);
+        writeOwner(writer, owner);
+        writeCamera(writer, camera);
+        writer.uint32(normalizedNodes.nodes.length);
+        writer.uint32(normalizedEdges.edges.length);
+        writer.uint32(normalizedEdges.totalPointCount);
+
+        for (const node of normalizedNodes.nodes) {
+            writer.uint32(node.handle);
+            writer.float64(node.x);
+            writer.float64(node.y);
+            writer.float64(node.z);
+            writer.float64(node.width);
+            writer.float64(node.height);
+            writer.uint32(node.fillRgba);
+        }
+
+        for (const edge of normalizedEdges.edges) {
+            writer.uint32(edge.handle);
+            writer.uint32(edge.sourceHandle);
+            writer.uint32(edge.targetHandle);
+            writer.float64(edge.z);
+            writer.float64(edge.width);
+            writer.uint32(edge.colorRgba);
+            writer.uint32(edge.points.length);
+            for (const point of edge.points) {
+                writer.float64(point.x);
+                writer.float64(point.y);
+            }
+        }
+
+        return framePayload(
+            REQUEST_TYPE.snapshot,
+            writer.finish('native-renderer-snapshot-size-mismatch')
+        );
+    }
+
+    function encodeCameraMessage(frame, owner) {
+        if (!frame || typeof frame !== 'object' || Array.isArray(frame)) {
+            throw createProtocolError('native-renderer-invalid-camera-frame');
+        }
+        const camera = normalizeHybridCamera(frame.camera);
+        const writer = new BinaryWriter(ownerPayloadBytes(owner) + 72);
+        writeOwner(writer, owner);
+        writeCamera(writer, camera);
+        return framePayload(
+            REQUEST_TYPE.camera,
+            writer.finish('native-renderer-camera-size-mismatch')
+        );
+    }
+
+    function encodeDetachMessage(owner) {
+        const writer = new BinaryWriter(ownerPayloadBytes(owner));
+        writeOwner(writer, owner);
+        return framePayload(
+            REQUEST_TYPE.detach,
+            writer.finish('native-renderer-detach-size-mismatch')
+        );
+    }
+
+    class PayloadReader {
+        constructor(bytes) {
+            this.bytes = bytes;
+            this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+            this.offset = 0;
+        }
+
+        require(count) {
+            if (!Number.isSafeInteger(count) || count < 0 || count > this.bytes.length - this.offset) {
+                throw createProtocolError('native-renderer-response-truncated');
+            }
+        }
+
+        uint8() {
+            this.require(1);
+            const value = this.view.getUint8(this.offset);
+            this.offset += 1;
+            return value;
+        }
+
+        uint16() {
+            this.require(2);
+            const value = this.view.getUint16(this.offset, true);
+            this.offset += 2;
+            return value;
+        }
+
+        uint64() {
+            this.require(8);
+            const value = this.view.getBigUint64(this.offset, true);
+            this.offset += 8;
+            return value;
+        }
+
+        stringU16(name, { allowEmpty = true, maxBytes = 0xffff } = {}) {
+            const length = this.uint16();
+            if (length > maxBytes) {
+                throw createProtocolError(`native-renderer-response-invalid-${name}`);
+            }
+            this.require(length);
+            const bytes = this.bytes.subarray(this.offset, this.offset + length);
+            this.offset += length;
+            let value;
+            try {
+                value = textDecoder.decode(bytes);
+            } catch {
+                throw createProtocolError(`native-renderer-response-invalid-${name}`);
+            }
+            if ((!allowEmpty && value.length === 0) || value.includes('\0')) {
+                throw createProtocolError(`native-renderer-response-invalid-${name}`);
+            }
+            return value;
+        }
+
+        owner() {
+            const owner = {
+                boardId: this.stringU16('board-id', { allowEmpty: false, maxBytes: MAX_BOARD_ID_BYTES }),
+                engineGeneration: this.uint64(),
+                boardEpoch: this.uint64(),
+                boardRevision: this.uint64(),
+                requestSequence: this.uint64()
+            };
+            if (owner.engineGeneration === 0n ||
+                owner.boardEpoch === 0n ||
+                owner.boardRevision === 0n ||
+                owner.requestSequence === 0n) {
+                throw createProtocolError('native-renderer-response-owner-token-zero');
+            }
+            return owner;
+        }
+
+        finish() {
+            if (this.offset !== this.bytes.length) {
+                throw createProtocolError('native-renderer-response-trailing-bytes');
+            }
+        }
+    }
+
+    function decodeResponseFrame(bytes) {
+        if (!(bytes instanceof Uint8Array) || bytes.length < HEADER_BYTES) {
+            throw createProtocolError('native-renderer-response-truncated');
+        }
+        if (bytes.length > MAX_BINARY_BYTES) {
+            throw createProtocolError('native-renderer-response-too-large');
+        }
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        const magic = view.getUint32(0, true);
+        const version = view.getUint16(4, true);
+        const responseType = view.getUint16(6, true);
+        const payloadLength = view.getUint32(8, true);
+        if (magic !== PROTOCOL_MAGIC || version !== PROTOCOL_VERSION) {
+            throw createProtocolError('native-renderer-response-header-invalid');
+        }
+        if (HEADER_BYTES + payloadLength !== bytes.length) {
+            throw createProtocolError('native-renderer-response-size-mismatch');
+        }
+        const reader = new PayloadReader(bytes.subarray(HEADER_BYTES));
+        let response;
+        switch (responseType) {
+            case RESPONSE_TYPE.ready:
+                response = {
+                    type: 'ready',
+                    backend: reader.stringU16('backend', { allowEmpty: false, maxBytes: MAX_BACKEND_BYTES })
+                };
+                break;
+            case RESPONSE_TYPE.accepted:
+                response = {
+                    type: 'accepted',
+                    requestType: reader.uint16(),
+                    owner: reader.owner()
+                };
+                break;
+            case RESPONSE_TYPE.rejected: {
+                const requestType = reader.uint16();
+                const hasOwner = reader.uint8();
+                if (hasOwner !== 0 && hasOwner !== 1) {
+                    throw createProtocolError('native-renderer-response-invalid-owner-flag');
+                }
+                response = {
+                    type: 'rejected',
+                    requestType,
+                    owner: hasOwner === 1 ? reader.owner() : null,
+                    reason: reader.stringU16('reason', { allowEmpty: false, maxBytes: MAX_REASON_BYTES })
+                };
+                break;
+            }
+            case RESPONSE_TYPE.shutdown:
+                response = { type: 'shutdown' };
+                break;
+            default:
+                throw createProtocolError('native-renderer-response-type-unknown');
+        }
+        reader.finish();
+        return response;
+    }
+
+    function bytesToBase64(bytes) {
+        const chunkBytes = 0x6000;
+        let encoded = '';
+        for (let offset = 0; offset < bytes.length; offset += chunkBytes) {
+            const chunk = bytes.subarray(offset, Math.min(bytes.length, offset + chunkBytes));
+            let binary = '';
+            for (let index = 0; index < chunk.length; index += 1) {
+                binary += String.fromCharCode(chunk[index]);
+            }
+            encoded += window.btoa(binary);
+        }
+        return encoded;
+    }
+
+    function base64ToBytes(value, maxBytes, errorCode) {
+        if (typeof value !== 'string' ||
+            value.length === 0 ||
+            value.length % 4 !== 0 ||
+            !BASE64_PATTERN.test(value)) {
+            throw createProtocolError(errorCode);
+        }
+        const padding = value.endsWith('==') ? 2 : (value.endsWith('=') ? 1 : 0);
+        const decodedLength = value.length / 4 * 3 - padding;
+        if (!Number.isSafeInteger(decodedLength) || decodedLength <= 0 || decodedLength > maxBytes) {
+            throw createProtocolError(decodedLength > maxBytes
+                ? 'native-renderer-response-too-large'
+                : errorCode);
+        }
+        let binary;
+        try {
+            binary = window.atob(value);
+        } catch {
+            throw createProtocolError(errorCode);
+        }
+        if (binary.length !== decodedLength) {
+            throw createProtocolError(errorCode);
+        }
+        const bytes = new Uint8Array(decodedLength);
+        for (let index = 0; index < decodedLength; index += 1) {
+            bytes[index] = binary.charCodeAt(index);
+        }
+        if (bytesToBase64(bytes) !== value) {
+            throw createProtocolError(errorCode);
+        }
+        return bytes;
+    }
+
+    function decodeErrorReason(value) {
+        const bytes = base64ToBytes(value, MAX_REASON_BYTES, 'native-renderer-error-reason-invalid');
+        let reason;
+        try {
+            reason = textDecoder.decode(bytes);
+        } catch {
+            throw createProtocolError('native-renderer-error-reason-invalid');
+        }
+        if (!reason || reason.includes('\0')) {
+            throw createProtocolError('native-renderer-error-reason-invalid');
+        }
+        return reason;
+    }
+
+    function parseCanonicalPositiveDecimal(value, name) {
+        if (typeof value !== 'string' || !REQUEST_ID_PATTERN.test(value)) {
+            throw createProtocolError(`native-renderer-invalid-${name}`);
+        }
+        const number = Number(value);
+        if (!Number.isSafeInteger(number) || number <= 0 || String(number) !== value) {
+            throw createProtocolError(`native-renderer-invalid-${name}`);
+        }
+        return number;
+    }
+
+    function allocateRequestId() {
+        if (!Number.isSafeInteger(nextRequestId) ||
+            nextRequestId <= 0 ||
+            nextRequestId > Number.MAX_SAFE_INTEGER) {
+            throw createProtocolError('native-renderer-request-id-exhausted');
+        }
+        const requestId = String(nextRequestId);
+        nextRequestId += 1;
+        return requestId;
+    }
+
+    function currentStatus(extra = null) {
+        const snapshot = {
+            ...status,
+            desktopStage: 'hybrid-compare',
+            requestedCompareLayer,
+            compareLayer: effectiveCompareLayer
+        };
+        return extra ? { ...snapshot, ...extra } : snapshot;
+    }
+
+    function notifyStatus() {
+        const snapshot = currentStatus();
+        for (const callback of [...statusListeners]) {
+            try {
+                callback(snapshot);
+            } catch {
+                // A consumer callback must not break host message correlation.
+            }
+        }
+    }
+
+    function writeCompareLayer(value) {
+        effectiveCompareLayer = value;
+        if (root?.dataset) {
+            root.dataset.mindexecNativeCompareLayer = value;
+        }
+    }
+
+    function applyRequestedCompareLayer() {
+        writeCompareLayer(status.ready && hasAcceptedSnapshot &&
+            !viewportAcknowledgementRequired
+            ? requestedCompareLayer
+            : 'web');
+    }
+
+    function requireWebFallback() {
+        hasAcceptedSnapshot = false;
+        acceptedSnapshotOwner = null;
+        viewportAcknowledgementRequired = false;
+        writeCompareLayer('web');
+    }
+
+    function sameSceneOwner(left, right) {
+        return left?.boardId === right?.boardId &&
+            left?.engineGeneration === right?.engineGeneration &&
+            left?.boardEpoch === right?.boardEpoch &&
+            left?.boardRevision === right?.boardRevision;
+    }
+
+    function retainedSceneOwner(owner) {
+        if (!owner) return null;
+        return {
+            boardId: owner.boardId,
+            engineGeneration: owner.engineGeneration.toString(),
+            boardEpoch: owner.boardEpoch.toString(),
+            boardRevision: owner.boardRevision.toString()
+        };
+    }
+
+    function requireCameraAcknowledgement() {
+        if (!hasAcceptedSnapshot) {
+            requireWebFallback();
+            return;
+        }
+        viewportAcknowledgementRequired = true;
+        writeCompareLayer('web');
+    }
+
+    function handleViewportResize() {
+        if (disposed) return;
+        viewportEpoch = viewportEpoch >= Number.MAX_SAFE_INTEGER
+            ? 1
+            : viewportEpoch + 1;
+        viewportAcknowledgementRequired = true;
+        writeCompareLayer('web');
+    }
+
+    function setCompareLayer(value) {
+        if (value !== 'web' && value !== 'overlay' && value !== 'native') {
+            throw createProtocolError('native-renderer-invalid-compare-layer');
+        }
+        requestedCompareLayer = value;
+        applyRequestedCompareLayer();
+        return effectiveCompareLayer;
+    }
+
+    function countsAsFrame(requestType) {
+        return requestType === REQUEST_TYPE.snapshot || requestType === REQUEST_TYPE.camera;
+    }
+
+    function takePending(requestId) {
+        const entry = pending.get(requestId);
+        if (!entry) return null;
+        pending.delete(requestId);
+        window.clearTimeout(entry.timer);
+        return entry;
+    }
+
+    function markFrameFailure(requestType, reason, { notify = true } = {}) {
+        if (countsAsFrame(requestType)) {
+            status.rejectedFrames += 1;
+        }
+        status.lastError = String(reason || 'native-renderer-rejected').slice(0, MAX_REASON_BYTES);
+        if (requestType === REQUEST_TYPE.camera) {
+            requireCameraAcknowledgement();
+        } else {
+            requireWebFallback();
+        }
+        if (notify) notifyStatus();
+    }
+
+    function settleFrameFailure(entry, reason, options = {}) {
+        const attachmentRetained = entry.requestType === REQUEST_TYPE.camera &&
+            hasAcceptedSnapshot &&
+            sameSceneOwner(acceptedSnapshotOwner, entry.owner);
+        markFrameFailure(entry.requestType, reason, options);
+        entry.resolve(currentStatus({
+            accepted: false,
+            reason,
+            attachmentRetained,
+            cameraRetryAllowed: attachmentRetained,
+            retainedSceneOwner: attachmentRetained
+                ? retainedSceneOwner(acceptedSnapshotOwner)
+                : null
+        }));
+    }
+
+    function invalidateStatus(reason, entry = null) {
+        statusChecked = true;
+        status.ready = false;
+        status.backend = '';
+        status.lastError = String(reason || 'native-renderer-not-ready').slice(0, MAX_REASON_BYTES);
+        sessionToken = '';
+        requireWebFallback();
+
+        for (const [requestId, candidate] of [...pending]) {
+            if (candidate === entry || candidate.kind !== 'frame') continue;
+            takePending(requestId);
+            settleFrameFailure(candidate, status.lastError, { notify: false });
+        }
+        notifyStatus();
+        entry?.resolve(currentStatus());
+    }
+
+    function rejectBeforeSend(requestType, reason) {
+        markFrameFailure(requestType, reason);
+        return currentStatus({ accepted: false, reason });
+    }
+
+    function onRequestTimeout(requestId) {
+        const entry = takePending(requestId);
+        if (!entry) return;
+        const reason = 'native-renderer-response-timeout';
+        if (entry.kind === 'status') {
+            invalidateStatus(reason, entry);
+            return;
+        }
+        settleFrameFailure(entry, reason);
+    }
+
+    function registerPending(requestId, entry) {
+        const timer = window.setTimeout(() => onRequestTimeout(requestId), RESPONSE_TIMEOUT_MS);
+        timer?.unref?.();
+        pending.set(requestId, { ...entry, timer });
+    }
+
+    function postString(message, requestId) {
+        try {
+            webview.postMessage(message);
+            return true;
+        } catch (error) {
+            const entry = takePending(requestId);
+            if (!entry) return false;
+            const reason = `native-renderer-webmessage-post-failed:${String(error?.message || error)}`
+                .slice(0, MAX_REASON_BYTES);
+            if (entry.kind === 'status') {
+                invalidateStatus(reason, entry);
+            } else {
+                settleFrameFailure(entry, reason);
+            }
+            return false;
+        }
+    }
+
+    function getStatus() {
+        if (disposed) {
+            return Promise.resolve(currentStatus({
+                ready: false,
+                lastError: 'native-renderer-bridge-disposed'
+            }));
+        }
+        if (pending.size >= MAX_PENDING_REQUESTS) {
+            return Promise.resolve(currentStatus({ lastError: 'native-renderer-pending-limit' }));
+        }
+        let requestId;
+        try {
+            requestId = allocateRequestId();
+        } catch (error) {
+            return Promise.resolve(currentStatus({ ready: false, lastError: error.message }));
+        }
+        return new Promise((resolve) => {
+            registerPending(requestId, { kind: 'status', resolve });
+            postString(`${WIRE_PREFIX}|${requestId}|status`, requestId);
+        });
+    }
+
+    function hasDuplicatePending(requestType, owner) {
+        for (const entry of pending.values()) {
+            if (entry.kind === 'frame' &&
+                entry.requestType === requestType &&
+                ownersEqual(entry.owner, owner)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    async function sendOwned(requestType, ownerValue, encode) {
+        if (disposed) {
+            return rejectBeforeSend(requestType, 'native-renderer-bridge-disposed');
+        }
+        if (!statusChecked || !sessionToken) {
+            return rejectBeforeSend(requestType, 'native-renderer-status-required');
+        }
+        if (!status.ready) {
+            return rejectBeforeSend(requestType, status.lastError || 'native-renderer-not-ready');
+        }
+
+        let owner;
+        try {
+            owner = normalizeOwner(ownerValue);
+        } catch (error) {
+            return rejectBeforeSend(requestType, error?.message || String(error));
+        }
+        if (owner.engineGeneration !== BigInt(status.engineGeneration)) {
+            return rejectBeforeSend(requestType, 'native-renderer-engine-generation-mismatch');
+        }
+        if (requestType === REQUEST_TYPE.detach) {
+            // Board A must disappear before board B can begin attaching. Waiting
+            // for the detach acknowledgement could expose the retired native shell.
+            requireWebFallback();
+        }
+        if (pending.size >= MAX_PENDING_REQUESTS) {
+            return rejectBeforeSend(requestType, 'native-renderer-pending-limit');
+        }
+        if (hasDuplicatePending(requestType, owner)) {
+            return rejectBeforeSend(requestType, 'native-renderer-request-duplicate');
+        }
+
+        const requestViewportEpoch = viewportEpoch;
+        let frame;
+        try {
+            frame = encode(owner);
+        } catch (error) {
+            return rejectBeforeSend(requestType, error?.message || String(error));
+        }
+        if (!(frame instanceof Uint8Array) || frame.length > MAX_BINARY_BYTES) {
+            return rejectBeforeSend(requestType, 'native-renderer-payload-too-large');
+        }
+
+        let requestId;
+        try {
+            requestId = allocateRequestId();
+        } catch (error) {
+            return rejectBeforeSend(requestType, error?.message || String(error));
+        }
+        const token = sessionToken;
+        return new Promise((resolve) => {
+            registerPending(requestId, {
+                kind: 'frame',
+                requestType,
+                owner,
+                sessionToken: token,
+                viewportEpoch: requestViewportEpoch,
+                resolve
+            });
+            postString(
+                `${WIRE_PREFIX}|${requestId}|frame|${token}|${bytesToBase64(frame)}`,
+                requestId
+            );
+        });
+    }
+
+    function sendSnapshot(scene) {
+        return sendOwned(
+            REQUEST_TYPE.snapshot,
+            scene?.owner,
+            (owner) => encodeSnapshotMessage(scene, owner)
+        );
+    }
+
+    function sendCamera(frame) {
+        return sendOwned(
+            REQUEST_TYPE.camera,
+            frame?.owner,
+            (owner) => encodeCameraMessage(frame, owner)
+        );
+    }
+
+    function detach(ownerValue) {
+        return sendOwned(
+            REQUEST_TYPE.detach,
+            ownerValue,
+            (owner) => encodeDetachMessage(owner)
+        );
+    }
+
+    function onStatus(callback) {
+        if (typeof callback !== 'function' || disposed) {
+            return () => undefined;
+        }
+        statusListeners.add(callback);
+        return () => statusListeners.delete(callback);
+    }
+
+    function settleMalformed(entry, error) {
+        const reason = String(error?.message || error || 'native-renderer-response-malformed')
+            .slice(0, MAX_REASON_BYTES);
+        if (entry.kind === 'status') {
+            invalidateStatus(reason, entry);
+        } else {
+            settleFrameFailure(entry, reason);
+        }
+    }
+
+    function retireOldSessionFrames(newToken) {
+        for (const [requestId, entry] of [...pending]) {
+            if (entry.kind !== 'frame' || entry.sessionToken === newToken) continue;
+            takePending(requestId);
+            settleFrameFailure(entry, 'native-renderer-session-changed', { notify: false });
+        }
+    }
+
+    function handleStatusResponse(fields, requestId, entry) {
+        if (fields.length !== 6 || entry.kind !== 'status') {
+            throw createProtocolError('native-renderer-status-envelope-invalid');
+        }
+        const generation = parseCanonicalPositiveDecimal(fields[3], 'engine-generation');
+        const nextToken = fields[4];
+        if (!SESSION_TOKEN_PATTERN.test(nextToken)) {
+            throw createProtocolError('native-renderer-session-token-invalid');
+        }
+        const response = decodeResponseFrame(base64ToBytes(
+            fields[5],
+            MAX_BINARY_BYTES,
+            'native-renderer-status-base64-invalid'
+        ));
+        if (response.type !== 'ready') {
+            throw createProtocolError('native-renderer-status-response-type-invalid');
+        }
+
+        takePending(requestId);
+        const generationChanged = status.engineGeneration !== generation;
+        const sessionChanged = sessionToken !== nextToken;
+        if (generationChanged) {
+            status.acceptedFrames = 0;
+            status.rejectedFrames = 0;
+        }
+        if (generationChanged || sessionChanged) {
+            requireWebFallback();
+            retireOldSessionFrames(nextToken);
+        }
+        statusChecked = true;
+        sessionToken = nextToken;
+        status.ready = true;
+        status.backend = response.backend;
+        status.engineGeneration = generation;
+        status.lastError = '';
+        applyRequestedCompareLayer();
+        notifyStatus();
+        entry.resolve(currentStatus());
+    }
+
+    function handleFrameResponse(fields, requestId, entry) {
+        if (fields.length !== 5 || entry.kind !== 'frame') {
+            throw createProtocolError('native-renderer-response-envelope-invalid');
+        }
+        const responseToken = fields[3];
+        if (!SESSION_TOKEN_PATTERN.test(responseToken)) {
+            throw createProtocolError('native-renderer-session-token-invalid');
+        }
+        if (responseToken !== sessionToken || responseToken !== entry.sessionToken) {
+            return;
+        }
+        const response = decodeResponseFrame(base64ToBytes(
+            fields[4],
+            MAX_BINARY_BYTES,
+            'native-renderer-response-base64-invalid'
+        ));
+        if ((response.type !== 'accepted' && response.type !== 'rejected') ||
+            response.requestType !== entry.requestType) {
+            throw createProtocolError('native-renderer-response-request-type-mismatch');
+        }
+        if (!response.owner || !ownersEqual(response.owner, entry.owner)) {
+            throw createProtocolError('native-renderer-response-owner-mismatch');
+        }
+
+        takePending(requestId);
+        if (response.type === 'accepted') {
+            if (countsAsFrame(entry.requestType)) {
+                status.acceptedFrames += 1;
+            }
+            status.lastError = '';
+            if (entry.requestType === REQUEST_TYPE.snapshot) {
+                hasAcceptedSnapshot = true;
+                acceptedSnapshotOwner = entry.owner;
+                if (entry.viewportEpoch === viewportEpoch) {
+                    viewportAcknowledgementRequired = false;
+                }
+                applyRequestedCompareLayer();
+            } else if (entry.requestType === REQUEST_TYPE.camera &&
+                hasAcceptedSnapshot && entry.viewportEpoch === viewportEpoch) {
+                viewportAcknowledgementRequired = false;
+                applyRequestedCompareLayer();
+            } else if (entry.requestType === REQUEST_TYPE.detach && !hasAcceptedSnapshot) {
+                // A newer board snapshot may have completed while this older
+                // detach acknowledgement was in flight. Never hide that newer surface.
+                requireWebFallback();
+            }
+            notifyStatus();
+            entry.resolve(currentStatus({ accepted: true }));
+            return;
+        }
+        settleFrameFailure(entry, response.reason || 'native-renderer-rejected');
+    }
+
+    function handleErrorResponse(fields, requestId, entry) {
+        if (fields.length !== 5) {
+            throw createProtocolError('native-renderer-error-envelope-invalid');
+        }
+        const responseToken = fields[3];
+        if (responseToken !== '-' && !SESSION_TOKEN_PATTERN.test(responseToken)) {
+            throw createProtocolError('native-renderer-session-token-invalid');
+        }
+        if (responseToken !== '-' &&
+            (responseToken !== sessionToken ||
+                (entry.kind === 'frame' && responseToken !== entry.sessionToken))) {
+            return;
+        }
+        const reason = decodeErrorReason(fields[4]);
+        takePending(requestId);
+        if (entry.kind === 'status') {
+            invalidateStatus(reason, entry);
+        } else {
+            settleFrameFailure(entry, reason);
+        }
+    }
+
+    function handleWebMessage(event) {
+        if (disposed || typeof event?.data !== 'string') return;
+        const fields = event.data.split('|');
+        if (fields[0] !== WIRE_PREFIX || fields.length < 3) return;
+
+        let requestId;
+        try {
+            parseCanonicalPositiveDecimal(fields[1], 'request-id');
+            requestId = fields[1];
+        } catch {
+            return;
+        }
+        const entry = pending.get(requestId);
+        if (!entry) return;
+
+        try {
+            if (fields[2] === 'status') {
+                handleStatusResponse(fields, requestId, entry);
+            } else if (fields[2] === 'response') {
+                handleFrameResponse(fields, requestId, entry);
+            } else if (fields[2] === 'error') {
+                handleErrorResponse(fields, requestId, entry);
+            } else {
+                throw createProtocolError('native-renderer-response-envelope-invalid');
+            }
+        } catch (error) {
+            const current = takePending(requestId);
+            if (current) settleMalformed(current, error);
+        }
+    }
+
+    function disposeBridge() {
+        if (disposed) return;
+        disposed = true;
+        statusChecked = false;
+        sessionToken = '';
+        status.ready = false;
+        status.backend = '';
+        status.lastError = 'native-renderer-bridge-disposed';
+        requireWebFallback();
+        try {
+            webview.removeEventListener?.('message', handleWebMessage);
+        } catch {
+        }
+        try {
+            window.removeEventListener?.('pagehide', disposeBridge);
+        } catch {
+        }
+        try {
+            window.removeEventListener?.('resize', handleViewportResize);
+        } catch {
+        }
+        try {
+            visualViewportTarget?.removeEventListener?.('resize', handleViewportResize);
+        } catch {
+        }
+        for (const [requestId, entry] of [...pending]) {
+            takePending(requestId);
+            if (entry.kind === 'status') {
+                entry.resolve(currentStatus());
+            } else {
+                if (countsAsFrame(entry.requestType)) status.rejectedFrames += 1;
+                entry.resolve(currentStatus({
+                    accepted: false,
+                    reason: 'native-renderer-bridge-disposed'
+                }));
+            }
+        }
+        notifyStatus();
+        statusListeners.clear();
+    }
+
+    const api = Object.freeze({
+        BUILD_ID,
+        getStatus,
+        onStatus,
+        sendSnapshot,
+        sendCamera,
+        detach,
+        setCompareLayer,
+        dispose: disposeBridge
+    });
+
+    const existingDesktop = window.mindExecDesktop;
+    let installed = false;
+    if (existingDesktop && (typeof existingDesktop === 'object' || typeof existingDesktop === 'function')) {
+        try {
+            existingDesktop.nativeRender = api;
+            installed = existingDesktop.nativeRender === api;
+        } catch {
+            installed = false;
+        }
+    }
+    if (!installed) {
+        try {
+            window.mindExecDesktop = Object.assign({}, existingDesktop || {}, { nativeRender: api });
+            installed = window.mindExecDesktop?.nativeRender === api;
+        } catch {
+            installed = false;
+        }
+    }
+    if (!installed) return;
+
+    if (root?.dataset) {
+        root.dataset.mindexecNativeDesktopStage = 'hybrid-compare';
+    }
+    writeCompareLayer('web');
+    webview.addEventListener('message', handleWebMessage);
+    window.addEventListener?.('pagehide', disposeBridge, { once: true });
+    window.addEventListener?.('resize', handleViewportResize);
+    visualViewportTarget?.addEventListener?.('resize', handleViewportResize);
+})();