@mindexec/cli 0.2.442 → 0.2.444

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.442",
+  "version": "0.2.444",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",
@@ -10,6 +10,9 @@
     "launch-bridge.cjs",
     "server.js",
     "remote-hub.js",
+    "lzo1x.js",
+    "mode4-atlas.js",
+    "mode4-atlas-worker.js",
     "codex-runtime.js",
     "codex-model-catalog.js",
     "port-guard.cjs",
@@ -59,11 +62,13 @@
     "node": ">=20"
   },
   "dependencies": {
+    "@ffmpeg-installer/ffmpeg": "^1.1.0",
     "@mindexec/remote": "^0.1.17",
     "@openai/codex-sdk": "^0.144.1",
     "chokidar": "^3.6.0",
     "cors": "^2.8.5",
     "express": "^4.18.2",
+    "ffmpeg-static": "^5.3.0",
     "multer": "^2.2.0",
     "playwright-core": "^1.53.0",
     "sharp": "^0.33.2",

package/remote-hub.js

@@ -60,6 +60,17 @@ const REMOTE_FRAME_MODE_PROFILES = Object.freeze({
         modeVersion: 1,
         implemented: true
     }),
+    'mode2-lzo': Object.freeze({
+        mode: 'mode2-lzo',
+        label: 'Mode 2 RGB565 LZO Wall',
+        transport: 'ws-binary',
+        encoding: 'image-raw',
+        codec: 'rgb565',
+        compression: 'lzo1x',
+        profile: 'mode2-lzo-rgb565-v1',
+        modeVersion: 2,
+        implemented: true
+    }),
     'mode3-h264-hw': Object.freeze({
         mode: 'mode3-h264-hw',
         label: 'Mode 3 H.264 Control',
@@ -103,6 +114,13 @@ const REMOTE_FRAME_MODE_ALIASES = new Map([
     ['remotequality', 'remote-quality'],
     ['remote_quality', 'remote-quality'],
     ['remote-quality', 'remote-quality'],
+    ['2', 'mode2-lzo'],
+    ['mode2', 'mode2-lzo'],
+    ['mode-2', 'mode2-lzo'],
+    ['mode2-lzo', 'mode2-lzo'],
+    ['lzo', 'mode2-lzo'],
+    ['lzo1x', 'mode2-lzo'],
+    ['rgb565', 'mode2-lzo'],
     ['mode3-h264', 'mode3-h264-hw'],
     ['mode3-h264-hw', 'mode3-h264-hw'],
     ['h264', 'mode3-h264-hw'],
@@ -2449,6 +2467,12 @@ export function createRemoteHub(options = {}) {
             fps: Number.isFinite(Number(message.fps)) ? Number(message.fps) : device.activeLiveStream.fps,
             streamPurpose: safeString(message.streamPurpose, 32),
             monitorIndex: Number.isFinite(Number(message.monitorIndex)) ? Number(message.monitorIndex) : 0,
+            monitorCount: Number.isFinite(Number(message.monitorCount)) ? Number(message.monitorCount) : 0,
+            pixelFormat: safeString(message.pixelFormat, 24),
+            bytesPerPixel: Number.isFinite(Number(message.bytesPerPixel)) ? Number(message.bytesPerPixel) : 0,
+            uncompressedByteLength: Number.isFinite(Number(message.uncompressedByteLength)) ? Number(message.uncompressedByteLength) : 0,
+            sourceWidth: Number.isFinite(Number(message.sourceWidth)) ? Number(message.sourceWidth) : 0,
+            sourceHeight: Number.isFinite(Number(message.sourceHeight)) ? Number(message.sourceHeight) : 0,
             h264Format: safeString(message.h264Format, 24),
             isKeyFrame: message.isKeyFrame === true,
             chunkType: safeString(message.chunkType, 24),
@@ -3260,9 +3284,11 @@ export function createRemoteHub(options = {}) {
 
             const now = new Date().toISOString();
             const streamId = safeString(options.streamId, 128) || `live-${Date.now()}`;
-            const fps = clampNumber(options.fps, 1, 30, 20);
+            const streamPurpose = safeString(options.streamPurpose, 32).toLowerCase();
+            const requestedMode = options.mode || (streamPurpose === 'control' ? 'mode3-h264-hw' : 'mode2-lzo');
+            const fps = clampNumber(options.fps, 1, 30, streamPurpose === 'control' ? 30 : 20);
             const commandId = safeString(options.commandId, 128) || crypto.randomUUID();
-            const transfer = buildRemoteFrameTransferDescriptor(options.mode || DEFAULT_REMOTE_FRAME_MODE);
+            const transfer = buildRemoteFrameTransferDescriptor(requestedMode, streamPurpose === 'control' ? 'mode3-h264-hw' : 'mode2-lzo');
             device.counters.commandsSent += 1;
             device.activeLiveStream = {
                 streamId,
@@ -3281,6 +3307,7 @@ export function createRemoteHub(options = {}) {
                 transferProtocolVersion: transfer.transferProtocolVersion,
                 handshake: transfer.handshake,
                 fps,
+                streamPurpose,
                 startedAt: now,
                 stoppedAt: '',
                 stopReason: '',
@@ -3314,9 +3341,11 @@ export function createRemoteHub(options = {}) {
 
         const now = new Date().toISOString();
         const streamId = safeString(options.streamId, 128) || `live-${Date.now()}`;
-        const fps = clampNumber(options.fps, 1, 30, 20);
+        const streamPurpose = safeString(options.streamPurpose, 32).toLowerCase();
+        const requestedMode = options.mode || (streamPurpose === 'control' ? 'mode3-h264-hw' : 'mode2-lzo');
+        const fps = clampNumber(options.fps, 1, 30, streamPurpose === 'control' ? 30 : 20);
         const commandId = safeString(options.commandId, 128) || crypto.randomUUID();
-        const transfer = buildRemoteFrameTransferDescriptor(options.mode || DEFAULT_REMOTE_FRAME_MODE);
+        const transfer = buildRemoteFrameTransferDescriptor(requestedMode, streamPurpose === 'control' ? 'mode3-h264-hw' : 'mode2-lzo');
         const result = sendCommand(deviceId, {
             command: 'stream.start',
             commandId,
@@ -3331,6 +3360,7 @@ export function createRemoteHub(options = {}) {
                 transferProtocol: transfer.transferProtocol,
                 transferProtocolVersion: transfer.transferProtocolVersion,
                 handshake: transfer.handshake,
+                streamPurpose,
                 fps,
                 maxWidth: clampNumber(options.maxWidth, 320, 2560, 960),
                 maxHeight: clampNumber(options.maxHeight, 180, 1440, 540),
@@ -3360,6 +3390,7 @@ export function createRemoteHub(options = {}) {
             transferProtocolVersion: transfer.transferProtocolVersion,
             handshake: transfer.handshake,
             fps,
+            streamPurpose,
             startedAt: now,
             stoppedAt: '',
             stopReason: '',

package/server.js

@@ -24,6 +24,7 @@ import { fileURLToPath } from 'url';
 import { createCodexRuntime } from './codex-runtime.js';
 import { createCodexModelCatalog } from './codex-model-catalog.js';
 import { createRemoteHub } from './remote-hub.js';
+import { Mode4AtlasSession } from './mode4-atlas.js';
 import portGuard from './port-guard.cjs';
 
 const execAsync = promisify(exec);
@@ -2399,12 +2400,15 @@ app.get('/api/local-files/:id', async (req, res) => {
 const httpServer = createServer(app);
 const wss = new WebSocketServer({ noServer: true });
 const remoteFrameWss = new WebSocketServer({ noServer: true });
+const remoteAtlasWss = new WebSocketServer({ noServer: true });
 const remoteInputWss = new WebSocketServer({ noServer: true });
 const wsClients = new Set();
 const remoteFrameClients = new Set();
+const remoteAtlasClients = new Map();
 const remoteInputClients = new Set();
 const shellJobs = new Map();
 let remoteFrameClientSeq = 0;
+let remoteAtlasClientSeq = 0;
 let remoteInputClientSeq = 0;
 const remoteFrameWsDiagnostics = {
     opened: 0,
@@ -2480,6 +2484,14 @@ httpServer.on('upgrade', (req, socket, head) => {
             return;
         }
 
+        if (parsed.pathname === '/api/remote/atlas/ws'
+            && (!bridgeAuthRequired || token === bridgeToken)) {
+            remoteAtlasWss.handleUpgrade(req, socket, head, (ws) => {
+                remoteAtlasWss.emit('connection', ws, req);
+            });
+            return;
+        }
+
         if (parsed.pathname === '/api/remote/input/ws'
             && (!bridgeAuthRequired || token === bridgeToken)) {
             remoteInputWss.handleUpgrade(req, socket, head, (ws) => {
@@ -2581,8 +2593,9 @@ function clampRemoteFrameWsNumber(value, min, max, fallback) {
 }
 
 function normalizeRemoteFrameWsLiveOptions(payload = {}) {
-    const mode = String(payload.frameMode || payload.mode || 'remote-fast').trim() || 'remote-fast';
     const streamPurpose = String(payload.streamPurpose || '').trim().toLowerCase();
+    const defaultMode = streamPurpose === 'control' ? 'mode3-h264-hw' : 'mode2-lzo';
+    const mode = String(payload.frameMode || payload.mode || defaultMode).trim() || defaultMode;
     const defaultFps = streamPurpose === 'control' || mode === 'mode3-h264-hw' ? 30 : REMOTE_FRAME_WS_DEFAULT_FPS;
     return {
         fps: clampRemoteFrameWsNumber(payload.fps, 1, 30, defaultFps),
@@ -2725,6 +2738,12 @@ function buildRemoteFrameBinaryPacket(frameEvent) {
         sameContentStreak: Number(frame.sameContentStreak || 0) || 0,
         streamPurpose: frame.streamPurpose || '',
         monitorIndex: Number.isFinite(Number(frame.monitorIndex)) ? Number(frame.monitorIndex) : 0,
+        monitorCount: Number.isFinite(Number(frame.monitorCount)) ? Number(frame.monitorCount) : 0,
+        pixelFormat: frame.pixelFormat || '',
+        bytesPerPixel: Number.isFinite(Number(frame.bytesPerPixel)) ? Number(frame.bytesPerPixel) : 0,
+        uncompressedByteLength: Number.isFinite(Number(frame.uncompressedByteLength)) ? Number(frame.uncompressedByteLength) : 0,
+        sourceWidth: Number.isFinite(Number(frame.sourceWidth)) ? Number(frame.sourceWidth) : 0,
+        sourceHeight: Number.isFinite(Number(frame.sourceHeight)) ? Number(frame.sourceHeight) : 0,
         codec: frame.codec || '',
         h264Format: frame.h264Format || '',
         isKeyFrame: frame.isKeyFrame === true,
@@ -2733,6 +2752,15 @@ function buildRemoteFrameBinaryPacket(frameEvent) {
         durationUs: Number.isFinite(Number(frame.durationUs)) ? Number(frame.durationUs) : 0,
         streamFrameSeq: Number.isFinite(Number(frame.streamFrameSeq)) ? Number(frame.streamFrameSeq) : 0,
         commandId: frame.commandId || ''
+        ,layoutVersion: Number(frame.layoutVersion || 0) || 0
+        ,atlasComposeMs: Number(frame.atlasComposeMs || 0) || 0
+        ,atlasPoolStarved: Number(frame.atlasPoolStarved || 0) || 0
+        ,atlasReadyTiles: Number(frame.atlasReadyTiles || 0) || 0
+        ,atlasTileCount: Number(frame.atlasTileCount || 0) || 0
+        ,hardwareEncoder: frame.hardwareEncoder || ''
+        ,platformProfile: frame.platformProfile || ''
+        ,workerGeneration: Number(frame.workerGeneration || 0) || 0
+        ,encoderGeneration: Number(frame.encoderGeneration || 0) || 0
     };
     const metaBuffer = Buffer.from(JSON.stringify(metadata), 'utf8');
     const header = Buffer.allocUnsafe(4);
@@ -2740,7 +2768,84 @@ function buildRemoteFrameBinaryPacket(frameEvent) {
     return Buffer.concat([header, metaBuffer, payload], header.length + metaBuffer.length + payload.length);
 }
 
+function sendMode4AtlasFrame(ws, output) {
+    if (!ws || ws.readyState !== 1 || !output?.payload?.length) return;
+    const metadata = output.metadata || {};
+    const frameSeq = Number(metadata.frameSeq || 0) || 0;
+    const isKeyFrame = metadata.isKeyFrame === true;
+    const workerGeneration = Math.max(1, Number(metadata.workerGeneration || 1) || 1);
+    const encoderGeneration = Math.max(1, Number(metadata.encoderGeneration || 1) || 1);
+    const streamId = `${ws.remoteAtlasStreamId}-w${workerGeneration}-e${encoderGeneration}`;
+    const width = Number(metadata.width || 1920) || 1920;
+    const height = Number(metadata.height || 1080) || 1080;
+    const frameEvent = {
+        kind: 'live',
+        deviceId: '__mindexec_mode4_atlas__',
+        mimeType: 'video/h264',
+        byteLength: output.payload.length,
+        payload: output.payload,
+        frame: {
+            deviceId: '__mindexec_mode4_atlas__', frameSeq,
+            streamFrameSeq: Number(metadata.streamFrameSeq || frameSeq) || frameSeq,
+            streamId, commandId: streamId, width, height,
+            sourceWidth: width, sourceHeight: height,
+            mimeType: 'video/h264', mode: 'mode4-h264-atlas', frameMode: 'mode4-h264-atlas',
+            frameProfile: 'mode4-h264-atlas-v1', encoding: 'video-atlas', codec: 'h264',
+            compression: 'video/h264', h264Format: 'annexb', isKeyFrame,
+            chunkType: isKeyFrame ? 'key' : 'delta',
+            timestampUs: Number(metadata.timestampUs || 0), durationUs: Number(metadata.durationUs || 0),
+            fps: Number(metadata.fps || 20), capturedAt: new Date().toISOString(), receivedAt: new Date().toISOString(),
+            hardwareEncoder: String(metadata.hardwareEncoder || ''), platformProfile: 'mode4-hub-atlas-worker',
+            workerGeneration, encoderGeneration, layoutVersion: Number(metadata.layoutVersion || 0),
+            atlasComposeMs: Number(metadata.composeMs || 0), atlasPoolStarved: Number(metadata.poolStarved || 0),
+            atlasReadyTiles: Number(metadata.readyTileCount || 0), atlasTileCount: Number(metadata.tileCount || 0)
+        }
+    };
+    const packet = buildRemoteFrameBinaryPacket(frameEvent);
+    if (!packet || ws.bufferedAmount > 8 * 1024 * 1024) return;
+    try { ws.send(packet, { binary: true }); } catch { /* client closed */ }
+}
+
+function normalizeRemoteAtlasMonitorSelections(value) {
+    if (!value || typeof value !== 'object') return {};
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) result[String(key)] = Math.max(0, Number(entry) || 0);
+    return result;
+}
+
+function configureMode4Atlas(ws, payload = {}) {
+    const deviceIds = normalizeRemoteFrameWsDeviceIds(payload.deviceIds ?? payload.devices ?? payload.deviceId).slice(0, 100);
+    const monitorSelections = normalizeRemoteAtlasMonitorSelections(payload.monitorSelections);
+    const sharpTiles = Number(payload.tileWidth) >= 480 || Number(payload.tileHeight) >= 270;
+    const tileWidth = sharpTiles ? 480 : 320;
+    const tileHeight = sharpTiles ? 270 : 180;
+    ws.remoteAtlasDeviceIds = new Set(deviceIds);
+    ws.remoteAtlasInputOptions = { tileWidth, tileHeight, monitorSelections };
+    ws.remoteAtlasSession.configure({
+        deviceIds,
+        width: clampRemoteFrameWsNumber(payload.width, 640, 3840, 1920),
+        height: clampRemoteFrameWsNumber(payload.height, 360, 2160, 1080),
+        tileWidth, tileHeight,
+        fps: clampRemoteFrameWsNumber(payload.fps, 1, 30, 20)
+    });
+    for (const deviceId of deviceIds) startMode4AtlasInput(ws, deviceId, 'atlas-configure');
+    sendRemoteFrameClientJson(ws, { type: 'Mode4AtlasSubscription', deviceIds, inputMode: 'mode2-lzo', outputMode: 'mode4-h264-atlas', tileWidth, tileHeight, timestamp: new Date().toISOString() });
+}
+
+function startMode4AtlasInput(ws, deviceId, reason = 'atlas-configure') {
+    const options = ws?.remoteAtlasInputOptions;
+    if (!options || !ws.remoteAtlasDeviceIds?.has(deviceId)) return { ok: false, error: 'atlas-device-not-configured' };
+    return remoteHub.startLiveStream(deviceId, {
+        fps: 8, maxWidth: options.tileWidth, maxHeight: options.tileHeight, quality: 60,
+        mode: 'mode2-lzo', frameMode: 'mode2-lzo', streamPurpose: 'atlas',
+        monitorIndex: Number(options.monitorSelections?.[deviceId] || 0),
+        streamId: `atlas-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+        restartReason: reason
+    });
+}
+
 function broadcastRemoteBinaryFrame(frameEvent) {
+    for (const session of remoteAtlasClients.values()) session.ingest(frameEvent);
     const frame = frameEvent?.frame || {};
     remoteFrameWsDiagnostics.framesReceived += 1;
     remoteFrameWsDiagnostics.lastFrameAt = new Date().toISOString();
@@ -2901,6 +3006,44 @@ remoteFrameWss.on('connection', (ws, req) => {
     });
 });
 
+remoteAtlasWss.on('connection', (ws) => {
+    ws.binaryType = 'arraybuffer';
+    ws.remoteAtlasClientId = `ratlas-${++remoteAtlasClientSeq}`;
+    ws.remoteAtlasStreamId = `mode4-atlas-${crypto.randomUUID()}`;
+    try { ws._socket?.setNoDelay?.(true); } catch { /* ignore */ }
+    const session = new Mode4AtlasSession({
+        onFrame: output => sendMode4AtlasFrame(ws, output),
+        onLayout: layout => sendRemoteFrameClientJson(ws, { ...layout, type: 'Mode4AtlasLayout' }),
+        onStatus: status => sendRemoteFrameClientJson(ws, { ...status, type: 'Mode4AtlasStatus' })
+    });
+    ws.remoteAtlasSession = session;
+    remoteAtlasClients.set(ws, session);
+    let cleaned = false;
+    const cleanup = () => {
+        if (cleaned) return;
+        cleaned = true;
+        remoteAtlasClients.delete(ws);
+        session.close();
+        ws.remoteAtlasSession = null;
+    };
+    ws.on('message', data => {
+        try {
+            const payload = JSON.parse(Buffer.isBuffer(data) ? data.toString('utf8') : String(data || ''));
+            if (payload?.type === 'subscribe' || payload?.type === 'configure') configureMode4Atlas(ws, payload);
+        } catch {
+            sendRemoteFrameClientJson(ws, { type: 'Mode4AtlasError', error: 'invalid-message' });
+        }
+    });
+    ws.on('close', cleanup);
+    ws.on('error', cleanup);
+    sendRemoteFrameClientJson(ws, {
+        type: 'Mode4AtlasSocketReady',
+        protocol: 'mindexec.remote.atlas.h264.v1',
+        clientId: ws.remoteAtlasClientId,
+        timestamp: new Date().toISOString()
+    });
+});
+
 function sendRemoteInputClientJson(ws, payload) {
     if (!ws || ws.readyState !== WebSocket.OPEN) {
         return false;
@@ -12411,6 +12554,7 @@ app.get('/api/status', async (req, res) => {
         wsToken,
         wsPath: '/events',
         remoteFrameWsPath: '/api/remote/frames/ws',
+        remoteAtlasWsPath: '/api/remote/atlas/ws',
         remoteInputWsPath: '/api/remote/input/ws',
         bridgeToken,
         bridgeTokenHeader,
@@ -12819,9 +12963,11 @@ app.get('/api/remote/devices/:deviceId/live/frame', (req, res) => {
 });
 
 app.post('/api/remote/devices/:deviceId/live/start', (req, res) => {
+    const streamPurpose = String(req.body?.streamPurpose || '').trim().toLowerCase();
     res.json(remoteHub.startLiveStream(req.params.deviceId, {
         streamId: req.body?.streamId,
-        mode: req.body?.frameMode || req.body?.mode || 'mode3-h264-hw',
+        mode: req.body?.frameMode || req.body?.mode || (streamPurpose === 'control' ? 'mode3-h264-hw' : 'mode2-lzo'),
+        streamPurpose,
         fps: req.body?.fps,
         maxWidth: req.body?.maxWidth,
         maxHeight: req.body?.maxHeight,
@@ -14333,6 +14479,14 @@ async function shutdownBridge(signal) {
         }
     }
 
+    for (const client of remoteAtlasClients.keys()) {
+        try { client.close(); } catch { /* Ignore close race */ }
+    }
+    for (const session of remoteAtlasClients.values()) {
+        try { session.close(); } catch { /* Ignore atlas worker shutdown errors */ }
+    }
+    remoteAtlasClients.clear();
+
     for (const client of remoteInputClients) {
         try {
             client.close();
@@ -14347,6 +14501,12 @@ async function shutdownBridge(signal) {
         // Ignore if already closed
     }
 
+    try {
+        remoteAtlasWss.close();
+    } catch {
+        // Ignore if already closed
+    }
+
     try {
         remoteInputWss.close();
     } catch {

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

@@ -15955,7 +15955,7 @@
             maxWidth: Number(options.maxWidth || 960) || 960,
             maxHeight: Number(options.maxHeight || 540) || 540,
             quality: Number(options.quality || 60) || 60,
-            mode: String(options.mode || 'mode3-h264-hw'),
+            mode: String(options.mode || 'mode2-lzo'),
             streamPurpose: String(options.streamPurpose || 'wall')
         };
         bodyView._remoteFleetBinaryFrameSession = session;
@@ -17192,13 +17192,15 @@
     function applyRemoteFleetFramePatchToPreview(preview, frame) {
         if (frame?._remoteFleetBinaryFrame === true
             && frame?._remoteFleetPayloadBlob
-            && String(frame.codec || '').toLowerCase().includes('h264')
-            && window.MindExecRemoteCodecs?.decodeH264Frame) {
+            && (String(frame.codec || '').toLowerCase().includes('h264')
+                || (String(frame.frameMode || frame.mode || '').toLowerCase() === 'mode2-lzo'
+                    && String(frame.compression || '').toLowerCase() === 'lzo1x'))
+            && window.MindExecRemoteCodecs?.decodeFrame) {
             const canvas = ensureRemoteFleetFrameCanvas(preview);
             if (canvas) {
                 canvas.style.display = 'block';
                 preview.querySelector?.('img[data-remote-fleet-frame-image="true"]')?.style.setProperty('display', 'none');
-                window.MindExecRemoteCodecs.decodeH264Frame(canvas, frame).catch?.(() => undefined);
+                window.MindExecRemoteCodecs.decodeFrame(canvas, frame).catch?.(() => undefined);
                 preview.dataset.remoteFleetFrameKind = String(frame.kind || 'live').toLowerCase();
                 preview.dataset.remoteFleetFrameSeq = String(frame.frameSeq || 0);
                 return true;
@@ -17535,9 +17537,11 @@
         }
 
         if (frame._remoteFleetPayloadBlob
-            && String(frame.codec || '').toLowerCase().includes('h264')
-            && window.MindExecRemoteCodecs?.decodeH264Frame) {
-            const painted = await window.MindExecRemoteCodecs.decodeH264Frame(session.canvas, frame);
+            && (String(frame.codec || '').toLowerCase().includes('h264')
+                || (String(frame.frameMode || frame.mode || '').toLowerCase() === 'mode2-lzo'
+                    && String(frame.compression || '').toLowerCase() === 'lzo1x'))
+            && window.MindExecRemoteCodecs?.decodeFrame) {
+            const painted = await window.MindExecRemoteCodecs.decodeFrame(session.canvas, frame);
             if (painted && session.active) {
                 session.canvas.dataset.remoteFleetFrameKind = 'live';
                 session.canvas.dataset.remoteFleetFrameSeq = String(frameSeq || 0);
@@ -20717,7 +20721,7 @@
                 maxWidth: 960,
                 maxHeight: 540,
                 quality: 60,
-                mode: 'mode3-h264-hw',
+                mode: 'mode2-lzo',
                 streamPurpose: 'wall'
             });
             if (!binaryFrameSocketStarted) {

package/wwwroot/_content/MindExecution.Shared/js/mind-map-remote-codecs.js

@@ -3,6 +3,7 @@
 
     const decoderByCanvas = new WeakMap();
     const MAX_DECODE_QUEUE = 3;
+    const rawFrameByCanvas = new WeakMap();
 
     function emit(type, data) {
         window.RuntimeTrace?.emit?.(type, data);
@@ -30,6 +31,73 @@
         state.pending = 0;
     }
 
+    // LiveDesk Mode 2 payloads are LZO1X-compressed little-endian RGB565.
+    // Keep this decoder local to the wall path so H.264 control surfaces remain
+    // fully independent.
+    function decodeLzo1x(input, outputLength) {
+        if (!(input instanceof Uint8Array) || input.length < 3) throw new Error('Invalid LZO1X block');
+        const output = new Uint8Array(outputLength);
+        const s = { i: 0, o: 0 };
+        const need = (n) => { if (s.i + n > input.length) throw new Error('LZO input overrun'); };
+        const literals = (n) => {
+            need(n);
+            if (s.o + n > output.length) throw new Error('LZO output overrun');
+            output.set(input.subarray(s.i, s.i + n), s.o); s.i += n; s.o += n;
+        };
+        const ext = (basis) => { let zeros = 0; while (true) { need(1); if (input[s.i] !== 0) break; zeros++; s.i++; } return zeros * 255 + basis + input[s.i++]; };
+        const match = (at, length) => {
+            const distance = s.o - at;
+            if (distance <= 0 || s.o + length > output.length) throw new Error('LZO match overrun');
+            for (let n = 0; n < length; n++) output[s.o++] = output[at + (n % distance)];
+        };
+        let state = 0; let matchLength = 0;
+        if (input[0] >= 22) { s.i++; literals(input[0] - 17); state = 4; }
+        else if (input[0] >= 18) { s.i++; state = input[0] - 17; literals(state); }
+        while (true) {
+            need(1); const instruction = input[s.i++]; let nextState; let at;
+            if ((instruction & 0xc0) !== 0) {
+                need(1); at = s.o - ((input[s.i++] << 3) + ((instruction >> 2) & 7) + 1); matchLength = (instruction >> 5) + 1; nextState = instruction & 3;
+            } else if ((instruction & 0x20) !== 0) {
+                matchLength = (instruction & 0x1f) + 2; if (matchLength === 2) matchLength += ext(31); need(2); const encoded = input[s.i++] | (input[s.i++] << 8); at = s.o - ((encoded >> 2) + 1); nextState = encoded & 3;
+            } else if ((instruction & 0x10) !== 0) {
+                matchLength = (instruction & 7) + 2; if (matchLength === 2) matchLength += ext(7); need(2); const encoded = input[s.i++] | (input[s.i++] << 8); at = s.o - (((instruction & 8) << 11) + (encoded >> 2)); nextState = encoded & 3; if (at === s.o) break; at -= 0x4000;
+            } else if (state === 0) {
+                let length = instruction + 3; if (length === 3) length += ext(15); literals(length); state = 4; continue;
+            } else {
+                need(1); nextState = instruction & 3; at = s.o - ((instruction >> 2) + (input[s.i++] << 2) + (state === 4 ? 2049 : 1)); matchLength = state === 4 ? 3 : 2;
+            }
+            if (at < 0 || s.o + matchLength + nextState > output.length) throw new Error('LZO lookbehind overrun');
+            match(at, matchLength); state = nextState; literals(nextState);
+        }
+        if (matchLength !== 3 || s.i !== input.length || s.o !== output.length) throw new Error('Incomplete LZO block');
+        return output;
+    }
+
+    async function decodeMode2Frame(canvas, frame) {
+        const payload = frame?._remoteFleetPayloadBlob;
+        if (!canvas || !payload) return false;
+        const width = Math.max(1, Number(frame.width || 0) | 0);
+        const height = Math.max(1, Number(frame.height || 0) | 0);
+        const expected = width * height * 2;
+        if (Number(frame.bytesPerPixel || 2) !== 2 || (Number(frame.uncompressedByteLength || expected) !== expected)) return false;
+        const state = rawFrameByCanvas.get(canvas) || { lastSeq: 0 };
+        const seq = Number(frame.streamFrameSeq || frame.frameSeq || 0) || 0;
+        if (seq > 0 && seq <= state.lastSeq) return true;
+        const compressed = new Uint8Array(await payload.arrayBuffer());
+        const rgb565 = decodeLzo1x(compressed, expected);
+        const rgba = new Uint8ClampedArray(width * height * 4);
+        for (let source = 0, target = 0; source < rgb565.length; source += 2, target += 4) {
+            const pixel = rgb565[source] | (rgb565[source + 1] << 8);
+            const r = (pixel >> 11) & 31; const g = (pixel >> 5) & 63; const b = pixel & 31;
+            rgba[target] = (r << 3) | (r >> 2); rgba[target + 1] = (g << 2) | (g >> 4); rgba[target + 2] = (b << 3) | (b >> 2); rgba[target + 3] = 255;
+        }
+        canvas.width = width; canvas.height = height;
+        canvas.getContext('2d', { alpha: false, desynchronized: true })?.putImageData(new ImageData(rgba, width, height), 0, 0);
+        state.lastSeq = seq; rawFrameByCanvas.set(canvas, state);
+        emit('remote.mode2.paint', { frameSeq: seq, width, height });
+        return true;
+    }
+
     function ensureDecoder(canvas, frame, state) {
         if (typeof VideoDecoder !== 'function' || typeof EncodedVideoChunk !== 'function') {
             return null;
@@ -88,9 +156,14 @@
 
     async function decode(canvas, frame) {
         const payload = frame?._remoteFleetPayloadBlob;
-        if (!canvas || !payload || !String(frame?.codec || '').toLowerCase().includes('h264')) {
+        if (!canvas || !payload) {
             return false;
         }
+        const mode = String(frame?.frameMode || frame?.mode || '').toLowerCase();
+        if (mode === 'mode2-lzo' || String(frame?.compression || '').toLowerCase() === 'lzo1x' || String(frame?.mimeType || '').toLowerCase() === 'application/vnd.livedesk.lzo-rgb565') {
+            try { return await decodeMode2Frame(canvas, frame); } catch (error) { emit('remote.mode2.decodeFailed', { error: error?.message || String(error || '') }); return false; }
+        }
+        if (!String(frame?.codec || '').toLowerCase().includes('h264')) return false;
         const state = getDecoderState(canvas);
         const seq = Number(frame.streamFrameSeq || frame.frameSeq || 0) || 0;
         if (seq > 0 && seq <= state.lastSeq) return true;
@@ -122,5 +195,5 @@
         }
     }
 
-    window.MindExecRemoteCodecs = Object.freeze({ decodeH264Frame: decode });
+    window.MindExecRemoteCodecs = Object.freeze({ decodeH264Frame: decode, decodeFrame: decode });
 })();

package/wwwroot/_framework/blazor.boot.json

@@ -1,7 +1,7 @@
 {
   "mainAssemblyName": "MindExecution.Web",
   "resources": {
-    "hash": "sha256-WNzAmWuVhn9JyBiHwwIttruk/GbsVNnakpghIldcLg8=",
+    "hash": "sha256-vyIwPs5NXG0WvUn1crlwB/OCRyxH6tUNE8CXfOaHuOI=",
     "fingerprinting": {
       "Google.Protobuf.9h59ukbel7.dll": "Google.Protobuf.dll",
       "Markdig.d1j7v41cl1.dll": "Markdig.dll",
@@ -122,16 +122,16 @@
       "System.brmz7yk5qh.dll": "System.dll",
       "netstandard.b50t77veor.dll": "netstandard.dll",
       "System.Private.CoreLib.g6ztz7cmo2.dll": "System.Private.CoreLib.dll",
-      "MindExecution.Core.nxjlewduna.dll": "MindExecution.Core.dll",
-      "MindExecution.Kernel.vrfi63yg9f.dll": "MindExecution.Kernel.dll",
-      "MindExecution.Plugins.Admin.1rcwhdxl0r.dll": "MindExecution.Plugins.Admin.dll",
-      "MindExecution.Plugins.Business.rx0eieg51y.dll": "MindExecution.Plugins.Business.dll",
-      "MindExecution.Plugins.Concept.zzczjzhvk1.dll": "MindExecution.Plugins.Concept.dll",
-      "MindExecution.Plugins.Directory.bsorcntiwp.dll": "MindExecution.Plugins.Directory.dll",
-      "MindExecution.Plugins.PlanMaster.i5j9t4f1jf.dll": "MindExecution.Plugins.PlanMaster.dll",
-      "MindExecution.Plugins.YouTube.1mpn9satft.dll": "MindExecution.Plugins.YouTube.dll",
-      "MindExecution.Shared.mpi1gzau9b.dll": "MindExecution.Shared.dll",
-      "MindExecution.Web.nxykcyxd02.dll": "MindExecution.Web.dll",
+      "MindExecution.Core.4moacskf64.dll": "MindExecution.Core.dll",
+      "MindExecution.Kernel.pa251cfsz4.dll": "MindExecution.Kernel.dll",
+      "MindExecution.Plugins.Admin.dxyuwmxv1s.dll": "MindExecution.Plugins.Admin.dll",
+      "MindExecution.Plugins.Business.7uj5erqhhn.dll": "MindExecution.Plugins.Business.dll",
+      "MindExecution.Plugins.Concept.108rmsxc96.dll": "MindExecution.Plugins.Concept.dll",
+      "MindExecution.Plugins.Directory.ccsy3g0fe5.dll": "MindExecution.Plugins.Directory.dll",
+      "MindExecution.Plugins.PlanMaster.1vjpuoe9ff.dll": "MindExecution.Plugins.PlanMaster.dll",
+      "MindExecution.Plugins.YouTube.q8ml98phj9.dll": "MindExecution.Plugins.YouTube.dll",
+      "MindExecution.Shared.2pywq19zjy.dll": "MindExecution.Shared.dll",
+      "MindExecution.Web.qucbls1wfr.dll": "MindExecution.Web.dll",
       "dotnet.native.566r55w3xu.js": "dotnet.native.js",
       "dotnet.native.x6q5aixc38.wasm": "dotnet.native.wasm",
       "dotnet.js": "dotnet.js",
@@ -276,18 +276,18 @@
       "System.Xml.XDocument.sn51jas17n.dll": "sha256-GNI2kFgFmPTwzuzwUn8gxK+AzGLUWRJFdg9JzIbrybQ=",
       "System.brmz7yk5qh.dll": "sha256-CfM2miyj1KHApFmqMdLYWio3S/jrdON2pW9Xr2nTwlo=",
       "netstandard.b50t77veor.dll": "sha256-//jQGOXjb8ET8WtXgOJrAxLx6E7zDJ5RjRRutwkvmxo=",
-      "MindExecution.Core.nxjlewduna.dll": "sha256-K/aYKYR7u21eWdPhsuyT3DfAcldItQ9fUJDpyAW1Yk8=",
-      "MindExecution.Kernel.vrfi63yg9f.dll": "sha256-pQ3AG4I0yHOE+LjWf41pPTzD6WAPx5QEVQR99tgmjv8=",
-      "MindExecution.Plugins.Business.rx0eieg51y.dll": "sha256-wXky9gfkYuS9LpiAJcaHL2ySg388QTlafZ7dDYaYGkc=",
-      "MindExecution.Plugins.Concept.zzczjzhvk1.dll": "sha256-caSJdsMUA/y2XoLlC69Ml7LVPyEklu9iUqK8LbLH/Ac=",
-      "MindExecution.Plugins.PlanMaster.i5j9t4f1jf.dll": "sha256-NsaH6mfDGUtq96FRS/yR+b5QyLzjVWublyCQBKugpss=",
-      "MindExecution.Shared.mpi1gzau9b.dll": "sha256-Bk/J98QCHrurXfAfiETiavqv5g5jXQ73yvEdYibuIrU=",
-      "MindExecution.Web.nxykcyxd02.dll": "sha256-JW4hqFR8NT2yFKIvMflIhM8Wks9Dec4w+0ofv69tU6w="
+      "MindExecution.Core.4moacskf64.dll": "sha256-5OiBWkHcOvL4NsaHtQ7O3z5N1Ba7nTRi3xkehUMMgkE=",
+      "MindExecution.Kernel.pa251cfsz4.dll": "sha256-4dswyE6zmKAS+CnExpbXK871UMxIp+a7SPMIMwmZ+2Q=",
+      "MindExecution.Plugins.Business.7uj5erqhhn.dll": "sha256-URKvk2etEOiEa/URXJpkYx7aJcPQd1Xs0Yxn3Uqg/ok=",
+      "MindExecution.Plugins.Concept.108rmsxc96.dll": "sha256-QTd+zvSVcfwz3gYaKZ3pP0wgxrj9R1aP6qQKsByDRR0=",
+      "MindExecution.Plugins.PlanMaster.1vjpuoe9ff.dll": "sha256-M3Fvm8WU5xbx24cTyACzH1IuZXuIY06dkeCfNCgeUT4=",
+      "MindExecution.Shared.2pywq19zjy.dll": "sha256-Wjp+pPwb4TDj0YtYTzvNQGIzQI7xAg9DeyO0g/jxyxU=",
+      "MindExecution.Web.qucbls1wfr.dll": "sha256-0kpuM4z2XvRReo2Eiy7cJ/SAfoF/dVnn6WChaz//lGc="
     },
     "lazyAssembly": {
-      "MindExecution.Plugins.Admin.1rcwhdxl0r.dll": "sha256-jV0N8WevIxIidWNinjH1vZ+NS+eKshBtlZpvb6vCfmg=",
-      "MindExecution.Plugins.Directory.bsorcntiwp.dll": "sha256-O07lrIPzxWQRivTDifZBsSoG+ZMptwdu2Ey2e9sF0M0=",
-      "MindExecution.Plugins.YouTube.1mpn9satft.dll": "sha256-l6UnB6LB9UHscjF/q5j8F2fKCunQ63w6mkwEEuWK3tg="
+      "MindExecution.Plugins.Admin.dxyuwmxv1s.dll": "sha256-URTQOP1nUuBC2leUgGdGWb+rc/1blCxbpbhRGE1MW/I=",
+      "MindExecution.Plugins.Directory.ccsy3g0fe5.dll": "sha256-BFk4mut2rsioBC9unD8+BoxnoJqTJlS5uZV7uXr8i5E=",
+      "MindExecution.Plugins.YouTube.q8ml98phj9.dll": "sha256-2vzs6nizBsYO1JjXPxdSi6O7uyZLpqFblwE0q09mvfw="
     }
   },
   "cacheBootResources": true,

package/wwwroot/index.html

@@ -579,7 +579,7 @@
             }
 
             const base = '_content/MindExecution.Shared/js/';
-            const scriptVersion = '20260717-livedesk-h264-transport-v936';
+            const scriptVersion = '20260717-livedesk-wall-lzo-control-h264-v937';
             const scriptUrl = (script) => `${base}${script}?v=${scriptVersion}`;
             console.log(`[Script Loader] Shared JS version: ${scriptVersion}`);
             const criticalScripts = [