livedesk 0.1.664 → 0.1.666

package/client/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livedesk/client",
-  "version": "0.1.271",
+  "version": "0.1.272",
   "description": "VuvoDesk local remote client",
   "type": "module",
   "bin": {
@@ -36,16 +36,16 @@
   "dependencies": {
     "@ffmpeg-installer/ffmpeg": "^1.1.0",
     "ffmpeg-static": "^5.3.0",
-    "@livedesk/runtime-core": "0.1.8",
+    "@livedesk/runtime-core": "0.1.9",
     "@supabase/supabase-js": "^2.110.0",
     "node-screenshots": "^0.2.8",
     "ws": "^8.18.3"
   },
   "optionalDependencies": {
-    "@livedesk/fast-linux-x64": "0.1.466",
-    "@livedesk/fast-osx-arm64": "0.1.466",
-    "@livedesk/fast-osx-x64": "0.1.466",
-    "@livedesk/fast-win-x64": "0.1.466"
+    "@livedesk/fast-linux-x64": "0.1.467",
+    "@livedesk/fast-osx-arm64": "0.1.467",
+    "@livedesk/fast-osx-x64": "0.1.467",
+    "@livedesk/fast-win-x64": "0.1.467"
   },
   "publishConfig": {
     "access": "public"

package/electron/installer.nsh

@@ -93,6 +93,17 @@
   !insertmacro MUI_PAGE_DIRECTORY
 !macroend
 
+!macro customInstall
+  # electron-builder normally launches $newStartMenuLink after a silent update.
+  # The updater removes and recreates that shortcut during replacement, so
+  # Explorer can receive a path that no longer exists. Launch the installed
+  # executable directly after an update; ordinary installs keep the default
+  # shortcut-backed finish-page behavior.
+  ${If} ${isUpdated}
+    StrCpy $launchLink "$INSTDIR\${APP_EXECUTABLE_FILENAME}"
+  ${EndIf}
+!macroend
+
 !macro customUnInstallCheck
   ${If} ${Errors}
     DetailPrint "Uninstall was not successful. The registered uninstaller could not be launched."

package/electron/main.mjs

@@ -1538,6 +1538,12 @@ if (!app.requestSingleInstanceLock()) {
       log
     });
     desktopAutoStartOwner.reconcile('startup');
+    if (process.argv.includes('--updated')) {
+      log(
+        `desktop update event=post-install-startup platform=${process.platform} version=${app.getVersion()} marker=updated`,
+        { source: 'desktop-update' }
+      );
+    }
     let lastProductUpdateLogSignature = '';
     productUpdates = createProductUpdateManager({
       app,

package/hub/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livedesk/hub",
-  "version": "0.1.66",
+  "version": "0.1.67",
   "description": "VuvoDesk local Hub API and browser frame bridge",
   "type": "module",
   "main": "src/server.js",
@@ -16,7 +16,7 @@
   },
   "dependencies": {
     "@ffmpeg-installer/ffmpeg": "^1.1.0",
-    "@livedesk/runtime-core": "0.1.8",
+    "@livedesk/runtime-core": "0.1.9",
     "@openai/codex-sdk": "0.145.0",
     "cors": "^2.8.5",
     "express": "^4.21.2",

package/hub/src/console-direct.js

@@ -371,6 +371,8 @@ export function createHubConsoleDirect(options = {}) {
   let lastHttpStatus = 0;
   let rejectedRelayCandidates = 0;
   let dataChannelBackpressureCloses = 0;
+  let dataChannelSendFailures = 0;
+  let lastDataChannelSendFailure = null;
   let malformedWireCloses = 0;
   let wireBudgetCleanupFailures = 0;
 
@@ -730,11 +732,28 @@ export function createHubConsoleDirect(options = {}) {
       }
       return false;
     }
-    for (const chunk of chunks) {
+    for (const [chunkIndex, chunk] of chunks.entries()) {
       if (!isOwnerActive(owner) || channelState.closed || !channelIsOpen(channelState.channel)) return false;
       try {
-        if (channelState.channel.sendMessageBinary(chunk) !== true) throw new Error('send-rejected');
-      } catch {
+        // Normalize the node-datachannel native boundary to its documented
+        // Node Buffer shape. Share the exact encoded bytes without copying or
+        // retaining a second application queue.
+        const nativeChunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+        if (channelState.channel.sendMessageBinary(nativeChunk) !== true) throw new Error('send-rejected');
+      } catch (error) {
+        dataChannelSendFailures += 1;
+        lastDataChannelSendFailure = Object.freeze({
+          purpose: channelState.purpose,
+          channelId: channelState.channelId,
+          generation: owner.generation,
+          messageId: (channelState.nextSendMessageId - 1) >>> 0,
+          chunkIndex,
+          chunkCount: chunks.length,
+          chunkBytes: chunk.byteLength,
+          bufferedBytes: channelBufferedAmount(channelState),
+          error: String(error instanceof Error ? error.message : error).slice(0, 120),
+          occurredAt: Date.now()
+        });
         if (options.closeOnFailure !== false) {
           if (channelState === owner.control) retirePeer(owner, 'console-direct-control-send-failed');
           else closeLogicalChannel(owner, channelState, {
@@ -1983,6 +2002,8 @@ export function createHubConsoleDirect(options = {}) {
         + Number(signalHeartbeatTimerActive),
       rejectedRelayCandidates,
       dataChannelBackpressureCloses,
+      dataChannelSendFailures,
+      lastDataChannelSendFailure,
       malformedWireCloses,
       wireBudgetCleanupFailures,
       lastConnectedAt,

package/hub/src/console-direct.test.mjs

@@ -124,6 +124,7 @@ class FakeDataChannel {
 
   sendMessageBinary(value) {
     if (!this.isOpen()) return false;
+    if (!Buffer.isBuffer(value)) throw new TypeError('Buffer expected');
     this.sent.push(new Uint8Array(value));
     return true;
   }
@@ -1498,7 +1499,7 @@ test('native node-datachannel peers carry the fragmented control wire over loopb
       kind: 'control'
     });
     assert.ok(chunks.length > 1);
-    for (const chunk of chunks) assert.equal(offerChannel.sendMessageBinary(chunk), true);
+    for (const chunk of chunks) assert.equal(offerChannel.sendMessageBinary(Buffer.from(chunk)), true);
     const message = await received;
     clearTimeout(messageTimer);
     messageTimer = null;

package/hub/src/remote-hub.js

@@ -10924,23 +10924,29 @@ export function createRemoteHub(options = {}) {
         ensureLiveStreamReplacementTimers(device).set(stream.streamId, timer);
     }
 
-    function failPendingLiveStream(device, commandId, error = 'stream-start-failed') {
+    function failPendingLiveStream(device, commandId, error = 'stream-start-failed') {
         const key = safeString(commandId, 128);
         if (!device || !key) {
             return false;
         }
         const streams = ensureDeviceLiveStreams(device);
         for (const stream of streams.values()) {
-            const pending = getPendingLiveStreamDescriptor(stream);
-            if (safeString(pending?.commandId, 128) !== key) {
-                continue;
-            }
-            clearPendingLiveStreamDescriptor(device, stream);
-            emitRemoteEvent('RemoteLiveStreamRestartFailed', device, {
-                streamId: stream.streamId,
-                commandId: key,
-                error: safeString(error, 500) || 'stream-start-failed'
-            });
+            const pending = getPendingLiveStreamDescriptor(stream);
+            if (safeString(pending?.commandId, 128) !== key) {
+                continue;
+            }
+            const failedOwner = { ...pending };
+            clearPendingLiveStreamDescriptor(device, stream);
+            emitRemoteEvent('RemoteLiveStreamRestartFailed', device, {
+                streamId: stream.streamId,
+                commandId: key,
+                streamPurpose: safeString(failedOwner.streamPurpose, 24) || 'wall',
+                captureGeneration: Number(failedOwner.captureGeneration || 0),
+                monitorIndex: Number(failedOwner.monitorIndex || 0),
+                retainedCommandId: safeString(stream.commandId, 128),
+                retainedCaptureGeneration: Number(stream.captureGeneration || 0),
+                error: safeString(error, 500) || 'stream-start-failed'
+            });
             return true;
         }
         for (const stream of streams.values()) {
@@ -11293,7 +11299,7 @@ export function createRemoteHub(options = {}) {
             }
             : normalized;
         return {
-            ok: true,
+            ok: true,
             commandId: activeLiveStream.commandId,
             sessionId: device.sessionId,
             streamId: activeLiveStream.streamId,
@@ -11802,10 +11808,11 @@ export function createRemoteHub(options = {}) {
             fps,
             mode: transfer.mode,
             frameMode: transfer.frameMode,
-            monitorIndex,
-            captureGeneration,
-            ready: false
-        };
+            monitorIndex,
+            captureGeneration,
+            ready: false,
+            pending: replacingActiveStream
+        };
     }
 
     function stopLiveStream(deviceId, options = {}) {

package/hub/src/server.js

@@ -35,7 +35,11 @@ import {
   isReusedLiveStreamFrameReady
 } from './live-stream-monitor-contract.js';
 import { createLiveCaptureTransitionRetryCoordinator } from './live-capture-transition-retry.mjs';
-import { selectSharedWallSourceProfile } from './shared-wall-profile-contract.mjs';
+import {
+  selectSharedWallSourceProfile,
+  shouldRetainWallOwnerUntilPendingStartCommits,
+  wallBindingMatchesFailedOwner
+} from './shared-wall-profile-contract.mjs';
 import {
   createPlanDeviceAccessSnapshot,
   partitionPlanDeviceIds,
@@ -436,7 +440,25 @@ function handleRemoteHubEvent(type, event) {
     || type === 'RemoteLiveStreamStopped') {
     const liveStreamEventDeviceId = String(event?.deviceId || event?.device?.deviceId || '').trim();
     const liveStreamEventPurpose = readRemoteLiveStreamEventPurpose(event);
-    if ((type === 'RemoteLiveStreamStarted' || type === 'RemoteLiveStreamOpened')
+    if (type === 'RemoteLiveStreamOpened' && liveStreamEventPurpose === 'wall') {
+      const committedOwner = event?.device?.activeLiveStream;
+      if (String(committedOwner?.commandId || '').trim() === String(event?.commandId || '').trim()
+        && Number(committedOwner?.captureGeneration || 0) === Number(event?.captureGeneration || 0)) {
+        rebindSharedWallSubscribersToOwner(liveStreamEventDeviceId, {
+          ...committedOwner,
+          sessionId: event?.device?.sessionId || ''
+        }, {
+          effectiveProfile: {
+            fps: Number(committedOwner?.fps || 0),
+            maxWidth: Number(committedOwner?.maxWidth || 0),
+            maxHeight: Number(committedOwner?.maxHeight || 0),
+            quality: Number(committedOwner?.quality || 0)
+          },
+          readySent: false,
+          reason: 'shared-wall-profile-upgrade-committed'
+        });
+      }
+    } else if ((type === 'RemoteLiveStreamStarted' || type === 'RemoteLiveStreamOpened')
       && liveStreamEventPurpose === 'control') {
       readOnlyControlPresentationReconcileCoordinator
         .cancelForControlTransition(liveStreamEventDeviceId);
@@ -454,7 +476,7 @@ function handleRemoteHubEvent(type, event) {
     const failedDeviceId = String(event?.deviceId || event?.device?.deviceId || '').trim();
     const retainedOwner = event?.device?.activeLiveStream;
     if (String(retainedOwner?.streamPurpose || '').trim().toLowerCase() === 'wall') {
-      rebindSharedWallSubscribersToOwner(failedDeviceId, {
+      const rebound = rebindSharedWallSubscribersToOwner(failedDeviceId, {
         ...retainedOwner,
         sessionId: event?.device?.sessionId || ''
       }, {
@@ -465,8 +487,20 @@ function handleRemoteHubEvent(type, event) {
           quality: Number(retainedOwner?.quality || 0)
         },
         readySent: true,
+        replaceOnlyOwner: {
+          commandId: event?.commandId || '',
+          captureGeneration: Number(event?.captureGeneration || 0)
+        },
         reason: 'shared-wall-profile-upgrade-failed'
       });
+      console.warn(
+        `[VuvoDesk Hub] Wall replacement failed device=${failedDeviceId} `
+        + `attemptedCommand=${String(event?.commandId || '').slice(0, 8) || '-'} `
+        + `attemptedGeneration=${Number(event?.captureGeneration || 0)} `
+        + `retainedCommand=${String(event?.retainedCommandId || retainedOwner?.commandId || '').slice(0, 8) || '-'} `
+        + `retainedGeneration=${Number(event?.retainedCaptureGeneration || retainedOwner?.captureGeneration || 0)} `
+        + `rebound=${rebound} error=${String(event?.error || 'stream-start-failed').slice(0, 160)}`
+      );
     }
   }
   if (type === 'RemoteDeviceConnected' || type === 'RemoteDeviceDisconnected') {
@@ -2681,6 +2715,7 @@ function resolveSharedWallSourceDemand(ws, deviceId, liveOptions, monitorIndex)
 function rebindSharedWallSubscribersToOwner(deviceId, owner, {
   effectiveProfile = null,
   readySent = false,
+  replaceOnlyOwner = null,
   reason = 'shared-wall-profile-owner-changed'
 } = {}) {
   const normalizedDeviceId = String(deviceId || '').trim();
@@ -2721,6 +2756,7 @@ function rebindSharedWallSubscribersToOwner(deviceId, owner, {
       ? candidate.liveDeskExpectedStreamBindingsByDeviceId.get(normalizedDeviceId)
       : null;
     if (!previousBinding || previousBinding.readOnlyControlBorrow === true) continue;
+    if (replaceOnlyOwner && !wallBindingMatchesFailedOwner(previousBinding, replaceOnlyOwner)) continue;
     const nextBinding = {
       deviceId: normalizedDeviceId,
       sessionId,
@@ -4005,6 +4041,11 @@ function startFrameSubscriptionLive(
       );
     }
     if (result?.ok) {
+      const activeStream = device?.activeLiveStream;
+      const retainWallOwner = shouldRetainWallOwnerUntilPendingStartCommits(
+        result,
+        activeStream
+      );
       const effectiveWallProfile = String(result.streamPurpose || liveOptions.streamPurpose || '')
         .trim().toLowerCase() === 'wall'
         ? {
@@ -4015,6 +4056,7 @@ function startFrameSubscriptionLive(
           }
         : result.effectiveProfile || null;
       if (result.reused !== true
+        && retainWallOwner !== true
         && String(result.streamPurpose || '').trim().toLowerCase() === 'wall') {
         rebindSharedWallSubscribersToOwner(deviceId, result, {
           effectiveProfile: effectiveWallProfile,
@@ -4029,27 +4071,40 @@ function startFrameSubscriptionLive(
         ) + 1;
       }
       frameCaptureTransitionRetries.complete(ws, deviceId, intentGeneration, 'capture-started');
+      const bindingOwner = retainWallOwner
+        ? {
+            ...activeStream,
+            sessionId: String(device?.sessionId || result.sessionId || '')
+          }
+        : result;
+      const bindingEffectiveWallProfile = retainWallOwner
+        ? {
+            fps: Number(activeStream?.fps || 0),
+            maxWidth: Number(activeStream?.maxWidth || 0),
+            maxHeight: Number(activeStream?.maxHeight || 0),
+            quality: Number(activeStream?.quality || 0)
+          }
+        : effectiveWallProfile;
       const expectedBinding = {
-        deviceId,
-        sessionId: String(result.sessionId || device.sessionId || ''),
-        streamId: String(result.streamId || ''),
-        streamPurpose: String(result.streamPurpose || liveOptions.streamPurpose || 'wall'),
-        commandId: String(result.commandId || ''),
-        captureGeneration: Number(result.captureGeneration || 0),
-        monitorIndex: Number(result.monitorIndex || 0),
-        readOnlyControlBorrow: result.readOnlyControlBorrow === true,
-        presentationPurpose: result.presentationPurpose === 'wall' ? 'wall' : '',
-        effectiveProfile: effectiveWallProfile,
+        deviceId,
+        sessionId: String(bindingOwner?.sessionId || device.sessionId || ''),
+        streamId: String(bindingOwner?.streamId || ''),
+        streamPurpose: String(bindingOwner?.streamPurpose || liveOptions.streamPurpose || 'wall'),
+        commandId: String(bindingOwner?.commandId || ''),
+        captureGeneration: Number(bindingOwner?.captureGeneration || 0),
+        monitorIndex: Number(bindingOwner?.monitorIndex || 0),
+        readOnlyControlBorrow: bindingOwner?.readOnlyControlBorrow === true,
+        presentationPurpose: bindingOwner?.presentationPurpose === 'wall' ? 'wall' : '',
+        effectiveProfile: bindingEffectiveWallProfile,
         readySent: false
-      };
-      const activeStream = device?.activeLiveStream;
+      };
       // A new read-only browser presentation has no decoder history from the
       // already-running Control stream. It must enter through the next exact
       // key frame even when the native owner itself is already ready.
       const reusedFrameReady = expectedBinding.readOnlyControlBorrow !== true
         && isReusedLiveStreamFrameReady(result, activeStream, expectedBinding);
       expectedBinding.readySent = reusedFrameReady;
-      ws.liveDeskStreamIdsByDeviceId.set(deviceId, result.streamId);
+      ws.liveDeskStreamIdsByDeviceId.set(deviceId, expectedBinding.streamId);
       const installedBindingIdentity = replaceExpectedFrameBindingForClient(
         ws,
         deviceId,
@@ -4058,9 +4113,9 @@ function startFrameSubscriptionLive(
       if (!installedBindingIdentity) {
         skipped.push({ deviceId, reason: 'invalid-live-stream-binding' });
         continue;
-      }
+      }
       if (expectedBinding.readOnlyControlBorrow !== true) {
-        cancelPendingFrameStreamStop(deviceId, result.streamId, expectedBinding.streamPurpose);
+        cancelPendingFrameStreamStop(deviceId, expectedBinding.streamId, expectedBinding.streamPurpose);
       }
       started.push({
         deviceId: expectedBinding.deviceId,

package/hub/src/shared-wall-profile-contract.mjs

@@ -38,3 +38,32 @@ export function liveProfileSatisfiesDemand(activeProfile, requestedProfile) {
     && finiteProfileNumber(activeProfile.maxHeight) >= finiteProfileNumber(requestedProfile.maxHeight)
     && finiteProfileNumber(activeProfile.quality) >= finiteProfileNumber(requestedProfile.quality);
 }
+
+export function shouldRetainWallOwnerUntilPendingStartCommits(startResult, activeOwner) {
+  if (!startResult || startResult.pending !== true || !activeOwner) return false;
+  const startPurpose = String(startResult.streamPurpose || '').trim().toLowerCase();
+  const activePurpose = String(activeOwner.streamPurpose || '').trim().toLowerCase();
+  const startStreamId = String(startResult.streamId || '').trim();
+  const activeStreamId = String(activeOwner.streamId || '').trim();
+  const activeCommandId = String(activeOwner.commandId || '').trim();
+  const activeGeneration = Number(activeOwner.captureGeneration || 0);
+  return startPurpose === 'wall'
+    && activePurpose === 'wall'
+    && !!startStreamId
+    && startStreamId === activeStreamId
+    && !!activeCommandId
+    && Number.isSafeInteger(activeGeneration)
+    && activeGeneration > 0
+    && activeOwner.active === true;
+}
+
+export function wallBindingMatchesFailedOwner(binding, failedOwner) {
+  const commandId = String(failedOwner?.commandId || '').trim();
+  const captureGeneration = Number(failedOwner?.captureGeneration || 0);
+  return !!binding
+    && !!commandId
+    && Number.isSafeInteger(captureGeneration)
+    && captureGeneration > 0
+    && String(binding.commandId || '').trim() === commandId
+    && Number(binding.captureGeneration || 0) === captureGeneration;
+}

package/hub/src/shared-wall-profile-contract.test.mjs

@@ -3,7 +3,9 @@ import test from 'node:test';
 
 import {
   liveProfileSatisfiesDemand,
-  selectSharedWallSourceProfile
+  selectSharedWallSourceProfile,
+  shouldRetainWallOwnerUntilPendingStartCommits,
+  wallBindingMatchesFailedOwner
 } from './shared-wall-profile-contract.mjs';
 
 test('shared Wall source keeps the strongest field from every current viewer', () => {
@@ -36,3 +38,62 @@ test('a shared source is reused only when it satisfies every requested profile f
   assert.equal(liveProfileSatisfiesDemand(low, high), false);
   assert.equal(liveProfileSatisfiesDemand({ ...high, fps: 5 }, high), false);
 });
+
+test('a pending Wall replacement keeps the current browser owner until a real frame commits it', () => {
+  const activeOwner = {
+    active: true,
+    streamId: 'wall-device',
+    streamPurpose: 'wall',
+    commandId: 'wall-command-current',
+    captureGeneration: 41
+  };
+  const pendingStart = {
+    ok: true,
+    pending: true,
+    streamId: 'wall-device',
+    streamPurpose: 'wall',
+    commandId: 'wall-command-pending',
+    captureGeneration: 42
+  };
+  assert.equal(
+    shouldRetainWallOwnerUntilPendingStartCommits(pendingStart, activeOwner),
+    true
+  );
+  assert.equal(
+    shouldRetainWallOwnerUntilPendingStartCommits({ ...pendingStart, pending: false }, activeOwner),
+    false
+  );
+  assert.equal(
+    shouldRetainWallOwnerUntilPendingStartCommits(pendingStart, {
+      ...activeOwner,
+      streamPurpose: 'control'
+    }),
+    false
+  );
+  assert.equal(
+    shouldRetainWallOwnerUntilPendingStartCommits({
+      ...pendingStart,
+      streamId: 'wall-other'
+    }, activeOwner),
+    false
+  );
+});
+
+test('a late failed upgrade cannot rewind a newer Wall binding', () => {
+  const failedOwner = {
+    commandId: 'wall-command-42',
+    captureGeneration: 42
+  };
+  assert.equal(wallBindingMatchesFailedOwner({
+    commandId: 'wall-command-42',
+    captureGeneration: 42
+  }, failedOwner), true);
+  assert.equal(wallBindingMatchesFailedOwner({
+    commandId: 'wall-command-43',
+    captureGeneration: 43
+  }, failedOwner), false);
+  assert.equal(wallBindingMatchesFailedOwner({
+    commandId: 'wall-command-42',
+    captureGeneration: 43
+  }, failedOwner), false);
+});

package/hub/src/wall-source-restart-runtime.test.mjs

@@ -138,7 +138,17 @@ test('a new Wall frame lane reuses a healthy exact capture', async () => {
       restartToken: 'explicit-owner-restart'
     });
     assert.equal(hardRestart.ok, true);
+    assert.equal(hardRestart.pending, true);
     assert.ok(hardRestart.captureGeneration > first.captureGeneration);
+    const pendingDevice = hub.listDevices({ includeDataUrl: false })
+      .find(device => device.deviceId === 'wall-source-device');
+    assert.equal(pendingDevice.activeLiveStream.commandId, first.commandId);
+    assert.equal(pendingDevice.activeLiveStream.captureGeneration, first.captureGeneration);
+    assert.equal(pendingDevice.activeLiveStream.pendingCommandId, hardRestart.commandId);
+    assert.equal(
+      pendingDevice.activeLiveStream.pendingCaptureGeneration,
+      hardRestart.captureGeneration
+    );
   } finally {
     socket?.destroy();
     await hub.close();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "livedesk",
-  "version": "0.1.664",
-  "livedeskClientVersion": "0.1.271",
+  "version": "0.1.666",
+  "livedeskClientVersion": "0.1.272",
   "buildFlavor": "production",
   "description": "VuvoDesk Hub and client launcher",
   "type": "module",
@@ -54,10 +54,10 @@
     "ws": "^8.18.3"
   },
   "optionalDependencies": {
-    "@livedesk/fast-linux-x64": "0.1.466",
-    "@livedesk/fast-osx-arm64": "0.1.466",
-    "@livedesk/fast-osx-x64": "0.1.466",
-    "@livedesk/fast-win-x64": "0.1.466"
+    "@livedesk/fast-linux-x64": "0.1.467",
+    "@livedesk/fast-osx-arm64": "0.1.467",
+    "@livedesk/fast-osx-x64": "0.1.467",
+    "@livedesk/fast-win-x64": "0.1.467"
   },
   "publishConfig": {
     "access": "public"

package/runtime-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livedesk/runtime-core",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Shared VuvoDesk runtime role and lifecycle contracts",
   "type": "module",
   "main": "src/index.js",

package/runtime-core/src/console-direct-wire.d.ts

@@ -64,10 +64,13 @@ export interface DirectConsoleWireAssemblerInspection {
   readonly maxPendingMessages: number;
   readonly pendingMessages: number;
   readonly pendingBytes: number;
+  readonly abandonedMessages: number;
+  readonly abandonedChunksRemaining: number;
   readonly budget: DirectConsoleWireBudgetInspection;
 }
 
 export interface DirectConsoleWireAssembler {
+  abandonPending(): DirectConsoleWireAssemblerInspection;
   push(chunk: DirectConsoleWireChunk): DirectConsoleWireResult | null;
   inspect(): DirectConsoleWireAssemblerInspection;
   dispose(): DirectConsoleWireAssemblerInspection;

package/runtime-core/src/console-direct-wire.js

@@ -239,6 +239,7 @@ export function createDirectConsoleWireAssembler(options = undefined) {
   }
 
   const pending = new Map();
+  const abandoned = new Map();
   let disposed = false;
 
   const releasePending = () => {
@@ -246,15 +247,23 @@ export function createDirectConsoleWireAssembler(options = undefined) {
     pending.clear();
   };
 
+  const releaseAbandoned = () => {
+    abandoned.clear();
+  };
+
   const inspect = () => {
     let pendingBytes = 0;
     for (const state of pending.values()) pendingBytes += state.totalLength;
+    let abandonedChunksRemaining = 0;
+    for (const state of abandoned.values()) abandonedChunksRemaining += state.remainingChunks;
     return Object.freeze({
       disposed,
       maxMessageBytes,
       maxPendingMessages,
       pendingMessages: pending.size,
       pendingBytes,
+      abandonedMessages: abandoned.size,
+      abandonedChunksRemaining,
       budget: budget.inspect()
     });
   };
@@ -263,6 +272,7 @@ export function createDirectConsoleWireAssembler(options = undefined) {
     if (!disposed) {
       disposed = true;
       releasePending();
+      releaseAbandoned();
     }
     return inspect();
   };
@@ -270,6 +280,7 @@ export function createDirectConsoleWireAssembler(options = undefined) {
   const closeWithError = error => {
     disposed = true;
     releasePending();
+    releaseAbandoned();
     if (error instanceof DirectConsoleWireError) throw error;
     throw new DirectConsoleWireError('wire-chunk-malformed');
   };
@@ -278,6 +289,20 @@ export function createDirectConsoleWireAssembler(options = undefined) {
     if (disposed) fail('assembler-disposed');
     try {
       const header = parseHeader(input, maxMessageBytes);
+      const abandonedState = abandoned.get(header.messageId);
+      if (abandonedState) {
+        if (abandonedState.kind !== header.kind
+          || abandonedState.chunkCount !== header.chunkCount
+          || abandonedState.totalLength !== header.totalLength) {
+          fail('wire-message-metadata-mismatch');
+        }
+        if (abandonedState.receivedChunks[header.chunkIndex] === 0) {
+          abandonedState.receivedChunks[header.chunkIndex] = 1;
+          abandonedState.remainingChunks -= 1;
+        }
+        if (abandonedState.remainingChunks <= 0) abandoned.delete(header.messageId);
+        return null;
+      }
       let state = pending.get(header.messageId);
       if (!state) {
         if (pending.size >= maxPendingMessages) {
@@ -347,5 +372,25 @@ export function createDirectConsoleWireAssembler(options = undefined) {
     }
   };
 
-  return Object.freeze({ dispose, inspect, push });
+  const abandonPending = () => {
+    if (disposed) fail('assembler-disposed');
+    for (const [messageId, state] of pending.entries()) {
+      if (abandoned.size >= DIRECT_CONSOLE_MAX_CONFIGURED_PENDING_MESSAGES) {
+        const oldestMessageId = abandoned.keys().next().value;
+        abandoned.delete(oldestMessageId);
+      }
+      abandoned.set(messageId, {
+        kind: state.kind,
+        chunkCount: state.chunkCount,
+        totalLength: state.totalLength,
+        receivedChunks: new Uint8Array(state.receivedChunks),
+        remainingChunks: Math.max(0, state.chunkCount - state.receivedChunkCount)
+      });
+      state.reservation.release();
+    }
+    pending.clear();
+    return inspect();
+  };
+
+  return Object.freeze({ abandonPending, dispose, inspect, push });
 }