@onekeyfe/hd-transport-web-device 1.1.27 → 1.2.0-alpha.0

package/dist/index.js

@@ -41,16 +41,43 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-const { parseConfigure: parseConfigure$1, buildEncodeBuffers, decodeProtocol, receiveOne: receiveOne$1, check: check$1 } = transport__default["default"];
+const { parseConfigure: parseConfigure$1, check: check$1, ProtocolV1: ProtocolV1$1 } = transport__default["default"];
 const CONFIGURATION_ID = 1;
 const INTERFACE_ID = 0;
 const ENDPOINT_ID = 1;
-const PACKET_SIZE = 64;
-const HEADER_LENGTH = 6;
+const PACKET_SIZE = transport.PROTOCOL_V1_USB_PACKET_SIZE;
+const PAYLOAD_SIZE = transport.PROTOCOL_V1_CHUNK_PAYLOAD_SIZE;
+const REPORT_ID = transport.PROTOCOL_V1_REPORT_ID;
+const HEADER_LENGTH = transport.PROTOCOL_V1_MESSAGE_HEADER_SIZE;
 const PACKET_IO_MAX_RETRIES = 3;
 const PACKET_IO_RETRY_DELAY = 300;
+const PROTOCOL_PROBE_TIMEOUT = 1000;
+const WEBUSB_FILE_WRITE_LOG_BLOCK_PATTERN = /(?:^|[^a-z])(?:raw)?(?:filesystem|emmc)?filewrite$/i;
+function shouldSuppressWebUsbCallLog(name) {
+    const normalized = name.replace(/[_\s-]/g, '');
+    return WEBUSB_FILE_WRITE_LOG_BLOCK_PATTERN.test(normalized);
+}
+function isLogBlockCommand$1(name) {
+    var _a, _b;
+    return (_b = (_a = transport.LogBlockCommand === null || transport.LogBlockCommand === void 0 ? void 0 : transport.LogBlockCommand.has) === null || _a === void 0 ? void 0 : _a.call(transport.LogBlockCommand, name)) !== null && _b !== void 0 ? _b : false;
+}
+function shouldBlockWebUsbCallDataLog(name) {
+    const normalized = name.replace(/[_\s-]/g, '');
+    return isLogBlockCommand$1(name) || WEBUSB_FILE_WRITE_LOG_BLOCK_PATTERN.test(normalized);
+}
+function inferProtocolHintFromDeviceName$1(name) {
+    return /\bpro\s*2\b/i.test(name !== null && name !== void 0 ? name : '') ? 'V2' : undefined;
+}
 class WebUsbTransport {
     constructor() {
+        this.deviceProtocol = new Map();
+        this.deviceProtocolHints = new Map();
+        this.protocolV2Assemblers = new Map();
+        this.protocolV2Sessions = new Map();
+        this.protocolV2ReadTimeouts = new Map();
+        this.deviceEndpoints = new Map();
+        this.mockSerialPaths = new WeakMap();
+        this.mockSerialCounter = 0;
         this.name = 'WebUsbTransport';
         this.stopped = false;
         this.configured = false;
@@ -72,6 +99,13 @@ class WebUsbTransport {
         this.configured = true;
         this.messages = messages;
     }
+    configureProtocolV2(signedData) {
+        var _a;
+        this.messagesV2 = parseConfigure$1(signedData);
+        this.protocolV2Sessions.clear();
+        this.protocolV2ReadTimeouts.clear();
+        (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[WebUsbTransport] Protocol V2 schema configured');
+    }
     promptDeviceAccess() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.usb)
@@ -92,31 +126,61 @@ class WebUsbTransport {
             return this.deviceList;
         });
     }
+    getDevicePath(device) {
+        var _a;
+        if (typeof device.serialNumber === 'string' && device.serialNumber.length > 0) {
+            return device.serialNumber;
+        }
+        let path = this.mockSerialPaths.get(device);
+        if (!path) {
+            this.mockSerialCounter += 1;
+            path = `mock-serial:${device.vendorId.toString(16)}:${device.productId.toString(16)}:${this.mockSerialCounter}`;
+            this.mockSerialPaths.set(device, path);
+            (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[WebUSB] device has no serial number, using mock path: ${path}`);
+        }
+        return path;
+    }
     getConnectedDevices() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.usb)
                 return [];
             const devices = yield this.usb.getDevices();
-            const onekeyDevices = devices.filter(dev => {
-                const isOneKey = hdShared.ONEKEY_WEBUSB_FILTER.some(desc => dev.vendorId === desc.vendorId && dev.productId === desc.productId);
-                const hasSerialNumber = typeof dev.serialNumber === 'string' && dev.serialNumber.length > 0;
-                return isOneKey && hasSerialNumber;
+            const onekeyDevices = devices.filter(dev => hdShared.ONEKEY_WEBUSB_FILTER.some(desc => dev.vendorId === desc.vendorId && dev.productId === desc.productId));
+            this.deviceList = onekeyDevices.map(device => {
+                const path = this.getDevicePath(device);
+                const protocolHint = inferProtocolHintFromDeviceName$1(device.productName);
+                if (protocolHint) {
+                    this.deviceProtocolHints.set(path, protocolHint);
+                }
+                return {
+                    path,
+                    device,
+                    commType: 'webusb',
+                };
             });
-            this.deviceList = onekeyDevices.map(device => ({
-                path: device.serialNumber,
-                device,
-                commType: 'webusb',
-            }));
+            for (const dev of onekeyDevices) {
+                this.Log.debug(`[WebUSB] Device: name="${dev.productName}" serial="${dev.serialNumber}" ` +
+                    `VID=0x${dev.vendorId.toString(16)} PID=0x${dev.productId.toString(16)}`);
+            }
             return this.deviceList;
         });
     }
     acquire(input) {
-        var _a;
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             if (!input.path)
                 return;
             try {
+                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
+                    : (_c = this.deviceProtocolHints.get(input.path)) !== null && _c !== void 0 ? _c : inferProtocolHintFromDeviceName$1(deviceName);
+                if (protocolHint) {
+                    this.deviceProtocolHints.set(input.path, protocolHint);
+                }
+                yield this.detectProtocol(input.path, input.expectedProtocol, protocolHint);
                 return yield Promise.resolve(input.path);
             }
             catch (e) {
@@ -125,6 +189,40 @@ class WebUsbTransport {
             }
         });
     }
+    createProtocolMismatchError(expected) {
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`);
+    }
+    createProtocolDetectionError() {
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Unable to detect USB protocol: device did not respond to Protocol V1 Initialize or Protocol V2 Ping');
+    }
+    detectProtocol(path, expectedProtocol, protocolHint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (expectedProtocol === 'V1') {
+                if (yield this.probeProtocolV1(path)) {
+                    this.deviceProtocol.set(path, 'V1');
+                    this.Log.debug(`[WebUsbTransport] detectProtocol: path=${path} -> V1 (expected)`);
+                    return 'V1';
+                }
+                throw this.createProtocolMismatchError(expectedProtocol);
+            }
+            if (expectedProtocol === 'V2') {
+                this.deviceProtocol.set(path, 'V2');
+                this.Log.debug(`[WebUsbTransport] detectProtocol: path=${path} -> V2 (expected)`);
+                return 'V2';
+            }
+            const probeOrder = protocolHint === 'V2' || this.deviceProtocol.get(path) === 'V2' ? ['V2', 'V1'] : ['V1', 'V2'];
+            for (const protocol of probeOrder) {
+                const detected = protocol === 'V1' ? yield this.probeProtocolV1(path) : yield this.probeProtocolV2(path);
+                if (detected) {
+                    this.deviceProtocol.set(path, protocol);
+                    this.Log.debug(`[WebUsbTransport] detectProtocol: path=${path} -> ${protocol}`);
+                    return protocol;
+                }
+            }
+            this.deviceProtocol.delete(path);
+            throw this.createProtocolDetectionError();
+        });
+    }
     findDevice(path) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.deviceList.length === 0) {
@@ -157,19 +255,99 @@ class WebUsbTransport {
             }
         });
     }
+    discoverEndpoints(device) {
+        var _a, _b;
+        for (const config of device.configurations) {
+            for (const iface of config.interfaces) {
+                for (const alt of iface.alternates) {
+                    if (alt.interfaceClass === 0xff) {
+                        let endpointIn = this.endpointId;
+                        let endpointOut = this.endpointId;
+                        for (const ep of alt.endpoints) {
+                            if (ep.direction === 'in')
+                                endpointIn = ep.endpointNumber;
+                            else
+                                endpointOut = ep.endpointNumber;
+                        }
+                        (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[WebUsbTransport] discovered vendor interface ${iface.interfaceNumber}, ` +
+                            `endpointIn=${endpointIn}, endpointOut=${endpointOut}`);
+                        return { interfaceNumber: iface.interfaceNumber, endpointIn, endpointOut };
+                    }
+                }
+            }
+        }
+        (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('[WebUsbTransport] no vendor interface found, using defaults');
+        return {
+            interfaceNumber: this.interfaceId,
+            endpointIn: this.endpointId,
+            endpointOut: this.endpointId,
+        };
+    }
     connectToDevice(path, first) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            const device = yield this.findDevice(path);
-            yield device.open();
-            if (first) {
+            let device = yield this.findDevice(path);
+            this.Log.debug('[WebUsbTransport] connecting to device:', device.productName, 'PID:', device.productId);
+            if (!device.opened) {
+                yield device.open();
+            }
+            try {
+                yield device.reset();
+            }
+            catch (error) {
+                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[WebUsbTransport] reset before claim failed, continuing:', error);
+            }
+            yield this.getConnectedDevices();
+            device = yield this.findDevice(path);
+            if (!device.opened) {
+                yield device.open();
+            }
+            if (first ||
+                !device.configuration ||
+                device.configuration.configurationValue !== this.configurationId) {
                 yield device.selectConfiguration(this.configurationId);
-                try {
-                    yield device.reset();
-                }
-                catch (error) {
-                }
             }
-            yield device.claimInterface(this.interfaceId);
+            const endpoints = this.discoverEndpoints(device);
+            this.deviceEndpoints.set(path, endpoints);
+            (_b = this.protocolV2Assemblers.get(path)) === null || _b === void 0 ? void 0 : _b.reset();
+            this.protocolV2Assemblers.set(path, new transport.ProtocolV2FrameAssembler(transport.PROTOCOL_V2_FRAME_MAX_BYTES));
+            yield device.claimInterface(endpoints.interfaceNumber);
+            yield this.clearEndpointHalt(device, 'in', endpoints.endpointIn);
+            yield this.clearEndpointHalt(device, 'out', endpoints.endpointOut);
+        });
+    }
+    closeOpenDevice(path) {
+        var _a, _b, _c, _d, _e;
+        return __awaiter(this, void 0, void 0, function* () {
+            (_a = this.protocolV2Assemblers.get(path)) === null || _a === void 0 ? void 0 : _a.reset();
+            const current = (_b = this.deviceList.find(device => device.path === path)) === null || _b === void 0 ? void 0 : _b.device;
+            if (!(current === null || current === void 0 ? void 0 : current.opened))
+                return;
+            const endpoints = this.deviceEndpoints.get(path);
+            const ifaceNum = (_c = endpoints === null || endpoints === void 0 ? void 0 : endpoints.interfaceNumber) !== null && _c !== void 0 ? _c : this.interfaceId;
+            try {
+                yield current.releaseInterface(ifaceNum);
+            }
+            catch (error) {
+                (_d = this.Log) === null || _d === void 0 ? void 0 : _d.debug('[WebUsbTransport] releaseInterface before reconnect failed:', error);
+            }
+            try {
+                yield current.close();
+            }
+            catch (error) {
+                (_e = this.Log) === null || _e === void 0 ? void 0 : _e.debug('[WebUsbTransport] close before reconnect failed:', error);
+            }
+        });
+    }
+    clearEndpointHalt(device, direction, endpointNumber) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield device.clearHalt(direction, endpointNumber);
+            }
+            catch (error) {
+                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[WebUsbTransport] clearHalt ${direction} endpoint ${endpointNumber} failed, continuing:`, error);
+            }
         });
     }
     post(session, name, data) {
@@ -199,14 +377,17 @@ class WebUsbTransport {
             message.includes('networkerror'));
     }
     reconnectForPacketIoRetry(path, direction, attempt, error) {
+        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)}`);
             yield hdShared.wait(attempt * PACKET_IO_RETRY_DELAY);
             try {
                 const currentDevice = yield this.findDevice(path);
                 if (currentDevice.opened) {
+                    const endpoints = this.deviceEndpoints.get(path);
+                    const ifaceNum = (_a = endpoints === null || endpoints === void 0 ? void 0 : endpoints.interfaceNumber) !== null && _a !== void 0 ? _a : this.interfaceId;
                     try {
-                        yield currentDevice.releaseInterface(this.interfaceId);
+                        yield currentDevice.releaseInterface(ifaceNum);
                     }
                     catch (releaseError) {
                         this.Log.debug('[WebUsbTransport] releaseInterface before retry error:', releaseError);
@@ -239,6 +420,7 @@ class WebUsbTransport {
         return copied.buffer;
     }
     transferOutWithRetry(path, packet) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             let lastError;
             for (let attempt = 1; attempt <= PACKET_IO_MAX_RETRIES; attempt += 1) {
@@ -247,8 +429,10 @@ class WebUsbTransport {
                     if (!device.opened) {
                         yield this.connect(path, false);
                     }
+                    const endpoints = this.deviceEndpoints.get(path);
+                    const endpointOut = (_a = endpoints === null || endpoints === void 0 ? void 0 : endpoints.endpointOut) !== null && _a !== void 0 ? _a : this.endpointId;
                     const transferBuffer = this.toArrayBuffer(packet.buffer.slice(packet.byteOffset, packet.byteOffset + packet.byteLength));
-                    yield device.transferOut(this.endpointId, transferBuffer);
+                    yield device.transferOut(endpointOut, transferBuffer);
                     return;
                 }
                 catch (error) {
@@ -269,20 +453,29 @@ class WebUsbTransport {
             throw lastError;
         });
     }
-    transferInWithRetry(path, length) {
+    transferInWithRetry(path, length, cancelToken) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             let lastError;
             for (let attempt = 1; attempt <= PACKET_IO_MAX_RETRIES; attempt += 1) {
+                if (cancelToken === null || cancelToken === void 0 ? void 0 : cancelToken.cancelled) {
+                    throw new Error('transferIn cancelled');
+                }
                 try {
                     const device = yield this.findDevice(path);
                     if (!device.opened) {
                         yield this.connect(path, false);
                     }
-                    const result = yield device.transferIn(this.endpointId, length);
+                    const endpoints = this.deviceEndpoints.get(path);
+                    const endpointIn = (_a = endpoints === null || endpoints === void 0 ? void 0 : endpoints.endpointIn) !== null && _a !== void 0 ? _a : this.endpointId;
+                    const result = yield device.transferIn(endpointIn, length);
                     return this.getTransferInData(result);
                 }
                 catch (error) {
                     lastError = error;
+                    if (cancelToken === null || cancelToken === void 0 ? void 0 : cancelToken.cancelled) {
+                        throw error;
+                    }
                     const shouldRetry = attempt < PACKET_IO_MAX_RETRIES && this.isRetryablePacketIoError(error);
                     if (!shouldRetry) {
                         throw error;
@@ -299,7 +492,92 @@ class WebUsbTransport {
             throw lastError;
         });
     }
-    call(path, name, data) {
+    resetConnectionAfterProbe(path) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            (_a = this.protocolV2Assemblers.get(path)) === null || _a === void 0 ? void 0 : _a.reset();
+            this.protocolV2Sessions.delete(path);
+            this.protocolV2ReadTimeouts.delete(path);
+            try {
+                const device = yield this.findDevice(path);
+                if (device.opened) {
+                    const endpoints = this.deviceEndpoints.get(path);
+                    const ifaceNum = (_b = endpoints === null || endpoints === void 0 ? void 0 : endpoints.interfaceNumber) !== null && _b !== void 0 ? _b : this.interfaceId;
+                    try {
+                        yield device.releaseInterface(ifaceNum);
+                    }
+                    catch (error) {
+                        this.Log.debug('[WebUsbTransport] releaseInterface after protocol probe error:', error);
+                    }
+                    yield device.close();
+                }
+            }
+            catch (error) {
+                this.Log.debug('[WebUsbTransport] close after protocol probe error:', error);
+            }
+            yield this.getConnectedDevices();
+            yield this.connect(path, false);
+        });
+    }
+    withProtocolReadTimeout(path, promise, timeoutMs, protocol, onTimeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let timer;
+            let timedOut = false;
+            const waitForeverAfterTimeout = () => new Promise(() => { });
+            const guardedPromise = promise.then(value => (timedOut ? waitForeverAfterTimeout() : value), error => {
+                if (timedOut) {
+                    return waitForeverAfterTimeout();
+                }
+                throw error;
+            });
+            try {
+                return yield Promise.race([
+                    guardedPromise,
+                    new Promise((_, reject) => {
+                        timer = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                            timedOut = true;
+                            onTimeout === null || onTimeout === void 0 ? void 0 : onTimeout();
+                            reject(new Error(`Protocol ${protocol} read timeout after ${timeoutMs}ms`));
+                        }), timeoutMs);
+                    }),
+                ]);
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        });
+    }
+    probeProtocolV1(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.messages) {
+                return false;
+            }
+            try {
+                yield this.callProtocolV1(path, 'Initialize', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT });
+                return true;
+            }
+            catch (error) {
+                this.Log.debug('[WebUsbTransport] Protocol V1 Initialize probe failed:', error);
+                return false;
+            }
+        });
+    }
+    probeProtocolV2(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.messages || !this.messagesV2) {
+                return false;
+            }
+            return transport.probeProtocolV2({
+                call: (name, data, options) => this.callProtocolV2(path, name, data, options),
+                timeoutMs: PROTOCOL_PROBE_TIMEOUT,
+                logger: this.Log,
+                logPrefix: 'ProtocolV2 WebUSB',
+                onProbeFailed: () => this.resetConnectionAfterProbe(path),
+            });
+        });
+    }
+    call(path, name, data, options) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.messages == null) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
@@ -308,33 +586,123 @@ class WebUsbTransport {
             if (!device) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound);
             }
-            const { messages } = this;
-            if (transport.LogBlockCommand.has(name)) {
-                this.Log.debug('call-', ' name: ', name);
+            const protocol = this.deviceProtocol.get(path);
+            if (!protocol) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol has not been detected for ${path}`);
+            }
+            if (shouldSuppressWebUsbCallLog(name)) ;
+            else if (shouldBlockWebUsbCallDataLog(name)) {
+                this.Log.debug('call-', ' name: ', name, ' protocol: ', protocol);
             }
             else {
-                this.Log.debug('call-', ' name: ', name, ' data: ', data);
+                this.Log.debug('call-', ' name: ', name, ' data: ', data, ' protocol: ', protocol);
+            }
+            if (protocol === 'V2') {
+                return this.callProtocolV2(path, name, data, options);
+            }
+            return this.callProtocolV1(path, name, data, options);
+        });
+    }
+    callProtocolV1(path, name, data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { messages } = this;
+            if (!messages) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
             }
-            const encodeBuffers = buildEncodeBuffers(messages, name, data);
+            const encodeBuffers = ProtocolV1$1.encodeMessageChunks(messages, name, data);
             for (const buffer of encodeBuffers) {
                 const newArray = new Uint8Array(PACKET_SIZE);
-                newArray[0] = 63;
+                newArray[0] = REPORT_ID;
                 newArray.set(new Uint8Array(buffer), 1);
                 yield this.transferOutWithRetry(path, newArray);
             }
-            const resData = yield this.receiveData(path);
+            const resData = yield this.receiveData(path, options === null || options === void 0 ? void 0 : options.timeoutMs);
             if (typeof resData !== 'string') {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NetworkError, 'Returning data is not string.');
             }
-            const jsonData = receiveOne$1(messages, resData);
+            const jsonData = ProtocolV1$1.decodeMessage(messages, resData);
             return check$1.call(jsonData);
         });
     }
-    receiveData(path) {
+    callProtocolV2(path, name, data, options) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const firstPacketData = yield this.transferInWithRetry(path, PACKET_SIZE);
+            const protocolV1Messages = this.messages;
+            if (!this.messagesV2) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured, 'Protocol V2 schema not configured');
+            }
+            if (!protocolV1Messages) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
+            }
+            let session = this.protocolV2Sessions.get(path);
+            if (!session) {
+                session = new transport.ProtocolV2Session({
+                    schemas: {
+                        protocolV1: protocolV1Messages,
+                        protocolV2: this.messagesV2,
+                    },
+                    router: transport.PROTOCOL_V2_CHANNEL_USB,
+                    writeFrame: (frame) => this.transferOutWithRetry(path, frame),
+                    readFrame: () => this.receiveProtocolV2Frame(path, this.protocolV2ReadTimeouts.get(path)),
+                    logger: this.Log,
+                    logPrefix: 'ProtocolV2 WebUSB',
+                    createTimeoutError: (messageName, timeoutMs) => new Error(`Protocol V2 response timeout after ${timeoutMs}ms for ${messageName}`),
+                });
+                this.protocolV2Sessions.set(path, session);
+            }
+            this.protocolV2ReadTimeouts.set(path, options === null || options === void 0 ? void 0 : options.timeoutMs);
+            (_a = this.protocolV2Assemblers.get(path)) === null || _a === void 0 ? void 0 : _a.reset();
+            try {
+                return yield session.call(name, data, options);
+            }
+            finally {
+                this.protocolV2ReadTimeouts.delete(path);
+            }
+        });
+    }
+    receiveProtocolV2Frame(path, timeoutMs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let assembler = this.protocolV2Assemblers.get(path);
+            if (!assembler) {
+                assembler = new transport.ProtocolV2FrameAssembler(transport.PROTOCOL_V2_FRAME_MAX_BYTES);
+                this.protocolV2Assemblers.set(path, assembler);
+            }
+            let frame = assembler.push(new Uint8Array(0));
+            const deadline = timeoutMs ? Date.now() + timeoutMs : undefined;
+            while (!frame) {
+                const cancelToken = { cancelled: false };
+                const transferIn = this.transferInWithRetry(path, transport.PROTOCOL_V2_FRAME_MAX_BYTES, cancelToken);
+                const dataView = deadline
+                    ? yield this.withProtocolReadTimeout(path, transferIn, Math.max(deadline - Date.now(), 1), 'V2', () => {
+                        cancelToken.cancelled = true;
+                    })
+                    : yield transferIn;
+                const bytes = new Uint8Array(this.toArrayBuffer(dataView.buffer.slice(dataView.byteOffset, dataView.byteOffset + dataView.byteLength)));
+                try {
+                    frame = assembler.push(bytes);
+                }
+                catch (error) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NetworkError, error instanceof Error ? error.message : String(error));
+                }
+            }
+            return frame;
+        });
+    }
+    receiveData(path, timeoutMs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deadline = timeoutMs ? Date.now() + timeoutMs : undefined;
+            const readPacket = () => __awaiter(this, void 0, void 0, function* () {
+                const cancelToken = { cancelled: false };
+                const transferIn = this.transferInWithRetry(path, PACKET_SIZE, cancelToken);
+                return deadline
+                    ? this.withProtocolReadTimeout(path, transferIn, Math.max(deadline - Date.now(), 1), 'V1', () => {
+                        cancelToken.cancelled = true;
+                    })
+                    : transferIn;
+            });
+            const firstPacketData = yield readPacket();
             const firstData = this.toArrayBuffer(firstPacketData.buffer.slice(1));
-            const { length, typeId, restBuffer } = decodeProtocol.decodeChunked(firstData);
+            const { length, typeId, restBuffer } = ProtocolV1$1.decodeFirstChunk(firstData);
             const lengthWithHeader = Number(length + HEADER_LENGTH);
             const decoded = new ByteBuffer__default["default"](lengthWithHeader);
             decoded.writeUint16(typeId);
@@ -343,9 +711,9 @@ class WebUsbTransport {
                 decoded.append(restBuffer);
             }
             while (decoded.offset < lengthWithHeader) {
-                const packetData = yield this.transferInWithRetry(path, PACKET_SIZE);
+                const packetData = yield readPacket();
                 const buffer = this.toArrayBuffer(packetData.buffer.slice(1));
-                if (lengthWithHeader - decoded.offset >= PACKET_SIZE) {
+                if (lengthWithHeader - decoded.offset >= PAYLOAD_SIZE) {
                     decoded.append(buffer);
                 }
                 else {
@@ -358,24 +726,64 @@ class WebUsbTransport {
         });
     }
     release(path) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             const device = yield this.findDevice(path);
-            yield device.releaseInterface(this.interfaceId);
+            const endpoints = this.deviceEndpoints.get(path);
+            const ifaceNum = (_a = endpoints === null || endpoints === void 0 ? void 0 : endpoints.interfaceNumber) !== null && _a !== void 0 ? _a : this.interfaceId;
+            yield device.releaseInterface(ifaceNum);
             yield device.close();
+            this.deviceProtocol.delete(path);
+            this.deviceProtocolHints.delete(path);
+            (_b = this.protocolV2Assemblers.get(path)) === null || _b === void 0 ? void 0 : _b.reset();
+            this.protocolV2Assemblers.delete(path);
+            this.deviceEndpoints.delete(path);
         });
     }
+    getProtocolType(path) {
+        return this.deviceProtocol.get(path);
+    }
 }
 
-const { parseConfigure, buildBuffers, receiveOne, check } = transport__default["default"];
+const FILE_WRITE_LOG_BLOCK_PATTERN = /(?:^|[^a-z])(?:raw)?(?:filesystem|emmc)?filewrite$/i;
+function shouldSuppressHighVolumeCallLog(name) {
+    const normalized = name.replace(/[_\s-]/g, '');
+    return FILE_WRITE_LOG_BLOCK_PATTERN.test(normalized);
+}
+function isLogBlockCommand(name) {
+    var _a, _b;
+    return (_b = (_a = transport.LogBlockCommand === null || transport.LogBlockCommand === void 0 ? void 0 : transport.LogBlockCommand.has) === null || _a === void 0 ? void 0 : _a.call(transport.LogBlockCommand, name)) !== null && _b !== void 0 ? _b : false;
+}
+const { parseConfigure, ProtocolV1, check } = transport__default["default"];
+function inferProtocolHintFromDeviceName(name) {
+    return /\bpro\s*2\b/i.test(name !== null && name !== void 0 ? name : '') ? 'V2' : undefined;
+}
+const toBleDescriptor = (device, protocolType) => (Object.assign({ id: device.id, name: device.name, path: device.id, debug: false, commType: 'electron-ble' }, (protocolType ? { protocolType } : {})));
+const BLE_PACKET_SIZE = 192;
+const BLE_WRITE_DELAY_MS = 5;
+const BLE_WRITE_MAX_RETRIES = 3;
+const BLE_WRITE_RETRY_DELAY_MS = 300;
+const BLE_RESPONSE_TIMEOUT_MS = 30000;
+const PROTOCOL_PROBE_TIMEOUT_MS = 1000;
+const PROTOCOL_V2_PROBE_TIMEOUT_MS = 5000;
 class ElectronBleTransport {
     constructor() {
         this.name = 'ElectronBleTransport';
         this.configured = false;
         this.runPromise = null;
         this.connectedDevices = new Set();
-        this.dataBuffers = new Map();
+        this.deviceProtocol = new Map();
+        this.deviceProtocolHints = new Map();
+        this.v1Buffers = new Map();
+        this.v2Assemblers = new Map();
+        this.v2FrameQueues = new Map();
+        this.v2FramePromises = new Map();
+        this.activeProtocolV2Call = null;
+        this.nextProtocolV2CallToken = 1;
         this.notificationCleanups = new Map();
         this.disconnectCleanups = new Map();
+        this.notificationTokens = new Map();
+        this.nextNotificationToken = 1;
     }
     handleBluetoothError(error) {
         if (error && typeof error === 'object') {
@@ -407,8 +815,16 @@ class ElectronBleTransport {
         throw error;
     }
     cleanupDeviceState(deviceId) {
+        var _a;
         this.connectedDevices.delete(deviceId);
-        this.dataBuffers.delete(deviceId);
+        this.deviceProtocol.delete(deviceId);
+        this.v1Buffers.delete(deviceId);
+        this.v2Assemblers.delete(deviceId);
+        this.resetProtocolV2Frames(deviceId);
+        if (((_a = this.activeProtocolV2Call) === null || _a === void 0 ? void 0 : _a.uuid) === deviceId) {
+            this.activeProtocolV2Call = null;
+        }
+        this.notificationTokens.delete(deviceId);
         const notifyCleanup = this.notificationCleanups.get(deviceId);
         if (notifyCleanup) {
             notifyCleanup();
@@ -427,39 +843,59 @@ class ElectronBleTransport {
         if (!((_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle)) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Noble BLE API is not available. Please ensure you are running in Electron with Noble support.');
         }
-        (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('[Transport] Noble BLE Transport initialized');
+        (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('[Electron BLE] Transport initialized');
     }
     configure(signedData) {
-        const messages = parseConfigure(signedData);
+        this._messages = parseConfigure(signedData);
         this.configured = true;
-        this._messages = messages;
     }
-    listen() { }
+    configureProtocolV2(signedData) {
+        var _a;
+        this._messagesV2 = parseConfigure(signedData);
+        (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Electron BLE] Protocol V2 schema configured');
+    }
+    listen() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.enumerate();
+        });
+    }
     enumerate() {
-        var _a, _b;
+        var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 if (!((_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle)) {
                     throw new Error('Noble BLE API not available');
                 }
                 const devices = yield window.desktopApi.nobleBle.enumerate();
-                return devices;
+                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug(`[Electron BLE] enumerate found ${devices.length} device(s):`);
+                for (const dev of devices) {
+                    (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug(`[Electron BLE]   id="${dev.id}" name="${dev.name}"`);
+                    const protocolHint = inferProtocolHintFromDeviceName(dev.name);
+                    if (protocolHint) {
+                        this.deviceProtocolHints.set(dev.id, protocolHint);
+                    }
+                }
+                return devices.map(device => toBleDescriptor(device));
             }
             catch (error) {
-                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.error('[Transport] Noble BLE enumerate failed:', error);
+                (_d = this.Log) === null || _d === void 0 ? void 0 : _d.error('[Electron BLE] enumerate failed:', error);
                 this.handleBluetoothError(error);
             }
         });
     }
     acquire(input) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e, _f;
         return __awaiter(this, void 0, void 0, function* () {
-            const { uuid, forceCleanRunPromise } = input;
+            const { uuid, forceCleanRunPromise, expectedProtocol } = input;
             if (!uuid) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleRequiredUUID);
             }
             if (forceCleanRunPromise && this.runPromise) {
-                this.runPromise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleForceCleanRunPromise));
+                const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleForceCleanRunPromise);
+                this.runPromise.reject(error);
+                this.rejectAllProtocolV2Frames(error);
+                this.runPromise = null;
+                this.activeProtocolV2Call = null;
             }
             try {
                 if (!((_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle)) {
@@ -469,6 +905,12 @@ class ElectronBleTransport {
                 if (!device) {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `Device ${uuid} not found`);
                 }
+                const protocolHint = expectedProtocol
+                    ? undefined
+                    : (_b = this.deviceProtocolHints.get(uuid)) !== null && _b !== void 0 ? _b : inferProtocolHintFromDeviceName(device.name);
+                if (protocolHint) {
+                    this.deviceProtocolHints.set(uuid, protocolHint);
+                }
                 try {
                     yield window.desktopApi.nobleBle.connect(uuid);
                     this.connectedDevices.add(uuid);
@@ -476,13 +918,10 @@ class ElectronBleTransport {
                 catch (error) {
                     this.handleBluetoothError(error);
                 }
-                this.dataBuffers.set(uuid, { buffer: [], bufferLength: 0 });
+                this.v1Buffers.set(uuid, { buffer: [], bufferLength: 0 });
+                this.v2Assemblers.set(uuid, new transport.ProtocolV2FrameAssembler());
                 yield window.desktopApi.nobleBle.subscribe(uuid);
-                const cleanup = window.desktopApi.nobleBle.onNotification((deviceId, data) => {
-                    if (deviceId === uuid) {
-                        this.handleNotificationData(uuid, data);
-                    }
-                });
+                const cleanup = this.createNotificationSubscription(uuid);
                 this.notificationCleanups.set(uuid, cleanup);
                 const disconnectCleanup = window.desktopApi.nobleBle.onDeviceDisconnected((disconnectedDevice) => {
                     var _a;
@@ -496,138 +935,511 @@ class ElectronBleTransport {
                     }
                 });
                 this.disconnectCleanups.set(uuid, disconnectCleanup);
-                (_b = this.emitter) === null || _b === void 0 ? void 0 : _b.emit('device-connect', {
+                const protocolType = yield this.detectProtocol(uuid, expectedProtocol, protocolHint);
+                (_c = this.emitter) === null || _c === void 0 ? void 0 : _c.emit('device-connect', {
                     name: device.name,
                     id: device.id,
                     connectId: device.id,
                 });
-                return { uuid, path: uuid };
+                return Object.assign(Object.assign({}, toBleDescriptor({ id: device.id, name: device.name }, protocolType)), { uuid });
             }
             catch (error) {
-                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.error('[Transport] Noble BLE acquire failed:', error);
+                (_d = this.Log) === null || _d === void 0 ? void 0 : _d.error('[Electron BLE] acquire failed:', error);
+                try {
+                    if (((_e = window.desktopApi) === null || _e === void 0 ? void 0 : _e.nobleBle) && this.connectedDevices.has(uuid)) {
+                        yield window.desktopApi.nobleBle.unsubscribe(uuid);
+                        yield window.desktopApi.nobleBle.disconnect(uuid);
+                    }
+                }
+                catch (cleanupError) {
+                    (_f = this.Log) === null || _f === void 0 ? void 0 : _f.debug('[Electron BLE] acquire cleanup failed:', cleanupError);
+                }
+                this.cleanupDeviceState(uuid);
                 throw error;
             }
         });
     }
     release(id) {
-        var _a, _b, _c;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 if (this.connectedDevices.has(id)) {
                     if ((_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle) {
                         yield window.desktopApi.nobleBle.unsubscribe(id);
-                    }
-                    if ((_b = window.desktopApi) === null || _b === void 0 ? void 0 : _b.nobleBle) {
                         yield window.desktopApi.nobleBle.disconnect(id);
                     }
                     this.cleanupDeviceState(id);
                 }
             }
             catch (error) {
-                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.error('[Transport] Noble BLE release failed:', error);
+                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.error('[Electron BLE] release failed:', error);
                 this.cleanupDeviceState(id);
             }
         });
     }
-    handleNotificationData(deviceId, hexData) {
+    createProtocolMismatchError(expected) {
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`);
+    }
+    createProtocolDetectionError() {
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleTimeoutError, 'Unable to detect BLE protocol: device did not respond to Protocol V1 Initialize or Protocol V2 Ping');
+    }
+    clearProbeProtocol(uuid, protocol) {
+        if (this.deviceProtocol.get(uuid) === protocol) {
+            this.deviceProtocol.delete(uuid);
+        }
+    }
+    detectProtocol(uuid, expectedProtocol, protocolHint) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (expectedProtocol === 'V1') {
+                if (yield this.probeProtocolV1(uuid)) {
+                    this.deviceProtocol.set(uuid, 'V1');
+                    (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[Electron BLE] detectProtocol: uuid=${uuid} -> V1 (expected)`);
+                    return 'V1';
+                }
+                throw this.createProtocolMismatchError(expectedProtocol);
+            }
+            if (expectedProtocol === 'V2') {
+                this.deviceProtocol.set(uuid, 'V2');
+                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug(`[Electron BLE] detectProtocol: uuid=${uuid} -> V2 (expected)`);
+                return 'V2';
+            }
+            const probeOrder = protocolHint === 'V2' || this.deviceProtocol.get(uuid) === 'V2' ? ['V2', 'V1'] : ['V1', 'V2'];
+            for (let i = 0; i < probeOrder.length; i += 1) {
+                const protocol = probeOrder[i];
+                if (i > 0) {
+                    yield this.resetProbeStateAfterProtocolProbe(uuid, probeOrder[i - 1]);
+                }
+                const detected = protocol === 'V1' ? yield this.probeProtocolV1(uuid) : yield this.probeProtocolV2(uuid);
+                if (detected) {
+                    this.deviceProtocol.set(uuid, protocol);
+                    (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug(`[Electron BLE] detectProtocol: uuid=${uuid} -> ${protocol}`);
+                    return protocol;
+                }
+            }
+            this.deviceProtocol.delete(uuid);
+            throw this.createProtocolDetectionError();
+        });
+    }
+    createNotificationSubscription(uuid) {
+        var _a;
+        if (!((_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle)) {
+            throw new Error('Noble BLE API not available');
+        }
+        const notificationToken = this.nextNotificationToken;
+        this.nextNotificationToken += 1;
+        this.notificationTokens.set(uuid, notificationToken);
+        return window.desktopApi.nobleBle.onNotification((deviceId, data) => {
+            if (deviceId === uuid && this.notificationTokens.get(uuid) === notificationToken) {
+                this.handleNotification(uuid, data);
+            }
+        });
+    }
+    resetProbeStateAfterProtocolProbe(uuid, protocol) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.v1Buffers.set(uuid, { buffer: [], bufferLength: 0 });
+            (_a = this.v2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
+            this.resetProtocolV2Frames(uuid);
+            if (((_b = this.activeProtocolV2Call) === null || _b === void 0 ? void 0 : _b.uuid) === uuid) {
+                this.activeProtocolV2Call = null;
+            }
+            if (this.runPromise) {
+                const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleForceCleanRunPromise);
+                this.runPromise.reject(error);
+                this.runPromise = null;
+            }
+            const notifyCleanup = this.notificationCleanups.get(uuid);
+            if (notifyCleanup) {
+                notifyCleanup();
+                this.notificationCleanups.delete(uuid);
+            }
+            this.notificationTokens.delete(uuid);
+            try {
+                yield ((_d = (_c = window.desktopApi) === null || _c === void 0 ? void 0 : _c.nobleBle) === null || _d === void 0 ? void 0 : _d.unsubscribe(uuid));
+            }
+            catch (error) {
+                (_e = this.Log) === null || _e === void 0 ? void 0 : _e.debug(`[Electron BLE] unsubscribe after Protocol ${protocol} probe failed:`, error);
+            }
+            try {
+                yield ((_g = (_f = window.desktopApi) === null || _f === void 0 ? void 0 : _f.nobleBle) === null || _g === void 0 ? void 0 : _g.subscribe(uuid));
+            }
+            catch (error) {
+                (_h = this.Log) === null || _h === void 0 ? void 0 : _h.debug(`[Electron BLE] resubscribe after Protocol ${protocol} probe failed:`, error);
+                throw error;
+            }
+            const cleanup = this.createNotificationSubscription(uuid);
+            this.notificationCleanups.set(uuid, cleanup);
+        });
+    }
+    probeProtocolV1(uuid) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._messages) {
+                return false;
+            }
+            try {
+                this.deviceProtocol.set(uuid, 'V1');
+                yield this.callProtocolV1(uuid, 'Initialize', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT_MS });
+                return true;
+            }
+            catch (error) {
+                this.clearProbeProtocol(uuid, 'V1');
+                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Electron BLE] Protocol V1 Initialize probe failed:', error);
+                return false;
+            }
+        });
+    }
+    probeProtocolV2(uuid) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._messages || !this._messagesV2) {
+                return false;
+            }
+            this.deviceProtocol.set(uuid, 'V2');
+            (_a = this.v2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
+            const detected = yield transport.probeProtocolV2({
+                call: (name, data, options) => this.callProtocolV2(uuid, name, data, options),
+                timeoutMs: PROTOCOL_V2_PROBE_TIMEOUT_MS,
+                logger: this.Log,
+                logPrefix: 'ProtocolV2 BLE',
+                onProbeFailed: () => {
+                    var _a;
+                    (_a = this.v2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
+                    this.resetProtocolV2Frames(uuid);
+                },
+            });
+            if (!detected) {
+                this.clearProbeProtocol(uuid, 'V2');
+            }
+            return detected;
+        });
+    }
+    writeWithChunking(uuid, hexData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const totalBytes = hexData.length / 2;
+            if (totalBytes <= BLE_PACKET_SIZE) {
+                yield hdShared.wait(BLE_WRITE_DELAY_MS);
+                yield this.writeWithRetry(uuid, hexData);
+                return;
+            }
+            for (let offset = 0; offset < hexData.length;) {
+                const chunkHexLen = Math.min(BLE_PACKET_SIZE * 2, hexData.length - offset);
+                const chunkHex = hexData.substring(offset, offset + chunkHexLen);
+                offset += chunkHexLen;
+                yield this.writeWithRetry(uuid, chunkHex);
+                if (offset < hexData.length) {
+                    yield hdShared.wait(BLE_WRITE_DELAY_MS);
+                }
+            }
+        });
+    }
+    writeWithRetry(uuid, hexData) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            let lastError;
+            const nobleBle = (_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle;
+            if (!nobleBle) {
+                throw new Error('Noble BLE API not available');
+            }
+            for (let attempt = 1; attempt <= BLE_WRITE_MAX_RETRIES; attempt++) {
+                try {
+                    yield nobleBle.write(uuid, hexData);
+                    return;
+                }
+                catch (error) {
+                    lastError = error;
+                    (_b = this.Log) === null || _b === void 0 ? void 0 : _b.error(`[Electron BLE] write failed (attempt ${attempt}/${BLE_WRITE_MAX_RETRIES}):`, error);
+                    if (attempt < BLE_WRITE_MAX_RETRIES) {
+                        yield hdShared.wait(BLE_WRITE_RETRY_DELAY_MS);
+                    }
+                }
+            }
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError, `BLE write failed after ${BLE_WRITE_MAX_RETRIES} attempts: ${(_c = lastError === null || lastError === void 0 ? void 0 : lastError.message) !== null && _c !== void 0 ? _c : lastError}`);
+        });
+    }
+    handleNotification(deviceId, hexData) {
         var _a, _b;
         if (hexData === 'PAIRING_REJECTED') {
-            (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Transport] Pairing rejection detected for device:', deviceId);
+            (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Electron BLE] Pairing rejection detected for device:', deviceId);
             if (this.runPromise) {
-                this.runPromise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceBondedCanceled));
+                const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceBondedCanceled);
+                this.runPromise.reject(error);
+                this.rejectAllProtocolV2Frames(error);
             }
             return;
         }
-        const result = this.processNotificationPacket(deviceId, hexData);
-        if (result.error) {
-            (_b = this.Log) === null || _b === void 0 ? void 0 : _b.error('[Transport] Packet processing error:', result.error);
+        const protocol = this.deviceProtocol.get(deviceId);
+        if (!protocol) {
+            (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('[Electron BLE] Ignore notification before protocol detection:', deviceId);
+            return;
+        }
+        if (protocol === 'V2') {
+            this.handleProtocolV2Notification(deviceId, hexData);
+            return;
+        }
+        this.handleProtocolV1Notification(deviceId, hexData);
+    }
+    handleProtocolV2Notification(deviceId, hexData) {
+        var _a, _b, _c;
+        try {
+            if (!this.runPromise || ((_a = this.activeProtocolV2Call) === null || _a === void 0 ? void 0 : _a.uuid) !== deviceId) {
+                (_b = this.v2Assemblers.get(deviceId)) === null || _b === void 0 ? void 0 : _b.reset();
+                this.resetProtocolV2Frames(deviceId);
+                return;
+            }
+            const bytes = transport.hexToBytes(hexData);
+            if (bytes.length === 0)
+                return;
+            const assembler = this.v2Assemblers.get(deviceId);
+            if (!assembler)
+                return;
+            for (const frameData of assembler.drain(bytes)) {
+                this.resolveProtocolV2Frame(deviceId, frameData);
+            }
+        }
+        catch (error) {
+            (_c = this.Log) === null || _c === void 0 ? void 0 : _c.error('[Electron BLE] Protocol V2 notification error:', error);
             if (this.runPromise) {
-                this.runPromise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError));
+                const notifyError = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError);
+                this.runPromise.reject(notifyError);
+                this.rejectAllProtocolV2Frames(notifyError);
             }
+        }
+    }
+    getProtocolV2FrameQueue(uuid) {
+        let queue = this.v2FrameQueues.get(uuid);
+        if (!queue) {
+            queue = [];
+            this.v2FrameQueues.set(uuid, queue);
+        }
+        return queue;
+    }
+    resolveProtocolV2Frame(uuid, frame) {
+        const framePromise = this.v2FramePromises.get(uuid);
+        if (framePromise) {
+            framePromise.resolve(frame);
+            this.v2FramePromises.delete(uuid);
             return;
         }
-        if (result.isComplete && result.completePacket) {
+        this.getProtocolV2FrameQueue(uuid).push(frame);
+    }
+    rejectAllProtocolV2Frames(error) {
+        this.v2FrameQueues.clear();
+        for (const framePromise of this.v2FramePromises.values()) {
+            framePromise.reject(error);
+        }
+        this.v2FramePromises.clear();
+    }
+    resetProtocolV2Frames(uuid) {
+        this.v2FrameQueues.delete(uuid);
+        this.v2FramePromises.delete(uuid);
+    }
+    isActiveProtocolV2Call(uuid, token) {
+        var _a;
+        return ((_a = this.activeProtocolV2Call) === null || _a === void 0 ? void 0 : _a.uuid) === uuid && this.activeProtocolV2Call.token === token;
+    }
+    readProtocolV2Frame(uuid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queuedFrame = this.getProtocolV2FrameQueue(uuid).shift();
+            if (queuedFrame) {
+                return queuedFrame;
+            }
+            const framePromise = hdShared.createDeferred();
+            this.v2FramePromises.set(uuid, framePromise);
+            try {
+                return yield framePromise.promise;
+            }
+            finally {
+                if (this.v2FramePromises.get(uuid) === framePromise) {
+                    this.v2FramePromises.delete(uuid);
+                }
+            }
+        });
+    }
+    handleProtocolV1Notification(deviceId, hexData) {
+        var _a;
+        const result = this.processProtocolV1Notification(deviceId, hexData);
+        if (result.error) {
+            (_a = this.Log) === null || _a === void 0 ? void 0 : _a.error('[Electron BLE] Protocol V1 packet processing error:', result.error);
             if (this.runPromise) {
-                this.runPromise.resolve(result.completePacket);
+                this.runPromise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError));
             }
+            return;
+        }
+        if (result.isComplete && result.completePacket && this.runPromise) {
+            this.runPromise.resolve(result.completePacket);
         }
     }
-    call(uuid, name, data) {
-        var _a, _b, _c, _d, _e, _f, _g;
+    call(uuid, name, data, options) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            if (this._messages == null) {
+            if (!this._messages) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
             }
-            const forceRun = name === 'Initialize' || name === 'Cancel';
-            if (this.runPromise && !forceRun) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportCallInProgress);
-            }
             if (!this.connectedDevices.has(uuid)) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotFound, `Device ${uuid} not connected`);
             }
-            this.runPromise = hdShared.createDeferred();
-            const messages = this._messages;
-            if (name === 'ResourceUpdate' || name === 'ResourceAck') {
-                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Transport] Noble BLE call', 'name:', name, 'data:', {
-                    file_name: data === null || data === void 0 ? void 0 : data.file_name,
-                    hash: data === null || data === void 0 ? void 0 : data.hash,
-                });
+            const protocol = this.deviceProtocol.get(uuid);
+            if (!protocol) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol has not been detected for ${uuid}`);
             }
-            else if (transport.LogBlockCommand.has(name)) {
-                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('[Transport] Noble BLE call', 'name:', name);
+            if (shouldSuppressHighVolumeCallLog(name)) ;
+            else if (isLogBlockCommand(name)) {
+                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Electron BLE] call', 'name:', name, 'protocol:', protocol);
             }
             else {
-                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug('[Transport] Noble BLE call', 'name:', name, 'data:', data);
+                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('[Electron BLE] call', 'name:', name, 'data:', data, 'protocol:', protocol);
+            }
+            if (protocol === 'V2') {
+                return this.callProtocolV2(uuid, name, data, options);
+            }
+            return this.callProtocolV1(uuid, name, data, options);
+        });
+    }
+    callProtocolV1(uuid, name, data, options) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._messages) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
+            }
+            const forceRun = name === 'Initialize' || name === 'Cancel';
+            if (this.runPromise && !forceRun) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportCallInProgress);
             }
-            const buffers = buildBuffers(messages, name, data);
+            const runPromise = hdShared.createDeferred();
+            runPromise.promise.catch(() => undefined);
+            this.runPromise = runPromise;
+            const messages = this._messages;
+            const buffers = ProtocolV1.encodeTransportPackets(messages, name, data);
+            let timeout;
             try {
-                if (!((_d = window.desktopApi) === null || _d === void 0 ? void 0 : _d.nobleBle)) {
+                if (!((_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle)) {
                     throw new Error('Noble BLE write API not available');
                 }
                 for (let i = 0; i < buffers.length; i++) {
                     const buffer = buffers[i];
                     if (!buffer || typeof buffer.toString !== 'function') {
-                        (_e = this.Log) === null || _e === void 0 ? void 0 : _e.error(`[Transport] Noble BLE buffer ${i + 1} is invalid:`, buffer);
                         throw new Error(`Buffer ${i + 1} is invalid`);
                     }
                     const hexString = buffer.toString('hex');
                     if (hexString.length === 0) {
-                        (_f = this.Log) === null || _f === void 0 ? void 0 : _f.error(`[Transport] Noble BLE buffer ${i + 1} generated empty hex string`);
                         throw new Error(`Buffer ${i + 1} is empty`);
                     }
                     yield window.desktopApi.nobleBle.write(uuid, hexString);
                 }
-                const response = yield this.runPromise.promise;
+                const response = yield Promise.race([
+                    runPromise.promise,
+                    new Promise((_, reject) => {
+                        if (options === null || options === void 0 ? void 0 : options.timeoutMs) {
+                            timeout = setTimeout(() => {
+                                const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleTimeoutError, `BLE response timeout after ${options.timeoutMs}ms for ${name}`);
+                                runPromise.reject(error);
+                                reject(error);
+                            }, options.timeoutMs);
+                        }
+                    }),
+                ]);
                 if (typeof response !== 'string') {
                     throw new Error('Returning data is not string.');
                 }
-                const jsonData = receiveOne(messages, response);
+                const jsonData = ProtocolV1.decodeMessage(messages, response);
                 return check.call(jsonData);
             }
             catch (e) {
-                (_g = this.Log) === null || _g === void 0 ? void 0 : _g.error('[Transport] Noble BLE call error:', e);
+                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.error('[Electron BLE] Protocol V1 call error:', e);
                 throw e;
             }
             finally {
+                if (timeout)
+                    clearTimeout(timeout);
+                if (this.runPromise === runPromise) {
+                    this.runPromise = null;
+                }
+            }
+        });
+    }
+    callProtocolV2(uuid, name, data, options) {
+        var _a, _b, _c, _d, _e;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._messages || !this._messagesV2) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
+            }
+            const forceRun = name === 'Initialize' || name === 'Cancel' || name === 'GetProtoVersion';
+            if (this.runPromise) {
+                if (!forceRun) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportCallInProgress);
+                }
+                const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleForceCleanRunPromise);
+                this.runPromise.reject(error);
+                this.rejectAllProtocolV2Frames(error);
                 this.runPromise = null;
+                this.activeProtocolV2Call = null;
+            }
+            const runPromise = hdShared.createDeferred();
+            runPromise.promise.catch(() => undefined);
+            this.runPromise = runPromise;
+            const callToken = this.nextProtocolV2CallToken++;
+            this.activeProtocolV2Call = { uuid, token: callToken };
+            (_a = this.v2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
+            this.resetProtocolV2Frames(uuid);
+            let completed = false;
+            const callOptions = Object.assign(Object.assign({}, options), { timeoutMs: (_b = options === null || options === void 0 ? void 0 : options.timeoutMs) !== null && _b !== void 0 ? _b : BLE_RESPONSE_TIMEOUT_MS });
+            try {
+                const session = new transport.ProtocolV2Session({
+                    schemas: {
+                        protocolV1: this._messages,
+                        protocolV2: this._messagesV2,
+                    },
+                    router: transport.PROTOCOL_V2_CHANNEL_BLE_UART,
+                    writeFrame: (frame) => this.writeWithChunking(uuid, transport.bytesToHex(frame)),
+                    readFrame: () => __awaiter(this, void 0, void 0, function* () {
+                        const rxFrame = yield this.readProtocolV2Frame(uuid);
+                        if (!(rxFrame instanceof Uint8Array)) {
+                            throw new Error('Response is not Uint8Array');
+                        }
+                        return rxFrame;
+                    }),
+                    logger: this.Log,
+                    logPrefix: 'ProtocolV2 BLE',
+                    createTimeoutError: (_messageName, timeout) => hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleTimeoutError, `BLE response timeout after ${timeout}ms for ${name}`),
+                });
+                const result = yield session.call(name, data, callOptions);
+                completed = true;
+                return result;
+            }
+            catch (e) {
+                if (this.isActiveProtocolV2Call(uuid, callToken)) {
+                    (_c = this.v2Assemblers.get(uuid)) === null || _c === void 0 ? void 0 : _c.reset();
+                    this.resetProtocolV2Frames(uuid);
+                }
+                (_d = this.Log) === null || _d === void 0 ? void 0 : _d.error('[Electron BLE] Protocol V2 call error:', e);
+                throw e;
+            }
+            finally {
+                if (this.isActiveProtocolV2Call(uuid, callToken)) {
+                    if (!completed) {
+                        (_e = this.v2Assemblers.get(uuid)) === null || _e === void 0 ? void 0 : _e.reset();
+                    }
+                    this.resetProtocolV2Frames(uuid);
+                    this.activeProtocolV2Call = null;
+                }
+                if (this.runPromise === runPromise) {
+                    this.runPromise = null;
+                }
             }
         });
     }
-    processNotificationPacket(deviceId, hexData) {
+    processProtocolV1Notification(deviceId, hexData) {
         try {
             if (typeof hexData !== 'string') {
                 return { isComplete: false, error: 'Invalid hexData type' };
             }
-            const cleanHexData = hexData.replace(/\s+/g, '');
-            if (!/^[0-9A-Fa-f]*$/.test(cleanHexData)) {
-                return { isComplete: false, error: 'Invalid hex data format' };
+            const data = transport.hexToBytes(hexData);
+            if (data.length === 0) {
+                return { isComplete: false, error: 'Empty or invalid hex data' };
             }
-            const hexMatch = cleanHexData.match(/.{1,2}/g);
-            if (!hexMatch) {
-                return { isComplete: false, error: 'Failed to parse hex data' };
-            }
-            const data = new Uint8Array(hexMatch.map(byte => parseInt(byte, 16)));
-            const bufferState = this.dataBuffers.get(deviceId);
+            const bufferState = this.v1Buffers.get(deviceId);
             if (!bufferState) {
                 return { isComplete: false, error: 'No buffer state for device' };
             }
@@ -639,14 +1451,11 @@ class ElectronBleTransport {
             else {
                 bufferState.buffer = bufferState.buffer.concat([...data]);
             }
-            if (bufferState.buffer.length - transport.COMMON_HEADER_SIZE >= bufferState.bufferLength) {
+            if (bufferState.buffer.length - transport.PROTOCOL_V1_MESSAGE_HEADER_SIZE >= bufferState.bufferLength) {
                 const completeBuffer = new Uint8Array(bufferState.buffer);
                 bufferState.bufferLength = 0;
                 bufferState.buffer = [];
-                const hexString = Array.from(completeBuffer)
-                    .map(b => b.toString(16).padStart(2, '0'))
-                    .join('');
-                return { isComplete: true, completePacket: hexString };
+                return { isComplete: true, completePacket: transport.bytesToHex(completeBuffer) };
             }
             return { isComplete: false };
         }
@@ -654,6 +1463,9 @@ class ElectronBleTransport {
             return { isComplete: false, error: `Packet processing error: ${error}` };
         }
     }
+    getProtocolType(path) {
+        return this.deviceProtocol.get(path);
+    }
 }
 
 exports.ElectronBleTransport = ElectronBleTransport;