@onekeyfe/hd-transport-web-device 1.2.0-alpha.133 → 1.2.0-alpha.134

package/__tests__/webusb-protocol-cache.test.ts

@@ -0,0 +1,204 @@
+import transport from '@onekeyfe/hd-transport';
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import WebUsbTransport from '../src/webusb';
+
+const schema = {
+  nested: {
+    Ping: { fields: { message: { type: 'string', id: 1 } } },
+    Success: { fields: { message: { type: 'string', id: 1 } } },
+    MessageType: {
+      values: {
+        MessageType_Ping: 60206,
+        MessageType_Success: 60207,
+      },
+    },
+  },
+};
+
+function buildAcquirableTransport() {
+  const webusb = new WebUsbTransport() as any;
+  webusb.Log = { debug: jest.fn() };
+  webusb.rotateProtocolV2UsbGeneration = jest.fn().mockResolvedValue(undefined);
+  webusb.closeOpenDevice = jest.fn().mockResolvedValue(undefined);
+  webusb.connect = jest.fn().mockResolvedValue(undefined);
+  return webusb;
+}
+
+describe('WebUsbTransport protocol probe cache', () => {
+  test('acquire skips the wire probe when the protocol is already cached', async () => {
+    const webusb = buildAcquirableTransport();
+    const path = 'pro-webusb';
+    webusb.deviceProtocol.set(path, 'V1');
+    webusb.detectProtocol = jest.fn();
+
+    await expect(webusb.acquire({ path, expectedProtocol: 'V1' })).resolves.toBe(path);
+
+    expect(webusb.detectProtocol).not.toHaveBeenCalled();
+    expect(webusb.deviceProtocol.get(path)).toBe('V1');
+    expect(webusb.acquiredPaths.has(path)).toBe(true);
+  });
+
+  test('acquire re-probes when the caller expects a different protocol than cached', async () => {
+    const webusb = buildAcquirableTransport();
+    const path = 'pro-webusb';
+    webusb.deviceProtocol.set(path, 'V1');
+    webusb.detectProtocol = jest.fn().mockImplementation((p: string) => {
+      webusb.deviceProtocol.set(p, 'V2');
+      return Promise.resolve('V2');
+    });
+
+    await expect(webusb.acquire({ path, expectedProtocol: 'V2' })).resolves.toBe(path);
+
+    expect(webusb.detectProtocol).toHaveBeenCalledWith(path, 'V2', undefined);
+    expect(webusb.deviceProtocol.get(path)).toBe('V2');
+  });
+
+  test('acquire probes when nothing is cached for the path', async () => {
+    const webusb = buildAcquirableTransport();
+    const path = 'pro-webusb';
+    webusb.detectProtocol = jest.fn().mockResolvedValue('V1');
+
+    await expect(webusb.acquire({ path, expectedProtocol: 'V1' })).resolves.toBe(path);
+
+    expect(webusb.detectProtocol).toHaveBeenCalledWith(path, 'V1', undefined);
+  });
+
+  test('acquire re-probes a stale-marked path even when a protocol is cached', async () => {
+    const webusb = buildAcquirableTransport();
+    const path = 'pro-webusb';
+    webusb.deviceProtocol.set(path, 'V1');
+    webusb.markProtocolStale(path);
+    webusb.detectProtocol = jest.fn().mockImplementation((p: string) => {
+      webusb.deviceProtocol.set(p, 'V1');
+      return Promise.resolve('V1');
+    });
+
+    await expect(webusb.acquire({ path, expectedProtocol: 'V1' })).resolves.toBe(path);
+
+    expect(webusb.detectProtocol).toHaveBeenCalledTimes(1);
+    expect(webusb.staleProtocolPaths.has(path)).toBe(false);
+  });
+
+  test('release keeps the cached V1 protocol so the next acquire can reuse it', async () => {
+    const webusb = new WebUsbTransport() as any;
+    const path = 'pro-webusb';
+    webusb.deviceProtocol.set(path, 'V1');
+    webusb.deviceProtocolHints.set(path, 'V2');
+    webusb.deviceEndpoints.set(path, { interfaceNumber: 0, endpointIn: 1, endpointOut: 1 });
+    webusb.acquiredPaths.add(path);
+    webusb.closeOpenDevice = jest.fn().mockResolvedValue(undefined);
+
+    await webusb.release(path);
+
+    expect(webusb.deviceProtocol.get(path)).toBe('V1');
+    expect(webusb.deviceProtocolHints.get(path)).toBe('V2');
+    expect(webusb.deviceEndpoints.has(path)).toBe(false);
+    expect(webusb.acquiredPaths.has(path)).toBe(false);
+  });
+
+  test('release still drops a cached V2 protocol through link invalidation', async () => {
+    const webusb = new WebUsbTransport() as any;
+    const path = 'pro2-webusb';
+    webusb.Log = { debug: jest.fn() };
+    webusb.messages = transport.parseConfigure(schema);
+    webusb.messagesV2 = transport.parseConfigure(schema);
+    webusb.writeProtocolV2UsbPacket = jest.fn().mockResolvedValue(undefined);
+    let markReadStarted: () => void = () => undefined;
+    const readStarted = new Promise<void>(resolve => {
+      markReadStarted = resolve;
+    });
+    webusb.readProtocolV2UsbPacket = jest.fn().mockImplementation(() => {
+      markReadStarted();
+      return new Promise<void>(() => {});
+    });
+    webusb.closeOpenDevice = jest.fn().mockResolvedValue(undefined);
+    webusb.deviceProtocol.set(path, 'V2');
+    await webusb.rotateProtocolV2UsbGeneration(path, 'test connection');
+
+    const call = webusb.callProtocolV2(path, 'Ping', { message: 'release' });
+    await readStarted;
+    await webusb.release(path);
+
+    await expect(call).rejects.toThrow('WebUSB transport released');
+    expect(webusb.deviceProtocol.has(path)).toBe(false);
+  });
+
+  test('call and post fail fast for a path that is not acquired', async () => {
+    const webusb = new WebUsbTransport() as any;
+    const path = 'pro-webusb';
+    webusb.Log = { debug: jest.fn() };
+    webusb.messages = transport.parseConfigure(schema);
+    webusb.messagesV2 = transport.parseConfigure(schema);
+    // A surviving protocol cache entry must NOT act as a session token.
+    webusb.deviceProtocol.set(path, 'V1');
+
+    await expect(webusb.call(path, 'Ping', {})).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.RuntimeError,
+      message: expect.stringContaining('not acquired'),
+    });
+    await expect(webusb.post(path, 'Ping', {})).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.RuntimeError,
+      message: expect.stringContaining('not acquired'),
+    });
+  });
+
+  test('a transfer-level reconnect marks the protocol stale for the next acquire', async () => {
+    const webusb = new WebUsbTransport() as any;
+    const path = 'pro-webusb';
+    webusb.Log = { debug: jest.fn() };
+    webusb.deviceProtocol.set(path, 'V1');
+    webusb.findDevice = jest.fn().mockResolvedValue({ opened: false });
+    webusb.getConnectedDevices = jest.fn().mockResolvedValue([]);
+    webusb.connect = jest.fn().mockResolvedValue(undefined);
+
+    await webusb.reconnectForPacketIoRetry(path, 'in', 0, new Error('transferIn failed'));
+
+    // The in-flight call keeps the cached protocol; only the next acquire re-probes.
+    expect(webusb.deviceProtocol.get(path)).toBe('V1');
+    expect(webusb.staleProtocolPaths.has(path)).toBe(true);
+  });
+
+  test('USB disconnect marks the serial stale and the listener attaches only once', () => {
+    const addEventListener = jest.fn();
+    const usb = { addEventListener } as unknown as USB;
+    const originalNavigator = (globalThis as any).navigator;
+    Object.defineProperty(globalThis, 'navigator', {
+      value: { usb },
+      configurable: true,
+    });
+    try {
+      const first = new WebUsbTransport() as any;
+      first.init({ debug: jest.fn() });
+      const second = new WebUsbTransport() as any;
+      second.init({ debug: jest.fn() });
+
+      // Module-level listener: one registration across instances.
+      expect(addEventListener).toHaveBeenCalledTimes(1);
+      const handler = addEventListener.mock.calls[0][1] as (event: {
+        device?: { serialNumber?: string | null };
+      }) => void;
+
+      const path = 'pro-webusb';
+      first.deviceProtocol.set(path, 'V1');
+      second.deviceProtocol.set(path, 'V1');
+      handler({ device: { serialNumber: path } });
+
+      // Routed to the most recently initialized instance; the cached value is
+      // retained (in-flight sessions keep working) but marked stale.
+      expect(second.staleProtocolPaths.has(path)).toBe(true);
+      expect(second.deviceProtocol.get(path)).toBe('V1');
+      expect(first.staleProtocolPaths.has(path)).toBe(false);
+
+      // Events without a usable serial are ignored.
+      handler({ device: { serialNumber: null } });
+      handler({});
+      expect(second.staleProtocolPaths.size).toBe(1);
+    } finally {
+      Object.defineProperty(globalThis, 'navigator', {
+        value: originalNavigator,
+        configurable: true,
+      });
+    }
+  });
+});

package/dist/index.d.ts

@@ -20,6 +20,13 @@ declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
     /** Per-path protocol type detected by active wire-level probe. */
     private deviceProtocol;
     private deviceProtocolHints;
+    /**
+     * Paths whose cached protocol must be re-probed on the next acquire (a USB
+     * disconnect was seen, or a transfer-level reconnect happened mid-call).
+     */
+    private staleProtocolPaths;
+    /** Paths currently acquired (between a successful acquire() and its release()). */
+    private acquiredPaths;
     /** Per-path USB endpoint / interface numbers (discovered from USB descriptors) */
     private deviceEndpoints;
     name: string;
@@ -40,6 +47,17 @@ declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
      * Initialize WebUSB transport
      */
     init(logger: any): void;
+    /**
+     * Protocol type is a property of the physical device keyed by USB serial number.
+     * It can only change across a device reboot (e.g. normal ↔ bootloader mode), and
+     * a reboot always surfaces as a USB disconnect. Disconnects (and transfer-level
+     * reconnects, which cover a missed disconnect event) only MARK the cached probe
+     * result stale instead of deleting it: an in-flight session keeps using the old
+     * value so the transfer-level reconnect retries can absorb a transient
+     * re-enumeration exactly as they did before the cache existed, while the next
+     * acquire re-probes from scratch.
+     */
+    markProtocolStale(path: string): void;
     /**
      * Configure Protocol V1 protobuf schema (legacy chunked 0x3F framing).
      */
@@ -97,6 +115,14 @@ declare class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
     connectToDevice(path: string, first: boolean): Promise<void>;
     private closeOpenDevice;
     private clearEndpointHalt;
+    /**
+     * With the protocol cache surviving release(), deviceProtocol presence no
+     * longer implies an active session. Guard call()/post() explicitly so a
+     * post-release straggler fails fast instead of silently reopening the device
+     * and driving it outside any session (pre-cache behavior: the deleted
+     * protocol entry produced the same fail-fast).
+     */
+    private assertAcquired;
     post(session: string, name: string, data: Record<string, unknown>): Promise<void>;
     private getErrorMessage;
     private isRetryablePacketIoError;

package/dist/index.js

@@ -57,6 +57,20 @@ const EXPECTED_PROTOCOL_V2_PROBE_ATTEMPTS = 2;
 function inferProtocolHintFromDeviceName$1(name) {
     return /\bpro\s*2\b/i.test(name !== null && name !== void 0 ? name : '') ? 'V2' : undefined;
 }
+let activeWebUsbTransport;
+let usbDisconnectListenerAttached = false;
+function attachUsbDisconnectListener(usb) {
+    if (usbDisconnectListenerAttached)
+        return;
+    usbDisconnectListenerAttached = true;
+    usb.addEventListener('disconnect', event => {
+        var _a;
+        const serial = (_a = event.device) === null || _a === void 0 ? void 0 : _a.serialNumber;
+        if (typeof serial !== 'string' || serial.length === 0)
+            return;
+        activeWebUsbTransport === null || activeWebUsbTransport === void 0 ? void 0 : activeWebUsbTransport.markProtocolStale(serial);
+    });
+}
 class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
     constructor() {
         super({
@@ -66,6 +80,8 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
         });
         this.deviceProtocol = new Map();
         this.deviceProtocolHints = new Map();
+        this.staleProtocolPaths = new Set();
+        this.acquiredPaths = new Set();
         this.deviceEndpoints = new Map();
         this.name = 'WebUsbTransport';
         this.stopped = false;
@@ -82,6 +98,11 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'WebUSB is not supported by current browsers');
         }
         this.usb = usb;
+        activeWebUsbTransport = this;
+        attachUsbDisconnectListener(usb);
+    }
+    markProtocolStale(path) {
+        this.staleProtocolPaths.add(path);
     }
     configure(signedData) {
         const messages = parseConfigure$1(signedData);
@@ -156,18 +177,30 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
                 yield this.rotateProtocolV2UsbGeneration(input.path, 'WebUSB transport acquired');
                 yield this.closeOpenDevice(input.path);
                 yield this.connect((_a = input.path) !== null && _a !== void 0 ? _a : '', true);
-                const deviceName = (_b = this.deviceList.find(device => device.path === input.path)) === null || _b === void 0 ? void 0 : _b.device.productName;
-                const protocolHint = input.expectedProtocol
-                    ? undefined
-                    : (_d = (_c = input.protocolHint) !== null && _c !== void 0 ? _c : this.deviceProtocolHints.get(input.path)) !== null && _d !== void 0 ? _d : inferProtocolHintFromDeviceName$1(deviceName);
-                if (protocolHint) {
-                    this.deviceProtocolHints.set(input.path, protocolHint);
+                if (this.staleProtocolPaths.has(input.path)) {
+                    this.staleProtocolPaths.delete(input.path);
+                    this.deviceProtocol.delete(input.path);
+                }
+                const cachedProtocol = this.deviceProtocol.get(input.path);
+                if (cachedProtocol && input.expectedProtocol && cachedProtocol !== input.expectedProtocol) {
+                    this.deviceProtocol.delete(input.path);
                 }
-                yield this.detectProtocol(input.path, input.expectedProtocol, protocolHint);
+                if (!this.deviceProtocol.has(input.path)) {
+                    const deviceName = (_b = this.deviceList.find(device => device.path === input.path)) === null || _b === void 0 ? void 0 : _b.device.productName;
+                    const protocolHint = input.expectedProtocol
+                        ? undefined
+                        : (_d = (_c = input.protocolHint) !== null && _c !== void 0 ? _c : this.deviceProtocolHints.get(input.path)) !== null && _d !== void 0 ? _d : inferProtocolHintFromDeviceName$1(deviceName);
+                    if (protocolHint) {
+                        this.deviceProtocolHints.set(input.path, protocolHint);
+                    }
+                    yield this.detectProtocol(input.path, input.expectedProtocol, protocolHint);
+                }
+                this.acquiredPaths.add(input.path);
                 return yield Promise.resolve(input.path);
             }
             catch (e) {
                 this.Log.debug('acquire error: ', e instanceof Error ? `${e.name}: ${e.message}` : String(e));
+                this.acquiredPaths.delete(input.path);
                 yield this.closeOpenDevice(input.path);
                 throw e;
             }
@@ -351,8 +384,14 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             }
         });
     }
+    assertAcquired(path) {
+        if (!this.acquiredPaths.has(path)) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device is not acquired for ${path}`);
+        }
+    }
     post(session, name, data) {
         return __awaiter(this, void 0, void 0, function* () {
+            this.assertAcquired(session);
             if (this.deviceProtocol.get(session) === 'V2') {
                 yield this.sendProtocolV2UsbFlowControl(session, name, data);
                 return;
@@ -385,6 +424,7 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             this.Log.debug(`[WebUsbTransport] transfer${direction} failed, retry ${attempt}/${PACKET_IO_MAX_RETRIES}: ${this.getErrorMessage(error)}`);
+            this.staleProtocolPaths.add(path);
             yield hdShared.wait(attempt * PACKET_IO_RETRY_DELAY);
             try {
                 const currentDevice = yield this.findDevice(path);
@@ -599,6 +639,7 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
             if (this.messages == null) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
             }
+            this.assertAcquired(path);
             const device = yield this.findDevice(path);
             if (!device) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound);
@@ -678,10 +719,9 @@ class WebUsbTransport extends transport.ProtocolV2UsbTransportBase {
     }
     release(path) {
         return __awaiter(this, void 0, void 0, function* () {
+            this.acquiredPaths.delete(path);
             yield this.invalidateProtocolV2UsbLink(path, 'WebUSB transport released');
             yield this.closeOpenDevice(path);
-            this.deviceProtocol.delete(path);
-            this.deviceProtocolHints.delete(path);
             this.deviceEndpoints.delete(path);
         });
     }

package/dist/webusb.d.ts

@@ -12,6 +12,8 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
     private protocolV2SchemaSource;
     private deviceProtocol;
     private deviceProtocolHints;
+    private staleProtocolPaths;
+    private acquiredPaths;
     private deviceEndpoints;
     name: string;
     stopped: boolean;
@@ -24,6 +26,7 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
     interfaceId: number;
     constructor();
     init(logger: any): void;
+    markProtocolStale(path: string): void;
     configure(signedData: any): void;
     configureProtocolV2(signedData: any): void;
     promptDeviceAccess(): Promise<USBDevice | null>;
@@ -40,6 +43,7 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
     connectToDevice(path: string, first: boolean): Promise<void>;
     private closeOpenDevice;
     private clearEndpointHalt;
+    private assertAcquired;
     post(session: string, name: string, data: Record<string, unknown>): Promise<void>;
     private getErrorMessage;
     private isRetryablePacketIoError;

package/dist/webusb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webusb.d.ts","sourceRoot":"","sources":["../src/webusb.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"webusb.d.ts","sourceRoot":"","sources":["../src/webusb.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-web-device",
-  "version": "1.2.0-alpha.133",
+  "version": "1.2.0-alpha.134",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
   "license": "MIT",
@@ -21,13 +21,13 @@
     "lint:fix": "eslint . --fix"
   },
   "dependencies": {
-    "@onekeyfe/hd-shared": "1.2.0-alpha.133",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.133"
+    "@onekeyfe/hd-shared": "1.2.0-alpha.134",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.134"
   },
   "devDependencies": {
-    "@onekeyfe/hd-transport-electron": "1.2.0-alpha.133",
+    "@onekeyfe/hd-transport-electron": "1.2.0-alpha.134",
     "@types/w3c-web-usb": "^1.0.6",
     "@types/web-bluetooth": "^0.0.17"
   },
-  "gitHead": "b6d3307b47c535c876655afd99a6681399453508"
+  "gitHead": "47de2b0244584f6a541a84b0f94e4676bf63221a"
 }

package/src/webusb.ts

@@ -69,6 +69,26 @@ interface TransferCancelToken {
   cancelled: boolean;
 }
 
+/**
+ * The navigator.usb disconnect listener is module-scoped and attached at most
+ * once: listeners on navigator.usb are global and never garbage collected, so a
+ * per-instance listener would retain every transport instance created across
+ * SDK re-initializations. Events are routed to the most recently initialized
+ * transport instance instead.
+ */
+let activeWebUsbTransport: WebUsbTransport | undefined;
+let usbDisconnectListenerAttached = false;
+
+function attachUsbDisconnectListener(usb: USB) {
+  if (usbDisconnectListenerAttached) return;
+  usbDisconnectListenerAttached = true;
+  usb.addEventListener('disconnect', event => {
+    const serial = event.device?.serialNumber;
+    if (typeof serial !== 'string' || serial.length === 0) return;
+    activeWebUsbTransport?.markProtocolStale(serial);
+  });
+}
+
 export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string> {
   messages: ReturnType<typeof transport.parseConfigure> | undefined;
 
@@ -82,6 +102,15 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
 
   private deviceProtocolHints: Map<string, ProtocolType> = new Map();
 
+  /**
+   * Paths whose cached protocol must be re-probed on the next acquire (a USB
+   * disconnect was seen, or a transfer-level reconnect happened mid-call).
+   */
+  private staleProtocolPaths: Set<string> = new Set();
+
+  /** Paths currently acquired (between a successful acquire() and its release()). */
+  private acquiredPaths: Set<string> = new Set();
+
   /** Per-path USB endpoint / interface numbers (discovered from USB descriptors) */
   private deviceEndpoints: Map<string, DeviceEndpoints> = new Map();
 
@@ -129,6 +158,22 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
       );
     }
     this.usb = usb;
+    activeWebUsbTransport = this;
+    attachUsbDisconnectListener(usb);
+  }
+
+  /**
+   * Protocol type is a property of the physical device keyed by USB serial number.
+   * It can only change across a device reboot (e.g. normal ↔ bootloader mode), and
+   * a reboot always surfaces as a USB disconnect. Disconnects (and transfer-level
+   * reconnects, which cover a missed disconnect event) only MARK the cached probe
+   * result stale instead of deleting it: an in-flight session keeps using the old
+   * value so the transfer-level reconnect retries can absorb a transient
+   * re-enumeration exactly as they did before the cache existed, while the next
+   * acquire re-probes from scratch.
+   */
+  markProtocolStale(path: string) {
+    this.staleProtocolPaths.add(path);
   }
 
   /**
@@ -231,20 +276,36 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
       await this.rotateProtocolV2UsbGeneration(input.path, 'WebUSB transport acquired');
       await this.closeOpenDevice(input.path);
       await this.connect(input.path ?? '', true);
-      const deviceName = this.deviceList.find(device => device.path === input.path)?.device
-        .productName;
-      const protocolHint = input.expectedProtocol
-        ? undefined
-        : input.protocolHint ??
-          this.deviceProtocolHints.get(input.path) ??
-          inferProtocolHintFromDeviceName(deviceName);
-      if (protocolHint) {
-        this.deviceProtocolHints.set(input.path, protocolHint);
+      if (this.staleProtocolPaths.has(input.path)) {
+        // The device disconnected (possibly rebooting into another mode) since
+        // the protocol was probed — drop the cache so it is re-probed below.
+        this.staleProtocolPaths.delete(input.path);
+        this.deviceProtocol.delete(input.path);
       }
-      await this.detectProtocol(input.path, input.expectedProtocol, protocolHint);
+      const cachedProtocol = this.deviceProtocol.get(input.path);
+      if (cachedProtocol && input.expectedProtocol && cachedProtocol !== input.expectedProtocol) {
+        // The caller expects a different protocol than the cached probe result;
+        // the cache is stale — drop it and re-probe on the wire below.
+        this.deviceProtocol.delete(input.path);
+      }
+      if (!this.deviceProtocol.has(input.path)) {
+        const deviceName = this.deviceList.find(device => device.path === input.path)?.device
+          .productName;
+        const protocolHint = input.expectedProtocol
+          ? undefined
+          : input.protocolHint ??
+            this.deviceProtocolHints.get(input.path) ??
+            inferProtocolHintFromDeviceName(deviceName);
+        if (protocolHint) {
+          this.deviceProtocolHints.set(input.path, protocolHint);
+        }
+        await this.detectProtocol(input.path, input.expectedProtocol, protocolHint);
+      }
+      this.acquiredPaths.add(input.path);
       return await Promise.resolve(input.path);
     } catch (e) {
       this.Log.debug('acquire error: ', e instanceof Error ? `${e.name}: ${e.message}` : String(e));
+      this.acquiredPaths.delete(input.path);
       await this.closeOpenDevice(input.path);
       throw e;
     }
@@ -480,7 +541,24 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
     }
   }
 
+  /**
+   * With the protocol cache surviving release(), deviceProtocol presence no
+   * longer implies an active session. Guard call()/post() explicitly so a
+   * post-release straggler fails fast instead of silently reopening the device
+   * and driving it outside any session (pre-cache behavior: the deleted
+   * protocol entry produced the same fail-fast).
+   */
+  private assertAcquired(path: string) {
+    if (!this.acquiredPaths.has(path)) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `Device is not acquired for ${path}`
+      );
+    }
+  }
+
   async post(session: string, name: string, data: Record<string, unknown>) {
+    this.assertAcquired(session);
     if (this.deviceProtocol.get(session) === 'V2') {
       await this.sendProtocolV2UsbFlowControl(session, name, data);
       return;
@@ -522,6 +600,11 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
         error
       )}`
     );
+    // The device dropped off the bus mid-call and may have rebooted into a
+    // different mode. The in-flight retry keeps the known protocol, but the
+    // next acquire must re-probe — this also self-heals a stale cache when the
+    // USB disconnect event itself was missed.
+    this.staleProtocolPaths.add(path);
     await wait(attempt * PACKET_IO_RETRY_DELAY);
 
     try {
@@ -755,6 +838,7 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
     if (this.messages == null) {
       throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
     }
+    this.assertAcquired(path);
 
     const device = await this.findDevice(path);
     if (!device) {
@@ -871,10 +955,14 @@ export default class WebUsbTransport extends ProtocolV2UsbTransportBase<string>
    * Release device
    */
   async release(path: string) {
+    this.acquiredPaths.delete(path);
     await this.invalidateProtocolV2UsbLink(path, 'WebUSB transport released');
     await this.closeOpenDevice(path);
-    this.deviceProtocol.delete(path);
-    this.deviceProtocolHints.delete(path);
+    // Keep deviceProtocol/deviceProtocolHints across release: the probe result is a
+    // physical-device property, so the next acquire can skip the wire-level probe.
+    // V2 entries are still dropped by onProtocolV2UsbLinkInvalidated via the link
+    // invalidation above, and any entry is re-probed after a USB disconnect or a
+    // transfer-level reconnect (see markProtocolStale).
     this.deviceEndpoints.delete(path);
   }