@mindexec/cli 0.2.121 → 0.2.123

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.121",
+  "version": "0.2.123",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",

package/scripts/remote-fleet-render-smoke.mjs

@@ -95,6 +95,10 @@ class MiniElement {
         this.value = '';
         this.checked = false;
         this.disabled = false;
+        this.clientWidth = 320;
+        this.clientHeight = 180;
+        this.width = 0;
+        this.height = 0;
     }
 
     get textContent() {
@@ -182,6 +186,44 @@ class MiniElement {
         return true;
     }
 
+    getBoundingClientRect() {
+        return {
+            left: 0,
+            top: 0,
+            right: this.clientWidth,
+            bottom: this.clientHeight,
+            width: this.clientWidth,
+            height: this.clientHeight
+        };
+    }
+
+    getContext(type) {
+        if (this.tagName !== 'CANVAS' || String(type || '').toLowerCase() !== '2d') {
+            return null;
+        }
+
+        if (this._canvasContext) {
+            return this._canvasContext;
+        }
+
+        const owner = this.ownerDocument;
+        this._canvasContext = {
+            imageSmoothingEnabled: false,
+            imageSmoothingQuality: 'low',
+            fillStyle: '#000',
+            clearRect: (...args) => {
+                owner.canvasDrawCalls.push({ canvas: this, op: 'clearRect', args });
+            },
+            fillRect: (...args) => {
+                owner.canvasDrawCalls.push({ canvas: this, op: 'fillRect', args });
+            },
+            drawImage: (...args) => {
+                owner.canvasDrawCalls.push({ canvas: this, op: 'drawImage', args });
+            }
+        };
+        return this._canvasContext;
+    }
+
     querySelector(selector) {
         return this.querySelectorAll(selector)[0] || null;
     }
@@ -225,6 +267,7 @@ class MiniDocument {
     constructor() {
         this.body = new MiniElement('body', this);
         this.head = new MiniElement('head', this);
+        this.canvasDrawCalls = [];
     }
 
     createElement(tagName) {
@@ -373,6 +416,17 @@ async function loadCss3DManager() {
     const managerPath = path.resolve(__dirname, '../../MindExecution.Shared/wwwroot/js/mind-map-css3d-manager.js');
     const source = await fs.readFile(managerPath, 'utf8');
     const document = new MiniDocument();
+    const objectUrlCalls = [];
+    const revokedObjectUrls = [];
+    const imageBitmapCalls = [];
+    class SmokeURL extends URL {}
+    SmokeURL.createObjectURL = blob => {
+        objectUrlCalls.push(blob);
+        return `blob:remote-fleet-smoke-${objectUrlCalls.length}`;
+    };
+    SmokeURL.revokeObjectURL = value => {
+        revokedObjectUrls.push(String(value || ''));
+    };
     const context = {
         console,
         document,
@@ -397,15 +451,36 @@ async function loadCss3DManager() {
         Map,
         Set,
         WeakMap,
+        Blob,
+        requestAnimationFrame: callback => setTimeout(() => callback(Date.now()), 0),
+        cancelAnimationFrame: id => clearTimeout(id),
+        createImageBitmap: async blob => {
+            imageBitmapCalls.push(blob);
+            return {
+                width: 64,
+                height: 36,
+                close() {
+                    this.closed = true;
+                }
+            };
+        },
         THREE: createThreeStub(),
-        URL,
+        URL: SmokeURL,
         Promise
     };
     context.window = context;
     context.self = context;
 
     vm.runInNewContext(source, context, { filename: managerPath });
-    return { manager: context.window.MindMapCss3DManager, document };
+    return {
+        manager: context.window.MindMapCss3DManager,
+        document,
+        diagnostics: {
+            objectUrlCalls,
+            revokedObjectUrls,
+            imageBitmapCalls
+        }
+    };
 }
 
 function wait(ms = 0) {
@@ -646,7 +721,7 @@ try {
         }
     ];
 
-    const { manager, document } = await loadCss3DManager();
+    const { manager, document, diagnostics } = await loadCss3DManager();
     assert.equal(typeof manager?.renderRemoteFleetMonitorForTest, 'function');
     assert.equal(typeof manager?.renderRemoteFleetDeviceForTest, 'function');
     assert.equal(typeof manager?.applyRemoteFleetFramePatchesForTest, 'function');
@@ -765,6 +840,35 @@ try {
     assert.ok(patchPreview.querySelector('canvas[data-remote-fleet-frame-canvas="true"]'));
     assert.equal(patchPreview.querySelector('img[data-remote-fleet-frame-image="true"]')?.dataset.remoteFleetFrameUrl, patchUrl);
     assert.equal(patchPreview.querySelector('[data-remote-fleet-frame-badge="true"]'), null);
+
+    const objectUrlCountBeforeBinary = diagnostics.objectUrlCalls.length;
+    const imageBitmapCountBeforeBinary = diagnostics.imageBitmapCalls.length;
+    const drawCountBeforeBinary = document.canvasDrawCalls.length;
+    const binaryPatchCount = manager.applyRemoteFleetFramePatchesForTest(bodyView, [{
+        deviceId: patchTarget.DeviceId,
+        kind: 'live',
+        frameSeq: 10000,
+        frameUrl: '',
+        streamId: 'render-smoke-binary-live',
+        contentHash: 'render-smoke-binary-live-10000',
+        receivedAt: new Date().toISOString(),
+        _remoteFleetPayloadBlob: new Blob([new Uint8Array([0xff, 0xd8, 0xff, 0xd9])], { type: 'image/jpeg' }),
+        _remoteFleetBinaryFrame: true
+    }]);
+    assert.equal(binaryPatchCount, 1);
+    await wait(20);
+    const binaryCanvas = patchPreview.querySelector('canvas[data-remote-fleet-frame-canvas="true"]');
+    const binaryImage = patchPreview.querySelector('img[data-remote-fleet-frame-image="true"]');
+    assert.equal(patchPreview.dataset.remoteFleetFrameKind, 'live');
+    assert.equal(patchPreview.dataset.remoteFleetFrameSeq, '10000');
+    assert.equal(binaryCanvas?.dataset.remoteFleetFrameSeq, '10000');
+    assert.equal(binaryCanvas?.style.display, 'block');
+    assert.equal(binaryImage?.style.display, 'none');
+    assert.equal(diagnostics.imageBitmapCalls.length, imageBitmapCountBeforeBinary + 1);
+    assert.equal(diagnostics.objectUrlCalls.length, objectUrlCountBeforeBinary);
+    assert.ok(
+        document.canvasDrawCalls.slice(drawCountBeforeBinary).some(call => call.op === 'drawImage'),
+        'expected binary Blob frame to draw directly to canvas');
     const alternateDevice = devices.find(device =>
         device.Connected === true
         && device.DeviceId !== focusedDevice.DeviceId);

package/server.js

@@ -2909,12 +2909,17 @@ const REMOTE_AGENT_DEFAULT_ENGINE = 'auto';
 const REMOTE_AGENT_SYNC_REPORT_LOG_REPEAT_MS = 30000;
 const REMOTE_AGENT_RACE_START_STAGGER_MS = 120;
 const REMOTE_AGENT_MAX_PARALLEL_CANDIDATES = 6;
+const REMOTE_AGENT_RECENT_MANAGER_CACHE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+const REMOTE_AGENT_RECENT_MANAGER_CACHE_LIMIT = 64;
+const REMOTE_AGENT_RECENT_MANAGER_DEFAULT_KEY = 'default';
 let remoteAgentState = createRemoteAgentIdleState();
 let remoteAgentSyncReportState = null;
 let remoteAgentSyncReportLogKey = '';
 let remoteAgentSyncReportLogAt = 0;
 let remoteAgentConnectPromise = null;
 const remoteAgentRecentSuccessfulManagers = new Map();
+let remoteAgentRecentSuccessfulManagersLoaded = false;
+let remoteAgentRecentSuccessfulManagersSavePromise = null;
 
 function createRemoteAgentIdleState(overrides = {}) {
     return {
@@ -3216,7 +3221,104 @@ function createRemoteAgentConnectionKey(manager, leaseId) {
 }
 
 function getRemoteAgentRecentManagerKey(leaseId = '') {
-    return safeRemoteAgentField(leaseId || 'default', 128) || 'default';
+    return safeRemoteAgentField(leaseId || REMOTE_AGENT_RECENT_MANAGER_DEFAULT_KEY, 128)
+        || REMOTE_AGENT_RECENT_MANAGER_DEFAULT_KEY;
+}
+
+function getRemoteAgentRecentManagerCachePath() {
+    return path.join(getDataRoot(workspacePath), 'cache', 'remote-agent-recent-managers.json');
+}
+
+function normalizeRemoteAgentRecentManagerEntry(entry) {
+    const endpoint = normalizeRemoteManagerEndpoint(entry?.endpoint);
+    const updatedAt = Number(entry?.updatedAt || 0);
+    if (!endpoint || !Number.isFinite(updatedAt) || updatedAt <= 0) {
+        return null;
+    }
+
+    const now = Date.now();
+    if (now - updatedAt > REMOTE_AGENT_RECENT_MANAGER_CACHE_TTL_MS) {
+        return null;
+    }
+
+    return {
+        endpoint,
+        updatedAt
+    };
+}
+
+function loadRemoteAgentRecentSuccessfulManagers() {
+    if (remoteAgentRecentSuccessfulManagersLoaded) {
+        return;
+    }
+
+    remoteAgentRecentSuccessfulManagersLoaded = true;
+    const cachePath = getRemoteAgentRecentManagerCachePath();
+    let payload = null;
+    try {
+        payload = JSON.parse(readFileSync(cachePath, 'utf8'));
+    } catch (err) {
+        if (err?.code !== 'ENOENT') {
+            logWarn('remote', `managed RemoteAgent recent manager cache ignored: ${err?.message || err}`);
+        }
+        return;
+    }
+
+    const rawEntries = Array.isArray(payload?.entries)
+        ? payload.entries
+        : Object.entries(payload?.managers || {}).map(([key, value]) => ({ key, ...value }));
+    let loaded = 0;
+    for (const rawEntry of rawEntries) {
+        if (loaded >= REMOTE_AGENT_RECENT_MANAGER_CACHE_LIMIT) {
+            break;
+        }
+
+        const key = getRemoteAgentRecentManagerKey(rawEntry?.key || rawEntry?.leaseId || '');
+        const entry = normalizeRemoteAgentRecentManagerEntry(rawEntry);
+        if (!entry) {
+            continue;
+        }
+
+        remoteAgentRecentSuccessfulManagers.set(key, entry);
+        loaded += 1;
+    }
+}
+
+async function saveRemoteAgentRecentSuccessfulManagers() {
+    const entries = Array.from(remoteAgentRecentSuccessfulManagers.entries())
+        .map(([key, value]) => ({
+            key,
+            endpoint: normalizeRemoteManagerEndpoint(value?.endpoint),
+            updatedAt: Number(value?.updatedAt || 0)
+        }))
+        .map(entry => ({
+            ...entry,
+            normalized: normalizeRemoteAgentRecentManagerEntry(entry)
+        }))
+        .filter(entry => entry.normalized)
+        .sort((left, right) => Number(right.updatedAt || 0) - Number(left.updatedAt || 0))
+        .slice(0, REMOTE_AGENT_RECENT_MANAGER_CACHE_LIMIT)
+        .map(entry => ({
+            key: entry.key,
+            endpoint: entry.normalized.endpoint,
+            updatedAt: entry.normalized.updatedAt
+        }));
+
+    const payload = {
+        version: 1,
+        savedAt: new Date().toISOString(),
+        entries
+    };
+    await writeFileAtomically(getRemoteAgentRecentManagerCachePath(), JSON.stringify(payload, null, 2), 'utf8');
+}
+
+function scheduleRemoteAgentRecentSuccessfulManagersSave() {
+    remoteAgentRecentSuccessfulManagersSavePromise = Promise.resolve(remoteAgentRecentSuccessfulManagersSavePromise)
+        .catch(() => null)
+        .then(() => saveRemoteAgentRecentSuccessfulManagers())
+        .catch(err => {
+            logWarn('remote', `managed RemoteAgent recent manager cache save failed: ${err?.message || err}`);
+        });
 }
 
 function rememberRemoteAgentSuccessfulManager(manager, leaseId = '') {
@@ -3225,10 +3327,14 @@ function rememberRemoteAgentSuccessfulManager(manager, leaseId = '') {
         return;
     }
 
-    remoteAgentRecentSuccessfulManagers.set(getRemoteAgentRecentManagerKey(leaseId), {
+    loadRemoteAgentRecentSuccessfulManagers();
+    const entry = {
         endpoint,
         updatedAt: Date.now()
-    });
+    };
+    remoteAgentRecentSuccessfulManagers.set(getRemoteAgentRecentManagerKey(leaseId), entry);
+    remoteAgentRecentSuccessfulManagers.set(REMOTE_AGENT_RECENT_MANAGER_DEFAULT_KEY, entry);
+    scheduleRemoteAgentRecentSuccessfulManagersSave();
 }
 
 function prioritizeRemoteAgentManagers(managers, leaseId = '') {
@@ -3237,8 +3343,10 @@ function prioritizeRemoteAgentManagers(managers, leaseId = '') {
         return normalized;
     }
 
-    const recent = remoteAgentRecentSuccessfulManagers.get(getRemoteAgentRecentManagerKey(leaseId));
-    const recentEndpoint = normalizeRemoteManagerEndpoint(recent?.endpoint);
+    loadRemoteAgentRecentSuccessfulManagers();
+    const leaseRecent = remoteAgentRecentSuccessfulManagers.get(getRemoteAgentRecentManagerKey(leaseId));
+    const defaultRecent = remoteAgentRecentSuccessfulManagers.get(REMOTE_AGENT_RECENT_MANAGER_DEFAULT_KEY);
+    const recentEndpoint = normalizeRemoteManagerEndpoint(leaseRecent?.endpoint || defaultRecent?.endpoint);
     if (!recentEndpoint) {
         return normalized;
     }
@@ -10333,6 +10441,12 @@ async function shutdownBridge(signal) {
         // Ignore managed RemoteAgent close errors during shutdown
     }
 
+    try {
+        await remoteAgentRecentSuccessfulManagersSavePromise;
+    } catch {
+        // Ignore recent-manager cache save errors during shutdown
+    }
+
     try {
         await remoteHub.close();
     } catch {

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

@@ -13463,6 +13463,8 @@
     const REMOTE_FLEET_THUMBNAIL_FRAME_DECODE_TIMEOUT_MS = 1200;
     const REMOTE_FLEET_BINARY_FRAME_WS_RECONNECT_MS = 1500;
     const REMOTE_FLEET_BINARY_FRAME_SUBSCRIBE_MS = 1000;
+    const REMOTE_FLEET_BINARY_FRAME_STALE_FALLBACK_MS = 1400;
+    const REMOTE_FLEET_BINARY_FRAME_CONNECT_GRACE_MS = 1600;
     const REMOTE_FLEET_AUTO_LIVE_START_MAX_PARALLEL = 8;
     const REMOTE_FLEET_AUTO_LIVE_START_COOLDOWN_MS = 3000;
     const REMOTE_FLEET_TASK_FOLLOW_INITIAL_MS = 250;
@@ -13677,6 +13679,12 @@
         return candidates;
     }
 
+    function getRemoteFleetFrameNow() {
+        return typeof performance !== 'undefined' && typeof performance.now === 'function'
+            ? performance.now()
+            : Date.now();
+    }
+
     async function getRemoteFleetBridgeStatusForFrames() {
         if (remoteFleetBridgeStatusPromise) {
             return remoteFleetBridgeStatusPromise;
@@ -13863,9 +13871,11 @@
 
             const ws = new WebSocket(wsUrl);
             session.ws = ws;
+            session.wsOpeningAt = getRemoteFleetFrameNow();
             session.subscriptionKey = '';
             ws.binaryType = 'arraybuffer';
             ws.onopen = () => {
+                session.wsOpenedAt = getRemoteFleetFrameNow();
                 window.RuntimeTrace?.emit?.('remote.frame.wsOpen', { nodeId: session.nodeId });
                 refreshRemoteFleetBinaryFrameSubscription(session, true);
                 if (!session.subscriptionTimer) {
@@ -13894,9 +13904,15 @@
                         }
 
                         let applied = 0;
+                        const frameAt = getRemoteFleetFrameNow();
+                        session.lastBinaryFrameAt = frameAt;
                         session.bodies.forEach(body => {
                             if (document.body.contains(body)) {
-                                applied += applyRemoteFleetFramePatches(body, [frame]);
+                                const bodyApplied = applyRemoteFleetFramePatches(body, [frame]);
+                                if (bodyApplied > 0) {
+                                    body._remoteFleetLastBinaryFrameAt = frameAt;
+                                }
+                                applied += bodyApplied;
                             }
                         });
 
@@ -14998,9 +15014,20 @@
             if (binarySocket
                 && typeof WebSocket !== 'undefined'
                 && (binarySocket.readyState === WebSocket.OPEN || binarySocket.readyState === WebSocket.CONNECTING)) {
-                lastTick = timestamp;
-                bodyView._remoteFleetFrameLoopRaf = requestRemoteFleetFrameLoopFrame(loop);
-                return;
+                const lastBinaryFrameAt = Number(bodyView._remoteFleetLastBinaryFrameAt || binarySession?.lastBinaryFrameAt || 0);
+                const wsStartedAt = Number(binarySession?.wsOpenedAt || binarySession?.wsOpeningAt || 0);
+                const hasRecentBinaryFrame =
+                    lastBinaryFrameAt > 0
+                    && timestamp - lastBinaryFrameAt <= REMOTE_FLEET_BINARY_FRAME_STALE_FALLBACK_MS;
+                const stillWithinConnectGrace =
+                    wsStartedAt > 0
+                    && lastBinaryFrameAt <= 0
+                    && timestamp - wsStartedAt <= REMOTE_FLEET_BINARY_FRAME_CONNECT_GRACE_MS;
+                if (hasRecentBinaryFrame || stillWithinConnectGrace) {
+                    lastTick = timestamp;
+                    bodyView._remoteFleetFrameLoopRaf = requestRemoteFleetFrameLoopFrame(loop);
+                    return;
+                }
             }
 
             if (timestamp - lastTick >= intervalMs && bodyView._remoteFleetFrameRefreshInFlight !== true) {

package/wwwroot/_framework/blazor.boot.json

@@ -1,7 +1,7 @@
 {
   "mainAssemblyName": "MindExecution.Web",
   "resources": {
-    "hash": "sha256-o8W1U0lBmrbs5unXcwG+/IEh2KogSA7Rk3MqjQnNfGU=",
+    "hash": "sha256-aGxH2r2LOpixHAksGBYXRcA86Dv8rGHPIhoagHBUV2M=",
     "fingerprinting": {
       "Google.Protobuf.9h59ukbel7.dll": "Google.Protobuf.dll",
       "Markdig.d1j7v41cl1.dll": "Markdig.dll",
@@ -131,7 +131,7 @@
       "MindExecution.Plugins.Directory.jc0g7fvyzv.dll": "MindExecution.Plugins.Directory.dll",
       "MindExecution.Plugins.PlanMaster.2sugb66h95.dll": "MindExecution.Plugins.PlanMaster.dll",
       "MindExecution.Plugins.YouTube.vy0nsbcoo4.dll": "MindExecution.Plugins.YouTube.dll",
-      "MindExecution.Shared.uwkrc41o75.dll": "MindExecution.Shared.dll",
+      "MindExecution.Shared.vki6dm13ef.dll": "MindExecution.Shared.dll",
       "MindExecution.Web.994sb3nzuy.dll": "MindExecution.Web.dll",
       "dotnet.js": "dotnet.js",
       "dotnet.native.qc8g39g30v.js": "dotnet.native.js",
@@ -282,7 +282,7 @@
       "MindExecution.Kernel.3zom09ir6j.dll": "sha256-78vR2SNkF9FwdQv0fEItSyz4HzgyzwGUROJAnpripPA=",
       "MindExecution.Plugins.Concept.lxunwcdjgq.dll": "sha256-WVyvjaxW6UoGQvGW0icChLsXwYVCcdn0BLTftzlkCKc=",
       "MindExecution.Plugins.PlanMaster.2sugb66h95.dll": "sha256-Lp0AieRHDo2H4Yl0Il1pPruy9nFUHJsX9t1AblXGD6Y=",
-      "MindExecution.Shared.uwkrc41o75.dll": "sha256-YjF+7VcGo3+nB0fsa2nh3AiaRyrHS1AL6d6Mq4RWKqo=",
+      "MindExecution.Shared.vki6dm13ef.dll": "sha256-cUcgQfOJa1LaZuLSXdrmi1RrrueXoKuP49M/cjsbguU=",
       "MindExecution.Web.994sb3nzuy.dll": "sha256-jQshtLmhEC4xenzdD9PqHjaCuKvJf/frzaKBi2weDAg="
     },
     "lazyAssembly": {

package/wwwroot/index.html

@@ -7,8 +7,8 @@
     <title>MindExec | Run your ideas as AI task graphs</title>
     <meta name="description" content="MindExec is an AI execution canvas for solo builders, researchers, developers, and creators. Start with free browser tools, then move serious work into saved MindCanvas projects." />
     <base href="/" />
-    <link rel="stylesheet" href="_content/MindExecution.Shared/css/app.css?v=20260616-mdm-live-paint-v576" />
-    <link rel="stylesheet" href="_content/MindExecution.Shared/css/mind-map-overrides.css?v=20260616-mdm-live-paint-v576" />
+    <link rel="stylesheet" href="_content/MindExecution.Shared/css/app.css?v=20260616-mdm-ws-watchdog-v577" />
+    <link rel="stylesheet" href="_content/MindExecution.Shared/css/mind-map-overrides.css?v=20260616-mdm-ws-watchdog-v577" />
     <!-- ?쇄뼹??Font Awesome (local) ?쇄뼹??-->
     <link rel="stylesheet" href="_content/MindExecution.Shared/lib/font-awesome/css/all.min.css" />
     <!-- ?꿎뼯??-->
@@ -579,7 +579,7 @@
             }
 
             const base = '_content/MindExecution.Shared/js/';
-        const scriptVersion = '20260616-mdm-live-paint-v576';
+        const scriptVersion = '20260616-mdm-ws-watchdog-v577';
             const scriptUrl = (script) => `${base}${script}?v=${scriptVersion}`;
             console.log(`[Script Loader] Shared JS version: ${scriptVersion}`);
             const criticalScripts = [

package/wwwroot/service-worker-assets.js

@@ -1,5 +1,5 @@
 self.assetsManifest = {
-    "version":  "dvBBmOSo",
+    "version":  "PVMqIJP0",
     "assets":  [
                    {
                        "hash":  "sha256-+CSYMcqLNTsq3VnH11jgYyOCCdxvHzL74CBmo4sCmMU=",
@@ -86,7 +86,7 @@
                        "url":  "_content/MindExecution.Shared/js/mind-map-core.js.backup"
                    },
                    {
-                       "hash":  "sha256-f0C7hF8MEs79aW0LHHOPm+FeBP7cvy/GxhypXzccmd4=",
+                       "hash":  "sha256-04ZcgwZFW2ICQSVXCeuy61QLIexXoiGLVAIR1UDv3UQ=",
                        "url":  "_content/MindExecution.Shared/js/mind-map-css3d-manager.js"
                    },
                    {
@@ -442,8 +442,8 @@
                        "url":  "_framework/MindExecution.Plugins.YouTube.vy0nsbcoo4.dll"
                    },
                    {
-                       "hash":  "sha256-YjF+7VcGo3+nB0fsa2nh3AiaRyrHS1AL6d6Mq4RWKqo=",
-                       "url":  "_framework/MindExecution.Shared.uwkrc41o75.dll"
+                       "hash":  "sha256-cUcgQfOJa1LaZuLSXdrmi1RrrueXoKuP49M/cjsbguU=",
+                       "url":  "_framework/MindExecution.Shared.vki6dm13ef.dll"
                    },
                    {
                        "hash":  "sha256-jQshtLmhEC4xenzdD9PqHjaCuKvJf/frzaKBi2weDAg=",
@@ -770,7 +770,7 @@
                        "url":  "_framework/Websocket.Client.vapounvmnl.dll"
                    },
                    {
-                       "hash":  "sha256-lL/HCjpHZ3+EWJkTvNj72sH8NLl/eSU2UZDTr6bP99c=",
+                       "hash":  "sha256-RIddmeeu4/GO5kDBZ6kmWUv1o1+x8NzfFxWruTBtPec=",
                        "url":  "_framework/blazor.boot.json"
                    },
                    {
@@ -834,7 +834,7 @@
                        "url":  "image-manifest.json"
                    },
                    {
-                       "hash":  "sha256-HElWHU9ioUT0cuuCKMD/40OJ15fyVOJNYjuApu3T4mI=",
+                       "hash":  "sha256-a13nNlTLpG4s9DEqkhUdxDJRAp9L+OnnPbRXafbvBCo=",
                        "url":  "index.html"
                    },
                    {

package/wwwroot/service-worker.js

@@ -1,4 +1,4 @@
-/* Manifest version: dvBBmOSo */
+/* Manifest version: PVMqIJP0 */
 // Hosted deployments should prefer the network over stale offline caches.
 // This service worker immediately clears old Blazor offline caches and unregisters itself.