@onekeyfe/hd-transport-web-device 1.1.26 → 1.1.27-alpha.31

package/dist/index.js

@@ -41,16 +41,31 @@ 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$2, check: check$2, ProtocolV1: ProtocolV1$2 } = 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 shouldBlockWebUsbCallDataLog(name) {
+    const normalized = name.replace(/[_\s-]/g, '');
+    return transport.LogBlockCommand.has(name) || WEBUSB_FILE_WRITE_LOG_BLOCK_PATTERN.test(normalized);
+}
 class WebUsbTransport {
     constructor() {
+        this.deviceProtocol = new Map();
+        this.protocolV2Assemblers = new Map();
+        this.deviceEndpoints = new Map();
         this.name = 'WebUsbTransport';
         this.stopped = false;
         this.configured = false;
@@ -68,10 +83,15 @@ class WebUsbTransport {
         this.usb = usb;
     }
     configure(signedData) {
-        const messages = parseConfigure$1(signedData);
+        const messages = parseConfigure$2(signedData);
         this.configured = true;
         this.messages = messages;
     }
+    configureProtocolV2(signedData) {
+        var _a;
+        this.messagesV2 = parseConfigure$2(signedData);
+        (_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)
@@ -107,6 +127,10 @@ class WebUsbTransport {
                 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;
         });
     }
@@ -117,6 +141,7 @@ class WebUsbTransport {
                 return;
             try {
                 yield this.connect((_a = input.path) !== null && _a !== void 0 ? _a : '', true);
+                yield this.detectProtocol(input.path, input.expectedProtocol);
                 return yield Promise.resolve(input.path);
             }
             catch (e) {
@@ -125,6 +150,41 @@ class WebUsbTransport {
             }
         });
     }
+    createProtocolMismatchError(expected) {
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`);
+    }
+    detectProtocol(path, expectedProtocol) {
+        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') {
+                if (yield this.probeProtocolV2(path)) {
+                    this.deviceProtocol.set(path, 'V2');
+                    this.Log.debug(`[WebUsbTransport] detectProtocol: path=${path} -> V2 (expected)`);
+                    return 'V2';
+                }
+                throw this.createProtocolMismatchError(expectedProtocol);
+            }
+            if (this.deviceProtocol.get(path) === 'V2' && (yield this.probeProtocolV2(path))) {
+                this.deviceProtocol.set(path, 'V2');
+                this.Log.debug(`[WebUsbTransport] detectProtocol: path=${path} -> V2 (cached)`);
+                return 'V2';
+            }
+            let protocol = 'V1';
+            if (!(yield this.probeProtocolV1(path)) && (yield this.probeProtocolV2(path))) {
+                protocol = 'V2';
+            }
+            this.deviceProtocol.set(path, protocol);
+            this.Log.debug(`[WebUsbTransport] detectProtocol: path=${path} -> ${protocol}`);
+            return protocol;
+        });
+    }
     findDevice(path) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.deviceList.length === 0) {
@@ -157,19 +217,50 @@ 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) {
         return __awaiter(this, void 0, void 0, function* () {
             const device = yield this.findDevice(path);
+            this.Log.debug('[WebUsbTransport] connecting to device:', device.productName, 'PID:', device.productId);
             yield device.open();
-            if (first) {
+            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);
+            if (!this.protocolV2Assemblers.has(path)) {
+                this.protocolV2Assemblers.set(path, new transport.ProtocolV2FrameAssembler(transport.PROTOCOL_V2_FRAME_MAX_BYTES));
+            }
+            yield device.claimInterface(endpoints.interfaceNumber);
         });
     }
     post(session, name, data) {
@@ -199,14 +290,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 +333,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 +342,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 +366,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 +405,99 @@ 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();
+            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();
+                            try {
+                                yield this.resetConnectionAfterProbe(path);
+                            }
+                            catch (error) {
+                                this.Log.debug(`[WebUsbTransport] reset after Protocol ${protocol} timeout failed:`, error);
+                            }
+                            finally {
+                                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) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             if (this.messages == null) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
@@ -308,33 +506,110 @@ 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 = (_a = this.deviceProtocol.get(path)) !== null && _a !== void 0 ? _a : 'V1';
+            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);
             }
-            const encodeBuffers = buildEncodeBuffers(messages, name, data);
+            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 = ProtocolV1$2.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);
-            return check$1.call(jsonData);
+            const jsonData = ProtocolV1$2.decodeMessage(messages, resData);
+            return check$2.call(jsonData);
+        });
+    }
+    callProtocolV2(path, name, data, options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            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);
+            }
+            const 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, options === null || options === void 0 ? void 0 : options.timeoutMs),
+                logger: this.Log,
+                logPrefix: 'ProtocolV2 WebUSB',
+                createTimeoutError: (_messageName, timeoutMs) => new Error(`Protocol V2 response timeout after ${timeoutMs}ms for ${name}`),
+            });
+            (_a = this.protocolV2Assemblers.get(path)) === null || _a === void 0 ? void 0 : _a.reset();
+            return session.call(name, data, options);
+        });
+    }
+    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) {
+    receiveData(path, timeoutMs) {
         return __awaiter(this, void 0, void 0, function* () {
-            const firstPacketData = yield this.transferInWithRetry(path, PACKET_SIZE);
+            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$2.decodeFirstChunk(firstData);
             const lengthWithHeader = Number(length + HEADER_LENGTH);
             const decoded = new ByteBuffer__default["default"](lengthWithHeader);
             decoded.writeUint16(typeId);
@@ -343,9 +618,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,15 +633,26 @@ 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);
+            (_b = this.protocolV2Assemblers.get(path)) === null || _b === void 0 ? void 0 : _b.reset();
+            this.protocolV2Assemblers.delete(path);
+            this.deviceEndpoints.delete(path);
         });
     }
+    getProtocolType(path) {
+        var _a;
+        return (_a = this.deviceProtocol.get(path)) !== null && _a !== void 0 ? _a : 'V1';
+    }
 }
 
-const { parseConfigure, buildBuffers, receiveOne, check } = transport__default["default"];
+const { parseConfigure: parseConfigure$1, ProtocolV1: ProtocolV1$1, check: check$1 } = transport__default["default"];
 class ElectronBleTransport {
     constructor() {
         this.name = 'ElectronBleTransport';
@@ -377,6 +663,9 @@ class ElectronBleTransport {
         this.notificationCleanups = new Map();
         this.disconnectCleanups = new Map();
     }
+    getProtocolType(_path) {
+        return 'V1';
+    }
     handleBluetoothError(error) {
         if (error && typeof error === 'object') {
             if ('code' in error) {
@@ -430,7 +719,7 @@ class ElectronBleTransport {
         (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('[Transport] Noble BLE Transport initialized');
     }
     configure(signedData) {
-        const messages = parseConfigure(signedData);
+        const messages = parseConfigure$1(signedData);
         this.configured = true;
         this._messages = messages;
     }
@@ -579,7 +868,7 @@ class ElectronBleTransport {
             else {
                 (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug('[Transport] Noble BLE call', 'name:', name, 'data:', data);
             }
-            const buffers = buildBuffers(messages, name, data);
+            const buffers = ProtocolV1$1.encodeTransportPackets(messages, name, data);
             try {
                 if (!((_d = window.desktopApi) === null || _d === void 0 ? void 0 : _d.nobleBle)) {
                     throw new Error('Noble BLE write API not available');
@@ -601,8 +890,8 @@ class ElectronBleTransport {
                 if (typeof response !== 'string') {
                     throw new Error('Returning data is not string.');
                 }
-                const jsonData = receiveOne(messages, response);
-                return check.call(jsonData);
+                const jsonData = ProtocolV1$1.decodeMessage(messages, response);
+                return check$1.call(jsonData);
             }
             catch (e) {
                 (_g = this.Log) === null || _g === void 0 ? void 0 : _g.error('[Transport] Noble BLE call error:', e);
@@ -639,7 +928,624 @@ 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: false };
+        }
+        catch (error) {
+            return { isComplete: false, error: `Packet processing error: ${error}` };
+        }
+    }
+}
+
+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);
+}
+const { parseConfigure, ProtocolV1, check } = transport__default["default"];
+function inferProtocolTypeFromDeviceName(name) {
+    return /\bpro\s*2\b/i.test(name !== null && name !== void 0 ? name : '') ? 'V2' : undefined;
+}
+const toBleDescriptor = (device, protocolType) => {
+    const resolvedProtocolType = protocolType !== null && protocolType !== void 0 ? protocolType : inferProtocolTypeFromDeviceName(device.name);
+    return Object.assign({ id: device.id, name: device.name, path: device.id, debug: false, commType: 'electron-ble' }, (resolvedProtocolType ? { protocolType: resolvedProtocolType } : {}));
+};
+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;
+class ElectronAutoBleTransport {
+    constructor() {
+        this.name = 'ElectronAutoBleTransport';
+        this.configured = false;
+        this.runPromise = null;
+        this.connectedDevices = new Set();
+        this.deviceProtocol = new Map();
+        this.v1Buffers = new Map();
+        this.v2Assemblers = new Map();
+        this.v2FrameQueue = [];
+        this.v2FramePromise = null;
+        this.notificationCleanups = new Map();
+        this.disconnectCleanups = new Map();
+    }
+    handleBluetoothError(error) {
+        if (error && typeof error === 'object') {
+            if ('code' in error) {
+                if (error.code === hdShared.HardwareErrorCode.BlePoweredOff) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePoweredOff);
+                }
+                if (error.code === hdShared.HardwareErrorCode.BleUnsupported) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleUnsupported);
+                }
+                if (error.code === hdShared.HardwareErrorCode.BlePermissionError) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePermissionError);
+                }
+            }
+            const errorMessage = error.message || String(error);
+            const poweredOffMessage = hdShared.HardwareErrorCodeMessage[hdShared.HardwareErrorCode.BlePoweredOff];
+            const unsupportedMessage = hdShared.HardwareErrorCodeMessage[hdShared.HardwareErrorCode.BleUnsupported];
+            const permissionMessage = hdShared.HardwareErrorCodeMessage[hdShared.HardwareErrorCode.BlePermissionError];
+            if (errorMessage.includes(poweredOffMessage) || errorMessage.includes('poweredOff')) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePoweredOff);
+            }
+            if (errorMessage.includes(unsupportedMessage) || errorMessage.includes('unsupported')) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleUnsupported);
+            }
+            if (errorMessage.includes(permissionMessage) || errorMessage.includes('unauthorized')) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePermissionError);
+            }
+        }
+        throw error;
+    }
+    cleanupDeviceState(deviceId) {
+        this.connectedDevices.delete(deviceId);
+        this.deviceProtocol.delete(deviceId);
+        this.v1Buffers.delete(deviceId);
+        this.v2Assemblers.delete(deviceId);
+        const notifyCleanup = this.notificationCleanups.get(deviceId);
+        if (notifyCleanup) {
+            notifyCleanup();
+            this.notificationCleanups.delete(deviceId);
+        }
+        const disconnectCleanup = this.disconnectCleanups.get(deviceId);
+        if (disconnectCleanup) {
+            disconnectCleanup();
+            this.disconnectCleanups.delete(deviceId);
+        }
+    }
+    init(logger, emitter) {
+        var _a, _b;
+        this.Log = logger;
+        this.emitter = emitter;
+        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('[Auto BLE] Transport initialized');
+    }
+    configure(signedData) {
+        this._messages = parseConfigure(signedData);
+        this.configured = true;
+    }
+    configureProtocolV2(signedData) {
+        var _a;
+        this._messagesV2 = parseConfigure(signedData);
+        (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Auto BLE] Protocol V2 schema configured');
+    }
+    listen() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.enumerate();
+        });
+    }
+    enumerate() {
+        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();
+                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug(`[Auto BLE] enumerate found ${devices.length} device(s):`);
+                for (const dev of devices) {
+                    (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug(`[Auto BLE]   id="${dev.id}" name="${dev.name}"`);
+                }
+                return devices.map(device => toBleDescriptor(device));
+            }
+            catch (error) {
+                (_d = this.Log) === null || _d === void 0 ? void 0 : _d.error('[Auto BLE] enumerate failed:', error);
+                this.handleBluetoothError(error);
+            }
+        });
+    }
+    acquire(input) {
+        var _a, _b, _c, _d, _e;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { uuid, forceCleanRunPromise, expectedProtocol } = input;
+            if (!uuid) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleRequiredUUID);
+            }
+            if (forceCleanRunPromise && this.runPromise) {
+                const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleForceCleanRunPromise);
+                this.runPromise.reject(error);
+                this.rejectProtocolV2Frame(error);
+            }
+            try {
+                if (!((_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle)) {
+                    throw new Error('Noble BLE API not available');
+                }
+                const device = yield window.desktopApi.nobleBle.getDevice(uuid);
+                if (!device) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `Device ${uuid} not found`);
+                }
+                try {
+                    yield window.desktopApi.nobleBle.connect(uuid);
+                    this.connectedDevices.add(uuid);
+                }
+                catch (error) {
+                    this.handleBluetoothError(error);
+                }
+                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.handleNotification(uuid, data);
+                    }
+                });
+                this.notificationCleanups.set(uuid, cleanup);
+                const disconnectCleanup = window.desktopApi.nobleBle.onDeviceDisconnected((disconnectedDevice) => {
+                    var _a;
+                    if (disconnectedDevice.id === uuid) {
+                        this.cleanupDeviceState(uuid);
+                        (_a = this.emitter) === null || _a === void 0 ? void 0 : _a.emit('device-disconnect', {
+                            name: disconnectedDevice.name,
+                            id: disconnectedDevice.id,
+                            connectId: disconnectedDevice.id,
+                        });
+                    }
+                });
+                this.disconnectCleanups.set(uuid, disconnectCleanup);
+                const protocolType = yield this.detectProtocol(uuid, expectedProtocol);
+                (_b = this.emitter) === null || _b === void 0 ? void 0 : _b.emit('device-connect', {
+                    name: device.name,
+                    id: device.id,
+                    connectId: device.id,
+                });
+                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('[Auto BLE] acquire failed:', error);
+                try {
+                    if (((_d = window.desktopApi) === null || _d === void 0 ? void 0 : _d.nobleBle) && this.connectedDevices.has(uuid)) {
+                        yield window.desktopApi.nobleBle.unsubscribe(uuid);
+                        yield window.desktopApi.nobleBle.disconnect(uuid);
+                    }
+                }
+                catch (cleanupError) {
+                    (_e = this.Log) === null || _e === void 0 ? void 0 : _e.debug('[Auto BLE] acquire cleanup failed:', cleanupError);
+                }
+                this.cleanupDeviceState(uuid);
+                throw error;
+            }
+        });
+    }
+    release(id) {
+        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);
+                        yield window.desktopApi.nobleBle.disconnect(id);
+                    }
+                    this.cleanupDeviceState(id);
+                }
+            }
+            catch (error) {
+                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.error('[Auto BLE] release failed:', error);
+                this.cleanupDeviceState(id);
+            }
+        });
+    }
+    createProtocolMismatchError(expected) {
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`);
+    }
+    detectProtocol(uuid, expectedProtocol) {
+        var _a, _b, _c, _d;
+        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(`[Auto BLE] detectProtocol: uuid=${uuid} -> V1 (expected)`);
+                    return 'V1';
+                }
+                throw this.createProtocolMismatchError(expectedProtocol);
+            }
+            if (expectedProtocol === 'V2') {
+                if (yield this.probeProtocolV2(uuid)) {
+                    this.deviceProtocol.set(uuid, 'V2');
+                    (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug(`[Auto BLE] detectProtocol: uuid=${uuid} -> V2 (expected)`);
+                    return 'V2';
+                }
+                throw this.createProtocolMismatchError(expectedProtocol);
+            }
+            if (this.deviceProtocol.get(uuid) === 'V2' && (yield this.probeProtocolV2(uuid))) {
+                this.deviceProtocol.set(uuid, 'V2');
+                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug(`[Auto BLE] detectProtocol: uuid=${uuid} -> V2 (cached)`);
+                return 'V2';
+            }
+            let protocol = 'V1';
+            if (!(yield this.probeProtocolV1(uuid)) && (yield this.probeProtocolV2(uuid))) {
+                protocol = 'V2';
+            }
+            this.deviceProtocol.set(uuid, protocol);
+            (_d = this.Log) === null || _d === void 0 ? void 0 : _d.debug(`[Auto BLE] detectProtocol: uuid=${uuid} -> ${protocol}`);
+            return protocol;
+        });
+    }
+    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) {
+                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Auto 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();
+            return transport.probeProtocolV2({
+                call: (name, data, options) => this.callProtocolV2(uuid, name, data, options),
+                timeoutMs: PROTOCOL_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();
+                },
+            });
+        });
+    }
+    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(`[Auto 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('[Auto BLE] Pairing rejection detected for device:', deviceId);
+            if (this.runPromise) {
+                const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceBondedCanceled);
+                this.runPromise.reject(error);
+                this.rejectProtocolV2Frame(error);
+            }
+            return;
+        }
+        const protocol = (_b = this.deviceProtocol.get(deviceId)) !== null && _b !== void 0 ? _b : 'V1';
+        if (protocol === 'V2') {
+            this.handleProtocolV2Notification(deviceId, hexData);
+            return;
+        }
+        this.handleProtocolV1Notification(deviceId, hexData);
+    }
+    handleProtocolV2Notification(deviceId, hexData) {
+        var _a, _b;
+        try {
+            if (!this.runPromise) {
+                (_a = this.v2Assemblers.get(deviceId)) === null || _a === void 0 ? void 0 : _a.reset();
+                this.resetProtocolV2Frames();
+                return;
+            }
+            const bytes = transport.hexToBytes(hexData);
+            if (bytes.length === 0)
+                return;
+            const assembler = this.v2Assemblers.get(deviceId);
+            if (!assembler)
+                return;
+            let frameData = assembler.push(bytes);
+            while (frameData) {
+                this.resolveProtocolV2Frame(frameData);
+                frameData = assembler.push(new Uint8Array(0));
+            }
+        }
+        catch (error) {
+            (_b = this.Log) === null || _b === void 0 ? void 0 : _b.error('[Auto BLE] Protocol V2 notification error:', error);
+            if (this.runPromise) {
+                const notifyError = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError);
+                this.runPromise.reject(notifyError);
+                this.rejectProtocolV2Frame(notifyError);
+            }
+        }
+    }
+    resolveProtocolV2Frame(frame) {
+        if (this.v2FramePromise) {
+            this.v2FramePromise.resolve(frame);
+            this.v2FramePromise = null;
+            return;
+        }
+        this.v2FrameQueue.push(frame);
+    }
+    rejectProtocolV2Frame(error) {
+        this.v2FrameQueue = [];
+        if (this.v2FramePromise) {
+            this.v2FramePromise.reject(error);
+            this.v2FramePromise = null;
+        }
+    }
+    resetProtocolV2Frames() {
+        this.v2FrameQueue = [];
+        this.v2FramePromise = null;
+    }
+    readProtocolV2Frame() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queuedFrame = this.v2FrameQueue.shift();
+            if (queuedFrame) {
+                return queuedFrame;
+            }
+            const framePromise = hdShared.createDeferred();
+            this.v2FramePromise = framePromise;
+            try {
+                return yield framePromise.promise;
+            }
+            finally {
+                if (this.v2FramePromise === framePromise) {
+                    this.v2FramePromise = null;
+                }
+            }
+        });
+    }
+    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('[Auto BLE] Protocol V1 packet processing error:', result.error);
+            if (this.runPromise) {
+                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, options) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._messages) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
+            }
+            if (!this.connectedDevices.has(uuid)) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotFound, `Device ${uuid} not connected`);
+            }
+            const protocol = (_a = this.deviceProtocol.get(uuid)) !== null && _a !== void 0 ? _a : 'V1';
+            if (shouldSuppressHighVolumeCallLog(name)) ;
+            else if (transport.LogBlockCommand.has(name)) {
+                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('[Auto BLE] call', 'name:', name, 'protocol:', protocol);
+            }
+            else {
+                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug('[Auto 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 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 (!((_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') {
+                        throw new Error(`Buffer ${i + 1} is invalid`);
+                    }
+                    const hexString = buffer.toString('hex');
+                    if (hexString.length === 0) {
+                        throw new Error(`Buffer ${i + 1} is empty`);
+                    }
+                    yield window.desktopApi.nobleBle.write(uuid, hexString);
+                }
+                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 = ProtocolV1.decodeMessage(messages, response);
+                return check.call(jsonData);
+            }
+            catch (e) {
+                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.error('[Auto 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.rejectProtocolV2Frame(error);
+                this.runPromise = null;
+            }
+            const runPromise = hdShared.createDeferred();
+            runPromise.promise.catch(() => undefined);
+            this.runPromise = runPromise;
+            (_a = this.v2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
+            this.resetProtocolV2Frames();
+            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();
+                        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) {
+                (_c = this.v2Assemblers.get(uuid)) === null || _c === void 0 ? void 0 : _c.reset();
+                this.resetProtocolV2Frames();
+                (_d = this.Log) === null || _d === void 0 ? void 0 : _d.error('[Auto BLE] Protocol V2 call error:', e);
+                throw e;
+            }
+            finally {
+                if (!completed) {
+                    (_e = this.v2Assemblers.get(uuid)) === null || _e === void 0 ? void 0 : _e.reset();
+                }
+                this.resetProtocolV2Frames();
+                if (this.runPromise === runPromise) {
+                    this.runPromise = null;
+                }
+            }
+        });
+    }
+    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 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.v1Buffers.get(deviceId);
+            if (!bufferState) {
+                return { isComplete: false, error: 'No buffer state for device' };
+            }
+            if (hdShared.isHeaderChunk(data)) {
+                const dataView = new DataView(data.buffer);
+                bufferState.bufferLength = dataView.getInt32(5, false);
+                bufferState.buffer = [...data.subarray(3)];
+            }
+            else {
+                bufferState.buffer = bufferState.buffer.concat([...data]);
+            }
+            if (bufferState.buffer.length - transport.PROTOCOL_V1_MESSAGE_HEADER_SIZE >= bufferState.bufferLength) {
                 const completeBuffer = new Uint8Array(bufferState.buffer);
                 bufferState.bufferLength = 0;
                 bufferState.buffer = [];
@@ -654,7 +1560,12 @@ class ElectronBleTransport {
             return { isComplete: false, error: `Packet processing error: ${error}` };
         }
     }
+    getProtocolType(path) {
+        var _a;
+        return (_a = this.deviceProtocol.get(path)) !== null && _a !== void 0 ? _a : 'V1';
+    }
 }
 
+exports.ElectronAutoBleTransport = ElectronAutoBleTransport;
 exports.ElectronBleTransport = ElectronBleTransport;
 exports.WebUsbTransport = WebUsbTransport;